设计模式之原型模式

选择23种设计模式之一：原型模式

概述

用原型实例指定创建对象的种类，并通过拷贝这些原型创建新的对象。

解决的问题

使用原型模式创建对象比直接new一个对象在性能上要好的多，因为Object类的clone方法是一个本地方法，它直接操作内存中的二进制流，特别是复制大对象时，性能的差别非常明显。

使用原型模式的另一个好处是简化对象的创建，使得创建对象就像我们在编辑文档时的复制粘贴一样简单。

因为以上优点，所以在需要重复地创建相似对象时可以考虑使用原型模式。比如需要在一个循环体内创建对象，假如对象创建过程比较复杂或者循环次数很多的话，使用原型模式不但可以简化创建过程，而且可以使系统的整体性能提高很多。

模式中的角色

原型类的特点：

• 实现Cloneable接口。在java语言有一个Cloneable接口，它的作用只有一个，就是在运行时通知虚拟机可以安全地在实现了此接口的类上使用clone方法。在java虚拟机中，只有实现了这个接口的类才可以被拷贝，否则在运行时会抛出CloneNotSupportedException异常。
• 重写Object类中的clone方法。Java中，所有类的父类都是Object类，Object类中有一个clone方法，作用是返回对象的一个拷贝，但是其作用域protected类型的，一般的类无法调用，因此，Prototype类需要将clone方法的作用域修改为public类型。

　　

java剖析如下：

浅拷贝就是指两个对象共同拥有同一个值，一个对象改变了该值，也会影响到另一个对象。深拷贝就是两个对象的值相等，但是互相独立。

例如：

Person p = new Person();
		p.setName("person1");
		
		Person p2 = p;
		System.out.println(p.getName());
		System.out.println(p2.getName());
		
		p2.setName("gggggg");
		
		System.out.println(p.getName());
		System.out.println(p2.getName());

两个对象的值只有有一个改变了，其他的就会改变。这就是浅拷贝。

1.区分深浅拷贝

Object类的clone方法只会拷贝对象中的基本的数据类型，对于数组、容器对象、引用对象等都不会拷贝，这就是浅拷贝。如果要实现深拷贝，必须将原型模式中的数组、容器对象、引用对象等另行拷贝。

1.浅拷贝

package com.lgy.prototype;

public class Person implements Cloneable {
	private String name;

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	@Override
	public Object clone() throws CloneNotSupportedException {
		return super.clone();
	}
}

2.深拷贝

package com.lgy.prototype;

import java.util.ArrayList;
import java.util.List;

public class Person implements Cloneable {
	private String name;
	private Son son = new Son();
	
	public Son getSon() {
		return son;
	}

	public void setSon(Son son) {
		this.son = son;
	}

	private ArrayList <String> list;
	
	
	public ArrayList<String> getList() {
		return list;
	}

	public void setList(ArrayList<String> list) {
		this.list = list;
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	@Override
	public Object clone() throws CloneNotSupportedException {
		Person prototype = null;  
        try{  
        	System.out.println("clone");
            prototype = (Person)super.clone();  
            this.list = (ArrayList<String>) this.list.clone();
            this.son = (Son) this.son.clone();
        }catch(CloneNotSupportedException e){  
            e.printStackTrace();  
        }  
        return prototype;  
	}
}

此时list和son做了深拷贝，若不进行深拷贝，clone后的对象，会随着母对象改变son和list的值的改变而改变。

2.与单例模式的冲突

package com.lgy.prototype;

public class Singleton implements Cloneable {
	private String name;
	
	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	private static class SingletonHolder {
		private static final Singleton INSTANCE = new Singleton();
	}

	private Singleton() {
	}

	public static final Singleton getInstance() {
		return SingletonHolder.INSTANCE;
	}

	@Override
	public Object clone() throws CloneNotSupportedException {
		// TODO Auto-generated method stub
		return super.clone();
	}
	
}

                Singleton instance = Singleton.getInstance();
		instance.setName("hahaha");
		
		
		Singleton clone = (Singleton) instance.clone();
		instance.setName("ggggggg");
		System.out.println(instance.getName());
		System.out.println(clone.getName());

单例模式也能实现拷贝，原型模式是在内存中实现对对象的拷贝的，不需要经过构造函数就可以完成。

模式总结

　优点

　　　　 使用原型模式创建对象比直接new一个对象在性能上要好的多，因为Object类的clone方法是一个本地方法，它直接操作内存中的二进制流，特别是复制大对象时，性能的差别非常明显。

　缺点

　　　　 clone只是对基本数据类型进行拷贝，但是对引用类型还没进行拷贝。依赖关系并未完全解除，抽象通知者依旧依赖抽象的观察者。

　适用场景

　　　　使用原型模式的另一个好处是简化对象的创建，使得创建对象就像我们在编辑文档时的复制粘贴一样简单。