Java23种设计模式6大原则总结
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种设计模式记忆 口诀
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种设计模式，并且可以在以后的工作中灵活地运用它们。
Java23种设计模式6大原则总结
Java23种设计模式6大原则总结设计模式概念：一套被反复使用、多数人知晓、经过分类编目的优秀代码设计经验的总结。
设计模式要素：模式名称、问题、举例、末态环境、推理、其他有关模式、已知的应用。
设计模式分类：创建型、结构型、行为型。
创建型模式功能：1.统所使用的具体类的信息封装起来；2.类的实例是如何被创建和组织的。
创建型模式作用：1.封装创建逻辑，不仅仅是new一个对象那么简单。
2.封装创建逻辑变化，客户代码尽量不修改，或尽量少修改。
常见的创建型模式：单例模式、工厂方法模式、抽象工厂模式、建造者模式、原型模式。
常见的结构型模式：代理模式、装饰模式、适配器模式、组合模式、桥梁模式、外观模式、享元模式。
常见行为型模式：模板方法模式、命令模式、责任链模式、策略模式、迭代器模式、中介者模式、观察者模式、备忘录模式、访问者模式、状态模式、解释器模式。
单一职责原则：一个类应该只有一个职责。
优点：降低类的复杂性；提高类的可读性；提高代码的可维护性和复用性；降低因变更引起的风险。
里氏替换原则：优点：代码共享，减少创建类的工作量，每个子类都拥有父类的方法和属性；提高代码的可重用性；提高代码的可扩展性；提高产品或项目的开放性。
缺点：1.继承是入侵式的。
只要继承，就必须拥有父类所有属性和方法。
2.降低代码的灵活性。
子类必须拥有父类的属性和方法，使子类收到限制。
3.增强了耦合性。
当父类的常量、变量和方法修改时，必须考虑子类的修改，这种修改可能造成大片的代码需要重构。
依赖倒置原则：高层模块不应该依赖低层模块，两者都依赖其抽象；抽象不依赖细节；细节应该依赖于抽象。
在Java中的表现：模块间的依赖通过抽象发生，实现类之间不发生直接的依赖关系，其依赖关系是通过接口或抽象类产生的；接口或抽象类不依赖于是实现类；实现类依赖于接口或抽象类。
接口隔离原则：1.一个类对另外一个类的依赖性应当是建立在最小的接口上的2.一个接口代表一个角色，不应当将不同的角色交给一个接口。
设计模式六大规则
设计模式六⼤规则1.单⼀职责原则（六⼤规则中的⼩萝莉，⼈见⼈爱）：描述的意思是每个类都只负责单⼀的功能，切不可太多，并且⼀个类应当尽量的把⼀个功能做到极致。
2.⾥⽒替换原则（六⼤原则中最⽂静的姑娘，但却不太招⼈喜欢）：这个原则表达的意思是⼀个⼦类应该可以替换掉⽗类并且可以正常⼯作。
3. 接⼝隔离原则（六⼤原则当中最挑三拣四的挑剔⼥，胸部极⼩）：也称接⼝最⼩化原则，强调的是⼀个接⼝拥有的⾏为应该尽可能的⼩。
4.依赖倒置原则（六⼤原则中最⼩鸟依⼈的姑娘，对抽象的东西⾮常依赖）：这个原则描述的是⾼层模块不该依赖于低层模块，⼆者都应该依赖于抽象，抽象不应该依赖于细节，细节应该依赖于抽象。
5.迪⽶特原则（六⼤原则中最害羞的姑娘，不太爱和陌⽣⼈说话）：也称最⼩知道原则，即⼀个类应该尽量不要知道其他类太多的东西，不要和陌⽣的类有太多接触。
6.开-闭原则（六⼤原则中绝对的⼤姐⼤，另外五姐妹⼼⽢情愿⾂服）：最后⼀个原则，⼀句话，对修改关闭，对扩展开放。
《简介》说到设计模式，当初第⼀次听到时，第⼀反应就是很深奥，完全理解不了这个概念到底是什么意思，下⾯我先从⽹上摘录⼀份定义。
设计模式（Designpattern）是⼀套被反复使⽤、多数⼈知晓的、经过分类编⽬的、代码设计经验的总结。
上⾯是百度当中的解释，来解释⼀下这句简单的话的含义，⼏个关键词。
反复使⽤：这个不⽤过多解释，设计模式被使⽤太多了，上个系列spring源码当中就出现了很多模式，记忆中⽐较深刻的有模板模式，代理模式，单例模式，⼯⼚模式等等。
多数⼈知晓：这个就不需要过多解释了。
分类编⽬：就是说可以找到⼀些特征去划分这些设计模式，从⽽进⾏分类。
代码设计经验：这句很重要，设计经验的总结，也就是说设计模式，是为了指导设计⽽从经验中总结出来的套路。
还有⼀种说法是说，设计模式是可以解决特定场景的问题的⼀系列⽅法，其实我觉得这个解释更贴切⼀点。
《为何学习设计模式》上⾯简单的介绍，是让各位⾸先搞清楚设计模式是什么，下⾯我们来说说为什么要学习设计模式，学习总要有个驱动⼒。
面向对象设计的23个设计模式详解
面向对象设计的23个设计模式详解面向对象设计是一种广泛应用于软件开发的思想，其核心在于将数据和操作封装在一起形成对象，并通过各种方式进行交互和组合，从而实现复杂的功能。
在这一过程中，设计模式起到了非常重要的作用，可以有效地提高代码的可读性、可维护性和可扩展性。
本文将对23种常见的设计模式进行详解。
一、创建型模式1.简单工厂模式简单工厂模式属于创建型模式，其目的是提供一个工厂类，使得创建对象的过程更加简单。
在这种模式中，使用者只需要提供所需对象的参数，而无需关心对象的具体实现细节。
简单工厂模式适合于对象创建过程较为简单的情况。
2.工厂方法模式工厂方法模式是简单工厂模式的进一步扩展，其核心在于将工厂类进行接口抽象化，使得不同的工厂类可以创建不同的对象实例。
工厂方法模式适合于对象创建过程较为复杂的情况。
它可以为工厂类添加新的产品类型，而不会影响原有的代码。
3.抽象工厂模式抽象工厂模式是工厂方法模式的进一步扩展，其目的是提供一个可以创建一系列相关或者独立的对象的接口。
在抽象工厂模式中，使用者只需要关心所需对象组合的类型，而无需关注对象的具体实现过程。
4.建造者模式建造者模式也是一种创建型模式，其目的在于将复杂对象分解为多个简单的部分，并将其组装起来形成复杂对象实例。
在建造者模式中，使用者只需要关注所需对象以及它们的组合方式，而无需关心对象的具体实现过程。
5.原型模式原型模式是一种基于克隆的创建型模式，其核心在于通过复制现有的对象实例来创建新的对象。
在原型模式中，对象实例的创建过程与对象所包含的状态密切相关。
原型模式适合于创建复杂对象实例，且这些对象实例之间是相对独立的情况。
二、结构型模式6.适配器模式适配器模式是一种结构型模式，其目的在于将一个类的接口转换为另一个类所能使用的接口。
在适配器模式中，使用者可以通过不同的适配器实现对象之间的互相调用。
7.桥接模式桥接模式是一种结构型模式，其目的在于将抽象部分与实现部分相互分离，从而使得两者可以独立变化。
Java开发中的23种设计模式
Java开发中的23种设计模式通常，一个设计模式描述了一个被证实可行的方案。
这些方案非常普遍，是具有完整定义的最常用的模式。
一般模式有4个基本要素：模式名称(pattern name)、问题(problem)、解决方案(solution)、效果(consequences)。
常见的Java设计模式有以下23种：1、抽象工厂模式(Abstract Factory)：提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。
2、适配器模式(Adapter)：将一个类的接口转换成客户希望的另外一个接口。
适配器模式使得原本由于接口不兼容而不能一起工作的类可以一起工作。
3、桥梁模式(Bridge)：将抽象部分与它的实现部分分离，使它们都可以独立地变化。
4、建造模式(Builder)：将一个复杂对象的构建与它的表示分离，使同样的构建过程可以创建不同的表示。
5、责任链模式(Chain of Responsibility)：为解除请求的发送者和接收者之间耦合，而使多个对象都有机会处理这个请求。
将这些对象连成一条链，并沿着这条链传递该请求，直到有一个对象处理它。
6、命令模式(Command)：将一个请求封装为一个对象，从而可用不同的请求对客户进行参数化;对请求排队或记录请求日志，以及支持可取消的操作。
7、合成模式(Composite)：将对象组合成树形结构以表示“部分-整体”的层次结构。
它使得客户对单个对象和复合对象的使用具有一致性。
8、装饰模式(Decorator)：动态地给一个对象添加一些额外的职责。
就扩展功能而言，它能生成子类的方式更为灵活。
9、门面模式(Facade)：为子系统中的一组接口提供一个一致的界面，门面模式定义了一个高层接口，这个接口使得这一子系统更加容易使用。
10、工厂方法(Factory Method)：定义一个用于创建对象的接口，让子类决定将哪一个类实例化。
Factory Method 使一个类的实例化延迟到其子类。
JAVA设计模式总结之六大设计原则
JAVA设计模式总结之六⼤设计原则从今年的七⽉份开始学习设计模式到9⽉底，设计模式全部学完了，在学习期间，总共过了两篇；第⼀篇看完设计模式后，感觉只是脑⼦⾥⾯有印象但⽆法⾔语。
于是决定在看⼀篇，到9⽉份第⼆篇设计模式总于看完了，这⼀篇看完，脑⼦⾥⾯已经能够对绝⼤多数的设计模式能够说出其核⼼思想且可以画出类图也知道应⽤场景，算是⼀个进步，但可能还不能够特别熟练的使⽤，可能需要多多巩固和强化使⽤才能够完全理解设计模式的精髓所在。
学习期间收获还是不少的：1、从只听过设计模式到学习了所有的设计模式，并写了不少设计模式的博客，在公司期间也总结了，只会限于公司资料保密政策⽆法带出，对这个我只能呵呵，博客园也写了部分博客，有兴趣的可以查看随笔分类设计模式系列。
2、看源码和别⼈写的代码的时候，开始能够知道⽤的是什么模式，⽐如项⽬中典型的解释器模式，外观模式，策略模式等等，现在写代码也会考虑系统的可扩展性，以及如何来更好的设计，从⽽是代码更加优化和漂亮。
3、遇到问题也会想是否可以采⽤设计模式来解决问题，对⾯向对象也进⼀步的理解了。
下⾯来总结下⾃⼰所学习的设计模式，⾸先我们看下各个模式之间的关系图，下⾯这张图是⽹上⽐较典型的⼀个类图关系：从上⾯的类图之间可以看出，学习设计模式或者说学懂完全理解所有的设计模式还是挺难的，只能说不断的重复学习，不断的去领悟才是唯⼀的⽅法，当然不排除有些⼈是天才看⼀篇就学会了，可惜鄙⼈不是，所以必须不断重复学习来加深⾃⼰的理解。
个⼈感觉，单例、⼯⼚、装饰者、观察者、代理模式使⽤的频率⽐较⾼；当然不是说其他模糊就不使⽤，只是个⼈的看法⽽已，o(*￣︶￣*)o。
学习设计模式，⾸先要学习的就是设计原则，因此我从设计原则来开始第⼀个节。
⼀、设计原则1.单⼀职责⼀个类，只有⼀个引起它变化的原因。
应该只有⼀个职责。
每⼀个职责都是变化的⼀个轴线，如果⼀个类有⼀个以上的职责，这些职责就耦合在了⼀起。
这会导致脆弱的设计。
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种设计模式详解设计模式是指面向对象编程中，经过多次验证、被广泛接受的代码实现方法。
这些设计模式可以帮助开发者更快地解决问题，提高代码的可读性、可维护性、可扩展性。
目前，常用的设计模式有23种。
下面，我们来详细介绍一下这23种设计模式。
1. 单例模式(Singleton)单例模式是一种只允许生成一个实例的模式。
在实例化对象时，单例模式的生成过程比较特殊，需要先判断该类是否已经实例化过，如果已经实例化，则直接返回已有的实例对象，否则再进行实例化。
2. 工厂模式(Factory)工厂模式是一种生产对象实例的设计模式。
它将对象实例的生成过程封装在一个工厂类中，客户端需要对象时，只需要调用工厂类中对应的方法即可。
3. 抽象工厂模式(Abstract Factory)抽象工厂模式是一种扩展了工厂模式的模式。
它可以生成一系列相关或相互依赖的对象实例。
具体实现时，通常需要定义一个抽象工厂类和一些具体工厂类，来生产各种相关的对象实例。
4. 建造者模式(Builder)建造者模式是一种用于构建复杂对象的模式。
它将一个复杂对象的构建过程分解成多个简单的步骤，然后通过一个指挥者来管理这些步骤的执行，最终构建出一个复杂的对象。
5. 原型模式(Prototype)原型模式是一种通过复制已有对象来创建新对象的模式。
一般来说，系统中的对象包含大量相同或相似的部分，通过复制对象可以帮助我们节省生成对象的时间和资源。
6. 适配器模式(Adapter)适配器模式是一种将不兼容接口转换为兼容接口的模式。
具体实现时，需要定义一个适配器类，该类实现了客户端所期望的接口，而且还包装了原有不兼容的接口，使其能够兼容客户端期望的接口。
7. 桥接模式(Bridge)桥接模式是一种将抽象部分与其实现部分分离开来的模式。
具体实现时，需要定义抽象部分和实现部分的接口，然后定义一个桥接类，将抽象部分和实现部分联系起来。
8. 组合模式(Composite)组合模式是一种将具有相同属性和方法的对象组合成树形结构的模式。
六大设计原则和23种设计模式
六大设计原则和23种设计模式
设计原则是设计模式的基础，六大设计原则是SOLID原则和DRY原则。
SOLID是单一职责原则（Single Responsibility Principle，SRP）、开闭原则（Open Closed Principle，OCP）、里氏替换原则（Liskov Substitution Principle，LSP）、接口隔离原则（Interface Segregation Principle，ISP）和依赖反转原则（Dependency Inversion Principle，DIP）。
DRY原则是不要重复自己（Don't Repeat Yourself）。
设计模式是软件设计中常用的解决问题的模式，常见的23种设计模式包括：
1. 创建型模式，工厂方法模式、抽象工厂模式、建造者模式、原型模式、单例模式。
2. 结构型模式，适配器模式、桥接模式、组合模式、装饰者模式、外观模式、享元模式、代理模式。
3. 行为型模式，责任链模式、命令模式、解释器模式、迭代器模式、中介者模式、备忘录模式、观察者模式、状态模式、策略模
式、模板方法模式、访问者模式。
这些设计原则和设计模式在软件开发中起着重要的作用。
设计原则有助于编写具有良好结构和可维护性的代码，而设计模式则提供了解决特定问题的经过验证的解决方案。
通过遵循这些原则和模式，开发人员可以编写出高质量、可扩展和易于维护的软件系统。
同时，这些原则和模式也有助于促进团队之间的沟通和协作，使得软件开发过程更加高效和可靠。
Java设计模式的六大原则
Java设计模式的六大原则
1.单一职责原则（Single Responsibility Principle，SRP）：一个类只负责一个功能，即一个类应该只有一个引起它变化的原因。
2.开闭原则（Open-Closed Principle，OCP）：一个软件实体如类、模块
和函数应该对扩展开放，对修改关闭。
即软件实体应该通过扩展来实现变化，而不是通过修改已有的代码来实现变化。
3.里氏替换原则（Liskov Substitution Principle，LSP）：任何时候都可
以使用子类对象替换掉父类对象，且程序不会出错。
即子类必须能够完全替换掉它们的父类。
4.依赖倒置原则（Dependency Inversion Principle，DIP）：高层模块不
应该依赖底层模块，两者都应该依赖于抽象。
抽象不应该依赖于具体实现，具体实现应该依赖于抽象。
5.接口隔离原则（Interface Segregation Principle，ISP）：客户端不应该依赖它不需要的接口。
即一个类对另一个类的依赖应该建立在最小的接口上。
6.迪米特法则（Law of Demeter，LoD）：一个对象应该对其他对象保持
最少的了解。
即一个类对自己依赖的类应该知道的越少越好，只与直接的朋友通信，不与陌生人通信。
这六大原则是设计模式中非常重要的基本原则，对于设计出高质量、可扩展和易维护的软件具有重要的指导作用。
设计模式-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架构；银⾏⽇志管理：格式分类：操作⽇志、交易⽇志、异常⽇志距离分类：本地记录⽇志、异地记录⽇志⼈⼒资源系统中的奖⾦计算模块：奖⾦分类：个⼈奖⾦、团体奖⾦、激励奖⾦。
23种设计模式总结
23种设计模式总结设计模式是一种解决反复出现的设计问题的方案，它们被广泛应用于软件设计和架构中。
在这里，我们列举了23种常用的设计模式，分别属于创建型、结构型和行为型模式。
一、创建型模式1. 工厂方法模式（Factory Method Pattern）定义一个创建对象的接口，但让子类决定实例化哪个类。
工厂方法模式是让类来进行对象的创建，而不是由你的代码直接new 出来。
2. 抽象工厂模式（Abstract Factory Pattern）提供一个接口，用于创建一系列相关或相互依赖的对象。
3. 单例模式（Singleton Pattern）确保一个类只有一个实例，并提供一个全局访问点。
4. 建造者模式（Builder Pattern）将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。
5. 原型模式（Prototype Pattern）用原型实例指定创建对象的种类，并通过拷贝这些原型创建新的对象。
二、结构型模式6. 适配器模式（Adapter Pattern）将一个类的接口转换成客户希望的另外一个接口。
适配器模式使得原本由于接口不兼容而不能一起工作的那些类可以在一起工作。
7. 桥接模式（Bridge Pattern）将抽象部分与它的实现部分分离，使它们都可以独立地变化。
8. 组合模式（Composite Pattern）将对象组合成树形结构以表示“部分-整体”的层次结构，使得用户对单个对象和组合对象的使用具有一致性。
9. 装饰器模式（Decorator Pattern）动态地给一个对象添加一些额外的职责，就增加功能来说，装饰器比生成子类更为灵活。
10. 外观模式（Facade Pattern）为子系统中的一组接口提供一个一致的界面，此模式定义了一个高层接口，使得这一子系统更加容易使用。
11. 享元模式（Flyweight Pattern）运用共享技术有效地支持大量细粒度的对象。
Java设计模式知识要点
AbstractClass 叫做抽象模板，它的方法分为两类： ● 基本方法 基本方法也叫做基本操作，是由子类实现的方法，并且在模板方法被调用。 ● 模板方法 可以有一个或几个，一般是一个具体方法，也就是一个框架，实现对基本方法的调 度，完成固定的逻辑。 注意： 为了防止恶意的操作，一般模板方法都加上 final 关键字，不允许被覆 写。 具体模板：ConcreteClass1 和 ConcreteClass2 属于具体模板，实现父类所定义的 一个或多个抽象方法，也就是父类定义的基本方法在子类中得以实现 使用场景： ● 多个子类有公有的方法，并且逻辑基本相同时。 ● 重要、复杂的算法，可以把核心算法设计为模板方法，周边的相关细节功能则由 各个子类实现。 ● 重构时，模板方法模式是一个经常使用的模式，把相同的代码抽取到父类中，然 后通过钩子函数（见“模板方法模式的扩展”）约束其行为。
2.工厂模式
定义：Define an interface for creating an object,but let subclasses decide which class to instantiate.Factory Method lets a class defer instantiation to subclasses. （定义一个用于创建对象的接口，让子类决定实例化哪一个类。工厂方法使一个类 的实例化延迟到其子类。）
Java面向对象设计的六大原则
Java⾯向对象设计的六⼤原则这是设计模式系列开篇的第⼀篇⽂章。
也是我学习设计模式过程中的总结。
这篇⽂章主要讲的是⾯向对象设计中，我们应该遵循的六⼤原则。
只有掌握了这些原则，我们才能更好的理解设计模式。
我们接下来要介绍以下6个内容。
单⼀职责原则——SRP开闭原则——OCP⾥式替换原则——LSP依赖倒置原则——DIP接⼝隔离原则——ISP迪⽶特原则——LOD单⼀职责原则单⼀职责原则的定义是就⼀个类⽽⾔，应该仅有⼀个引起他变化的原因。
也就是说⼀个类应该只负责⼀件事情。
如果⼀个类负责了⽅法M1,⽅法M2两个不同的事情，当M1⽅法发⽣变化的时候，我们需要修改这个类的M1⽅法，但是这个时候就有可能导致M2⽅法不能⼯作。
这个不是我们期待的，但是由于这种设计却很有可能发⽣。
所以这个时候，我们需要把M1⽅法，M2⽅法单独分离成两个类。
让每个类只专⼼处理⾃⼰的⽅法。
单⼀职责原则的好处如下：可以降低类的复杂度，⼀个类只负责⼀项职责，这样逻辑也简单很多提⾼类的可读性，和系统的维护性，因为不会有其他奇怪的⽅法来⼲扰我们理解这个类的含义当发⽣变化的时候，能将变化的影响降到最⼩，因为只会在这个类中做出修改。
开闭原则开闭原则和单⼀职责原则⼀样，是⾮常基础⽽且⼀般是常识的原则。
开闭原则的定义是软件中的对象(类，模块，函数等)应该对于扩展是开放的，但是对于修改是关闭的。
当需求发⽣改变的时候，我们需要对代码进⾏修改，这个时候我们应该尽量去扩展原来的代码，⽽不是去修改原来的代码，因为这样可能会引起更多的问题。
这个准则和单⼀职责原则⼀样，是⼀个⼤家都这样去认为但是⼜没规定具体该如何去做的⼀种原则。
开闭原则我们可以⽤⼀种⽅式来确保他，我们⽤抽象去构建框架，⽤实现扩展细节。
这样当发⽣修改的时候，我们就直接⽤抽象了派⽣⼀个具体类去实现修改。
⾥⽒替换原则⾥⽒替换原则是⼀个⾮常有⽤的⼀个概念。
他的定义如果对每⼀个类型为T1的对象o1,都有类型为T2的对象o2,使得以T1定义的所有程序P在所有对象o1都替换成o2的时候，程序P的⾏为都没有发⽣变化，那么类型T2是类型T1的⼦类型。
单一职责原则(Java设计模式,设计原则)
Java设计模式设计模式是一套被反复使用、多数人知晓、经过分类编目的优秀代码设计经验的总结。
设计模式，我想大家都经常听，其重要性也不言也意。
从今天开始，会向大家介绍23种Java设计模式。
设计模式可分为23种，三大类型：一、创建型，包括：1.单例模式（单体模式）：一个类只有一个实例，而且自行实例化并向整个系统提供这个实例2.工厂方法模式3.抽象工厂模式4.建造者模式5.原型模式二、结构型1.代理模式：为其他对象提供一种代理以控制对该对象的访问2.装饰模式3.适配器模式4.组合模式5.桥梁模式6.外观模式三、行为型1.模板方法模式2.命令模式3.责任链模式4.策略模式5.迭代器模式6.中介者模式7.观察者模式8.备忘录模式9.访问者模式10.状态模式11.解释器模式在说设计模式之前，需要说一下设计原则，下面先说第一个原则单一职责原则定义：一个类，应当只有一个引起它变化的原因，也就是一个类应该只有一个职责。
意思是，就一个类而言，应该只专注做一件事和仅有一个引起变化的原因。
下面以一个用户管理为例演示单一职责原则。
在业务逻辑层上定义类UserManager，在数据访问层定义类UserDao，在实体对象层定义类User，每个类具有不同的职责和功能。
public class User {private String username;private String userpass;private int role;//………….各个属性的get、set方法}public class UserDao extends BaseDao {//返回所有用户public List<User> getAllUser() {List<User> userList = new ArrayList<User>();......//访问数据库return userList;}//根据用户名查找用户public User getUserByName(String name) {User user=null;String sql="SELECT * FROM userdetail WHERE username=?";...//查找相应用户名的用户return user;}//添加新用户public boolean addUser(User user) {//返回true 表示成功}}public class UserManager {private UserDao userDao = new UserDao();//验证用户名和密码public boolean CheckUser(String name,String pass) {boolean flag=false;User user =userDao.getUserByName(name);if(user!=null&&user.getUsername().equals(pass)) {flag=true;}return flag;}//注册新用户public void registUser(User user) {if(userDao.getUserByName(user.getUsername()) !=null) {System.out.println("用户名已存在");return;}if(UserDao.addUser(user)) {//注册成功}else {//注册失败}}}。
java23种设计模式详解
java23种设计模式详解跟晓明⼀起学java之java设计模式本⽂参考了：/tiancai/blog/224624⼀、设计模式的分类1、创建型模式有五种：⼯⼚⽅法模式，抽象⼯⼚模式，单例模式，创建者模式，原型模式。
2、结构型模式有七种：适配器模式，装饰器模式，代理模式，外观模式，桥接模式，组合模式，享元模式。
3、⾏为型模式有⼗⼀种：策略模式，模板⽅法模式，责任链模式，命令模式，迭代⼦模式，观察者模式，备忘录模式，状态模式，中介者模式，访问者模式，解释器模式。
⼆、设计模式的基本原则待完成三、设计模式详解1、创建型模式⾸先介绍⼀下⼀下简单⼯⼚模式，简单⼯⼚模式不属于23种设计模式之⼀。
简单⼯⼚模式（1）单⽅法简单⼯⼚模式就是创建⼀个⼯⼚类，对实现了同⼀个接⼝的实现类进⾏实例化。
<1> 关系图1><2>⾸次创建接⼝：2>public interface ISend { public void send();}<3> 然后创建实现类：3>/** * 邮件发送实现类 * @author Administrator * */public class MailSend implements ISend{@Override public void send() { System.out.println('邮件发送信息！'); }}/** *短信发送实现类 * @author Administrator * */public class MessageSend implements ISend{ @Override public void send() { System.out.println('短信发送信息！'); }}<4>创建简单⼯⼚类：4>/** * 简单⼯程类 * @author Administrator * */public class SigleMethodFactory { public ISend produce(String type){ if('mail'.equals(type)){ return new MailSend(); }elseif('message'.equals(type)){ return new MessageSend(); } return null; }}<5>测试5>public class SimpleFactoryTest { public static void main(String[] args){ ISend send = new SigleMethodFactory().produce('mail'); send.send(); }}输出：邮件发送信息！（2）多⽅法是对单⽅法简单⼯⼚⽅法模式的改进，如果但⽅法传⼊的字符串不正确，则不能创建出对象，⽽多个⽅法的简单⼯⼚模式，是提供多个⼯⼚⽅法来创建不同的对象。
设计模式的六大原则
设计模式的六大原则
1、单一职责原则：即一个类只负责一项职责，不允许一个类承担多项
职责，一个类的变更对其他类的影响应尽量减少。
2、开放-封闭原则：开放-封闭原则是指软件实体（类、模块、函数等）应该是可以扩展的，但是不可修改。
即对用户而言是开放的，但是对
开发者而言是封闭的。
3、里氏替换原则：指一个软件实体应当无论在任何环境中都可以根据
基类被正确地使用，而且基类可以被其子类所替换，在基类不变的条
件下，子类可以拓展自己的行为，扩展基类行为时不会破坏到程序的
逻辑结构，符合里氏替换原则的类的结构在软件变更时扩展性好，并
且软件单位测试的时候也比较方便；
4、依赖倒置原则：指软件实体之间应当遵循依赖于抽象而不依赖于具体；一个软件实体应当只依赖于它的直接朋友，不应该依赖于陌生类；一个类对自己依赖的类知道的越少越好。
5、接口隔离原则：指一个模块不应该依赖于其他模块的实现细节，任
何模块都尽量以松耦合的方式实现；在接口的设计上尽量的分细、分小，便于提高可维护性。
6、迪米特法则：这是一种类之间解耦的具体方法，又叫最少知识原则，即一个对象应该对其他的对象有最少的了解。
一个类应该尽可能的少
去知道其它类的实现细节；这个类可以保持独立，尽可能做到与其它
类解耦。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
设计模式概念：一套被反复使用、多数人知晓、经过分类编目的优秀代码设计经验的总结。
设计模式要素：模式名称、问题、举例、末态环境、推理、其他有关模式、已知的应用。
设计模式分类：创建型、结构型、行为型。
创建型模式功能：1.统所使用的具体类的信息封装起来；2.类的实例是如何被创建和组织的。
创建型模式作用：1.封装创建逻辑，不仅仅是new一个对象那么简单。
2.封装创建逻辑变化，客户代码尽量不修改，或尽量少修改。
常见的创建型模式：单例模式、工厂方法模式、抽象工厂模式、建造者模式、原型模式。
常见的结构型模式：代理模式、装饰模式、适配器模式、组合模式、桥梁模式、外观模式、享元模式。
常见行为型模式：模板方法模式、命令模式、责任链模式、策略模式、迭代器模式、中介者模式、观察者模式、备忘录模式、访问者模式、状态模式、解释器模式。
单一职责原则：一个类应该只有一个职责。
优点：降低类的复杂性；提高类的可读性；提高代码的可维护性和复用性；降低因变更引起的风险。
里氏替换原则：优点：代码共享，减少创建类的工作量，每个子类都拥有父类的方法和属性；提高代码的可重用性；提高代码的可扩展性；提高产品或项目的开放性。
缺点：1.继承是入侵式的。
只要继承，就必须拥有父类所有属性和方法。
2.降低代码的灵活性。
子类必须拥有父类的属性和方法，使子类收到限制。
3.增强了耦合性。
当父类的常量、变量和方法修改时，必须考虑子类的修改，这种修改可能造成大片的代码需要重构。
依赖倒置原则：高层模块不应该依赖低层模块，两者都依赖其抽象；抽象不依赖细节；细节应该依赖于抽象。
在Java中的表现：模块间的依赖通过抽象发生，实现类之间不发生直接的依赖关系，其依赖关系是通过接口或抽象类产生的；接口或抽象类不依赖于是实现类；实现类依赖于接口或抽象类。
接口隔离原则：1.一个类对另外一个类的依赖性应当是建立在最小的接口上的2.一个接口代表一个角色，不应当将不同的角色交给一个接口。
3.不应该强迫客户使用它们的不同方法。
如图所示的电子商务系统在三个地方会使用到订单类：一个是门户，只能有查询方法；一个是外部系统，有添加订单的方法；一个是管理后台，添加、删除、修改、查询都要用到。
“原子”在实践中的衡量规则：1.一个接口只对一个子模块或者业务逻辑进行分类。
2.只保留接口中业务逻辑需要的public方法。
3.尽量修改污染了的接口，若修改的风险较大，则可采用适配器模式进行转化处理。
4.接口设计应因项目而异，因环境而异，不能照搬教条。
迪米特法则：（表述）只与你直接的朋友们通信；不要跟“陌生人”说话；每一个软件单位对其他的单位都只有最少的了解，这些了解仅局限于那些与本单位密切相关的软件单位。
对迪米特法则进行模式设计有两个：外观模式、中介者模式。
开闭原则：一个软件实体应当对扩展开放，对修改关闭。
重要性体现：提高复用性；提高维护性；提高灵活性；易于测试单例模式：单例模式确保某一个类只有一个实例，而且自行实例化并向整个系统提供这个实例单例模式。
优点：1.在内存中只有一个实例，减少了内存的开支。
2.只生成一个实例，减少了系统的性能开销。
3.避免对资源的多重占用。
4.可以在系统设置全局的访问点，优化和共享资源访问。
缺点：1.无法创建子类，扩展困难，若要扩展，除修改代码基本上没有第二种途径可以实现。
2.对测试不利。
3.与单一职责原则有冲突。
饿汉式单例类与懒汉式单例类之间的区别：1.饿汉式单例类在被加载时实例化，而懒汉式单例类在第一次引用时实例化。
2.从资源利用效率上说，饿汉式单例类要差一点，但从速度和反应时间的角度来讲，饿汉式单例类则比懒汉式单例类稍好些。
3.饿汉式单例类可以在Java中实现，但不易在C++中实现。
单例模式的使用场景：1.要求生成唯一的序列号环境。
2.在整个项目中需要一个共享访问点或共享数据。
3.创建一个对象需要消耗的资源过多。
4.需要定义大量的静态方法的环境。
使用单例模式的注意事项：1.在使用任何EJB、RMI和JINI的分布式系统中，应当避免使用有状态的单例类。
2.同一个JVM中会有多个类加载器，当两个类加载器同时加载一个类时，会出现两个实例，此时也应当尽量避免使用有状态的单例类。
工厂方法模式：定义一个用于创建对象的接口，让子类决定实例化那个类。
优点：良好的封装性，代码结构清晰；优秀的可扩展性；屏蔽产品类；典型的解耦框架。
使用场景：1.工厂方法模式是new一个对象的替代品，故在所有需要生成对象的地方都可以使用，但是需要慎重考虑是否需要增加一个工厂类进行管理，增加代码的复杂度。
2．需要灵活的、可扩展的框架时。
3.可以用在异构项目中。
4.可以使用在测试驱动开发的框架下。
抽象工厂模式：为创建一组相关或相互依赖的对象提供一个接口，且无需指定它们的具体类。
优点： 1.产品族内的约束为非公开状态，在不同的工厂中，各种产品可能具有不同的相互依赖关系，这些依赖关系由工厂封装在其内部，对于工厂的使用者是不可见的。
2.生产线的扩展非常容易，如果要针对同一产品族建立新的生产线，只需要实现产品族中的所有产品接口并建立新的工厂类即可。
缺点：产品族本身的扩展非常困难，如果需要在产品族中增加一个新的产品类型，则需要修改多个接口，并且会影响已有的工厂类。
使用场景：当一个对象族（或是一组没有任何关系的对象）都有相同的约束。
建造者将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。
优点：1.封装性，可以使客户端不必知道产品内部组成的细节。
2.建造者独立，容易扩3.便于控制细节风险。
使用场景：1.相同的方法，不同的执行顺序，产生不同的结果。
2.多个部件或零件，都可以装配到一个对象中，但是产生的运行结果又不相同时。
3.产品类非常复杂，或者产品类中的方法调用顺序不同产生了不同的效能。
4.在对象创建过程中会使用到系统的一些其他对象，这些对象在产品对象的创建过程中不易得到时。
原型模式：用原型实例制定创建对象的种类，并且通过复制这些原型创建新的对象。
优点：性能优良；逃避构造函数的约束。
使用场景：资源优化场景；性能和安全要求场景；一个对象多个修改者的场景。
结构型模式：为其他对象提供一种代理以控制对这个对象的访问。
种类：远程代理、虚拟代理、保护代理、缓存代理、同步代理、智能引用代理优点：1.职责清晰：真实的角色实现实际的业务逻辑，不用关心其他非本职的事务，通过后期的代理完成附加的事务，附带的结果就是编程简洁清晰。
2.高扩展性：具体主题角色随需求不同可能有很多种，但只要实现了接口，代理类就完全可以在不做任何修改的情况下代理各种真实主题角色。
3.智能化：代理类可以在运行时才确定要去代理的真实主题，这是一种强大的功能。
使用场景：代理模式的应用非常广泛，大到一个系统框架、企业平台，小到事务处理、代码片段，随处可见代理模式的使用，例如，JavaRMI的远程调用和AOP。
装饰模式：动态的给一个对象添加一些额外的职责。
优点：装饰类和被装饰类都可以独立发展，而不会相互耦合；装饰模式是继承关系的一个替代方案；装饰模式可以动态地扩展一个实现类的功能。
使用场景：1.需要扩展一个类的功能，或给一个类增加附加功能。
2.需要动态地给一个对象增加功能，这些功能可以再动态地撤销。
3.需要为一批类进行改装或加装功能。
适配器模式：将一个类的接口变换成客户端所期待的的另一种接口，从而使原本因接口不匹配而无法在一起工作的两个类能够在一起工作。
优点：可以让两个没有任何关系的类在一起运行；增加了类的透明度；提高类的复用度；增强代码的灵活性。
使用场景：修改一个已经投产中的系统时，需要对系统进行扩展。
此时使用一个已有类，但这个类不符合系统中的接口，这是使用适配器模式是最合适的，它可以将不符合系统接口的类进行转换，转换成符合系统接口的、可以使用的类。
组合模式：将组合成树形结构以表示“部分-整体”的层次结构，使得用户对单个对象和组合对象的使用具有一致性。
优点：高层模块调用简单；节点自由增加。
缺点：不易控制树枝构件的类型；不易使用继承的方法来增加新的行为。
使用场景：1.需要描述对象的部分和整体的等级结构，如树形菜单、文件和文件夹管理。
2.需要客户端忽略个体构件和组合构件的区别，平等对待所有的构件。
桥梁模式：将抽象和现实解耦，使得两者可以独立地变化。
优点：1.抽象和现实的分离是桥梁模式的主要特点，是为了解决继承的缺点而提出的设计模式。
在该模式下，实现可以不受抽象的约束，不用绑定在一个固定的抽象层次上。
2.实现对客户的透明，客户端不用关心细节的实现，它已经由抽象层通过聚合关系完成了封装。
使用场合：1.如果一个系统需要在构件的抽象化角色和具体角色之间增加更多的灵活性，避免在两个层次之间建立静态的联系。
2.设计要求实现化角色的任何改变不应当影响客户端，或者说实现化及角色的改变对客户端是完全透明的。
3.一个构件有多于一个抽象化角色和实现化角色，系统需要它们之间进行动态耦合。
4.不希望或不适合使用继承的场合。
外观模式：要求一个子系统的外部与其内部的通信必须通过一个统一的对象进行。
优点：1.减少系统的相互依赖，所有的依赖都是对Façade对象的依赖，与子系统无关。
2．提高灵活性，不管子系统系统内部如何变化，只要不影响Façade对象，任何活动都是自由的。
3.提高安全性，Façade中未提供的方法，外界就无法访问，提高系统的安全性。
使用场景：1.为一个复杂的模块或子系统提供一个供外界访问的接口。
2.子系统相对独立，外界子系统的访问只要黑箱操作即可。
3.预防风险扩散，使用Façade进行访问操作控制。
享元模式：使用共享对象可有效地支持大量的细粒度的对象。
优点：大幅减少内存中对象的数量，降低程序内存的占用，提高性能。
缺点：1.增加了系统的复杂性，需要分出外部状态和内部状态，而且内部状态具有固化特性，不应该随外部状态改变而改变，这使得程序的逻辑复杂化。
2.将享元对象的状态外部化，而读取外部状态使得运行时间变长。
使用场景：1.系统中有大量的相似对象，这些对象耗费大量的内存。
2．细粒度的对象都具备较接近的外部状态，而且内部状态与环境无关，即对象没有特定身份。
3.需要缓冲池的场景。
模板方法模式：定义一个操作中的算法的框架，而将一些步骤延迟到子类中。
使得子类可以不改变一个算法的结构即可重定义该算法的某些特定步骤。
优点：封装不变的部分，扩展可变的部分；提取公共部分代码，便于维护；行为由父类控制，子类实现。
应用场景：1.多个子类有公共方法，并且逻辑基本相同。
2.可以把重要的、复杂的、核心算法设计为模板方法，周边的相关细节功能则由各个子类实现。
3.重构时，模板方法模式是一个经常使用的模式，将相同的代码抽取到父类中。