java原型模式

原型模式的定义

原型模式属于对象的创建模式。通过给出一个原型对象【某个类型的实例对象】来指明所有创建的对象的类型，然后用复制这个原型对象的办法创建出更多同类型的对象。这就是原型模式的用意。

定义→简而言之

就是复制某个实例对象的方式。

原型模式的实现

实现Cloneable接口进行浅拷贝

概述

浅拷贝就是通过实现Cloneacle接口然后重写父类的clone方法

具体过程

A包下的sheep 类

package yuanxing2;


public class Sheep implements Cloneable{
//	声明变量
	private String name;
	private int age;
	private String color;
	private String address="来自新疆";
	public Sheep friendSheep;
//	构造方法，实例化同时会执行构造方法
	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;
	}
//	打印值的方法
	
	@SuppressWarnings("unused")
	@Override
//	重写clone方法
	protected Object clone() throws CloneNotSupportedException {
		// TODO Auto-generated method stub
//		声明变量
		Sheep sheep =null;
		try {
//			克隆自身,由于这个重写的clone方法最后是Object类的方法，返回值也为Object所以需要类型转换
			sheep=(Sheep)super.clone();
		} catch (Exception e) {
			// TODO: handle exception
			System.out.println(e.getMessage());
		}
		return super.clone();
	}
	@Override
	public String toString() {
		return "Sheep [name=" + name + ", age=" + age + ", color=" + color + ", address=" + address + ", friendSheep="
				+ friendSheep + "]";
	}
	
}

同A包下的进行克隆/拷贝操作的client 类

package yuanxing2;

public class Client {
	@SuppressWarnings("unused")
	public static void main(String[] args) throws CloneNotSupportedException {
		Sheep sheep =new Sheep("tom", 1, "white");
		//sheep.friendSheep=new Sheep("jack", 1, "black");这段代码是为了区分深浅拷贝所实例化的一个对象
		Sheep sheep2=(Sheep)sheep.clone();
		Sheep sheep3=(Sheep)sheep.clone();
		Sheep sheep4=(Sheep)sheep.clone();
		Sheep sheep5=(Sheep)sheep.clone();
		System.out.println(sheep2.friendSheep.hashCode());
		System.out.println(sheep3.friendSheep.hashCode());
		
	}
}

以上两个类就可以实现浅拷贝

什么是浅拷贝

浅拷贝就是仅仅只拷贝其基本数据类型及其内容，但不对其存储对象的方式进行改变，其拷贝的对象均指向同一地址，由于java中存储对象是以地址形式存储所以这会使拷贝出来的对象不具有独立性

实现Serialization进行深拷贝

概述

通过字节流和对象流的层层转化以及输入输出和内部的读写实现对某个原型实例的深拷贝。

具体过程推荐：序列化

B包下的DeepProtoTypee类，其中的clone重写方法不用看，实现深拷贝的是deepclone方法。

package deepclone;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;

public class DeepProtoType implements Serializable,Cloneable{
	
public String name;
public Deepclass deepclass;
public DeepProtoType() {
	super();
}
@Override
	protected Object clone() throws CloneNotSupportedException {
		// TODO Auto-generated method stub
	Object deep =null;
//	浅拷贝
	deep=super.clone();
//	强制转换浅拷贝对象为正确的返回类型，因为上一步返回类型是OBJ
	DeepProtoType deepProtoType=(DeepProtoType) deep;
//	在这里对deepclass这个对象进行专门独有的克隆让这个对象的哈希值改变。
	deepProtoType.deepclass= (Deepclass)deepclass.clone();
	return deepProtoType;
	}
public Object deepClone() {
//	创建流对象
//	字节输出/输入流+对象输出输入流
	ByteArrayOutputStream bos = null;
	ObjectOutputStream oos =null;
	ByteArrayInputStream bis =null;
	ObjectInputStream ois = null;
	try {
//		序列化
//		实例化字节输出流bos
		bos = new ByteArrayOutputStream();
//		实例化以bos为参数的对象输出流oos
		oos = new ObjectOutputStream(bos);
//		把要克隆的对象写入对象输出流中
		oos.writeObject(this);
//		反序列化
//		把字节输出流变成字节数组bis
		bis = new ByteArrayInputStream(bos.toByteArray());
//		以bis为对象参数转换为对象输入流ois
		ois = new ObjectInputStream(bis);
//		读取对象方式读取ois同时赋值给copyobj对象流
		DeepProtoType copyobj=(DeepProtoType)ois.readObject();
		return copyobj;
	} catch (Exception e) {
		// TODO: handle exception
		System.out.println(e.getMessage());
		e.printStackTrace();
		return null;
	}finally {
//		最后关闭文件流
		try {
			bos.close();
			bis.close();
			oos.close();
			ois.close();
		} catch (Exception e2) {
			// TODO: handle exception
			System.out.println(e2.getMessage());
		}
	}
	
}
}

这是用于区分深浅拷贝用的展示型类，不用看重写的clone方法

package deepclone;

import java.io.Serializable;

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

这是用于实现拷贝的类

package deepclone;

public class Client {
	public static void main(String[] args) throws CloneNotSupportedException {
		DeepProtoType p = new DeepProtoType();
		p.name="宋江";
		p.deepclass = new Deepclass("大牛", "大牛的类");
//		方式1 完成深拷贝
		DeepProtoType p2 = (DeepProtoType) p.deepClone();
		System.out.println(p.deepclass.hashCode());
		System.out.println(p2.deepclass.hashCode());
	}
}

什么是深拷贝

深拷贝的实质就是使拷贝方式变成递归存储，使每个拷贝出的对象都具有独有的内存地址