首页 > 代码库 > 原型模式小试

原型模式小试

同为创建型模式的原型模式与单例模式是密不可分的,这也是最常用的设计模式之一。

原型模式是一种非常简单的设计模式。这里除了基本介绍和演示,还详细介绍了Java中原型模式的本质。

一、介绍

  同样,先来看一下《研磨设计模式》的定义——用原型实例指定创建对象的种类,并通过拷贝这些原型创建新的对象。

  原型模式的本质——克隆生成对象。

  那么原型模式是什么意思呢?说白了就是克隆自身。我们知道Java中没有引用这个概念,Java用变量名代表引用。像 Apple a = new Apple(); 我们知道,想要操作这个Apple对象,那么就是去操作"a"这个变量名,实质就是去操作“a”这个引用所指向的内存地址上的Apple对象。通常而言,赋值操作符“=”的本质就是将“=”右边的地址赋值给左边的引用。如果我们希望创建一个跟这个对象a一样的Apple对象,同时在操作这个新对象的时候,对象a无任何影响。Java新手可能下意识觉得使用Apple b = a; 很明显a和b指向的是同一片内存空间。

  原型模式就是为了解决这样的对象复制的问题。

  Java中的原型模式实现起来其实很简单,在对象的接口中添加一个复制自身的抽象方法,然后对象实现这个方法,复制自身即可。使用的时候直接调用接口方法即可。

 

二、我的实现

1、我们有一个水果接口,如下:

1 public interface Fruit {
2 
3     public double getPrice();
4     
5     public void setPrice(double price);
6     
7     //克隆接口
8     public Fruit cloneFruit();
9 }

2、一个简单实现类:

 1 public class Apple implements Fruit,Cloneable {
 2 
 3     // 价格
 4     private double price;
 5     // 平均尺寸
 6     private double avgSize;
 7     // 产地
 8     private String productionArea;
 9 
10     public Apple(double price, double avgSize, String productionArea) {
11         super();
12         this.price = price;
13         this.avgSize = avgSize;
14         this.productionArea = productionArea;
15     }
16 
17     public double getAvgSize() {
18         return avgSize;
19     }
20 
21     public void setAvgSize(double avgSize) {
22         this.avgSize = avgSize;
23     }
24 
25     public String getProductionArea() {
26         return productionArea;
27     }
28 
29     public void setProductionArea(String productionArea) {
30         this.productionArea = productionArea;
31     }
32 
33     @Override
34     public void setPrice(double price) {
35         // TODO Auto-generated method stub
36         this.price = price;
37     }
38 
39     @Override
40     public double getPrice() {
41         // TODO Auto-generated method stub
42         return price;
43     }
44 
45     @Override
46     public String toString() {
47         return "Apple [avgSize=" + avgSize + ", price=" + price
48                 + ", productionArea=" + productionArea + "]";
49     }
50 
51     //克隆自身的实现
52     @Override
53     public Fruit cloneFruit()
54     {
55         return new Apple(price, avgSize, productionArea);
56     }
57 
58 }

3、然后就可以测试了,如下:

 1 package prototype.myPrototype;
 2 
 3 public class Client {
 4 
 5     public static void main(String[] args)
 6     {
 7         Fruit fruit = new Apple(1,2,"红富士");
 8         System.out.println(fruit);
 9         
10         //根据原对象克隆
11         Fruit cloneFruit = fruit.cloneFruit();
12         System.out.println(cloneFruit);
13         System.out.println("两个水果是同一个吗?"+(fruit==cloneFruit));
14         
15     }
16 }

4、结果如下:

Apple [avgSize=2.0, price=1.0, productionArea=红富士]
Apple [avgSize=2.0, price=1.0, productionArea=红富士]
两个水果是同一个吗?false

如上,简单的实现了原型模式。也实现了接口与实现分离的克隆。在完全不知道对象类型的情况下完成了复制。

 

三、Java的原型模式(Object的clone()方法)

(1)、介绍

  Object类有一个clone()方法,这是java为实现原型模式准备的。

  要实现Java的克隆方法,要满足三个条件:

  1、调用对象实现了cloneable接口

  2、调用对象重写了public Object clone();方法。

  3、重写clone()时,调用super.clone();

  我们来看一下clone方法的原型

  protected native java.lang.Object clone() throws java.lang.CloneNotSupportedException

  我们可以看到,这个方法是protected访问控制,同时是一个本地方法。也就是说,任何Object的子类都可以调用这个方法,但是Object对象自身不能调用这个方法。

  这个方法执行的时候,是使用RTTI(run-time type identification)的机制,动态得找到目前正在调用clone方法的那个reference,根据它的大小申请内存空间,然后进行bitwise的复制,将该对象的内存空间完全复制到新的空间中去,从而达到shallowcopy的目的。(这句话摘自百度知道)

 

(2)、问题:

  1、为什么调用对象要实现cloneable接口?

  因为clone方法执行的时候,会判断当前对象是否实现了Cloneable这个标识接口,如果没有实现,就抛出CloneNotSupportedException异常。

  2、为什么调用对象要重写public Object clone();方法,为什么要调用super.clone()?

  如果调用对象不重写public Object clone()方法,那么clone()方法都不会显示出来。调用clone()方法,直接编译错误。可是clone()方法不是protected的吗?

  我们来看一下clone();方法的API:

By convention, the returned object should be obtained by calling super.clone. If a class and all of its superclasses (except Object) obey this convention,
it will be the case that x.clone().getClass() == x.getClass().
--按照惯例,返回的对象应该通过调用 super.clone 获得。如果一个类及其所有的超类(Object 除外)都遵守此约定,则 x.clone().getClass() == x.getClass()

  因为只有重写clone()方法,我们才能通过使用super.clone(),才能真正调用Object类的本地方法clone();

  从这里我们可以看到,clone()方法是很特殊的。不重写,会编译错误,应该涉及到编译器的优化。

 

(3)、实现:  

我们来Java的原型模式简单改一下上面的示例:

1、将Fruit接口中的克隆功能去掉,这里不列出了。

2、Apple类实现Fruit接口,也实现Cloneable接口,并重写clone()方法,如下:

 1 public class Apple implements Fruit, Cloneable {
 2 
 3     // 价格
 4     private double price;
 5     // 平均尺寸
 6     private double avgSize;
 7     // 产地
 8     private String productionArea;
 9 
10     public Apple(double price, double avgSize, String productionArea)
11     {
12         super();
13         this.price = price;
14         this.avgSize = avgSize;
15         this.productionArea = productionArea;
16     }
17 
18     public double getAvgSize()
19     {
20         return avgSize;
21     }
22 
23     public void setAvgSize(double avgSize)
24     {
25         this.avgSize = avgSize;
26     }
27 
28     public String getProductionArea()
29     {
30         return productionArea;
31     }
32 
33     public void setProductionArea(String productionArea)
34     {
35         this.productionArea = productionArea;
36     }
37 
38     @Override
39     public void setPrice(double price)
40     {
41         // TODO Auto-generated method stub
42         this.price = price;
43     }
44 
45     @Override
46     public double getPrice()
47     {
48         // TODO Auto-generated method stub
49         return price;
50     }
51 
52     // 重写了Object类的clone()方法
53     @Override
54     public Object clone()
55     {
56         // TODO Auto-generated method stub
57         Object cloneApple = null;
58         // 直接调用父类的克隆方法即可
59         try
60         {
61             cloneApple = super.clone();
62         } catch (CloneNotSupportedException e)
63         {
64             e.printStackTrace();
65         }
66         return cloneApple;
67     }
68 
69     @Override
70     public String toString()
71     {
72         return "Apple [avgSize=" + avgSize + ", price=" + price + ", productionArea=" + productionArea + "]";
73     }
74 
75 }

3、测试一下:

 1 public class Client {
 2 
 3     static Fruit fruit = new Apple(90, 5, "新疆");
 4 
 5     public static void main(String[] args) {
 6         System.out.println("Fruit:" + fruit);
 7         Fruit newFruit = (Fruit) ((Apple)fruit).clone();
 8         System.out.println("new Fruit : " + newFruit);
 9         System.out.println("前后是否为同一对象?" + (fruit == newFruit));
10     }
11 }

4、结果:

Fruit:Apple [avgSize=5.0, price=90.0, productionArea=新疆]
new Fruit : Apple [avgSize=5.0, price=90.0, productionArea=新疆]
前后是否为同一对象?false

个人认为,方便而言,还不如自己手动实现原型模式。这里再补充一点:

我们来看,static Fruit fruit = new Apple(90, 5, "新疆");

对于对象fruit,它的编译时类型是Fruit,运行时类型是Apple,所以fruit对象只能显式调用Fruit接口所有的方法。而这其中包含了Object类除了clone()方法之外的所有方法。Java中,接口和类是一个并列的概念

我们可以认为接口是一种特殊的类,它默认实现了Object中除了clone()之外的像toString()、getClass等一系列Object方法。

 

四、深度克隆和浅度克隆

  克隆分为深度克隆和浅度克隆。假设我们现在有一个对象,这个对象有一个引用属性是另一个对象。我们知道,引用属性的本质就是一个内存地址。按照上文的复制,我们会将复制对象的引用属性也一同复制,这样一来,复制对象和被复制对象的该属性都指向同一内存地址了。这就违背了我们克隆的初衷。而这个就是浅度克隆。

  相对的,深度克隆就是克隆之后,复制对象和被复制对象是完全不想干的。即对于对象的引用属性,我们重新克隆一次。

  下面是Java克隆、深度克隆的简单示例:

1、首先是一个包含刚才Fruit类的Businessman对象:

 1 public class Businessman implements Cloneable {
 2 
 3     private String name;
 4     private Fruit fruit;
 5 
 6     @Override
 7     public String toString()
 8     {
 9         return "Businessman [name=" + name + ", fruit=" + fruit + "]";
10     }
11 
12     public Businessman(String name, Fruit fruit)
13     {
14         super();
15         this.name = name;
16         this.fruit = fruit;
17     }
18 
19     public String getName()
20     {
21         return name;
22     }
23 
24     public void setName(String name)
25     {
26         this.name = name;
27     }
28 
29     public Fruit getFruit()
30     {
31         return fruit;
32     }
33 
34     public void setFruit(Fruit fruit)
35     {
36         this.fruit = fruit;
37     }
38     //克隆方法
39     public Object clone(){
40         //先克隆一下引用变量
41         Fruit f = (Fruit) ((Apple)fruit).clone();
42         Businessman man = new Businessman(name,f);
43         return man;
44     }
45 }

 

2、测试一下:

 1 package prototype;
 2 
 3 public class Client {
 4 
 5     public static void main(String[] args) {
 6         //水果类
 7         Fruit fruit = new Apple(90, 5, "新疆");
 8         //商人
 9         Businessman man1 = new Businessman("张三",fruit);
10         
11         System.out.println("man1:" + man1);
12         //克隆
13         Businessman man2 = (Businessman) man1.clone();
14         
15         System.out.println("man2 : " + man2);
16         System.out.println("man1和man2前后是否为同一对象?" + (man1 == man2));
17         System.out.println("两者的属性呢?"+(man1.getFruit()==man2.getFruit()));
18     }
19 }

3、结果如下:

man1:Businessman [name=张三, fruit=Apple [avgSize=5.0, price=90.0, productionArea=新疆]]
man2 : Businessman [name=张三, fruit=Apple [avgSize=5.0, price=90.0, productionArea=新疆]]
man1和man2前后是否为同一对象?false
两者的属性呢?false