java原型模式

现在要获取一只相同的猫十只,传统模式是直接new 相同的对象new 十次,每次都要传参,总是需要重新初始化对象,而不是动态地获得对象运行时的状态, 不够灵活 。

现在用原型模式,继承cloneable接口,直接调用方法进行复制。

cat类
public class cat implements Cloneable{
private String name;
private int age;
public cat(String name, int age) {
	super();
	this.name = name;
	this.age = age;
}
@Override
	protected Object clone() throws CloneNotSupportedException {
		cat c=null;
		cat cat1 = (cat)super.clone();
		return cat1;
	}
@Override
public String toString() {
	return "cat [name=" + name + ", age=" + age + "]";
}

}
public class test {
	public static void main(String[] args) throws CloneNotSupportedException {
         cat  a=new cat("小猫",10);
          cat c1=(cat) a.clone();
          cat c2=(cat) a.clone();
          cat c3=(cat) a.clone();
          System.out.println(c1);
          System.out.println(c2);
          System.out.println(c3);
}
}

原型模式(Prototype 模式)是指:用原型实例指定创建对象的种类,并且通过拷贝这些原型,创建新的对象

原型模式是一种创建型设计模式,允许一个对象再创建另外一个可定制的对象,无需知道如何创建的细节

工作原理是:通过将一个原型对象传给那个要发动创建的对象,这个要发动创建的对象通过请求原型对象拷贝它

们自己来实施创建,即 对象.clone()

稍微注意一下,Cloneable接口是不包含任何方法的!其实这个接口仅仅是一个标志,而且这个标志也仅仅是针对 Object类中clone()方法的,如果clone类没有实现Cloneable接口,并调用了Object的clone()方法(也就是调用了 super.Clone()方法),那么Object的clone()方法就会抛出CloneNotSupportedException异常。 

Spring 中原型 bean 的创建,就是原型模式的应用

浅拷贝:

1) 对于数据类型是基本数据类型的成员变量,浅拷贝会直接进行值传递,也就是将该属性值复制一份给新的对象。

2) 对于数据类型是引用数据类型的成员变量,比如说成员变量是某个数组、某个类的对象等,那么浅拷贝会进行

引用传递,也就是只是将该成员变量的引用值(内存地址)复制一份给新的对象。因为实际上两个对象的该成

员变量都指向同一个实例。在这种情况下,在一个对象中修改该成员变量会影响到另一个对象的该成员变量值

3) 前面我们克隆猫就是浅拷贝

4) 浅拷贝是使用默认的 clone()方法来实现

c= (cat) super.clone();

引用数据类型都是来源于一个引用,其中一个副本变了,其他都要变。

深拷贝:

1) 复制对象的所有基本数据类型的成员变量值

2) 为所有引用数据类型的成员变量申请存储空间,并复制每个引用数据类型成员变量所引用的对象,直到该对象

可达的所有对象。也就是说,对象进行深拷贝要对整个对象(包括对象的引用类型)进行拷

浅拷贝是指拷贝对象时仅仅拷贝对象本身(包括对象中的基本变量),而不拷贝对象包含的引用指向的对象。深拷贝不仅拷贝对象本身,而且拷贝对象包含的引用指向的所有对象。举例来说更加清楚:对象A1中包含对B1的引用,B1中包含对C1的引用。浅拷贝A1得到A2,A2 中依然包含对B1的引用,B1中依然包含对C1的引用。深拷贝则是对浅拷贝的递归,深拷贝A1得到A2,A2中包含对B2(B1的copy)的引用,B2 中包含对C2(C1的copy)的引用。

浅拷贝代码:

public class cat implements Cloneable{
private String name;
private int age;
private dog friend;
public dog getFriend() {
	return friend;
}
public void setFriend(dog friend) {
	this.friend = friend;
}
public cat(String name, int age) {
	super();
	this.name = name;
	this.age = age;
}
@Override
	protected Object clone() throws CloneNotSupportedException {
		
		return super.clone();
		
	}
@Override
public String toString() {
	return "cat [name=" + name + ", age=" + age + "]";
}

}
狗类
public class dog implements Cloneable {
private String name;
private int age;
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;
}

}
test
public class test {
	public static void main(String[] args) throws CloneNotSupportedException {
         cat  a=new cat("小猫",10);
         dog d=new dog();
         d.setAge(20);
         d.setName("杰瑞");
         a.setFriend(d);
          cat c1=(cat) a.clone();
          cat c2=(cat) a.clone();
          cat c3=(cat) a.clone();
          System.out.println(c1+"friend"+c1.getFriend().hashCode());
          System.out.println(c2+"friend"+c2.getFriend().hashCode());
          System.out.println(c3+"friend"+c3.getFriend().hashCode());
}
}

如上,经过复制后hashcode都一样。

深拷贝:

dog类
public class dog implements Cloneable {
private String name;
private int age;
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;
}
@Override
public String toString() {
	return "dog [name=" + name + ", age=" + age + "]";
}
@Override
	protected Object clone() throws CloneNotSupportedException {
		Object o=null;
		o=super.clone();
		return o ;
	}
}
cat类
public class cat implements Cloneable{
private String name;
private int age;
private dog friend;

public dog getFriend() {
	return friend;
}
public void setFriend(dog friend) {
	this.friend = friend;
}
public cat(String name, int age) {
	super();
	this.name = name;
	this.age = age;
}
@Override
	protected Object clone() throws CloneNotSupportedException {
		cat c=null;
		c=(cat)super.clone();
		c.friend = (dog)friend.clone();
		return c;
		
	}
@Override
public String toString() {
	return "cat [name=" + name + ", age=" + age + "]";
}

}
test类
public class test {
	public static void main(String[] args) throws CloneNotSupportedException {
         cat  a=new cat("小猫",10);
         dog d=new dog();
         d.setAge(20);
         d.setName("杰瑞");
         a.setFriend(d);
          cat c1=(cat) a.clone();
          cat c2=(cat) a.clone();
          cat c3=(cat) a.clone();
          System.out.println(c1+"friend"+c1.getFriend().hashCode());
          System.out.println(c2+"friend"+c2.getFriend().hashCode());
          System.out.println(c3+"friend"+c3.getFriend().hashCode());
}
}

得出hashcode不同

还有一种序列化的方法进行深拷贝。

cat类
public class cat implements Serializable {
	private static final long serialVersionUID = 1L;
	private String name;
	private int age;
	private dog dog;
	public cat(String name, int age, deepcopy.dog dog) {
		super();
		this.name = name;
		this.age = age;
		this.dog = dog;
	}
	
	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 dog getDog() {
		return dog;
	}

	public void setDog(dog dog) {
		this.dog = dog;
	}

	public Object deepcopy() throws IOException, ClassNotFoundException {
		//将对象写到流里
		ByteArrayOutputStream bo=new ByteArrayOutputStream();
		ObjectOutputStream oo=new ObjectOutputStream(bo);
		oo.writeObject(this);
		ByteArrayInputStream bi=new ByteArrayInputStream(bo.toByteArray());
		ObjectInputStream oi=new ObjectInputStream(bi);
		
		
		return oi.readObject();
		
	}
}
dog类
public class dog implements Serializable{
	private static final long serialVersionUID = 1L;
private String name;
private int age;
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;
}

}
test
public class test {
public static void main(String[] args) throws ClassNotFoundException, IOException {
	dog d=new dog();
	d.setAge(22);
	d.setName("Jerry");
	cat c=new cat("tom",20, d);
	cat c1 = (cat)c.deepcopy();
	dog dog = c1.getDog();
	System.out.println(dog==d);//false
}
}

要想序列化对象,必须先创建一个OutputStream,然后把它嵌入ObjectOutputStream。这时就能用writeObject()方法把对象写入OutputStream。读的时候需要把InputStream嵌到ObjectInputStream中,然后再调用readObject()方法。不过这样读出来的只是一个Object的reference,因此,在用之前,还要下转型。

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值