对象的拷贝

对象的拷贝又被成为对象的克隆。对象的拷贝分为两种：浅拷贝和深拷贝。

浅拷贝

浅复制(浅克隆)被复制对象的所有变量都含有与原来对象相同的值，而所有的对其他对象的引用仍然只指向原来的对象，换言之，浅复制仅仅复制锁考虑的对象，而不复制它所引用的对象。

对象的浅拷贝是通过调用clone方法来实现的。

浅拷贝需要注意的细节：

1. 如果一个对象需要调用clone的方法克隆，那么该对象所属的类必须要实现Cloneable接口。
2. Cloneable接口只不过是一个标识接口而已，没有任何方法。
3. 对象的浅克隆也不会调用到构造方法的。

代码示例：

//实体类代码
class Address{
    
    String city;
        
    public Address(String city){
        this.city = city;
    }
    
}

public class Person implements Cloneable{
    int id;
    
    String name;
    
    Address address;

    public Person(int id, String name) {
        this.id = id;
        this.name = name;
    }
    public Person(int id, String name, Address address) {
        this.id = id;
        this.name = name;
        this.address = address;
        System.out.println("=======构造方法调用了===");
    }
    @Override
    public String toString() {
        return "编号："+ this.id+" 姓名："+ this.name+" 地址："+ address.city;
    }
    @Override
    public Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
}
//测试类代码
public class DemoCopy {
    public static void main(String[] args) throws CloneNotSupportedException {
        Person p1 = new Person(110, "Nick",new Address("济南"));
        Person p2 = (Person)p1.clone();
        p2.address.city = "北京";
        System.out.println("p1的内容："+p1);
        System.out.println("p2的内容："+p2);
    }
}

深拷贝

深复制(深克隆)被复制对象的所有变量都含有与原来的对象相同的值，除去那些引用其他对象的变量，那些引用其他对象的变量将指向被复制过的新对象，而不再试原有的那些被引用的对象，换言之，深复制把要复制的对象所引用的对象都复制了一遍。

把对象写到流里的过程是串行化（Serilization）过程，但是在Java程序师圈子里又非常形象地称为“冷冻”或者“腌咸菜（picking）”过程；而把对象从流中读出来的并行化（Deserialization）过程则叫做“解冻”或者“回鲜(depicking)”过程。应当指出的是，写在流里的是对象的一个拷贝，而原对象仍然存在于JVM里面，因此“腌成咸菜”的只是对象的一个拷贝，Java咸菜还可以回鲜。

在Java语言里深复制一个对象，常常可以先使对象实现Serializable接口，然后把对象（实际上只是对象的一个拷贝）写到一个流里（腌成咸菜），再从流里读出来（把咸菜回鲜），便可以重建对象。

对象的深拷贝是通过对象输入（ObjectInputStream）输出（ObjectOutputStream）流来实现的。

示例代码如下：

//实体类代码
class Address implements Serializable{
    
    String city;
        
    public Address(String city){
        this.city = city;
    }
    
}

public class Person implements Serializable{
    int id;
    
    String name;
    
    Address address;

    public Person(int id, String name) {
        this.id = id;
        this.name = name;
    }
    public Person(int id, String name, Address address) {
        this.id = id;
        this.name = name;
        this.address = address;
        System.out.println("=======构造方法调用了===");
    }
    @Override
    public String toString() {
        return "编号："+ this.id+" 姓名："+ this.name+" 地址："+ address.city;
    }
    
}
//测试代码
public class Demo2 {

    public static void main(String[] args) throws IOException, ClassNotFoundException {
        Address address = new Address("广州");
        Person p1 = new Person(110,"狗娃",address);
        writeObj(p1);
        Person p2  =readObj();
        
        p2.address.city = "长沙";
        System.out.println("p1:"+ p1);
        System.out.println("p2:"+ p2);
        
        
    }
    
    
    //再从文件中读取对象的信息
    public static Person readObj() throws ClassNotFoundException, IOException{
        FileInputStream fileInputStream = new FileInputStream("F:\obj.txt");
        //创建对象的输入流对象
        ObjectInputStream objectInputStream = new ObjectInputStream(fileInputStream);
        return (Person) objectInputStream.readObject();
    }
    
    
    //先要把对象写到文件上。
    public static void writeObj(Person p) throws IOException{
        //建立一个文件 的输出流对象
        FileOutputStream fileOutputStream  = new FileOutputStream("F:\obj.txt");
        //建立对象的输出流
        ObjectOutputStream objectOutputStream = new ObjectOutputStream(fileOutputStream);
        //把对象写出
        objectOutputStream.writeObject(p);
        //关闭资源
        objectOutputStream.close();
        
    }
}