设计模式:原型模式

作为一个创建型模式,它的做用是复制一个已经实例化好的类，object类的clone方法是一个native本地方法，可直接操作内存中的二进制流，特别是复制大对象时，性能差别非常明显。clone时不会触发构造函数。

优点

创建复杂或耗时的实例时比构造创建速度快

缺点

实现Cloneable接口或Serializable接口

使用场景

1、资源优化场景。

2、类初始化需要消化非常多的资源，这个资源包括数据、硬件资源等。

3、性能和安全要求的场景。

4、通过 new 产生一个对象需要非常繁琐的数据准备或访问权限，则可以使用原型模式。

5、一个对象多个修改者的场景。

6、一个对象需要提供给其他对象访问，而且各个调用者可能都需要修改其值时，可以考虑使用原型模式拷贝多个对象供调用者使用。

7、在实际项目中，原型模式很少单独出现，一般是和工厂方法模式一起出现，通过 clone的方法创建一个对象，然后由工厂方法提供给调用者。

实现Cloneable接口会有两种拷贝方式它们的区别为下面图

现实生活中的例子

如何实现浅拷贝

实现Clone接口，覆盖Clone方法

Prototype.java

public class Prototype implements Cloneable {
    private int id;
        private String name;
        private Book book;
        public Prototype clone(){
                Prototype p=null;
                try {
                        p = (Prototype) super.clone();
                        return p;
                } catch (CloneNotSupportedException e) {
                        e.printStackTrace();
                }
                return null;
        }
        //...省略setter和getter方法
}

Test.java

public static void main(String[] args) {
                Book b=new Book();
                b.setBookName("数学");

                Prototype pro = new Prototype();
                pro.setBook(b);
                Prototype pro1 =  pro.clone();//复制一个
                b.setBookName("语文");//更改bookname

                System.out.println(pro.getBook()==pro1.getBook());
                System.out.println("original object:" + pro.getBook().getBookName());
                System.out.println("cloned object:" + pro1.getBook().getBookName());
        }

输出结果

true
original object:语文
cloned object:语文

如何实现深拷贝

由于浅拷贝默认只是把包含的对象引用复制了一份，所以也要把包含的对象也实现cloneable接口然后在原型clone方法里调用包含的对象clone方法

Prototype.java

public class Prototype implements Cloneable {
    private int id;
        private String name;
        private Book book;
        public Prototype clone(){
                Prototype p=null;
                try {
                        p = (Prototype) super.clone();
                        p.book = this.book.clone();
                        return p;
                } catch (CloneNotSupportedException e) {
                        e.printStackTrace();
                }
                return null;
        }
        //...省略setter和getter方法
}

Book.java

public class Book implements Cloneable{
        private String bookName;

        public Book clone(){
                try {
                        return (Book) super.clone();
                } catch (CloneNotSupportedException e) {
                        e.printStackTrace();
                }
                return null;
        }
        //...省略setter和getter方法
}

Test.java

public static void main(String[] args) {
                Book b=new Book();
                b.setBookName("数学");

                Prototype pro = new Prototype();
                pro.setBook(b);
                Prototype pro1 =  pro.clone();//复制一个
                b.setBookName("语文");//更改bookname

                System.out.println(pro.getBook()==pro1.getBook());
                System.out.println("original object:" + pro.getBook().getBookName());
                System.out.println("cloned object:" + pro1.getBook().getBookName());
        }

输出结果

false
original object:语文
cloned object:数学

利用序列化串行方式复制实例

原始类要实现serializable，包含的类也要实现serializable

NewPrototype.java

public class NewPrototype implements Serializable {
        private int id;
        private Book book;
        public NewPrototype deepClone(){
                try {
                        ByteArrayOutputStream bo = new ByteArrayOutputStream();
                        ObjectOutputStream oo = new ObjectOutputStream(bo);
                        oo.writeObject(this);

                        ByteArrayInputStream bi = new ByteArrayInputStream(bo.toByteArray());
                        ObjectInputStream oi = new ObjectInputStream(bi);
                        return (NewPrototype) oi.readObject();
                } catch (IOException | ClassNotFoundException e) {
                        e.printStackTrace();
                        return null;
                }
        }
        //...省略setter和getter方法
}

Book.java

public class Book implements Serializable
//...省略其他

Test.java

public static void main(String[] args) {
                Book book = new Book();
                book.setBookName("语文");
                NewPrototype original = new NewPrototype();
                original.setBook(book);
                //深度拷贝
                NewPrototype deepClone = original.deepClone();
                deepClone.getBook().setBookName("数学");
                System.out.println("original name:" + original.getBook().getBookName());
                System.out.println("cloned name:" + deepClone.getBook().getBookName());
        }

输出

original name:语文
cloned name:数学

赏

谢谢你的激励

微信