原型模式
介绍
原型(Propotype)模式：用原型实例指定要创建对象的种类，通过拷贝这些原型，创建新的对象。
原型模式是一种创建型设计模式，允许一个对象再创建另外一个可定制的对象，无需知道具体创建细节。
工作原理：通过将一个原型对象传给要发动创建的对象，这个发动创建的对象通过请求原型对象拷贝它们自己来实施创建，即原型对象.clone()。
UML类图
原理结构图说明
- Propotype: 原型类，声明克隆自己的接口
- ConcretePrototype: 具体的原型类，实现克隆自己的操作
- Client: 让一个原型对象克隆自己，从而创建一个新的对象（属性一样）
例子
羊对象的实体类如下
public class Sheep {
private String name;
private int age;
public Sheep(String name, int age) {
super();
this.name = name;
this.age = age;
}
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;
}
}
假如我们已经有了一只羊，需要创建同样的羊怎么做捏？
传统的方式：
public class Client {
public static void main(String[] args) {
// 已有的一只羊，名叫jerry, 1岁
Sheep sheep = new Sheep("jerry", 1);
// 创建同样的羊
Sheep sheep1 = new Sheep(sheep.getName(), sheep.getAge());
Sheep sheep2 = new Sheep(sheep.getName(), sheep.getAge());
}
}
优缺点：
- 优点是好理解，简单易操作
- 缺点是创建新对象时，需要重新获取原始对象的属性，而且总是要重新初始化对象。如果创建的对象很复杂，效率会很低
使用原型模式
先升级羊的实体类，使其具有克隆功能
public class Sheep implements Cloneable{
private String name;
private int age;
public Sheep(String name, int age) {
super();
this.name = name;
this.age = age;
}
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;
}
@Override
protected Sheep clone() {
Sheep sheep = null;
try {
sheep = (Sheep)super.clone();
} catch (CloneNotSupportedException e) {
e.printStackTrace();
}
return sheep;
}
}
Client端就可以使用sheep.clone()来复制羊了
public class Client {
public static void main(String[] args) {
// 已有的一只羊，名叫jerry, 1岁
Sheep sheep = new Sheep("jerry", 1);
// 创建同样的羊
Sheep sheep1 = sheep.clone();
Sheep sheep2 = sheep.clone();
}
}
深入讨论，浅拷贝和深拷贝
浅拷贝介绍
如果成员变量是基本数据类型，浅拷贝会直接进行值传递，也就是将该属性值复制一份给新的对象
如果成员变量是引用数据类型，如数组，类对象等，那么浅拷贝会进行引用传递，也就是将该成员变量的引用值（内存地址）复制一份给新的对象。这种情况下，新老对象的成员变量都指向同一个实例，在一个对象中修改该成员变量会影响到另一个对象的该成员变量值
如，上面的例子中，如果在Sheep类中添加一个属性Friend，然后克隆
public class Sheep implements Cloneable{
private String name;
private int age;
// 多了一个引用类型的属性
public Sheep friend;
// ... 省略，和之前一样
}
Client端
public class Client {
public static void main(String[] args) {
// 已有的一只羊，名叫jerry, 1岁
Sheep sheep = new Sheep("jerry", 1);
sheep.friend = new Sheep("tom", 2);
// 创建同样的羊
Sheep sheep1 = sheep.clone();
Sheep sheep2 = sheep.clone();
System.out.println(sheep1.friend);
System.out.println(sheep2.friend);
}
}
结果
propotype.Sheep@7852e922
propotype.Sheep@7852e922
可以看到克隆出来的所有羊的friend属性都指向同一个对象。这里如果改变了任意一只羊的friend属性，其他羊的friend的属性都会被修改。
深拷贝介绍
如果成员变量是基本数据类型，同浅拷贝一样，复制属性值给新的对象
如果成员变量是引用数据类型，为它们申请储存空间，并复制这些成员变量所引用的对象。也就是说，深拷贝会整个对象（包括对象的引用类型）进行拷贝
深拷贝有两种实现方式：重写clone方法，对象序列化（推荐）
深拷贝实现-重写clone方法
先修改Sheep类
public class Sheep implements Cloneable{
private String name;
private int age;
public Sheep friend;
// ...省略
@Override
protected Sheep clone() {
Sheep sheep = null;
try {
sheep = (Sheep)super.clone();
sheep.friend = new Sheep("tom", 2);
} catch (CloneNotSupportedException e) {
e.printStackTrace();
}
return sheep;
}
}
结果
propotype.Sheep@7852e922
propotype.Sheep@4e25154f
深拷贝实现-对象序列化
先修改Sheep类
public class Sheep implements Serializable{
private static final long serialVersionUID = 1L;
private String name;
private int age;
public Sheep friend;
// ...省略
public Sheep deepClone() {
// 流对象
ByteArrayOutputStream bos = null;
ObjectOutputStream oos = null;
ByteArrayInputStream bis = null;
ObjectInputStream ois = null;
try {
// 序列化
bos = new ByteArrayOutputStream();
oos = new ObjectOutputStream(bos);
oos.writeObject(this);
// 反序列化
bis = new ByteArrayInputStream(bos.toByteArray());
ois = new ObjectInputStream(bis);
Sheep copySheep = (Sheep)ois.readObject();
return copySheep;
} catch (Exception e) {
e.printStackTrace();
return null;
} finally{
try {
ois.close();
bis.close();
oos.close();
bos.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
结果
propotype.Sheep@214c265e
propotype.Sheep@448139f0
小结
- 创建新的对象比较复杂时，可以利用原型模式简化对象的创建过程，同时也能提高效率
- 不用重新初始化对象，而是动态获取对象运行时的状态
- 如果原始对象发生变化（增加或减少属性），其他克隆对象也会相应发生变化，无需修改代码
- 在实现深克隆的适合可能需要比较复杂的代码
- 缺点：需要为每一个配一个克隆方法。这对新的类来说不是很难，但对已有的类进行改造时，需要修改其源码，违背了ocp(Open Closed Principle)原则
