FacadePattern-Java代码实例讲解

Facade Pattern 外观模式

 

提供一个统一的接口去访问多个子系统的多个不同的接口。外观模式定义了一个高层次的接口。

Facade外形类
知道哪写子系统负责处理哪些请求
将客户请求传递给相应的子系统处理

Subsystem 子系统类
实现子系统功能
处理由Facade传来的任务
子系统补用知道Facade，在任何地方页没有引用Facade

demo
额 我觉得这个例子不好。。这个不是简单的封装么？= =到底简单的封装和facadepattern  什么区别 T_T

public class Client {//这个就是所谓的客户端啦~~他要调用interface
    public static void main(String[] args){
        FacadeCuppaMaker cuppaMaker = new FacadeCuppaMaker();
        TeaCup teaCup = cuppaMaker.makeACuppa();
        System.out.println(teaCup);
    }
}


public class FacadeCuppaMaker {//这是个复杂的子系统的对外接口 = =
    boolean teaBagIsSteeped;
    public FacadeCuppaMaker(){
        System.out.println("FacadeCuppaMaker准备好为您冲茶了！");
    }
    public TeaCup makeACuppa(){
        TeaCup cup = new TeaCup();
        TeaBag teaBag = new TeaBag();
        Water water = new Water();
        cup.addFacadeTeaBag(teaBag);
        water.boilFacadeWater();
        cup.addFacadeWater(water);
        cup.steepTeaBag();
        return cup;
    }
}

public class Water {
    boolean waterIsBoiling;
    public Water(){
        setWaterIsBoiling(false);
        System.out.println("纯净的水准备好了");
    }
    public void boilFacadeWater(){
        setWaterIsBoiling(true);
        System.out.println("水在沸腾");
    }
    public void setWaterIsBoiling(boolean isWaterBoiling){
        waterIsBoiling = isWaterBoiling;
    }
    public boolean getWaterIsBoiling(){
        return waterIsBoiling;
    }
}


public class TeaBag {
    public TeaBag(){
        System.out.println("清香的茶包准备好了");
    }
}


public class TeaCup {
    boolean teaBagIsSteeped;
    Water facadeWater;
    TeaBag facadeTeaBag;
    public TeaCup(){
        setTeaBagIsSteeped(false);
        System.out.println("茶杯准备好了");
    }
    public void setTeaBagIsSteeped(boolean isTeaBagSteeped){
        teaBagIsSteeped = isTeaBagSteeped;
    }
    public boolean getTeaBagIsSteeped(){
        return teaBagIsSteeped;
    }
    public void addFacadeTeaBag(TeaBag facadeTeaBagIn){
        facadeTeaBag = facadeTeaBagIn;
        System.out.println("茶包放在茶杯了");
    }
    public void addFacadeWater(Water facadeWaterIn){
        facadeWater = facadeWaterIn;
        System.out.println("水倒入杯子了");
    }
    public void steepTeaBag(){
        if((facadeTeaBag!=null) && (facadeWater!=null) && (facadeWater.getWaterIsBoiling())){
            System.out.println("茶渗透到杯子中");
            setTeaBagIsSteeped(true);
        }
        else{
            System.out.println("茶没有渗透到杯子中");
            setTeaBagIsSteeped(false);
        }
    }
    public String toString(){
        if(this.getTeaBagIsSteeped()){
            return "一杯又香又浓的茶冲好了！";
        }
        else{
            String tempString = new String("一个杯子");
            if(facadeWater != null){
                if(facadeWater.getWaterIsBoiling()){
                    tempString += "放有沸腾的水 ";
                }
                else{
                    tempString += "放有凉水 ";
                }
            }
            else{
                tempString += "没有放水 ";
            }
            if(facadeTeaBag != null){
                tempString += "有一个茶包";
            }
            else{
                tempString += "没有茶包";
            }
            return tempString;
        }
    }
}

 

 

===================================================

Facade Pattern 
我找到的另外一个例子：

 

/*  
 * Facade Pattern(外观模式）  
 *将一组复杂的行为封装起来，通过简单接口来实现统一调用。  
 *例子：在家里看电影，可能需要一系列步骤:打开dvd，放盘，打开tv，打开音响，调好音调，关灯等诸如此类动作  
 *如果需要每一个都在客户代码来控制，将来修改或者维护比较麻烦，但是如果将这些统一通过facade模式封装到一个  
 *watchMovie接口中，客户知道我只需按watchMovie就会形成一系列动作，具体干什么可以不清楚。另外对于被封装的类  
 *具体使用并没受到影响，依然可以自己打开tv，打开hifi等。  
 *  
 *在Head First中提到一个  
 *Least Knowledge Principle：talk only to your immediate friends;  
 *这个原则是说：向直接的类保持联系，不必要的可以封装起来，通过一个封装类统一打交道；  
 *其中head First指出几个guidelines  
 *  
 *only invoke methods that belong to:  
 *1)The object itself;      //方法属于本身  
 *2)objects passed in as a parameter to the method  //方法是属于参数传入的对象 类似setParam(ClassA ca) ca.methods()  
 *3)any object the method creates or instantiates   //方法属于内部创建的实例。  
 *4)any components of the object    //对象的组成成分  
 *  
 *  
 */  
  
  
class TV{   
    public void on(){   
        System.out.println("TV On");   
    }   
    public void off(){   
        System.out.println("TV Off");   
    }   
}   
  
class DvDplayer{   
       
    private String str;   
    public void on(){   
        System.out.println("DvD On");   
    }   
    public void off(){   
        System.out.println("DvD Off");   
    }   
    public void setDvD(String DvDstr){   
        str = DvDstr;   
        System.out.println("DvD setDvD " + str);   
    }   
    public void popDvD(){   
        System.out.println("DvD popDvD "+str);   
        str = "";   
    }   
}   
  
class HiFi{   
    private int v;   
    public void turnUp(){   
        v += 10;   
        System.out.println("HiFi turnUp to "+10);   
    }   
    public void turnDown(){   
        v -= 10;   
        System.out.println("HiFi turnDown to " + 10);   
    }   
    public void On(){   
        System.out.println("HiFi On");   
    }   
    public void Off(){   
        System.out.println("HiFi Off");   
    }   
}   
  
class myFacade{   
    private HiFi hifi;   
    private DvDplayer dvd;   
    private TV tv;   
    public myFacade(HiFi h,DvDplayer d,TV t){   
        hifi = h;   
        dvd = d;   
        tv = t;   
    }   
       
    public void watchMovie(String strDvD){   
        tv.on();                    //一系列行为调用   
        hifi.On();   
        hifi.turnUp();   
        dvd.on();   
        dvd.setDvD(strDvD);   
    }   
       
    public void stopWatchMovie(){   
        hifi.Off();   
        dvd.popDvD();   
        dvd.off();   
        tv.off();   
    }   
       
}   
  
  
  
public class FacadeTest {   
  
    /**  
     * @param args  
     */  
    public static void main(String[] args) {   
      
      HiFi h = new HiFi();   
        TV t = new TV();   
        DvDplayer dvd = new DvDplayer();   
        myFacade mf = new myFacade(h,dvd,t);               
        mf.watchMovie("War II");                    //关心看电影，不关心电影通过怎样操作才可以看到   
        mf.stopWatchMovie();                           
  
    }   
  
}  

 
 

有些关于Decorator Pattern ，Facade Pattern,Adapter Pattern比较：

从它们的目的来比较：

Decorator Pattern：动态添加一些额外功能；

Facade Pattern：封装功能，使一系列复杂动作通过简单接口公开；

Adapter Pattern：转换接口功能，从一个接口转换到另一种接口形式；

本文来自CSDN博客，转载请标明出处：http://blog.csdn.net/binghuazh/archive/2009/02/06/3866465.aspx

评论

2 楼 lt26w 2014-09-04  

理解成门面模式应该比较容易明白吧

1 楼 lt26w 2014-09-04  

看下面的例子比较明白.