什么是原型模式
这种模式是实现了一个原型接口，该接口用于创建当前对象的克隆。当直接创建对象的代价比较大时，则采用这种模式。例如，一个对象需要在一个高代价的数据库操作之后被创建。我们可以缓存该对象，在下一个请求时返回它的克隆，在需要的时候更新数据库，以此来减少数据库调用。
原型模式的特点
- 由原型对象自身创建目标对象。也就是说，对象创建这一动作发自原型对象本身。
2.目标对象是原型对象的一个克隆。也就是说，通过Prototype模式创建的对象，不仅仅与原型对象具有相同的结构，还与原型对象具有相同的值。
3.根据对象克隆深度层次的不同，有浅度克隆与深度克隆。
原型模式使用场景
1、资源优化场景。
2、类初始化需要消化非常多的资源，这个资源包括数据、硬件资源等。
3、性能和安全要求的场景。
4、通过 new 产生一个对象需要非常繁琐的数据准备或访问权限，则可以使用原型模式。
5、一个对象多个修改者的场景。
6、一个对象需要提供给其他对象访问，而且各个调用者可能都需要修改其值时，可以考虑使用原型模式拷贝多个对象供调用者使用。
7、在实际项目中，原型模式很少单独出现，一般是和工厂方法模式一起出现，通过 clone 的方法创建一个对象，然后由工厂方法提供给调用者。原型模式已经与 Java 融为浑然一体，大家可以随手拿来使用。
代码体现
import java.util.ArrayList;
import java.util.List;
public class Person implements Cloneable{
// 姓名
private String name;
// 年龄
private int age;
// 性别
private String sex;
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 String getSex() {
return sex;
}
public void setSex(String sex) {
this.sex = sex;
}
public Person clone() {
try {
Person person = (Person)super.clone();
return person;
} catch (CloneNotSupportedException e) {
e.printStackTrace();
return null;
}
}
}
import java.util.ArrayList;
import java.util.List;
public class MainClass {
public static void main(String[] args) {
Person person1 = new Person();
person1.setName("lifengxing");
person1.setAge(30);
person1.setSex("男");
Person person2 = person1;
//先注释这一句，保留上面
//Person person2 = person1.clone();
System.out.println("person1的hashcode值："+person1.hashCode());
System.out.println(person1.getName());
System.out.println(person1.getAge());
System.out.println(person1.getSex());
System.out.println("person2的hashcode值："+person2.hashCode());
System.out.println(person2.getName());
System.out.println(person2.getAge());
System.out.println(person2.getSex());
}
}
运行结果：
public class MainClass {
public static void main(String[] args) {
Person person1 = new Person();
person1.setName("lifengxing");
person1.setAge(30);
person1.setSex("男");
//注释这一句，保留下面
//Person person2 = person1;
Person person2 = person1.clone();
System.out.println("person1的hashcode值："+person1.hashCode());
System.out.println(person1.getName());
System.out.println(person1.getAge());
System.out.println(person1.getSex());
System.out.println("person2的hashcode值："+person2.hashCode());
System.out.println(person2.getName());
System.out.println(person2.getAge());
System.out.println(person2.getSex());
}
}
运行结果
上面的运行结果说明，某个类只要实现了cloneable接口，就能在客户端不用new关键字就可以创建对象，节省了类初始化消耗掉的很多资源
深度克隆和浅克隆的区别
浅克隆是指当一个类包含有引用类型的属性时，他并不能把该属性的值一并克隆过去给另外一个对象，他只能克隆该用用类型属性的引用，这就是浅克隆
举例：（把上面的person类再加一个属性：private List
import java.util.ArrayList;
import java.util.List;
public class Person implements Cloneable{
// 姓名
private String name;
// 年龄
private int age;
// 性别
private String sex;
//朋友
private List<String> friends;
public List<String> getFriends() {
return friends;
}
public void setFriends(List<String> friends) {
this.friends = friends;
}
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 String getSex() {
return sex;
}
public void setSex(String sex) {
this.sex = sex;
}
public Person clone() {
try {
Person person = (Person)super.clone();
return person;
} catch (CloneNotSupportedException e) {
e.printStackTrace();
return null;
}
}
}
import java.util.ArrayList;
import java.util.List;
public class MainClass {
public static void main(String[] args) {
Person person1 = new Person();
List<String> friends = new ArrayList<String>();
friends.add("James");
friends.add("Yao");
person1.setFriends(friends);
Person person2 = person1.clone();
System.out.println("person1的朋友"+person1.getFriends());
System.out.println("person2的朋友"+person2.getFriends());
//把朋友集合加一个元素
friends.add("Mike");
//把这个集合重新设置成person1的friends属性值，即person1加了一个朋友
person1.setFriends(friends);
System.out.println("person1加了一个朋友后的朋友"+person1.getFriends());
System.out.println("person2在person1加了一个朋友后的的朋友"+person2.getFriends());
}
}
运行结果
下面实现深度克隆
import java.util.ArrayList;
import java.util.List;
public class Person implements Cloneable{
// 姓名
private String name;
// 年龄
private int age;
// 性别
private String sex;
//朋友
private List<String> friends;
public List<String> getFriends() {
return friends;
}
public void setFriends(List<String> friends) {
this.friends = friends;
}
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 String getSex() {
return sex;
}
public void setSex(String sex) {
this.sex = sex;
}
public Person clone() {
try {
Person person = (Person)super.clone();
//new一个新的集合对象，肯定和上面的呢个属性的实例不一样吧
List<String> newfriends = new ArrayList<String>();
//遍历愿原有的friends(this.getFriends()),把原有的值添加到这个新的集合对象中
for(String friend : this.getFriends()) {
newfriends.add(friend);
}
//再把这个集合对象设置到要克隆的person中去
person.setFriends(newfriends);
return person;
} catch (CloneNotSupportedException e) {
e.printStackTrace();
return null;
}
}
}
import java.util.ArrayList;
import java.util.List;
public class MainClass {
public static void main(String[] args) {
Person person1 = new Person();
List<String> friends = new ArrayList<String>();
friends.add("James");
friends.add("Yao");
person1.setFriends(friends);
Person person2 = person1.clone();
System.out.println("person1的朋友"+person1.getFriends());
System.out.println("person2的朋友"+person2.getFriends());
//把朋友集合加一个元素
friends.add("Mike");
//把这个集合重新设置成person1的friends属性值，即person1加了一个朋友
person1.setFriends(friends);
System.out.println("person1加了一个朋友后的朋友"+person1.getFriends());
System.out.println("person2在person1加了一个朋友后的的朋友"+person2.getFriends());
}
}
运行结果
