Java设计模式之创建型模式--原型模式

一：简介

原型模式用起来很简单，我们只需实现Cloneable接口，重写clone方法即可。使用原型模式的目的，是为了避免初始化是需要消耗很多的资源，new一个对象时需要进行繁琐的数据准备。

二：例子

假设，创造一个人，设置他的性别，国籍，种类(黑人还是白人还是黄种人)。等等之类，比方说现在就这三个属性。

三：例子实现

1. 创建Type：

public class Type {
    //肤色
    private String fuse;
    //头发颜色
    private String toufa;
    public Type() {
    }
    public Type(String fuse, String toufa) {
        this.fuse = fuse;
        this.toufa = toufa;
    }
    public String getFuse() {
        return fuse;
    }
    public void setFuse(String fuse) {
        this.fuse = fuse;
    }
    public String getToufa() {
        return toufa;
    }
    public void setToufa(String toufa) {
        this.toufa = toufa;
    }
}
           

Type类很简单。

2.创建People：

这个类需要被我去拷贝，所有需要实现Cloneable接口和重写clone方法

public class People implements Cloneable {
    //性别
    private String sex;
    //国籍
    private String nationality;
    //种类
    private Type type;
    public People() {
    }
    public People(String sex, String nationality, Type type) {
        this.sex = sex;
        this.nationality = nationality;
        this.type = type;
    }
    //重写clone方法
    @Override
    protected Object clone(){
        People people = null;
        try {
            //拷贝一个人
            people = (People) super.clone();
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }
        return people;
    }
    public String getSex() {
        return sex;
    }
    public void setSex(String sex) {
        this.sex = sex;
    }
    public String getNationality() {
        return nationality;
    }
    public void setNationality(String nationality) {
        this.nationality = nationality;
    }
    public Type getType() {
        return type;
    }
    public void setType(Type type) {
        this.type = type;
    }
    @Override
    public String toString() {
        return "性别："+sex+"\n国籍："+nationality+"\n种类：\t肤色:"+type.getFuse()+"\t头发:"+type.getToufa();
    }
}
           

3.创建测试类：

public static void main(String[] args) {
        Type type = new Type("黄皮肤","黑头发");
        People people = new People();
        people.setSex("男");
        people.setNationality("中国");
        people.setType(type);
        System.out.println(people.toString());
        //第一个人创建好了，那如果我们还要创建这样的一个人呢，
        //我们只需要clone一下就行了
        People people1 = (People) people.clone();
        System.out.println("---------------------");
        System.out.println(people1.toString());
        //修改一些属性
        people1.setSex("女");
        System.out.println("---------------------");
        System.out.println(people1.toString());
    }
    结果：
    性别：男
    国籍：中国
    种类： 肤色:黄皮肤  头发:黑头发
    ---------------------
    性别：男
    国籍：中国
    种类： 肤色:黄皮肤  头发:黑头发
    ---------------------
    性别：女
    国籍：中国
    种类： 肤色:黄皮肤  头发:黑头发
           

我们可以看到，我们拷贝了一个一模一样的人。当然我们也可以动态的修改复制出来的人的一些属性。这样我们的对象不再是new出来，不过clone和new都会在内存中分配地址。并不会减少内存的开销，只不过，我们有时候用new会有繁琐的操作，即使实际上只需改其中的一点点。所以我们用clone就会很好的避免这个问题。

对象拷贝时，构造方法并不会被执行

我们修改默认构造方法：
 public People() {
        System.out.println("构造方法被调用了！");
    }
其他代码都不变
结果：
构造方法被调用了！
性别：男
国籍：中国
种类： 肤色:黄皮肤  头发:黑头发
---------------------
性别：男
国籍：中国
种类： 肤色:黄皮肤  头发:黑头发
---------------------
性别：女
国籍：中国
种类： 肤色:黄皮肤  头发:黑头发
           

我们可以看到，我们拷贝了两次，但是构造方法只是在最开始new的时候被调用了。

这是因为:

Object类的clone方法原理是从内存中(堆中)以二进制流的方法进行拷贝，重新分配一个内存块。

四：原型中的浅拷贝和深拷贝

1. 先看浅拷贝的例子

还是一个人，里面有个list

public class People implements Cloneable{
    private ArrayList<String> array = new ArrayList<String>();
    @Override
    protected People clone(){
        People people = null;
        try {
            people = (People) super.clone();
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }
        return people;
    }
    public List<String> getArray() {
        return array;
    }
    public void setValue(String value) {
        this.array.add(value);
    }
}
           

直接测试

public static void main(String[] args) {
        People people = new People();
        people.setValue("张三");
        People p2 = people.clone();
        p2.setValue("李四");
        for (String s : people .getArray())
            System.out.println(s);
    }
    结果：
    张三
    李四
           

我们会发现，people里应该只有一个张三啊，怎么被拷贝一个对象后，那个拷贝对象添加了一个李四，为什么原先的对象中也被添加了，太奇怪了。

这里我们要明白两点：

1.我们的clone方法并不是Cloneable接口的而是Object这个父类的，你可以去点进去看，发现这个接口，并没有任何方法，这个接口只是作为一个标识，只有实现改接口的类才‘有可能’被拷贝，没错是有可能！那么如何让这可能变成肯定呢，那就是重写clone方法。

2.Object提供的clone方法，只能拷贝一些原始类型如int，long…也包括String。

2.深拷贝例子

我们只需修改People中clone的代码就可以了
@Override
    protected People clone(){
        People people = null;
        try {
            people = (People) super.clone();
            //这句话，让我们的array在对象拷贝的时候也拷贝一下，这里注意我们不能用List，而是要用它的实现类ArrayList，因为接口并没有clone方法。
            people.array = (ArrayList<String>)this.array.clone();
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }
        return people;
    }
    看看结果：
    张三
           

我们发现这次被拷贝对象并没有和拷贝对象公用属性。而是各用个的。这就是深拷贝。

五：适用场景

参考设计模式

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

等；

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

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

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