10,外观模式-我来组成头部

最新推荐文章于 2024-05-16 16:51:23 发布

BraveWangDev

最新推荐文章于 2024-05-16 16:51:23 发布

阅读量1k

点赞数

分类专栏：【完结】Java设计模式文章标签：设计模式外观模式

本文链接：https://blog.csdn.net/abap_brave/article/details/78394095

版权

【完结】Java设计模式专栏收录该内容

15 篇文章 3 订阅

订阅专栏

一,前言

7种结构型设计模式:桥接模式,适配器模式,装饰模式,组合模式,享元模式,外观模式,代理模式
上篇我们说了适配器模式,通过包装接口,将一个不适配的接口转换成为我们需要的接口
结构型设计模式,还有一个和适配器模式相似,两者都是对类进行包装,但它的目的是简化接口

我们叫他外观模式,也叫门面模式

二,外观模式&场景

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

外观(Facade)角色 ：
    客户端可以调用这个角色的方法。
    此角色知晓相关的（一个或者多个）子系统的功能和责任。
    在正常情况下，本角色会将所有从客户端发来的请求委派到相应的子系统去。
　
子系统(SubSystem)角色 ：
    可以同时有一个或者多个子系统。
    每个子系统都不是一个单独的类，而是一个类的集合。
    每个子系统都可以被客户端直接调用，或者被外观角色调用。
    子系统并不知道外观的存在，对于子系统外观只是另一个客户端。

我们根据以下场景做一个Demo:
    一部小时候看的动画片,由黄,蓝,绿,红,黑五只狮子组成的"战神金刚"

战神金刚

    黄狮：汉克——左腿，从岩浆中获得能量
    蓝狮：阿劳拉公主——右腿，从水中获得能量
    绿狮：皮吉——左臂，从大风中获得能量
    红狮：兰斯——右臂，从火中获得能量
    黑狮：吉斯——头部和躯干，从闪电中获得能量

    队长：“组成脚和腿，组成躯干和手臂， 我来组成头部！”
    众：“前进，战神金刚！”

程序实现:
    五只狮子-BlackLion,BlueLion,GreenLion,RedLion,YellowLion
    每只狮子都有各自的组合成"战神金刚"需要执行的方法
    设计一个外观类对"战神金刚"的组合过程进行包装,包装各个部分执行的方法

三,五只狮子

package com.brave.facade.lion;

/**
 * 黑狮：吉斯——头部和躯干，从闪电中获得能量
 * @author Brave
 *
 */
public class BlackLion {

    public void combinationHead(){
        System.out.println("黑狮子准备组合...");
        System.out.println("黑狮：吉斯——头部和躯干，从闪电中获得能量");
    }

}

package com.brave.facade.lion;

/**
 * 蓝狮：阿劳拉公主——右腿，从水中获得能量
 * @author Brave
 *
 */
public class BlueLion {

    public void combinationBlue(){
        System.out.println("蓝狮子准备组合...");
        System.out.println("蓝狮：阿劳拉公主——右腿，从水中获得能量");
    }

}

package com.brave.facade.lion;

/**
 * 绿狮：皮吉——左臂，从大风中获得能量
 * @author Brave
 *
 */
public class GreenLion {

    public void combinationArm_Left(){
        System.out.println("绿狮子准备组合...");
        System.out.println("绿狮：皮吉——左臂，从大风中获得能量");
    }

}

package com.brave.facade.lion;

/**
 * 红狮：兰斯——右臂，从火中获得能量
 * @author Brave
 *
 */
public class RedLion {

    public void combinationArm_Right(){
        System.out.println("红狮子准备组合...");
        System.out.println("红狮：兰斯——右臂，从火中获得能量");
    }

}

package com.brave.facade.lion;

/**
 * 黄狮：汉克——左腿，从岩浆中获得能量
 * @author Brave
 *
 */
public class YellowLion {

     public void combinatioLeg_Left(){
        System.out.println("黄狮子准备组合...");
        System.out.println("黄狮：汉克——左腿，从岩浆中获得能量");
    }

}

四,不使用外观模式的组装方式:

package com.brave.facade;

import com.brave.facade.lion.BlackLion;
import com.brave.facade.lion.BlueLion;
import com.brave.facade.lion.GreenLion;
import com.brave.facade.lion.RedLion;
import com.brave.facade.lion.YellowLion;

/**
 * 使用外观模式的Client
 * 黄狮：汉克——左腿，从岩浆中获得能量
 * 蓝狮：阿劳拉公主——右腿，从水中获得能量
 * 绿狮：皮吉——左臂，从大风中获得能量
 * 红狮：兰斯——右臂，从火中获得能量
 * 黑狮：吉斯——头部和躯干，从闪电中获得能量
 * 队长：“组成脚和腿，组成躯干和手臂， 我来组成头部！”
 * 众：“前进，战神金刚！”
 * 
 * @author Brave
 *
 */
public class Client {

    public static void main(String[] args) {

        YellowLion yellowLion = new YellowLion();
        BlueLion blueLion = new BlueLion();
        GreenLion greenLion = new GreenLion();
        RedLion redLion = new RedLion();
        BlackLion blackLion = new BlackLion();

        System.out.println("******组成脚和腿******");
        yellowLion.combinatioLeg_Left();
        blueLion.combinationBlue();
        System.out.println("******组成躯干和手臂******");
        greenLion.combinationArm_Left();
        redLion.combinationArm_Right();
        System.out.println("******我来组成头部******");
        blackLion.combinationHead();
        System.out.println("******前进，战神金刚******");
    }

}

打印输出:

******组成脚和腿******
黄狮子准备组合...
黄狮：汉克——左腿，从岩浆中获得能量
蓝狮子准备组合...
蓝狮：阿劳拉公主——右腿，从水中获得能量
******组成躯干和手臂******
绿狮子准备组合...
绿狮：皮吉——左臂，从大风中获得能量
红狮子准备组合...
红狮：兰斯——右臂，从火中获得能量
******我来组成头部******
黑狮子准备组合...
黑狮：吉斯——头部和躯干，从闪电中获得能量
******前进，战神金刚******

五,使用外观模式的组成方式

1,创建一个外观类,对”战神金刚”的组合过程进行包装

package com.brave.facade;

import com.brave.facade.lion.BlackLion;
import com.brave.facade.lion.BlueLion;
import com.brave.facade.lion.GreenLion;
import com.brave.facade.lion.RedLion;
import com.brave.facade.lion.YellowLion;

/**
 * 简化接口的外观模式
 * 外观模式:提供一个更合理的接口的外观类,可以将一个复杂的子系统变得容易使用
 * 外观模式:提供了一个统一接口,访问子系统中的一群接口,外观定义了一个高层接口,让子系统更容易使用
 * 
 * 提供简化接口的同时,依然将系统完整功能暴露出来,提供给外部使用
 * 外观不只是简化了接口,也将客户从组件的子系统中解耦
 * 和适配器模式相比:都是对类进行包装,但外观的意图是简化接口,而适配器意图是将接口转换成需要的接口
 * 
 * 遵循了最少知识原则(墨忒耳法则)
 * @author Brave
 *
 */
public class Facade {

    private YellowLion yellowLion;
    private BlueLion blueLion;
    private GreenLion greenLion;
    private RedLion redLion;
    private BlackLion blackLion;

    public Facade(YellowLion yellowLion, BlueLion blueLion, GreenLion greenLion, RedLion redLion, BlackLion blackLion) {
        this.yellowLion = yellowLion;
        this.blueLion = blueLion;
        this.greenLion = greenLion;
        this.redLion = redLion;
        this.blackLion = blackLion;
    }

    public void combination(){

        System.out.println("******组成脚和腿******");
        yellowLion.combinatioLeg_Left();
        blueLion.combinationBlue();
        System.out.println("******组成躯干和手臂******");
        greenLion.combinationArm_Left();
        redLion.combinationArm_Right();
        System.out.println("******我来组成头部******");
        blackLion.combinationHead();
        System.out.println("******前进，战神金刚******");

    }

    public YellowLion getYellowLion() {
        return yellowLion;
    }

    public void setYellowLion(YellowLion yellowLion) {
        this.yellowLion = yellowLion;
    }

    public BlueLion getBlueLion() {
        return blueLion;
    }

    public void setBlueLion(BlueLion blueLion) {
        this.blueLion = blueLion;
    }

    public GreenLion getGreenLion() {
        return greenLion;
    }

    public void setGreenLion(GreenLion greenLion) {
        this.greenLion = greenLion;
    }

    public RedLion getRedLion() {
        return redLion;
    }

    public void setRedLion(RedLion redLion) {
        this.redLion = redLion;
    }

    public BlackLion getBlackLion() {
        return blackLion;
    }

    public void setBlackLion(BlackLion blackLion) {
        this.blackLion = blackLion;
    }

}

2,调用外观模式,组装战神金刚

package com.brave.facade;

import com.brave.facade.lion.BlackLion;
import com.brave.facade.lion.BlueLion;
import com.brave.facade.lion.GreenLion;
import com.brave.facade.lion.RedLion;
import com.brave.facade.lion.YellowLion;

/**
 * 使用外观模式的Client
 * 黄狮：汉克——左腿，从岩浆中获得能量
 * 蓝狮：阿劳拉公主——右腿，从水中获得能量
 * 绿狮：皮吉——左臂，从大风中获得能量
 * 红狮：兰斯——右臂，从火中获得能量
 * 黑狮：吉斯——头部和躯干，从闪电中获得能量
 * 队长：“组成脚和腿，组成躯干和手臂， 我来组成头部！”
 * 众：“前进，战神金刚！”
 * 
 * @author Brave
 *
 */
public class ClientFacade {

    public static void main(String[] args) {

        YellowLion yellowLion = new YellowLion();
        BlueLion blueLion = new BlueLion();
        GreenLion greenLion = new GreenLion();
        RedLion redLion = new RedLion();
        BlackLion blackLion = new BlackLion();

        Facade facade = new Facade(yellowLion, blueLion, greenLion, redLion, blackLion);
        facade.combination();
    }

}

3,打印输出

******组成脚和腿******
黄狮子准备组合...
黄狮：汉克——左腿，从岩浆中获得能量
蓝狮子准备组合...
蓝狮：阿劳拉公主——右腿，从水中获得能量
******组成躯干和手臂******
绿狮子准备组合...
绿狮：皮吉——左臂，从大风中获得能量
红狮子准备组合...
红狮：兰斯——右臂，从火中获得能量
******我来组成头部******
黑狮子准备组合...
黑狮：吉斯——头部和躯干，从闪电中获得能量
******前进，战神金刚******

六,外观模式的优点

　　
　　1,松散耦合
　　外观模式是客户端与子系统松耦合，使子系统内部模块更容易扩展和维护。
　　
　　2,简单易用
　　外观模式让客户端不需要了解子系统内部实现，也无需和子系统内部模块进行交互，只要跟外观类交互即可
　　
　　3,更好的划分访问层次
　　将需要暴露给外部的功能集中到外观中，既方便客户端使用，也隐藏了内部的细节。

维护记录:
20171102:添加战神金刚图片