朋友做客（外观模式或者门面模式）

老鸟飞过


  
package facade;   
/**  
*   
* 在实际的开发过程中，往往需要将不同的两个层分离，  
* 比如mvc 三层架构  
* 业务层与表现层、持久层与业务层之间建立外观Facade，  
* 这样为新的系统提供简单的接口。  
*/  
//facade类 组合了 三个子系统（每个girl是独立的系统）   
public class Boy {   
      
    private BeautifulGirl beautifulGirl;   
    private LivelyGirl  livelyGirl;   
    private LooksMediocreGirl looksMediocreGirl;   
      
    Boy(){   
        beautifulGirl = new BeautifulGirl();   
        livelyGirl =new LivelyGirl();   
        looksMediocreGirl = new LooksMediocreGirl();   
    }   
      
    //我的朋友并不知道我有几个女友，因为女友是我私有的，但是给我朋友做饭的不是我，却是我的女友们。   
    //我的朋友到我家做客，他不了解我们家的情况，如果让我的朋友直接命令我的女友做家务，也许他会忙的忘记和我讲正事了（违背了单一职责）   
    //我朋友 1————1 我(facade) 1————n girls   
    //如果没有了我(facade)，那么就变成了 我朋友 1————n girls   
    //如果我朋友是待开发的新系统， girls是老系统（之前实现了的）   
    //新系统需要用到老的系统提供服务，可是老系统很复杂，   
    //开发新系统的人可能不了解老系统是怎么实现的，   
    //那么facade 的出现就是提供给新系统 老系统的接口   
    public void  dinner_for_friend(Friend friend){   
           
        // if...else...可以考虑状态模式重构   
        if(  friend.getAges()<30){   
            this.methodA();   
        }else{   
            this.methodB();   
        }   
            
           
    }   
      
    public void methodA(){   
           
        beautifulGirl.do_it();   
        livelyGirl.do_something();   
        looksMediocreGirl.i_can_do();   
           
    }   
    public void methodB(){   
      
        looksMediocreGirl.i_can_do();   
        livelyGirl.do_something();   
        beautifulGirl.do_it();   
    }   
  
      
}  

package facade;
/**
*
* 在实际的开发过程中，往往需要将不同的两个层分离，
* 比如mvc 三层架构
* 业务层与表现层、持久层与业务层之间建立外观Facade，
* 这样为新的系统提供简单的接口。
*/
//facade类 组合了 三个子系统（每个girl是独立的系统）
public class Boy {
       
        private BeautifulGirl beautifulGirl;
        private LivelyGirl  livelyGirl;
        private LooksMediocreGirl looksMediocreGirl;
       
        Boy(){
                beautifulGirl = new BeautifulGirl();
                livelyGirl =new LivelyGirl();
                looksMediocreGirl = new LooksMediocreGirl();
        }
       
        //我的朋友并不知道我有几个女友，因为女友是我私有的，但是给我朋友做饭的不是我，却是我的女友们。
        //我的朋友到我家做客，他不了解我们家的情况，如果让我的朋友直接命令我的女友做家务，也许他会忙的忘记和我讲正事了（违背了单一职责）
        //我朋友 1————1 我(facade) 1————n girls
        //如果没有了我(facade)，那么就变成了 我朋友 1————n girls
        //如果我朋友是待开发的新系统， girls是老系统（之前实现了的）
        //新系统需要用到老的系统提供服务，可是老系统很复杂，
        //开发新系统的人可能不了解老系统是怎么实现的，
        //那么facade 的出现就是提供给新系统 老系统的接口
        public void  dinner_for_friend(Friend friend){
               
                // if...else...可以考虑状态模式重构
                if(  friend.getAges()<30){
                        this.methodA();
                }else{
                        this.methodB();
                }
                 
               
        }
       
        public void methodA(){
               
                beautifulGirl.do_it();
                livelyGirl.do_something();
                looksMediocreGirl.i_can_do();
               
        }
        public void methodB(){
       
                looksMediocreGirl.i_can_do();
                livelyGirl.do_something();
                beautifulGirl.do_it();
        }

       
}
  
public class BeautifulGirl {   
      
    public void do_it(){   
           
        System.out.println("来杯咖啡");   
    }   
  
}  

public class BeautifulGirl {
       
        public void do_it(){
               
                System.out.println("来杯咖啡");
        }

}

  
public class LivelyGirl {   
      
      
    public void do_something(){   
           
        System.out.println("准备午餐");   
    }   
  
}  

public class LivelyGirl {
       
       
        public void do_something(){
               
                System.out.println("准备午餐");
        }

}

  
public class LooksMediocreGirl {   
  
    public void i_can_do(){   
           
        System.out.println("准备点心");   
           
    }   
      
}  

public class LooksMediocreGirl {

        public void i_can_do(){
               
                System.out.println("准备点心");
               
        }
       
}


  
public class Friend {   
      
    int ages;   
  
      
    public int getAges() {   
        return ages;   
    }   
  
    public void setAges(int ages) {   
        this.ages = ages;   
    }   
      
      
  
}  

public class Friend {
       
        int ages;

       
        public int getAges() {
                return ages;
        }

        public void setAges(int ages) {
                this.ages = ages;
        }
       
       

}

楼主对设计模式的理解应用到这些有趣的例子上，真是不错

wujiazhao88 写道
楼主对设计模式的理解应用到这些有趣的例子上，真是不错

最近还是比较闲的，呵呵

ysen 写道
老鸟飞过


  
package facade;   
/**  
*   
* 在实际的开发过程中，往往需要将不同的两个层分离，  
* 比如mvc 三层架构  
* 业务层与表现层、持久层与业务层之间建立外观Facade，  
* 这样为新的系统提供简单的接口。  
*/  
//facade类 组合了 三个子系统（每个girl是独立的系统）   
public class Boy {   
      
    private BeautifulGirl beautifulGirl;   
    private LivelyGirl  livelyGirl;   
    private LooksMediocreGirl looksMediocreGirl;   
      
    Boy(){   
        beautifulGirl = new BeautifulGirl();   
        livelyGirl =new LivelyGirl();   
        looksMediocreGirl = new LooksMediocreGirl();   
    }   
      
    //我的朋友并不知道我有几个女友，因为女友是我私有的，但是给我朋友做饭的不是我，却是我的女友们。   
    //我的朋友到我家做客，他不了解我们家的情况，如果让我的朋友直接命令我的女友做家务，也许他会忙的忘记和我讲正事了（违背了单一职责）   
    //我朋友 1————1 我(facade) 1————n girls   
    //如果没有了我(facade)，那么就变成了 我朋友 1————n girls   
    //如果我朋友是待开发的新系统， girls是老系统（之前实现了的）   
    //新系统需要用到老的系统提供服务，可是老系统很复杂，   
    //开发新系统的人可能不了解老系统是怎么实现的，   
    //那么facade 的出现就是提供给新系统 老系统的接口   
    public void  dinner_for_friend(Friend friend){   
           
        // if...else...可以考虑状态模式重构   
        if(  friend.getAges()<30){   
            this.methodA();   
        }else{   
            this.methodB();   
        }   
            
           
    }   
      
    public void methodA(){   
           
        beautifulGirl.do_it();   
        livelyGirl.do_something();   
        looksMediocreGirl.i_can_do();   
           
    }   
    public void methodB(){   
      
        looksMediocreGirl.i_can_do();   
        livelyGirl.do_something();   
        beautifulGirl.do_it();   
    }   
  
      
}  

package facade;
/**
*
* 在实际的开发过程中，往往需要将不同的两个层分离，
* 比如mvc 三层架构
* 业务层与表现层、持久层与业务层之间建立外观Facade，
* 这样为新的系统提供简单的接口。
*/
//facade类 组合了 三个子系统（每个girl是独立的系统）
public class Boy {
       
        private BeautifulGirl beautifulGirl;
        private LivelyGirl  livelyGirl;
        private LooksMediocreGirl looksMediocreGirl;
       
        Boy(){
                beautifulGirl = new BeautifulGirl();
                livelyGirl =new LivelyGirl();
                looksMediocreGirl = new LooksMediocreGirl();
        }
       
        //我的朋友并不知道我有几个女友，因为女友是我私有的，但是给我朋友做饭的不是我，却是我的女友们。
        //我的朋友到我家做客，他不了解我们家的情况，如果让我的朋友直接命令我的女友做家务，也许他会忙的忘记和我讲正事了（违背了单一职责）
        //我朋友 1————1 我(facade) 1————n girls
        //如果没有了我(facade)，那么就变成了 我朋友 1————n girls
        //如果我朋友是待开发的新系统， girls是老系统（之前实现了的）
        //新系统需要用到老的系统提供服务，可是老系统很复杂，
        //开发新系统的人可能不了解老系统是怎么实现的，
        //那么facade 的出现就是提供给新系统 老系统的接口
        public void  dinner_for_friend(Friend friend){
               
                // if...else...可以考虑状态模式重构
                if(  friend.getAges()<30){
                        this.methodA();
                }else{
                        this.methodB();
                }
                 
               
        }
       
        public void methodA(){
               
                beautifulGirl.do_it();
                livelyGirl.do_something();
                looksMediocreGirl.i_can_do();
               
        }
        public void methodB(){
       
                looksMediocreGirl.i_can_do();
                livelyGirl.do_something();
                beautifulGirl.do_it();
        }

       
}
  
public class BeautifulGirl {   
      
    public void do_it(){   
           
        System.out.println("来杯咖啡");   
    }   
  
}  

public class BeautifulGirl {
       
        public void do_it(){
               
                System.out.println("来杯咖啡");
        }

}

  
public class LivelyGirl {   
      
      
    public void do_something(){   
           
        System.out.println("准备午餐");   
    }   
  
}  

public class LivelyGirl {
       
       
        public void do_something(){
               
                System.out.println("准备午餐");
        }

}

  
public class LooksMediocreGirl {   
  
    public void i_can_do(){   
           
        System.out.println("准备点心");   
           
    }   
      
}  

public class LooksMediocreGirl {

        public void i_can_do(){
               
                System.out.println("准备点心");
               
        }
       
}


  
public class Friend {   
      
    int ages;   
  
      
    public int getAges() {   
        return ages;   
    }   
  
    public void setAges(int ages) {   
        this.ages = ages;   
    }   
      
      
  
}  

public class Friend {
       
        int ages;

       
        public int getAges() {
                return ages;
        }

        public void setAges(int ages) {
                this.ages = ages;
        }
       
       

}

很好，简单易懂．

我觉得楼主应该在门面类型对象用容器来容纳其他的子系统更好~！如果子对象如果特别多
估计提供给客户端的门面对象非常庞大 维护不方便，浅见。。

讲的不错 很好理解

讲的很一般，没看出哪儿好。
之所以这么说，是因为我没看懂，哈哈！

methodA 和methodB 应该改为 私有访问更好吧

最近正在看设计模式有关的书籍，向楼主学习了！