设计模式——原型模式

1. 原型模式比较简单，本质就是将一个设置好一部分公共属性的对象进行克隆，产生出大量的对象，再对每个对象进行相应的个性化处理
2. 需要注意的是：对象克隆时，如果其成员变量中存在引用类型（数组、引用对象等），就必须解决浅拷贝问题
3. 浅拷贝：对于被克隆对象的成员变量，如果是基本类型（包括String），则会直接克隆，但对于引用类型，则是引用被克隆对象的地址，也就是说克隆对象可以直接操作原对象的引用类型成员变量。
4. 深拷贝：对象进行克隆时，将引用类型的成员变量也进行拷贝（该对象也需要实现Cloneable接口，否则不能拷贝），然后再赋值给克隆对象

原型模式（基本案例）

邮件类（个性属性多）

/**
 * 邮件
 */
public class Mail implements Cloneable{
	// 收件人
	private String receiver;
	// 邮件名称
	private String subject;
	// 称谓
	private String appellation;
	// 邮件内容
	private String content;
	// 邮件尾部
	private String tail;

	public Mail(AdvTemplate advTemplate){
		this.content = advTemplate.getAdvContent();
		this.subject = advTemplate.getAdvSubject();
	}

	@Override
	public Mail clone(){
		Mail mail = null;
		try {
			mail = (Mail) super.clone();
		} catch (CloneNotSupportedException e) {
			e.printStackTrace();
		}
		return mail;
	}
	// Getter、Setter省略
}

模板类（公共属性多）

/**
 * 广告信模板代码
 */
public class AdvTemplate {
	// 广告信名称
	private String advSubject = "XX银行国庆信用卡抽奖活动";
	// 广告信内容
	private String advContent = "国庆抽奖活动通知：只要刷卡就送100元话费充值券！";

	public String getAdvSubject() {
		return advSubject;
	}

	public String getAdvContent() {
		return advContent;
	}
}

入口类

public class PrototypeMain {
	// 发送账单的数量，假定6
	private static final int MAX_COUNT = 6;

	public static void main(String[] args) {
		// 模拟发送邮件
		int i = 0;
		Mail mail = new Mail(new AdvTemplate());
		mail.setTail("XX银行版权所有");
		while (i < MAX_COUNT) {
			// 改动：通过克隆，而不是new的方式创建对象，该对象保留大部分细节，个性部分再修改即可
			Mail cloneMail = mail.clone();
			cloneMail.setAppellation(getRandString(5) + "先生（女士）");
			cloneMail.setReceiver(getRandString(5) + "@" + getRandString(8) + ".com");
			// 然后发送邮件
			sendMain(cloneMail);
			i++;
		}
	}

	private static void sendMain(Mail mail) {
		System.out.println("标题：" + mail.getSubject() + "\t收件人：" + mail.getReceiver() + "\t...发送成功");
	}

	private static String getRandString(int maxLength) {
		String source = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
		StringBuffer sb = new StringBuffer();
		Random rand = new Random();
		for (int i = 0; i < maxLength; i++) {
			sb.append(source.charAt(rand.nextInt(source.length())));
		}
		return sb.toString();
	}
}

结果

浅拷贝、深拷贝案例

/**
 * 浅拷贝
 * 1. 浅拷贝对对象中基础类型的成员变量（包括String）是直接拷贝的
 * 2. 但是对于引用类型（数组、对象）的变量则不拷贝，而是采用地址引用，这样就会造成克隆对象可以操作原对象中的成员变量（对象类型）
 * 3. 注意：引用类型的成员变量也必须实现Cloneable接口，否则就会编译报错
 * 例如：List<String> list = new ArrayList<>()就会报错，ArrayList<String> list = new ArrayList<>() 才不会报错
 */
class ShallowCopyThing implements Cloneable{
	private ArrayList<String> list = new ArrayList<>();

	@Override
	public ShallowCopyThing clone(){
		ShallowCopyThing thing = null;
		try {
			// 这步只能算作浅拷贝，浅拷贝对于`引用类型`成员变量是地址引用，克隆的对象也能操作原对象的成员变量
			thing = (ShallowCopyThing) super.clone();
		} catch (CloneNotSupportedException e) {
			e.printStackTrace();
		}
		return thing;
	}
	// 设置List的值
	public void setValue(String value){
		this.list.add(value);
	}
	// 获取List的值
	public ArrayList<String> getValue(){
		return this.list;
	}
}

/**
 * 深拷贝
 * 连同类中的成员变量一起拷贝
 */
class DeepCopyThing implements Cloneable{
	private ArrayList<String> list = new ArrayList<>();
	private Person per = new Person();

	@Override
	public DeepCopyThing clone(){
		DeepCopyThing thing = null;
		try {
			// 这步只能算作浅拷贝，浅拷贝对于`引用类型`成员变量是地址引用，克隆的对象也能操作原对象的成员变量
			thing = (DeepCopyThing) super.clone();
			// 这步才算是深拷贝，对私有成员变量独立拷贝，再赋值给克隆对象
			thing.list = (ArrayList<String>) this.list.clone();
		} catch (CloneNotSupportedException e) {
			e.printStackTrace();
		}
		return thing;
	}
	// 设置List的值
	public void setValue(String value){
		this.list.add(value);
	}
	// 获取List的值
	public ArrayList<String> getValue(){
		return this.list;
	}
}

public class ShallowAndDeepCopyMain {
	public static void main(String[] args) {
		shallowCopy();
		deepCopy();
	}
	public static void deepCopy(){
	    DeepCopyThing thing = new DeepCopyThing();
	    thing.setValue("Good");
	    DeepCopyThing clone = thing.clone();
	    clone.setValue("Boy");
	    System.out.println("deepCopy: " + thing.getValue());
		}
	public static void shallowCopy(){
		ShallowCopyThing thing = new ShallowCopyThing();
		thing.setValue("Good");
		ShallowCopyThing clone = thing.clone();
		clone.setValue("Boy");
		System.out.println("shallowCopy: " + thing.getValue());  // 结果是原对象的值会被拷贝的值操作，极不安全
	}
}

结果

参考书籍

秦小波《设计模式之禅》