原型模式-通过克隆创建对象

介绍

原型模式:Specify the kinds of objects to create using a prototypical instance,and create new objects by copying this prototype.(用原型实例指定创建对象的种类,并且通过拷贝这些原型创建新的对

原型模式(Prototype Pattern)是一个比较简单的创建型设计模式,它的重点在于克隆,也就是将一个对象作为原型,对其进行复制、克隆,产生一个和原对象类似的新对象

原型模式类图

原型方法模式的角色及职责

  • 客户(Client):提出创建对象的请求,使用复制对象的方法创建新实例
  • 抽象原型(Abstract Prototype):定义所有的具体原型类所需的复制方法,接口或抽象类
  • 具体原型(Concrete Prototype):被克隆、复制的对象,此角色需要实现抽象的原型角色所要求的接口

原型模式通用类图

原型模式实现

在Java中实现原型模式特别简单,只要两步即可

  • 实现Cloneable接口
  • 重写clone()方法
public class PrototypeClass implements Cloneable{
    @Override
    protected PrototypeClass clone() throws CloneNotSupportedException {
        return (PrototypeClass)super.clone();
    }
}

原型模式已经与Java融为一体,Object类提供了一个clone()方法,且是native方法(本地原生方法,C/C++实现),所以所有类都可以通过重写Object的clone()方法或者调用clone()方法来实现对对象的克隆

不过要实现克隆的类还必须实现Cloneable接口,Cloneable是一个标识接口,表明该对象可以复制,如果没有实现该接口却调用Object的clone()方法,会抛出CloneNotSupportedException异常

我们再为上面的类添加一些成员变量,看一下再执行克隆方法的情况

public class PrototypeClass implements Cloneable{

    private String name;
    private List<String> list = new ArrayList<>();

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

    public String getName() {
        return name;
    }

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

    public List<String> getList() {
        return list;
    }

    public void setList(List<String> list) {
        this.list = list;
    }
    
    @Override
    public String toString() {
        return "[name: " + name + ", list: " + list.toString() + "]";
    }
}

测试

@Test
public void test() throws CloneNotSupportedException {
    PrototypeClass p1 = new PrototypeClass();
    p1.setName("zhangsan");
    p1.getList().add("zhangsan");
    System.out.println("p1 " + p1.toString());

    PrototypeClass p2 = p1.clone();
    p2.setName("lisi");
    p2.getList().add("lisi");
    System.out.println("p2 " + p2.toString());
    System.out.println("p1 " + p1.toString());
}

测试结果

p1 [name: zhangsan, list: [zhangsan]]
p2 [name: lisi, list: [zhangsan, lisi]]
p1 [name: zhangsan, list: [zhangsan, lisi]]

从上面的结果我们可以发现,当我们对克隆对象p2的引用类型的成员变量进行修改时,p1的list变量也改变了,这说明原始对象和克隆对象的list变量指向的是同一个对象。为什么会这样呢?

原来clone()方法只是复制成员变量的值,也就是说如果成员变量是值类型(基本数据类型和String),会复制值,而如果是引用类型,则只会复制引用但不会复制引用所指向的对象,这种复制叫做浅复制。两个对象会共享一个私有的变量,大家都能修改,这是不安全的,那是不是还有更深入的复制呢?

浅复制和深复制

  • 浅复制:将一个对象复制后,基本数据类型的变量都会重新创建,而引用类型,指向的还是原对象所指向的

  • 深复制:将一个对象复制后,不论是基本数据类型还有引用类型,都是重新创建的。简单来说,就是深复制进行了完全彻底的复制,而浅复制不彻底

我们通过直接调用Object的clone()便可以实现浅复制,但是引用地址只是复制了它的引用,那么我们想复制它指向的对象,是不是可以对成员变量也调用clone()方法复制一遍

public class PrototypeClass implements Cloneable {

    private String name;
    private ArrayList<String> list = new ArrayList<>();

    @Override
    protected PrototypeClass clone() throws CloneNotSupportedException {
        PrototypeClass newPrototypeClass = (PrototypeClass) super.clone();
        newPrototypeClass.list = (ArrayList<String>) this.list.clone();
        return newPrototypeClass;
    }

    public String getName() {
        return name;
    }

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

    public ArrayList<String> getList() {
        return list;
    }

    public void setList(ArrayList<String> list) {
        this.list = list;
    }

    @Override
    public String toString() {
        return "[name: " + name + ", list: " + list.toString() + "]";
    }
}

测试

@Test
public void test() throws CloneNotSupportedException {
    PrototypeClass p1 = new PrototypeClass();
    p1.setName("zhangsan");
    p1.getList().add("zhangsan");
    System.out.println("p1 " + p1.toString());

    PrototypeClass p2 = p1.clone();
    p2.setName("lisi");
    p2.getList().add("lisi");
    System.out.println("p2 " + p2.toString());
    System.out.println("p1 " + p1.toString());
}

测试结果

p1 [name: zhangsan, list: [zhangsan]]
p2 [name: lisi, list: [zhangsan, lisi]]
p1 [name: zhangsan, list: [zhangsan]]

使用序列化实现深复制

使用序列化实现深复制,采用流的形式读入当前对象的二进制输入,再写出二进制数据对应的对象

public class PrototypeClassSerialize implements Serializable {

    private String name;
    private ArrayList<String> list = new ArrayList<>();

    /**
     * 深复制 需要采用流的形式读入当前对象的二进制输入,再写出二进制数据对应的对象
     */
    public Object deepClone() throws IOException, ClassNotFoundException {
        // 将对象序列化到二进制流
        ByteArrayOutputStream bos = new ByteArrayOutputStream();
        ObjectOutputStream oos = new ObjectOutputStream(bos);
        oos.writeObject(this);
        // 从二进制流中读出产生的新对象
        ByteArrayInputStream bis = new ByteArrayInputStream(bos.toByteArray());
        ObjectInputStream ois = new ObjectInputStream(bis);
        return ois.readObject();
    }

    public String getName() {
        return name;
    }

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

    public ArrayList<String> getList() {
        return list;
    }

    public void setList(ArrayList<String> list) {
        this.list = list;
    }

    @Override
    public String toString() {
        return "[name: " + name + ", list: " + list.toString() + "]";
    }
}

测试

@Test
public void test() throws IOException, ClassNotFoundException {
    PrototypeClassSerialize p1 = new PrototypeClassSerialize();
    p1.setName("zhangsan");
    p1.getList().add("zhangsan");
    System.out.println("p1 " + p1.toString());

    PrototypeClassSerialize p2 = (PrototypeClassSerialize) p1.deepClone();
    p2.setName("lisi");
    p2.getList().add("lisi");
    System.out.println("p2 " + p2.toString());
    System.out.println("p1 " + p1.toString());
}

测试结果

p1 [name: zhangsan, list: [zhangsan]]
p2 [name: lisi, list: [zhangsan, lisi]]
p1 [name: zhangsan, list: [zhangsan]]

转载于:https://my.oschina.net/morgan412/blog/3085316

  • 0
    点赞
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值