原型模式(ProtoType) - Java里的对象复制

落日映苍穹つ 2022-08-06 02:26 156阅读 0赞

## 一, 引用的复制和对象复制. ##

在编程中, 我们有时会用两个引用指向同一个对象.

例如:

ArrayList a = new ArrayLIst();
    ArrayList b = a;

看起来好像有a,b两个容器, 实际上a,b是两个引用, 它们都指向同1个Object的内存地址.

**而对象复制是指:**

**在内存里划分一块与指定对象相同内容的内存.**

也就是说内存里原理有1个Object的内存, 复制后就有两个了...

## 二, 对象复制的简便方法. ##

当然, 对象复制的实现十分简单, 只需要实例化1个具有相同属性的对象就ok了.

注意, 如果用 "==" 来讲比较两个引用是返回false, 因为它们的地址不同.

举个列子:

### 2.1 产品类Prod: ###

public class Prod {
    	private int prodID;
    	private String prodName;
    	
    	public int getProdID() {
    		return prodID;
    	}
    	public void setProdID(int prodID) {
    		this.prodID = prodID;
    	}
    	
    	public String getProdName() {
    		return prodName;
    	}
    	public void setProdName(String prodName) {
    		this.prodName = prodName;
    	}
    	
    	@Override
    	public String toString(){
    		return "Prod: " + this.getProdID() + " , " + this.getProdName();
    	}
    }

### 2.2 订单类Order: ###

public class Order {
    	private int orderID;
    	private Prod prod;
    	private int amount;
    	
    	public int getOrderID() {
    		return orderID;
    	}
    	public void setOrderID(int orderID) {
    		this.orderID = orderID;
    	}
    	
    	public Prod getProd() {
    		return prod;
    	}
    	public void setProd(Prod prod) {
    		this.prod = prod;
    	}
    	
    	public int getAmount() {
    		return amount;
    	}
    	public void setAmount(int amount) {
    		this.amount = amount;
    	}
    	
    	public String toString(){
    		return "Order: " + this.getOrderID() + " , " + this.getAmount() + " " + this.getProd().toString();
    	}
    }

### 2.3 客户端代码: ###

这里我先实例化1个order类 od1, 然后在复制1个od1 的对象od2

Prod p1 = new Prod();
    		p1.setProdID(1);
    		p1.setProdName("Hammer");
    		
    		Order od1 = new Order();
    		od1.setOrderID(1);
    		od1.setProd(p1);
    		od1.setAmount(20);
    		
    		Prod p2 = new Prod();
    		p2.setProdID(1);
    		p2.setProdName("Hammer");
    		
    		Order od2 = new Order();
    		od2.setOrderID(1);
    		od2.setProd(p1);
    		od2.setAmount(20);
    		
    		System.out.println(od1);
    		System.out.println(od2);

输出:

Order: 1 , 20 Prod: 1 , Hammer
    Order: 1 , 20 Prod: 1 , Hammer

### 2.4 这种方法的缺点 ###

首先这种写法不够优雅, 很多重复代码.

其次, 这种复制方法调用了类的构造函数.

就如上面的例子, 即使Order类的构造函数是空的, 但是实际上构造函数的执行机制很复杂,.

构造函数最重要的动作就是给类里的每个成员划分内存空间. 毕竟java是类c语言, 相当于执行了很多次malloc()函数.

如果某些业务类的构造函数写的很复杂, 就更耗费资源了.

而且

## 三, 利用Object.clone()方法来实现对象复制. ##

java里所有对象都是直接或简直继承自基类Object.

而clone()是基类的Native 方法, 所谓Native方法可以认为是java 内部特定方法, 它比非Native的执行效率要好.

也就是说, 利用Object.clone() 方法会比实例化1个相同内容对象效率要好.

### **3.1 Object.clone()方法和 Cloneable接口**: ###

Object.clone() 方法有点特殊,  首先它是public方法, 也就是说它可以通过引用名和"."来调用.

但是它不能被子类继承, 也就说, 出了Object类外所有java里的class里面都没有clone()这个方法的.

如果要使用Object.clone()方法.

只能引用1个叫做 Cloneable里的Interface,  然后重写Cloneable接口里的clone()方法, 在里面调用object.clone().

这个接口就起了1个标记的作用, 帮组实现多态.

###  ###

### 3.2 订单类Order: ###

我们按在这个思路来修改上面的订单类Order:

public class Order implements Cloneable{
    	private int orderID;
    	private Prod prod;
    	private int amount;
    	
    	public int getOrderID() {
    		return orderID;
    	}
    	public void setOrderID(int orderID) {
    		this.orderID = orderID;
    	}
    	
    	public Prod getProd() {
    		return prod;
    	}
    	public void setProd(Prod prod) {
    		this.prod = prod;
    	}
    	
    	public int getAmount() {
    		return amount;
    	}
    	public void setAmount(int amount) {
    		this.amount = amount;
    	}
    	
    	public String toString(){
    		return "Order: " + this.getOrderID() + " , " + this.getAmount() + " " + this.getProd().toString();
    	}
    	
    	@Override
    	public Object clone(){
    		Object o = null;
    		try{
    			o = super.clone();
    		}catch(Exception e){
    			e.printStackTrace();
    		}
    		
    		return o;
    	}
    }

值得注意的是, Object.clone() 回抛异常.

而, Prod类没有任何修改.

### 3.3 客户端代码: ###

可见, 只需要执行一句

Order od2 = (Order)od1.clone();

就相当于 复制了1个对象.

### 3.4 UML图 ###

我们来看看这个例子的UML:

![444127020141221135111095.png_457x258_130][]

实际上这个就是原型模式(prototype)的UML图了,

原来我们不知不觉得使用了原型模式.

## 四, 原型模式的定义 ##

原型模式(protoType), 用原型实例制定创建对象的种类, 并且通过copy这些原型创建新的对象.

总觉得设计模式的定义都太过于简单恶心了.

上面的

原型指的是  Cloneable这个接口.

原型实例指的是 Order这个类.

## 五, 浅复制和深复制 ##

对象复制也分两种.

浅复制:

两个对象中的值类型成员属性相等,  对象成员成员属性实际上没有复制,都是同一个对象.

深复制:

两个对象中的值类型成员属性相等,  对象成员属性指向不同的 具有相同成员的 对象.

如上面的例子, 稍稍修改客户端代码:

Prod p1 = new Prod();
    		p1.setProdID(2);
    		p1.setProdName("knife");
    		
    		Order od1 = new Order();
    		od1.setOrderID(2);
    		od1.setAmount(30);
    		od1.setProd(p1);
    		
    		Order od2 = (Order)od1.clone();
    		System.out.println(od1);
    		System.out.println(od2);
    		
    		od1.setOrderID(3);
    		od1.setAmount(40);
    		od1.getProd().setProdName("blade");
    		
    		System.out.println(od1);
    		System.out.println(od2);

上面 构建了对象od1,

然后复制出了另1个对象od2,

然后修改od1的 值成员 和 对象成员

然后输出od1, 和 od2 成员的值:

Order: 2 , 30 Prod: 2 , knife
    Order: 2 , 30 Prod: 2 , knife
    Order: 3 , 40 Prod: 2 , blade
    Order: 2 , 30 Prod: 2 , blade

可见, 当od1 的id 和 amount的值被改成 3 和 40 后,  od2 的id和 Amount的值并不受影响, 因为它们的值类型成员属性是相互独立的.

但是当od1 的 prod属性的内容被修改后,    od2 的也被修改了(knife - > blade),  因为 od1 和 od2 的 prod成员指向的都是同1个对象.

这就证明了:

**Java里的 Object.clone()方法实现的是浅复制.**

## 六, 原型模式的深复制实现 ##

接下来再次修改上面的例子, 令其实现成深复制

而且, 根据项目需要, 复制并不会复制Order的id, 也就是订单号码是唯一的, 只复制Prod和数量.

### 6.1 订单类Order: ###

public class Order implements Cloneable{
    	private int orderID;
    	private Prod prod;
    	private int amount;
    	
    	public int getOrderID() {
    		return orderID;
    	}
    	public void setOrderID(int orderID) {
    		this.orderID = orderID;
    	}
    	
    	public Prod getProd() {
    		return prod;
    	}
    	public void setProd(Prod prod) {
    		this.prod = prod;
    	}
    	
    	public int getAmount() {
    		return amount;
    	}
    	public void setAmount(int amount) {
    		this.amount = amount;
    	}
    	
    	public String toString(){
    		return "Order: " + this.getOrderID() + " , " + this.getAmount() + " " + this.getProd().toString();
    	}
    	
    	@Override
    	public Object clone(){
    		Prod p = new Prod();
    		p.setProdID(this.getProd().getProdID());
    		p.setProdName(this.getProd().getProdName());
    		
    		Order o = new Order();
    		o.setOrderID(this.getOrderID() + 1);
    		o.setAmount(this.getAmount());
    		o.setProd(p);
    		
    		return o;
    	}
    }

客户端输出:

Order: 2 , 30 Prod: 2 , knife
    Order: 3 , 30 Prod: 2 , knife
    Order: 3 , 40 Prod: 2 , blade
    Order: 3 , 30 Prod: 2 , knife

可以, 无论od1修改了什么,  od2 都不受影响

这种方法放弃了Object.clone(), Order类在重写clone()方法里还是使用了构造方法去实例化1个新的对象.

这种方法配置更加灵活(选择性地复制成员)

当时放弃了Object.clone()的效能优点.

但是这仍然实现了原型模式(protoType)

[444127020141221135111095.png_457x258_130]: http://image16.poco.cn/mypoco/myphoto/20141221/13/444127020141221135111095.png?457x258_130