GOF以及JAVA的23种设计模式简介
常见设计模式及应用场景
常见设计模式及应用场景设计模式是一种解决特定问题的经验总结，可以提高代码的可重用性、可读性和灵活性。
在软件开发过程中，常见的设计模式有23种，下面将对其中的几种常见的设计模式及其应用场景进行介绍。
1. 单例模式（Singleton Pattern）：单例模式用于限制一个类只能有一个实例，并提供一个全局访问点。
在需要频繁创建和销毁对象的场景下，可以使用单例模式来减少系统开销。
例如，在多线程环境下需要共享某个资源时，通过单例模式可以保证该资源只有一个实例。
2. 工厂模式（Factory Pattern）：工厂模式用于创建对象，把实例化对象的过程封装在一个工厂类中。
它解耦了对象的创建和使用，提高了代码的可扩展性。
例如，一个电商平台上有多种类型的商品，可以通过工厂模式根据用户的选择来创建相应类型的商品。
3. 观察者模式（Observer Pattern）：观察者模式定义了一种一对多的依赖关系，当一个对象的状态发生改变时，所有依赖它的对象都会得到通知并自动更新。
观察者模式适用于对象之间存在一种一对多的关系，并且对象之间需要保持一致。
例如，一个新闻发布系统中，当发布一条新闻时，系统需要通知所有订阅该新闻频道的用户。
4. 策略模式（Strategy Pattern）：策略模式定义了一系列可以互相替换的算法，并根据具体情况选择合适的算法。
使用策略模式可以避免使用大量的if-else语句，提高代码的可维护性和扩展性。
例如，在一个电商平台中，根据会员等级的不同，可以采用不同的折扣策略来计算商品的价格。
5. 适配器模式（Adapter Pattern）：适配器模式用于将两个不兼容的接口转换为可兼容的接口，使得不同的类可以协同工作。
适配器模式可以增强代码的复用性和灵活性。
例如，一个音频播放器只支持mp3格式的音乐文件，当我们需要播放其他格式的音乐文件时，可以使用适配器模式将不同格式的音乐文件转换为mp3格式。
6. 建造者模式（Builder Pattern）：建造者模式可以将创建复杂对象的过程与表示分离，使得同样的创建过程可以创建不同的表示。
GOF的23种设计模式
GOF的23种设计模式一、创建型模式Abstract Factory：提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。
Builder：将一个复杂对象的构件与它的表示分离，使得同样的构建过程可以创建不同的表述。
Factory Method：定义一个用于创建对象的接口，让子类决定将哪一个类实例化。
Factory Method使一个类的实例化延迟到其子类。
Prototype：用原型实例指定创建对象的种类，并且通过拷贝这个原型来创建新的对象。
Singleton：保证一个类仅有一个实例，并提供一个访问它的全局访问点。
二、结构型模式Adapter：将一个类的接口转换成客户希望的另外一个接口。
Adapter模式使得原本由于接口不兼容而不能一起工作的那些类可以一起工作。
Bridge：将抽象部分与它的实现部分分离，使它们都可以独立地变化。
Composite：将对象组合成树型结构以表示“部分－整体”的层次结构。
Composite使得客户对单个对象和复合对象的使用具有一致性。
Decorator：动态地给一个对象添加一些额外的职责。
就扩展功能而言，Decorator模式比生成子类方式更为灵活。
Facade：为子系统中的一组接口提供一个一致的界面，Facade模式定义了一个高层接口，这个接口使得这一子系统更加容易使用。
Flyweight：运用共享技术有效地支持大量细粒度的对象。
Proxy：为其他对象提供一个代理以控制对这个对象的访问。
三、行为型模式Chain of Responsibility：为解除请求的发送者和接受者之间耦合，而使多个对象都有机会处理这个请求。
将这些对象连成一条链，并沿着这条链传递该请求，直到有一个对象处理它。
Command：将一个请求封装为一个对象，从而使你可以用不同的请求对客户进行参数化；对请求排队或记录请求日志，以及支持可取消的操作。
Interpreter：给定一个语言，定义它的文法的一种表示，并定义一个解释器，该解释器使用该表示来解释语言中的句子。
面向对象23种设计模式
面向对象23种设计模式面向对象23种设计模式在面向对象的编程中，设计模式是一种解决问题的通用方案。
设计模式可以帮助开发人员在开发过程中减少代码的冗余和复杂性，并提高代码的可维护性和可重用性。
本文将介绍23种面向对象的设计模式。
1. 工厂方法模式工厂方法模式是一种创建型设计模式，它定义了一个用于创建对象的接口，但是让子类决定实例化哪个类。
在工厂方法模式中，客户端不需要知道具体的创建逻辑，只需要知道工厂类中定义的接口即可。
2. 抽象工厂模式抽象工厂模式是一种创建型设计模式，它提供了一个接口，用于创建相关或依赖对象的家族，而不需要指定它们的具体类。
在抽象工厂模式中，客户端不需要知道具体的创建逻辑，只需要知道工厂类中定义的接口即可。
3. 单例模式单例模式是一种创建型设计模式，它保证一个类只有一个实例，并提供一个访问该实例的全局点。
4. 原型模式原型模式是一种创建型设计模式，它允许复制或克隆一个现有的对象，而不必知道其具体实现。
5. 建造者模式建造者模式是一种创建型设计模式，它允许逐步创建复杂的对象，而不必知道其内部实现细节。
6. 适配器模式适配器模式是一种结构型设计模式，它将一个或多个不兼容的类或接口转换为客户端所需的接口。
7. 桥接模式桥接模式是一种结构型设计模式，它将抽象部分与其实现部分分离开来，以便独立地进行修改。
8. 组合模式组合模式是一种结构型设计模式，它将一组对象作为单个对象处理，以便客户端可以以相同的方式处理单个对象和组合对象。
9. 装饰器模式装饰器模式是一种结构型设计模式，它允许向现有对象添加额外的功能，同时不改变其现有的结构。
10. 外观模式外观模式是一种结构型设计模式，它为一组复杂的子系统提供了一个统一的接口，以便于客户端使用。
11. 享元模式享元模式是一种结构型设计模式，它利用共享技术来最小化内存使用，以及提高应用程序的性能。
12. 代理模式代理模式是一种结构型设计模式，它提供了一个代理对象，使得客户端可以通过代理对象间接地访问实际对象。
Java设计模式之GOF23全面讲解
Java设计模式之GOF23全⾯讲解⼀、什么是设计模式设计模式（Design pattern）是解决软件开发某些特定问题⽽提出的⼀些解决⽅案也可以理解成解决问题的⼀些思路。
通过设计模式可以帮助我们增强代码的可重⽤性、可扩充性、可维护性、灵活性好。
我们使⽤设计模式最终的⽬的是实现代码的⾼内聚和低耦合。
⼆、设计模式的三⼤分类及关键点1、创建型模式对象实例化的模式，创建型模式⽤于解耦对象的实例化过程。
单例模式：某个类智能有⼀个实例，提供⼀个全局的访问点。
⼯⼚模式：⼀个⼯⼚类根据传⼊的参量决定创建出哪⼀种产品类的实例。
抽象⼯⼚模式：创建相关或依赖对象的家族，⽽⽆需明确指定具体类。
建造者模式：封装⼀个复杂对象的创建过程，并可以按步骤构造。
原型模式：通过复制现有的实例来创建新的实例。
2、结构型模式把类或对象结合在⼀起形成⼀个更⼤的结构。
装饰器模式：动态的给对象添加新的功能。
代理模式：为其它对象提供⼀个代理以便控制这个对象的访问。
桥接模式：将抽象部分和它的实现部分分离，使它们都可以独⽴的变化。
适配器模式：将⼀个类的⽅法接⼝转换成客户希望的另⼀个接⼝。
组合模式：将对象组合成树形结构以表⽰“部分-整体”的层次结构。
外观模式：对外提供⼀个统⼀的⽅法，来访问⼦系统中的⼀群接⼝。
享元模式：通过共享技术来有效的⽀持⼤量细粒度的对象。
3、⾏为型模式类和对象如何交互，及划分责任和算法。
策略模式：定义⼀系列算法，把他们封装起来，并且使它们可以相互替换。
模板模式：定义⼀个算法结构，⽽将⼀些步骤延迟到⼦类实现。
命令模式：将命令请求封装为⼀个对象，使得可以⽤不同的请求来进⾏参数化。
迭代器模式：⼀种遍历访问聚合对象中各个元素的⽅法，不暴露该对象的内部结构。
观察者模式：对象间的⼀对多的依赖关系。
仲裁者模式：⽤⼀个中介对象来封装⼀系列的对象交互。
备忘录模式：在不破坏封装的前提下，保持对象的内部状态。
解释器模式：给定⼀个语⾔，定义它的⽂法的⼀种表⽰，并定义⼀个解释器。
23种设计模式记忆口诀
23种设计模式记忆口诀设计模式是软件开发中常见的解决方案模板，它们能够解决许多常见的设计问题。
为了帮助记忆23种设计模式，可以使用下面这个口诀来记忆：Creational Patterns（创建型模式）:1. Singleton（单例模式）：一个类能产生一个实例，全局访问。
2. Builder（建造者模式）：分步骤创建复杂对象，易拓展。
3. Factory Method（工厂方法模式）：子类决定实例化哪个对象。
4. Abstract Factory（抽象工厂模式）：创建一组相关对象，不依赖具体类。
5. Prototype（原型模式）：通过复制现有对象来创建新对象。
Structural Patterns（结构型模式）:6. Adapter（适配器模式）：将类的接口转换为客户端希望的接口。
7. Bridge（桥接模式）：将抽象部分与实际部分分离。
将对象组合成树形结构来表示部分整体的层次结构。
9. Decorator（装饰器模式）：动态地给对象添加功能。
10. Facade（外观模式）：提供一个统一的接口，简化客户端使用。
11. Flyweight（享元模式）：共享细粒度对象，减少内存使用。
12. Proxy（代理模式）：控制对其他对象的访问。
Behavioral Patterns（行为型模式）:13. Chain Of Responsibility（责任链模式）：将请求的发送者和接收者解耦，多个对象都可能处理请求。
将请求封装成对象，可以用参数化方式处理。
15. Iterator（迭代器模式）：提供一种遍历集合的统一接口。
16. Mediator（中介者模式）：将多个对象之间的复杂关系解耦。
17. Memento（备忘录模式）：将对象的状态保存起来，以后可以恢复。
18. Observer（观察者模式）：当一个对象改变状态时，依赖它的对象都会收到通知。
19. State（状态模式）：对象的行为随状态的改变而改变。
面向对象设计的23个设计模式详解
面向对象设计的23个设计模式详解面向对象设计是一种广泛应用于软件开发的思想，其核心在于将数据和操作封装在一起形成对象，并通过各种方式进行交互和组合，从而实现复杂的功能。
在这一过程中，设计模式起到了非常重要的作用，可以有效地提高代码的可读性、可维护性和可扩展性。
本文将对23种常见的设计模式进行详解。
一、创建型模式1.简单工厂模式简单工厂模式属于创建型模式，其目的是提供一个工厂类，使得创建对象的过程更加简单。
在这种模式中，使用者只需要提供所需对象的参数，而无需关心对象的具体实现细节。
简单工厂模式适合于对象创建过程较为简单的情况。
2.工厂方法模式工厂方法模式是简单工厂模式的进一步扩展，其核心在于将工厂类进行接口抽象化，使得不同的工厂类可以创建不同的对象实例。
工厂方法模式适合于对象创建过程较为复杂的情况。
它可以为工厂类添加新的产品类型，而不会影响原有的代码。
3.抽象工厂模式抽象工厂模式是工厂方法模式的进一步扩展，其目的是提供一个可以创建一系列相关或者独立的对象的接口。
在抽象工厂模式中，使用者只需要关心所需对象组合的类型，而无需关注对象的具体实现过程。
4.建造者模式建造者模式也是一种创建型模式，其目的在于将复杂对象分解为多个简单的部分，并将其组装起来形成复杂对象实例。
在建造者模式中，使用者只需要关注所需对象以及它们的组合方式，而无需关心对象的具体实现过程。
5.原型模式原型模式是一种基于克隆的创建型模式，其核心在于通过复制现有的对象实例来创建新的对象。
在原型模式中，对象实例的创建过程与对象所包含的状态密切相关。
原型模式适合于创建复杂对象实例，且这些对象实例之间是相对独立的情况。
二、结构型模式6.适配器模式适配器模式是一种结构型模式，其目的在于将一个类的接口转换为另一个类所能使用的接口。
在适配器模式中，使用者可以通过不同的适配器实现对象之间的互相调用。
7.桥接模式桥接模式是一种结构型模式，其目的在于将抽象部分与实现部分相互分离，从而使得两者可以独立变化。
23种设计模式记忆口诀
23种设计模式记忆口诀
1.单例模式：唯一实例化，静态访问，线程不安全
2. 工厂方法模式：子类实现，工厂创建，扩展性强
3. 抽象工厂模式：创建一族产品，接口约束，扩展性强
4. 建造者模式：组合复杂对象，分步骤构建，灵活性高
5. 原型模式：克隆对象，避免重复创建，效率高
6. 适配器模式：兼容接口不同，类似转换器，易扩展
7. 桥接模式：抽象与实现分离，解耦合，易扩展
8. 装饰器模式：动态增强对象功能，不影响原有对象，易扩展
9. 组合模式：层次结构，统一访问，易扩展
10. 外观模式：简化复杂系统调用，易使用，易扩展
11. 享元模式：共享资源，避免重复创建，效率高
12. 代理模式：增强对象功能，控制对象访问，易扩展
13. 责任链模式：多个对象处理请求，自动传递，易扩展
14. 命令模式：将请求封装成对象，易扩展，易记录日志
15. 解释器模式：解释语言，易扩展，易维护
16. 迭代器模式：遍历集合，统一访问，易扩展
17. 中介者模式：分离对象间交互，降低耦合，易扩展
18. 观察者模式：对象状态改变，通知观察者，易扩展
19. 备忘录模式：保存对象状态，易恢复，易扩展
20. 状态模式：对象状态改变，自动改变行为，易扩展
21. 策略模式：选择不同策略，易切换，易扩展
22. 模板方法模式：定义操作流程，易扩展，易维护
23. 访问者模式：统一访问集合中对象，易扩展，易维护。
23种设计模式
23种设计模式（Design Patterns）设计模式（Design pattern）是一套被反复使用、多数人知晓的、经过分类编目的、代码设计经验的总结。
使用设计模式是为了可重用代码、让代码更容易被他人理解、保证代码可靠性。
项目中合理的运用设计模式可以完美的解决很多问题，每种模式在现在中都有相应的原理来与之对应，每一个模式描述了一个在我们周围不断重复发生的问题，以及该问题的核心解决方案，这也是它能被广泛应用的原因。
一、总体来说设计模式分为三大类：创建型模式，共五种：工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式。
结构型模式，共七种：适配器模式、装饰器模式、代理模式、外观模式、桥接模式、组合模式、享元模式。
行为型模式，共十一种：策略模式、模板方法模式、观察者模式、迭代子模式、责任链模式、命令模式、备忘录模式、状态模式、访问者模式、中介者模式、解释器模式。
还用两类模式：并发型模式和线程池模式。
二、设计模式六大原则:总原则：开闭原则开闭原则就是说对扩展开放，对修改关闭。
在程序需要进行拓展的时候，不能去修改原有的代码，而是要扩展原有代码，实现一个热插拔的效果。
所以一句话概括就是：为了使程序的扩展性好，易于维护和升级。
想要达到这样的效果，我们需要使用接口和抽象类等。
1、单一职责原则不要存在多于一个导致类变更的原因，也就是说每个类应该实现单一的职责，如若不然，就应该把类拆分。
2、里氏替换原则（Liskov Substitution Principle）里氏代换原则(Liskov Substitution Principle LSP)是面向对象设计的基本原则之一。
里氏代换原则中说，任何基类可以出现的地方，子类一定可以出现。
LSP是继承复用的基石，只有当衍生类可以替换掉基类，软件单位的功能不受到影响时，基类才能真正被复用，而衍生类也能够在基类的基础上增加新的行为。
里氏代换原则是对“开-闭”原则的补充。
Java中常用的设计模式23种JAVA设计模式项目实战教程java数据结构算法
Java中常⽤的设计模式23种JAVA设计模式项⽬实战教程java数据结构算法Java中常⽤的设计模式 23种JAVA设计模式项⽬实战教程java数据结构算法58套Java⾼级架构师视频教程，微服务，⾼并发，分布式，⾼可⽤，⾼性能，集群架构，设计模式，数据结构，中间件，并发编程，虚拟机，⾼可扩展，服务器，数据库，性能调优，负载均衡，安全架构，全⽂检索，权限管理Spring Boot，Spring Cloud⼤型分布式综合电商项⽬实战等视频教程JAVA⾼级架构师技术包含：JAVA架构设计，系统架构，缓存架构，分布式架构，安全架构，微服务，⾼并发，⾼可⽤，⾼可扩展，⾼性能，集群搭建，设计模式，数据结构，中间件，并发编程，JVM虚拟机，性能调优，负载均衡，单点登录，⽇志分析，全⽂检索，任务调度，权限管理，⼯作流，⽹络编程，脚本编程，分布式事务，分库分表，团队协作，持续集成，⾃动化部署，服务器，数据库，图形数据库，项⽬实战，SSM框架，SpringBoot，SpringCloud，Maven，Mybatis，Docker，K8S，Devops，Jenkins，Elasticsearch，Nginx，Tomcat，RabbitMQ，RocketMQ，ActiveMQ，Kafka，Dubbo，Solr，SSO，CAS，OA，Ehcache，Memcached，Activiti，Quartz，Shiro ，Git，Netty ，NIO，Linux，Shell，IDEA，Spring，Springmvc，SpringSecurity，SpringData，VueJS，RectJS，AngularJS，NodeJS，Hadoop，Hbase，Spark，HttpClient，Json，Nosql，Mysql，Redis，MongoDB，Zookeeper，Mycat，Oracle，健康项⽬实战，秒杀系统实战，电商项⽬实战，在线教育实战，P2P⾦融项⽬实战，⼤型分布式综合电商项⽬实战等视频教程......58套精品教程介绍：1、58套精品是掌柜最近整理出的最新教程，都是当下最⽕的技术，最⽕的课程，也是全⽹教程的精品；2、58套资源包含：全套完整⾼清视频、完整源码、配套⽂档；3、知识也是需要投资的，有投⼊才会有产出（保证投⼊产出⽐是⼏百上千倍），如果有⼼的朋友会发现，⾝边投资知识的⼤都是技术经理或者项⽬经理，⼯资⼀般相对于不投资的也要⾼出很多；总⽬录：58套JAVA⾼级架构师，微服务架构，亿级⾼并发，分布式架构，源码剖析系列，项⽬实战，设计模式实战，数据结构与算法，消息中间件，并发编程多线程，服务器系列，数据库，分布式事务，⼤型分布式综合电商项⽬实战视频教程第⼀套：01.【⾼并发课】亿级⾼并发⼤型电商详情页系统的⾼性能与⾼可⽤缓存架构实战视频教程第⼆套：02.【微服务课】微服务架构实战160讲.8⼤核⼼模块精讲.打通架构师进阶之路视频教程第三套：03.【项⽬实战】微服务电商系统从设计到实现全流程讲解基于SpringCloud视频教程第四套：04.【项⽬实战】微服务架构⼴告设计系统实战基于SpringCloud+Kafka+Mysql视频教程第五套：【项⽬实战】精讲SpringBoot2.0互联⽹⾦融理财项⽬实战，开发实战与原理分析视频教程（3套）第01套【主流框架】SpringBoot2.0全新系列精通到实战史上最全的完整版视频教程第02套【主流框架】Spring Boot实战与原理分析视频课程第03套【主流框架】SpringBoot2.0互联⽹⾦融理财系统综合项⽬实战视频课程第六套：06.【微服务课】精通SpringBoot Cloud微服务框架，实战案例与源码剖析视频教程（2套）第01套.Spring Cloud微服务最新技术⼊门到精通视频教程第02套.精通Spring Boot Cloud使⽤并理解框架的原理与底层运作机制视频教程第七套：07.【源码解析】深度剖析Spring Spring5 Mybatis Tomcat源码系列底层框架解析视频教程第⼋套：08.【项⽬实战】微服务容器化综合实践Docker+Kubernetes践⾏DevOps理念 k8s部署落地（3套）第01套：Docker+Kubernetes(k8s)微服务容器化及多技术综合实践视频教程第02套：深⼊系统学习Docker容器技术，实践DevOps理念视频教程第03套：Kubernetes（k8s）落地全程实践企业级应⽤实践从部署到核⼼应⽤视频教程第九套：09.【项⽬实战】从⽆到有搭建中⼩型互联⽹公司后台服务架构与运维架构视频课程第⼗套：10.【设计模式】精讲Java23种设计模式源码分析+内存分析+编程思想+Debug⽅式视频教程第⼗⼀套：11.【项⽬实战】设计模式综合项⽬（实战）设计模式综合应⽤的实战案例视频教程第⼗⼆套：12.【项⽬实战】软件系统功能设计（实战）训练（6个设计案例）视频教程第⼗三套：13.【数据结构】恋上数据结构与算法，程序员修炼编程内功（数组,栈,队列,链表,递归,排序,堆等）第⼗四套：14.【⾼级进阶】深度解析Spring5新特性，Java8~11新特性原理与实践,⾼级进阶实战视频教程第01套：Java8新特性原理，⾼级进阶实战视频教程第02套：Java9、10、11新特性全套精讲视频教程第03套：深⼊浅出spring原理与实践视频课程第04套：Spring5新特性及应⽤举例精讲剖析视频教程第⼗五套：15.【项⽬实战】快速上⼿SSO单点登录开发与项⽬实战单点登录在集群开发的作⽤视频教程（2套）第01套【单点登录】SSO单点登录快速上⼿与项⽬实战视频教程第02套【单点登录】SSO单点登录开发与实战，单点登录在集群开发的作⽤视频教程第⼗六套：16.【⾼级架构】Java架构之消息中间件Kafka RabbitMQ RocketMQ ActiveMq精通实战（4套）01.【中间件】ActiveMq中间件基础到精通⾼级实战视频课程02.【中间件】JAVA-ACE架构师系列课程 Rocketmq03.【中间件】RabbitMQ中间件基础到精通，消息订阅视频课程04.【中间件】Kafka分布式消息中间节原理剖析及实战演练视频课程第⼗七套：17.【项⽬实战】企业⽇志平台⽣产案例实战，⽇志分析之ELK stack实战视频教程第⼗⼋套：18.【⾼级进阶】顶尖⾼⼿系列Elasticsearch快速上⼿篇+⾼⼿进阶篇视频课程第⼗九套：19.【项⽬实战】基于Activiti6.X⼯作流进阶与项⽬实战，Activiti整合Drools视频课程第⼆⼗套：20.【任务调度】Spring+Quartz的分布式任务调度及源码解析视频课程第⼆⼗⼀套：21.【系统学习】Java架构之Shiro权限管理权限设计实现项⽬案例，与Springboot整合教程（3套）第01套.SpringBoot与Shiro整合-权限管理实战视频第02套.Shiro基础到精通，原理与架构视频课程第03套.Apache Shiro权限框架实战+项⽬案例+权限设计实现视频课程第⼆⼗⼆套：22.【系统学习】深⼊学习Zookeeper分布式系统开发实战视频课程第⼆⼗三套：23.【分布式】Dubbo第三⽅⽀付项⽬的系统架构实战视频教程第⼆⼗四套：24.【微服务】基于⽀付系统场景的微服务架构的分布式事务解决⽅案视频课程第⼆⼗五套：25.【项⽬实战】实战技能Linux100讲全⽅位实战讲解视频教程第⼆⼗六套：26.【linux精讲】Shell脚本编程⼤量企业级实例带你全⾯掌握六⼤技术点视频教程第⼆⼗七套：27.【⾼级进阶】⾼并发多线程实训营-Java多线程编程三个阶进阶实战视频教程第⼆⼗⼋套：28.【⾼级架构】架构之⾼并发系统架构实战⽅案 Java⾼并发解决⽅案与并发编程教程第⼆⼗九套：29.【⾼级进阶】深⼊Java并发编程原理与实战线程安全+锁原理+同步容器+实战讲解视频教程第三⼗套：30.【分布式】分布式事务框架Myth+Raincat+Tcc源码解析视频教程第三⼗⼀套：31.【分布式】分布式常见问题解决⽅案，分布式事务与锁，缓存实战解决⽅案视频教程第三⼗⼆套：32.【分布式】解决分布式事务数据⼀致性开发与实践分布式事务实现视频教程第三⼗三套：33.【分布式】分布式集群部署实战，分布式存储缓存协调调度视频教程第三⼗四套：34.【性能优化】深⼊JAVA虚拟机，JVM内核-原理，诊断与优化+内存模型+虚拟机原理视频教程第三⼗五套：35.【性能优化】架构⼤⽜带你学习MySql，Nginx，Tomcat，JVM性能调优系列专题视频教程第三⼗六套：36.【性能优化】深⼊JAVA程序性能调优视频(阿姆达尔定律、缓存组件、并⾏开发、线程池、JVM调优)第三⼗七套：37.【⾼级进阶】全⾯深⼊Mysql数据库系统优化+查询优化，Mysql⼤型分布式集群，从⼩⽩到⼤神（3套）第01套：全⾯深⼊Mysql数据库优化查询优化mysql⾼级第02套【数据库】MySQL⾼级⼤型分布式集群，主从复制，负载均衡，数据库中间件视频课程第03套：Mysql从⼩⽩到⼤神视频教程第三⼗⼋套：38.【⾼级进阶】深⼊进阶Oracle DBA性能优化+⾼可⽤+海量数据库设计视频课程（2套）第三⼗九套：39.【项⽬实战】企业级开发与运维Redis从⼊门到项⽬实战视频教程第四⼗套：40.【项⽬实战】精通MongoDB4.0从⼊门到实践，掌握NoSQL数据库企业主流解决⽅案视频教程第四⼗⼀套：41.【⾼级架构】Java架构之Mycat实现mysql⾼可⽤集群，分布库分表中间件视频教程第四⼗⼆套：42.【数据库】图形数据库之王 Neo4j从⼊门到精通视频教程第四⼗三套：43.【⾼级进阶】企业级Nginx核⼼知识，百万并发下的Nginx性能优化之道视频教程。
《Java设计模式课件：详解23种设计模式》
软件架构师
任何希望了解如何在软件架构中应用设计模式的架 构师都会从本课程中受益。
任何对设计模式感兴趣的人
如果您对设计模式有兴趣，并希望了解如何在实际 项目中应用它们，本课程将为您提供必要的指导。
设计模式的概述
1 什么是设计模式？
2 为什么使用设计模式？ 3 设计模式的类型
设计模式是解决软件设计问 题的可复用解决方案。
使用设计模式可以提高代码 的可读性、可维护性和可扩 展性。
创建性设计模式、结构性设 计模式和行为性设式
创建对象的工厂方法，使代码更具灵活性。
抽象工厂模式
2
提供一组相关或相互依赖的对象创建接口，
而无需指定具体类。
3
单例模式
确保一个类只有一个实例，并提供对该实例 的全局访问点。
展望
• 不断学习和探索新的设计模式。 • 应用设计模式来解决更复杂的软件设计问题。 • 分享和交流设计模式的实践经验。
定义对象间的一种一对多的 依赖关系，使得当每个对象 改变状态时，所有依赖于它 的对象都会得到通知。
定义一系列算法，将它们封 装起来，并使它们可以相互 替换，使得算法的变化不会 影响到使用算法的客户。
定义一个算法的骨架，而将 一些步骤延迟到子类中实现。
设计模式的实际应用
1
实现范例
2
通过实际的示例代码来演示设计模式的实际
结构性设计模式
组合模式
将对象组织成树状结构，以表示“整体-部分”的层次关 系。
桥接模式
将抽象部分和实现部分分离，以便它们可以独立地变 化。
适配器模式
将一个类的接口转换成客户希望的另一个接口，从而
代理模式
为其他对象提供一个代理，以控制对这个对象的访问。
23种设计模式记忆口诀
23种设计模式记忆口诀根据内容要求，对23种设计模式进行简要说明，并整理成口诀。
设计模式是软件开发中常用的一种解决方案，它提供了面向对象设计和编程中常见问题的解决思路和方法。
根据GoF（Gang of Four）的分类，设计模式可以分为创建型、结构型和行为型三种类型，共23种设计模式。
1. 创建型模式（Creational Patterns）：- 工厂方法模式（Factory Method Pattern）：定义一个用于创建对象的接口，但由子类决定实例化的类。
- 抽象工厂模式（Abstract Factory Pattern）：提供一个创建一系列相关对象或依赖对象的接口，而无须指定它们的具体类。
- 单例模式（Singleton Pattern）：确保一个类只有一个实例，并提供一个全局访问点。
- 原型模式（Prototype Pattern）：用于创建重复性对象的一个原型。
- 建造者模式（Builder Pattern）：将一个复杂对象的构建和表示分离，使得同样的构建过程可以创建不同的表示。
2. 结构型模式（Structural Patterns）：- 适配器模式（Adapter Pattern）：将一个类的接口转换成客户希望的另外一个接口，使得原本由于接口不兼容而不能一起工作的类可以一起工作。
- 桥接模式（Bridge Pattern）：将抽象部分和它真正的实现分离，使它们独立的变化。
- 装饰器模式（Decorator Pattern）：动态地将责任附加到对象上，扩展功能。
- 外观模式（Facade Pattern）：为子系统中的一组接口提供一个统一的接口，以简化系统的使用。
3. 行为型模式（Behavioral Patterns）：- 策略模式（Strategy Pattern）：定义一系列算法，将每个算法封装起来，并使它们可以相互替换。
- 模板方法模式（Template Method Pattern）：定义一个算法的骨架，由子类实现具体步骤。
二十三种设计模式
B. 结构模式 设计模式之 Adapter(适配器) 使用类再生的两个方式:组合(new)和继承(extends),这个已经在 thinking in java 中提到过. 设计模式之 Proxy(代理) 以 Jive 为例,剖析代理模式在用户级别授权机制上的应用 设计模式之 Facade(门面？) 可扩展的使用 JDBC 针对不同的数据库编程,Facade 提供了一种灵活的实现. 设计模式之 Composite(组合) 就是将类用树形结构组合成一个单位.你向别人介绍你是某单位，你是单位中的一个元素，别人和你做买卖，相当于 和单位做买卖。文章中还对 Jive 再进行了剖析。 设计模式之 Decorator(装饰器) Decorator 是个油漆工,给你的东东的外表刷上美丽的颜色. 设计模式之 Bridge(桥连) 将牛郎织女分开(本应在一起,分开他们,形成两个接口),在他们之间搭建一个桥(动态的结合) 设计模式之 Flyweight(共享元) 提供 Java 运行性能,降低小而大量重复的类的开销.
可以这么说：GoF 设计模式是程序员真正掌握面向对象核心思想的必修课。虽然你可能已经通过了 SUN 的很多令人炫目的 技术认证，但是如果你没有学习掌握 GoF 设计模式，只能说明你还是一个技工。
在浏览《Thingking in Java》(第一版)时，你是不是觉得好象这还是一本 Java 基础语言书籍？但又不纯粹是，因为这本书的作 者将面向对象的思想巧妙的融合在 Java 的具体技术上，潜移默化的让你感觉到了一种新的语言和新的思想方式的诞生。
C. 行为模式 设计模式之 Command(命令) 什么是将行为封装,Command 是最好的说明. 设计模式之 Observer(观察者) 介绍如何使用 Java API 提供的现成 Observer 设计模式之 Iterator(迭代器) 这个模式已经被整合入 Java 的 Collection.在大多数场合下无需自己制造一个 Iterator,只要将对象装入 Collection 中， 直接使用 Iterator 进行对象对书中这些蕴含的思想也许需要一种更明晰更系统更透彻的了解和掌握，那么你就需要研读 GoF 的《设 计模式》了。
23种设计模式的经典运用
23种设计模式的经典运用介绍设计模式是解决软件设计中常见问题的可重复使用的解决方案。
本文将介绍23种经典的设计模式，并给出它们在实际开发中的应用示例。
通过学习这些设计模式，您将增加对软件设计的理解，并能够更好地解决问题。
创建型设计模式1.工厂方法模式（F a c t o r y M e t h o d）工厂方法模式通过定义一个创建对象的接口，但由子类决定实例化具体类。
这种方法可以延迟实例化过程，具有更高的灵活性和可扩展性。
应用场景：-在一个系统中，希望客户端与具体类的实例化解耦。
-希望通过增加具体类的扩展来增加系统的灵活性。
2.抽象工厂模式（A b s t r a c t F a c t o r y）抽象工厂模式提供一个接口，用于创建相关或依赖对象组。
这种模式将对象的实例化推迟到子类中，从而实现了解耦。
应用场景：-当一个系统独立于其产品的创建、组合和表示时。
-当需要一个系列的相互依赖的对象而无需指定其具体类时。
3.单例模式（S i n gl e t o n）单例模式确保一个类只有一个实例，并提供一个全局访问点。
这种模式常用于控制对资源的访问，例如数据库连接或日志文件。
应用场景：-当需要一个类的唯一实例，并且该实例需要被多个客户端共享时。
-当需要限制系统中特定类的实例数量时。
4.原型模式（P r o to t y p e）原型模式通过复制现有对象来创建新对象。
这种模式对于创建需要消耗大量资源的对象非常有用，可以通过克隆现有对象来提高性能。
应用场景：-当一个系统的某些对象的创建比较昂贵时。
-当需要避免构造函数调用，而直接通过复制现有对象来创建新对象时。
5.建造者模式（B ui l d e r）建造者模式将一个复杂对象的构建过程与其表现分离，使得相同的构建过程可以创建不同的表现。
应用场景：-当想要构建一些复杂对象时，如生成器。
-当需要创建对象的过程具有多个步骤，并且每个步骤都可以按需选择或省略时。
结构型设计模式6.适配器模式（A da p t e r）适配器模式将一个类的接口转换为客户端所期望的另一个接口。
设计模式-23种设计模式整体介绍及应用场景、七大设计原则总结
设计模式-23种设计模式整体介绍及应⽤场景、七⼤设计原则总结对象的⼀、创建型模式：都是⽤来帮助我们创建对象的!（关注（关注对象的创建过程））创建过程模式1.单例单例模式保证⼀个类只有⼀个实例，并且提供⼀个访问该实例的全局访问点。
模式("Gof book"中把⼯⼚⽅法与抽象⼯⼚分为两种模式，所以创建型模式共为⼯⼚模式2.⼯⼚五种，这⾥只是为了⽅便整理，合在了⼯⼚模式中)-简单⼯⼚模式⽤来⽣产同⼀等级结构的任意产品。
（对于增加新的产品，需要修改已有代码）-⼯⼚⽅法模式⽤来⽣成同⼀等级结构中的固定产品。
（⽀持增加任意产品）-抽象⼯⼚模式⽤来⽣产不同产品族的全部产品。
（对于增加新的产品，⽆能为⼒，⽀持增加产品族）模式3.建造者建造者模式分离了对象⼦组件的单独构造（由Builder来负责）和装配（由Director负责），从⽽可以构造出复杂的对象。
模式原型模式4.原型通过new产⽣⼀个对象需要⾮常繁琐的数据准备或访问权限，则可以使⽤原型模式。
耦合，从⽽可以松耦合，从⽽可以扩⼤扩⼤结构上实现上实现松⼆、结构型模式：是从程序的、结构型模式：是从程序的结构对象和和类的组织）类的组织）（关注对象解决更⼤的问题。
（关注整体的类结构，⽤来整体的类结构，⽤来解决更⼤的问题。
模式1.适配器适配器模式⼯作中的场景：经常⽤来做旧系统改造和升级；如果我们的系统开发之后再也不需要维护，那么很多模式都是没必要的，但是不幸的是，事实却是维护⼀个系统的代价往往是开发⼀个系统的数倍。
学习中见过的场景：java.io.InputStreamReader(InputStream); java.io.OutpuStreamWriter(OutputStream)模式2.代理代理模式核⼼作⽤：通过代理，控制对对象的访问！可以详细控制访问某个（某类）对象的⽅法，在调⽤这个⽅法前做前置处理，调⽤这个⽅法后做后置处理。
（即：AOP的微观实现！）AOP（Aspect Oriented Programming⾯向切⾯编程）的核⼼实现机制！开发框架中应⽤场景：structs2中拦截器的实现；数据库连接池关闭处理；Hibernate中延时加载的实现；mybatis中实现拦截器插件；AspectJ的实现；spring中AOP的实现（⽇志拦截，声明式事务处理）；web service；RMI远程⽅法调⽤模式桥接模式3.桥接实际开发中应⽤场景：JDBC驱动程序；AWT中的Peer架构；银⾏⽇志管理：格式分类：操作⽇志、交易⽇志、异常⽇志距离分类：本地记录⽇志、异地记录⽇志⼈⼒资源系统中的奖⾦计算模块：奖⾦分类：个⼈奖⾦、团体奖⾦、激励奖⾦。
java23种设计模式及其应用场景
创建型模式•单例模式（Singleton）：确保一个类只有一个实例。
–应用场景：数据库连接池、日志记录、缓存系统。
•工厂方法模式（Factory Method）：定义一个创建对象的接口，但让子类决定实例化哪个类。
–应用场景：提供创建对象的灵活性，允许在不改变代码的情况下更换创建逻辑。
•抽象工厂模式（Abstract Factory）：提供一个创建一系列相关或依赖对象的接口，而无需指定具体的类。
–应用场景：创建复杂的对象结构，需要保持多个对象之间的一致性。
•建造者模式（Builder）：将一个复杂对象的构建与它的表示分离，使其能够一步一步创建。
–应用场景：创建复杂的对象，需要自定义不同的配置或属性。
•原型模式（Prototype）：通过复制一个现有的对象来创建新的对象。
–应用场景：创建大量相似对象时，避免重复创建的开销。
结构型模式•适配器模式（Adapter）：将一个类的接口转换成另一个类所期望的接口。
–应用场景：将不兼容的类或系统集成在一起。
•桥接模式（Bridge）：将抽象部分与实现部分解耦，使它们可以独立变化。
–应用场景：当需要在抽象层和实现层之间引入灵活性时。
•组合模式（Composite）：将对象组织成树形结构，以便以类似的方式处理单个对象和组合对象。
–应用场景：表示部分与整体之间的层次关系。
•装饰器模式（Decorator）：在不改变对象自身的情况下，向对象添加新的功能。
–应用场景：向对象添加可选项功能，避免创建新的子类。
•外观模式（Facade）：提供一个统一的界面来访问一个子系统，隐藏其内部复杂性。
–应用场景：简化对复杂系统的访问，降低客户端与子系统之间的耦合。
•享元模式（Flyweight）：使用共享的对象来减少内存开销和对象数量。
–应用场景：需要创建大量相同或相似对象时。
•代理模式（Proxy）：为另一个对象提供一个代理或替身，以便控制对该对象的访问。
–应用场景：为对象添加额外的功能，如访问控制、缓存、日志记录。
盘点GoF的23种设计模式
盘点GoF的23种设计模式前⾔设计模式最初并⾮出于软件设计中，⽽是⽤于建筑领域的设计中。
1995年，四位作者将建筑设计的基本模式融合到软件开发中，合作出版了《设计模式：可复⽤的⾯向对象软件的基础》，⼀共收录了23个设计模式，这是设计模式领域⾥程碑的事件，导致了软件设计模式的突破。
所以这四位作者在软件开发领域耦以四⼈帮（Gang Of Four）匿名著称，简称GoF。
⼀、设计模式的分类设计模式按照⽬的来划分的话可以划分为三种类型，分别为创建型模式、结构型模式和⾏为型模式1.1、创建型模式⽤于描述“怎样创建对象”，主要特点是将对象的创建和使⽤进⾏分离。
对象使⽤者不需要关⼼对象的创建细节，可以降低创建对象和使⽤对象之间的耦合度。
主要有单例模式、原型模式、⼯⼚⽅法模式、抽象⼯⼚模式和建造者模式等五种设计模式1.2、结构型模式⽤于描述如何将类或对象按某种布局组成更⼤的结构主要有代理模式、适配器模式、桥接模式、装饰器模式、外观模式、享元模式和组合模式等七种设计模式1.3、⾏为型模式⽤于描述类或对象之间怎样协作共同完成单个对象都⽆法单独完成的任务以及如何分配各个对象的职责分配主要有模版⽅法模式、策略模式、命令模式、责任链模式、状态模式、观察者模式、中介者模式、迭代器模式、访问者模式、备忘录模式和解释器模式等⼗⼀中设计模式⼆、创建型设计模式2.1、单例模式（Singleton）定义：某个类只能⽣成⼀个实例，该类需要提供⼀个全局访问点供外部获取该类的全局唯⼀实例单例模式的类需要满⾜以下三个要求：1.单例类只有⼀个实例对象2.单例对象必须由单例类⾃⾏创建3.单例类需要对外提供⼀个获取单例对象的全局访问点优缺点：1、保证内存中仅有⼀个实例，减少内存开销2、不易扩展，需求发⽣改变需要修改单例类，会违背开闭原则应⽤场景：1、需要频繁创建和销毁某个类的实例时;2、某个类的实例具有唯⼀性时3、类的创建实例的过程⾮常消耗资源时4、对象需要被全局共享时可参考⽂章：2.2、原型模式（Prototype）定义：将⼀个对象作为原型，通过对其复制从⽽克隆出多个和原型类似的新的实例优缺点：1、采⽤clone的⽅式⽐new⼀个对象性能更好，因为是直接基于内存⼆进制流的复制2、深克隆时需要每⼀层的对象都需要实现cloneable接⼝原型模式在Java中的实现依赖于cloneable接⼝，原型实现cloneable接⼝，需要根据原型创建新对象时，直接调⽤原型对象的clone⽅法进⾏复制即可应⽤场景：1、对象之间相同或相似时，⽆需通过new创建2、创建对象成本⼤，⽐如⽐较消耗CPU或⽹络资源等3、系统中⼤量使⽤该类对象，且各个调⽤者都需要给它的属性重写赋值时，⽐如状态等属性案例如下：业务场景⽃地主游戏有3⼈⽃地主和4⼈⽃地主，每种模式还分为新⼿房和⾼⼿房，此时可以抽象出游戏房间的类，并初始化各种类型的房间原型，每当有玩家进⼊对应模式的房间时就通过原型直接复制出⼀个房间即可。
23种设置模式
OO中对于23种设计模式的整理设计模式的分类1.抽象工厂Abstract FACTORY厂模式：客户类和工厂类分开，把各种需要使用到的实例的创建方法统一单独写成抽象类，实现类具体实现创建过程，创建出来的对象类型用接口来表示，抽象工厂可以用在高层类中使用，不用考虑太多具体的创建细节，如何创建由工厂的具体实现去定义。
核心工厂类不再负责所有产品的创建，而是将具体创建的工作交给子类去做，成为一个抽象工厂角色，仅负责给出具体工厂类必须实现的接口，而不接触哪一个产品类应当被实例化这种细节。
2.BUILDER建造模式：将产品的内部表象和产品的生成过程分割开来，从而使一个建造过程生成具有不同的内部表象的产品对象。
建造模式使得产品内部表象可以独立的变化，客户不必知道产品内部组成的细节。
建造模式可以强制实行一种分步骤进行的建造过程。
3.FACTORY METHOD工厂方法模式：用一个方法来创建所需要的所有实例，跟抽象工厂的区别，就是不需要单独写个工厂类，相当于把抽象工厂类里面定义的抽象方法，合并到应用类里面，子类去实现就好了，比抽象工厂更简洁。
4. PROTOTYPE原始模型模式：通过给出一个原型对象来指明所要创建的对象的类型，然后用复制这个原型对象的方法创建出更多同类型的对象。
原始模型模式允许动态的增加或减少产品类，产品类不需要非得有任何事先确定的等级结构，原始模型模式适用于任何的等级结构。
缺点是每一个类都必须配备一个克隆方法。
5.SINGLETON单例模式：单例模式确保某一个类只有一个实例，而且自行实例化并向整个系统提供这个实例单例模式。
单例模式只应在有真正的“单一实例”的需求时才可使用。
6.ADAPTER适配器（变压器）模式：把一个类的接口变换成客户端所期待的另一种接口，从而使原本因接口原因不匹配而无法一起工作的两个类能够一起工作。
适配类可以根据参数返还一个合适的实例给客户端。
7.BRIDGE桥梁模式：将抽象化与实现化脱耦，使得二者可以独立的变化，也就是说将他们之间的强关联变成弱关联，也就是指在一个软件系统的抽象化和实现化之间使用组合/聚合关系而不是继承关系，从而使两者可以独立的变化。
GangOfFour的23中设计模式
GangOfFour的23中设计模式Gang Of Four的23中设计模式标签（空格分隔）： 设计模式1. 根据⽬的来进⾏划分根据⽬的进⾏划分可以分为创建型模式, 结构型模式和⾏为模式三种.1.1 创建型模式怎样创建对象, 主要特点是将对象的创建和使⽤分离, GoF中提供了单例, 原型, ⼯⼚⽅法, 抽象⼯⼚, 建造者等5中创建型模式.1.2 结构性模式⽤于描述如何将类或者对象按照某种布局组成更⼤的结构, GoF提供了代理, 适配器, 桥接, 外观, 享元, 组合等6中结构性模式.1.3 ⾏为模式⽤于描述类或对象之间如何通过写作共同完成单个对象⽆法完成的任务, 以及怎样分配职责. GoF中提供了模板⽅法, 策略, 命令, 职责链, 状态, 观察者, 中介者, 迭代者, 访问者, 备忘录, 解释器.GoF的23中设计模式的功能(只列出常见的).单例(Singleton)模式: 某个类只能⽣成⼀个实例, 该类提供了⼀个全局访问点供外部获取该实例拓展是有限多例模式.原型(Prototype)模式: 将⼀个对象作为原型, 通过对其进⾏复制⽽克隆出多个和原型类似的新实例.⼯⼚(Factory)⽅法: 定义⼀个⽤于创建产品的接⼝, 由⼦类决定⽣产什么产品.抽象⼯⼚(AbstractFactory)模式: 提供⼀个创建产品族的接⼝, 其每个⼦类可以⽣产⼀系列相关的产品.代理(Proxy)模式: 为某对象提供⼀种代理以控制对该对象的访问, 即客户端通过代理间接的访问该对象, 从⽽限制, 增强或者修改该对象的⼀些特性.适配器(Adapter)模式: 将⼀个类的接⼝转换成客户希望的另⼀个接⼝, 使得原本由于接⼝不兼容⽽不能⼀起⼯作的哪些类⼀起⼯作.桥接(Bridge)模式: 将抽象和实现分离, 它他们可以独⽴变化, 他们使⽤组合关系替代竭诚关系来实现, 从⽽降低了抽象和实现这两个可变维度的耦合度.装饰(Decorator)模式: 动态的给对象增加⼀些功能.享元(Flyweight)模式: 运⾏共享技术来有效的⽀持⼤量细粒度对象的复⽤.策略(Strategy)模式: 定义了⼀些列的算法, 并且将每个算法封装起来, 使他们可以相互替换, 且算法的改变不会影响使⽤算法的客户.模板⽅法（TemplateMethod）模式：定义⼀个操作中的算法⾻架，⽽将算法的⼀些步骤延迟到⼦类中，使得⼦类可以不改变该算法结构的情况下重定义该算法的某些特定步骤。
23种编程设计模式
23种编程设计模式编程设计模式是在软件开发过程中经过实践验证的解决问题的方案，它们是解决常见问题的模板。
在设计模式的指导下，开发人员可以更加高效地开发出可维护、可扩展的软件。
本文将介绍23种常见的编程设计模式。
1.创建型模式：-工厂方法模式：当需要创建复杂对象时，通过工厂方法来解决对象的创建问题，将具体对象的创建延迟到子类中。
-抽象工厂模式：提供一个接口，用于创建一系列相关或相互依赖的对象，而不需要指定具体类。
-单例模式：确保类只有一个实例，并提供一个全局访问点。
-原型模式：通过复制现有对象的方式，创建新的对象。
2.结构型模式：-适配器模式：将一个类的接口转换成客户期望的另一个接口，使得原本因接口不兼容而无法工作的类可以一起工作。
-桥接模式：将抽象部分与它们的实现部分分离，以便二者可以独立地变化。
-组合模式：将对象组合成树形结构以表示“整体-部分”层次结构。
-装饰器模式：动态地给对象添加一些额外的职责，而不需要修改其原始类的代码。
-外观模式：提供一个统一的接口，用于访问子系统中一群接口的功能。
-享元模式：通过共享对象来减少内存使用量。
-代理模式：为其他对象提供一个代理，以控制对这个对象的访问。
3.行为型模式：-责任链模式：将请求的发送者和接收者解耦。
-命令模式：将请求封装成一个对象，从而允许参数化对客户端不同的请求、排队或记录请求日志，以及支持可撤消的操作。
-解释器模式：定义一个语言的文法，并且建立一个解释器来解释该语言中的句子。
-迭代器模式：提供一种顺序访问聚合对象中各个元素的方法，而又不暴露聚合对象的内部表示。
-中介者模式：用一个中介对象来封装一系列的对象交互。
-备忘录模式：在不违背封装原则的前提下，保存对象内部状态的快照，以便在将来需要时恢复到该状态。
-观察者模式：定义对象间的一种一对多的依赖关系，以便当一个对象的状态发生变化时，所有依赖它的对象都得到通知。
-状态模式：允许对象在其内部状态改变时改变它的行为。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
GOF以及java的23种设计模式简介GoF:（Gang of Four，GOF设计模式）---四人组Design Patterns:Elements of Reusable Object-Oriented Software（即后述《设计模式》一书），由Erich Gamma、Richard Helm、Ralph Johnson 和John Vlissides合著（Addison-Wesley，1995）。
这几位作者常被称为"四人组（Gang of Four）"，而这本书也就被称为"四人组（或GoF）"书。
Design Patterns:Elements of Reusable Object-Oriented Software（即后述《设计模式》一书），由Erich Gamma、Richard Helm、Ralph Johnson 和John Vlissides合著（Addison-Wesley，1995）。
这几位作者常被称为“四人组（Gang of Four）”，而这本书也就被称为“四人组（或GoF）”书。
在《设计模式》这本书的最大部分是一个目录，该目录列举并描述了23种设计模式。
另外，近来这一清单又增加了一些类别，最重要的是使涵盖范围扩展到更具体的问题类型。
例如，Mark Grand在Patterns in Java:A Catalog of Reusable Design Patterns Illustrated with UML（即后述《模式Java版》一书）中增加了解决涉及诸如并发等问题的模式，而由Deepak Alur、John Crupi和Dan Malks合著的Core J2EE Patterns:Best Practices and Design Strategies一书中主要关注使用Java2企业技术的多层应用程序上的模式。
对软件设计模式的研究造就了一本可能是面向对象设计方面最有影响的书籍：《设计模式》。
GOF的设计模式是一座"桥"就Java语言体系来说，GOF的设计模式是Java基础知识和J2EE 框架知识之间一座隐性的"桥"。
会Java的人越来越多，但是一直徘徊在语言层次的程序员不在少数，真正掌握Java中接口或抽象类的应用不是很多，大家经常以那些技术只适合大型项目为由，避开或忽略它们，实际中，Java的接口或抽象类是真正体现Java思想的核心所在，这些你都将在GoF的设计模式里领略到它们变幻无穷的魔力。
GoF的设计模式表面上好像也是一种具体的"技术"，而且新的设计模式不断在出现，设计模式自有其自己的发展轨道，而这些好像和等技术也无关！实际上，GoF的设计模式并不是一种具体"技术",它讲述的是思想，它不仅仅展示了接口或抽象类在实际案例中的灵活应用和智慧，让你能够真正掌握接口或抽象类的应用，从而在原来的Java语言基础上跃进一步，更重要的是，GoF的设计模式反复向你强调一个宗旨：要让你的程序尽可能的可重用。
这其实在向一个极限挑战：软件需求变幻无穷，计划没有变化快，但是我们还是要寻找出不变的东西，并将它和变化的东西分离开来，这需要非常的智慧和经验。
而GoF的设计模式是在这方面开始探索的一块里程碑。
J2EE等属于一种框架软件，什么是框架软件？它不同于我们以前接触的Java API等，那些属于Toolkist(工具箱)，它不再被动的被使用，被调用，而是深刻的介入到一个领域中去，J2EE等框架软件设计的目的是将一个领域中不变的东西先定义好，比如整体结构和一些主要职责(如数据库操作事务跟踪安全等)，剩余的就是变化的东西，针对这个领域中具体应用产生的具体不同的变化需求，而这些变化东西就是J2EE程序员所要做的。
由此可见，设计模式和J2EE在思想和动机上是一脉相承，只不过1.设计模式更抽象，J2EE是具体的产品代码，我们可以接触到，而设计模式在对每个应用时才会产生具体代码。
2.设计模式是比J2EE等框架软件更小的体系结构，J2EE中许多具体程序都是应用设计模式来完成的，当你深入到J2EE的内部代码研究时，这点尤其明显，因此，如果你不具备设计模式的基础知识(GoF 的设计模式)，你很难快速的理解J2EE。
不能理解J2EE,如何能灵活应用？3.J2EE只是适合企业计算应用的框架软件，但是GoF的设计模式几乎可以用于任何应用！因此GoF的设计模式应该是J2EE的重要理论基础之一。
所以说，GoF的设计模式是Java基础知识和J2EE框架知识之间一座隐性的"桥"。
为什么说隐性的？GOF设计模式是一座隐性的"桥"因为很多人没有注意到这点，学完Java基础语言就直接去学J2EE,有的甚至鸭子赶架，直接使用起Weblogic等具体J2EE软件，一段时间下来，发现不过如此，挺简单好用，但是你真正理解J2EE了吗？你在具体案例中的应用是否也是在延伸J2EE的思想？如果你不能很好的延伸J2EE的思想，那你岂非是大炮轰蚊子，认识到J2EE不是适合所有场合的人至少是明智的，但我们更需要将J2EE用对地方，那么只有理解J2EE此类框架软件的精髓，那么你才能真正灵活应用Java解决你的问题，甚至构架出你自己企业的框架来。
(我们不能总是使用别人设定好的框架，为什么不能有我们自己的框架？)因此，首先你必须掌握GoF的设计模式。
虽然它是隐性，但不是可以越过的。
关于23种设计模式的有趣见解作者以轻松的语言比喻了java的23种模式，有很好的启发作用。
创建型模式1、FACTORY—追MM少不了请吃饭了，麦当劳的鸡翅和肯德基的鸡翅都是MM爱吃的东西，虽然口味有所不同，但不管你带MM 去麦当劳或肯德基，只管向服务员说“来四个鸡翅”就行了。
麦当劳和肯德基就是生产鸡翅的Factory工厂模式：客户类和工厂类分开。
消费者任何时候需要某种产品，只需向工厂请求即可。
消费者无须修改就可以接纳新产品。
缺点是当产品修改时，工厂类也要做相应的修改。
如：如何创建及如何向客户端提供。
2、BUILDER—MM最爱听的就是“我爱你”这句话了，见到不同地方的MM,要能够用她们的方言跟她说这句话哦，我有一个多种语言翻译机，上面每种语言都有一个按键，见到MM我只要按对应的键，它就能够用相应的语言说出“我爱你”这句话了，国外的MM也可以轻松搞掂，这就是我的“我爱你”builder。
（这一定比美军在伊拉克用的翻译机好卖）建造模式：将产品的内部表象和产品的生成过程分割开来，从而使一个建造过程生成具有不同的内部表象的产品对象。
建造模式使得产品内部表象可以独立的变化，客户不必知道产品内部组成的细节。
建造模式可以强制实行一种分步骤进行的建造过程。
3、FACTORY METHOD—请MM去麦当劳吃汉堡，不同的MM 有不同的口味，要每个都记住是一件烦人的事情，我一般采用Factory Method模式，带着MM到服务员那儿，说“要一个汉堡”，具体要什么样的汉堡呢，让MM直接跟服务员说就行了。
工厂方法模式：核心工厂类不再负责所有产品的创建，而是将具体创建的工作交给子类去做，成为一个抽象工厂角色，仅负责给出具体工厂类必须实现的接口，而不接触哪一个产品类应当被实例化这种细节。
4、PROTOTYPE—跟MM用QQ聊天，一定要说些深情的话语了，我搜集了好多肉麻的情话，需要时只要copy出来放到QQ里面就行了，这就是我的情话prototype了。
（100块钱一份，你要不要）原始模型模式：通过给出一个原型对象来指明所要创建的对象的类型，然后用复制这个原型对象的方法创建出更多同类型的对象。
原始模型模式允许动态的增加或减少产品类，产品类不需要非得有任何事先确定的等级结构，原始模型模式适用于任何的等级结构。
缺点是每一个类都必须配备一个克隆方法。
5、SINGLETON—俺有6个漂亮的老婆，她们的老公都是我，我就是我们家里的老公Sigleton，她们只要说道“老公”，都是指的同一个人，那就是我(刚才做了个梦啦，哪有这么好的事)单例模式：单例模式确保某一个类只有一个实例，而且自行实例化并向整个系统提供这个实例单例模式。
单例模式只应在有真正的“单一实例”的需求时才可使用。
结构型模式6、ADAPTER—在朋友聚会上碰到了一个美女Sarah，从香港来的，可我不会说粤语，她不会说普通话，只好求助于我的朋友kent了，他作为我和Sarah之间的Adapter，让我和Sarah可以相互交谈了(也不知道他会不会耍我)适配器（变压器）模式：把一个类的接口变换成客户端所期待的另一种接口，从而使原本因接口原因不匹配而无法一起工作的两个类能够一起工作。
适配类可以根据参数返还一个合适的实例给客户端。
7、BRIDGE—早上碰到MM，要说早上好，晚上碰到MM，要说晚上好；碰到MM穿了件新衣服，要说你的衣服好漂亮哦，碰到MM新做的发型，要说你的头发好漂亮哦。
不要问我“早上碰到MM 新做了个发型怎么说”这种问题，自己用BRIDGE组合一下不就行了桥梁模式：将抽象化与实现化脱耦，使得二者可以独立的变化，也就是说将他们之间的强关联变成弱关联，也就是指在一个软件系统的抽象化和实现化之间使用组合/聚合关系而不是继承关系，从而使两者可以独立的变化。
8、COMPOSITE—Mary今天过生日。
“我过生日，你要送我一件礼物。
”“嗯，好吧，去商店，你自己挑。
”“这件T恤挺漂亮，买，这条裙子好看，买，这个包也不错，买。
”“喂，买了三件了呀，我只答应送一件礼物的哦。
”“什么呀，T恤加裙子加包包，正好配成一套呀，小姐，麻烦你包起来。
”“……”，MM都会用Composite模式了，你会了没有？合成模式：合成模式将对象组织到树结构中，可以用来描述整体与部分的关系。
合成模式就是一个处理对象的树结构的模式。
合成模式把部分与整体的关系用树结构表示出来。
合成模式使得客户端把一个个单独的成分对象和由他们复合而成的合成对象同等看待。
9、DECORATOR—Mary过完轮到Sarly过生日，还是不要叫她自己挑了，不然这个月伙食费肯定玩完，拿出我去年在华山顶上照的照片，在背面写上“最好的的礼物，就是爱你的Fita”，再到街上礼品店买了个像框（卖礼品的MM也很漂亮哦），再找隔壁搞美术设计的Mike设计了一个漂亮的盒子装起来……，我们都是Decorator，最终都在修饰我这个人呀，怎么样，看懂了吗？装饰模式：装饰模式以对客户端透明的方式扩展对象的功能，是继承关系的一个替代方案，提供比继承更多的灵活性。
动态给一个对象增加功能，这些功能可以再动态的撤消。
增加由一些基本功能的排列组合而产生的非常大量的功能。