设计模式 概览

版权声明:欢迎转载,转载请说明出处. 大数据Github项目地址https://github.com/SeanYanxml/bigdata。 https://blog.csdn.net/u010416101/article/details/88859685

前言

概括总结下设计模式. 通常, 设计模式人如其名, 从名称中其实就可以透露出设计模式的主要信息. 本章从名称入手, 概括性总结下设计模式.

什么叫做理解了设计模式? 个人认为, 从名称入手, 一句话就总结出模式的纲要, 最能体现一个人的功力.


章节目录

本文主要包括如下几个部分:

  • 六项基本准则
  • 创建型模式(五种)
  • 结构型模式(七种)
  • 行为型模式(十一种)

另: 1. 本章是概览章节, 具体细节请看同系列其他章节.
2. 模式是死的,业务是活的. 业务不同, 理解不同, 解读不同, 设计也不同.


六项基本原则

不以规矩, 难以成方圆.

  • 从结构划分的角度来说, 单一指责原则接口隔离原则分别从业务结构两个角度定义了类结构的划分.
  • 其次, 依赖倒置里氏替换原则设计理念设计要求上规范我们在开发的时候要面向接口, 父类存在的地方子类一定可以替换.
  • 迪米特法则是对于类中方法划分的一种补充.
  • 开闭原则是基本规则的最终目标: 对修改关闭, 对扩展(继承/使用)开放的.
  • 实际上, 六项基本原则无非告诉我们如下几点: 业务对象和开发类如何划分面向接口开发对修改关闭&对扩展开放.

面对原则, 我们应对: 拥抱原则,单不拘泥于原则. 拥抱变化, 以需求为核心进行设计. 要知道, 一切的设计都是为了满足实际需求.


创建型模式

创建者模式的目标是创建对象. 其种类也比较多样, 主要包括如下五种:

  • 工厂模式: 对象工厂, 用于生产类的对象.
  • 抽象工厂模式: 抽象对象工厂, 将工厂模式中的某些方法抽象出来;
  • 单例模式: 单个对象的模式;
  • 原型模式: 拷贝创建的模式;
  • 建造者模式: 集合创建对象的模式.
单例模式

单例模式的核心在于类中维护类中对象的唯一性.
在这里插入图片描述

单例模式类{
	唯一对象;
	获取唯一对象方法() {返回 唯一对象;}
}

相关问题: 懒汉模式、饿汉模式、双重锁定(Synchronized&Volatile)

工厂模式

工厂模式的要点在于创建对象. (可以是特地对象、通用对象、单例对象.)
在这里插入图片描述

工厂模式类{
	创建对象方法{	返回 创建对象; }
}

相关问题: 通用工厂模式、单例工厂模式

抽象工厂模式

抽象工厂的核心仍然是创建对象. 抽象工厂是对于工厂模式的抽象.
在这里插入图片描述

抽象工厂接口{
	创建对象接口
}
抽象工厂类 继承 抽象工厂接口{
	创建对象类{ 返回 实例对象}
}

相关问题: 抽象工厂模式(多流水线)

原型模式

原型模式的核心在于拷贝创建. 个人认为, 成为拷贝创建模式也无不可.
在这里插入图片描述

原型业务类{
	拷贝方法(拷贝对象) {返回 拷贝对象}
}

相关问题: 浅拷贝、深拷贝(集合&数字流)、PropertiesUtils.copy()、拷贝创建不需要运行初始化方法.

建造者模式

建造者模式的核心在于创建对象, 并对对象进行组装.
在这里插入图片描述

建造类{
	建造方法{
		对象初始化;
		组装步骤1;
		组装步骤2;
		返回 对象;
	}
}

相关问题: 通用建造模式、多参数构造函数


结构型模式

结构型模式与创建型不同. 其旨在类与类之间的关系. 结构型模式主要包括如下几种:

  • 适配器模式: 适配不同的接口&类.
  • 装饰模式: 对接口&方法进行装饰, 补充.
  • 代理模式: 对对象进行代理.
  • 门面模式: 统一开放对门面.
  • 桥接模式: 桥接抽象对象,使两边能够独立对变化.
  • 组合模式: 部分与整体进行组合.
  • 享元模式: 分享和重用对象.
适配器模式

适配器模式的核心在于匹配. 通过适配, 将不同的接口进行匹配.

接口A{
	接口方法A
}
类A{
	方法A
}
接口B{
	接口方法B
}
类B{
	方法B
}
适配类 继承 类A 实现 接口B{
	方法B{
		类A.方法A()
	}
}

相关问题: 类适配器、对象适配器、接口适配器.

代理模式

代理模式的核心在于代理被代理的对象.

类A{
	方法A
}
代理类{
	对象A
	方法A{
		对象A.方法A
	}
}

相关问题: 静态代理、动态代理

装饰模式

装饰模式的核心在于在原类的前后进行装饰(丰富).

类A{
	方法A
}
装饰类{
	对象A
	方法A{
		方法前装饰
		对象A.方法A
		方法后装饰
	}
}

相关问题: 通用装饰模式.

门面模式

门面模式的核心在于作为门面开放,隐藏实现的细节.

类A{
	方法A
}
类B{
	方法B
}
门面类{
	对象A
	对象B
	方法A { 对象A.方法A }
	方法B { 对象B.方法B }
}

相关问题: 通用门面模式

桥接模式

桥接模式的核心在于, 将抽象与抽象对接, 使其对接的双方可以独立变化.

抽象类A1{
	方法A
}
实现类A2 继承 抽象类A1{
	方法A
}
抽象类B1 {
	抽象对象A1-1
	方法B { 抽象对象A1-1.方法A }
}
实现类B2 继承 抽象类B1{
	方法B
}
组合模式

组合模式的核心在于部分与整体.

组合类A{
}
组合类B{
	集合<组合类A> 组合类A集合对象;
}

相关问题: 树类型结构

享元模式

享元模式的核心在于对象的分享.

享元类A{
	享元方法A
}

享元工具类A{
	集合<享元类A> 享元类A集合对象;
	享元方法{
		享元类A集合对象.获取享元对象.享元方法A
	}
}

相关问题: 线程池、线程安全问题


行为型模式

行为型模式旨在类与类间的动态关系. 行为型模式主要包括如下几种.

  • 策略模式: 根据调用类, 使用不同的策略.
  • 模板方法模式: 提供创建类的模板.
  • 观察者模式: 观察对象, 更新通知.
  • 迭代子模式: 迭代接口, 遍历对象.
  • 责任链模式: 链式调用.
  • 命令模式: 命令发布者、接收者、执行者拆分.
  • 备忘录模式: 数据库备忘.
  • 状态模式: 根据状态变化当前调用?
  • 访问者模式: 允许访问接口.
  • 中介者模式: 解耦类见复杂调用.
  • 解释器模式: 解析表达式.
策略模式

策略模式的核心在于将策略封装, 调用类调用策略接口, 实现类可以相互替换.

策略接口{
	策略方法
}
策略实现类A 继承 策略接口{
	策略方法
}
策略实现类B 继承 策略接口{
	策略方法
}
策略实现类C 继承 策略接口{
	策略方法
}
场景类{
	主方法{
		策略接口 策略接口对象 = 策略实现类A对象;
		// 此处调用的就是A对象的方法
		策略接口对象.策略方法
	}
}

相关问题: 多态

模版方法模式

模版方法模式就是将部分实现模板化, 留给子类进行实现.

模版类{
	方法A{
		抽象方法B
	}
	抽象方法B
}

模板子类 继承 模板类{
	// 实现抽象方法B
	方法B{ }
}

相关问题: 通用模板方法

观察者模式

观察者模式的核心在于观察者注册和观察者通知.

观察者类A{
}

被观察类B{
	观察者类A 对象A
	构造函数{
		初始化对象A
	}
	方法B{
		更新被观察类B
		通知观察者
	}
}

相关问题: 触发器, 监听器

迭代子模式

迭代子模式的核心在于实现迭代接口.

迭代接口{
	接口方法A: 是否有下一个成员
	接口方法B: 获取下一个成员
	接口方法C: 获取迭代器
}

实例方法 实现 迭代接口{
	方法A: 是否有下一个成员
	方法B: 获取下一个成员
	方法C: 获取迭代器
}

相关问题: 迭代器

责任链模式

责任链模式的核心在于链式调用.

责任接口{
	责任方法
}
类A 实现 责任接口{
	接口对象 接口对象A
	构造函数{
		初始化接口对象A
	}
	责任方法{ 接口对象A.责任方法. }
}
类B 实现 责任接口{
	接口对象 接口对象B
	构造函数{
		初始化接口对象B
	}
	责任方法{ 接口对象B.责任方法. }
}

相关问题: 通用责任链

命令模式

命令模式将命令发送者、命令接收者、命令执行者进行解耦的模式. 发送者只需要知道接收者是谁, 而不需要知道执行者. 个人理解, 命令接收者是实现的纽带.

命令发送者{
	发送(接收者){}
}
命令接收者{
	传递(执行者){}
}
命令执行者{
	执行方法
}

乍一看和责任链有些类似. 但是需要注意的是责任链是相同级别的对象之间的操作. 命令模式是不同级别对象之间的操作.
相关问题: 通用命令模式

备忘录模式

备忘录模式的核心在于存储历史状态, 获取历史状态. 其作用和数据库差不多.

实例类A{
	属性A_1
}
备忘录类{
	属性B_1
	设置属性方法
	获取属性方法
}
场景类{
	主方法{
		实例类A 对象类A
		// 存储属性
		备忘录类.设置属性方法(对象类A.属性A_1)
		对象类A.属性A_1 变化为 对象类A.属性A_2
		 备忘录类.获取属性方法()
	}
}


相关问题: 通用备忘录模式、数据库、缓存

状态模式

不太熟悉.(简略写下)

状态模式的核心在于一个类中维护多个状态. 根据状态的模式调用进行不同的操作.

类A{
	方法A_1
	方法B_1
}
类B{
	方法A_2
	方法B_2
}

状态类{
	接口 当前生效实例接口C
	类A 对象A
	类B 对象B
	方法A{
		当前生效实例C.方法A
	}
	方法B{
		当前生效实例C.方法B
	}
	更改状态{
		// 更改状态为状态A
		当前生效实例接口C = 对象A
		// 更改状态为状态B
		当前生效实例接口C = 对象B
	}
}

相关问题: 通用状态模式

访问者模式

不太熟悉.(简略写下)

访问者模式的核心在于不该变数据结构的情况下, 通过添加访问者, 对原有的方法进行扩展.

访问的核心在于自己不调用自己, 让外部调用自己, 进行一定的操作. 比如public void accept(Visitor visitor){visitor.visit(this)}看似是对于对象类Element的调用, 其实是对与访问者Visior的调用, Visitor.visit(element). 于是, 我们可以通过不同的Visitor类, 进行不同的定制化操作. 而不需要更改Element类.

数据结构类A{
	// 对原数据结构的扩展
	同意访问(访问者){
		访问者.访问方法(当前对象)
	}
}
访问者类B{
	访问对象(数据结构){
		// 数据结构类型A
		操作A
		// 数据结构类型B
		操作B
		// 其他数据了下
		其他操作
	}
}
场景类C{
	主方法{
		数据结构类A 数据结构对象A_1
		访问者类B 访问者对象B_1
		数据结构对象A_1.同意访问(访问者对象B_1)
	}
}

相关问题: 通用访问者模式.

中介者模式

中介者模式的核心在于使用中介者, 将相关对象解耦.

类A{
	中介者类C 中介者对象C_1
	方法A	
	方法B {中介者对象C_1.类B对象B_1.方法B}
}
类B{
	中介者类C 中介者对象C_1
	方法B
	方法A {中介者对象C_1.类A对象A_1.方法A}
}
中介者类C{
	类A 类A对象A_1
	类B 类B对象B_1
}

相关问题: 通用中介者模式

解释器模式

解释器模式的核心在于解释解析式.

解析器类{
	解析方法(解析字符串){
		解析
	}
}

相关问题: 解析字符串、逆波兰解析式


Reference

[1]. 设计模式之禅
[2]. Java开发中的23种设计模式详解(转)

展开阅读全文

没有更多推荐了,返回首页