Android设计模式(三)- 原型模式

原创 2017年03月27日 16:15:20

原文地址 http://blog.csdn.net/qq_25806863/article/details/66972873

原型模式也是一种创建型设计模式,从名字就能理解,这个模式应该有一个样板实例,也就是原型,然后用户从这个原型中复制出一个内部属性一致的实例,也就是克隆。
有时,一个对象的构造比较复杂并且比较耗时时,直接从已有对象复制一个实例比重新构造出来更高效。

简书地址

定义

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

使用场景

  • 对象的初始化要消耗非常多的资源,包括硬件,数据等。可以使用原型模式避免这种资源的消耗。
  • 用new来实例化一个对象时需要非常繁琐的数据准备或访问权限时,可以使用原型模式。
  • 一个对象要供其他对象访问,而每个调用者都可能会修改他的值,这时可以考虑用原型模式拷贝多个原型的对象供各个调用者使用,不互相影响,即保护性拷贝。
  • 需要频繁的创建相似的对象时,比如在一个循环中创建对象。

这里说明一下,使用clone产生实例并不一定都比new来的快,当一些对象的构造非常简单时,new是比clone还快的。但是当对象的构造复杂起来的时候用new构造就会造成较大的成本,这时clone才能体现出效率的优势。

UML类图


其中Prototype不一定非要实现Cloneable接口,在演示的时候会有两种。

简单实现

使用Cloneable接口

原型,实现Cloneable接口:

public class Prototype implements Cloneable{ 
}

原型的实现:

public class ConcretePrototype extends Prototype {
    public String name;
    public ArrayList<String> list = new ArrayList<>();

    public ConcretePrototype() {
        System.out.println("执行了ConcretePrototype构造函数");
    }
    @Override
    public ConcretePrototype clone()  {
        ConcretePrototype prototype = null;
        try {
            prototype = (ConcretePrototype) super.clone();
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }
        return prototype;
    }
    @Override
    public String toString() {
        return "ConcretePrototype{" +
                "name='" + name + '\'' +
                ", list=" + list +
                '}';
    }
}

使用:

public class MainM {
    public static void main(String[] args) {
        ConcretePrototype concretePrototype = new ConcretePrototype();
        concretePrototype.name="yuanxing";
        concretePrototype.list.add("yuanxing1");
        concretePrototype.list.add("yuanxing2");
        concretePrototype.list.add("yuanxing3");
        ConcretePrototype cloneConcretePrototype = (ConcretePrototype) concretePrototype.clone();
        cloneConcretePrototype.name = "clone";
        System.out.println(concretePrototype.toString());
        System.out.println(cloneConcretePrototype.toString());
    }
}

输出:

通过clone方法获得一个实例,而且修改这个实例的内容并不会影响原来的实例的内容。
当然,这样也只是对基本数据类型有效。

不实现Cloneable接口

原型:

public class Prototype1 {
}

原型的实现:

public class ConcretePrototype1 extends Prototype1 {
    public String name;
    public ArrayList<String> list = new ArrayList<>();

    public ConcretePrototype1() {
        System.out.println("执行了ConcretePrototype构造函数");
    }
    public ConcretePrototype1 clone()  {
        ConcretePrototype1 prototype1 = new ConcretePrototype1() ;
        prototype1.name = this.name;
        prototype1.list=this.list;
        return prototype1;
    }
    @Override
    public String toString() {
        return "ConcretePrototype1{" +
                "name='" + name + '\'' +
                ", list=" + list +
                '}';
    }
}

使用:

public class MainM {
    public static void main(String[] args) {
        ConcretePrototype1 concretePrototype1 = new ConcretePrototype1();
        concretePrototype1.name="yuanxing";
        concretePrototype1.list.add("yuanxing1");
        concretePrototype1.list.add("yuanxing2");
        concretePrototype1.list.add("yuanxing3");
        ConcretePrototype1 cloneconcretePrototype1 = (ConcretePrototype1) concretePrototype1.clone();
        cloneconcretePrototype1.name="clone";
        System.out.println(concretePrototype1.toString());
        System.out.println(cloneconcretePrototype1.toString());
    }
}

输出的结果是有点不一样的:

直接调用Cloneable的方法是不会再次调用构造方法的,而自己new是一定会调用构造方法的。
我个人觉得这个应该是伪克隆吧,只是写了一个clone的方法,然后在方法中new出一个对象,然后要手动把自己本来的值赋值给新的对象。

问题

上面两个都测试了name这个属性,如果在克隆的对象里修改了ArrayList对象list会怎样呢?来试试:
使用:

public class MainM {
    public static void main(String[] args) {
        ConcretePrototype concretePrototype = new ConcretePrototype();
        concretePrototype.name="yuanxing";
        concretePrototype.list.add("yuanxing1");
        concretePrototype.list.add("yuanxing2");
        concretePrototype.list.add("yuanxing3");
        ConcretePrototype cloneConcretePrototype = (ConcretePrototype) concretePrototype.clone();
        cloneConcretePrototype.name = "clone";
        cloneConcretePrototype.list.add("clone1");
        System.out.println(concretePrototype.toString());
        System.out.println(cloneConcretePrototype.toString());
    }
}

发现输出并不是预期的:

修改了克隆出来的对象的list,原型中的list的值也变了。

深拷贝-浅拷贝

之所以会出现上面的情况,是因为上面的原型中使用的是浅拷贝。Cloneable的方法clone默认就是浅拷贝,浅拷贝并不是把所有字段都重新构造了一份,而是引用了原型中的字段。对于值类型,也就是基本数据类型来说,还有String类型,clone方法会进行一个拷贝,可以让拷贝的对象和原型互不干扰。但是对于引用类型(对象,集合,数组等)来说,clone方法只是让他们指向了同一个内存地址,所以修改其中一个的内容,两个都会变化。
所以对于不是基本类型的属性,在clone的时候要手动调用引用对象的clone方法进行拷贝,也就是深拷贝。
把重写的clone方法加上深拷贝

@Override
    public ConcretePrototype clone()  {
        ConcretePrototype prototype = null;
        try {
            prototype = (ConcretePrototype) super.clone();
            prototype.list = (ArrayList<String>) this.list.clone();
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }
        return prototype;
    }

然后就会得到我们期望的输出:

Android源码中的原型模式:

原型模式可能很少单独使用吧,在书中的例子举了个Intent,虽然实现了Cloneable接口,但在clone方法中是直接new的一个Intent,把原型传进去,然后复制给新的Intent:

package android.content;
public class Intent implements Parcelable, Cloneable {
    /**
     * 拷贝构造函数
     */
    public Intent(Intent o) {
        this.mAction = o.mAction;
        this.mData = o.mData;
        this.mType = o.mType;
        this.mPackage = o.mPackage;
        this.mComponent = o.mComponent;
        this.mFlags = o.mFlags;
        this.mContentUserHint = o.mContentUserHint;
        if (o.mCategories != null) {
            this.mCategories = new ArraySet<String>(o.mCategories);
        }
        if (o.mExtras != null) {
            this.mExtras = new Bundle(o.mExtras);
        }
        if (o.mSourceBounds != null) {
            this.mSourceBounds = new Rect(o.mSourceBounds);
        }
        if (o.mSelector != null) {
            this.mSelector = new Intent(o.mSelector);
        }
        if (o.mClipData != null) {
            this.mClipData = new ClipData(o.mClipData);
        }
    }
    @Override
    public Object clone() {
        return new Intent(this);
    }    
}

这里可能考虑的就是直接new比clone快吧。。

总结

原型模式主要就是拷贝对象,拷贝对象一般有两个作用
1. 保护原型不被修改,只给外部提供一个拷贝以供访问,保护性拷贝。
2. 避免构造复杂的对象时的资源消耗问题,提升创建对象的效率。

优点

  • Object的clone方法是一个本地方法,直接操作的是二进制流,性能会好很多。

缺点

  • 构造方法在clone的时候不会执行,既是优点也是缺点,使用时要注意这个潜在的问题。

Android开发中无处不在的设计模式——原型模式

不知不觉这个系列已经写了三篇了,其实很早之前就想写设计模式了,只不过怕自己误人子弟没有提笔去写。后来在实际开发中,发现设计模式可以让一个开发人员融会贯通所学的知识,为了进一步巩固自己,就写下了这一些列...
  • sbsujjbcy
  • sbsujjbcy
  • 2015年10月22日 16:20
  • 4427

Android 原型模式

原型的是一种创建的设计模式,主用来创建的复杂的对象和构建耗时的实例。通过克隆已有的对象来创建的新的对象,从而节省时间和内存。...
  • zhi184816
  • zhi184816
  • 2016年05月04日 22:30
  • 3909

<六>读<<大话设计模式>>之原型模式

原型模式也是很简单的一种模式,对于java来说已经有相应的接口了(Cloneable)。关于原型模式>是以投放简历作为例子讲解的,即我要投放很多简历,其实每个简历都一样,所以只要我写好一份,其他的复制...
  • jzhf2012
  • jzhf2012
  • 2014年10月30日 20:58
  • 1043

Java设计模式——原型模式

原型模式是为了解决一些不必要的对象创建过程。当Java JDK中提供了Cloneable接口之后,原型模式就变得异常的简单了。虽然由于Cloneable的引入使用程序变得更简单了,不过还是有一些需要说...
  • u013761665
  • u013761665
  • 2016年03月03日 13:50
  • 1843

JAVA设计模式之原型模式

定义:用原型实例指定创建对象的种类,并通过拷贝这些原型创建新的对象。 类型:创建类模式 类图: 原型模式主要用于对象的复制,它的核心是就是类图中的原型类Prototype。Prototype...
  • jason0539
  • jason0539
  • 2014年04月08日 08:22
  • 14798

设计模式--原型模式

1.设计模式分类         所谓设计模式,是前人在开发过程中总结的经验。各自有各自的使用情况。分类条件不同 设计模式的分类也不尽相同。编程之道中大致分类如下 创建型 包括 单例设计模式,简单工厂...
  • a316212802
  • a316212802
  • 2015年11月13日 18:45
  • 982

Android源码分析之原型模式

模式的定义 用原型实例指定创建对象的种类,并通过拷贝这些原型创建新的对象。 使用场景 1、类初始化需要消化非常多的资源,这个资源包括数据、硬件资源等,通过原型拷贝避免这些消耗; 2、通过 ne...
  • bboyfeiyu
  • bboyfeiyu
  • 2014年08月06日 17:44
  • 3304

我所理解的设计模式(C++实现)——原型模式(Prototype Pattern)

解决的问题: 用原型实例指定创建对象的种类,并且通过拷贝这些原型创建新的对象。这个其实和C++的拷贝构造函数的作用是一致的,实际上就是动态抽取当前对象运行时的状态。 类图结构:      ...
  • LCL_data
  • LCL_data
  • 2013年04月06日 16:01
  • 9217

设计模式(六)原型模式

一、说说鸣人的影分身 话说鸣人听了水木老师的建议偷出了卷轴并且学会了一招禁术:影分身之术。当鸣人使用影分身之术的时候就会有好多个和鸣人一模一样的人出现,就像复制出来的一样,这种影分身之术在面向对象的...
  • xingjiarong
  • xingjiarong
  • 2015年11月28日 16:13
  • 1648

设计模式之原型模式

1 原型模式概念1.1 介绍  原型模式是一个创建型的模式。原型二字表明了改模式应该有一个样板实例,用户从这个样板对象中复制一个内部属性一致的对象,这个过程也就是我们称的“克隆”。被复制的实例就是我们...
  • chenliguan
  • chenliguan
  • 2017年04月09日 17:49
  • 358
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:Android设计模式(三)- 原型模式
举报原因:
原因补充:

(最多只允许输入30个字)