java设计模式之(三) - 原型模式

最新推荐文章于 2021-02-12 14:50:58 发布

蓬必生辉

最新推荐文章于 2021-02-12 14:50:58 发布

阅读量182

点赞数

分类专栏：设计模式文章标签： java 设计模式 prototype 编程语言

本文链接：https://blog.csdn.net/weixin_35783708/article/details/109604805

版权

设计模式专栏收录该内容

5 篇文章 0 订阅

订阅专栏

1. 定义

原型模式（Prototype): 用原型实例指定创建对象的种类，并且通过拷贝这些原型，创建新的对象。

在应用程序中，有些对象比较复杂，其创建过程过于复杂，而且我们又需要频繁的利用该对象，如果这个时候我们按照常规思维new该对象，那么务必会造成资源浪费，这个时候我们就希望可以利用一个已有的对象来不断对他进行复制就好了，这就是编程中的“克隆”。原型模式直接操作底层二进制流，在创建复杂对象时效率提升明显。

2.UML类图

在这里插入图片描述
说明：

Prototype：原型类，声明一个克隆自己的接口。
ConcretePrototype：具体的原型类，实现一个克隆自己的操作。
Client：让一个原型对象克隆自己，从而创建一个新的对象（属性一样）。

3.浅拷贝（克隆）

介绍

1）对于数据类型是基本数据类型的成员变量，浅拷贝会直接进行值传递，也就是将该属性值复制一份给新的对象。
2) 对于数据类型是引用数据类型的成员变量，比如说成员变量是某个数组、某个类的对象等，那么浅拷贝会进行引用传递，也就是只是将该成员变量的引用值（内存地址）复制一份给新的对象。因为实际上两个对象的该成员变量都指向同一个实例。在这种情况下，在一个对象中修改该成员变量会影响到另一个对象的该成员变量值。

实例

原型类：

public class Sheep implements Cloneable {

    private String name;
    private Integer age;
    private String color;
    private Sheep friend;
    
    public Sheep(String name, Integer age, String color) {
        this.name = name;
        this.age = age;
        this.color = color;
    }

    public String getName() {
        return name;
    }

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

    public Integer getAge() {
        return age;
    }

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

    public String getColor() {
        return color;
    }

    public void setColor(String color) {
        this.color = color;
    }

    public Sheep getFriend() {
        return friend;
    }

    public void setFriend(Sheep friend) {
        this.friend = friend;
    }

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

    /**
     * 克隆的方法
     *
     * @return
     */
    @Override
    protected Object clone() {

        Sheep sheep = null;
        try {
            sheep = (Sheep) super.clone();
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }
        return sheep;
    }
}

测试类：

public class Test {

    public static void main(String[] args) {
        Sheep sheep = new Sheep("懒羊羊",12,"屎黄色");
        sheep.setFriend(new Sheep("喜洋洋", 13, "亮白色"));

        Sheep sheep1 = (Sheep) sheep.clone();
        Sheep sheep2 = (Sheep) sheep.clone();
        Sheep sheep3 = (Sheep) sheep.clone();
        Sheep sheep4 = (Sheep) sheep.clone();
        Sheep sheep5 = (Sheep) sheep.clone();
        System.out.println("sheep1 = " + sheep1 + ",\tsheep1的friend=" + sheep1.getFriend().hashCode());
        System.out.println("sheep2 = " + sheep2 + ",\tsheep2的friend=" + sheep2.getFriend().hashCode());
        System.out.println("sheep3 = " + sheep3 + ",\tsheep3的friend=" + sheep3.getFriend().hashCode());
        System.out.println("sheep4 = " + sheep4 + ",\tsheep4的friend=" + sheep4.getFriend().hashCode());
        System.out.println("sheep5 = " + sheep5 + ",\tsheep5的friend=" + sheep5.getFriend().hashCode());
        System.out.println(sheep3 == sheep1);
    }
}

执行结果：

sheep1 = Sheep{name='懒羊羊', age=12, color='屎黄色'},	sheep1的friend=356573597
sheep2 = Sheep{name='懒羊羊', age=12, color='屎黄色'},	sheep2的friend=356573597
sheep3 = Sheep{name='懒羊羊', age=12, color='屎黄色'},	sheep3的friend=356573597
sheep4 = Sheep{name='懒羊羊', age=12, color='屎黄色'},	sheep4的friend=356573597
sheep5 = Sheep{name='懒羊羊', age=12, color='屎黄色'},	sheep5的friend=356573597
false

Process finished with exit code 0

可以看到，浅拷贝产生了两个完全不同的对象（==为false)，被复制的对象的所有属性值与原对象一致，而对其他对象的引用都仍然指向原来的对象（hashcode值相同）。

4. 深拷贝（克隆）

介绍

1）复制对象的所有基本数据类型的成员变量值。
2) 为所有引用数据类型的成员变量申请存储空间，并复制每个引用数据类型成员变量所引用的对象，直到该对象可达的所有对象。也就是说，对象进行深拷贝要对整个对象进行拷贝。

实例
深度克隆(deep clone)有两种实现方式，第一种是在浅克隆的基础上实现，第二种是通过序列化和反序列化实现。我们分别来介绍

第一种方式

public class Deep implements Serializable, Cloneable {

    private String name;
    private DeepTarget target;

    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public DeepTarget getTarget() {
        return target;
    }
    public void setTarget(DeepTarget target) {
        this.target = target;
    }

    public Deep(String name, DeepTarget target) {
        this.name = name;
        this.target = target;
    }

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

    /**
     * 深拷贝-方式1  使用clone方法
     */
    @Override
    protected Object clone() throws CloneNotSupportedException {
        Deep deep = (Deep) super.clone();
        deep.target = (DeepTarget) target.clone();
        return deep;
    }
    
	/**
     * 深拷贝-方式2 对象序列化
     *
     */
    public Object deepClone() {

        ByteArrayOutputStream bos = null;
        ObjectOutputStream oos = null;

        ByteArrayInputStream bis = null;
        ObjectInputStream ois = null;

        try {
            //序列化
            bos = new ByteArrayOutputStream();
            oos = new ObjectOutputStream(bos);
            oos.writeObject(this);

            //反序列化
            bis = new ByteArrayInputStream(bos.toByteArray());
            ois = new ObjectInputStream(bis);
            Deep deep = (Deep) ois.readObject();

            return deep;
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        } finally {
            //关闭流
        }

    }
}

public class DeepTarget implements Serializable, Cloneable {

    private String name;
    private Integer age;

    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public Integer getAge() {
        return age;
    }
    public void setAge(Integer age) {
        this.age = age;
    }
    public DeepTarget(String name, Integer age) {
        this.name = name;
        this.age = age;
    }

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

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

测试类：

public class Test {

    public static void main(String[] args) throws CloneNotSupportedException {
        Deep deep = new Deep("赵四", new DeepTarget("刘能", 22));
        Deep deep1 = (Deep) deep.clone();
        System.out.println("deep=" + deep.toString() + "deep.target=" + deep.getTarget().hashCode());
        System.out.println("deep1=" + deep1.toString() + "deep1.target=" + deep1.getTarget().hashCode());
    }
}

执行结果：

deep=Deep{name='赵四', target=DeepTarget{name='刘能', age=22}}deep.target=356573597
deep1=Deep{name='赵四', target=DeepTarget{name='刘能', age=22}}deep1.target=1735600054

Process finished with exit code 0

我们发现两个对象的引用对象的hashCode值已经不一样了，说明克隆对象的DeepTarget 属性和原型对象的DeepTarget 属性引用的不是同一个对象，实现的深度复制。

第二种方式（推荐）

	/**
     * 深拷贝-方式2 对象序列化
     *
     */
    public Object deepClone() {

        ByteArrayOutputStream bos = null;
        ObjectOutputStream oos = null;

        ByteArrayInputStream bis = null;
        ObjectInputStream ois = null;

        try {
            //序列化
            bos = new ByteArrayOutputStream();
            oos = new ObjectOutputStream(bos);
            oos.writeObject(this);

            //反序列化
            bis = new ByteArrayInputStream(bos.toByteArray());
            ois = new ObjectInputStream(bis);
            Deep deep = (Deep) ois.readObject();

            return deep;
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        } finally {
            //关闭流
        }

    }

测试类：

public class Test {

    public static void main(String[] args) throws CloneNotSupportedException {
        Deep deep = new Deep("赵四", new DeepTarget("刘能", 22));
        Deep deep1 = (Deep) deep.deepClone();
        System.out.println("deep=" + deep.toString() + "deep.target=" + deep.getTarget().hashCode());
        System.out.println("deep1=" + deep1.toString() + "deep1.target=" + deep1.getTarget().hashCode());
    }
}

执行结果：

deep=Deep{name='赵四', target=DeepTarget{name='刘能', age=22}}deep.target=692404036
deep1=Deep{name='赵四', target=DeepTarget{name='刘能', age=22}}deep1.target=284720968

Process finished with exit code 0

总结
原型模式一般和工厂方法模式一起使用，通过clone的方法创建一个对象，然后由工厂方法提供给调用者。Spring中的bean的创建实际就是两种：单例模式和原型模式。

蓬必生辉

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
java设计模式之(三) - 原型模式

1. 定义原型模式（Prototype): 用原型实例指定创建对象的种类，并且通过拷贝这些原型，创建新的对象。在应用程序中，有些对象比较复杂，其创建过程过于复杂，而且我们又需要频繁的利用该对象，如果这个时候我们按照常规思维new该对象，那么务必会造成资源浪费，这个时候我们就希望可以利用一个已有的对象来不断对他进行复制就好了，这就是编程中的“克隆”。原型模式直接操作底层二进制流，在创建复杂对象时效率提升明显。2.UML类图说明：Prototype：原型类，声明一个克隆自己的接口。Concr
复制链接

扫一扫