原型模式——NWU_LK

最新推荐文章于 2021-11-20 11:14:20 发布

NWU_LK

最新推荐文章于 2021-11-20 11:14:20 发布

阅读量178

点赞数

分类专栏：设计模式文章标签：设计模式

本文链接：https://blog.csdn.net/NWU_LK/article/details/108053611

版权

设计模式专栏收录该内容

9 篇文章 0 订阅

订阅专栏

原型模式

基本概念

原型模式是指用原型实例指定创建的种类，并且通过拷贝这些原型，创建新的对象。原型模式是一种创建型设计模式，允许一个对象创建另一个可定制的对象，无需知道创建的细节。
在这里插入图片描述
如图所示，首先我们可以看到一共有三个角色：

客户(Client)角色：客户类提出创建对象的请求；也就是我们用户使用复制粘贴的功能。
抽象原型(Prototype)角色：此角色定义了的具体原型类所需的实现的方法。也就是定义一个文件，说明一下它有被克隆复制的功能。
具体原型(Concrete Prototype)角色：实现抽象原型角色的克隆接口。就是我们的文件实现了可以被复制的功能。

我们会发现其实原型模式的核心就是Prototype（抽象原型），他需要继承Cloneable接口，并且重写Object类中的clone方法才能有复制粘贴的功能。

拷贝的分类

既然我们知道原型模式的核心就是拷贝对象，那么我们能拷贝一个对象实例的什么内容呢？这就要区分深拷贝和浅拷贝之分了。

浅拷贝：我们只拷贝对象中的基本数据类型（8种），对于数组、容器、引用对象等都不会拷贝。比如该段代码输出的结果为false和true，duoli对象和clone对象不是同一个对象，但是其friend都指向同一个对象。

//创建引用对象Dog类
class Dog{
    public String name;
    public int age;
    public Dog(String name,int age){
        this.name=name;
        this.age=age;
    }
}
class Sheep implements Cloneable{
    public String name;
    public int age;
    public Dog friend;
    public Sheep(String name,int age){
        this.name=name;
        this.age=age;
    }
    @Override
    protected Sheep clone(){
        Sheep sheep=null;
        try {
            sheep = (Sheep)super.clone();
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }
        return sheep;
    }
}
public void test() throws CloneNotSupportedException {
    Sheep duoli=new Sheep("duoli",2);
    duoli.friend= new Dog("dahuang",2);
    Sheep clone = duoli.clone();
    System.out.println(clone==duoli);
    System.out.println(clone.friend==duoli.friend);
}

深拷贝：不仅能拷贝基本数据类型，还能拷贝那些数组、容器、引用对象等，实现方式可以是引用对象实现Cloneable接口，也可是序列化接口。

实现Cloneable接口，让Sheep中的引用对象实现克隆接口，然后在Sheep类的Clone方法中，对其引用属性也进行克隆。

class Dog implements Cloneable{
    public String name;
    public int age;
    public Dog(String name,int age){
        this.name=name;
        this.age=age;
    }
    @Override
    protected Dog clone(){
        Dog dog=null;
        try {
            dog = (Dog)super.clone();
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }
        return dog;
    }
}
class Sheep implements Cloneable{
    public String name;
    public int age;
    public Dog friend;
    public Sheep(String name,int age){
        this.name=name;
        this.age=age;
    }
    @Override
    protected Sheep clone(){
        Sheep sheep=null;
        try {
            sheep = (Sheep)super.clone();
            sheep.friend=friend.clone();
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }
        return sheep;
    }
}

实现序列化接口

class Dog implements Serializable{
    public String name;
    public int age;
    public Dog(String name,int age){
        this.name=name;
        this.age=age;
    }
}
class Sheep implements Cloneable,Serializable{
    public String name;
    public int age;
    public Dog friend;
    public Sheep(String name,int age){
        this.name=name;
        this.age=age;
    }
    @Override
    protected Sheep clone(){
        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);
            return (Sheep)ois.readObject();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                bos.close();
                oos.close();
                bis.close();
                ois.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        return null;
    }
}