设计模式-原型模式

简介

定义：用原型实例指定创建对象的种类，并且通过拷贝这些原型来创建新的对象。

功能：
1.是通过克隆来创建新的对象实例；
2.是为克隆出来的新的对象实例复制原型实例属性的值。

本质：通过克隆来创建新的对象实例。

英文：Prototype

类型：创建型

应用场景

1、一个系统想要独立于它想要使用的对象时，可以使用原型模式，让系统只面向接口编程，在系统需要新的对象的时候，可以通过克隆原型来得到；

2、需要实例化的类是在运行时刻动态指定时，可以使用原型模式，通过克隆原型来得到需要的实例；

3、创建新对象成本较大（如初始化需要占用较长的时间，占用太多的CPU资源或网络资源），新的对象可以通过原型模式对已有对象进行复制来获得，如果是相似对象，则可以对其成员变量稍作修改。

优点：

1、对客户端隐藏具体的实现类型：原型模式的客户端，只知道原型接口的类型，并不知道具体的实现类型，从而减少了客户端对这些具体实现类型的依赖。

2、在运行时动态改变具体的实现类型：原型模式可以在运行期间，由客户来注册符合原型接口的实现类型，也可以动态的改变具体的实现类型，看起来接口没有任何变化，但其实运行的已经是另外一个类实例了。因为克隆一个原型就类似于实例化一个类。

缺点：

深度克隆方法实现会比较困难：原型模式最大的缺点就在于每个原型的子类都必须实现clone的操作，尤其在包含引用类型的对象时，clone方法会比较麻烦，必须要能够递归的让所有的相关对象都要正确的实现克隆。

原型模式中的角色

• 抽象原型(Prototype)：声明一个克隆自身的接口，用来约束想要克隆自己的类，要求它们都要实现这里定义的克隆方法。
• 具体原型(ConcretePrototype)：实现Prototype接口的类，这些类真正实现了克隆自身的功能。
• 客户端(Client)：使用原型的客户端，首先要获取到原型实例对象，然后通过原型实例克隆自身来创建新的对象实例。

角色UML

Java实现原型模式的两个要点：

1、实现Cloneable接口。在java语言有一个Cloneable接口，它的作用只有一个，就是在运行时通知虚拟机可以安全地在实现了此接口的类上使用clone方法。在java虚拟机中，只有实现了这个接口的类才可以被拷贝，否则在运行时会抛出 CloneNotSupportedException异常。

2、重写Object类中的clone方法。Java中，所有类的父类都是Object类，Object类中有一个clone方法，作用是返回对象的一个拷贝，但是其作用域protected类型的，一般的类无法调用，因此，Prototype类需要将clone方法的作用域修改为public类型。

Cloneable接口的源码:

package java.lang;

public interface

Object类中的clone()源码:

protected native Object clone() throws

注意：

Object类的clone方法只会拷贝java中的8中基本类型以及他们的封装类型，另外还有String类型。对于数组、容器对象、引用对象等都不会拷贝，这就是浅拷贝。如果要实现深拷贝，必须将原型模式中的数组、容器对象、引用对象等另行拷贝。

浅拷贝与深拷贝

▶浅拷贝（shallow copy）

被复制对象的所有变量都含有与原来的对象相同的值(仅对于简单的值类型数据)，而所有的对其他对象的引用都仍然指向原来的对象。换言之，只负责克隆按值传递的数据（比如：基本数据类型、String类型）。

▶深拷贝 （deep copy）

被复制对象的所有的变量都含有与原来的对象相同的值，除去那些引用其他对象的变量。那些引用其他对象的变量将指向被复制过的新对象，而不再是原有的那些被引用的对象。换言之，除了浅度克隆要克隆的值外，还负责克隆引用类型的数据，基本上就是被克隆实例所有的属性的数据都会被克隆出来。

UML图如下:

java代码:

浅拷贝实例

具体原型

package demo7;

import java.util.ArrayList;
import java.util.List;

/**
 * 
 * @ClassName: People
 * @Description: 具体原型
 * @author cheng
 * @date
public class People implements Cloneable
    private String name;
    private int age;
    private List<String> addressList = new ArrayList<String>();

    /**
     * 重写Object类中的clone方法
     */
    @Override
    public People clone() throws CloneNotSupportedException {
        return (People) super.clone();
    }

    /**
     * 重写toString方法
     */
    @Override
    public String toString() {
        return "name=" + name + ",age=" + age + ",addressList=" + addressList;
    }

    public People() {
        super();
    }

    public People(List<String> addressList, int age, String name) {
        super();
        this.addressList = addressList;
        this.age = age;
        this.name = name;
    }

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public List<String> getAddressList() {
        return addressList;
    }

    public void setAddressList(List<String> addressList) {
        this.addressList = addressList;
    }

}

客户端

package demo7;

import java.util.ArrayList;
import java.util.List;

/**
 * 
 * @ClassName: CloneTest
 * @Description: 测试
 * @author cheng
 * @date 2017-8-14 上午09:27:14
 */
public class CloneTest {

    public static void main(String[] args) throws CloneNotSupportedException {
        List<String> addressList = new ArrayList<String>();
        addressList.add("上海市");
        addressList.add("安徽省");
        addressList.add("江苏省");
        People people1 = new People();
        people1.setName("张三");
        people1.setAge(22);
        people1.setAddressList(addressList);

        People people2 = people1.clone();

        System.out.println("两个对象是否为同一个:" + (people1.equals(people2)));
        System.out.println("具体原型对象:" + people1);
        System.out.println("克隆出来的对象:" + people2);

        people2.setName("李四");
        people2.setAge(24);
        List<String> addressList2 = people2.getAddressList();
        addressList2.add("重庆市");
        people2.setAddressList(addressList2);
        System.out.println("修改前的对象:" + people1);
        System.out.println("修改后的对象:" + people2);
        System.out.println("两个对象中的List是否为同一个:"
                + (people1.getAddressList().equals(people2.getAddressList())));

运行结果:

对于引用类型List，修改people2的List，people1的List也随着变化了，这就是浅拷贝带来的问题；

深拷贝实例

具体原型:

package demo7;

import java.util.ArrayList;
import java.util.List;

/**
 * 
 * @ClassName: People
 * @Description: 具体原型
 * @author cheng
 * @date
public class People implements Cloneable
    private String name;
    private int age;
    private List<String> addressList = new ArrayList<String>();

    /**
     * 重写Object类中的clone方法
     */
    @SuppressWarnings("unchecked")
    @Override
    public People clone() throws CloneNotSupportedException {
        People people = (People) super.clone();
        // 引用类型的属性，需要处理
        if (this.getAddressList() != null) {
            //ArrayList已经实现了Cloneable接口
            List<String> newAddressList = (List<String>) ((ArrayList<String>) this
                    .getAddressList()).clone();
            people.setAddressList(newAddressList);
        }
        return people;
    }

    /**
     * 重写toString方法
     */
    @Override
    public String toString() {
        return "name=" + name + ",age=" + age + ",addressList=" + addressList;
    }

    public People() {
        super();
    }

    public People(List<String> addressList, int age, String name) {
        super();
        this.addressList = addressList;
        this.age = age;
        this.name = name;
    }

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public List<String> getAddressList() {
        return addressList;
    }

    public void setAddressList(List<String> addressList) {
        this.addressList = addressList;
    }

}

测试(不变):

package demo7;

import java.util.ArrayList;
import java.util.List;

/**
 * 
 * @ClassName: CloneTest
 * @Description: 测试
 * @author cheng
 * @date 2017-8-14 上午09:27:14
 */
public class CloneTest {

    public static void main(String[] args) throws CloneNotSupportedException {
        List<String> addressList = new ArrayList<String>();
        addressList.add("上海市");
        addressList.add("安徽省");
        addressList.add("江苏省");
        People people1 = new People();
        people1.setName(new String("张三"));
        people1.setAge(22);
        people1.setAddressList(addressList);

        People people2 = people1.clone();

        System.out.println("两个对象是否为同一个:" + (people1.equals(people2)));
        System.out.println("具体原型对象:" + people1);
        System.out.println("克隆出来的对象:" + people2);

        people2.setName(new String("李四"));
        people2.setAge(24);
        List<String> addressList2 = people2.getAddressList();
        addressList2.add("重庆市");
        people2.setAddressList(addressList2);
        System.out.println("修改前的对象:" + people1);
        System.out.println("修改后的对象:" + people2);
        System.out.println("两个对象中的List是否为同一个:"
                + (people1.getAddressList().equals(people2.getAddressList())));

运行结果:

扩展总结

Java中对象的创建：

clone就是复制，在Java中，clone方法被对象调用，所以会复制对象。所谓的复制对象，首先要分配一个和源对象同样大小的空间，在这个空间中创建一个新的对象。

那么在java语言中，有几种方式可以创建对象呢？

1、使用new操作符创建一个对象

2、使用clone方法复制一个对象

那么这两种方式有什么相同和不同呢？

▶ new操作符的本意是分配内存。程序执行到new操作符时，首先去看new操作符后面的类型，因为知道了类型，才能知道要分配多大的内存空间。分配完内存之后，再调用构造函数，填充对象的各个域，这一步叫做对象的初始化，构造方法返回后，一个对象创建完毕，可以把他的引用（地址）发布到外部，在外部就可以使用这个引用操纵这个对象。

▶ clone在第一步是和new相似的，都是分配内存，调用clone方法时，分配的内存和源对象（即调用clone方法的对象）相同，然后再使用原对象中对应的各个域，填充新对象的域，填充完成之后，clone方法返回，一个新的相同的对象被创建，同样可以把这个新对象的引用发布到外部。

clone 方法需要满足的几个原则：

x.clone() != x，两个对象不是一个；

x.clone().getClass() == x.getClass()，两个对象的class是同一个；

x.clone().equals(x)，两个应该满足equals()方法条件；

注意：

Object类的clone方法只会拷贝java中的8中基本类型以及他们的封装类型，另外还有String类型。对于数组、容器对象、引用对象等都不会拷贝，这就是浅拷贝。如果要实现深拷贝，必须将原型模式中的数组、容器对象、引用对象等另行拷贝。

1.要使用clone方法，类的成员变量上不要增加final关键字。

2.深拷贝和浅拷贝建议不要混合使用，特别是是在涉及到类的继承，父类有多个引用的情况就非常的复杂，建议的方案是深拷贝和浅拷贝分开实现。

3.java实现真正的深拷贝，可以通过实现Serializable接口用序列化的办法来实现。