优雅的克隆——原型模式

作者: 李斯维 | 来源:发表于2017-05-25 17:44 被阅读35次

    原型模式是一个创建型模式。原型二字表明了该模式应该由一个样板实例,用户从这个样板对象中复制出一个内部属性一致的对象,这个过程也就是俗称的克隆。被复制的实例就是原型,这个原型是可定制的。原型模式多用于创建复杂的或者构造好事的实例,因为这种情况下,复制一个已经存在的实例比重新创建一个更高效。

    综上总结一下,原型模式的定义就是:用原型实例指定创建对象的种类,并通过拷贝这些原型创建新的对象。

    原型模式的使用场景:

    • 类初始化需要消耗非常多的资源,这个资源包括数据、硬件资源等,通过原型拷贝避免这些消耗;
    • 通过 new 产生一个对象需要非常繁琐的数据准备或访问权限,这时可以使用原型模式;
    • 一个对象需要提供给其他对象访问,而且各个调用者可能都需要修改其值时,可以考虑使用原型模式拷贝多个对象供调用者使用,即保护性拷贝;

    需要注意的是,通过实现Cloneable接口的原型模式再调用 clone 函数构造实例时并不一定比通过new操作速度快,只有当通过 new 构造对象较为耗时或成本较高时,通过 clone 方法才能够活的效率上的提升。因此再使用 Cloneable 时需要考虑构建对象的成本以及做一些效率上的测试。当然,实现原型模式也不一定非要实现 Cloneable 接口,也有其他的实现方式。

    但是首先,我们还是使用 Cloneable 接口来实现一个原型模式,以便对原型模式有一个简单的理解:

    import java.util.ArrayList;
    import java.util.List;
    
    public class Prototype implements Cloneable {
    
        private String text;
        private List<String> textList;
    
        public Prototype() {
            textList = new ArrayList<>();
        }
    
        @Override
        public Prototype clone() throws CloneNotSupportedException {
            Prototype prototype = (Prototype) super.clone();
            prototype.text = this.text;
            prototype.textList = this.textList;
            return prototype;
        }
    
        public String getText() {
            return text;
        }
    
        public void setText(String text) {
            this.text = text;
        }
    
        public List<String> getTextList() {
            return textList;
        }
    
        public void addToList(String text) {
            this.textList.add(text);
        }
    
        @Override
        public String toString() {
            return "Prototype{" +
                    "text='" + text + '\'' +
                    ", textList=" + textList +
                    '}';
        }
    }
    
    

    上面是一个简单的原型模式,该类通过 clone 函数以实现对原型对象的克隆。特别注意的是,这个方法并不是 Cloneable 接口中的,二是 Object 中的方法。 Cloneable是一个标识接口,它表明这个类的对象是可拷贝的。如果没有实现 Cloneable 接口却调用了clone 函数将抛出异常,在这个示例中,我们通过实现 Cloneable 接口和覆写 clone 方法实现了原型模式。

    下面我们进行一下测试:

    Prototype prototype = new Prototype();
    prototype.setText("the first class");
    prototype.addToList("the first class in list");
    
    Log.i("swifter", prototype.toString());
    
    try {
        Prototype second = prototype.clone();
        second.setText("the second class");
        second.addToList("the second class in list");
        Log.i("swifter", second.toString());
    } catch (CloneNotSupportedException e) {
        e.printStackTrace();
    }
    

    结果:

    05-25 09:15:46.848 2544-2544/? I/swifter: Prototype{text='the first class', textList=[the first class in list]}
    05-25 09:15:46.849 2544-2544/? I/swifter: Prototype{text='the second class', textList=[the first class in list, the second class in list]}
    

    可见这种原型模式是没有问题的。至此,我们演示了原型模式的概念和一种实现方式。

    但这里仍然会有一个问题:假如我们再此时再打印一下原型对象的话,就会发现如下结果:

    05-25 09:39:01.278 3496-3496/lic.swifter.note.pattern.c4 I/swifter: Prototype{text='the first class', textList=[the first class in list]}
    05-25 09:39:01.278 3496-3496/lic.swifter.note.pattern.c4 I/swifter: Prototype{text='the second class', textList=[the first class in list, the second class in list]}
    05-25 09:39:01.278 3496-3496/lic.swifter.note.pattern.c4 I/swifter: Prototype{text='the first class', textList=[the first class in list, the second class in list]}
    

    我们仅仅修改了克隆出来的兑现,为什么连原型对象也修改了呢?这就是在原型模式中很重要的浅拷贝和深拷贝了。

    浅拷贝和深拷贝

    我们都知道在 JAVA 中存在两种类型的数据:一种是基本数据类型(共有八种:charbytebooleanshortintlongfloatdouble),另一种就是引用数据类型了。对于引用数据类型,学过 C++ 的理解肯定会很深刻,因为这个东西非常像 C 或 C++ 中的指针类型,它并不包含所代表的对象的数据,而是一个地址,这个地址指向了这个对象。

    那么对于这两种数据类型,深拷贝与浅拷贝又该怎么理解呢?很简单,只要理解了引用数据类型这两个概念就变得非常容易了:

    深拷贝会拷贝所有的属性,并拷贝属性指向的动态分配的内存。当对象和它所引用的对象一起拷贝时即发生深拷贝。深拷贝相比于浅拷贝速度较慢并且花销较大。

    浅拷贝是按位拷贝对象,它会创建一个新对象,这个对象有着原始对象属性值的一份精确拷贝。如果属性是基本类型,拷贝的就是基本类型的值;如果属性是内存地址(引用类型),拷贝的就是内存地址 ,因此如果其中一个对象改变了这个地址,就会影响到另一个对象。

    举例来说更加清楚:对象A1中包含对B1的引用,B1中包含对C1的引用。浅拷贝A1得到A2,A2 中依然包含对B1的引用,B1中依然包含对C1的引用。深拷贝则是对浅拷贝的递归,深拷贝A1得到A2,A2中包含对B2(B1的copy)的引用,B2 中包含对C2(C1的copy)的引用。

    那么理解了深浅拷贝这两个概念,那么结合上面所说的现象,我们很容易能够得出一个结论:

    Object类里的clone()方法仅仅用于浅拷贝(拷贝基本成员属性,对于引用类型仅返回指向改地址的引用)

    所以在进行拷贝时,我们就应该谨慎使用Object中的clone函数,因为其仅仅进行浅拷贝,在很多情况下不符合我们的要求。如果不经意使用了这个函数而又在其他地方更改了其中的引入数据,那么很有可能造成数据异常等业务上的问题。

    那么我们应该如何进行深拷贝呢,说白了那就是在clone函数中多做一些事情,这些事情当然就是对引用数据对象的创建了。

    举个例子,假如我们有如下的对象:

    public class Person implements Cloneable{
        private int age;
        private String name;
    
        public Person(Integer age, String name) {
            super();
            this.age = age;
            this.name = name;
        }
    }
    

    那么对于这个类的clone函数应该怎么写呢?我们知道age是基本数据类型,这个用Object的方法就能帮我们做了,那这个String类型的就需要我们操作了:

    @Override
    protected Object clone() throws CloneNotSupportedException {
        Person person = super.clone();
        person.name = new String(this.name);
        return person;
    }
    

    相关文章

      网友评论

        本文标题:优雅的克隆——原型模式

        本文链接:https://www.haomeiwen.com/subject/foyzxxtx.html