android设计模式二十三式（四）——原型模式（Prototype）

最新推荐文章于 2021-10-07 16:33:36 发布
最新推荐文章于 2021-10-07 16:33:36 发布
阅读量161 收藏
点赞数
分类专栏： android 设计模式 文章标签： android 设计模式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/CSDN_xiaoxiaocainiao/article/details/90169961
版权

原型模式

因为类初始化需要消耗非常多的资源，包括数据、硬件资源等，通过原型拷贝则可以避免这些消耗，而且new一个对象会经过非常繁琐的数据准备或访问权限，假若一个对象需要供给其他对象访问，而且各个对象都需要修改其值时，可以拷贝多个对象供调用者访问，即保护性拷贝，以上就是用到原型模型的场景。总而言之，及时你需要用到一个对象，还需要修改该对象部分值，保留部分值，你就可以用它。下面就结合代码来说明一下

我们有一个对象，包含了一些文本和一些对象

原型模型，主要是实现Cloneable接口和覆写Object的clone方法

1.浅拷贝

我们还是写一辆车，有品牌，重量，供应商，和拥有者的信息

/**
 * @author: hx
 * @Time: 2019/5/6
 * @Description: Car
 */
public class Car implements Cloneable {
    private String brand;
    private int weight;
    private ArrayList<String> supplier = new ArrayList<>();
    private Owner mOwner = new Owner();

    public String getBrand() {
        return brand;
    }

    public void setBrand(String brand) {
        this.brand = brand;
    }

    public int getWeight() {
        return weight;
    }

    public void setWeight(int weight) {
        this.weight = weight;
    }

    public List<String> getSupplier() {
        return supplier;
    }

    public void setSupplier(String... factoryName) {
        for (int i = 0; i < factoryName.length; i++) {
            supplier.add(factoryName[i]);
        }
    }

    public Owner getOwner() {
        return mOwner;
    }

    public void setOwner(String name, int age) {
        mOwner.setName(name);
        mOwner.setAge(age);
    }

    @Override
    public String toString() {
        return "Car{" +
                "brand='" + brand + '\'' +
                ", weight=" + weight +
                ", supplier=" + supplier +
                ", mOwner=" + mOwner +
                '}';
    }

    @Override
    public Car clone() throws CloneNotSupportedException {
        System.out.println("clone时不执行构造函数");
        Car car = (Car) super.clone();
        return car;
    }

    static class Owner {
        private String name;
        private int age;

        public String getName() {
            return name;
        }

        public void setName(String name) {
            this.name = name;
        }

        public int getAge() {
            return age;
        }

        public void setAge(int age) {
            this.age = age;
        }

        @Override
        public String toString() {
            return "Owner{" +
                    "name='" + name + '\'' +
                    ", age=" + age +
                    '}';
        }
    }
}
public static void main(String[] args) throws CloneNotSupportedException {
    Car car1 = new Car();
    car1.setBrand("保时捷");
    car1.setWeight(1895);
    car1.setOwner("张三",33);
    car1.setSupplier("车轮","方向盘");
    System.out.println(car1.toString());
    System.out.println("----------------------");
    Car car2 = car1.clone();
    System.out.println(car2.toString());
    System.out.println("----------------------");
}

输出结果：

Car{brand='保时捷', weight=1895, supplier=[车轮, 方向盘], mOwner=Owner{name='张三', age=33}}
----------------------
clone时不执行构造函数
Car{brand='保时捷', weight=1895, supplier=[车轮, 方向盘], mOwner=Owner{name='张三', age=33}}
----------------------

看起来并没有什么问题，对吧，我们来定制一下第二辆车的信息

public static void main(String[] args) throws CloneNotSupportedException {
    Car car1 = new Car();
    car1.setBrand("保时捷");
    car1.setWeight(1895);
    car1.setOwner("张三",33);
    car1.setSupplier("车轮","方向盘");
    System.out.println("car1="+car1.toString());
    System.out.println("----------------------");
    Car car2 = car1.clone();
    car2.setWeight(2000);
    car2.setOwner("李四",50);
    car2.setSupplier("底盘");
    System.out.println("car1="+car1.toString());
    System.out.println("----------------------");
    System.out.println("car2="+car2.toString());
    System.out.println("----------------------");
}

输出结果：

car1=Car{brand='保时捷', weight=1895, supplier=[车轮, 方向盘], mOwner=Owner{name='张三', age=33}}
----------------------
clone时不执行构造函数
car1=Car{brand='保时捷', weight=1895, supplier=[车轮, 方向盘, 底盘], mOwner=Owner{name='李四', age=50}}
----------------------
car2=Car{brand='保时捷', weight=2000, supplier=[车轮, 方向盘, 底盘], mOwner=Owner{name='李四', age=50}}
----------------------

可以看到，我们只修改了第二辆车的信息，但是第一辆车的也一起改了，只是第一辆车的原本基本类型的值没有修改，所以可以得出结论，浅拷贝，在拷贝引用的时候，并没有拷贝对象，只是拷贝了对象的引用，所以我们需要对非基本类型也进行拷贝，即深拷贝。

2.深拷贝

在运用原型模式时建议还是用深拷贝，下面我们把上面的浅拷贝改成深拷贝

要注意的是，拷贝的时候是不走构造函数的

/**
 * @author: hx
 * @Time: 2019/5/6
 * @Description: Car
 */
public class Car implements Cloneable {
    private String brand;
    private int weight;
    private ArrayList<String> supplier = new ArrayList<>();
    private Owner mOwner = new Owner();

    public String getBrand() {
        return brand;
    }

    public void setBrand(String brand) {
        this.brand = brand;
    }

    public int getWeight() {
        return weight;
    }

    public void setWeight(int weight) {
        this.weight = weight;
    }

    public List<String> getSupplier() {
        return supplier;
    }

    public void setSupplier(String... factoryName) {
        for (int i = 0; i < factoryName.length; i++) {
            supplier.add(factoryName[i]);
        }
    }

    public Owner getOwner() {
        return mOwner;
    }

    public void setOwner(String name, int age) {
        mOwner.setName(name);
        mOwner.setAge(age);
    }

    @Override
    public String toString() {
        return "Car{" +
                "brand='" + brand + '\'' +
                ", weight=" + weight +
                ", supplier=" + supplier +
                ", mOwner=" + mOwner +
                '}';
    }

    @Override
    public Car clone() throws CloneNotSupportedException {
        System.out.println("clone时不执行构造函数");
        Car car = (Car) super.clone();
        car.supplier = (ArrayList<String>) this.supplier.clone();
        car.mOwner = (Owner) this.mOwner.clone();
        return car;
    }

    static class Owner implements Cloneable{
        private String name;
        private int age;

        public String getName() {
            return name;
        }

        public void setName(String name) {
            this.name = name;
        }

        public int getAge() {
            return age;
        }

        public void setAge(int age) {
            this.age = age;
        }

        @Override
        public String toString() {
            return "Owner{" +
                    "name='" + name + '\'' +
                    ", age=" + age +
                    '}';
        }

        @Override
        protected Object clone() throws CloneNotSupportedException {
            Owner owner = (Owner) super.clone();
            return owner;
        }
    }

}

看一下运行结果

public static void main(String[] args) throws CloneNotSupportedException {
    Car car1 = new Car();
    car1.setBrand("保时捷");
    car1.setWeight(1895);
    car1.setOwner("张三",33);
    car1.setSupplier("车轮","方向盘");
    System.out.println("car1="+car1.toString());
    System.out.println("----------------------");
    Car car2 = car1.clone();
    car2.setWeight(2000);
    car2.setOwner("李四",50);
    car2.setSupplier("底盘");
    System.out.println("car1="+car1.toString());
    System.out.println("----------------------");
    System.out.println("car2="+car2.toString());
    System.out.println("----------------------");
}

输出结果：

car1=Car{brand='保时捷', weight=1895, supplier=[车轮, 方向盘], mOwner=Owner{name='张三', age=33}}
----------------------
clone时不执行构造函数
car1=Car{brand='保时捷', weight=1895, supplier=[车轮, 方向盘], mOwner=Owner{name='张三', age=33}}
----------------------
car2=Car{brand='保时捷', weight=2000, supplier=[车轮, 方向盘, 底盘], mOwner=Owner{name='李四', age=50}}
----------------------

 可以看到，深拷贝的之后，再修改拷贝对象就不会对原始对象的值有所影响。

为了防止遗漏，一般都是将所有的值都会进行一次赋值，即

    @Override
    public Car clone() throws CloneNotSupportedException {
        System.out.println("clone时不执行构造函数");
        Car car = (Car) super.clone();
        car.brand = this.brand;
        car.weight = this.weight;
        car.supplier = (ArrayList<String>) this.supplier.clone();
        car.mOwner = (Owner) this.mOwner.clone();
        return car;
    }



    @Override
    protected Object clone() throws CloneNotSupportedException {
        Owner owner = (Owner) super.clone();
        owner.name = this.name;
        owner.age = this.age;
        return owner;
    }

 在android中，其实还有的会将赋值行为放到构造函数中，然后在clone方法中直接new一个自己的对象。如Intent对象

/**
     * Copy constructor.
     */
    public Intent(Intent o) {
        this(o, COPY_MODE_ALL);
    }

    private Intent(Intent o, @CopyMode int copyMode) {
        this.mAction = o.mAction;
        this.mData = o.mData;
        this.mType = o.mType;
        this.mPackage = o.mPackage;
        this.mComponent = o.mComponent;

        if (o.mCategories != null) {
            this.mCategories = new ArraySet<>(o.mCategories);
        }

        if (copyMode != COPY_MODE_FILTER) {
            this.mFlags = o.mFlags;
            this.mContentUserHint = o.mContentUserHint;
            this.mLaunchToken = o.mLaunchToken;
            if (o.mSourceBounds != null) {
                this.mSourceBounds = new Rect(o.mSourceBounds);
            }
            if (o.mSelector != null) {
                this.mSelector = new Intent(o.mSelector);
            }

            if (copyMode != COPY_MODE_HISTORY) {
                if (o.mExtras != null) {
                    this.mExtras = new Bundle(o.mExtras);
                }
                if (o.mClipData != null) {
                    this.mClipData = new ClipData(o.mClipData);
                }
            } else {
                if (o.mExtras != null && !o.mExtras.maybeIsEmpty()) {
                    this.mExtras = Bundle.STRIPPED;
                }

                // Also set "stripped" clip data when we ever log mClipData in the (broadcast)
                // history.
            }
        }
    }

    @Override
    public Object clone() {
        return new Intent(this);
    }

 执行Intent的clone方法时，实际上是重新new了一个对象，具体是选择clone对象还是new一个对象，就看实际创建对象的成本和场景，如果构造很麻烦或者成本太高，还是选择clone效率会高一点。

优点

  • 可以解决复杂对象创建时消耗过多的问题，在某些场景下提升创建对象的效率。
  • 保护性拷贝，可以防止外部调用者对对象的修改，保证这个对象是只读的。

缺点

  • 拷贝对象时不会执行构造函数。
  • 有时需要考虑深拷贝和浅拷贝的问题。
csdn_xiaoxiaocainiao
关注
专栏目录
设计模式（十六）原型模式
Android进阶三部曲 - 刘望舒
06-26 3026
公众号有同学留言设计模式，才发现好久没有写设计模式了。关于创建型设计模式只差原型模式没写了，这一篇就来填补这个空缺。
Android设计模式详解之原型模式
最新发布
故不积跬步无以至千里
12-21 643
原型模式是一个创建型设计模式。用原型实例指定创建对象的种类，并通过复制这些原型创建新的对象。类初始化需要消耗非常多的资源，这个资源包括数据、硬件资源，通过原型复制避免这些消耗；通过new产生一个对象需要非常繁琐的数据准备或访问权限；一个对象需要提供给其他对象访问，而且各个调用者可能都需要修改其值时，可以考虑使用原型模式复制多个对象供调用者使用，即保护性拷贝。
Android常见设计模式——原型模式（Prototype Pattern）
梦否
10-07 299
前言 在23种常见设计模式概述——GoF 23（四人帮，Gang of Four）一文中提到过设计模式可以分为三种类型，分别为 创建型模式 结构型模式 行为型模式 1. 原型模式 这里介绍的原型模式(Prototype Pattern)属于第一种类型，即创建型模式。对于创建型模式，侧重点也还是关注于如何生成新的对象。在原型模式中，通过复制一个现有的对象来生成新的对象，而不是通过实例化的方式。当复制一个对象时，新的对象将拥有与原对象相同的属性和方法。被复制的实例就是我们所称的“原型”。 在创建一个对象比较
Android设计模式之——原型模式
Davis
10-23 6902
一、介绍原型模式是一个创建型的模式。原型二字表明了该模型应该有一个样板实例，用户从这个样板对象中复制出一个内部属性一致的对象，这个过程也就是我们俗称的“克隆”。被复制的实例就是我们所称的“原型”，这个原型也是可定制的。原型模型多用于创建复杂的或者构造耗时的实例，因为这种情况下，复制一个已经存在的实例可使程序运行更高效。二、定义用原型实例指定创建对象的种类，并通过拷贝这些原型创建新的对象。三、使用场景
Android开发学习笔记之设计模式——原型模式&建造者模式
qq_36425800的博客
01-10 389
文章目录Android开发学习笔记之设计模式——原型模式&建造者模式原型模式概述应用场景优缺点实现建造者模式概述应用场景优缺点实现 Android开发学习笔记之设计模式——原型模式&建造者模式 原型模式 概述 在开发过程中，我们经常会遇到这样的问题，如果我们想要创建一个非常复杂的对象，那我们可能需要进行相当多的处理，尤其是数据类，通常都存在很多成员变量，而其中很多变量还是需要通过I/O操作获取的，此时创建一个新的对象的成本就显得很高了。此时，我们或许会想，如果存在一种方法可以复制原有的对象就
创建型设计模式之二——原型模式
技术人生
02-19 136
博客结构1.为什么2.是什么3.怎么用（1）.网络层4.源码解析5.巨人肩膀 1.为什么 一种更高效的对象创建方式。利用原型对象来复制产生新的对象。 2.是什么 利用标记来实现新的对象！ 3.怎么用 （1）.网络层 4.源码解析 1.克隆比直接创建效率更高吗？ （1）实例： 对象的创建和克隆比对： long newObjectStart = System.currentTimeMillis(); List<Student> newStudentList = new
设计模式之（2）——原型模式
茅屋
08-30 851
设计模式之（2）——原型模式基本介绍定义原型模式（Prototype Pattern）：用原型实例指定创建对象的种类，并通过拷贝这些原型创建新的对象。UML类图使用场景一个对象需要提供给其他对象访问，而各个调用者都需要修改其值，可以利用原型模式赋值多个拷贝对象公其他调用者使用。使用优点减少了类对象创建时的资源消耗。通过原型模式，直接操作内存中的数据，对于一些复杂对象的创建，大大减少了资源的消耗。实现
Java设计模式 —— 原型模式（Prototype）
许浑的博客
04-13 306
Java设计模式 —— 原型模式（Prototype） 定义 原型模式：用原型实例指定创建对象的种类，并且通过拷贝这些原型来创建新的对象。 特征： 原型模式是通过拷贝一个现有对象生成新对象的。 浅拷贝实现 Cloneable 接口重写，通过 clone 的方法创建一个对象 深拷贝是通过实现 Serializable 读取二进制流 代码实现 实现了 Cloneable 接口的抽象类 pub...
设计模式篇（五）——原型模式
catzifeng的博客
05-30 228
文章目录一、简介二、实现三、相关源码四、小结 一、简介 原型模式（Prototype Pattern） 是我们即将要学完的 创建型模式 的最后一个模式，该模式是为了优化性能而存在。 定义：通过 克隆 的方式创建一个已有对象的复制品。 使用场景：当我们对数据库进行耗时查询而得到了一个对象，我们可以将其缓存，等下次再进行同样的操作时，返回其复制后的对象。 实现要素： 在 Java 或者 Kotlin 中，使对象实现 克隆接口。 注意 浅拷贝 和 深拷贝 的区别。 原型模式 其实就是使一个类能够实现 克隆 ，
Android进阶知识树——23种设计模式详解
浅谈Android
09-10 723
创建型模式，共五种：工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式。 结构型模式，共七种：适配器模式、装饰器模式、代理模式、外观模式、桥接模式、组合模式、享元模式。 行为型模式，共十一种：策略模式、模板方法模式、观察者模式、迭代子模式、责任链模式、命令模式、备忘录模式、状态模式、访问者模式、中介者模式、解释器模式 创建模式： 1、 定义 2、角色 3、优点 4、使用场景 5、使用实例 ...
Android 23种设计模式全面解析
鸿蒙开发知识记录
06-23 2727
一、设计模式的分类 总体来说设计模式分为三大类： 创建型模式，共五种：工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式。 结构型模式，共七种：适配器模式、装饰器模式、代理模式、外观模式、桥接模式、组合模式、享元模式。 行为型模式，共十一种：策略模式、模板方法模式、观察者模式、迭代子模式、责任链模式、命令模式、备忘录模式、状态模式、访问者模式、中介者模式、解释器模式。 其实还有两类：并发型模式和线程池模式。用一个图片来整体描述一下： 二、设计模式的六大原则 总原则：开闭原则（.
python常用设计模式
冠军阿狗的博客
06-09 926
python常用设计模式一、设计模式基础1. 基础知识2. 面向对象设计SOLID原则3. 设计模式分类4. 简单工厂模式（Simple Factory Pattern）二、创建型模式（5种）1. 工厂方法模式（Factory Pattern）2. 抽象工厂模式（Abstract Factory Pattern）3. 建造者模式（Builder Pattern）4. 单例模式（Singleton ...
膜拜大佬！java设计模式刘伟课后答案
CHAMPION8888的博客
07-02 3615
一、先来解读：23种设计模式要点 1.单例模式（Singleton Pattern） 2.工厂模式 3.抽象工厂模式（Abstract Factory Pattern） 4.模板方法模式（Template Method Pattern） 5.建造者模式（Builder Pattern） 6.代理模式（Proxy Pattern） 7.原型模式（Prototype Pattern） 8.中介者模式 9.命令模式 10.责任链模式 11.装饰模式（Decorator Pattern） 12.策略模式
linphone源码研究之callState回调——无法及时获取sip消息中正确的AudioDirection和VideoDirection
CSDN_xiaoxiaocainiao的博客
12-13 2032
需要准备的材料： 1.liphone4android-master代码，此代码已经编译过，可直接运行到手机上 需要的伙伴可以自行下载： https://github.com/treasure-lau/Linphone4Android 2.linphone-3.11.1，此代码为linphone底层源码，在linphone官网下载即可 这里项目代码和C源码并不是用一个版本，项目为3.10....
android设计模式二十三式（二十）——状态模式（State）
CSDN_xiaoxiaocainiao的博客
05-30 697
状态模式 庄陶模式非常简单，就是根据某一个类值的变化，显示不同的状态，也可以有不同的操作，我们经常会用到。 还是举个栗子： 当我们打电话的时候，有呼叫中，通话总，通话结束，还有一个是通话中有另一个人再次呼入的多方呼叫状态，根据不用的状态，我们可以选择是接听还是挂断。 /** * @author: hx * @Time: 2019/5/23 * @Description: State...
Android修改语言设置--项目需求需要修改在应用中修改系统时间
CSDN_xiaoxiaocainiao的博客
05-07 657
这里直接贴上代码，防止自己忘记try { IActivityManager am = ActivityManagerNative.getDefault(); Configuration config = am.getConfiguration(); switch (checkedLanguage) { case ViewGlobal.LANGUA...
android设计模式二十三式（五）——工厂模式（Factory）
CSDN_xiaoxiaocainiao的博客
05-16 465
工厂模式 在这一篇，我会把工厂模式和抽象工厂模式两个梵高一起来讲 1.简单工厂模式 /** * @author: hx * @Time: 2019/5/6 * @Description: Producer */ public interface Car { /** * 车的基本方法和属性 */ void brand(); } /** * @a...
android设计模式二十三式（二十三）——解释器模式（Interpreter）
CSDN_xiaoxiaocainiao的博客
05-30 410
解释器模式 在一般开发中，我们很少还是用到解释器模式，但是我们都接触过，sql语句，正则，都是一个典型的解释器模式。 解释器模式中给定一个语言，定义它的规则和标识，并定义一个解释器，这个解释器使用该标识来解释语言中的句子。 先看一下解释器模式的一些成员的定义： 抽象解释器：具体的解释任务由各个实现类完成。终结符表达式：实现与文法中的元素相关联的解释操作，通常一个解释器模式中只有一个终结表达...
设计模式在Android开发中的应用——状态模式
"这篇文档主要讨论了在Android开发中如何运用设计模式，特别是State(状态模式)，并列举了多种其他的设计模式，包括创建型、结构型和行为型模式的实例。" 在Android开发中，设计模式是提升代码可读性、可维护性和...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值