原型模式（PrototypePattern）

拼搏现实的明天。 2021-07-12 12:56 248阅读 0赞

介绍：原型模式：通过复制现有的实例来创建新的实例。

使用条件：直接创建对象的代价比较大时，则采用这种模式。例如，一个对象需要在一个高代价的数据库操作之后被创建。我们可以缓存该对象，在下一个请求时返回它的克隆，在需要的时候更新数据库，以此来减少数据库调用。

使用原型模式的注意事项:

1、使用原型模式复制对象不会调用类的构造方法.因为对象的复制是通过调用Objetc类的clone()方法来完成的,它直接是在内存中复制 数据,因此是不会调用到类的构造方法.不但构造方法中的代码不会执行,甚至连访问权限都对原型模式无效.单例模式中,只要将构造方法的访问权限设置为private型,就可以实现单例.但是clone方法直接无视构造方法的权限,所以单例模式跟原型模式是冲突的,在使用是需要注意

**应用场景：** 1、细胞分裂。 2、JAVA 中的 Object clone() 方法。

**注意事项：**与通过对一个类进行实例化来构造新对象不同的是，原型模式是通过拷贝一个现有对象生成新对象的。浅拷贝实现 Cloneable，重写，深拷贝是通过实现 Serializable 读取二进制流。

类图：

![aHR0cHM6Ly9pbWFnZXMyMDE3LmNuYmxvZ3MuY29tL2Jsb2cvNDAxMzM5LzIwMTcwOS80MDEzMzktMjAxNzA5MjkyMDU0NDExNTMtMTk1MDc0NTM2OC5wbmc][]

先创建一个支持克隆的类

//如果要克隆就必须实现Cloneable接口
    public class Person implements Cloneable{
        //可能会抛出不支持克隆异常，原因是没有实现Cloneable接口
        @Override
        protected Person clone(){
            try{
                return (Person) super.clone();
            }catch(CloneNotSupportedException e){
                e.printStackTrace();
                return null;
            }
        }
    }

再进行克隆

public class MainClass {
        public static void main(String[] args) {
            Person person1 = new Person();
            
            Person person2 = person1.clone();
        }
    }

这种不通过 new 关键字来产生一个对象，而是通过对象拷贝来实现的模式就叫做原型模式，这个模式的核心是一个clone( )方法，通过这个方法进行对象的拷贝，Java 提供了一个 Cloneable 接口来标示这个对象是可拷贝的，为什么说是“标示”呢？翻开 JDK 的帮助看看 Cloneable 是一个方法都没有的，

这个接口只是一个标记作用，在 JVM 中具有这个标记的对象才有可能被拷贝，所以覆盖了覆盖clone()方法就可以了。

在 clone()方法上增加了一个注解@Override， 没有继承一个类为什么可以重写呢？在 Java 中所有类的父类是Object 类，每个类默认都是继承了这个类，所以这个用上@Override是非常正确的。原型模式虽然很简单，但是在 Java 中使用原型模式也就是 clone 方法还是有一些注意事项的：

**对象拷贝时，类的构造函数是不会被执行的**。 一个实现了 Cloneable 并重写了 clone 方法的类 A,有一个无参构造或有参构造 B，通过 new 关键字产生了一个对象 S，再然后通过 S.clone()方式产生了一个新的对象 T，那么在对象拷贝时构造函数 B 是不会被执行的， 对象拷贝时确实构造函数没有被执行，这个从原理来讲也是可以讲得通的，Object 类的 clone 方法的 原理是从内存中（具体的说就是堆内存）以二进制流的方式进行拷贝，重新分配一个内存块，那构造函数 没有被执行也是非常正常的了。

还有就是深度克隆与浅度克隆

**首先，是浅度克隆**

//如果要克隆就必须实现Cloneable接口
    public class Person implements Cloneable{
        private String name;
        private String sex;
        private List<String> list;
        public String getName() {
            return name;
        }
        public void setName(String name) {
            this.name = name;
        }
        public String getSex() {
            return sex;
        }
        public void setSex(String sex) {
            this.sex = sex;
        }
        public List<String> getList() {
            return list;
        }
        public void setList(List<String> list) {
            this.list = list;
        }
        //可能会抛出不支持克隆异常，原因是没有实现Cloneable接口
        @Override
        protected Person clone(){
            try{
                return (Person) super.clone();
            }catch(CloneNotSupportedException e){
                e.printStackTrace();
                return null;
            }
        }
    }

这就是浅度克隆，当被克隆的类中有引用对象**（String或Integer等包装类型除外）**时，克隆出来的类中的引用变量存储的还是之前的内存地址，也就是说克隆与被克隆的对象是同一个。这样的话两个对象共享了一个私有变量，所有人都可以改，是一个种非常不安全的方式，在实际项目中使用还是比较少的。

**深度拷贝**

//如果要克隆就必须实现Cloneable接口
    public class Person implements Cloneable{
        private String name;
        private String sex;
        private List<String> list;
        public String getName() {
            return name;
        }
        public void setName(String name) {
            this.name = name;
        }
        public String getSex() {
            return sex;
        }
        public void setSex(String sex) {
            this.sex = sex;
        }
        public List<String> getList() {
            return list;
        }
        public void setList(List<String> list) {
            this.list = list;
        }
        //可能会抛出不支持克隆异常，原因是没有实现Cloneable接口
        @Override
        protected Person clone(){
            try{
                Person person = (Person) super.clone();
                List<String> newList = new ArrayList();
                
                for(String str : this.list){
                    newList.add(str);
                }
                person.setList(newList);
                return person;
            }catch(CloneNotSupportedException e){
                e.printStackTrace();
                return null;
            }
        }
    }

这样就完成了深度拷贝，两种对象互为独立，属于单独对象。

**注意：final 类型修饰的成员变量不能进行深度拷贝　　**

### **　　最后说一下，原型模式的使用场景** ###

**　　**1、在创建对象的时候，我们不只是希望被创建的对象继承其基类的基本结构，还希望继承原型对象的数据。

2、希望对目标对象的修改不影响既有的原型对象（深度克隆的时候可以完全互不影响）。

3、隐藏克隆操作的细节，很多时候，对对象本身的克隆需要涉及到类本身的数据细节。

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

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

6、一个对象需要提供给其他对象访问，而且各个调用者可能都需要修改其值时，可以考虑使用原型模式拷贝多个对象供调用者使用。在实际项目中，原型模式很少单独出现，一般是和工厂方法模式一起出现，通过 clone的方法创建一个对象，然后由工厂方法提供给调用者。原型模式先产生出一个包含

大量共有信息的类，然后可以拷贝出副本，修正细节信息，建立了一个完整的个性对象。

[aHR0cHM6Ly9pbWFnZXMyMDE3LmNuYmxvZ3MuY29tL2Jsb2cvNDAxMzM5LzIwMTcwOS80MDEzMzktMjAxNzA5MjkyMDU0NDExNTMtMTk1MDc0NTM2OC5wbmc]: /images/20210708/190f0e18f34240dd98776c1e572e4bed.png