建造者模式与原型模式

一、建造者模式

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

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

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

在这里插入图片描述

以克隆羊为例

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

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

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();   //克隆好的对象！
		
	}
}

三、创建型模式总结

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

建造者模式与原型模式

建造者模式与原型模式

一、建造者模式

二、原型模式prototype

三、创建型模式总结

猜你喜欢