您的位置:首页 > 其它

设计模式(三)——原型模式

2022-01-07 00:37 316 查看

一、引子

1、克隆人的问题

  问题:有一个人叫张三,姓名:张三,年龄:18,身高:178。如何创建和张三属性完全相同的10个人呢?
  代码示例:

1 public class Main {
2
3     public static void main(String[] args) {
4         Person p0 = new Person("张三", 18, 178);
5
6         Person p1 = new Person(p0.getName(), p0.getAge(), p0.getHeight());
7         Person p2 = new Person(p0.getName(), p0.getAge(), p0.getHeight());
8         Person p3 = new Person(p0.getName(), p0.getAge(), p0.getHeight());
9         Person p4 = new Person(p0.getName(), p0.getAge(), p0.getHeight());
10         Person p5 = new Person(p0.getName(), p0.getAge(), p0.getHeight());
11         Person p6 = new Person(p0.getName(), p0.getAge(), p0.getHeight());
12         Person p7 = new Person(p0.getName(), p0.getAge(), p0.getHeight());
13         Person p8 = new Person(p0.getName(), p0.getAge(), p0.getHeight());
14         Person p9 = new Person(p0.getName(), p0.getAge(), p0.getHeight());
15         Person p10 = ne
56c
w Person(p0.getName(), p0.getAge(), p0.getHeight());
16
17         System.out.println(JSON.toJSONString(p0));
18     }
19 }
20
21 class Person {
22     private String name;
23     private int age;
24     private int height;
25     // getter & setter
26     // 有参数、无参构造器
27 }

  这样创建的问题显而易见:如果Person类有100个属性呢?如果要创建和张三属性完全相同的100个人呢?

二、原型模式

1、介绍

  原型模式(Prototype):用原型实例指定创建对象的种类,并且通过拷贝这些原型,创建新的对象,无需知道创建的细节。简单来说就是复制一个和已知对象一模一样的对象。
  方式:实现 Cloneable 接口,复写 Object 类的 clone() 方法。该方法可以将一个 Java 对象复制一份,但调用该方法的类必须实现Cloneable接口,这是一个标志接口,标识该类能够复制且具有复制的能力。如果不实现 Cloneable 接口,直接调用 clone() 方法,会抛出 CloneNotSupportedException 异常。
  源码示例:Object.clone()

1 protected native Object clone() throws CloneNotSupportedException;

  这是一个本地方法,具体实现细节,不需要了解,由操作系统实现。只需要知道它的作用就是复制对象,产生一个新的对象。

2、解决克隆人的问题

  代码示例:实现Cloneable接口,复写clone()方法。

1 public class Main {
2
3     public static void main(String[] args) {
4         Person p0 = new Person("张三", 18, 178);
5
6         final Person p1 = p0.clone();
7
8         System.out.println(JSON.toJSONString(p1));
9         System.out.println(p0 == p1);
10     }
11 }
12
13 class Person implements Cloneable {
14     private String name;
15     private int age;
16     private int height;
17
18     @Override
19     public Person clone() {
20         Person person = null;
21         try {
22             person = (Person) super.clone();
23         } catch (CloneNotSupportedException e) {
24             e.printStackTrace();
25         }
26         return person;
27     }
28
29     // getter & setter
30     // 有参数、无参构造器
31 }
32
33 // 结果
34 {"age":18,"height":178,"name":"张三"}
35 false

  从结果可以看出,复制了一个和张三一模一样的人。

三、深拷贝与浅拷贝

1、介绍

  在 Java 中有两种数据类型:基本类型和引用类型。
  基本类型,也称为值类型,有八大基本数据类型:byte、short、int、long、float、double、char、boolean。注:String并不是基本数据类型。
  引用类型,有数组、类、接口、枚举等。

  浅拷贝:只复制基本数据类型,以及引用类型的引用。
  深拷贝:复制基本数据类型,以及引用类型的引用,和引用对象的实例。

  如图所示:克隆"张三"。
  浅拷贝,只会克隆张三的基本属性,如姓名,年龄,身高等,不会克隆他的狗,他两共用这只狗。
  深拷贝,除了克隆张三,还会克隆他的狗,他两分别独立拥有各自的狗。

2、浅拷贝

  上述在解决克隆人的问题上,其实就是一种浅拷贝。接下来,假设张三拥有一只狗,叫"旺财"。
  代码示例:

1 public class Main {
2
3     public static void main(String[] args) {
4         Dog dog = new Dog("旺财");
5         Person p0 = new Person("张三", 18, 178, dog);
6
7         final Person p1 = p0.clone();
8
9         // 修改p0 张三的狗的名字为 大黄
10         p0.getDog().setName("大黄");
11
12         System.out.println(JSON.toJSONString(p1));
13     }
14 }
15
16 class Person implements Cloneable {
17     private String name;
18     private int age;
19     private int height;
20     private Dog dog; // 引用类属性
21
22     @Override
23     public Person clone() {
24         Person person = null;
25         try {
26             person = (Person) super.clone();
27         } catch (CloneNotSupportedException e) {
28             e.printStackTrace();
29         }
30         return person;
31     }
32     // getter & setter
33     // 有参数、无参构造器
34 }
35
36 class Dog {
37     private String name;
38     // getter & setter
39     // 有参数、无参构造器
40 }
41
42 // 结果
43 {"age":18,"dog":{"name":"大黄"},"height":178,"name":"张三"}

  问题:从结果可以看出,修改了张三的狗的名字,克隆张三的狗的名字也改变了。原因是他两指向的是同一只狗。也就是说对象经过克隆后,只是复制了其引用,其指向的还是同一块堆内存空间,当修改其中一个对象的属性,另一个也会跟着变化。

3、深拷贝

  如果就想要,在克隆张三后,他两各自拥有自己独立的狗,怎么办呢?就要用到深拷贝。
  实现方式一:让引用类属性也具备可拷贝性。
  代码示例:让Dog同样具备可拷贝性

1 public class Main {
2
3     public static void main(String[] args) {
4         Dog dog = new Dog("旺财");
5         Person p0 = new Person("张三", 18, 178, dog);
6
7         final Person p1 = p0.clone();
8
9         // 修改p0 张三的狗的名字为 大黄
10         p0.getDog().setName("大黄");
11
12         System.out.println(JSON.toJSONString(p1));
13         System.out.println(JSON.toJSONString(p0));
14     }
15 }
16
17 class Person implements Cloneable {
18     private String name;
19     private int age;
20     private int height;
21     private Dog dog; // 引用类属性
22
23     @Override
24     public Person clone() {
25         Person person = null;
26         try {
27             // 1.先克隆一个人
28             person = (Person) super.clone();
29
30             // 2.再克隆一条狗,并让这个狗属于这个人.
31             person.dog = this.dog.clone();
32         } catch (CloneNotSupportedException e) {
33             e.printStackTrace();
34         }
35         return person;
36     }
37     // getter & setter
38     // 有参数、无参构造器
39 }
40
41 class Dog implements Cloneable {
42     private String name;
43
44     @Override
45     public Dog clone() {
46         Dog dog = null;
47         try {
48             dog = (Dog) super.clone();
49         } catch (CloneNotSupportedException e) {
50             e.printStackTrace();
51         }
52         return dog;
53     }
54     // getter & setter
55     // 有参数、无参构造器
56 }
57
58 // 结果
59 {"age":18,"dog":{"name":"旺财"},"height":178,"name":"张三"}
60 {"age":18,"dog":{"name":"大黄"},"height":178,"name":"张三"}

  问题:从结果可以看出,他两各自拥有了独立的狗。这种方式,确实实现了对象的深拷贝。但是有一个问题,如果Dog类还有引用类属性,也需要同样让其具备可拷贝性,嵌套太深的话,很不利于代码的扩展性。
  一般推荐使用方式二来实现。
  实现方式二:序列化。对序列化不了解的,可以先看这篇,对象流。
  代码示例:序列化

1 public class Main {
2
3     public static void main(String[] args) throws Exception {
4         Dog dog = new Dog("旺财");
5         Person p0 = new Person("张三", 18, 178, dog);
6         // 序列化
7         ObjectOutputStream output = new ObjectOutputStream(new FileOutputStream("temp.dat"));
8         output.writeObject(p0);
9
10         // 反序列化
11         ObjectInputStream input = new ObjectInputStream(new FileInputStream("temp.dat"));
12         final Person p1 = (Person) input.readObject();
13
14         // 修改p0 张三
1044
的狗的名字为 大黄
15         p0.getDog().setName("大黄");
16
17         System.out.println(JSON.toJSONString(p1));
18         System.out.println(JSON.toJSONString(p0));
19     }
20 }
21
22 class Person implements Serializable {
23     private static final long serialVersionUID = 1L;
24     private String name;
25     private int age;
26     private int height;
27     private Dog dog; // 引用类属性
28     // getter & setter
29     // 有参数、无参构造器
30 }
31
32 class Dog implements Serializable {
33     private static final long serialVersionUID = 1L;
34     private String name;
35     // getter & setter
36     // 有参数、无参构造器
37 }

  注意:因为使用了序列化,引用类属性,要想序列化,也需要具备可序列化。
  代码示例:优化,可抽取为一个工具类

1 public class CloneUtils {
2     @SuppressWarnings("unchecked")
3     public static <T extends Serializable> T deepClone(T obj) {
4         T cloneObj = null;
5         try {
6             // 写入字节流
7             ByteArrayOutputStream out = new ByteArrayOutputStream();
8             ObjectOutputStream obs = new ObjectOutputStream(out);
9
10             obs.writeObject(obj);
11             obs.close();
12
13             // 分配内存,写入原始对象,生成新对象
14             ByteArrayInputStream ios = new ByteArrayInputStream(out.toByteArray());
15             ObjectInputStream ois = new ObjectInputStream(ios);
16
17             cloneObj = (T) ois.readObject();
18             ois.close();
19         } catch (Exception e) {
20             e.printStackTrace();
21         }
22         return cloneObj;
23     }
24 }

4、优点

  性能高:原型模式是在内存二进制流的拷贝,要比直接new一个对象性能好很多,特别是要在一个循环体内产生大量的对象时,原型模式可以很好地体现其优点。
  避免构造函数的约束:这既是它的优点也是缺点,直接在内存中拷贝,构造函数是不会执行的,优点就是减少了约束, 缺点也是减少了约束,需要在实际应用时考虑使用。

四、原型模型在框架中的应用

 

内容来自用户分享和网络整理,不保证内容的准确性,如有侵权内容,可联系管理员处理 点击这里给我发消息
标签: