java 设计模式 prototype_Java设计模式---原型模式(Prototype)

1.  原型模式(Prototype)定义:

用原型实例指定创建对象的种类,并且通过拷贝这些原型得到行的实例

2.  实现方式:

实现Cloneable接口。在java语言有一个Cloneable接口,它的作用只有一个,就是在运行时通知虚拟机可以安全地在实现了此接口的类上使用clone方法。在java虚拟机中,只有实现了这个接口的类才可以被拷贝,否则在运行时会抛出CloneNotSupportedException异常。

重写Object类中的clone方法。Java中,所有类的父类都是Object类,Object类中有一个clone方法,作用是返回对象的一个拷贝,但是其作用域protected类型的,一般的类无法调用,因此,Prototype类需要将clone方法的作用域修改为public类型。

3. 原型模式的注释事项:

1.  构造方法不会执行

一个实现了Cloneable并重写了clone方法的类A,有一个无参构造或有参构造B,通过new关键字产生了一个对象S,再然后通过S.clone()方式产生了一个新的对象T,那么在对象拷贝时构造函数B是不会被执行的。因为Object类的clone方法的原理是从内存中(具体的说就

是堆内存)以二进制流的方式进行拷贝,重新分配一个内存块。

2.  浅复制与深复制

浅复制:将一个对象复制后,基本数据类型的变量都会重新创建,而引用类型,指向的还是原对象所指向的,所以浅复制是不安全的(如果原来的实例被修改,那么新的实例也会跟着变化或者复制产生的实例被修改,原实例会发生变化)。

对于浅复制: 类引用的成员变量必须满足两个条件才不会被拷贝:1.是类的成员变量而不是方法内变量;2必须是一个可变的引用对象,而不是一个原始类型或者不可变对象(包括int、long、char等及其对象类型[Integer、Long]、String)

深复制:将一个对象复制后,不论是基本数据类型还有引用类型,都是重新创建的。简单来说,就是深复制进行了完全彻底的复制,而浅复制不彻底。

4. 浅复制与深复制的示例代码:

辅助User类

public class User implements Serializable{

/**

*

*/

private static final long serialVersionUID = 1L;

private String username;

private String phone;

public User(String username,String phone){

this.username=username;

this.phone=phone;

}

public String getUsername() {

return username;

}

public void setUsername(String username) {

this.username = username;

}

public String getPhone() {

return phone;

}

public void setPhone(String phone) {

this.phone = phone;

}

}原型类:

public class Prototype implements Cloneable ,Serializable{

/**

*

*/

private static final long serialVersionUID = 1L;

private String str;

private User user;

public User getUser() {

return user;

}

public void setUser(User user) {

this.user = user;

}

public String getStr() {

return str;

}

public void setStr(String str) {

this.str = str;

}

/*

* 浅复制

*/

@Override

public Object clone() throws CloneNotSupportedException {

Prototype up=(Prototype) super.clone();

return up;

}

/**

* 深复制

* @return

* @throws IOException

* @throws ClassNotFoundException

*/

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);

Object obj=ois.readObject();

return obj;

}

public static void main(String[] args) {

Prototype obj=new Prototype();

User user=new User("aaaa", "13321352222");

obj.setStr("原型模式");

obj.setUser(user);

try {

//浅复制对象

System.out.println("浅克隆前的obj-user的username为:"+obj.getUser().getUsername());

Prototype copyObj=(Prototype) obj.clone();

System.out.println("浅克隆后的obj-user的username为:"+obj.getUser().getUsername());

System.out.println("浅克隆后的copyObj-user的username为:"+copyObj.getUser().getUsername());

user.setUsername("vvvv");

System.out.println("浅克隆后修改user后obj的username为:"+obj.getUser().getUsername());

System.out.println("浅克隆后修改user后copyObj的username为:"+copyObj.getUser().getUsername());

//深复制对象

Prototype deepCopyObj=(Prototype) obj.deepClone();

System.out.println("深克隆后deepCopyObj的username为:"+deepCopyObj.getUser().getUsername());

user.setUsername("pppp");

System.out.println("深隆后修改user后deepCopyObj的username为:"+deepCopyObj.getUser().getUsername());

System.out.println("深隆后修改user后obj的username为:"+obj.getUser().getUsername());

} catch (CloneNotSupportedException e) {

e.printStackTrace();

} catch (ClassNotFoundException e) {

e.printStackTrace();

} catch (IOException e) {

e.printStackTrace();

}

}

}测试结果:

浅克隆前的obj-user的username为:aaaa

浅克隆后的obj-user的username为:aaaa

浅克隆后的copyObj-user的username为:aaaa

浅克隆后修改user后obj的username为:vvvv

浅克隆后修改user后copyObj的username为:vvvv

深克隆后deepCopyObj的username为:vvvv

深隆后修改user后deepCopyObj的username为:vvvv

深隆后修改user后obj的username为:pppp结果分析:

从结果来看,浅复制之后修改了user的内容,2个对象都发生了变化,而深复制之后修改user,只是原对象发生了改变,复制产生的对象并没有发生变化。所以这也验证了:Object类提供的方法clone只是拷贝本对象,其对象内部的数组、引用对象等都不拷贝,还是指向原生对象的内部元素地址

上述代码中的深复制通过读取序列化后的对象二进制流的方式实现,所以User类和原型类均实现了Serializable接口

5. 原型模式的优点:

原型模式是在内存二进制流的拷贝,要比直接new一个对象性能好很多,特别是要在一个循环体内产生大量的对象时,原型模式可以更好的体现其优点。

  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值