原型模式概念
该模式的思想就是将一个对象作为原型,对其进行复制、克隆,产生一个和原对象类似的新对象。java中复制通过clone()实现的。clone中涉及深、浅复制。深、浅复制的概念如下:
⑴浅复制(浅克隆)
被复制对象的所有变量都含有与原来的对象相同的值,而所有的对其他对象的引用仍然指向原来的对象。换言之,浅复制仅仅复制所考虑的对象,而不复制它所引用的对象。 Object类提供的方法clone只是拷贝本对象,其对象内部的数组、引用对象等都不拷贝,还是指向原生对象的内部元素地址
⑵深复制(深克隆)
被复制对象的所有变量都含有与原来的对象相同的值,除去那些引用其他对象的变量。那些引用其他对象的变量将指向被复制过的新对象,而不再是原有的那些被引用的对象。换言之,深复制把要复制的对象所引用的对象都复制了一遍。
原型模式代码
package com.roc.prototype;
import java.io.Serializable;
/**
* 原型模式 程序员
* @author liaowp
*
*/
public class Programmer implements Serializable,Cloneable{
/**
*
*/
private static final long serialVersionUID = 3078949912404836178L;
private String name;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Programmer clone() throws CloneNotSupportedException {
Programmer proto = (Programmer) super.clone();
return proto;
}
}
下面写一个浅复制的例子
package com.roc.prototype;
/**
* 地址
* @author liaowp
*
*/
public class Address{
private String province;//省
private String city;//市
public Address(String province,String city){
this.province=province;
this.city=city;
}
public String getProvince() {
return province;
}
public void setProvince(String province) {
this.province = province;
}
public String getCity() {
return city;
}
public void setCity(String city) {
this.city = city;
}
}
package com.roc.prototype;
/**
* 原型模式 程序员
* @author liaowp
*
*/
public class Programmer implements Cloneable{
private String name;//名字
private Address address;
public Programmer(String name,Address address){
this.name=name;
this.address=address;
}
public Address getAddress() {
return address;
}
public void setAddress(Address address) {
this.address = address;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Object clone() throws CloneNotSupportedException {
Programmer proto = (Programmer) super.clone();
return proto;
}
}
package com.roc.prototype;
/**
* 原型模式
* @author liaowp
*
*/
public class Client {
public static void main(String[] args) throws CloneNotSupportedException {
//浅复制复制
Address address=new Address("jx","gz");
Programmer a=new Programmer("liaowp",address);
a.setAddress(new Address("jx", "gz"));
a.setName("liaowp");
Programmer b=(Programmer) a.clone();
b.setName("pwl");
b.getAddress().setProvince("bj");
System.err.println(b.getName()+b.getAddress().getProvince());
System.err.println(a.getName()+a.getAddress().getProvince());
}
}
输出结果:pwlbj
liaowpbj
可以看出来对象并复制,依然使用的是同一个引用。其对象内部的数组、引用对象等都不拷贝,还是指向原生对象的内部元素地址。下面看深复制的写法,深复制有2种写法,一种是对象实现Cloneable,另外一种是二进制流。我都一起写了。
package com.roc.prototype;
/**
* 原型模式 程序员
* @author liaowp
*
*/
public class Programmer implements Cloneable{
private String name;//名字
private Address address;
public Programmer(String name,Address address){
this.name=name;
this.address=address;
}
public Address getAddress() {
return address;
}
public void setAddress(Address address) {
this.address = address;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Object clone() throws CloneNotSupportedException {
Programmer proto = (Programmer) super.clone();
proto.address=(Address) address.clone();
return proto;
}
}
package com.roc.prototype;
/**
* 地址
* @author liaowp
*
*/
public class Address implements Cloneable{
private String province;//省
private String city;//市
public Object clone(){
Address address = null;
try {
address = (Address) super.clone();
} catch (CloneNotSupportedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
return address;
}
public Address(String province,String city){
this.province=province;
this.city=city;
}
public String getProvince() {
return province;
}
public void setProvince(String province) {
this.province = province;
}
public String getCity() {
return city;
}
public void setCity(String city) {
this.city = city;
}
/* 深复制 */ 二进制的写法,需要类序列化
public Object deepClone() throws IOException, ClassNotFoundException {
/* 写入当前对象的二进制流 */
ByteArrayOutputStream bos = new ByteArrayOutputStream();
ObjectOutputStream oos = new ObjectOutputStream(bos);
oos.writeObject(this);
/* 读出二进制流产生的新对象 */
ByteArrayInputStream bis = new ByteArrayInputStream(bos.toByteArray());
ObjectInputStream ois = new ObjectInputStream(bis);
return ois.readObject();
}
}
package com.roc.prototype;
/**
* 原型模式
* @author liaowp
*
*/
public class Client {
public static void main(String[] args) throws CloneNotSupportedException {
//浅复制复制
Address address=new Address("jx","gz");
Programmer a=new Programmer("liaowp",address);
a.setAddress(new Address("jx", "gz"));
a.setName("liaowp");
Programmer b=(Programmer) a.clone();
b.setName("pwl");
b.getAddress().setProvince("bj");
System.err.println(b.getName()+b.getAddress().getProvince());
System.err.println(a.getName()+a.getAddress().getProvince());
}
}
结果:pwlbj
liaowpjx
拷贝还有2个知识点,对象拷贝时,类的构造函数是不会被执行的。一个实现了 Cloneable 并重写了 clone 方法的类 Programmer,有一个无参构造或有参构造 ,通过 new 关键字产生了一个对象 A,再然后通过 A.clone()方式产生了一个新的对象 T,那么在对象拷贝时构造函数是不会被执行的。即拷贝的过程中只执行一次构造方法。
Clone 与 final 两对冤家。对象的 clone 与对象内的 final 属性是由冲突.在上面的Programmer类中修改为private final Address address;去掉get,set方法, proto.address=(Address) address.clone();这一句就会报错: proto.address=(Address) address.clone();final类型不能重新设置值。解决办法就是删除掉fina咯
深拷贝和浅拷贝建议不要混合使用,一个类中某些引用使用深拷贝某些引用使用浅拷贝,这是一种非常差的设计,特别是是在涉及到类的继承,父类有几个引用的情况就非常的复杂,建议深拷贝和浅拷贝分开实现。