设计模式（三）原型模式

定义：

原型（Prototype）模式是一种对象创建型模式，它采取复制原型对象的方法来创建对象的实例。使用Prototype模式创建的实例，具有与原型一样的数据。

特点：

• 由原型对象自身创建目标对象。也就是说，对象创建这一动作发自原型对象本身。

• 目标对象是原型对象的一个克隆。也就是说，通过Prototype模式创建的对象，不仅仅与原型对象具有相同的结构，还与原型对象具有相同的值。

• 根据对象克隆深度层次的不同，有浅度克隆与深度克隆。

原型模式的应用场景

• 在创建对象的时候，我们不只是希望被创建的对象继承其基类的基本结构，还希望继承原型对象的数据。

• 希望对目标对象的修改不影响既有的原型对象（深度克隆的时候可以完全互不影响）。

• 隐藏克隆操作的细节。很多时候，对对象本身的克隆需要涉及到类本身的数据细节。

• 和factory一样属于创建型,它和factory不一样的地方在于prototype返回的对象全部是其本身的副本,复制品~但factory不一定,可能是多个new出来的对象,也可能是同一个对象.
  很多时候选择factory或者prototype在于性能上来说,差距不大.但一旦短时间内需求大量对象的话,prototype比factory更加节省资源,效率更高.

原型模式举例

要实现原型模式，就要让当前对象实现Cloneable接口，并写一个返回当前对象的方法。实现接口的意义是告诉虚拟机我当前这个类可以被克隆，通过调用放回当前对象方法的形式创建出与当前对象一模一样的对象。在浅度克隆中，会指向当前对象的引用类的地址，而在深度克隆中，完全会创建一个对象，然后将对象放入到克隆对象中。

• 浅度克隆

    public class Person implements Cloneable{
    	// 姓名
    	private String name;
    	// 年龄
    	private int age;
    	// 性别
    	private String sex;
    	//朋友
    	private List<String> friends;
  
    	public List<String> getFriends() {
    		return friends;
    	}
  
    	public void setFriends(List<String> friends) {
    		this.friends = friends;
    	}
  
    	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 getSex() {
    		return sex;
    	}
  
    	public void setSex(String sex) {
    		this.sex = sex;
    	}
    	
    	public Person clone() {
    		try {
    			return  (Person)super.clone();
    		} catch (CloneNotSupportedException e) {
    			e.printStackTrace();
    			return null;
    		}
    	}
    }
  

如果使用当前克隆方式的话，新对象会将引用类型（ArrayList）的指针指向之前的对象中，这样两个数据是一样的。

• 深度克隆

    public class Person implements Cloneable{
    	// 姓名
    	private String name;
    	// 年龄
    	private int age;
    	// 性别
    	private String sex;
    	//朋友
    	private List<String> friends;
  
    	public List<String> getFriends() {
    		return friends;
    	}
  
    	public void setFriends(List<String> friends) {
    		this.friends = friends;
    	}
  
    	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 getSex() {
    		return sex;
    	}
  
    	public void setSex(String sex) {
    		this.sex = sex;
    	}
    	
    	public Person clone() {
    		try {
    			Person person  = (Person)super.clone();
    			List<String> newfriends = new ArrayList<String>();
    			for(String friend : this.getFriends()) {
    				newfriends.add(friend);
    			}
    			person.setFriends(newfriends);
    			return  person;
    		} catch (CloneNotSupportedException e) {
    			e.printStackTrace();
    			return null;
    		}
    	}
  
    }
  

深度克隆会把之前引用对象的数据重新取出来，然后重新指向新的List集合，这样新旧对象就再无任何关联了。

	public class MainClass {
		public static void main(String[] args) {
		
			Person person1 = new Person();
			List<String> friends = new ArrayList<String>();
			friends.add("James");
			friends.add("Yao");
			
			person1.setFriends(friends);
			
			Person person2 = person1.clone();
			
			System.out.println(person1.getFriends());
			System.out.println(person2.getFriends());
			
			friends.add("Mike");
			person1.setFriends(friends);
			System.out.println(person1.getFriends());
			System.out.println(person2.getFriends());
		}
	}

在第二次person1添加过数据后，person2对象并没有增加新的数据，这时候已经是两个独立的主体了。