【设计模式】外观模式(结构型)

外观模式

      为子系统中的一组接口，提供一个一致的界面，此模式定义了一个高层接口，这一接口使得子系统更加容易使用。

模型图

 

 代码

public class Facade {
	private SubSystemOne one;
	private SubSystemTwo two;
	private SubSystemThree three;
	private SubSystemFour four;
	
	public Facade(SubSystemOne one, SubSystemTwo two,SubSystemThree three,SubSystemFour four){
		this.one=one;
		this.two=two;
		this.three=three;
		this.four=four;
	}
	
	public void methodA(){
		one.MethodOne();
		two.MethodTwo();
		three.MethodThree();
		four.MethodFour();
	}
	public void methodB(){
		one.MethodOne();
		two.MethodTwo();
		four.MethodFour();
		three.MethodThree();
		four.MethodX();
	}
}

public class SubSystemFour {
	public void MethodFour(){
		System.out.println("MethodFour");
	}
	
	public void MethodX(){
		System.out.println("MethodX");
	}
}

 

public class SubSystemOne {
	public void MethodOne(){
		System.out.println("MethodOne");
	}
}

 

public class SubSystemThree {
	public void MethodThree(){
		System.out.println("MethodThree");
	}
}

 

public class SubSystemTwo {
	public void MethodTwo(){
		System.out.println("MethodTwo");
	}
}

 

public class Test {
	public static void main(String[] args) {
		SubSystemOne one=new SubSystemOne();
		SubSystemTwo two=new SubSystemTwo();
		SubSystemThree three=new SubSystemThree();
		SubSystemFour four=new SubSystemFour();
		Facade facade=new Facade(one, two, three, four);
		facade.methodA();
		System.out.println("============================");
		facade.methodB();
	}
}

结果

 

 案例

需求  soul_aretist买了四支股票，可有些时候他总是一支一支的去买入，或者一支支的去卖掉，但是时间不等人，这样的情况下

soul_Artist希望能够有这样一组操作，他能够控制四支股票的买入与卖出的组合，以达到及时的消费。

分析与设计

    通过如上所示的需求，我们可以分析出是把一组操作进行组合，减小客户端的操作负担

模型图

 

代码

public class FacadeBox {
	private StockA stockA = null;
	private StockB stockB = null;
	private StockC stockC = null;
	private StockD stockD = null;

	public FacadeBox(StockA stocka, StockB stockb, StockC stockc, StockD stockd) {
		// TODO Auto-generated constructor stub
		this.stockA = stocka;
		this.stockB = stockb;
		this.stockC = stockc;
		this.stockD = stockd;
	}

	public void MethodA() {
		stockA.buy();
		stockB.sale();
		stockC.buy();
		stockD.sale();
	}

	public void MethodB() {
		stockA.buy();
		stockB.buy();
		stockC.buy();
		stockD.buy();
	}

	public void MethodC() {
		stockB.sale();
		stockA.buy();
		stockC.buy();
		stockD.sale();
		stockA.sale();
	}

	public void MethodD() {
		stockD.sale();
		stockB.sale();
		stockA.buy();
		stockC.buy();
		stockD.sale();
		stockA.sale();
	}
}

public class StockA {

	public void buy(){
		System.out.println("StockA buy");
	}
	
	public void sale(){
		System.out.println("StockA sale");
	}
}

 

public class StockB {
	public void buy(){
		System.out.println("StockB buy");
	}
	
	public void sale(){
		System.out.println("StockB sale");
	}
}

 

public class StockC {
	public void buy(){
		System.out.println("StockC buy");
	}
	
	public void sale(){
		System.out.println("StockC sale");
	}
}

 

public class StockD {
	public void buy(){
		System.out.println("StockD buy");
	}
	
	public void sale(){
		System.out.println("StockD sale");
	}
}

 

public class Client {
	public static void main(String[] args) {
		StockA stockA=new StockA();
		StockB stockB=new StockB();
		StockC stockC=new StockC();
		StockD stockD=new StockD();
		FacadeBox stockBox=new FacadeBox(stockA, stockB, stockC, stockD);
		System.out.println("============");
		stockBox.MethodA();
		System.out.println("============");
		stockBox.MethodB();
		System.out.println("============");
		stockBox.MethodC();
		System.out.println("============");
		stockBox.MethodD();
	}
}

 

结果图

 

 小结:

   第一  设计阶段，应该有意识的将不同的两层分离，提供合适的接口影藏没有必要暴露的细节

   第二 开发阶段，系统因为不断的重构，演化而变的越来越复杂，增加很多小类是好事，但是可以提供一个接口减少它们之间的依赖

   第三 在维护一个系统时，这个系统已经很复杂，并且很难维护的时候，应该为系统提供一个接口，把系统的核心功能封装起来，提供一个合适的facade，给客户端进行调用。