Java进阶

如果你想复制一个简单变量。很简单：

int x = 7;  
int y = x;

不仅仅是int类型，其它七种原始数据类型(boolean,char,byte,short,float,double.long)同样适用于该类情况。

但是如果你复制的是一个对象，情况就有些复杂了。

当我说我是一个beginner的时候，我会这样写：

class Car{

    private String color;
    private String name;

    Car(String color, String name) {
        this.color = color;
        this.name = name;
    }

    public String getColor() {
        return color;
    }

    public void setColor(String color) {
        this.color = color;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "Car [color=" + color + ", name=" + name + "]";
    }
}

public class Test{

    public static void main(String[] args) throws Exception {

        Car car = new Car("白色", "奔驰");
        Car cloneCar = car;

        System.out.println("car = " + car);
        System.out.println("cloneCar = " + cloneCar);
    }
}

结果：

car = Car [color=白色, name=奔驰]

cloneCar = Car [color=白色, name=奔驰]

这里我们自定义了一个Car类，该类有color和name字段。

我们新建了一个Car实例，然后将该值赋值给cloneCar实例。(Car cloneCar = car;)

再看看打印结果，作为一个新手，拍了拍胸腹，对象复制不过如此！

难道真的是这样吗？我们试着改变cloneCar实例的name字段，再打印结果看看：

cloneCar.setName("大众");
System.out.println("car = " + car);
System.out.println("cloneCar = " + cloneCar);

结果：

car = Car [color=白色, name=大众]

cloneCar = Car [color=白色, name=大众]

为什么改变cloneCar属性，car属性也发生了变化呢？

原因出在(cloneCar = car) 这一句。该语句的作用是将car的引用赋值给cloneCar，这样，car和cloneCar指向内存堆中同一个对象。

那么才能复制一个对象呢？

这就要用到我们的Object类了。它有11个方法，有两个protected的方法，其中一个为clone方法。

在Java中所有的类都是缺省的继承自Java语言包中的Object类的，查看它的源码。你会发现里面有一个访问限定符为protected的方法clone()：

/* 
   Creates and returns a copy of this object. The precise meaning of "copy" may depend on the class of the object.
   The general intent is that, for any object x, the expression:
   1) x.clone() != x will be true
      保证克隆对象将有单独的内存地址分配。
   2) x.clone().getClass() == x.getClass() will be true, but these are not absolute requirements.
      原始和克隆的对象应该具有相同的类类型，但它不是强制性的。
   3) x.clone().equals(x) will be true, this is not an absolute requirement. 
　　   原始和克隆的对象应该是平等的equals()方法使用，但它不是强制性的。
*/
protected native Object clone() throws CloneNotSupportedException;

仔细一看，它还是一个native方法，大家都知道native方法是非Java语言实现的代码，供Java程序调用的，因为Java程序是运行在JVM虚拟机上面的，要想访问到比较底层的与操作系统相关的就没办法了，只能由靠近操作系统的语言来实现。

因为每个类直接或间接的父类都是Object，因此它们都含有clone()方法，但是因为该方法是protected，所以都不能在类外进行访问。

要想对一个对象进行复制，就需要对clone方法覆盖。

一、为什么要克隆？

为什么需要克隆对象？直接new一个对象不行吗？

答案是：克隆的对象可能包含一些已经修改过的属性，而new出来的对象的属性都还是初始化时候的值，所以当需要一个新的对象来保存当前对象的“状态”就靠clone方法了。

那么我把这个对象的临时属性一个一个的赋值给我新new的对象不也行嘛？可以是可以，但是一来麻烦不说，二来，大家通过上面的源码都发现了clone 是一个 native 方法，就是快啊，在底层实现的。

常见的 Object a = new Object()；Object b = a；这种形式的代码复制的是引用，即对象在内存中的地址，a和b对象仍然指向了同一个对象。

而通过clone方法赋值的对象跟原来的对象时同时独立存在的。

二、如何实现克隆

Java中有两种不同的克隆方法：浅克隆(ShallowClone)和深克隆(DeepClone)

（1）浅克隆：实现Cloneable接口并重写Object类中的clone()方法；

（2）深克隆：实现Serializable接口，通过对象的序列化和反序列化实现克隆；

Java语言提供的Cloneable接口和Serializable接口的代码非常简单，它们都是空接口，这种空接口也称为标识接口，标识接口中没有任何方法的定义，其作用是告诉JRE这些接口的实现类是否具有某个功能，如是否支持克隆、是否支持序列化等。

- 注意：基于序列化和反序列化实现的克隆不仅仅是深度克隆，更重要的是通过泛型限定，可以检查出要克隆的对象是否支持序列化，这项检查是编译器完成的，不是在运行时抛出异常，这种是方案明显优于使用Object类的clone方法克隆对象。让问题在编译的时候暴露出来总是优于把问题留到运行时。

三、浅克隆

Car类：

class Car implements Cloneable {
    private String color;
    private String name;

    Car() {
        super();
    }

    Car(String color, String name) {
        this.color = color;
        this.name = name;
    }

    public String getColor() {
        return color;
    }

    public void setColor(String color) {
        this.color = color;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "Car [color=" + color + ", name=" + name + "]";
    }
}

Persion类：实现Cloneable接口，需要重写clone方法。

class Persion implements Cloneable {

    private int age;
    private String name;
    private Car car;

    public Persion() {
        super();
    }

    public Persion(int age, String name, Car car) {
        super();
        this.age = age;
        this.name = name;
        this.car = car;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Car getCar() {
        return car;
    }

    public void setCar(Car car) {
        this.car = car;
    }

    @Override
    public String toString() {
        return "Persion [age=" + age + ", name=" + name + ", car=" + car + "]";
    }

    /**
     *     实现Cloneable接口，并重写clone方法
     */
    @Override
    protected Object clone() throws CloneNotSupportedException {
        Persion persion = null;
        try {
            /**
             *     若要实现深克隆，此处就必须将对象中所有的复合数据类型统统单独复制拷贝一份， 但是实际开发中，无法确定对象中复合数据的种类和个数，
             *     因此一般不采用此种方式实现深克隆
             */
            persion = (Persion) super.clone();
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }
        return persion;
    }
}

测试类：

public class Test {

    public static void main(String[] args) throws Exception {

        Car car = new Car("白色", "奔驰");
        Persion p1 = new Persion(24, "阿大", car);

        Persion p2 = (Persion) p1.clone();
        p2.setAge(17);
        p2.setName("小黄");
        p2.getCar().setName("大众");

        System.out.println("p1 == p2 ? " + (p1 == p2));
        System.out.println(p1);
        System.out.println(p2);
    }
}

结果：小黄将阿大的奔驰变成大众。

修改基础数据结构数值不会影响其他对象，修改复合数据数值，全部都会受影响；

四、深克隆

Car类：必须实现Serializable接口

class Car implements Serializable {
    private static final long serialVersionUID = -6593855835779505248L;

    private String color;
    private String name;

    Car() {
        super();
    }

    Car(String color, String name) {
        this.color = color;
        this.name = name;
    }

    public String getColor() {
        return color;
    }

    public void setColor(String color) {
        this.color = color;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "Car [color=" + color + ", name=" + name + "]";
    }
}

Persion类：必须实现Serializable接口

class Persion implements Serializable {

    private static final long serialVersionUID = -630014110607564384L;

    private int age;
    private String name;
    private Car car;

    public Persion() {
        super();
    }

    public Persion(int age, String name, Car car) {
        super();
        this.age = age;
        this.name = name;
        this.car = car;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Car getCar() {
        return car;
    }

    public void setCar(Car car) {
        this.car = car;
    }

    @Override
    public String toString() {
        return "Persion [age=" + age + ", name=" + name + ", car=" + car + "]";
    }

}

CloneUtil - 克隆工具类：

class CloneUtil {

    @SuppressWarnings("unchecked")
    public static <T extends Serializable> T clone(T object) throws Exception {
        ByteArrayOutputStream bout = new ByteArrayOutputStream();
        ObjectOutputStream oos = new ObjectOutputStream(bout);
        oos.writeObject(object);

        ByteArrayInputStream bin = new ByteArrayInputStream(bout.toByteArray());
        ObjectInputStream ois = new ObjectInputStream(bin);
        // 此处不需要释放资源，说明：调用ByteArrayInputStream或ByteArrayOutputStream对象的close方法没有任何意义
        // 这两个基于内存的流只要垃圾回收器清理对象就能够释放资源，这一点不同于对外部资源（如文件流）的释放
        return (T) ois.readObject();
    }
}

测试：

public class Test{

    public static void main(String[] args) throws Exception {

        Car car = new Car("白色", "奔驰");
        Persion p1 = new Persion(24, "阿大", car);

        Persion p2 = CloneUtil.clone(p1);
        p2.setAge(17);
        p2.setName("小黄");
        p2.getCar().setName("大众");

        System.out.println("p1 == p2 ? " + (p1 == p2));
        System.out.println(p1);
        System.out.println(p2);
    }
}

结果：奔驰还是奔驰，大众还是大众。

由输出结果来看，p2对象的car值修改不影响p1对象的car值，即使用序列化可以实现对象的深拷贝。