设计模式之原型模式
原型模式 属于 创建型模式，提供创建对象的最佳方式。
原型模式
简介
用原型实例指定创建对象的种类，并且通过拷贝这些原型创建新的对象。
也就是 说 根据一个已有对象(原型实例) 创建 新的对象
作用
用于创建许多重复的对象。
当系统中需要创建相同或相似的对象时，可以通过原型模式实现。
如何实现
在java中，需要拷贝的原型类 需要实现Cloneable接口，然后重写其中的clone方法，才可以实现类的拷贝。
java中的深浅拷贝
浅拷贝：
- 当类的成员变量是基本数据类型时，浅拷贝会将原对象的属性值赋值给新对象。
- 当类中成员变量时引用数据类型时，浅拷贝 会将 原对象的引用数据类型的地址 赋值给新对象的成员变量。也就是说 两个对象共享了同一个数据。当其中一个对象修改成员变量的值时，另外一个的值也会随之改变。
深拷贝：
无论是 基本数据类型还是引用数据类型，都会去开辟额外的空间给新对象。不会 出现浅拷贝中存在的问题。
当一个类中只有 基本数据类型时，浅拷贝与深拷贝 是同样的。
当一个类中含有 引用数据类型是，浅拷贝只是拷贝一份引用，修改浅拷贝的值，原来的也会跟着变化。
说的晕晕的，来一个实例看看效果。
实例
有一个叫张三的人，他想克隆自己，减轻自己的工作任务。
要实现克隆，需要实现Cloneable标志接口，并实现里面的clone方法。
浅拷贝
Person类
- 类中为基本数据类型
- 注意，String 不是基本数据类型，但是因为String 是final 修饰的。改变这个值 其实是new 一个新String对象,所以不会影响之前的原对象。
public class Person implements Cloneable {
//姓名与职业
private String name;
private String occupation;
//省略get set 有参构造方法 以及重写toString方法
@Override
protected Object clone() {//重写clone方法
Person person= null;
try {
person = (Person)super.clone();
} catch (CloneNotSupportedException e) {
e.printStackTrace();
}
return person;
}
}
Client类
public class Client {
public static void main(String[] args) throws CloneNotSupportedException {
Person person = new Person("张三","程序员");
Person clonePerson= (Person)person.clone();
System.out.println(person);
System.out.println(clonePerson);
clonePerson.setName("李四");
System.out.println(person);
System.out.println(clonePerson);
}
}
Person{name='张三', occupation='程序员'} Person{name='张三', occupation='程序员'} Person{name='张三', occupation='程序员'} Person{name='李四', occupation='程序员'}
修改clone 对象的值 不影响 原对象的值。
- 类中含有 引用数据类型的对象
此时 在添加一个引用数据类型的对象 Computer;
Computer类
public class Computer implements Cloneable{
//品牌与颜色
private String color;
private String brand;
//省略get set 有参构造方法 以及重写toString方法
@Override
protected Object clone() {
Computer computer= null;
try {
computer = (Computer)super.clone();
} catch (CloneNotSupportedException e) {
e.printStackTrace();
}
return computer;
}
}
//添加一个引用类型的数据
private Computer computer;
//更改toString 方法
再次使用Clone方法。
public class Client2 {
public static void main(String[] args) {
Computer computer = new Computer("red","xiaomi");
Person person = new Person("张三","程序员",computer);
Person clonePerson = (Person)person.clone();
System.out.println(person);
System.out.println(clonePerson);
//使用克隆对象修改 电脑属性值
clonePerson.getComputer().setBrand("huawei");
clonePerson.getComputer().setColor("black");
System.out.println("克隆对象修改值后");
System.out.println(person);
System.out.println(clonePerson);
}
}
结果
修改克隆对象的属性值，会将原对象的属性值一起改变。
Computer 引用类型 被克隆时，只是将原有的地址 指向了被克隆的对象。
此时 Computer 还只是一个对象。只是有两个引用指向同一份地址，一个地址中存放着一个值。
其中一个引用改变 了地址中的内容，另外一个也会跟着改变。
深拷贝
方式一
使用 两层浅拷贝实现。
此时 我们使用深拷贝。 将Computer 对象也复制一份。
我们在 clone() 方法中这样写
@Override
protected Object clone() {
Person person= null;
try {
person = (Person)super.clone();//将基本类型 复制
person.computer = (Computer) person.getComputer().clone();//将引用类型 也复制一份。
} catch (CloneNotSupportedException e) {
e.printStackTrace();
}
return person;
}
此时 再次运行。
此时，进行的复制 是将整个引用类型的对象，开辟了另外的空间。
复制的对象 与原有的对象 不再共享同一个Computer.
其实这种方式 也是属于浅层次的拷贝，因为 Computer类中数据类型 是基本数据类型。
如果 Computer 类中 还有 一层引用数据类型的话，那还需要在 clone 方法中在添加一层，才可以实现真正的 深拷贝。
不太推荐使用这种方式。
方式二
使用 序列化对象实现 深拷贝
Person,Computer需要 实现Serializable接口
具体代码如下
public Person deepClone(){
//声明流对象
ByteArrayOutputStream bos = null;
ByteArrayInputStream bis = null;
ObjectOutputStream oos = null;
ObjectInputStream ois = null;
try {
//创建序列化流
bos = new ByteArrayOutputStream();
oos = new ObjectOutputStream(bos);
//将当前对象以对象流的方式输出
oos.writeObject(this);
//创建反序化流
bis = new ByteArrayInputStream(bos.toByteArray());
ois = new ObjectInputStream(bis);
//将流对象反序列化，实现类的深拷贝。
return (Person) ois.readObject();
} catch (Exception e) {
e.printStackTrace();
return null;
}finally {
try {
//关闭资源
bos.close();
bis.close();
oos.close();
ois.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
测试
public static void main(String[] args) {
Computer computer = new Computer("red","xiaomi");
Person person = new Person("张三","程序员",computer);
Person clonePerson = person.deepClone();
clonePerson.getComputer().setBrand("huawei");
clonePerson.getComputer().setColor("black");
System.out.println("克隆对象修改后");
System.out.println(person);
System.out.println(clonePerson);
}
结果
同样能够实现类的深拷贝。
总结
本篇文章 讲了 原型模式的例子。
以及java 中 浅拷贝与深拷贝的区别，以及 深拷贝的两种实现方式。推荐使用序列化对象的方式，实现深拷贝。
有帮助还请点赞哦！