建造者模式与原型模式

比眉伴天荒 2022-04-18 01:57 106阅读 0赞

# 建造者模式与原型模式 #

## 一、建造者模式 ##

1.  建造者模式概述
    
     *  建造者模式分离了对象子组件。子组件单独构造(由Builder来负责)然后再装配(由Director负责)。 从而可以构 造出复杂的对象。这个模式适用于：某个对象的构建过程复杂的情况下使用。
     *  由于实现了构建和装配的解耦。不同的构建器，相同的装配，也可以做出不同的对象； 相同的构建器，不同的装配顺序也可以做出不同的对象。也就是实现了构建算法、装配 算法的解耦，实现了更好的复用。
2.  以建造宇宙飞船为例：

public class AirShip {
    	//要建造的宇宙飞船类，三个组件由不同的builder分别构建，然后装配
    	private OrbitalModule orbitalModule;  //轨道舱
    	private Engine engine; //发动机
    	private EscapeTower escapeTower;  //逃逸塔
    	
    	
    	public void launch(){
    		System.out.println("发射！");
    	}
    	
    	
    	
    	public OrbitalModule getOrbitalModule() {
    		return orbitalModule;
    	}
    	public void setOrbitalModule(OrbitalModule orbitalModule) {
    		this.orbitalModule = orbitalModule;
    	}
    	public Engine getEngine() {
    		return engine;
    	}
    	public void setEngine(Engine engine) {
    		this.engine = engine;
    	}
    	public EscapeTower getEscapeTower() {
    		return escapeTower;
    	}
    	public void setEscapeTower(EscapeTower escapeTower) {
    		this.escapeTower = escapeTower;
    	}
    	
    }
    
    class OrbitalModule{
    	private String name;
    
    	public OrbitalModule(String name) {
    		this.name = name;
    	}
    
    	public String getName() {
    		return name;
    	}
    
    	public void setName(String name) {
    		this.name = name;
    	}
    	
    }
    
    class Engine {
    	private String name;
    
    	public Engine(String name) {
    		this.name = name;
    	}
    
    	public String getName() {
    		return name;
    	}
    
    	public void setName(String name) {
    		this.name = name;
    	}
    
    }
    
    class EscapeTower{
    	private String name;
    
    	public String getName() {
    		return name;
    	}
    
    	public void setName(String name) {
    		this.name = name;
    	}
    
    	public EscapeTower(String name) {
    		super();
    		this.name = name;
    	}
    	
    }
    ----------------------------------------------------------------
    public interface AirShipBuilder {
    //Builder的接口
    	Engine builderEngine();
    	OrbitalModule builderOrbitalModule();
    	EscapeTower  builderEscapeTower();
    }
    
    public class AirShipBuilderImpl implements AirShipBuilder {
    	//Builder的实现类，构建飞船的各个组件
    	@Override
    	public Engine builderEngine() {
    		System.out.println("构建发动机！");
    		return new Engine("发动机！");
    	}
    
    	@Override
    	public EscapeTower builderEscapeTower() {
    		
    		System.out.println("构建逃逸塔");
    		return new EscapeTower("逃逸塔");
    	}
    
    	@Override
    	public OrbitalModule builderOrbitalModule() {
    		System.out.println("构建轨道舱");
    		return new OrbitalModule("轨道舱");
    	}	
    	
    }
    ------------------------------------------------------------------------
    public interface AirShipDirector {
    	/**
    	 * 组装飞船对象的接口
    	 * @return
    	 */
    	AirShip   directAirShip();
    }
    
    public class AirshipDirectorImpl implements AirShipDirector {
    //组装飞船对象的实现类
    	private AirShipBuilder builder;
    	public tAirshipDirectorImpl(AirShipBuilder builder) {
    		this.builder = builder;
    	}
    	@Override
    	public AirShip directAirShip() {
    		Engine e = builder.builderEngine();
    		OrbitalModule o = builder.builderOrbitalModule();
    		EscapeTower et = builder.builderEscapeTower();
    		
    		//装配成飞船对象
    		AirShip ship = new AirShip();
    		ship.setEngine(e);
    		ship.setEscapeTower(et);
    		ship.setOrbitalModule(o);
    		
    		return ship;
    	}
    }
    ------------------------------------------------------
    public class Client {
    	public static void main(String[] args) {
    		//组装
    		AirShipDirector director = new AirshipDirectorImpl(new AirShipBuilderImpl());
    		AirShip ship = director.directAirShip();
    		System.out.println(ship.getEngine().getName());
    		ship.launch();
    	}
    }

## 二、原型模式prototype ##

1.  原型模式概述
    
     *  通过new产生一个对象需要非常繁琐的数据准备或访问权限，则可以使用原型模式。
     *  就是java中的克隆技术，以某个对象为原型，复制出新的对象。显然，新的对象具备原型对象的特点
     *  优势有：效率高(直接克隆，避免了重新执行构造过程步骤) 。
     *  克隆类似于new，但是不同于new。new创建新的对象属性采用的是默认值。克隆出的 对象的属性值完全和原型对象相同。并且克隆出的新对象改变不会影响原型对象。然后， 再修改克隆对象的值。
2.  浅克隆与深克隆
    
     *  浅克隆：被复制的对象的所有变量都含有与原来的对象相同的值，而所有的对其他对象的引用都 仍然指向原来的对象。
     *  深克隆：深克隆把引用的变量指向复制过的新对象，而不是原有的被引用的对象。 **基本数据类型和String能够自动实现深度克隆（值的复制）**

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2tpbmdfY2Fubm9uX2ZvZGRlcg_size_16_color_FFFFFF_t_70]

1.  以克隆羊为例

public class Sheep2 implements Cloneable { 
    	private String sname;
    	private Date birthday;
    	
    	@Override
    	protected Object clone() throws CloneNotSupportedException {
    		Object obj = super.clone();  //直接调用object对象的clone()方法！
    		
    		//添加如下代码实现深复制(deep Clone)
    	    Sheep2 s = (Sheep2) obj;
    		s.birthday = (Date) this.birthday.clone();  //把属性也进行克隆！
    		
    		return obj;
    	}
    
    	public String getSname() {
    		return sname;
    	}
    
    	public void setSname(String sname) {
    		this.sname = sname;
    	}
    
    
    	public Date getBirthday() {
    		return birthday;
    	}
    
    	public void setBirthday(Date birthday) {
    		this.birthday = birthday;
    	}
    
    	public Sheep2(String sname, Date birthday) {
    		super();
    		this.sname = sname;
    		this.birthday = birthday;
    	}
    	
    	public Sheep2() {
    	}
    	
    }
    public class Client2 {
    	public static void main(String[] args) throws CloneNotSupportedException {
    		Date date = new Date(12312321331L);
    		Sheep2 s1 = new Sheep2("少利",date);
    		//实现复制。是否是深复制取决于Sheep2 
    		Sheep2 s2 = (Sheep2) s1.clone();   
    	}
    }

1.  用序列化与反序列化实现深克隆

public class Client3 {
    	public static void main(String[] args) throws CloneNotSupportedException, Exception {
    		Date date = new Date(12312321331L);
    		Sheep s1 = new Sheep("多利",date);
    
    		
    //		使用序列化和反序列化实现深复制
    		ByteArrayOutputStream bos = new ByteArrayOutputStream();
    		ObjectOutputStream    oos = new ObjectOutputStream(bos);
    		oos.writeObject(s1);
    		byte[] bytes = bos.toByteArray();
    		
    		ByteArrayInputStream  bis = new ByteArrayInputStream(bytes);
    		ObjectInputStream	  ois = new ObjectInputStream(bis);
    		
    		Sheep s2 = (Sheep) ois.readObject();   //克隆好的对象！
    		
    	}
    }

## 三、创建型模式总结 ##

1.  单例模式  
    保证一个类只有一个实例，并且提供一个访问该实例的全局访问点。
2.  简单工厂模式  
    用来生产同一等级结构中的任意产品。（对于增加新的产品，需要修改已有代码）
3.  工厂方法模式  
    用来生产同一等级结构中的固定产品。（支持增加任意产品）
4.  抽象工厂模式  
    用来生产不同产品族的全部产品。（对于增加新的产品，无能为力；支持增加产品族）
5.  原型模式  
    通过new产生一个对象需要非常繁琐的数据准备或访问权限，则可以使用原型模式

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2tpbmdfY2Fubm9uX2ZvZGRlcg_size_16_color_FFFFFF_t_70]: /images/20220418/73a8e0f0ddcc473c86c152985a50245f.png