场景
设计模式-简单工厂模式、工厂模式、抽象工厂模式在Java中的使用示例：
设计模式-简单工厂模式、工厂模式、抽象工厂模式在Java中的使用示例_霸道流氓气质的博客-博客
设计模式-单例模式-饿汉式单例模式、懒汉式单例模式、静态内部类在Java中的使用示例：
设计模式-单例模式-饿汉式单例模式、懒汉式单例模式、静态内部类在Java中的使用示例_霸道流氓气质的博客-博客
上面讲了工厂模式和单例模式在Java中的示例，下面将原型模式的示例。
原型模式(Prototype Pattern)
原型模式是指原型实例指定创建对象的种类，并且通过拷贝这些原型创建新的对象。
原型模式可分为浅克隆和深克隆。
原型模式主要适用于以下场景:
1、类初始化消耗资源较多。
2、使用new生成一个对象需要非常繁琐的过程(数据准备、访问权限等)。
3、构造函数比较复杂。
4、在循环体重产生大量对象。
具体举例：
一个对象需要在一个高代价的数据库操作之后被创建，我们可以缓存该对象，在下一个请求时返回它的克隆，在需要
的时候更新数据库，以此来减少数据库调用。
注：
实现
浅克隆-复制过程自己实现
先创建原型Prototype
package com.ruoyi.demo.designPattern.prototypePattern;
/**
* 原型Prototype接口
*/
public interface Prototype {
Prototype clone();
}
创建具体需要克隆的类ConcretePrototypeA
package com.ruoyi.demo.designPattern.prototypePattern;
import java.io.*;
import java.util.List;
/**
* 需要克隆的类
*/
public class ConcretePrototypeA implements Prototype{
private int age;
private String name;
private List hobbies;
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public List getHobbies() {
return hobbies;
}
public void setHobbies(List hobbies) {
this.hobbies = hobbies;
}
@Override
public ConcretePrototypeA clone() {
//浅克隆-复制过程自己实现
ConcretePrototypeA concretePrototype = new ConcretePrototypeA();
concretePrototype.setAge(this.age);
concretePrototype.setName(this.name);
concretePrototype.setHobbies(this.hobbies);
return concretePrototype;
}
}
创建Client类
package com.ruoyi.demo.designPattern.prototypePattern;
public class Client {
private Prototype prototype;
public Client(Prototype prototype){
this.prototype = prototype;
}
public Prototype startClone(Prototype concretePrototype){
return concretePrototype.clone();
}
}
测试代码如下
package com.ruoyi.demo.designPattern.prototypePattern;
import java.util.ArrayList;
public class ProtoTypeTest {
public static void main(String[] args) {
//创建一个具体的需要克隆的对象
ConcretePrototypeA concretePrototype = new ConcretePrototypeA();
//填充属性，方便测试
concretePrototype.setAge(20);
concretePrototype.setName("霸道的程序猿");
concretePrototype.setHobbies(new ArrayList());
System.out.println(concretePrototype);
//创建client对象，准备开始克隆
Client client = new Client(concretePrototype);
ConcretePrototypeA concretePrototypeClone = (ConcretePrototypeA) client.startClone(concretePrototype);
System.out.println(concretePrototypeClone);
System.out.println(concretePrototype.getHobbies() == concretePrototypeClone.getHobbies());
}
}
运行测试代码
从测试结果看，hobbies的引用地址是相同的，意味着复制的不是值，而是引用的地址。
这样的话，如果我们修改任意一个对象的属性值，则concretePrototype和concretePrototypeClone的hobbies
值都会改变，这就是浅克隆。
浅克隆-调用jdk现成api-clone方法
只需要实现Cloneable接口，重写clone方法，此处clone方法可以改成任意名称，因为Cloneable接口是个空接口，
可以任意定位实现类的方法，此处的重点是super.clone()这句话，super.clone()调用的是Object的clone()方法。
在Object类中clone()是native的，是底层C实现的，它直接操作内存中的二进制流，特别是复制大对象时，性能的
差别很明显。
修改clone方法
package com.ruoyi.demo.designPattern.prototypePattern;
import java.io.*;
import java.util.List;
/**
* 需要克隆的类
*/
public class ConcretePrototypeA implements Prototype,Cloneable{
private int age;
private String name;
private List hobbies;
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public List getHobbies() {
return hobbies;
}
public void setHobbies(List hobbies) {
this.hobbies = hobbies;
}
@Override
public ConcretePrototypeA clone() {
//浅克隆-调用jdk现成的api，只需要实现Cloneable接口接口
try{
return (ConcretePrototypeA) super.clone();
} catch (CloneNotSupportedException e) {
e.printStackTrace();
return null;
}
}
}
此时也是浅克隆。下面介绍深克隆。
深克隆
将一个对象复制之后，不论是基本数据类型还有引用类型，都是重新创建的。
深克隆是通过实现Serializable读取二进制流。
package com.ruoyi.demo.designPattern.prototypePattern;
import java.io.*;
import java.util.List;
/**
* 需要克隆的类
*/
public class ConcretePrototypeA implements Prototype,Cloneable,Serializable{
private int age;
private String name;
private List hobbies;
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public List getHobbies() {
return hobbies;
}
public void setHobbies(List hobbies) {
this.hobbies = hobbies;
}
@Override
public ConcretePrototypeA clone() {
//深克隆-方法得实现可序列化，Serializable
try {
//序列化
ByteArrayOutputStream bos = new ByteArrayOutputStream();
ObjectOutputStream oos = new ObjectOutputStream(bos);
//将当前对象以对象流的方式输出
oos.writeObject(this);
//反序列化
ByteArrayInputStream bis = new ByteArrayInputStream(bos.toByteArray());
ObjectInputStream ois = new ObjectInputStream(bis);
ConcretePrototypeA copy = (ConcretePrototypeA) ois.readObject();
return copy;
} catch (Exception e) {
e.printStackTrace();
return null;
}
}
}
此时再运行测试代码
