设计模式_原型模式(7)

• 什么是原型模式
• 原型模式的例子
• 原型模式的使用场景
• 原型模式的优缺点
• 闲言碎语

什么是原型模式

   在很小的时候我们都应该有过这样的梦想,有多个一模一样的你,一个帮你写作业,一个帮你出去玩,一个帮你去上学这样的梦想,当然在现实中这是不可能实现的.但是在程序中我们是可以通过拷贝内存中(堆内存)以二进制流的方式进行拷贝，重新分配一个内存块来实现它.这也就是原型模式.

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

UML

 

   在理解原型模式之前有必要了解下深拷贝浅拷贝:

   深克隆:被复制对象的所有变量都含有与原来的对象相同的值，除去那些引用其他对象的变量。那些引用其他对象的变量将指向被复制过的新对象，而不再是原有的那些被引用的对象。换言之，深复制把要复制的对象所引用的对象都复制了一遍。

   浅克隆:被复制对象的所有变量都含有与原来的对象相同的值，而所有的对其他对象的引用仍然指向原来的对象。换言之，浅复制仅仅复制所考虑的对象，而不复制它所引用的对象。 Object类提供的方法clone只是拷贝本对象，其对象内部的数组、引用对象等都不拷贝，还是指向原生对象的内部元素地址.

   原型模式是一种比较简单的模式，也非常容易理解，实现一个接口，重写一个方法即完成了原型模式。在实际应用中，原型模式很少单独出现。经常与其他模式混用，他的原型类Prototype也常用抽象类来替代。而且原型模式和java已经有着非常紧密的联系.

原型模式的例子

package com.designPattern.prototype;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;
import java.util.LinkedList;
import java.util.List;

//需要被复制的对象
public class People implements Serializable, Cloneable {
	private String name;
	private String age;
	private List<String> duties;

	@Override
	// 浅克隆(自身的值属性[int,double,string,char,long,boolean,属性])
	public Object clone() throws CloneNotSupportedException {
		return super.clone();
	}

	// 深克隆
	public Object deepClone() throws ClassNotFoundException, IOException {
		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());
	}

	public People(String name, String age) {
		this.name = name;
		this.age = age;
	}

	public void addDuty(String duty) {
		if (duties == null) {
			duties = new LinkedList<String>();
		}
		if (duty == null || duty.trim().equals("")) {
			return;
		}
		duties.add(duty);
	}

	public String getName() {
		return name;
	}

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

	public String getAge() {
		return age;
	}

	public void setAge(String age) {
		this.age = age;
	}

	public List<String> getDuties() {
		return duties;
	}

	public void setDuties(List<String> duties) {
		this.duties = duties;
	}

	@Override
	public String toString() {
		StringBuffer buffer = new StringBuffer();
		buffer.append("name:" + name);
		buffer.append(", age:" + age);
		buffer.append(", work:");
		duties.forEach(work -> {
			buffer.append(work+" ");
		});
		return buffer.toString();
	}

}

测试类

package com.designPattern.prototype;

import java.io.IOException;

import org.junit.Test;

public class TestCase {

	@Test
	public void test() throws CloneNotSupportedException, ClassNotFoundException, IOException{
		People you = new People("jason","20");
		you.addDuty("study");
		you.addDuty("work");
		System.out.println("初始的你:");
		System.out.println(you.toString());
		People doubleYou=(People)you.clone();
		you.addDuty("eat");
		you.setName("jason1");
		doubleYou.addDuty("play");
		doubleYou.setName("jason2");
		People triYou=(People)you.deepClone();
		triYou.addDuty("sleep");
		triYou.setName("jason3");
		System.out.println("克隆后的你:");
		System.out.println("you:"+you.toString());
		System.out.println("doubleYou:"+doubleYou.toString());
		System.out.println("triYou:"+triYou.toString());
	}
}

运行截图

  分析:

   浅拷贝中我们将对象自身的基本属性成功拷贝,但与其关联的深层次属性,依旧老对象与关联.而深拷贝之后两个元素已经没有任何关系了.

原型模式的使用场景,同时注意到克隆时有不受构造函数的影响!

资源优化场景

1. 类初始化需要消化非常多的资源，这个资源包括数据、硬件资源等。
2. 性能和安全要求的场景
3. 通过new产生一个对象需要非常繁琐的数据准备或访问权限，则可以使用原型模式。
4. 一个对象多个修改者的场景
5. 一个对象需要提供给其他对象访问，而且各个调用者可能都需要修改其值时，可以考虑使用原型模式拷贝多个对象供调用者使用。

原型模式的优缺点

   优点: 1、允许动态的增加或减少产品类.    2、提供简化的创建结构. 3、具有给一个应用软件动态加载新功能的能力. 4、产品类不需要非得有任何实现确定的等级结构

   缺点:原型模式的最大缺点就是每一个类必须都有一个clone方法，如果这个类的组成不太复杂的话还比较好，如果类的组成很复杂的话，如果想实现深度复制就相对比较麻烦了.

闲言碎语

   在例子中,对int(基本元素)属性在浅拷贝中可以成功拷贝不足为奇.但众所周知string实际上也是一个引用.但也可以进行成功拷贝,我对此也不是很理解.待日后进行研究.