对象的克隆

对象的克隆

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

     对象浅克隆要注意的细节：

        1.如果一个对象需要调用clone的方法克隆，那么该对象所属的类必须要实现Cloneable接口。

        2.Cloneable接口只不过是一个标识接口而已，没有任何方法。 

        3.对象的浅克隆就是克隆一个对象的时候，如果被克隆的对象中维护了另外一个类的对象，这时候只是克隆另外一个对象的地址，而没有把另外一个对象克隆一份。

        4.对象的浅克隆也不会调用到构造方法。

    对象的深克隆：对象的深克隆就是利用对象的输入输出流把对象先写到文件上，然后再读取对象的信息这个过程就称作为对象的深克隆。

①对象的浅克隆demo：

package com.cn.clone;
/**
* Author：Liu Zhiyong（QQ：1012421396）
* Version：Version_1
* Date：2016年8月19日17:26:05
* Desc：
对象的克隆
	对象的浅克隆：浅复制(浅克隆)被复制对象的所有变量都含有与原来对象相同的值，而所有的对其他对象的引用仍然只指向原来的对象，换言之，浅复制仅仅复制锁考虑的对象，而不复制它所引用的对象。
	对象浅克隆要注意的细节：
		1.如果一个对象需要调用clone的方法克隆，那么该对象所属的类必须要实现Cloneable接口。
		2.Cloneable接口只不过是一个标识接口而已，没有任何方法。 
		3.对象的浅克隆就是克隆一个对象的时候，如果被克隆的对象中维护了另外一个类的对象，这时候只是克隆另外一个对象的地址，而没有把另外一个对象克隆一份。
		4.对象的浅克隆也不会调用到构造方法。
*/
public class Demo1 {
	public static void main(String[] args) throws CloneNotSupportedException {
		Address address = new Address("香港");
		Person p1 = new Person(110, "木先森", address);
		Person p2 = p1; //这属于对象的地址引用
		
		/*System.out.println("p1和p2是同一个对象吗：" + (p1==p2));
		p2.address.city = "黄冈";
		System.out.println("p1" + p1);
		System.out.println("p2" + p2);
		System.out.println("============================================");*/
		
		Person p3 = (Person)p1.clone();//克隆了一个对象
		p3.name = "哈哈";
		p3.address.city = "澳门";
		System.out.println(p1);
		System.out.println(p3);
		System.out.println("p1和p3是同一个对象吗：" + (p1==p3));
		
	}
}

package com.cn.clone;
import java.io.Serializable;
class Address implements Serializable{
	String city;
	public Address(String city) {
		super();
		this.city = city;
	}
	
	@Override
	public String toString() {
		// TODO Auto-generated method stub
		return this.city;
	}
}
public class Person implements Cloneable, Serializable{
	int id;
	String name;
	Address address;
	
	public Person(int id, String name, Address address) {
		super();
		this.id = id;
		this.name = name;
		this.address = address;
		System.out.println("构造方法调用了");
	}
	@Override
	public String toString() {
		return "编号：" + this.id + "\t姓名：" + this.name + "\t地址：" + this.address;
	}
	
	@Override
	public Object clone() throws CloneNotSupportedException {
		// TODO Auto-generated method stub
		return super.clone();
	}
}

对象的浅克隆demo结果：

 对象的浅克隆demo分析：

 ②对象的深克隆demo：

package com.cn.clone;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.OutputStream;
/**
* Author：Liu Zhiyong（QQ：1012421396）
* Version：Version_1
* Date：2016年8月25日18:09:40
* Desc：
对象的深克隆：对象的深克隆就是利用对象的输入输出流把对象先写到文件上，然后再读取对象的信息这个过程就称作为对象的深克隆。
*/
public class Demo2 {
	public static void main(String[] args) throws FileNotFoundException, IOException, ClassNotFoundException {
		Address address = new Address("香港");
		Person p1 = new Person(110, "木先森", address);
		System.out.println(p1);
		//把对象写到文件上去
		writeObj(p1);
		//读取文件上的文件
		Person p2 = readObj();
		p2.address.city =  "黄冈";
		System.out.println(p2);
	}
	
	//先要把对象写到文件上
	public static void writeObj(Person p) throws FileNotFoundException, IOException{
		ObjectOutputStream objectOutputStream = new ObjectOutputStream(new FileOutputStream(new File("f:/obj.txt")));
		objectOutputStream.writeObject(p);
		//关闭资源
		objectOutputStream.close();
	}
	
	//再从文件中读取信息
	public static Person readObj() throws FileNotFoundException, IOException, ClassNotFoundException{
		ObjectInputStream objectInputStream = new ObjectInputStream(new FileInputStream(new File("f:/obj.txt")));
		return (Person)objectInputStream.readObject();
	}
}

对象的深克隆demo结果：