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

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

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

例如:

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 客户端代码:

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);

可见, 只需要执行一句

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

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

3.4 UML图

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



实际上这个就是原型模式(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)