【设计模式】原型模式

看了一些文章，感觉总结的语言不太好懂，所以自己写一篇。

一、原型模式是什么？

原型模式是一种对象创建型模式（这23种模式怎么分类等我学完最后总结），它采取复制原型对象的方法来创建对象的实例。使用原型模式创建的实例，具有与原型一样的数据。

二、原型模式的特点

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

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

3.根据对象克隆深度层次的不同，有浅克隆和深克隆。

三、原型模式应用场景

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

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

隐藏克隆的细节。

实现比较

先创建两个class文件，一个Person类，一个MainClass类。

public class Person{
	
	String name;
	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;
	}
	
}

public class MainClass {

	public static void main(String[] args) {
		Person person1=new Person();
		person1.setName("aa");
		person1.setAge(10);

		Person person2=new Person();
		
		System.out.println(person1.getName());
		System.out.println(person2.getName());
	}

}

这时运行结果是。

将person2的声明处改成

Person person2=person1;

运行结果是。这时person1和person2的name都是“aa”，看起来好像复制了。

但是这种方法是将person1的地址赋值给了person2，也就是说，对象只有person1一个，person2只是跟person1指向了同一个地址。

将Person类改成如下：实现了Cloneable接口，重写了clone()方法。

public class Person implements Cloneable{
	
	String name;
	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;
	}
	
	public Person clone() {
		try {
			return (Person) super.clone();
		} catch (CloneNotSupportedException e) {
			e.printStackTrace();
			return null;
		}
	}
}

将person2的声明处改成

		Person person2=person1.clone();

运行结果是，这时在堆中复制了一个person1对象，由person2指向它。

 

上面类的属性都是值类型，那如果是引用类型呢？这就出现了浅克隆和深克隆的问题。

给Person类增加一个引用类型的属性，同时增加它的get、set方法。如下：

        private List<String> friends;
	
	public List<String> getFriends() {
		return friends;
	}
	public void setFriends(List<String> friends) {
		this.friends = friends;
	}

主函数如下：

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

运行结果是。

这时再给person1添加一个friend，主函数如下：

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

运行结果是，这时就发现了问题，要添加的是person1的朋友，但是结果里面person2的朋友也多了一个。

这是因为对于引用类型的变量，复制的不是引用变量，而是它的地址，使person2的friends指向了person1的friends的地址。

这就是浅克隆。

那怎么样让person2真正的克隆到person1的引用类型变量呢？？

将Person类中的clone()方法做如下修改，使引用类型变量在clone()方法中进行复制。

	public Person clone() {
		try {
			Person person=(Person) super.clone();
			List<String> friends=new ArrayList<>();
			for(String friend : this.getFriends()) {
				friends.add(friend);
			}
			person.setFriends(friends);
			return person;
		} catch (CloneNotSupportedException e) {
			e.printStackTrace();
			return null;
		}
	}

这时运行结果是，实现了真正的复制。

这就是深克隆。