设计模式-原型模式

原型模式

定义

抽象原型类是定义就有克隆自己的方法的接口，是所有具体原型类的父类，既可以是接口，也可以是抽象类。

具体原型类实现具体的克隆方法，在克隆方法中返回自己的一个克隆对象。

UML图：

浅克隆

在浅克隆中，被复制的对象的所有成员变量都与原来对对象的相同。即如果包含其他类的对象A，复制后的对象cloneB中的对象A和原来的对象B中的对象A是指向同一个对象。

深克隆

深克隆与浅克隆相反，新克隆的对象与原来对象是完全不同的两个对象，仅仅是其中的值相等。

代码实现

实现矩阵的克隆，矩阵类中包含两个顶点的对象（为自定义的点类）。自定义点类中包含两个double类型数据用来记录点的坐标。

点类：

import java.io.*;
public class Point implements Serializable {
    double x,y;
    public Point(double x, double y){
        this.x = x;
        this.y = y;
    }

    public double getX() {
        return x;
    }

    public void setX(double x) {
        this.x = x;
    }

    public double getY() {
        return y;
    }

    public void setY(double y) {
        this.y = y;
    }
}

客户端（测试类）

public class Main {
    public static void main(String[] args) throws Exception {
        Point p1 = new Point(1,2);
        Point p2 = new Point(2,1);
        Point p3 = new Point(1,2);
        Point p4 = new Point(2,1);

        Rectangle1 r2 = new Rectangle1(p3,p4);
        Rectangle1 cloneR2 = r2.clone();

        Rectangle r1 = new Rectangle(p1,p2);
        Rectangle cloneR1 = r1.clone1();

        System.out.println("浅克隆：");
        System.out.println(cloneR2 == r2);
        p3.setX(5);
        System.out.println("cloneR2: "+ cloneR2.toString() + "\n r2: " + r2.toString());
        System.out.println();

        System.out.println("深克隆：");
        System.out.println(cloneR1 == r1);
        p1.setX(5);
        System.out.println("cloneR1: "+ cloneR1.toString() + "\n r1: " + r1.toString());

    }
}

浅克隆：

java实现浅克隆可以直接调用Object类中的clone方法。但是该类必须实现Cloneable接口。

import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.ObjectOutputStream;

public class Rectangle1 implements Cloneable{
    private Point p1,p2;
    public Rectangle1(Point p1, Point p2){
        this.p1 = p1;
        this.p2 = p2;
    }

    @Override
    public Rectangle1 clone() throws CloneNotSupportedException {
        return (Rectangle1) super.clone();
    }
    @Override
    public String toString(){
        return "p1: x = " + p1.getX() + " y = " + p1.getY()
                + "\np2: x = " + p2.getX() + "y = " + p2.getY();
    }


}

深克隆：  

深克隆使用序列化流来进行创建一个新对象。首先在内存中创建一个字节数组缓冲区。使用序列化流将被克隆的对象序列化，输出进缓冲区中，再将其取出。在对象流入缓冲区的时候，就已经实现了重新创建新对象。  

要想将类序列化，该类必须实现Serializable接口。  

```java

import java.io.*;

public class Rectangle implements Serializable {
    private Point p1,p2;
    public Rectangle(Point p1, Point p2){
        this.p1 = p1;
        this.p2 = p2;
    }


    @Override
    public String toString(){
        return "p1: x = " + p1.getX() + " y = " + p1.getY()
                + "\np2: x = " + p2.getX() + "y = " + p2.getY();
    }

    public Rectangle clone1()throws Exception{
        ByteArrayOutputStream bao = new ByteArrayOutputStream();
        ObjectOutputStream oos = new ObjectOutputStream(bao);
        oos.writeObject(this);
        ByteArrayInputStream bis = new ByteArrayInputStream(bao.toByteArray());
        ObjectInputStream ois = new ObjectInputStream(bis);
        return (Rectangle) ois.readObject();

    }
}