设计模式--原型模式

于 2021-09-24 21:37:42 发布
阅读量200 收藏
点赞数
分类专栏： 设计模式 Java 文章标签： java 设计模式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/m0_46633875/article/details/120461702
版权

原型模式

1.概述

原型模式主要解决的是创建重复对象的问题。而这部分对象内容本身比较复杂，因此获取相关对象数据耗时较长，所以采用复制的方式节省时间。

2.介绍

原型模式包含如下角色：

  • 抽象原型类：规定了具体原型对象必须实现的的 clone() 方法。
  • 具体原型类：实现抽象原型类的 clone() 方法，它是可被复制的对象。
  • 访问类：使用具体原型类中的 clone() 方法来复制新的对象。
    结构：
    在这里插入图片描述

3.引例

这里我们采用批量生产手机为例

4.原始的设计

我们可能采用不断new的方法却常见相同的结构的对象。
4.1 类图
在这里插入图片描述
4.2 代码

public class Phone {
    private  String name;
    private String  type;
    private String version;
    private Processor processor;

    public  Phone(){}
    public Phone(String name, String type, String version) {
        this.name = name;
        this.type = type;
        this.version = version;
    }

    public String getName() {
        return name;
    }

    public String getType() {
        return type;
    }

    public String getVersion() {
        return version;
    }

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

    public void setType(String type) {
        this.type = type;
    }

    public void setVersion(String version) {
        this.version = version;
    }

    public Phone setProcessor(Processor processor) {
        this.processor = processor;
        return this;
    }

    public Processor getProcessor() {
        return processor;
    }
}


public class Processor {
    private String name;

    public Processor(){}
    public Processor(String name) {
        this.name = name;
    }

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

    }

    public String getName() {
        return name;
    }
}


public class PhoneFactory {

    public Phone createPhone(String name, String type, String version,Processor processor){
        return new Phone(name,type,version).setProcessor(processor);
    }
}


public class TestOne {

    private  PhoneFactory phoneFactory;
    @Before
    public void init(){
        phoneFactory=new PhoneFactory();
    }
    @Test
    public void test01(){
        Phone phone1 = phoneFactory.createPhone("华为 Mate30", "MAR-AL00", "2.0.0.184",new Processor("Hisilicon Kirin 710"));
        Phone phone2 = phoneFactory.createPhone("华为 Mate30", "MAR-AL00", "2.0.0.184",new Processor("Hisilicon Kirin 710"));
        Phone phone3 = phoneFactory.createPhone("华为 Mate30", "MAR-AL00", "2.0.0.184",new Processor("Hisilicon Kirin 710"));
        Phone phone4 = phoneFactory.createPhone("华为 Mate30", "MAR-AL00", "2.0.0.184",new Processor("Hisilicon Kirin 710"));
        Phone phone5 = phoneFactory.createPhone("华为 Mate30", "MAR-AL00", "2.0.0.184",new Processor("Hisilicon Kirin 710"));
        System.out.println("phone1: "+phone1.getName()+"phone1-hashCOde: "+phone1.hashCode()+" phone1-processor-name: " +phone1.getProcessor().getName()+" phone1-processor-hashCOde: "+phone1.getProcessor().hashCode());
        System.out.println("phone2: "+phone2.getName()+"phone2-hashCOde: "+phone2.hashCode()+" phone2-processor-name: " +phone2.getProcessor().getName()+" phone2-processor-hashCOde: "+phone2.getProcessor().hashCode());
        System.out.println("phone3: "+phone3.getName()+"phone3-hashCOde: "+phone3.hashCode()+" phone3-processor-name: " +phone3.getProcessor().getName()+" phone3-processor-hashCOde: "+phone3.getProcessor().hashCode());
        System.out.println("phone4: "+phone4.getName()+"phone4-hashCOde: "+phone4.hashCode()+" phone4-processor-name: " +phone4.getProcessor().getName()+" phone4-processor-hashCOde: "+phone4.getProcessor().hashCode());
        System.out.println("phone5: "+phone5.getName()+"phone5-hashCOde: "+phone5.hashCode()+" phone5-processor-name: " +phone5.getProcessor().getName()+" phone5-processor-hashCOde: "+phone5.getProcessor().hashCode());
    }
}

4.3 结果

phone1: 华为 Mate30phone1-hashCOde: 2027961269 phone1-processor-name: Hisilicon Kirin 710 phone1-processor-hashCOde: 1586270964
phone2: 华为 Mate30phone2-hashCOde: 1642360923 phone2-processor-name: Hisilicon Kirin 710 phone2-processor-hashCOde: 1343441044
phone3: 华为 Mate30phone3-hashCOde: 693632176 phone3-processor-name: Hisilicon Kirin 710 phone3-processor-hashCOde: 326549596
phone4: 华为 Mate30phone4-hashCOde: 1364335809 phone4-processor-name: Hisilicon Kirin 710 phone4-processor-hashCOde: 458209687
phone5: 华为 Mate30phone5-hashCOde: 233530418 phone5-processor-name: Hisilicon Kirin 710 phone5-processor-hashCOde: 683287027
------------------------------------------------------------------
可以看出五个phone的hashCode是不同的，且每个phone的processor的hashCode也不同，成功创建。

4.4 分析

1)优点是比较好理解，简单易操作。
2)在创建新的对象时，总是需要重新获取原始对象的属性，如果创建的对象比较复杂时，效率较低。
3)总是需要重新初始化对象，而不是动态地获得对象运行时的状态，不够灵活。

5. 用原型模式改善

5.1 示例：利用clone进行复制

改进的思路分析
思路:Java 中 Object类是所有类的根类，Object类提供了一个clone()方法，该方法可以将一个Java对象复制一份﹐但是需要实现clone 的Java类必须要实现一个接口Cloneable,该接口表示该类能够复制且具有复制的能力=→>原型模式。

5.1.2 代码：
phone实现Cloneable接口

public class Phone implements Cloneable{
    private  String name;
    private String  type;
    private String version;
    private Processor processor;

    public Phone(){}
    public Phone(String name, String type, String version) {
        this.name = name;
        this.type = type;
        this.version = version;
    }

    public String getName() {
        return name;
    }

    public String getType() {
        return type;
    }

    public String getVersion() {
        return version;
    }

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

    public void setType(String type) {
        this.type = type;
    }

    public void setVersion(String version) {
        this.version = version;
    }

    public Phone setProcessor(Processor processor) {
        this.processor = processor;
        return this;
    }

    public Processor getProcessor() {
        return processor;
    }

    @Override
    protected Object clone() throws CloneNotSupportedException {
        Phone phone=null;
        phone=(Phone) super.clone();
        return phone;
    }
}

改进phoneFactory（调用clone）

public class PhoneFactory {

    private Phone phone=null;
    public Phone createPhone(String name, String type, String version,Processor processor) throws CloneNotSupportedException {
        if(phone==null){
            phone=new Phone(name,type,version).setProcessor(processor);
            return phone;
        }
        else{
            return (Phone) phone.clone();
        }

    }
}

测试


```cpp
phone1: 华为 Mate30phone1-hashCOde: 2027961269 phone1-processor-name: Hisilicon Kirin 710 phone1-processor-hashCOde: 1586270964
phone2: 华为 Mate30phone2-hashCOde: 1642360923 phone2-processor-name: Hisilicon Kirin 710 phone2-processor-hashCOde: 1586270964
phone3: 华为 Mate30phone3-hashCOde: 1343441044 phone3-processor-name: Hisilicon Kirin 710 phone3-processor-hashCOde: 1586270964
phone4: 华为 Mate30phone4-hashCOde: 693632176 phone4-processor-name: Hisilicon Kirin 710 phone4-processor-hashCOde: 1586270964
phone5: 华为 Mate30phone5-hashCOde: 326549596 phone5-processor-name: Hisilicon Kirin 710 phone5-processor-hashCOde: 1586270964

5.2 问题

我们发现测试中5个phone的hashCode不一样，正常创建，但是这5个phone的processor的hasHCode一样，这里他们引用了同一个实例对象，那么修改其中一个，其他的也会被修改。这就涉及浅拷贝和深拷贝。

5.3 浅拷贝和深拷贝

浅拷贝：

  1. 对于数据类型是基本数据类型的成员变量,浅拷贝会直接进行值传递，也就是将该属性值复制一份给新的对象。对于数据类型是引用数据类型的成员变量，比如说成员变量是某个数组、某个类的对象等，那么浅拷贝会进行引用传递，也就是只是将该成员变量的引用值(内存地址)复制一份给新的对象。因为实际上两个对象的该成员变量都指向同一个实例。在这种情况下，在一个对象中修改该成员变量会影响到另一个对象的该成员变量值。
    2.前面我们采用的就是浅拷贝
    3.浅拷贝是使用默认的 clone()方法来实现sheep = (Sheep) super.clone();

深拷贝：
1.复制对象的所有基本数据类型的成员变量值
2.为所有引用数据类型的成员变量申请存储空间，并复制每个引用数据类型成员变量所引用的对象，直到该对象可达的所有对象。也就是说，对象进行深拷贝要对整个对象(包括对象的引用类型)进行拷贝
3.深拷贝实现方式1:重写clone方法来实现深拷贝
4. 深拷贝实现方式2:通过对象序列化实现深拷贝(推荐)

5.4 使用clone实现深拷贝（每个用到的类需要实现clone）

processor类中：

public class Processor implements  Cloneable{
    private String name;

    public Processor(){}
    public Processor(String name) {
        this.name = name;
    }

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

    }
    public String getName() {
        return name;
    }

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

Phone类中

  @Override
    protected Object clone() throws CloneNotSupportedException {
        Phone phone=null;
        phone=(Phone) super.clone();
        //克隆processor属性
        phone.setProcessor((Processor) phone.getProcessor().clone());
        return phone;
    }

测试代码不变：

phone1: 华为 Mate30phone1-hashCOde: 2027961269 phone1-processor-name: Hisilicon Kirin 710 phone1-processor-hashCOde: 1586270964
phone2: 华为 Mate30phone2-hashCOde: 1642360923 phone2-processor-name: Hisilicon Kirin 710 phone2-processor-hashCOde: 1343441044
phone3: 华为 Mate30phone3-hashCOde: 693632176 phone3-processor-name: Hisilicon Kirin 710 phone3-processor-hashCOde: 326549596
phone4: 华为 Mate30phone4-hashCOde: 1364335809 phone4-processor-name: Hisilicon Kirin 710 phone4-processor-hashCOde: 458209687
phone5: 华为 Mate30phone5-hashCOde: 233530418 phone5-processor-name: Hisilicon Kirin 710 phone5-processor-hashCOde: 683287027
-------------------------------------------------------
可以看出五个phone的hashCode是不同的，且每个phone的processor的hashCode也不同，成功创建。可以实现深拷贝。

5.5 通过对象序列化实现深拷贝

只需要在需要拷贝的类中写，引用类型也可以完成拷贝。

改变Phone 的clone方法

 public Object copyClone() {
        ByteArrayOutputStream bos=null;
        ObjectOutputStream oos=null;
        ByteArrayInputStream bis=null;
        ObjectInputStream ois=null;
        Phone copyPhone=null;
        try{
            //序列化(将当前对象序列化）
            bos= new ByteArrayOutputStream();
            oos=new ObjectOutputStream(bos);
            oos.writeObject(this);

            //反序列化(根据当前对象的流复制一份，所有属性都能被克隆包括引用类型)
            bis=new ByteArrayInputStream(bos.toByteArray());
            ois=new ObjectInputStream(bis);
            copyPhone=(Phone) ois.readObject();


        }catch (Exception e){
            System.out.println(e.getMessage());
        }
        finally {
            try {
                bis.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
                bos.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
                if (oos != null) {
                    oos.close();
                }
            } catch (IOException e) {
                e.printStackTrace();


            }
            try {
                if (ois != null) {
                    ois.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
            return copyPhone;
        }

    }

测试：

phone1: 华为 Mate30phone1-hashCOde: 326549596 phone1-processor-name: Hisilicon Kirin 710 phone1-processor-hashCOde: 683287027
phone2: 华为 Mate30phone2-hashCOde: 1552787810 phone2-processor-name: Hisilicon Kirin 710 phone2-processor-hashCOde: 1361960727
phone3: 华为 Mate30phone3-hashCOde: 739498517 phone3-processor-name: Hisilicon Kirin 710 phone3-processor-hashCOde: 125130493
phone4: 华为 Mate30phone4-hashCOde: 914504136 phone4-processor-name: Hisilicon Kirin 710 phone4-processor-hashCOde: 166239592
phone5: 华为 Mate30phone5-hashCOde: 991505714 phone5-processor-name: Hisilicon Kirin 710 phone5-processor-hashCOde: 385242642

成功！

6.总结

  1. 创建新的对象比较复杂时，可以利用原型模式简化对象的创建过程，同时够提高效率不用重新初始化对象，而是动态地获得对象运行时的状态。
  2. 如果原始对象发生变化(增加或者减少属性)，其它克隆对象的也会发生相应的变化，无需修改代码在实现深克隆的时候可能需要比较复杂的代码。
  3. 缺点:需要为每一个类配备一个克隆方法，这对全新的类来说不是很难，但对已有的类进行改造时，需要修改其源代码，违背了ocp原则，这点请同学们注意.
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

霓乤

谢谢支持，菜鸟会继续努力..

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值