设计模式-原型模式

原型模式（prototype）

介绍

java的Object类中含有一个函数clone(),但是实现克隆的方法需要实现Java的CloneAble类 改接口表示该类能够复制且有复制能力。

• 用原型¹ 的实例来保证创建对象的种类，并通过拷贝这些原型创建新的对象
• 原型模式是一种创建型设计模式，它能够在不知道对方创建细节的情况下创建另一个设计模式
• 通过将原型对象传递给要法动创建的队象，这个发动创建对象通过请求原型对象拷贝他们自己来实施创建。对象.clone()；

UML

案例

public class Client {
    public static void main(String[] args) throws CloneNotSupportedException {
        Sheep sheep = new Sheep();
        sheep.setAge("10");
        sheep.setName("jiaxing");
        sheep.setColor("white");
        Sheep sheep1 = (Sheep) sheep.clone();
        System.out.println(sheep1.Name);
        System.out.println(sheep == sheep1);
    }
}


public class Sheep implements Cloneable {
    String Name;
    String Color;
    String Age;

    public String getName() {
        return Name;
    }

    public void setName(String name) {
        Name = name;
    }

    public String getColor() {
        return Color;
    }

    public void setColor(String color) {
        Color = color;
    }

    public String getAge() {
        return Age;
    }

    public void setAge(String age) {
        Age = age;
    }

    @Override
    protected Object clone() throws CloneNotSupportedException {
        Sheep sheep = null;
        try{
            sheep = (Sheep) super.clone();
        }catch (Exception e){
            System.out.println(e.getMessage());
        }

        return super.clone();
    }
}

###浅拷贝，和深拷贝
浅拷贝支部会引用（引用数据类型的地址），但是深拷贝会分配一个新的内存空间，并且复制原有的数据。
深拷贝有两种方式实现。

• 重写clone（）方法
• 利用序列化和反序列化实现。

package prototype;

import com.sun.xml.internal.messaging.saaj.util.ByteInputStream;

import java.io.*;

public class DeepCloneAble implements Serializable ,Cloneable {
    private String name;
    private   Sheep sheep;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
    public DeepCloneAble (String name,Sheep sheep){
        this.name = name;
        this.sheep = sheep;
    }

    @Override
    protected Object clone() throws CloneNotSupportedException {
        Object deep = null;
        deep = super.clone();
        DeepCloneAble deepCloneAble = (DeepCloneAble) deep;
        deepCloneAble.sheep = (Sheep) sheep.clone();
        return deep;
    }
    public  Object DeepClone(){
        //字节数组输入流
        ByteArrayInputStream bis = null;
        //对象输入流
        ObjectInputStream ois = null;
        //字节数组输出流
        ByteArrayOutputStream bos  = null;
        //对象输出流
        ObjectOutputStream oos = null;
        try{
            //序列化
            bos = new ByteArrayOutputStream();
            oos = new ObjectOutputStream(bos);
            //将当前对象以对象流的方式输出
            System.out.println(this.sheep.getName());
            oos.writeObject(this);
            //反序列化
            bis = new ByteArrayInputStream(bos.toByteArray());
            ois = new ObjectInputStream(bis);
            DeepCloneAble deepCloneAble = (DeepCloneAble) ois.readObject();
            return deepCloneAble;
        }catch (Exception e){
            e.printStackTrace();
            return null;
        }finally {
            try {
                //关闭流
                bos.close();
                bis.close();
                oos.close();
                ois.close();
            }catch (Exception e){
                e.printStackTrace();
            }


        }
    }
}

注意： 序列化必须继承Serializable。

---

1. 你认为最初的实例叫做原型实例 ↩︎