结构型——外观模式（Facade）&&行为型——中介者模式（Mediator）day11

最新推荐文章于 2022-03-09 16:27:12 发布
最新推荐文章于 2022-03-09 16:27:12 发布
阅读量368 收藏 2
点赞数
分类专栏： 设计模式复习 文章标签： 设计模式 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zero_ko/article/details/107291776
版权

结构型——外观模式（Facade）

外观模式基本介绍

  1. 外观模式(Facade)，外观模式为子系统中的一组接口提供一个一致的界面，此模式定义了一个高层接口，这个接口使得这一子系统更加容易使用
  2. 外观模式通过定义一个一致的接口，用以屏蔽内部子系统的细节，使得调用端只需跟这个接口发生调用，而无需关心这个子系统的内部细节

一个简单的例子理解：去一些政府部门办事，会跑很多不同的部门，可能去了部门A，部门A又让你去部门B……这样就很麻烦
在这里插入图片描述
如果使用门面模式，用户只需要访问门面，由门面模式去协调内部的关系。
在这里插入图片描述

外观模式原理类图

在这里插入图片描述
➢对类图说明(分类外观模式的角色)

  • 外观类(Facade):为调用端提供统一的调用接口,外观类知道哪些子系统负责处理请求,从而将调用端的请求代理给适当子系统对象
  • 调用者(Client):外观接口的调用者
  • 子系统的集合:指模块或者子系统，处理Facade对象指派的任务，他是功能的实际提供者。

影院管理项目

组建一个家庭影院:
DVD播放器、投影仪、自动屏幕、环绕立体声、爆米花机，要求完成使用家庭影院的功能，其过程为:
直接用遥控器:统筹各设备开关
开爆米花机
放下屏幕
开投影仪
开音响
开DVD，选dvd
去拿爆米花
调暗灯光
播放
观影结束后，关闭各种设备

传统方式

在这里插入图片描述
分析

  1. 在ClientTest的main方法中，创建各个子系统的对象，并直接去调用子系统(对象)相关方法，会造成调用过程混乱，没有清晰的过程
  2. 不利于在ClientTest中，去维护对子系统的操作
  3. 解决思路: 定义一个高层接口，给子系统中的一组接口提供一个一致的界面(比如在高层接口提供四个方法(ready, play, pause, end)，用来访问子系统中的一群接口
  4. 也就是说 就是通过定义-一个- -致的接口(界面类),用以屏蔽内部子系统的细节，使得调用端只需跟这个接口发生调用，而无需关心这个子系统的内部细节=>外观模式
外观模式
  • 外观模式可以理解为转换一群接口， 客户只要调用一个接口，而不用调用多个接口才能达到目的。比如:在pc上安装软件的时候经常有一键安装选项(省去选择安装目录、安装的组件等等)，还有就是手机的重启功能(把.关机和启动合为一个操作)。
  • 外观模式就是解决多个复杂接口带来的使用困难，起到简化用户操作的作用
  • 示意图说明
    在这里插入图片描述
package com.xhl.Facade;

public class DVDPlays {
	//单例模式，饿汉
	private static final DVDPlays instance = new DVDPlays();
	
	private DVDPlays() {};
	
	public static DVDPlays getIntance(){
		return instance;
	}
	
	public void on() {
		System.out.println("DVD ON");
	}
	
	public void off() {
		System.out.println("DVD OFF");
	}
	
	public void play() {
		System.out.println("DVD IS PLAYING");
	}
	
	public void pause() {
		System.out.println("DVD PAUSE...");
	}
}

package com.xhl.Facade;

public class Popcorn {
	//单例模式，饿汉
	private static final Popcorn instance = new Popcorn();
	
	private Popcorn() {};
	
	public static Popcorn getIntance(){
		return instance;
	}
	
	public void on() {
		System.out.println("POPCORN ON");
	}
	
	public void off() {
		System.out.println("POPCORN OFF");
	}
	
	public void pop() {
		System.out.println("POPCORN IS POPING");
	}
	
}

package com.xhl.Facade;

public class Projector {
	//单例模式，饿汉
	private static final Projector instance = new Projector();
	
	private Projector() {};
	
	public static Projector getIntance(){
		return instance;
	}
	
	public void on() {
		System.out.println("PROJECTOR ON");
	}
	
	public void off() {
		System.out.println("PROJECTOR OFF");
	}
	
	public void focus() {
		System.out.println("PROJECTOR IS PROJECTOR");
	}
	
}

package com.xhl.Facade;

public class Screen {
	//单例模式，饿汉
	private static final Screen instance = new Screen();
	
	private Screen() {};
	
	public static Screen getIntance(){
		return instance;
	}
	
	public void up() {
		System.out.println("SCREEN UP");
	}
	
	public void down() {
		System.out.println("SCREEN DOWN");
	}
	
}

package com.xhl.Facade;

public class Stereo {
	//单例模式，饿汉
	private static final Stereo instance = new Stereo();
	
	private Stereo() {};
	
	public static Stereo getIntance(){
		return instance;
	}
	
	public void on() {
		System.out.println("STEREO ON");
	}
	
	public void off() {
		System.out.println("STEREO OFF");
	}
	
	public void up() {
		System.out.println("STEREO UP...");
	}
	
}


package com.xhl.Facade;

public class TheaterLight {
	//单例模式，饿汉
	private static final TheaterLight instance = new TheaterLight();
	
	private TheaterLight() {};
	
	public static TheaterLight getIntance(){
		return instance;
	}
	
	public void on() {
		System.out.println("THEATER LIGHT ON");
	}
	
	public void off() {
		System.out.println("THEATER LIGHT OFF");
	}
	
	public void dim() {
		System.out.println("THEATER LIGHT DIM...");
	}
	
	public void brigth() {
		System.out.println("THEATER LIGHT BRIGHT...");
	}
	
}

package com.xhl.Facade;

public class HomeTheaterFacade {
	private TheaterLight theaterLight;
	private Popcorn popcorn;
	private Stereo stereo;
	private Projector projector;
	private Screen screen;
	private DVDPlays dvdPlays;
	
	public HomeTheaterFacade() {
		super();
		this.theaterLight = TheaterLight.getIntance();
		this.popcorn = Popcorn.getIntance();
		this.stereo = Stereo.getIntance();
		this.projector = Projector.getIntance();
		this.screen = Screen.getIntance();
		this.dvdPlays = DVDPlays.getIntance();
	}
	
	public void ready() {
		popcorn.on();
		popcorn.pop();
		screen.down();
		projector.on();
		stereo.on();
		dvdPlays.on();
		theaterLight.dim();
	}
	
	public void play() {
		dvdPlays.play();
	}
	
	public void pause() {
		dvdPlays.pause();
	}
	
	public void end() {
		popcorn.off();
		theaterLight.off();
		screen.up();
		projector.off();
		stereo.off();
		dvdPlays.off();
	}
}

package com.xhl.Facade;

public class FacadeDemo {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		HomeTheaterFacade facade = new HomeTheaterFacade();
		facade.ready();
		System.out.println("=============================");
		facade.play();
		System.out.println("=============================");
		facade.pause();
		System.out.println("=============================");
		facade.end();
	}

}

在这里插入图片描述

外观模式在MyBatista框架中的源码分析

MyBatis中Configuration去创建MetaObject对象使用外观模式
在这里插入图片描述
在这里插入图片描述
Configuration是一个外观类，他聚合了objectFactory objectWrapperFactory reflectFactory对象实例
在这里插入图片描述
在这里插入图片描述

总结

  1. 外观模式对外屏蔽了子系统的细节，因此外观模式降低了客户端对子系统使用的复杂性
  2. 外观模式对客户端与子 系统的耦合关系-------解耦，让子系统内部的模块更易维护和扩展
  3. 通过合理的使用外观模式，可以帮我们更好的划分访问的层次
  4. 当系统需要进行分层设计时，可以考虑使用Facade模式
  5. 在维护一-个遗留的大型系统时，可能这个系统已经变得非常难以维护和扩展，此时可以考虑为新系统开发一个Facade类，来提供遗留系统的比较清晰简单的接口，让新系统与Facade类交互，提高复用性
  6. 不能过多的或者不合理的使用外观模式，使用外观模式好，还是直接调用模块好。要以让系统有层次，利于维护为目的。

行为型——中介者模式（Mediator）

中介者模式基本介绍

  1. 中介者模式(Mediator Pattern) ，用一个中介对象来封装一 系列的对象交互。中介者使各个对象不需要显式地相互引用，从而使其耦合松散，而且可以独立地改变它们之间的交互
  2. 中介者模式属于行为型模式，使代码易于维护
  3. 比如 MVC模式，C (Controller 控制器)是M (Model 模型)和V (View 视图)的中介者，在前后端交互时起到了中间人的作用。消息中间件就是中介者。

还是之前的例子，政府部门内部打交道也是很复杂，一个新的部门进来，十分麻烦，我们可以抽出一个专门的部门打交道，所有部门都和这个部门打交道，互相之间不打交道，中介者模式是对抽出一个部门，外观模式是对外抽出一个部门，这个对内对外的部门可以是同一个。
在这里插入图片描述

中介者模式原理类图

在这里插入图片描述

  1. Mediator 就是抽象中介者,定义了同事对象到中介者对象的接口
  2. Colleague 是抽象同事类
  3. ConcreteMediator 具体的中介者对象，实现抽象方法，他需要知道所有的具体的同事类，即以一个集合来管理HashMap,并接受某个同事对象消息，完成相应的任务
  4. ConcreteColleague 具体的同事类，会有很多,每个同事只知道自己的行为，而不了解其他同事类的行为(方法), 但是他们都依赖中介者对 象.

智能家庭项目

在这里插入图片描述

  1. 智能家庭包括各种设备，闹钟、咖啡机、电视机、窗帘等
  2. 主人要看电视时，各个设备可以协同工作，自动完成看电视的准备工作，比如流程为:闹铃响起----->咖啡机开始做咖啡----->窗帘自动落下----->电视机开始播放
传统方式

在这里插入图片描述
分析

  1. 当各电器对象有多种状态改变时，相互之.间的调用关系会比较复杂
  2. 各个电器对象彼此联系，你中有我，我中有你，不利于松耦合.
  3. 各个电器对象之间所传递的消息(参数)，容易混乱
  4. 当系统增加一个新的电器对象时，或者执行流程改变时，代码的可维护性、扩展性都不理想==>考虑中介者模式
中介者模式

在这里插入图片描述

package com.xhl.Mediator;
//同事抽象类
public abstract class Colleague {
	private Mediator mediator;
	public String name;
	
	public Colleague(Mediator mediator, String name) {
		super();
		this.mediator = mediator;
		this.name = name;
	}
	
	public Mediator GetMediator() {
		return this.mediator;
	}
	
	public abstract void SendMessage(int stateChange);
}


package com.xhl.Mediator;

public class Alarm extends Colleague {

	public Alarm(Mediator mediator, String name) {
		super(mediator, name);
		//在创建Alarm同事对象时，将自己放到ConcrateMediator集合中
		mediator.Register(name, this);
	}

	public void SendAlarm(int stateChange) {
		SendMessage(stateChange);
	}
	
	@Override
	public void SendMessage(int stateChange) {
		// 调用的中介者对象的getMessage
		this.GetMediator().GetMessage(stateChange, this.name);

	}

}

package com.xhl.Mediator;

public class CoffeeMachine extends Colleague {

	public CoffeeMachine(Mediator mediator, String name) {
		super(mediator, name);
		//在创建Alarm同事对象时，将自己放到ConcrateMediator集合中
		mediator.Register(name, this);
	}

	public void StartCoffee() {
		System.out.println("It's time to startcoffee!");
	}
	
	@Override
	public void SendMessage(int stateChange) {
		// 调用的中介者对象的getMessage
		this.GetMediator().GetMessage(stateChange, this.name);

	}
	
	public void FinishCoffee() {
		System.out.println("After 5 minutes!");
		System.out.println("Coffee is ok");
		SendMessage(0);
	}

}


package com.xhl.Mediator;

public class Curtains extends Colleague {

	public Curtains(Mediator mediator, String name) {
		super(mediator, name);
		//在创建Alarm同事对象时，将自己放到ConcrateMediator集合中
		mediator.Register(name, this);
	}

	public void UpCurtain() {
		System.out.println("I am holding Up Curtains!");
	}
	
	@Override
	public void SendMessage(int stateChange) {
		// 调用的中介者对象的getMessage
		this.GetMediator().GetMessage(stateChange, this.name);

	}
	
}

package com.xhl.Mediator;

public class TV extends Colleague {

	public TV(Mediator mediator, String name) {
		super(mediator, name);
		//在创建Alarm同事对象时，将自己放到ConcrateMediator集合中
		mediator.Register(name, this);
	}

	public void StartTV() {
		System.out.println("It's time to StartTV!");
	}
	
	@Override
	public void SendMessage(int stateChange) {
		// 调用的中介者对象的getMessage
		this.GetMediator().GetMessage(stateChange, this.name);

	}
	
	public void StopTV() {
		System.out.println("StopTV!");
	}
}


package com.xhl.Mediator;

public abstract class Mediator {
	//将给中介者对象加入到集合中
	public abstract void Register(String name,Colleague colleague);
	
	//接受信息，具体的同事对象发出
	public abstract void GetMessage(int stateChange , String name);
	
	public abstract void SendMessage();
}

package com.xhl.Mediator;

import java.util.HashMap;

public class ConcreteMediator extends Mediator {
	//集合放入所以的同事对象
	private HashMap<String, Colleague> colleagueMap;
	private HashMap<String, String> interMap;
	
	public ConcreteMediator() {
		super();
		colleagueMap = new HashMap();
		interMap = new HashMap();
	}

	@Override
	public void Register(String name, Colleague colleague) {
		colleagueMap.put(name, colleague);
		if(colleague instanceof Alarm) {
			interMap.put("Alarm", name);
		}else if(colleague instanceof CoffeeMachine) {
			interMap.put("CoffeeMachine", name);
		}else if(colleague instanceof TV) {
			interMap.put("TV", name);
		}else if(colleague instanceof Curtains) {
			interMap.put("Curtains", name);
		}
	}

	//集体中介者的核心方法
	//1、根据得到信息，完成对应任务
	//2、中介者在这个方法协调各个具体的同事对象，完成任务
	@Override
	public void GetMessage(int stateChange, String name) {
		if(colleagueMap.get(name) instanceof Alarm) {
			if(stateChange==0) {
				((CoffeeMachine)(colleagueMap.get(interMap.get("CoffeeMachine")))).StartCoffee();
				((TV)(colleagueMap.get(interMap.get("TV")))).StartTV();
			}else if(stateChange==1) {
				((TV)(colleagueMap.get(interMap.get("TV")))).StopTV();
			}
		}else if(colleagueMap.get(name) instanceof CoffeeMachine) {
			((Curtains)(colleagueMap.get(interMap.get("Curtains")))).UpCurtain();
		}else if(colleagueMap.get(name) instanceof TV) {
			//TV发出的消息处理
		}else if(colleagueMap.get(name) instanceof Curtains) {
			//Curtains发出的消息处理
		}
	}

	@Override
	public void SendMessage() {
		// TODO Auto-generated method stub

	}

}


package com.xhl.Mediator;

public class MediatorDemo {

	public static void main(String[] args) {
		Mediator mediator = new ConcreteMediator();
		Alarm alarm = new Alarm(mediator, "alarm");
		
		CoffeeMachine coffeeMachine = new CoffeeMachine(mediator, "coffeeMachine");
		
		Curtains curtains = new Curtains(mediator, "curtains");
		
		TV tv = new TV(mediator, "TV");
		
		alarm.SendAlarm(0);
		coffeeMachine.FinishCoffee();
		alarm.SendAlarm(1);
	}

}

在这里插入图片描述

总结

1)多个类相互耦合，会形成网状结构,使用中介者模式将网状结构分离为星型结构，进行解耦
2)减少类间依赖，降低了耦合，符合迪米特原则
3)中介者承担 了较多的责任，一旦中介者出现了问题，整个系统就会受到影响
4)如果设计不当， 中介者对象本身变得过于复杂，这点在实际使用时，要特别注意

哆唻咪à
关注
专栏目录
ym——Andorid-15k+的面试题。
陈宇明
08-07 2万+
最近才开的博客，希望大家多多关注，andorid开发也做了3年有余了，也面试很多加企业，借此机会分享一下，我们中遇到过的问题以及解决方案吧，希望能够对正在找工作的andoird程序员有一定的帮助。学完本人博客发表《ym--andorid从零开始教程》+面试题目全理解，年薪18w以上绝对没问题。 特别献上整理过的50道面试题目 1.listView的优化方式 重用conve
Java入门基础及面试100题--初入门
loki的博客
12-15 2396
Java入门基础及面试100题 1、面向对象的特征有哪些方面？ 答：面向对象的特征主要有以下几个方面： - 抽象：抽象是将一类对象的共同特征总结出来构造类的过程，包括数据抽象和行为抽象两方面。抽象只关注对象有哪些属性和行为，并不关注这些行为的细节是什么。 - 继承：继承是从已有类得到继承信息创建新类的过程。提供继承信息的类被称为父类（超类、基类）；得到继承信息的类被称为子类（派生类）。继承让变化中的软件系统有了一定的延续性，同时继承也是封装程序中可变因素的重要手段（如果不能理解请阅读阎宏博士的《Java与
java设计模式-中介者模式
02-27
设计模式（Design pattern）代表了最佳的实践，通常被有经验的面向对象的软件开发人员所采用。设计模式是软件开发人员在软件开发过程中面临的一般问题的解决方案。这些解决方案是众多软件开发人员经过相当长的一段时间的试验和错误总结出来的。
中介者模式
实践求真知
02-20 429
一 点睛 一般来说，同事类之间的关系是比较复杂的，多个同事类之间互相关联时，他们之间的关系会呈现为复杂的网状结构，这是一种过度耦合的架构，即不利于类的复用，也不稳定。例如在下左图中，有六个同事类对象，假如对象1发生变化，那么将会有4个对象受到影响。如果对象2发生变化，那么将会有5个对象受到影响。也就是说，同事类之间直接关联的设计是不好的。 如果引入中介者模式，那么同事类之间的关系将变为星型结构，从下右图中可以看到，任何一个类的变动，只会影响的类本身，以及中介者，这样就减小了系统的耦合。一个好的设计，必定不会
外观模式 VS 中介者模式
weixin_30625691的博客
04-04 196
<外观模式> 看外观模式，自己刚开始的简单理解就是这个模式特别省事，方便自己。 定义：为子系统中的一组接口提供一个一致的界面，此模式定义了一个高层接口，这个接口使得这一子系统更加容易使用。 讲述：外观模式是一种使用频率非常高的结构型设计模式，它通过引入一个外观角色来简化客户端与子系统之间的交互，为复杂的子系统调用提供一个统一接口，降低子系统与客户端的...
设计模式（十四）中介者模式
Android进阶三部曲 - 刘望舒
03-06 6691
写了很多篇设计模式的文章，才发现没有讲关于设计模式的分类，那么这一篇就补上这一内容，顺便带来中介者模式的讲解。并与此前讲过的代理模式和外观模式做对比。
外观,代理与中介者模式
何静媛
01-12 4608
外观模式 个人理解：         子类继承外观类的所有属性方法，客户端只需要跟外观类进行交流，实现了对所有子类的封装。 没有使用外观类 如图：         应用外观类 如图：           代理模式 个人理解：          代理模式是将原类进行封装，客户端只需要与代理进行交流。代理就是原类的一个替身。简而言之就是用一个对象代表另
UML笔记
郗晓勇|利己者生,利人者恒
12-15 3248
uml基础与应用（第0讲） 2课程内容 2参考教材 2uml概述 2内容提纲 2面向对象技术（第一部分） 3模型与可视化建模 4什么是uml 4uml发展历史 5软件过程 6UML工具（第1讲） 6UML的构成 7UML示例(第3讲) 11UML在软件开发各个阶段的应用 11面向对象技术（第4讲） 12内容提纲 12面向对象技术的
Java开发工程师笔试面试题
Jealous_boy的博客
10-18 1966
1.List和Set和Map的区别 List，Set都是继承自Collection接口 List：元素放入顺序，元素可以重复,允许按照对象在集合中的索引位置检索对象，例如通过list.get(i)方法来获取集合中的元素； Set:元素放入无序，元素不可重复，重复元素会被覆盖掉 元素虽然无法顺序放入，但是元素在set中的位置是有该元素的HashCode决定的，其位置其实是固定的，加入Set的O...
【零散知识点总结2】
weixin_44543307的博客
03-09 5661
大部分知识点来源于网络，知道的可以在评论区贴上来源喔 内容涵盖：MySQL、Spring、Spring Boot、Spring Cloud、RabbitMQ、Kafka、 Linux 等技术栈 零散知识点总结2MySQLMySQL 中有哪几种锁？MySQL 中有哪些不同的表格？简述在 MySQL 数据库中 MyISAM 和 InnoDB 的区别 MySQL MySQL 中有哪几种锁？ 1、表级锁：开销小，加锁快；不会出现死锁；锁定粒度大，发生锁冲突的概率最高，并发度最低。 2、行级锁：开销大，加锁慢；会出现
外观模式
weixin_30674525的博客
08-08 299
深入浅出外观模式（一） 外观模式是一种使用频率非常高的结构型设计模式，它通过引入一个外观角色来简化客户端与子系统之间的交互，为复杂的子系统调用提供一个统一的入口，降低子系统与客户端的耦合度，且客户端调用非常方便。 1.外观模式概述 不知道大家有没有比较过自己泡茶和去茶馆喝茶的区别，如果是自己泡茶需要自行准备茶叶、茶具和开水，如图1(A)所示，而去茶馆喝茶，最简单的方式就是跟茶馆服务员说想...
北风设计模式课程---外观模式、代理模式和中介者模式的区别
weixin_33701294的博客
06-21 191
北风设计模式课程---外观模式、代理模式和中介者模式的区别 一、总结 一句话总结： 1、外观模式（Facade Pattern）：外观类隐藏子系统的复杂性 2、代理模式（Proxy Pattern）：用一个代理类代表另一个类的功能 3、中介者模式（Mediator Pattern）：用一个中介对象来封装一系列的对象交互：比如男人类和女人类之间的交互给媒婆 二、外观模式...
外观模式-Facade/中介者模式-Mediator
Somous_的博客
11-01 213
外观模式主要解决：降低访问复杂系统的内部子系统时的复杂度，简化客户端之间的接口。 中介者模式主要解决：对象与对象之间存在大量的关联关系，这样势必会导致系统的结构变得很复杂，同时若一个对象发生改变，我们也需要跟踪与之相关联的对象，同时做出相应的处理。 外观模式 public class CPU { public void startup(){ System.out.println("cpu startup!"); } public void shutdown(){ Syst.
再话设计模式-外观模式和中介者模式对比
一朝风月
01-31 636
1 说明       在《设计模式-结构型设计模式》文章的3.3章节（https://blog.csdn.net/weixin_37624828/article/details/105955923）和《设计模式-行为型设计模式》文章中的4.5章节（https://blog.csdn.net/weixin_37624828/article/details/106059837）和已经提到外观模式和中介者模式是如何编写的，并对应给出了两个例子，外观模式给
中介者模式和外观模式的区别
qq_41970663的博客
12-24 4281
对于中介者模式和外观模式或许有一定的了解，但是他们因为太过相似而难以分别，今天就总结一下，给自己深刻的理解； 外观模式定义：为子系统中的一组接口提供一个一致的界面，此模式定义了一个高层接口，这个接口使得这一子系统更加容易使用。 中介者模式定义：用一个中介对象来封装一系列的对象交互。中介者使各对象不需要显式地相互引用，从而使其耦合松散，而且可以独立地改变它们之间的交互。 首先协议不同：中介者是...
设计模式之——外观模式（Facade）和中介者模式（Mediator）
V_S1r的博客
03-25 819
文章目录外观模式（Facade）定义使用场景 外观模式（Facade） 定义 Facade（外观） 模式为子系统中的各类（或结构与方法）提供一个简明一致的界面，隐藏子系统的复杂性，使子系统更加容易使用。它是为子系统中的一组接口所提供的一个一致的界面。 使用场景         在开发过程中功能和接口的不断扩展、子系统慢慢变得繁多时，在各个类之间的联系会变得比较复杂。这时候就需要用到Facade模式，创建一个用于对外打交道的“大管
设计模式 - 中介者模式
好好学习，天天向上
12-06 335
中介者模式 ​ 在现实生活中，常常会出现好多对象之间存在复杂的交互关系，这种交互关系常常是“网状结构”，它要求每个对象都必须知道它需要交互的对象。例如，每个人必须记住他（她）所有朋友的电话；而且，朋友中如果有人的电话修改了，他（她）必须让其他所有的朋友一起修改，这叫作“牵一发而动全身”，非常复杂。 ​ 如果把这种“网状结构”改为“星形结构”的话，将大大降低它们之间的“耦合性”，这时只要找一个“中介者”就可以了。如前面所说的“每个人必须记住所有朋友电话”的问题，只要在网上建立一个每个朋友都可以访问的“通.
[Java] [设计模式] [行为型模式] [外观模式/门面模式]
Hendy_Raw的博客
10-12 201
定义 要求一个子系统的外部与其内部的通信必须通过一个统一的对象进行。 举个例子，我们在启动计算机时，只需按一下开关键，无需关系里面的磁盘、内存、cpu、电源等等这些如何工作，我们只关心他们帮我启动好了就行。实际上，由于里面的线路太复杂，我们也没办法去具体了解内部电路如何工作。主机提供唯一一个接口“开关键”给用户就好。 模式结构 示例 /** * cpu子系统类 */ public class...
"FlyWeight效果-软件设计模式—结构型模式讲义
除了Flyweight模式之外，结构型模式还包括Facade（外观）模式、Proxy（代理）模式、Adapter（适配器）模式、Bridge（桥接）模式、Composite（组合）模式、Decorator（装饰）模式等。 在Flyweight模式中，适配器...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值