设计模式（三）--- 原型模式

1、克隆羊

1. 传统方式

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;
	}
	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 String getColor() {
		return color;
	}
	public void setColor(String color) {
		this.color = color;
	}
	@Override
	public String toString() {
		return "Sheep [name=" + name + ", age=" + age + ", color=" + color + "]";
	}
}

public class Client {	
	public static void main(String[] args) {
		
		Sheep sheep = new Sheep("tom",1,"白色");
		
		Sheep sheep2 = new Sheep("tom",1,"白色");	
	}
}

传统方式优缺点
1.优点是比较好理解，简单易操作。
2.在创建新的对象时，总是需要重新获取原始对象的属性，如果创建的对象比较复杂
时，效率较低
3.总是需要重新初始化对象，而不是动态地获得对象运行时的状态，不够灵活
4.改进的思路分析
思路: Java中Object类 是所有类的根类，Object类提供 了一个clone()方法， 该方法可以
将一个Java对象复制一份，但是需要实现clone的Java类必须要实现一个接OCloneable,
该接口表示该类能够复制且具有复制的能力=> 原型模式

原型模式基本介绍
1.原型模式(Prototype模式)是指: 用原型实例指定创建对象的种类，并且通过拷
贝这些原型，创建新的对象
2.原型模式是一种创建型设计模式，允许一个对象再创建另外-一个可定制的对象，
无需知道如何创建的细节
3.工作原理是:通过将-一个 原型对象传给那个要发动创建的对象，这个要发动创建
的对象通过请求原型对象拷贝它们自己来实施创建，即对象.clone()
4.形象的理解:孙大圣拔出猴毛，变出其它孙大圣

sheep.java加入以下代码

	//克隆该实例，使用默认的clone方法来完成
	@Override
	protected Object clone() {
		// TODO Auto-generated method stub
		
		Sheep sheep = null;
		
		try {
			sheep = (Sheep) super.clone();
			
		} catch (Exception e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}		
		return sheep;
	}

client.java产生对象代码

		Sheep sheep = new Sheep("tom",1,"白色");		
		Sheep sheep2 = (Sheep) sheep.clone();		

2、浅拷贝

浅拷贝的介绍：

1.对于数据类型是基本数据类型的成员变量，浅拷贝会直接进行值传递，也就是将
该属性值复制一份给 新的对象。
2.对于数据类型是引用数据类型的成员变量，比如说成员变量是某个数组、某个类
的对象等，那么浅拷贝会进行引用传递，也就是只是将该成员变量的引用值(内
存地址)复制- -份给新的对象。因为实际上两个对象的该成员变量都指向同一个
实例。在这种情况下，在一个对象中修改该成员变量会影响到另-一个对象的该成
员变量值
3).前面我们克隆羊就是浅拷贝
4.浅拷贝是使用默认的clone()方法来实现
sheep = (Sheep) super.clone();

前面提的克隆羊就是浅拷贝

3、深拷贝

深拷贝基本介绍：

1.复制对象的所有基本数据类型的成员变量值
2.为所有 引用数据类型的成员变量申请存储空间，并复制每个引用数据类型成员变
量所引用的对象，直到该对象可达的所有对象。也就是说，对象进行深拷贝要对
整个对象进行拷贝，
3.深拷贝实现方式1:重写clone方法来实现深拷贝
4.深拷贝实现方式2:通过对象序列化实现深拷贝

3.1、使用clone方法

DeepCloneableTarget.java

package 原型模式;

import java.io.Serializable;

public class DeepCloneableTarget implements Serializable,Cloneable{
	
	private static final long serialVersionUID = 1L;	
	private String cloneName;	
	private String cloneClass;	
	public DeepCloneableTarget(String cloneName,String cloneClass) {
		this.cloneName = cloneName;
		this.cloneClass = cloneClass;
	}
	
	@Override
	protected Object clone() throws CloneNotSupportedException {
		// TODO Auto-generated method stub
		return super.clone();
	}
}

package 原型模式;
import java.io.Serializable;
public class DeepProtoType  implements Serializable,Cloneable{
	public String naem;
	public DeepCloneableTarget deepCloneableTarget;
	public DeepProtoType() {
		super();
	}
	
	@Override
	protected Object clone() throws CloneNotSupportedException {
		// TODO Auto-generated method stub
		
		Object deep = null;
		deep = super.clone();
		DeepProtoType deepProtoType = (DeepProtoType) deep;
		
		deepProtoType.deepCloneableTarget = (DeepCloneableTarget) deepCloneableTarget.clone();
		return deepProtoType;
	}
}

3.2、通过对象的序列化实现（推荐）

	public Object 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);
			DeepProtoType copyObj = (DeepProtoType) ois.readObject();			
			return copyObj;
			
		} catch (Exception e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
			return null;
		} finally {			
			try {
				
				bos.close();
				oos.close();
				bis.close();
				ois.close();
				
			} catch (IOException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}			
		}
	}