克隆，就是复制一个对象的副本，而克隆又分浅克隆和深克隆。浅克隆是指克隆得到的对象基本类型的值改变了，而源对象的值不会变。但如果被克隆对象引用类型的值改变了，那么源对象的值同样会改变，因为引用类型在栈内存中存放的是一个引用地址，被克隆对象后也和源对象的引用地址一样，都是指向同样的内存空间的值。所以在克隆时，任何一个对象的值的改变都会令另外的值改变，所以这种情况下要用深克隆。                                         

要注意的是要克隆的对象的泪必须继承cloneable接口，而该接口不提供任何抽象非抽象方法，所以又可以把它看做是克隆的标志性东西。浅克隆的特点是只克隆该对象本体，它的优缺点就是一改皆改；深克隆的特点是新建对象，与源对象互不干扰，而它的优缺点也是互不干扰和麻烦。通常情况下我们使用克隆的时候都只使用浅克隆。                              

对克隆可以简单的理解为：当克隆一个对象时，把属性的值和方法都一起拷贝的是浅拷贝，而方法的值可以设置不同的是深克隆。深克隆要进行反序例化，先把内容输出到内存，再从内存读取。

 

       代码示例：

 

 

 

package clone;

import java.io.ByteArrayInputStream;

import java.io.ByteArrayOutputStream;

import java.io.IOException;

import java.io.ObjectInputStream;

import java.io.ObjectOutputStream;

import java.io.Serializable;

 

public class BasketballStar implements Cloneable,Serializable{

       private String name;

       private int age;

       private float height;

       private Skill mySkill;

       public String getName() {

              return name;

       }

       public void setName(String name) {

              this.name = name;

       }

       public int getAge() {

              return age;

       }

       public void setAge(int age) {

              this.age = age;

       }

       public float getHeight() {

              return height;

       }

public void setHeight(float height) {

              this.height = height;

       }

       public Skill getMySkill() {

              return mySkill;

       }

       public void setMySkill(Skill mySkill) {

              this.mySkill = mySkill;

       }

       //浅克隆

       public Object clone() throws CloneNotSupportedException {

              BasketballStar bs2 = (BasketballStar)super.clone();

              bs2.setMySkill((Skill)this.mySkill.clone());

              return bs2;

       }    

       public BasketballStar deepClone(){  //深克隆

              ByteArrayOutputStream bos = null;

              ObjectOutputStream oos = null;

              ByteArrayInputStream bis = null;

              ObjectInputStream ois = null;      

              try {

                     bos = new ByteArrayOutputStream();

                     oos = new ObjectOutputStream(bos);

                     oos.writeObject(this);

                     bis = new ByteArrayInputStream(bos.toByteArray());

                     ois = new ObjectInputStream(bis);

                     return (BasketballStar)ois.readObject();

              } catch (IOException e) {

                     e.printStackTrace();

              } catch (ClassNotFoundException e) {

                     e.printStackTrace();

              }finally{

                     try {

                            bis.close();

                            ois.close();

                            bos.close();

                            oos.close();

                     } catch (IOException e) {

                            e.printStackTrace();

                     }

              }

              return null;

       }

       }

 

 

 

package clone;

import java.io.Serializable;

 

public class Skill implements Cloneable,Serializable{

       private int shooting;

       private int jumping;      

       private int strength;

       public int getShooting() {

              return shooting;

       }

       public void setShooting(int shooting) {

              this.shooting = shooting;

       }

       public int getJumping() {

              return jumping;

       }

       public void setJumping(int jumping) {

              this.jumping = jumping;

       }

       public int getStrength() {

              return strength;

       }

       public void setStrength(int strength) {

              this.strength = strength;

       }

       protected Object clone() throws CloneNotSupportedException {

              return super.clone();

       }

}

 

 

 

 

 

package clone;

 

public class MyClone {

       public static void main(String[] args) {

              BasketballStar bs1 = new BasketballStar();

              bs1.setName("YM");

              bs1.setAge(30);

              bs1.setHeight( 2.26f);

              Skill theSkill = new Skill();

              theSkill.setShooting(95);

              theSkill.setJumping(50);

              theSkill.setStrength(60);

              bs1.setMySkill(theSkill);

              // try {

              // BasketballStar bs2 = (BasketballStar)bs1.clone();

              // bs2.setName("YN2");

              // bs2.setAge(22);

              // bs2.getMySkill().setJumping(90);

              // bs2.getMySkill().setStrength(108);

              //                  

              // System.out.println(bs1.getMySkill() == bs2.getMySkill());

              // System.out.println(bs1.getName() + " " + bs1.getAge());

              // System.out.println(bs1.getMySkill().getStrength() + " " +

              // bs1.getMySkill().getJumping());

              // } catch (CloneNotSupportedException e) {

              // e.printStackTrace();

              // }

              BasketballStar bs2 = bs1.deepClone();

              System.out.println(bs1.getMySkill() == bs2.getMySkill());

              System.out.println(bs2.getName() + "  " + bs2.getAge());

              System.out.println(bs2.getMySkill().getStrength() + " "

                            + bs2.getMySkill().getJumping());

       }

}