设计模式之原型模式

1.原型模式概念

通过复制一个现有的对象实例来创建新对象，而不是通过直接实例化对象。这样可以避免构造过程中的开销，并允许根据需要定制对象的创建过程。

2.原型模式实现的两种方式

1)java字节流拷贝

通过继承Cloneable类，通过调用super.clone()方法克隆对象(也可以使用Serializable接口，使用java字节流进行拷贝)，然后在类型转化就能实现和原来一模一样的对象，并且对象的地址，是不一样的。克隆的对象和源对象的数据一模一样，克隆过程无法定制。如果需要定制克隆的话推荐第二种.

2)创建对象拷贝

通过new StudentC()对象的方式,并且把数据一一设置到新的对象中，然后返回对象就可以得到克隆的对象，并且对象的地址，是不一样的。但如果对象比较大的话，设置起来会非常麻烦，如果对克隆没有什么要求，推荐第一种。

3.举个例子

上小学时，小久周六，周日没写作业，第二天找到同学惜己的作业抄了一下。

4.代码实现

1)原型类

package org.xiji.Prototype2;



import java.io.*;

public class StudentC implements Serializable,Cloneable{
    private String name;
    private int age;

    public StudentC(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public StudentC() {
    }

    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;
    }

    /**
     * 使用Cloneable接口，直接调用父接口的方法
     */
    public StudentC cloneByCloneable() {
        try {
            // 调用父接口的克隆方法 ===》并且进行强转
            return (StudentC) super.clone();

        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }
        return null;
    }

    /**
     * 通过java字节流流克隆对象
     */

    public StudentC cloneByStream() {
        try {

            ByteArrayOutputStream outPutStream = new ByteArrayOutputStream();

            ObjectOutputStream objectOutputStream = new ObjectOutputStream(outPutStream);

            objectOutputStream.writeObject(this);


            ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream(outPutStream.toByteArray());


            ObjectInputStream objectInputStream = new ObjectInputStream(byteArrayInputStream);


            return (StudentC) objectInputStream.readObject();


        } catch (Exception e) {
            e.printStackTrace();

        }



        return null;
    }

    /**
     * 通过创建对象的方式克隆
     * 如果对象的属性少话，还行，但是如果对象的多的话就不如上面的那种方法
     */
    public StudentC cloneByNew() {
        return new StudentC(this.name, this.age);
    }
}

2)原型测试类

package org.xiji.Prototype2;

/**
 * 原型模式测试类
 */
public class Prototype2 {
    public static void main(String[] args) throws CloneNotSupportedException {


        StudentC xiji = new StudentC("惜己", 18);
        System.out.println("xiji.name = " + xiji.getName());
        System.out.println("================================");
        //通过Cloneable实现克隆方法
        System.out.println("通过java字节流实现克隆方法");
        StudentC cloneS = xiji.cloneByStream();

        System.out.println("cloneS.name = " + cloneS.getName());

        System.out.println("判断两个对象是否相等");
        System.out.println(xiji.equals(cloneS));

        System.out.println("================================");

        //通过创建对象的方法克隆对象
        System.out.println("通过创建对象的方法克隆对象");
        StudentC studentC = xiji.cloneByNew();
        System.out.println("studentC.name = " + studentC.getName());

        System.out.println("判断两个对象是否相等");
        System.out.println(xiji.equals(studentC));
        System.out.println("================================");

        //通过Cloneable类型实现克隆方法
        System.out.println("通过Cloneable类型实现克隆方法");
        StudentC cloneable = xiji.cloneByCloneable();
        System.out.println("cloneable.name = " + cloneable.getName());
        System.out.println("判断两个对象是否相等");
        System.out.println(xiji.equals(cloneable));

    }
}

3)测试结果