原型模式

 原型模式：用原型实例指定创建对象的种类，并且通过拷贝这些原型创建新的对象。
                 即从一个对象再创建另外一个可定制的对象，而且不需要知道任何创建的细节。

 浅复制：被复制对象的所有变量都含有与原来的对象相同的值，而所用的对其它对象的引用都仍然指向原来的对象
  深复制：把引用对象的变量指向复制过的新对象，而不是原来被引用的对象。

 

 

/**
 * 原型接口
 *
 */
public  interface Prototype extends Cloneable{	
	
	public abstract Prototype copy();	
	
}

 

/**
 * 地址类，定义为具体类型（拷贝时只复制引用）
 *
 */
public class Address {
	
	private String id;
	private String telephone;
	private String address;
	
	public String getId() {
		return id;
	}
	public void setId(String id) {
		this.id = id;
	}
	public String getTelephone() {
		return telephone;
	}
	public void setTelephone(String telephone) {
		this.telephone = telephone;
	}
	public String getAddress() {
		return address;
	}
	public void setAddress(String address) {
		this.address = address;
	}
}

 

/**
 * 部门类（实现原型类方法，提供深拷贝）
 *
 */
public class Department implements Prototype{	
	
	private String id;
	// 部门名称
	private String name;

	public Prototype copy() {
		
		Department department = null;
		try {
			department = (Department)this.clone();
		} catch (CloneNotSupportedException e) {
			e.printStackTrace();
		}
		return department;
	}

	public String getId() {
		return id;
	}

	public void setId(String id) {
		this.id = id;
	}

	public String getName() {
		return name;
	}

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

 

/**
 * 具体的原型类1
 *
 */
public class ConcretePrototype1 implements Prototype {
	
	// 姓名
	private String name;
	
	// 地址
	private Address address;
	
	// 部门
	private Department department;

	public Prototype copy() {	
		
		Prototype prototype = null;
		try {
			
			// 调用clone()方法时，必须实现java.lang.Cloneable接口
			prototype = (Prototype)this.clone();
		} catch (CloneNotSupportedException e) {
			e.printStackTrace();
		}
		return prototype;
	}

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

	public Address getAddress() {
		return address;
	}

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

	public Department getDepartment() {
		return department;
	}

	public void setDepartment(Department department) {		
		// 此处为引用类型department的深拷贝
		this.department = (Department)department.copy();
	}
}

 

public class Main {

	public static void main(String[] args) {
		
		ConcretePrototype1 c1 = new ConcretePrototype1();
		c1.setName("C1");
		Address address = new Address();
		address.setTelephone("1359978768");
		address.setAddress("厦门");
		c1.setAddress(address);
		Department department = new Department();
		department.setName("开发部");
		c1.setDepartment(department);
		
		ConcretePrototype1 copyC1 =(ConcretePrototype1) c1.copy();
		System.out.println(copyC1.getName());
		System.out.println(copyC1.getAddress().getAddress());
		
		// c1的改变不会影响copyC1的变化
		c1.setName("C2");	
		System.out.println(copyC1.getName());//输出仍为C1
		
		// 此时c1的改变会影响copyC1的变化，因为clone()实现的是浅拷贝，address为引用类型，只复制引用
		address.setAddress("北京");
		c1.setAddress(address);
		System.out.println(copyC1.getAddress().getAddress());//输出变为北京
		
		//此时c1的改变不会影响copyC1的变化，因为Department引用类型实现了深拷贝。
		department.setName("总经理室");
		c1.setDepartment(department);
		System.out.println(copyC1.getDepartment().getName());//输出仍为开发部
		
	}
}

 

输出结果为：

 

C1
厦门
C1
北京
开发部