定义
用原型实例指定创建对象的种类，并且通过拷贝这些原型来创建新的对象。简单点来说，就是要创建一个新的对象，不采用ｎｅｗ的方式，而是通过将一个已有的实例内容复制一份的方式，生成一个新的对象实例（内存中是新的地址，修改原型对象的内容，并不影响新对象的内容）。
角色
- 抽象原型类：声明克隆方法的接口，所有具体原型的父类
- 原型类：抽象原型的实现类
- 客户端：通过原型对象，生成新的对象，让具体原型类克隆自身，供客户端使用
原型模式的核心功能在于克隆方法的实现，一般有三种方法：
- 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方法，如果对已有的类进行改造的时候，违反了开闭原则
- 深拷贝的代码比较的复杂，实现起来比价的麻烦，当然通过流的方式不存在这样的问题，但是要实现序列化接口
使用场景
- 类的初始化需要消耗大量的资源，可以考虑使用原型模式
- 一个对象多个修改者的场景
- 创建一个对象耗时较长，会大量加载其他的类，可以考虑使用原型模式
少年听雨歌楼上，红烛昏罗帐。
壮年听雨客舟中，江阔云低，断雁叫西风。
感谢支持！
---起个名忒难
