23种设计模式详解及实现方式
详解23种设计模式
详解23种设计模式
设计模式（Design Patterns）
⾸先说⼀下我对设计模式的理解，设计模式是⼀种在软件内部优化代码的技巧。注意，是代码的内部，也就是在⼀个局部范围内优化设
计。这⼀点和软件的架构是完全不同的，软件架构是全局的优化，讲的是怎么对软件进⾏切分以及对切开之后的内容进⾏重组的⼀个过程。
软件的设计模式强调的是代码，软件架构强调的是结构。在⾯向对象的编程思想中，这就体现在怎么解决类与类之间的关系。能处理好类与
类之间的关系，优化设计就搞好了。下⾯这段话是软件设计模式的定义：
设计模式（Design pattern）是⼀套被反复使⽤、多数⼈知晓的、经过分类编⽬的、代码设计经验的总结。使⽤设计模式是为了可重⽤
代码、让代码更容易被他⼈理解、保证代码可靠性。
毫⽆疑问，设计模式于⼰于他⼈于系统都是多赢的，设计模式使代码编制真正⼯程化，设计模式是软件⼯程的基⽯，如同⼤厦的⼀块块
砖⽯⼀样。项⽬中合理的运⽤设计模式可以完美的解决很多问题，每种模式在现在中都有相应的原理来与之对应，每⼀个模式描述了⼀个在
我们周围不断重复发⽣的问题，以及该问题的核⼼解决⽅案，这也是它能被⼴泛应⽤的原因。设计模式是⼀代⼜⼀代的编程⼤师总结出来
的，我们应该重视，不能束之⾼阁，应当合理利⽤。关键是要搞清楚哪种情况⽤哪种设计模式。
⼀、设计模式的分类
总体来说设计模式分为三⼤类：
创建型模式，共五种：⼯⼚⽅法模式、抽象⼯⼚模式、单例模式、建造者模式、原型模式。（还有⼀种叫简单⼯⼚模式，是⼯⼚模式的变
形，不满⾜单⼀职责，设计不太合理，所以就没列出来）
结构型模式，共七种：适配器模式、装饰器模式、代理模式、外观模式、桥接模式、组合模式、享元模式。
⾏为型模式，共⼗⼀种：策略模式、模板⽅法模式、观察者模式、迭代⼦模式、责任链模式、命令模式、备忘录模式、状态模式、访问者模
式、中介者模式、解释器模式。
⼆、设计模式的七⼤原则
设计模式的七⼤原则堪称经典，这七条原则是我们在设计软件的过程中必须准守的，当然不遵守的话，你的⽼板可能就会“嘿嘿”你，你懂
23种设计模式及应用
23种设计模式及应用
设计模式是指在软件设计过程中，针对常见问题的解决方案的经验总结。它们提供了解决特定或常见问题的可重用方案，使得软件设计更加灵活、可扩展和可维护。
1. 创建型模式：
- 单例模式：确保一个类只有一个实例，并提供全局访问点。
- 简单工厂模式：通过一个共同的接口创建不同的对象实例。
- 工厂方法模式：定义一个创建对象的接口，由子类决定具体创建哪个对象。
- 抽象工厂模式：提供一个创建一系列相关或互相依赖对象的接口。
- 建造者模式：将一个复杂对象的构建与其表示分离，使得同样的构建过程可以创建不同的表示。
2. 结构型模式：
- 适配器模式：将一个类的接口转换为客户端所期待的另一种接口。
- 桥接模式：将抽象部分与它的实现部分分离，使它们可以独立变化。
- 组合模式：将对象组合成树形结构以表示"整体-部分"的层次结构。
- 装饰器模式：动态地给对象添加额外的功能，避免继承带来的类膨胀问题。
- 外观模式：为子系统中一组接口提供一个一致的界面。
3. 行为型模式：
- 策略模式：定义一系列算法，将它们封装起来，并使它们可以相互替换。 - 观察者模式：定义对象之间的依赖关系，当对象状态改变时自动通知依赖方。
- 模板方法模式：定义一个操作中的算法骨架，将一些步骤延迟到子类中实现。
- 命令模式：将一个请求封装成一个对象，从而使您可以用不同的请求参数化客户端对象。
- 状态模式：允许对象在其内部状态改变时改变其行为。
4. J2EE模式：
- MVC模式：将应用程序划分为三个核心组件：模型、视图和控制器。
- 业务代表模式：将对业务对象的访问和业务逻辑从表示层分离出来。
- 数据访问对象模式：用于将业务逻辑和数据访问逻辑分离。
- 前端控制器模式：通过一个单一的入口点来处理应用程序的所有请求。
JAVA23种设计模式详细讲解
一、设计模式的分类
总体来说设计模式分为三大类：
创建型模式，共五种：工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式。
结构型模式，共七种：适配器模式、装饰器模式、代理模式、外观模式、桥接模式、组合模式、享元模式。
行为型模式，共十一种：策略模式、模板方法模式、观察者模式、迭代子模式、责任链模式、命令模式、备忘录模式、状态模式、访问者模式、中介者模式、解释器模式。
其实还有两类：并发型模式和线程池模式。用一个图片来整体描述一下：
二、设计模式的六大原则 1、开闭原则（Open Close Principle）
开闭原则就是说对扩展开放，对修改关闭。在程序需要进行拓展的时候，不能去修改原有的代码，实现一个热插拔的效果。所以一句话概括就是：为了使程序的扩展性好，易于维护和升级。想要达到这样的效果，我们需要使用接口和抽象类，后面的具体设计中我们会提到这点。
2、里氏代换原则（Liskov Substitution Principle）
里氏代换原则(Liskov Substitution Principle LSP)面向对象设计的基本原则之一。 里氏代换原则中说，任何基类可以出现的地方，子类一定可以出现。 LSP是继承复用的基石，只有当衍生类可以替换掉基类，软件单位的功能不受到影响时，基类才能真正被复用，而衍生类也能够在基类的基础上增加新的行为。里氏代换原则是对“开-闭”原则的补充。实现“开-闭”原则的关键步骤就是抽象化。而基类与子类的继承关系就是抽象化的具体实现，所以里氏代换原则是对实现抽象化的具体步骤的规范。—— From Baidu 百科
3、依赖倒转原则（Dependence Inversion Principle）
这个是开闭原则的基础，具体内容：真对接口编程，依赖于抽象而不依赖于具体。
4、接口隔离原则（Interface Segregation Principle）
这个原则的意思是：使用多个隔离的接口，比使用单个接口要好。还是一个降低类之间的耦合度的意思，从这儿我们看出，其实设计模式就是一个软件的设计思想，从大型软件架构出发，为了升级和维护方便。所以上文中多次出现：降低依赖，降低耦合。
经典文档-23种设计模式
二十三种设计模式
1 引言
谈到设计模式，绝对应该一起来说说重构。重构给我们带来了什么？除了作为对遗留代码的改进的方法，另一 大意义在于，可以让我们在写程序的时候可以不需事先考虑太多的代码组织问题，当然这其中也包括了应用模式的问题。尽管大多数开发者都已经养成了写代码前先 从设计开始的习惯，但是，这种程度的设计，涉及到到大局、到总体架构、到主要的模块划分我觉得就够了。换句话说，这时就能写代码了。这就得益于重构的思想 了。如果没有重构的思想，有希望获得非常高质量的代码，我们就不得不在开始写代码前考虑更多其实并非非常稳定的代码组织及设计模式的应用问题，那开发效率 当然就大打折扣了。在重构和设计模式的合理应用之下，我们可以相对较早的开始写代码，并在功能尽早实现的同时，不断地通过重构和模式来改善我们的代码质 量。所以，下面的章节中，在谈模式的同时，我也会谈谈关于常用的这些模式的重构成本的理解。重构成本越高意味着，在遇到类似的问题情形的时候，我们更应该 提前考虑应用对应的设计模式，而重构成本比较低则说明，类似的情形下，完全可以先怎么方便，怎么快怎么写，哪怕代码不是很优雅也没关系，回头再重构也很容 易。
1 创建型
1.1 Factory Method
思想：Factory Method的主要思想是使一个类的实例化延迟到其子类。
场景：典 型的应用场景如：在某个系统开发的较早阶段，有某些类的实例化过程，实例化方式可能还不是很确定，或者实际实例化的对象（可能是需要对象的某个子类中的一 个）不确定，或者比较容易变化。此时，如果直接将实例化过程写在某个函数中，那么一般就是if-else或select-case代 码。如果，候选项的数目较少、类型基本确定，那么这样的if-else还是可以接受的，一旦情形变 得复杂、不确定性增加，更甚至包含这个构造过程的函数所在的类包含几个甚至更多类似的函数时，这样的if-else代 码就会变得比较不那么容易维护了。此时，应用本模式，可以将这种复杂情形隔离开，即将这类不确定的对象的实例化过程延迟到子类。 实现：该模式的典型实现方法就是将调用类定义为一个虚类，在调用类定义一个专门用于构造不确定的对象实例的虚函数，再将实际的对象实例化代码 留到调用类的子类来实现。如果，被构造的对象比较复杂的话，同时可以将这个对象定义为可以继承、甚至虚类，再在不同的调用类的子类中按需返回被构造类的子 类。
23种设计模式代码
23种设计模式代码
设计模式是软件工程中常用的解决问题的方法论，它们提供了一套通用的解决方案，帮助开发人员设计出可复用、可维护和可扩展的代码。本文将介绍23种常见的设计模式，分别是：
1. 单例模式：确保一个类只有一个实例，并提供全局访问点。
2. 简单工厂模式：通过一个工厂类创建不同类型的对象，而无需直接实例化对象。
3. 工厂方法模式：定义一个创建对象的接口，由子类决定实例化哪个类。
4. 抽象工厂模式：提供一个创建一系列相关或相互依赖对象的接口，而无需指定具体类。
5. 建造者模式：将一个复杂对象的构建与其表示分离，使同样的构建过程可以创建不同的表示。
6. 原型模式：通过复制现有对象来创建新对象，而无需知道具体的创建过程。
7. 适配器模式：将一个类的接口转换为客户端所期望的另一个接口。
8. 桥接模式：将抽象部分与实现部分分离，使它们可以独立变化。
9. 组合模式：将对象组合成树形结构以表示“整体-部分”的层次结构，使客户端对单个对象和组合对象的使用具有一致性。
10. 装饰器模式：动态地给一个对象添加额外的职责，同时又不改变其结构。
11. 外观模式：为子系统中的一组接口提供一个统一的接口，用来简化客户端的使用。
12. 享元模式：通过共享对象来减少内存使用，提高性能。
13. 代理模式：为其他对象提供一种代理以控制对这个对象的访问。
14. 责任链模式：将多个对象组成一条链，并沿着这条链传递请求，直到有一个对象处理它为止。
15. 命令模式：将一个请求封装成一个对象，从而使你可以用不同的请求对客户端进行参数化。
16. 解释器模式：给定一个语言，定义它的文法的一种表示，并定义一个解释器，该解释器使用该表示来解释语言中的句子。
17. 迭代器模式：提供一种方法顺序访问一个聚合对象中的各个元素，而又不需要暴露该对象的内部表示。
18. 中介者模式：用一个中介对象来封装一系列对象之间的交互，使得各对象之间不需要显式地相互引用。
23种设计模式___大牛笔记
设计模式（Design Patterns）
——可复用面向对象软件的基础
设计模式（Design pattern）是一套被反复使用、多数人知晓的、经过分类编目的、代码设计经验的总结。使用设计模式是为了可重用代码、让代码更容易被他人理解、保证代码可靠性。 毫无疑问，设计模式于己于他人于系统都是多赢的，设计模式使代码编制真正工程化，设计模式是软件工程的基石，如同大厦的一块块砖石一样。项目中合理的运用设计模式可以完美的解决很多问题，每种模式在现在中都有相应的原理来与之对应，每一个模式描述了一个在我们周围不断重复发生的问题，以及该问题的核心解决方案，这也是它能被广泛应用的原因。本章系Java之美[从菜鸟到高手演变]系列之设计模式，我们会以理论与实践相结合的方式来进行本章的学习，希望广大程序爱好者，学好设计模式，做一个优秀的软件工程师！
一、设计模式的分类
总体来说设计模式分为三大类：
创建型模式，共五种：工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式。
结构型模式，共七种：适配器模式、装饰器模式、代理模式、外观模式、桥接模式、组合模式、享元模式。
行为型模式，共十一种：策略模式、模板方法模式、观察者模式、迭代子模式、责任链模式、命令模式、备忘录模式、状态模式、访问者模式、中介者模式、解释器模式。
其实还有两类：并发型模式和线程池模式。用一个图片来整体描述一下：
二、设计模式的六大原则
1、开闭原则（Open Close Principle）
开闭原则就是说对扩展开放，对修改关闭。在程序需要进行拓展的时候，不能去修改原有的代码，实现一个热插拔的效果。所以一句话概括就是：为了使程序的扩展性好，易于维护和升级。想要达到这样的效果，我们需要使用接口和抽象类，后面的具体设计中我们会提到这点。
2、里氏代换原则（Liskov Substitution Principle）
23种设计模式 简单明了
23种设计模式 简单明了
1. 单例模式（Singleton Pattern）：确保一个类只有一个实例，并提供全局访问点。
2. 工厂模式（Factory Pattern）：定义创建对象的接口，但将实际创建对象的过程推迟到子类中。
3. 抽象工厂模式（Abstract Factory Pattern）：提供一个创建一系列相关对象的接口，而无需指定具体的类。
4. 建造者模式（Builder Pattern）：将一个复杂对象的创建与表示分离，使同样的构建过程可以创建不同的表示。
5. 原型模式（Prototype Pattern）：通过复制现有的对象来创建新对象。
6. 适配器模式（Adapter Pattern）：将一个类的接口转换成客户希望的另一个接口。
7. 桥接模式（Bridge Pattern）：将抽象与实现分离，使它们可以独立变化，从而减少两者之间的耦合。
8. 过滤器模式（Filter Pattern）：通过某种条件来过滤一组对象。
9. 组合模式（Composite Pattern）：将对象组合成树形结构，以表示 "部分-整体" 的层次结构。
10. 装饰器模式（Decorator Pattern）：动态地给一个对象添加一些额外的职责。
11. 外观模式（Facade Pattern）：隐藏系统的复杂性，并向客户端提供一个简化的接口。
12. 享元模式（Flyweight Pattern）：共享对象，以便有效地支持大量细粒度的对象。
13. 代理模式（Proxy Pattern）：为其他对象提供一种代理以控制对这个对象的访问。
14. 责任链模式（Chain of Responsibility Pattern）：将请求的发送者和接收者解耦，并让多个对象都有机会处理这个请求。
15. 命令模式（Command Pattern）：将请求封装成对象，从而允许使用不同的请求、队列或者日志请求。
Java开发中的23种设计模式详解（转）
Java开发中的23种设计模式详解（转）
设计模式 学习进阶中 。。。 敬请谅解。
设计模式（Design Patterns）
——可复⽤⾯向对象软件的基础
计模式（Design pattern）是⼀套被反复使⽤、多数⼈知晓的、经过分类编⽬的、代码设计经验的总结。使⽤设计模式是为了可重⽤代
码、让代码更容易被他⼈理解、保证代码可靠性。 毫⽆疑问，设计模式于⼰于他⼈于系统都是多赢的，设计模式使代码编制真正⼯程化，设
计模式是软件⼯程的基⽯，如同⼤厦的⼀块块砖⽯⼀样。项⽬中合理的运⽤设计模式可以完美的解决很多问题，每种模式在现在中都有相应
的原理来与之对应，每⼀个模式描述了⼀个在我们周围不断重复发⽣的问题，以及该问题的核⼼解决⽅案，这也是它能被⼴泛应⽤的原因。
本章系Java之美[从菜鸟到⾼⼿演变]系列之设计模式，我们会以理论与实践相结合的⽅式来进⾏本章的学习，希望⼴⼤程序爱好者，学好设
计模式，做⼀个优秀的软件⼯程师！
⼀、设计模式的分类
总体来说设计模式分为三⼤类：
创建型模式，共五种：⼯⼚⽅法模式、抽象⼯⼚模式、单例模式、建造者模式、原型模式。
结构型模式，共七种：适配器模式、装饰器模式、代理模式、外观模式、桥接模式、组合模式、享元模式。
⾏为型模式，共⼗⼀种：策略模式、模板⽅法模式、观察者模式、迭代⼦模式、责任链模式、命令模式、备忘录模式、状态模式、访问者模
式、中介者模式、解释器模式。
其实还有两类：并发型模式和线程池模式。⽤⼀个图⽚来整体描述⼀下：
⼆、设计模式的六⼤原则
1、开闭原则（Open Close Principle）
开闭原则就是说对扩展开放，对修改关闭。在程序需要进⾏拓展的时候，不能去修改原有的代码，实现⼀个热插拔的效果。所以⼀句话概括
就是：为了使程序的扩展性好，易于维护和升级。想要达到这样的效果，我们需要使⽤接⼝和抽象类，后⾯的具体设计中我们会提到这点。
2、⾥⽒代换原则（Liskov Substitution Principle）
23种设计模式
23种设计模式（Design Patterns）
设计模式（Design pattern）是一套被反复使用、多数人知晓的、经过分类编目的、代码设计经验的总结。使用设计模式是为了可重用代码、让代码更容易被他人理解、保证代码可靠性。项目中合理的运用设计模式可以完美的解决很多问题，每种模式在现在中都有相应的原理来与之对应，每一个模式描述了一个在我们周围不断重复发生的问题，以及该问题的核心解决方案，这也是它能被广泛应用的原因。
一、总体来说设计模式分为三大类：
创建型模式，共五种：工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式。
结构型模式，共七种：适配器模式、装饰器模式、代理模式、外观模式、桥接模式、组合模式、享元模式。
行为型模式，共十一种：策略模式、模板方法模式、观察者模式、迭代子模式、责任链模式、命令模式、备忘录模式、状态模式、访问者模式、中介者模式、解释器模式。
还用两类模式：并发型模式和线程池模式。
二、设计模式六大原则:
总原则：开闭原则
开闭原则就是说对扩展开放，对修改关闭。在程序需要进行拓展的时候，不能去修改原有的代码，而是要扩展原有代码，实现一个热插拔的效果。所以一句话概括就是：为了使程序的扩展性好，易于维护和升级。想要达到这样的效果，我们需要使用接口和抽象类等。
1、单一职责原则
不要存在多于一个导致类变更的原因，也就是说每个类应该实现单一的职责，如若不然，就应该把类拆分。
2、里氏替换原则（Liskov Substitution Principle）
里氏代换原则(Liskov Substitution Principle LSP)是面向对象设计的基本原则之一。 里氏代换原则中说，任何基类可以出现的地方，子类一定可以出现。 LSP是继承复用的基石，只有当衍生类可以替换掉基类，软件单位的功能不受到影响时，基类才能真正被复用，而衍生类也能够在基类的基础上增加新的行为。里氏代换原则是对“开-闭”原则的补充。实现“开-闭”原则的关键步骤就是抽象化。而基类与子类的继承关系就是抽象化的具体实现，所以里氏代换原则是对实现抽象化的具体步骤的规范。
23种常用的设计模式
23种常⽤的设计模式
23种设计模式总体可以分为三类：
⼀、创建型模式
⼯⼚模式、抽象⼯⼚、单例模式、建造者模式、原型模式
⼆、结构型模式
装饰器模式、适配器模式、代理模式、外观模式、桥接模式、组合模式、享元模式
三、⾏为型模式
策略模式、观察者模式、模板⽅法模式、责任链模式、迭代⼦模式、备忘录模式、命令模式、访问者模式、中介者模式、状态模式、解
释器模式
下⾯主要介绍以上9种红⾊字体的设计模式。
（1）⼯⼚模式：定义⼀个创建对象的接⼝，让⼦类决定具体实例化哪⼀个对象。
public interface Sender{
void sender();
}
public class SenderFactory{ //创建简单⼯⼚
public Sender produce(String type){
if(type.equals("mail")){
return new MailSender();
}else if(type.equals("msg")){
return new MsgSender();
}else{
return null;
}
}
}
（2）抽象⼯⼚：为⼀组相关或相互依赖的对象提供⼀个接⼝，且⽆需指定他们的具体实现类。
//定义实现功能的接⼝
public interface Sender{
void sender();
}
//定义⽣产⼯⼚的接⼝,提供⼀个返回上⾯接⼝功能的⽅法，⽐如Sender
public interface Provider{
Sender produce();
}
//扩展发送邮件的实现类
public class MailSenderFactory implements Provider{
@Override
Sender produce(){
return new MailSender();
}
}
（3）单例模式：确保⼀个类只存在⼀个实例（介绍两种线程安全的单例模式）
1.使⽤volatile关键字实现线程安全的单例模式