java原型模式

现在要获取一只相同的猫十只，传统模式是直接new 相同的对象new 十次，每次都要传参，总是需要重新初始化对象，而不是动态地获得对象运行时的状态, 不够灵活 。

现在用原型模式，继承cloneable接口，直接调用方法进行复制。

cat类
public class cat implements Cloneable{
private String name;
private int age;
public cat(String name, int age) {
	super();
	this.name = name;
	this.age = age;
}
@Override
	protected Object clone() throws CloneNotSupportedException {
		cat c=null;
		cat cat1 = (cat)super.clone();
		return cat1;
	}
@Override
public String toString() {
	return "cat [name=" + name + ", age=" + age + "]";
}

}
public class test {
	public static void main(String[] args) throws CloneNotSupportedException {
         cat  a=new cat("小猫",10);
          cat c1=(cat) a.clone();
          cat c2=(cat) a.clone();
          cat c3=(cat) a.clone();
          System.out.println(c1);
          System.out.println(c2);
          System.out.println(c3);
}
}

原型模式(Prototype 模式)是指：用原型实例指定创建对象的种类，并且通过拷贝这些原型，创建新的对象

原型模式是一种创建型设计模式，允许一个对象再创建另外一个可定制的对象，无需知道如何创建的细节

工作原理是:通过将一个原型对象传给那个要发动创建的对象，这个要发动创建的对象通过请求原型对象拷贝它

们自己来实施创建，即 对象.clone()

稍微注意一下，Cloneable接口是不包含任何方法的！其实这个接口仅仅是一个标志，而且这个标志也仅仅是针对 Object类中clone()方法的，如果clone类没有实现Cloneable接口，并调用了Object的clone()方法（也就是调用了 super.Clone()方法），那么Object的clone()方法就会抛出CloneNotSupportedException异常。 

Spring 中原型 bean 的创建，就是原型模式的应用

浅拷贝：

1) 对于数据类型是基本数据类型的成员变量，浅拷贝会直接进行值传递，也就是将该属性值复制一份给新的对象。

2) 对于数据类型是引用数据类型的成员变量，比如说成员变量是某个数组、某个类的对象等，那么浅拷贝会进行

引用传递，也就是只是将该成员变量的引用值（内存地址）复制一份给新的对象。因为实际上两个对象的该成

员变量都指向同一个实例。在这种情况下，在一个对象中修改该成员变量会影响到另一个对象的该成员变量值

3) 前面我们克隆猫就是浅拷贝

4) 浅拷贝是使用默认的 clone()方法来实现

c= (cat) super.clone();

引用数据类型都是来源于一个引用，其中一个副本变了，其他都要变。

深拷贝：

1) 复制对象的所有基本数据类型的成员变量值

2) 为所有引用数据类型的成员变量申请存储空间，并复制每个引用数据类型成员变量所引用的对象，直到该对象

可达的所有对象。也就是说，对象进行深拷贝要对整个对象(包括对象的引用类型)进行拷贝

浅拷贝是指拷贝对象时仅仅拷贝对象本身（包括对象中的基本变量），而不拷贝对象包含的引用指向的对象。深拷贝不仅拷贝对象本身，而且拷贝对象包含的引用指向的所有对象。举例来说更加清楚：对象A1中包含对B1的引用，B1中包含对C1的引用。浅拷贝A1得到A2，A2 中依然包含对B1的引用，B1中依然包含对C1的引用。深拷贝则是对浅拷贝的递归，深拷贝A1得到A2，A2中包含对B2（B1的copy）的引用，B2 中包含对C2（C1的copy）的引用。

浅拷贝代码：

public class cat implements Cloneable{
private String name;
private int age;
private dog friend;
public dog getFriend() {
	return friend;
}
public void setFriend(dog friend) {
	this.friend = friend;
}
public cat(String name, int age) {
	super();
	this.name = name;
	this.age = age;
}
@Override
	protected Object clone() throws CloneNotSupportedException {
		
		return super.clone();
		
	}
@Override
public String toString() {
	return "cat [name=" + name + ", age=" + age + "]";
}

}
狗类
public class dog implements Cloneable {
private String name;
private int age;
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;
}

}
test
public class test {
	public static void main(String[] args) throws CloneNotSupportedException {
         cat  a=new cat("小猫",10);
         dog d=new dog();
         d.setAge(20);
         d.setName("杰瑞");
         a.setFriend(d);
          cat c1=(cat) a.clone();
          cat c2=(cat) a.clone();
          cat c3=(cat) a.clone();
          System.out.println(c1+"friend"+c1.getFriend().hashCode());
          System.out.println(c2+"friend"+c2.getFriend().hashCode());
          System.out.println(c3+"friend"+c3.getFriend().hashCode());
}
}

如上，经过复制后hashcode都一样。

深拷贝：

dog类
public class dog implements Cloneable {
private String name;
private int age;
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;
}
@Override
public String toString() {
	return "dog [name=" + name + ", age=" + age + "]";
}
@Override
	protected Object clone() throws CloneNotSupportedException {
		Object o=null;
		o=super.clone();
		return o ;
	}
}
cat类
public class cat implements Cloneable{
private String name;
private int age;
private dog friend;

public dog getFriend() {
	return friend;
}
public void setFriend(dog friend) {
	this.friend = friend;
}
public cat(String name, int age) {
	super();
	this.name = name;
	this.age = age;
}
@Override
	protected Object clone() throws CloneNotSupportedException {
		cat c=null;
		c=(cat)super.clone();
		c.friend = (dog)friend.clone();
		return c;
		
	}
@Override
public String toString() {
	return "cat [name=" + name + ", age=" + age + "]";
}

}
test类
public class test {
	public static void main(String[] args) throws CloneNotSupportedException {
         cat  a=new cat("小猫",10);
         dog d=new dog();
         d.setAge(20);
         d.setName("杰瑞");
         a.setFriend(d);
          cat c1=(cat) a.clone();
          cat c2=(cat) a.clone();
          cat c3=(cat) a.clone();
          System.out.println(c1+"friend"+c1.getFriend().hashCode());
          System.out.println(c2+"friend"+c2.getFriend().hashCode());
          System.out.println(c3+"friend"+c3.getFriend().hashCode());
}
}

得出hashcode不同

还有一种序列化的方法进行深拷贝。

cat类
public class cat implements Serializable {
	private static final long serialVersionUID = 1L;
	private String name;
	private int age;
	private dog dog;
	public cat(String name, int age, deepcopy.dog dog) {
		super();
		this.name = name;
		this.age = age;
		this.dog = dog;
	}
	
	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 dog getDog() {
		return dog;
	}

	public void setDog(dog dog) {
		this.dog = dog;
	}

	public Object deepcopy() throws IOException, ClassNotFoundException {
		//将对象写到流里
		ByteArrayOutputStream bo=new ByteArrayOutputStream();
		ObjectOutputStream oo=new ObjectOutputStream(bo);
		oo.writeObject(this);
		ByteArrayInputStream bi=new ByteArrayInputStream(bo.toByteArray());
		ObjectInputStream oi=new ObjectInputStream(bi);
		
		
		return oi.readObject();
		
	}
}
dog类
public class dog implements Serializable{
	private static final long serialVersionUID = 1L;
private String name;
private int age;
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;
}

}
test
public class test {
public static void main(String[] args) throws ClassNotFoundException, IOException {
	dog d=new dog();
	d.setAge(22);
	d.setName("Jerry");
	cat c=new cat("tom",20, d);
	cat c1 = (cat)c.deepcopy();
	dog dog = c1.getDog();
	System.out.println(dog==d);//false
}
}

要想序列化对象，必须先创建一个OutputStream，然后把它嵌入ObjectOutputStream。这时就能用writeObject()方法把对象写入OutputStream。读的时候需要把InputStream嵌到ObjectInputStream中，然后再调用readObject()方法。不过这样读出来的只是一个Object的reference，因此，在用之前，还要下转型。