• 外观模式


    在讲述这个模式之前,我们先看一个案例:股民炒股

    先看一个比较笨的写法

    public class Stock1 {
        public void sell(){
            System.out.println("股票 1 卖出");
        }
        public void buy(){
            System.out.println("股票 1 买入");
        }
    }
    public class Stock2 {
        //代码类似股票1  略
    }
    public class Stock3 {
        //代码类似股票1  略
    }
    public class Realty1{
        //代码类似股票1  略
    }
    public class NationalDebt1{
        //代码类似股票1  略
    }
    
    测试方法
    public class Test {
        public static void main(String[] args) {
            Stock1 gu1 = new Stock1();
            Stock2 gu2 = new Stock2();
            Stock3 gu3 = new Stock3();
            NationalDebt1 nd1 = new NationalDebt1();
            Realty1 rt1 = new Realty1();
            
            gu1.buy();
            gu2.buy();
            gu3.buy();
            nd1.buy();
            rt1.buy();
            
            gu1.sell();
            gu2.sell();
            gu3.sell();
            nd1.sell();
            rt1.sell();
        }
    }

    输出结果:

    股票 1 买入
    股票 2 买入
    股票 3 买入
    国债 1 买入
    房地产 1 买入
    股票 1 卖出
    股票 2 卖出
    股票 3 卖出
    国债 1 卖出
    房地产 1 卖出

    这种写法耦合度过高,股民投资需要知道各种投资的方法,为什么股民不将资金交给基金代理去投资呢?

    现在引入一个基金类,去代替股民进行投资操作

    基金类
    public class Fund {
        Stock1 gu1;
        Stock2 gu2;
        Stock3 gu3;
        NationalDebt1 nd1;
        Realty1 rt1;
        
        public Fund(){
            gu1 = new Stock1();
            gu2 = new Stock2();
            gu3 = new Stock3();
            nd1 = new NationalDebt1();
            rt1 = new Realty1();
        }
        
        public void buyFund(){
            gu1.buy();
            gu2.buy();
            gu3.buy();
            nd1.buy();
            rt1.buy();
        }
        
        public void sellFund(){
            gu1.sell();
            gu2.sell();
            gu3.sell();
            nd1.sell();
            rt1.sell();
        }
    }
    
    测试方法
    public class Test {
        public static void main(String[] args) {
            Fund jijin = new Fund();
            //基金购买
            jijin.buyFund();
            //基金赎回
            jijin.sellFund();
        }
    }

    输出结果同上

    下面介绍外观模式:http://www.runoob.com/design-pattern/facade-pattern.html

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

    四个子系统
    public class SubSystemOne {
        public void methodOne(){
            System.out.println("子系统方法一");
        }
    }
    public class SubSystemTwo {
        public void methodTwo(){
            System.out.println("子系统方法二");
        }
    }
    public class SubSystemThree {
        public void methodThree(){
            System.out.println("子系统方法三");
        }
    }
    public class SubSystemFour {
        public void methodFour(){
            System.out.println("子系统方法四");
        }
    }
    
    //外观类,它需要了解所有的子系统的方法或属性,进行组合,以备外界调用
    public class Facade {
        SubSystemOne one;
        SubSystemTwo two;
        SubSystemThree three;
        SubSystemFour four;
        
        public Facade(){
            one = new SubSystemOne();
            two = new SubSystemTwo() ;
            three = new SubSystemThree();
            four = new SubSystemFour();
        }
        
        public void methodA(){
            System.out.println("方法组A() ----");
            one.methodOne();
            two.methodTwo();
            four.methodFour();
        }
        
        public void methodB(){
            System.out.println("方法组B() ----");
            two.methodTwo();
            three.methodThree();
        }
    }
    
    测试方法
    public class Test {
        public static void main(String[] args) {
            Facade facade = new Facade();
            
            facade.methodA();
            facade.methodB();
        }
    }

    对于面向对象有一定基础的朋友,即使没有听说过外观模式,也完全有可能在很多时候使用它,因为它完美地体现了依赖倒转原则和迪米特法则的思想,所以是非常常用的模式之一。

    什么时候用外观模式?

    这要分三个阶段来说,首先,在设计初期阶段,就应该要有意识的将不同的两个层分离,比如经典的三层架构,就需要考虑在数据访问层和业务逻辑层、业务层逻辑层和表示层的层与层之间建立外观Facade,这样可以为复杂的子系统提供一个简单的接口,使得耦合度大大降低。其次,在开发阶段,子系统往往因为不断的重构演化而变得越来越复杂,大多数的模式使用时也都会产生很多很小的类,这本是好事,但也给外部调用它们的用户程序带来了使用上的困难,增加外观Facade可以提供一个简单的接口,减少它们之间的依赖。第三,在维护一个遗留的大型系统时,可能这个系统已经非常难以维护和扩展了,但因为它包含非常重要的功能,新的需求开发必须要依赖它。此时用外观模式Facade也是非常合适的。你可以为新系统开发一个外观Facade类,来提供设计粗糙或高度复杂的遗留代码的比较清晰简单的接口,让新系统与Facade对象交互,Facade与遗留代码交互所有复杂的工作。

  • 相关阅读:
    队列的定义与实现(C语言实现)
    在CTime类中重载<<和>>
    华为OJ:统计大写字母个数
    sql server smo
    应用服务器负载平衡集群
    存储过程如何执行的快速
    sql server 分布式事务
    代理服务器
    怎样实现数据库负载均衡集群
    多层插件开发框架
  • 原文地址:https://www.cnblogs.com/jwen1994/p/10110956.html
Copyright © 2020-2023  润新知