深拷贝与浅拷贝

浅拷贝：将一个对象复制后，基本数据类型的变量都会重新创建，而引用类型，指向的还是原对象所指向的。

深拷贝：将一个对象复制后，不论是基本数据类型还是引用类型，都是重新创建的。简单来说，就是深拷贝进行了完全彻底地复制，而浅复制不彻底。

要实现深复制，需要采用流的形式读入当前对象的二进制输入，再写出二进制数据对应的对象。

1.克隆羊问题
(1) 问题
一只羊，姓名为Tom，年龄为1，颜色为白色。现在需要创建10只羊，他们的属性和Tom的属性完全相同。

(2) 传统方法实现

/** 羊类 **/
public class Sheep{
	private String name;
	private int age;
	private String color;

	public Sheep(String name, int age, String color){
		super();
		this.name = name;
		this.age = age;
		this.color = color;
	}

	setter & getters
}

/** 创建羊 **/
public class Client(){
	psvm() {
		Sheep tom = new Sheep("Tom",1,"白色");
		
		Sheep sheep2 = new Sheep(tom.getName(), tom.getAge(), tom.getColor());
		Sheep sheep3 = new Sheep(tom.getName(), tom.getAge(), tom.getColor());
		
		...10次
	}
}

(3) 优缺点
优点：简单好理解
缺点：在创建新的对象时，总是需要重新获取原始对象的属性(tom.getXX())，如果创建的对象比较复杂时，效率较低。
总是需要重新初始化对象，而不是动态获取的对象运行时的状态，不够灵活。
(4) 解决方案
Java中Object类是所有类的根类，Object类提供了一个clone()方法，该方法可以将一个Java对象复制一份。
但是需要实现clone的Java类必须要实现一个接口Cloneable，该接口表示该类能够复制且具有复制的能力。

2.原型模式(Prototype)
(1) 基本介绍
用原型实例指定创建对象的种类，并且通过拷贝这些原型，创建新的对象。
原型模式是一种创建型设计模式，允许一个对象在创建另一个可定制的对象，无需知道如何创建的细节。
通过一个原型对象传给那个要发动创建的对象，这个要发动创建的对象通过请求原型对象拷贝他们自己来实施创建。即对象.clone()
原理：

(2) 用原型模式实现克隆羊

/** 羊类 **/
public class Sheep implements Cloneable{
	private String name;
	private int age;
	private String color;

	public Sheep(String name, int age, String color){
		super();
		this.name = name;
		this.age = age;
		this.color = color;
	}

	// 克隆该实例
	@override
	protected Object clone() throws CloneNotSupportedException{
		Sheep sheep = null;
		sheep = (Sheep)super.clone();	// 使用默认的clone方法完成
		return sheep ;
	}

	setter & getters
}

/** 创建羊 **/
public class Client(){
	psvm() {
		Sheep tom = new Sheep("Tom",1,"白色");
		Sheep sheep2 = (Sheep)tom.clone();
		Sheep sheep3 = (Sheep)tom.clone();
	}
}

(3) 优缺点
优点：这样如果羊新增一个属性，比如地区，只需要改动羊类的属性和Tom的实例创建代码即可。
缺点：浅拷贝
如果羊Sheep对象中有一个属性：private Sheep friend; 使用默认的clone()这个拷贝前后这个属性指向同一实例对象。

3.浅拷贝和深拷贝
(1) 浅拷贝
对于数据类型是基本数据类型的成员变量，浅拷贝会直接进行值传递，也就是将该属性值复制一份给新的对象。
对于数据类型是引用数据类型的成员变量，比如说成员变量是某个数组、某个类的对象等，浅拷贝会进行引用传递：只是将该成员变量的引用值(内存地址)复制一份给新的对象。因为实际上两个对象的该成员变量都指向同一个实例。在拷贝前的对象中修改成员变量，会影响到拷贝后的对象中的该成员变量的值。
默认的clone()方法是浅拷贝：sheep = (Sheep)super.clone();

(2) 深拷贝
复制对象的所有基本数据类型的成员变量值。
为所有引用数据类型的成员变量申请存储空间，并复制每个引用数据类型成员变量所引用的对象。
实现方式：重写clone()方法、通过对象序列化。

4.深拷贝方式1-重写clone()

/** 鼠标类 **/
public class Mouse implements Cloneable{
	// 鼠标名称（罗技、苹果）
	private String name;
	// 接口类型（usb、type-c）
	private String usbType;

	public Mouse(String name, String usbType){
		this.name = name;
		this.usbType = usbType;
	}

	// 因为鼠标类中的属性都是基本数据类型，所以使用默认的clone()方法即可。
	@Override
	protected Object clone(){
		return super clone();
	}
}

/** 计算机类 **/
public class Computer implements Cloneable{
	// 电脑名称（Macbook、联想）
	public String name;
	// 鼠标，引用类型
	public Mouse mouse;

	public Computer(){
	}

	// 深拷贝实现方式1：重写clone()
	@Override
	protected Object clone(){
		Object deep = null;
		// 先使用默认的clone(), 完成对Computre类中的基本数据类型的拷贝
		deep  = super.clone();

		// 对Computer类中的引用数据类型进行处理
		Computer computer = (Computer)deep;
		computer.mouse = (Mouse)mouse.clone();
		
		return computer;
	}
}

5.深拷贝方式2-序列化（推荐使用）

/** 鼠标类 **/
public class Mouse implements Serializable{
	// 鼠标名称（罗技、苹果）
	private String name;
	// 接口类型（usb、type-c）
	private String usbType;
}

/** 计算机类 **/
public class Computer implements Serializable{
	// 电脑名称（Macbook、联想）
	public String name;
	// 鼠标
	public Mouse mouse;

	public Computer(){
	}

	// 深拷贝实现方式2：序列化
	public Object deepClone(){
		// 创建流对象
		ByteArrayOutputStream byteOut = null;
		ObjectOutputStream objectOut = null;
		ByteArrayInputStream byteIn = null;
		ObjectInputStream objectIn = null;
		
		// 序列化
		byteOut = new ByteArrayOutputStream();
		objectOut = new ObjectOutputStream(byteOut);
		objectOut.write(this);	// 把当前这个对象以对象流的方式输出
		
		// 反列化
		byteIn = new ByteArrayInputStream(objectOut.toByteArray());
		objectIn = new ObjectInputStream(byteIn);
		Computer com = (Computer)objectIn.readObjct();
		
		// 流关闭,这里应放在finally中
		byteOut.close();
		objectOut.close();
		byteIn.close();
		objectIn.close();
		
		return com;
	}
}

6.原型模式的注意事项
创建新的对象比较复杂时，可以利用原型模式简化对象的创建过程，同时也能提高效率。
不用重新初始化对象，而是动态的获得对象运行时的状态。
如果原始对象发生变化，如增加了2个属性，则就不需要修改其他创建对象时的代码，其他克隆对象就会发生相应的变化。
在实现深克隆的时候，可能需要比较复杂的代码。
对已有的类要它支持克隆时，要修改该类的代码，违背了ocp原则。