设计模式学习笔记-原型模式

最新推荐文章于 2020-11-21 16:40:06 发布

一年而已

最新推荐文章于 2020-11-21 16:40:06 发布

阅读量150

点赞数

本文链接：https://blog.csdn.net/weixin_44406146/article/details/105990995

版权

设计模式专栏收录该内容

23 篇文章 0 订阅

订阅专栏

克隆羊问题

现有一只羊tom，具有姓名、年龄、颜色等属性，请克隆出多只完全相同的羊

传统的解决方法

在这里插入图片描述
代码
1.定义一个Sheep类

public class Sheep {
	private String name;
	private int age;
	private String color;
	public Sheep(String name, int age, String color) {
		super();
		this.name = name;
		this.age = age;
		this.color = color;
	}
	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 String getColor() {
		return color;
	}
	public void setColor(String color) {
		this.color = color;
	}
	@Override
	public String toString() {
		return "Sheep [name=" + name + ", age=" + age + ", color=" + color + "]";
	}
}

2.客户端创建羊

public class Client {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		//传统的方法
		Sheep sheep = new Sheep("tom", 1, "白色");
		
		Sheep sheep2 = new Sheep(sheep.getName(), sheep.getAge(), sheep.getColor());
		Sheep sheep3 = new Sheep(sheep.getName(), sheep.getAge(), sheep.getColor());
		Sheep sheep4 = new Sheep(sheep.getName(), sheep.getAge(), sheep.getColor());
		Sheep sheep5 = new Sheep(sheep.getName(), sheep.getAge(), sheep.getColor());
		//....
		
		System.out.println(sheep);
		System.out.println(sheep2);
		System.out.println(sheep3);
		System.out.println(sheep4);
		System.out.println(sheep5);
		//...
	}

}

优缺点： 好理解，但是在创建对象时总是需要重新获取类的属性，假如属性很复杂那么创建效率会很低

改进思路: Java中Object类提供了clone()方法，该方法可以将一个java对象复制一份，但是需要实现clone方法的java类实现Cloneable接口，该接口表示该类具有复制能力并且能够复制–>原型模式

原型模式

基本介绍

原型模式是指用原型实例指定创建对象的种类，并且通过拷贝这些原型，创建对象
原型模式是创建型设计模式，允许一个对象再创建另一个可定制化的对象，无需知道创建细节
原理为通过将一个原型对象传给要发动创建的对象，这个要发动创建的对象通过请求原型对象拷贝他们自己来实施创建，即对象.clone()

原理结构图
在这里插入图片描述

Prototype：原型类，声明一个克隆自己的接口
ConcretePrototype:具体原型类，实现一个克隆自己的操作

代码实现
1.修改羊类，注意添加了引用变量

//实现Cloneable接口 标志作用
public class Sheep implements Cloneable {
	private String name;
	private int age;
	private String color;
	private String address = "蒙古羊";
	public Sheep friend; //是对象, 克隆是会如何处理
	public Sheep(String name, int age, String color) {
		super();
		this.name = name;
		this.age = age;
		this.color = color;
	}
	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 String getColor() {
		return color;
	}
	public void setColor(String color) {
		this.color = color;
	}
	@Override
	public String toString() {
		return "Sheep [name=" + name + ", age=" + age + ", color=" + color + ", address=" + address + "]";
	}
	
	//克隆该实例，使用默认的clone方法来完成
	@Override
	protected Object clone()  {
		
		Sheep sheep = null;
		try {
			sheep = (Sheep)super.clone();
		} catch (Exception e) {
			// TODO: handle exception
			System.out.println(e.getMessage());
		}
		// TODO Auto-generated method stub
		return sheep;
	}
}

2.Client类中克隆

public class Client {

	public static void main(String[] args) {
		System.out.println("原型模式完成对象的创建");
		// TODO Auto-generated method stub
		Sheep sheep = new Sheep("tom", 1, "白色");
		
		sheep.friend = new Sheep("jack", 2, "黑色");
		
		Sheep sheep2 = (Sheep)sheep.clone(); //克隆
		Sheep sheep3 = (Sheep)sheep.clone(); //克隆
		Sheep sheep4 = (Sheep)sheep.clone(); //克隆
		Sheep sheep5 = (Sheep)sheep.clone(); //克隆
		
		System.out.println("sheep2 :" +"hashcode="+sheep2.hashCode()+ sheep3 +"sheep2.friend=" + sheep2.friend.hashCode());
		System.out.println("sheep3 :" +"hashcode="+sheep3.hashCode()+ sheep3 + "sheep3.friend=" + sheep3.friend.hashCode());
		System.out.println("sheep4 :" +"hashcode="+sheep4.hashCode()+ sheep4 + "sheep4.friend=" + sheep4.friend.hashCode());
		System.out.println("sheep5 :" +"hashcode="+sheep5.hashCode() + sheep5 + "sheep5.friend=" + sheep5.friend.hashCode());
	}

}

3.输出结果

原型模式完成对象的创建
sheep2 :hashcode=366712642Sheep [name=tom, age=1, color=白色, address=蒙古羊]sheep2.friend=1829164700
sheep3 :hashcode=2018699554Sheep [name=tom, age=1, color=白色, address=蒙古羊]sheep3.friend=1829164700
sheep4 :hashcode=1311053135Sheep [name=tom, age=1, color=白色, address=蒙古羊]sheep4.friend=1829164700
sheep5 :hashcode=118352462Sheep [name=tom, age=1, color=白色, address=蒙古羊]sheep5.friend=1829164700

存在问题
当一个实例中存在引用变量时，克隆后引用变量的没有产生克隆效果，还是指向同一个对象，这就是浅拷贝。

浅拷贝与深拷贝

浅拷贝

对于基本数据类型的拷贝采用值传递的形式
对于引用数据类型采用引用传递的方式，只是把引用所指向的内存地址进行传递，但是最终克隆的引用变量和原来的引用变量都根据引用地址指向的同一块内存区域

深拷贝

对于引用数据类型变量的拷贝是，先重新生成一个引用数据类型，并使引用变量指向这个新的引用数据类型。
实现方式：重写clone()方法或序列化反序列化。

深拷贝的代码实现
1.需要被克隆的类

public class DeepProtoType implements Serializable, Cloneable{
	
	public String name; //String 属性
	public DeepCloneableTarget deepCloneableTarget;// 引用类型
	public DeepProtoType() {
		super();
	}
	
	
	//深拷贝 - 方式 1 使用clone 方法
	@Override
	protected Object clone() throws CloneNotSupportedException {
		
		Object deep = null;
		//这里完成对基本数据类型(属性)和String的克隆,super就是Object
		deep = super.clone(); 
		//对引用类型的属性，进行单独处理
		DeepProtoType deepProtoType = (DeepProtoType)deep;
		deepProtoType.deepCloneableTarget  = (DeepCloneableTarget)deepCloneableTarget.clone();
		// TODO Auto-generated method stub
		return deepProtoType;
	}
	
	//深拷贝 - 方式2 通过对象的序列化实现 (推荐)
	
	public Object deepClone() {
		
		//创建流对象
		ByteArrayOutputStream bos = null;
		ObjectOutputStream oos = null;
		ByteArrayInputStream bis = null;
		ObjectInputStream ois = null;
		
		try {
			
			//序列化
			bos = new ByteArrayOutputStream();
			oos = new ObjectOutputStream(bos);
			oos.writeObject(this); //当前这个对象以对象流的方式输出
			
			//反序列化
			bis = new ByteArrayInputStream(bos.toByteArray());
			ois = new ObjectInputStream(bis);
			DeepProtoType copyObj = (DeepProtoType)ois.readObject();
			
			return copyObj;
			
		} catch (Exception e) {
			// TODO: handle exception
			e.printStackTrace();
			return null;
		} finally {
			//关闭流
			try {
				bos.close();
				oos.close();
				bis.close();
				ois.close();
			} catch (Exception e2) {
				// TODO: handle exception
				System.out.println(e2.getMessage());
			}
		}
		
	}
	
}

2.引用变量

public class DeepCloneableTarget implements Serializable, Cloneable {
	private static final long serialVersionUID = 1L;

	private String cloneName;

	private String cloneClass;

	//构造器
	public DeepCloneableTarget(String cloneName, String cloneClass) {
		this.cloneName = cloneName;
		this.cloneClass = cloneClass;
	}

	//因为该类的属性，都是String , 因此我们这里使用默认的clone完成即可
	@Override
	protected Object clone() throws CloneNotSupportedException {
		return super.clone();
	}
}

3.使用方式

public class Client {
	public static void main(String[] args) throws Exception {
		// TODO Auto-generated method stub
		DeepProtoType p = new DeepProtoType();
		p.name = "宋江";
		p.deepCloneableTarget = new DeepCloneableTarget("大牛", "小牛");
		
		//方式1 完成深拷贝
		
		DeepProtoType p2 = (DeepProtoType) p.clone();
		
		System.out.println("p.name=" + p.name + "p.deepCloneableTarget=" + p.deepCloneableTarget.hashCode());
		System.out.println("p2.name=" + p.name + "p2.deepCloneableTarget=" + p2.deepCloneableTarget.hashCode());
	
//		//方式2 完成深拷贝
//		DeepProtoType p2 = (DeepProtoType) p.deepClone();
//		
//		System.out.println("p.name=" + p.name + "p.deepCloneableTarget=" + p.deepCloneableTarget.hashCode());
//		System.out.println("p2.name=" + p.name + "p2.deepCloneableTarget=" + p2.deepCloneableTarget.hashCode());
	
	}

}

原型模式的优缺点

创建的对象很复杂时可以使用原型模式简化创建的过程
对于需要动态追踪实例状态的情形，可以创造出与现有实例相同状态的实例
缺点是：对于已经拥有的类修改，可能需要也对于clone方法修改可能会违反ocp原则，即开闭原则

原型模式的应用

在spring中可以用@Scope注解或者配置文件配置注入的bean是单例还是原型的。
在这里插入图片描述我的疑惑：那配置成prototype时如果类没有实现Cloneable接口，是直接new出对象还是序列化完成对象创建呢？以后看spring源码再关注吧。

一年而已

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
设计模式学习笔记-原型模式

克隆羊问题现有一只羊tom，具有姓名、年龄、颜色等属性，请克隆出多只完全相同的羊传统的解决方法代码1.定义一个Sheep类public class Sheep { private String name; private int age; private String color; public Sheep(String name, int age, String color)...
复制链接

扫一扫