精华内容
下载资源
问答
  • 设计模式 外观模式 一键电影模式.pdf
  • 设计模式专题之(十一)外观模式---设计模式外观模式示例代码(python--c++)
  • 设计模式 外观模式 一键电影模式

    万次阅读 多人点赞 2014-05-14 22:51:52
    老样子,先看 外观模式(Facade Pattern)定义:提供一个统一的接口,用来访问子系统中的一群接口,外观定义了一个高层的接口,让子系统更容易使用。其实就是为了方便客户的使用,把一群操作,封装成一个方法。 举...

    注:文章参考《head first设计模式》一书,非常值得学习的一本书。

    转载请标明出处:http://blog.csdn.net/lmj623565791/article/details/25837275

    这个模式比较简单,嘿嘿,简单写一下。

    老样子,先看 外观模式(Facade Pattern)定义:提供一个统一的接口,用来访问子系统中的一群接口,外观定义了一个高层的接口,让子系统更容易使用。其实就是为了方便客户的使用,把一群操作,封装成一个方法。

    举个例子:我比较喜欢看电影,于是买了投影仪、电脑、音响、设计了房间的灯光、买了爆米花机,然后我想看电影的时候,我需要:

    1、打开爆米花机

    2、制作爆米花

    3、将灯光调暗

    4、打开投影仪

    5、放下投影仪投影区

    6、打开电脑

    7、打开播放器

    8、将播放器音调设为环绕立体声

    ...

    尼玛,花了一笔钱,看电影还要这么多的步骤,太累了,而且看完还要一个一个关掉。

    所有,我们使用外观模式解决这些复杂的步骤,轻松享受电影:

    package com.zhy.pattern.facade;
    
    public class HomeTheaterFacade
    {
    	private Computer computer;
    	private Player player;
    	private Light light;
    	private Projector projector;
    	private PopcornPopper popper;
    
    	public HomeTheaterFacade(Computer computer, Player player, Light light, Projector projector, PopcornPopper popper)
    	{
    		this.computer = computer;
    		this.player = player;
    		this.light = light;
    		this.projector = projector;
    		this.popper = popper;
    	}
    
    	public void watchMovie()
    	{
    		/**
    		 *  1、打开爆米花机
    			2、制作爆米花
    			3、将灯光调暗
    			4、打开投影仪
    			5、放下投影仪投影区
    			6、打开电脑
    			7、打开播放器
    			8、将播放器音调设为环绕立体声
    		 */
    		popper.on();
    		popper.makePopcorn();
    		light.down();
    		projector.on();
    		projector.open();
    		computer.on();
    		player.on();
    		player.make3DListener();
    	}
    	
    	public void stopMovie()
    	{
    		popper.off();
    		popper.stopMakePopcorn();
    		light.up();
    		projector.close();
    		projector.off();
    		player.off();
    		computer.off();
    	}
    }
    

    可以看到,我们定义了一个类,然后可以让我一键享受看电影了,看完,一键关闭,享受多了。

    外观模式:一般用于需要简化一个很大的接口,或者一群复杂的接口的时候。


    这个模式比较容易理解,就不多说了,最后附上类图:



    好了,恭喜你,你又学会了一个设计模式,外观模式(Facade Pattern)。





    展开全文
  • 设计模式外观模式

    2017-06-18 12:59:48
    设计模式 java 外观模式
  • 设计模式外观模式

    2016-01-10 19:49:05
    设计模式外观模式
  • 主要介绍了C++设计模式外观模式,本文详细讲解了C++中的Facade模式,并给出了实例代码,需要的朋友可以参考下
  • 主要介绍了JavaScript设计模式外观模式实例,本文用一些代码实例来讲解JavaScript中的外观模式,需要的朋友可以参考下
  • C#设计模式-外观模式

    2016-05-11 18:20:03
    C#设计模式-外观模式
  • 设计模式-外观模式

    2013-04-21 17:54:28
    设计模式练习-外观模式厂-JAVA外观模式练习示例。
  • 主要介绍了JavaScript设计模式外观模式介绍,外观模式是用于由于子系统或程序组成较复杂而提供的一个高层界面接口,使用客户端更容易访问底层的程序或系统接口,需要的朋友可以参考下
  • java设计模式外观模式
  •  外观模式 (Facade)  为子系统中的一组接口提供一个一致的界面,此模式定义了一个高层接口,这个接口使得这一子系统更加容易使用。  外观模式是一种结构型模式。  结构  图-外观模式结构图  Facade ...
  • 设计模式——外观模式

    千次阅读 2018-04-06 17:33:15
    外观模式,是一种把子系统和客户端做松耦合操作的一个设计模式。这样客户端调用系统,根本不需要知道系统内部是如何操作的,只需要调用外部“接待员”即可,所以即使子系统有变化时,也不需要客户端做改变,达到松...

    外观模式,是一种把子系统和客户端做松耦合操作的一个设计模式。这样客户端调用系统,根本不需要知道系统内部是如何操作的,只需要调用外部“接待员”即可,所以即使子系统有变化时,也不需要客户端做改变,达到松耦合的效果。

    我们通过外观的包装,使应用程序只能看到外观对象,而不会看到具体的细节对象,这样无疑会降低应用程序的复杂度,并且提高了程序的可维护性。

    外观模式包含三个角色:

    外观角色(Facade):是模式的核心,他被客户client角色调用,知道各个子系统的功能。同时根据客户角色已有的需求预订了几种功能组合

    子系统角色(Subsystem classes):实现子系统的功能,并处理由Facade对象指派的任务。对子系统而言,facade和client角色是未知的,没有Facade的任何相关信息;即没有指向Facade的实例。

    客户角色(client):调用facade角色获得完成相应的功能。

    主要解决:降低访问复杂系统的内部子系统时的复杂度,客户端与子系统松耦合。

    何时使用: 1、客户端不需要知道系统内部的复杂联系,整个系统只需提供一个"接待员"即可。 2、定义系统的入口。

    如何解决:客户端不与系统耦合,外观类与系统耦合。

    关键代码:在客户端和复杂系统之间再加一层,这一次将调用顺序、依赖关系等处理好。

    应用实例: 1、去医院看病,可能要去挂号、门诊、划价、取药,让患者或患者家属觉得很复杂,如果有提供接待人员,只让接待人员来处理,就很方便。

    优点: 1、减少系统相互依赖。 2、提高灵活性。 3、提高了安全性。

    缺点:不符合开闭原则,如果要改东西很麻烦,继承重写都不合适。

    使用场景: 1、为复杂的模块或子系统提供外界访问的模块。 2、子系统相对独立。 3、预防低水平人员带来的风险。

    注意事项:在层次化结构中,可以使用外观模式定义系统中每一层的入口。

    下边时一个开车和停车操作的例子,两个操作,在不调用和调用外观模式的时候的代码:

    <?php
    //子系统角色
    
    //车门
    class CarDoor{
        public function Open()
        {
            echo "Open the door. ";
        }
        public function Close()
        {
            echo "Close the door. ";
        }
    }
    
    //发动机
    class Engine{
        public function Start()
        {
            echo "Start Engine. ";
        }
        public function Stop()
        {
            echo "Stop Engine. ";
        }
    }
    
    //踩油门
    class Accelerator{
        public function Run()
        {
            echo "Press the accelerator. ";
        }
    }
    
    //踩刹车
    class Breaking {
    
        public function Run()
        {
            echo "Break. ";
        }
    }
    
    //如果不采用外观模式,那么开车和停车的调用如下
    $CarDoor = new CarDoor();
    $Engine = new Engine();
    $Accelerator = new Accelerator();
    $Breaking = new Breaking();
    
    //开车
    $CarDoor->Open();
    $Engine->Start();
    $Accelerator->Run();
    
    //停车
    $Breaking->Run();
    $Engine->Stop();
    $CarDoor->Close();
    
    
    
    //采用外观模式.定义外观角色
    class Facade{
        private $CarDoor;
        private $Engine;
        private $Accelerator;
        private $Breaking;
        
        function __construct()
        {
            $this->CarDoor = new CarDoor();
            $this->Engine = new Engine();
            $this->Accelerator = new Accelerator();
            $this->Breaking = new Breaking();
        }
        
        public function Start()
        {
            $this->CarDoor->Open();
            $this->Engine->Start();
            $this->Accelerator->Run();
        }
        
        public function Stop()
        {
            $this->Breaking->Run();
            $this->Engine->Stop();
            $this->CarDoor->Close();
        }
        
    }
    
    //调用外观模式
    $Facade = new Facade();
    //开车
    $Facade->Start();
    //停车
    $Facade->Stop();
    
    ?>

    展开全文
  • Java 设计模式——外观模式

    千次阅读 2016-06-06 00:11:17
    今天要说的外观模式是一个相对简单的设计模式,而且在日常的开发中,可能你也会时常使用它,只是你可能并未想过这是一个设计模式。本文会从一些实例着手,来对本文要说明的外观模式进行尽可能全面的讲解。希望于你...

    概述

    今天要说的外观模式是一个相对简单的设计模式,而且在日常的开发中,可能你也会时常使用它,只是你可能并未想过这是一个设计模式。本文会从一些实例着手,来对本文要说明的外观模式进行尽可能全面的讲解。希望于你有益。

    引言

    这里插入一条引言的目的是让你回想一下,在你日常开发中何时用到了外观模式。
    可能你的 boss 会这样安排你一个任务。这可能是一个核心模块,模块会有它的一个功能,只是你的 boss 可能只想要你提供一个给他调用的接口。他会这么跟你说:嗨,小明,我们现在的这个系统里需要一个核心的功能 P0,它就交给你实现吧。你只要给我可以调用的接口就好了,你代码的内部逻辑我不需要知道的。去做吧。
    如果你时常被安排这样的任务,我想你应该已经掌握外观模式了。

    定义

    外观模式提供了一个统一的接口,用来访问子系统中的一群接口。外观模式定义一个高层接口,让子系统更容易使用。


    目录

    版权说明

    著作权归作者所有。
    商业转载请联系作者获得授权,非商业转载请注明出处。
    本文作者:Q-WHai
    发表日期: 2016年6月6日
    本文链接:https://qwhai.blog.csdn.net/article/details/51592617
    来源:CSDN
    更多内容:分类 >> 设计模式


    非外观模式

    这里我就使用《大话设计模式》书中的例子了,感觉这个例子还是挺形象的。现在假设你是一个股民(只是博主不炒股,也不知道这里会不会有说得不对的地方,如果有你就当没看见吧。。_),你想做一些理财活动。你看中了两支股票、一支国债和一支房地产。
    如果让你现在来编写这份代码,你的代码框架可能会像下面的这幅类图:

    这里写图片描述

    这里只列举了股票的代码,是因为其他理财活动的逻辑与股票的逻辑是一致的。冗余的代码除了占地方之外并没有再多的好处了。
    StockA.java

    public class StockA {
    
        private int stockCount = 0;
        
        public void sell(int count){
            stockCount -= count;
            System.out.println("卖了" + count + "支 A 股票");
        }
        
        public void buy(int count){
            stockCount += count;
            System.out.println("买了" + count + "支 A 股票");
        }
        
        public int getStockCount() {
            return stockCount;
        }
    }
    

    下面的代码是处理理财者的,对于一个简单地买进买出逻辑,理财者都要花费这么多的代码处理,实在是折磨人嘛。
    Investors.java

    public class Investors {
    
        public static void main(String[] args) {
            StockA stockA = new StockA();
            StockB stockB = new StockB();
            NationalDebt debt = new NationalDebt();
            RealEstate estate = new RealEstate();
            
            stockA.buy(100);
            stockB.buy(200);
            debt.buy(150);
            estate.buy(120);
            
            stockA.sell(100);
            stockB.sell(200);
            debt.sell(150);
            estate.sell(120);
        }
    }
    

    上面说的这些是在没有使用外观模式的情况下编写的代码。也就是说下面要说的外观模式可以让代码更加简单明了了。


    外观模式

    在上面的非外观模式中,我们看到了一些不是很友好的代码逻辑。而外观模式可以基于更高层次的封装,从而达到对调用者更加透明。下面是修改后的外观模式类图:

    这里写图片描述

    FundFacade.java

    public class FundFacade {
    
        private StockA stockA = null;
        private StockB stockB = null;
        private NationalDebt debt = null;
        private RealEstate estate = null;
        
        public FundFacade() {
            stockA = new StockA();
            stockB = new StockB();
            debt = new NationalDebt();
            estate = new RealEstate();
        }
        
        public void buyAll(int count) {
            stockA.buy(count);
            stockB.buy(count);
            debt.buy(count);
            estate.buy(count);
        }
        
        public void sellAll(int count) {
            stockA.sell(count);
            stockB.sell(count);
            debt.sell(count);
            estate.sell(count);
        }
        
        public void buyStockA(int count) {
            stockA.buy(count);
        }
        
        public void sellNationalDebt(int count) {
            debt.sell(count);
        }
    }
    

    上面的代码则是外观的核心类:FundFacade。在理财系统中的所有操作都可以通过这个类来实现。你通过这个类可以很方便地实现对股票、国债、房地产等理财项目的操作,而不用关心里面究竟是怎么处理的。这是对用户来说是一件好事,不是吗?
    来看看用户的操作吧(当然上面图类已经反映了绝大部分效果了),这是用户的代码逻辑:
    Investors.java

    public class Investors {
    
        public static void main(String[] args) {
            FundFacade facade = new FundFacade();
            facade.buyAll(120);
            facade.buyStockA(50);
            facade.sellAll(80);
        }
    }
    

    看看,用户只要告诉 FundFacade 类,买入什么、卖出什么、买多少、卖多少,就可以达到目的。实在是太方便了。
    看看股票 A 的代码吧,其实它并什么实质性的变化。这也是外观模式的魅力所在,它不用你去修改原来子系统的代码,只要做一件事,构建更高层次的封装。当然,这里我做了一些简单地修改,StockA 的访问权限。既然要对用户透明,那么我的子系统就没有必要再对用户开放了,不是吗?因为我们已经有专业的外交官—— FundFacade。
    StockA.java

    class StockA {
    
        private int stockCount = 0;
        
        void sell(int count){
            stockCount -= count;
            System.out.println("卖了" + count + "支 A 股票");
        }
        
        void buy(int count){
            stockCount += count;
            System.out.println("买了" + count + "支 A 股票");
        }
        
        int getStockCount() {
            return stockCount;
        }
    }
    

    外观模式是一个相对简单的设计模式,你可以很轻松地掌握并使用它。只是我想说,外观模式也会存在一定的局限性。相信你已经发现了。
    由于我们把对于子系统所有的操作都交给了 FundFacade 类来处理,所以我们就受到了 FundFacade 类的约束了。比如上面的 FundFacade 类中并没有实现单独对 StockB 的操作,那么我们就不能单独对 StockB 进行操作了,除非你在 FundFacade 类中封装一个对 StockB 操作的接口。


    外观模式的应用

    上面的描述中我们不仅知道了如何使用外观模式,也了解了外观模式的局限,所以我们应该站在客观的立场,有选择性地使用它。这里说一个我在工作中使用外观模式的例子吧。
    目前项目的老大让我去实现一个系统中的某一个模块,我想这应该是一个核心模块吧。这个模块的功能是,检查一个文件夹下的所有文件是否包含了敏感信息。而这个模块中会有很多小的子模块(当然老大并不会关心这些子模块做的事情),比如 AC 自动机的模式匹配、压缩文件的全自动解压、各种格式文件(doc/xls/ppt/zip/eml/rtf/pdf 等等,绝大部分的文件格式基本都在吧)、日志系统等等。
    我不可能去跟老大说,你要完成的功能是要先去干嘛、再去干嘛、再去干嘛、再去干嘛… …
    哦,天啦。烦死了,你能对它封装一下吗?(当然,这些只是我的心理活动。事实上,我还没有让老大说明我的设计过程)
    封装过后,我只要告诉老大,去调用这个类的这个方法就 ok 了。这样老大那边就不用操心里面的逻辑了,虽然如果出了错就是你的责任,可那也本该就 是你的责任啊。哈哈。。。
    好了,扯蛋就到这里。不管是上面正儿八经地模式详解,还是下面的胡说八道,我都希望它可以让你充分了解本文这个设计模式,学习并合理使用它。


    Ref

    • http://blog.csdn.net/jason0539/article/details/22775311
    • 《大话设计模式》

    征集

    如果你也需要使用ProcessOn这款在线绘图工具,可以使用如下邀请链接进行注册:
    https://www.processon.com/i/56205c2ee4b0f6ed10838a6d

    展开全文
  • 主要介绍了Python设计模式外观模式,结合实例形式详细分析了外观模式的概念、原理、用法及相关操作注意事项,需要的朋友可以参考下
  • 大话设计模式外观模式 经典代码 C#类
  • 主要介绍了Java设计模式外观模式(Facade模式)介绍,外观模式(Facade)的定义:为子系统中的一组接口提供一个一致的界面,需要的朋友可以参考下
  • 主要为大家详细介绍了java设计模式外观模式学习笔记,具有一定的参考价值,感兴趣的小伙伴们可以参考一下
  • Python设计模式外观模式

    万次阅读 2020-01-01 11:20:27
    设计模式七:外观模式 什么是外观模式 有助于隐藏系统的内部复杂性,并通过一个简化的接口向客户端暴露必要的部分,这就是外观模式 使用场景 要为一个复杂系统提供单个简单的入口点时,就可以使用此模式 优点: 1....

    设计模式七:外观模式

    什么是外观模式

    有助于隐藏系统的内部复杂性,并通过一个简化的接口向客户端暴露必要的部分,这就是外观模式

    使用场景

    要为一个复杂系统提供单个简单的入口点时,就可以使用此模式
    优点:
    1.可以改变系统内部代码,但是客户端代码不用关心也不受影响。
    2.在多层系统中,可以为每一层引入一个外观接口,并让所有层级通过这些外观相互通信,提高了层级之间的松耦合性,尽可能保持层级独立。

    典型案例

    启动一台电脑,不会把内存、硬盘CPU加点运行,引导加载程序,CPU启动操作系统内核等这些复杂性暴露给客户端,而是创建一个外观(启动键)来封装整个过程,并且保证所有步骤按正确的次序运行。

    补充知识

    ABCMeta 抽象基类
    1.需要使用metaclass关键字继承ABCmeta
    2.使用@abstractmethod修饰器声明的方法在子类中必须实现

    实例代码

    from abc import ABCMeta,abstractmethod
    
    class Hardware(metaclass=ABCMeta):
        #定义硬件基类,子类必须实现 getpower start off 三个方法
        @abstractmethod
        def __init__(self):
            pass
    
        def __str__(self):
            pass
    
        @abstractmethod
        def getpower(self):
            pass
    
        @abstractmethod
        def start(self):
            pass
    
        @abstractmethod
        def off(self):
            pass
    
    class CPU(Hardware):
    
        def __init__(self):
            self.name = 'CPU'
    
        def getpower(self):
            print('{} get power.... '.format(self.name))
    
        def start(self):
            print('{} start ............OK'.format(self.name))
    
        def off(self):
            print('{} off ............OK'.format(self.name))
    
    class Disk(Hardware):
    
        def __init__(self):
            self.name = 'Disk'
    
        def getpower(self):
            print('{} get power.... '.format(self.name))
    
        def start(self):
            print('{} start ............OK'.format(self.name))
    
        def off(self):
            print('{} off ............OK'.format(self.name))
    
    class Memory(Hardware):
    
        def __init__(self):
            self.name = 'Memory'
    
        def getpower(self):
            print('{} get power.... '.format(self.name))
    
        def start(self):
            print('{} start ............OK'.format(self.name))
    
        def off(self):
            print('{} off ............OK'.format(self.name))
    
    class Computer:
        #外观
        def __init__(self):
            #创建所有需要的硬件类实例
            self.name = 'Computer'
            self.cpu = CPU()
            self.disk = Disk()
            self.memory = Memory()
    
        def start(self):
            #启动入口
            self.cpu.getpower()
            self.disk.getpower()
            self.memory.getpower()
            self.memory.start()
            self.disk.start()
            self.cpu.start()
            print('{} start ............OK'.format(self.name))
    
        def off(self):
            #关闭入口
            self.cpu.off()
            self.memory.off()
            self.disk.off()
            print('{} off ............OK'.format(self.name))
    
    def main():
        pc = Computer()
        #用户只需要知道启动方法,无需知道启动细节,下面关闭同理
        pc.start()
        print()
        pc.off()
    
    if __name__ == "__main__":
        main()
    
    
    展开全文
  • 1、在设计初期阶段,应该要有意识的将不同的两层分离,比如考虑数据访问层、业务逻辑层、表示层之间建立外观模式,这样可以为子系统提供简单一致的接口,使得耦合大大降低。 2、开发阶段,子系统内部由于不够重构变...
  • 设计模式外观模式 facade 采用JAVA实现,请结合文档看,欢迎讨论。。
  • 外观模式:提供看一个统一的接口,用来访问子系统中的一群接口。外观定义了一个高层接口,让子系统更容易使用。 UML 类图? 外观模式的作用? 外观模式与适配器模式有什么异同? 这个模式需要什么时候设计?...
  • Facade:(1)、意图:为子系统中的一组接口提供一个一致的界面,Facade模式定义了一个高层接口,这个接口使得这一子系统更加容易使用。
  • JAVA设计模式--外观模式

    万次阅读 2017-02-12 23:37:41
    二、外观模式的结构 三、外观模式的适用性 四、外观模式和中介者模式 五、外观模式的优缺点 六、总结 一、什么是外观式 外观(Facade)模式是一种对象的结构型模式。为子系统中的一组接口提供一个一致的界面, ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 96,648
精华内容 38,659
关键字:

设计模式外观模式