外观模式

外观模式

package com;

import com.SubSystem.*;

public class Facade {
	public SubSystemOne one;
	public SubSystemTwo two;
	public SubSystemThree three;
	public SubSystemFour four;
	public Facade() {
		one =new SubSystem().new SubSystemOne();
		two=new SubSystem().new SubSystemTwo();
		three=new SubSystem().new SubSystemThree();
		four=new SubSystem().new SubSystemFour();
	}
	
	public void methodA(){
		System.out.println("方法A组");
		one.methodOne();
		two.methodTwo();
		three.methodThree();
	}
	public void methodB(){
		System.out.println("方法组B");
		two.methodTwo();
		three.methodThree();
		four.methodFour();
	}
	public void methodC(){
		System.out.println("方法组C");
		three.methodThree();
		four.methodFour();
		one.methodOne();
	}
	

}
*********************
package com;

public class SubSystem {
	class SubSystemOne{
      public void methodOne(){
    	  System.out.println("子系统方法1");
      }
	}
	
	class SubSystemTwo{
	      public void methodTwo(){
	    	  System.out.println("子系统方法2");
	      }
		}
	
	class SubSystemThree{
	      public void methodThree(){
	    	  System.out.println("子系统方法3");
	      }
		}
	
	class SubSystemFour{
	      public void methodFour(){
	    	  System.out.println("子系统方法4");
	      }
		}
	
	

}
*******************
package com;

public class Main {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Facade facade=new Facade();
		facade.methodA();
		facade.methodB();
		facade.methodC();

	}

}

 

优点

 松散耦合
    外观模式松散了客户端与子系统的耦合关系，让子系统内部的模块能更容易扩展和维护。

l          简单易用
    外观模式让子系统更加易用，客户端不再需要了解子系统内部的实现，也不需要跟众多子系统内部的模块进行交互，只需要跟外观交互就可以了，相当于外观类为外部客户端使用子系统提供了一站式服务。

l          更好的划分访问层次
    通过合理使用Facade，可以帮助我们更好的划分访问的层次。有些方法是对系统外的，有些方法是系统内部使用的。把需要暴露给外部的功能集中到外观中，这样既方便客户端使用，也很好的隐藏了内部的细节。

 

缺点

   过多的或者是不太合理的Facade也容易让人迷惑，到底是调用Facade好呢，还是直接调用模块好。

本质

封装交互，简化调用。

应用场景

建议在如下情况中，选用外观模式：

• 如果你希望为一个复杂的子系统提供一个简单接口的时候，可以考虑使用外观模式，使用外观对象来实现大部分客户需要的功能，从而简化客户的使用
• 如果想要让客户程序和抽象类的实现部分松散耦合，可以考虑使用外观模式，使用外观对象来将这个子系统与它的客户分离开来，从而提高子系统的独立性和可移植性
• 如果构建多层结构的系统，可以考虑使用外观模式，使用外观对象作为每层的入口，这样可以简化层间调用，也可以松散层次之间的依赖关系

 

相关模式

 外观模式和中介者模式
    这两个模式非常类似，但是有本质的区别。
    中介者模式主要用来封装多个对象之间相互的交互，多用在系统内部的多个模块之间；而外观模式封装的是单向的交互，是从客户端访问系统的调用，没有从系统中来访问客户端的调用。
    在中介者模式的实现里面，是需要实现具体的交互功能的；而外观模式的实现里面，一般是组合调用或是转调内部实现的功能，通常外观模式本身并不实现这些功能。
    中介者模式的目的主要是松散多个模块之间的耦合，把这些耦合关系全部放到中介者中去实现；而外观模式的目的是简化客户端的调用，这点和中介者模式也不同。

l          外观模式和单例模式
    通常一个子系统只需要一个外观实例，所以外观模式可以和单例模式组合使用，把Facade类实现成为单例。当然，也可以跟前面示例的那样，把外观类的构造方法私有化，然后把提供给客户端的方法实现成为静态的。

l          外观模式和抽象工厂模式
    外观模式的外观类通常需要和系统内部的多个模块交互，每个模块一般都有自己的接口，所以在外观类的具体实现里面，需要获取这些接口，然后组合这些接口来完成客户端的功能。
    那么怎么获取这些接口呢？就可以和抽象工厂一起使用，外观类通过抽象工厂来获取所需要的接口，而抽象工厂也可以把模块内部的实现对Facade进行屏蔽，也就是说Facade也仅仅只是知道它从模块中获取的它需要的功能，模块内部的细节，Facade也不知道了。

package com;

import com.FundOf.*;

public class Fund {
	public Stock stock;
	public NationDebt nationDebt;
	public Realty realty;
	
	public Fund(){
		stock=new FundOf().new Stock();
		nationDebt=new FundOf().new NationDebt();
		realty=new FundOf().new Realty();
	}
	
	public void shell(){
		System.out.println("基金卖出");
		stock.sell();
		nationDebt.sell();
		realty.sell();
	}
	
	public void buy(){
		System.out.println("基金卖出");
		stock.buy();
		nationDebt.buy();
		realty.buy();
	}

}
*****************
package com;

public class FundOf {

	class Stock{
		public void sell(){
			System.out.println("股票卖出");
		}
		public void buy(){
			System.out.println("股票买入");
		}
	}
	
	class NationDebt{
		public void sell(){
			System.out.println("国债卖出");
		}
		public void buy(){
			System.out.println("国债买入");
		}
	}
	
	class Realty{
		public void sell(){
			System.out.println("房地产卖出");
		}
		public void buy(){
			System.out.println("房地产买入");
		}
	}

}
*********************
package com;

public class Main {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Fund fund=new Fund();
		fund.shell();
		fund.buy();

	}

}