原型模式

定义

用原型实例指定创建对象的种类，并且通过拷贝这些原型来创建新的对象。简单点来说，就是要创建一个新的对象，不采用ｎｅｗ的方式，而是通过将一个已有的实例内容复制一份的方式，生成一个新的对象实例（内存中是新的地址，修改原型对象的内容，并不影响新对象的内容）。

角色

• 抽象原型类：声明克隆方法的接口，所有具体原型的父类
• 原型类：抽象原型的实现类
• 客户端：通过原型对象，生成新的对象，让具体原型类克隆自身，供客户端使用

原型模式的核心功能在于克隆方法的实现，一般有三种方法：

• new 一个新的对象，并设置和当前对象一样的内容
• 使用Object.clone()方法
• 使用流的方式来进行对象的拷贝

第一种方法

//抽象原型类
public interface Person {
    Person clone() ;
}

//具体原型类
public class Teacher implements Person {
    private String name ;
    private int age ;

    public Teacher(String name, int age) {
        this.name = name;
        this.age = age;
    }
    public Teacher(){}

    public Person clone() {
        Teacher t = new Teacher();
        t.setName(this.getName());
        t.setAge(this.getAge());
        return t;
    }
    //省略set ,get 方法
    .....
}
//客户端
public class Client {
    public static void main(String[] args) {
        Person p = new Teacher("zhangsan" ,18);
        Person clone = p.clone();
        System.out.println(p ==clone);  //false

    }
}

上面的原型复制实现是通过new了一个新的对象，并将原型的内容显式的赋值给了新创建的对象，如果原型的属性比较少可以使用上面的方式，如果有大量的属性就显得有些吃力了，要写大量的代码来完成原型内容的拷贝、

其实在Object类中，Java提供了一个clone()方法，可以通过这个方法来完成对象的拷贝，下面来看使用示例，这个也是原型模式的通用实现方式。

代码与上面的基本上完全一样，不同的是要使用clone()方法，必须要实现Cloneable接口，克隆的实现要是用super.clone()实现。

public class Teacher implements Person ,Cloneable {
    private String name ;
    private int age ;

    public Teacher(String name, int age) {
        this.name = name;
        this.age = age;
    }
    public Teacher(){}

    @Override
    public Person clone() {
        Object object = null ;
        try {
           object =  super.clone();
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }
        return (Person) object;
    }
    //省略setter()getter()
    ....
}

Object.clone()是一种浅拷贝，也就是只是拷贝了对象的本身，基本类型的值会被复制，如果是引用类型，则没有实现复制，只是将引用类型的地址复制了一份。这显然和要求不符，如果将引用类型变量所指向的值也一同拷贝，这种复制方式称之为深拷贝。

下面看一下深拷贝的实现方式：

public class Student implements Cloneable {
    private String name;
    public Student(){}
    public Student(String name ){
        this.name = name ;
    }

    public Student clone(){
        Student student = null ;
        try {
            student = (Student) super.clone();
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }
        return student;
    }
}

public class Teacher implements Person ,Cloneable {
    private String name ;
    private int age ;
    private Student student;
    public Teacher(String name, int age) {
        this.name = name;
        this.age = age;
    }
    public Teacher(){}

    @Override
    public Teacher clone() {
        Teacher object = null ;
        try {
            object =  (Teacher)super.clone();
            object.setStudent(this.getStudent().clone());
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }
        return object;
    }
}
public class Client {
    public static void main(String[] args) {
        Student student = new Student("wangwu");
        Teacher p = new Teacher("zhangsan" ,18);
        p.setStudent(student);
        Teacher clone = p.clone();
        System.out.println(p ==clone);  //false
        System.out.println(student);  //com.huoyan.prototype.Student@1b6d3586
        System.out.println(clone.getStudent()); //com.huoyan.prototype.Student@4554617c
    }
}

上面的代码虽然实现了原型的深拷贝，但是每一个引用变量都要重写clone()方法，感觉也不是很友好，而且每个引用变量还是要单独的设置，感觉上稍差那么一点，有没有更好的方法呢，我们看第三种实现方式：

那就是通过流的方式来实现，但是原型的每个引用变量类都要实现实例化接口，不然会抛异常的。序列化就是将对象写到流的过程，写到流的对象是原有对象的一个拷贝，也元对象仍然存在于内存中。这样即可实现原型对象的基本类型的拷贝，也能实现引用变量对象内容的拷贝

Student类和Teacher类均要实现Serializable ，其他的代码与上面的相同，唯一不同的是clone()方法的实现方式，下面也已经将代码贴上。

    @Override
    public Teacher clone() {
        try {
            ByteArrayOutputStream bos = new ByteArrayOutputStream();

            ObjectOutputStream oos = new ObjectOutputStream(bos);
            oos.writeObject(this);

            ByteArrayInputStream bis = new ByteArrayInputStream(bos.toByteArray());
            ObjectInputStream ois = new ObjectInputStream(bis);
            return  (Teacher) ois.readObject();

        } catch (Exception e) {
            e.printStackTrace();
            return  null ;
        }
    }

总结
原型模式作为一种快速创建大量相同或相似对象的方式，在软件开发中使用的方式还是比价广泛的。

优点

• 性能优良，原型模式可以在内容通过二进制流的方式进行拷贝，比new的方式性能要好，特别是有大量的引用时
• 避免了构造函数的约束，原型模式对原型的拷贝其实是不经过构造函数的。

缺点

• 需要为每个类提供一个clone方法，如果对已有的类进行改造的时候，违反了开闭原则
• 深拷贝的代码比较的复杂，实现起来比价的麻烦，当然通过流的方式不存在这样的问题，但是要实现序列化接口

使用场景

• 类的初始化需要消耗大量的资源，可以考虑使用原型模式
• 一个对象多个修改者的场景
• 创建一个对象耗时较长，会大量加载其他的类，可以考虑使用原型模式

---

---

少年听雨歌楼上，红烛昏罗帐。  
壮年听雨客舟中，江阔云低，断雁叫西风。
感谢支持！
                                        ---起个名忒难

---