原型模式

最新推荐文章于 2024-12-16 12:45:00 发布

转载最新推荐文章于 2024-12-16 12:45:00 发布 · 505 阅读

Java设计模式专栏收录该内容

24 篇文章

订阅专栏

网址链接：https://my.oschina.net/Sheamus/blog/384180

原型模式算是JAVA中最简单的设计模式了，原因是因为它已经被提供了语言级的支持，但是如果提到它的实现原理，又是最复杂的一个设计模式。

下面我们先来看看这个又简单又复杂的设计模式的定义。

定义：用原型实例指定创建对象的种类，并且通过拷贝这些原型创建新的对象。

定义比较简单，总结一下是通过实例指定种类，通过拷贝创建对象。

在JAVA语言中使用原型模式是非常简单的，这是因为Object类当中提供了一个本地方法clone，而JAVA中的任何类只要实现了Cloneable标识接口，就可以使用clone方法来进行对象的拷贝。

我们写一个简单的实例来测试一下，很简单。

public class Prototype implements Cloneable {

        private int x;

        private int y;

        private int z;

        public Prototype() {

                this.x = 2;

                this.y = 3;

                this.z = 4;

        }

        public void change() {

                this.x = 9;

                this.y = 8;

                this.z = 7;

        }

        public Prototype clone() {

                Object object = null;

                try {

                        object = super.clone();

                } catch (CloneNotSupportedException exception) {

                        throw new RuntimeException(exception);

                }

                return (Prototype) object;

        }

        public String toString() {

                return "[" + x + "," + y + "," + z + "]";

        }

        public static void main(String[] args) {

                Prototype prototype1 = new Prototype();

                prototype1.change();

                System.out.println(prototype1);

                Prototype prototype2 = prototype1.clone();

                System.out.println(prototype2);

        }

}

输出结果：

[9,8,7]

从输出结果可以看出来，clone方法将prototype1复制了一个，然后赋给了prototype2，这就像复制粘贴一样。值得注意的是，在使用Object.clone()方法去拷贝一个对象时，构造方法是不被执行的，否则prototype2实例中x，y，z的值应该为2，3，4才对，如果你觉得不够直观，可以在构造方法里写一个输出语句试试。

从原型模式的使用方式不难推断出，原型模式常使用于以下场景：

1、对象的创建非常复杂，可以使用原型模式快捷的创建对象。

2、在运行过程中不知道对象的具体类型，可使用原型模式创建一个相同类型的对象，或者在运行过程中动态的获取到一个对象的状态。

对于clone方法，它执行的是浅拷贝，也就是说如果是引用类型的属性，则它不会进行拷贝，而是只拷贝引用。

看下面这个简单的测试，就能看出来了。

class Field{

        private int a;

        public int getA() {

                return a;

        }

        public void setA(int a) {

                this.a = a;

        }

       

}



public class ShallowPrototype implements Cloneable {

        private int x;

        private int y;

        private int z;

        private Field field;

        public ShallowPrototype() {

                this.x = 2;

                this.y = 3;

                this.z = 4;

                this.field = new Field();

                this.field.setA(5);

        }

       

        public Field getField() {

                return field;

        }

        public ShallowPrototype clone() {

                Object object = null;

                try {

                        object = super.clone();

                } catch (CloneNotSupportedException exception) {

                        throw new RuntimeException(exception);

                }

                return (ShallowPrototype) object;

        }

        public String toString() {

                return "[" + x + "," + y + "," + z + "," + field.getA() + "]";

        }

        public static void main(String[] args) {

                ShallowPrototype prototype1 = new ShallowPrototype();

                System.out.println(prototype1);

                System.out.println(prototype1.getField());

                ShallowPrototype prototype2 = prototype1.clone();

                System.out.println(prototype2);

                System.out.println(prototype2.getField());

        }

}

输出结果：

[2,3,4,5]

com.prototype.Field@de6ced

[2,3,4,5]

com.prototype.Field@de6ced

可以看到我们对ShallowPrototype拷贝以后，得到一个实例prototype2，不过当我们输出field属性时，发现它们是引用的同一个对象。这当然不是我们期望得到的结果，这种情况下，我们如果修改prototype1中field的属性a的值，则prototype2中的也会跟着改变。

然而如果要实现深度拷贝，则需要将实现了Cloneable接口并重写了clone方法的类中，所有的引用类型也全部实现Cloneable接口并重写clone方法，而且需要将引用类型的属性全部拷贝一遍。

下面是一个简单的深度拷贝的例子，由上面的例子更改得到。

class Field implements Cloneable{       

        private int a;

        public int getA() {

                return a;

        }

        public void setA(int a) {

                this.a = a;

        }

       

        protected Field clone() {

                Object object = null;

                try {

                        object = super.clone();

                } catch (CloneNotSupportedException exception) {

                        throw new RuntimeException(exception);

                }

                return (Field) object;

        }

       

}



public class DeepPrototype implements Cloneable {

        private int x;

        private int y;

        private int z;

        private Field field;

        public DeepPrototype() {

                this.x = 2;

                this.y = 3;

                this.z = 4;

                this.field = new Field();

                this.field.setA(5);

        }

       

        public Field getField() {

                return field;

        }

        protected DeepPrototype clone() {

                Object object = null;

                try {

                        object = super.clone();

                        ((DeepPrototype)object).field = this.field.clone();

                } catch (CloneNotSupportedException exception) {

                        throw new RuntimeException(exception);

                }

                return (DeepPrototype) object;

        }

        public String toString() {

                return "[" + x + "," + y + "," + z + "," + field.getA() + "]";

        }

        public static void main(String[] args) {

                DeepPrototype prototype1 = new DeepPrototype();

                System.out.println(prototype1);

                System.out.println(prototype1.getField());

                DeepPrototype prototype2 = prototype1.clone();

                System.out.println(prototype2);

                System.out.println(prototype2.getField());

        }

}