【Java】好似你，饼印咁：原型模式、浅拷贝与深拷贝

0x01：原型模式简介

用原型实例指定创建对象的种类，并且通过拷贝这些原型创建新的对象。大概意思就是：允许一个对象再创建另外一个可定制的对象，根本无需知道对象创建的细节。其工作原理是通过将一个原型对象传给那个要发动创建的对象，这个要发动创建的对象通过请求原型对象拷贝它们自己来实施创建。其UML类图如下：
【Java】好似你，饼印咁：原型模式、浅拷贝与深拷贝

主要角色如下：

  • Prototype：为原型类，声明一个克隆自身的接口；

  • ConcretePrototype：为具体实现类，实现一个克隆自身的操作；

  • Client（客户端）只需让一个原型克隆自身，就可以创建一个新的对象。

原型模式主要用于对象的拷贝，其核心是就是类图中的原型类Prototype，其一般是一个java抽象类或是一个接口，定义了具体原型类所需要的实现的方法。

0x02：原型模式的实现

原型类Prototype

public abstract class Prototype {
private String name;
private String sex;
public Prototype() {
}
public Prototype(String name, String sex) {
super();
this.name = name;
this.sex = sex;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getSex() {
return sex;
}
public void setSex(String sex) {
this.sex = sex;
}
//声明一个实现克隆自身的方法
public abstract Prototype clone();
}

具体实现类ConcretePrototype

public class ConcretePrototype extends Prototype{
public ConcretePrototype(String name, String sex) {
super(name, sex);
}
@Override
public ConcretePrototype clone() {
return new ConcretePrototype(this.getName(), this.getSex());
}
}

原型模式测试代码

public class Client {
public static void main(String[] args) {
ConcretePrototype p = new ConcretePrototype("Hello", "gril");
ConcretePrototype c = (ConcretePrototype) p.clone();
System.out.println(c.getName() + ", " + c.getSex());
}
}

0x03：JDK中浅拷贝、深拷贝与原型模型

Java赋值是复制对象引用，如果想要得到一个对象的副本，使用赋值操作是无法达到目的的

普通pojo对象Person

public class Person {
private String name;
private int age;
//省略getter  setter
}

测试代码

public static void main(String[] args) {
Person p1 = new Person();
p1.setAge(31);
p1.setName("java乐园");
Person p2 = p1;
System.out.println(p1==p2);// true
}

如果创建一个对象的新的副本，也就是说他们的初始状态完全一样，但以后可以改变各自的状态，而互不影响，就需要用到Java中对象的复制，如原生的clone()方法。如何进行对象克隆呢？

Object对象有个clone()方法，实现了对象中各个属性的复制，但它的可见范围是protected的，所以实体类使用克隆的前提是：

实现Cloneable接口，这是一个标记接口，自身没有任何方法；

覆盖clone()方法，可见性提升为public；

public class Person implements Cloneable{
private String name;
private int age;
//省略getter  setter
@Override
protected Object clone() throws CloneNotSupportedException {
return super.clone();
}
}

测试代码

public static void main(String[] args) throws Exception{
Person p1=new Person();
p1.setAge(31);
p1.setName("java乐园");
Person p2=(Person) p1.clone();
System.out.println(p1 == p2);//false
p2.setName("架构师知音");
System.out.println("p1 = " + p1.getName() + ", " + p1.getAge()); // p1 = java乐园, 31
System.out.println("p2 = " + p2.getName() + ", " + p2.getAge()); //p2 = 架构师知音, 31
}

该测试用例只有两个基本类型的成员变量，测试目的达到。好像没有任何问题？为Person增加一个地址的引用类型成员变量Address

public class Address {
private String city;
private String street;
//省略getter  setter
}

Person增加Address成员对象

public class Person implements Cloneable{
private String name;
private int age;
private Address address;
//省略 getter  setter
@Override
protected Object clone() throws CloneNotSupportedException {
return super.clone();
}
}

测试代码

public static void main(String[] args) throws Exception{
Address address=new Address();
address.setStreet("天庭88号");
address.setCity("魔都");
Person p1=new Person();
p1.setAge(31);
p1.setName("java乐园");
p1.setAddress(address);
Person p2=(Person) p1.clone();
System.out.println(p1 == p2); //false
p2.getAddress().setCity("广东");
System.out.println("p1=" + p1.getAddress().getCity());
System.out.println("p2="+  p2.getAddress().getCity());
}

遇到了麻烦，只修改了p2的城市，两个地址城市都变成了“广东”。这个实例是浅拷贝和深拷贝的典型用例。

浅拷贝：被复制对象的所有值属性都含有与原来对象的相同，而所有的对象引用属性仍然指向原来的对象。

深拷贝：在浅拷贝的基础上，所有引用其他对象的变量也进行了clone，并指向被复制过的新对象。

也就是说，一个默认的clone()方法实现机制，仍然是赋值。

如果一个被复制的属性都是基本类型，那么只需要实现当前类的cloneable机制就可以了，此为浅拷贝；如果被复制对象的属性包含其他实体类对象引用，那么这些实体类对象都需要实现Cloneable接口并覆盖clone()方法。对Address做以下修改：

public class Address implements Cloneable {
private String city;
private String street;
//省略 getter  setter
@Override
protected Object clone() throws CloneNotSupportedException {
return super.clone();
}
}

通过以上案例可以看出通过Cloneable接口并覆盖Object类的clone()方法就很方便的实现了原型模式。

参考：https://www.cnblogs.com/xuanxufeng/p/6558330.html

以上是 【Java】好似你，饼印咁：原型模式、浅拷贝与深拷贝 的全部内容， 来源链接： utcz.com/a/95871.html

回到顶部