4.原型模式(设计模式笔记)

旧城等待， 2022-08-04 04:06 184阅读 0赞

分类:  
1：创建型模式：  
单例模式，工厂模式，抽象工厂模式，建造者模式，原型模式；  
2：结构型模式：  
适配器模式，桥接模式，装饰模式，组合模式，外观模式，享元模式，代理模式  
3：行为型模式：  
模板方法模式，命令模式，迭代器模式，观察者模式，中介者模式，备忘录模式，

解释器模式，状态模式，策略模式，职责链模式，访问者模式。

原型模式:  
通过new产生一个对象需要非常繁琐的数据准备或访问权限(耗时)，则可以使用原型模式。  
就是java中的克隆技术，以某个对象为原型，复制出新的对象。显然，新的对象具有  
原型对象的特点  
优势有：效率高（直接克隆，避免了重新执行构造的过程步骤）  
克隆类似于new，但是不同意new。new创建新的对象属性采用的是默认值，克隆出的  
对象属性值和原型对象相同。并且克隆出的新对象改变不会影响原型对象。然后，  
再修改克隆对象的值

下面的例子演示耗时操作:

public class Test1 {
    	
    	@Test
    	public void test1() {
    		long startTime = System.currentTimeMillis();
    		for(int i=0 ; i < 3; i++) {
    			Car car = new Car();
    		}
    		long endTime = System.currentTimeMillis();
    		System.out.println("直接new对象耗时:" + (endTime - startTime));
    		/**
    		 * 直接new对象耗时:3000
    		 */
    	}
    	
    	@Test
    	public void test2() throws CloneNotSupportedException {
    		long startTime = System.currentTimeMillis();
    		Car car = new Car();
    		for(int i = 0; i < 3; i++) {
    			Car car1 = (Car) car.clone();
    		}
    		long endTime = System.currentTimeMillis();
    		System.out.println("clone对象耗时:" + (endTime - startTime));
    		
    		/**
    		 * clone对象耗时:1000
    		 */
    	}
    	
    }
    
    class Car implements Cloneable{
    	
    	public Car() {
    		try {
    			Thread.sleep(1000);
    		} catch (InterruptedException e) {
    			e.printStackTrace();
    		}
    	}
    	
    	public Object clone() throws CloneNotSupportedException {
    		return super.clone();
    	}
    }

原型模式深复制和浅复制:

public class Friend implements Serializable{
    	private String name;
    
    	public String getName() {
    		return name;
    	}
    
    	public void setName(String name) {
    		this.name = name;
    	}
    
    	public Friend(String name) {
    		this.name = name;
    	}
    
    	public Friend() {
    		super();
    		// TODO Auto-generated constructor stub
    	}
    
    	public Object clone() throws CloneNotSupportedException {
    		// TODO Auto-generated method stub
    		return (Friend)super.clone();
    	}
    
    }

/**
     * 浅复制
     * 
     * @author Administrator
     *
     */
    public class Sheep implements Cloneable { // 1997,英国的克隆羊，多利
    	private String name;
    	private Friend myFriend;
    
    	public String getName() {
    		return name;
    	}
    
    	public void setName(String name) {
    		this.name = name;
    	}
    
    	public Friend getMyFriend() {
    		return myFriend;
    	}
    
    	public void setMyFriend(Friend myFriend) {
    		this.myFriend = myFriend;
    	}
    
    	/**
    	 * 实现浅复制方法
    	 */
    	@Override
    	protected Object clone() throws CloneNotSupportedException {
    		Object obj = super.clone();
    		return obj;
    	}
    
    }

/**
     * 深复制
     * 使用系列化和反系列化实现
     * @author Administrator
     *
     */
    public class Sheep1 implements Cloneable, Serializable { // 1997,英国的克隆羊，多利
    
    	private String name;
    	public Friend myFriend;
    
    	public String getName() {
    		return name;
    	}
    
    	public void setName(String name) {
    		this.name = name;
    	}
    
    	public Friend getMyFriend() {
    		return myFriend;
    	}
    
    	public void setMyFriend(Friend myFriend) {
    		this.myFriend = myFriend;
    	}
    
    	/**
    	 * 实现深复制方法
    	 */
    
    	public Object clone() {
    		try {
    			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());
    		} catch (ClassNotFoundException e) {
    			// TODO Auto-generated catch block
    			e.printStackTrace();
    		} catch (IOException e) {
    			// TODO Auto-generated catch block
    			e.printStackTrace();
    		}
    		return null;
    	}
    
    }

测试:

public class Test {
    
    	@org.junit.Test
    	public void test1() throws CloneNotSupportedException {
    		Sheep s = new Sheep();
    		s.setName("多利");
    		Friend myFriend = new Friend("少利");
    		s.setMyFriend(myFriend);
    		System.out.println("浅复制前我的朋友的名字:" + s.getMyFriend().getName());
    		
    		//改变s的朋友的名字
    		s.getMyFriend().setName("高利");
    		
    		//复制对象
    		Sheep s1 = (Sheep) s.clone();
    		System.out.println("浅复制后我的朋友的名字：" + s1.getMyFriend().getName());
    		
    		/** 运行结果:
    		 * 浅复制前我的朋友的名字:少利
    			浅复制后我的朋友的名字：高利
    		 */
    	}
    	
    	@org.junit.Test
    	public void test2() throws CloneNotSupportedException {
    		Sheep1 s = new Sheep1();
    		s.setName("多利");
    		Friend myFriend = new Friend("少利");
    		s.setMyFriend(myFriend);
    		System.out.println("深复制前我的朋友的名字:" + s.getMyFriend().getName());
    		
    		//复制对象
    		Sheep1 s1 = (Sheep1) s.clone();
    		
    		//改变s的朋友的名字
    		s.getMyFriend().setName("高利");
    		
    		System.out.println("深复制后我的朋友的名字：" + s1.getMyFriend().getName());
    		
    		/** 运行结果:
    		 * 浅复制前我的朋友的名字:少利
    			浅复制后我的朋友的名字：少利
    		 */
    	}
    	
    }