看了一些文章,感觉总结的语言不太好懂,所以自己写一篇。
一、原型模式是什么?
原型模式是一种对象创建型模式(这23种模式怎么分类等我学完最后总结),它采取复制原型对象的方法来创建对象的实例。使用原型模式创建的实例,具有与原型一样的数据。
二、原型模式的特点
1.由原型对象自身创建目标对象。也就是说,对象创建这一动作发自原型对象本身。
2.目标对象是原型对象的一个克隆。也就是说,通过原型模式创建的对象,不仅仅与原型对象具有相同的结构,还与原型对象具有相同的值。
3.根据对象克隆深度层次的不同,有浅克隆和深克隆。
三、原型模式应用场景
在创建对象的时候,我们不只是希望被创建对象基础其基类的基本结构,还希望继承原型对象的数据。
希望对目标对象的修改不影响既有的原型对象(深度克隆的可以完全互不影响)。
隐藏克隆的细节。
实现比较
先创建两个class文件,一个Person类,一个MainClass类。
public class Person{
String name;
int 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 MainClass {
public static void main(String[] args) {
Person person1=new Person();
person1.setName("aa");
person1.setAge(10);
Person person2=new Person();
System.out.println(person1.getName());
System.out.println(person2.getName());
}
}
这时运行结果是。
将person2的声明处改成
Person person2=person1;
运行结果是。这时person1和person2的name都是“aa”,看起来好像复制了。
但是这种方法是将person1的地址赋值给了person2,也就是说,对象只有person1一个,person2只是跟person1指向了同一个地址。
将Person类改成如下:实现了Cloneable接口,重写了clone()方法。
public class Person implements Cloneable{
String name;
int 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 Person clone() {
try {
return (Person) super.clone();
} catch (CloneNotSupportedException e) {
e.printStackTrace();
return null;
}
}
}
将person2的声明处改成
Person person2=person1.clone();
运行结果是,这时在堆中复制了一个person1对象,由person2指向它。
上面类的属性都是值类型,那如果是引用类型呢?这就出现了浅克隆和深克隆的问题。
给Person类增加一个引用类型的属性,同时增加它的get、set方法。如下:
private List<String> friends;
public List<String> getFriends() {
return friends;
}
public void setFriends(List<String> friends) {
this.friends = friends;
}
主函数如下:
public static void main(String[] args) {
Person person1=new Person();
List<String> friends=new ArrayList<>();
friends.add("bb");
friends.add("cc");
person1.setFriends(friends);
Person person2=person1.clone();
System.out.println(person1.getFriends());
System.out.println(person2.getFriends());
}
运行结果是。
这时再给person1添加一个friend,主函数如下:
public static void main(String[] args) {
Person person1=new Person();
List<String> friends=new ArrayList<>();
friends.add("bb");
friends.add("cc");
person1.setFriends(friends);
Person person2=person1.clone();
System.out.println(person1.getFriends());
System.out.println(person2.getFriends());
friends.add("dd");
person1.setFriends(friends);
System.out.println(person1.getFriends());
System.out.println(person2.getFriends());
}
运行结果是,这时就发现了问题,要添加的是person1的朋友,但是结果里面person2的朋友也多了一个。
这是因为对于引用类型的变量,复制的不是引用变量,而是它的地址,使person2的friends指向了person1的friends的地址。
这就是浅克隆。
那怎么样让person2真正的克隆到person1的引用类型变量呢??
将Person类中的clone()方法做如下修改,使引用类型变量在clone()方法中进行复制。
public Person clone() {
try {
Person person=(Person) super.clone();
List<String> friends=new ArrayList<>();
for(String friend : this.getFriends()) {
friends.add(friend);
}
person.setFriends(friends);
return person;
} catch (CloneNotSupportedException e) {
e.printStackTrace();
return null;
}
}
这时运行结果是,实现了真正的复制。
这就是深克隆。