设计模式-原型模式

设计模式-原型模式

定义

用原型实例指定建立对象的种类，而且经过拷贝这些原型建立出一个新的对象。
 简单理解就是用一个已有的对象克隆出一个新的对象

UML

优势

• 性能优良，原型模式使用的是内存的二进制流的拷贝，比直接new对象性能好不少，特别是循环产生大量对象时，能够更好的提现其优势
• 逃避构造函数的约束。这既是优势，也是缺点，内存拷贝不会通过构造函数，很容易被忽略形成错误

缺点

实现

public class Student {

	private String name;

	private String targetClass;

	private int age;

	private String address;


	public String getName() {
		return name;
	}

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

	public String getTargetClass() {
		return targetClass;
	}

	public void setTargetClass(String targetClass) {
		this.targetClass = targetClass;
	}

	public int getAge() {
		return age;
	}

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

	public String getAddress() {
		return address;
	}

	public void setAddress(String address) {
		this.address = address;
	}
}

public class Notice implements Cloneable{

	private String receiver;

	private String subject;

	private String msg;

	private String address;

	public Notice(Student student) {
		this.receiver = student.getName();
		this.address = student.getAddress();
	}

	public String getReceiver() {
		return receiver;
	}

	public void setReceiver(String receiver) {
		this.receiver = receiver;
	}

	public String getSubject() {
		return subject;
	}

	public void setSubject(String subject) {
		this.subject = subject;
	}

	public String getMsg() {
		return msg;
	}

	public void setMsg(String msg) {
		this.msg = msg;
	}

	public String getAddress() {
		return address;
	}

	public void setAddress(String address) {
		this.address = address;
	}

	@Override
	public Notice  clone(){
		Notice notice = null;

		try {
			notice = (Notice) super.clone();
		} catch (CloneNotSupportedException e) {
			e.printStackTrace();
		}
		return notice;
	}
}

import java.util.Random;

public class Client {

	private static int MAX_COUNT = 10;

	public static void main(String[] args) {

		int i = 0;
		Notice noticePrototype = new Notice(new Student());
		noticePrototype.setSubject("入学通知书");
		noticePrototype.setMsg("咱们将于九月一日开学");

		while (i < MAX_COUNT){
			Notice notice = noticePrototype.clone();
			notice.setAddress(getRandString(20));
			notice.setReceiver(getRandString(5) +" 同窗");
			sendNotice(notice);
			i++;
		}
	}

	private  static  void sendNotice(Notice notice){
		System.out.println("发送通知书给 " + notice.getReceiver());
		System.out.println("  address = [" + notice.getAddress() + "]");
	}


	public static String getRandString(int length){
		String str="abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
		Random random=new Random();
		StringBuffer sb=new StringBuffer();
		for(int i=0;i<length;i++){
			int number=random.nextInt(62);
			sb.append(str.charAt(number));
		}

		return sb.toString();
	}
}

使用场景

• 资源优化场景 ，类初始化时须要消耗大量资源，并且须要反复新生成这个类
• 性能和安全要求场景，经过new产生一个对象须要很是繁琐的数据准备或访问权限
• 一个对象供多个修改者使用，能够拷贝多个对象供调用者使用
• 易于工厂方法模式结合使用

扩展

• 须要注意深拷贝和浅拷贝
• 拷贝时容易忽略构造函数的执行引发没必要要的错误