JAVA二十三种设计模式
java最常用的六种设计模式及举例
java最常用的六种设计模式及举例设计模式是在软件开发过程中经验总结的一种编码和设计方式，它们可以帮助我们更好地组织代码，提高代码的可维护性和可复用性。
下面是 Java 中最常用的六种设计模式及其举例：1. 单例模式：单例模式确保一个类只有一个实例，并提供一个全局访问点。
典型的例子是 `ng.Runtime` 类，在整个 JVM 中只有一个运行时实例。
2. 工厂模式：工厂模式通过一个工厂类来创建其他类的对象，将对象的创建和使用分离，降低了代码的耦合度。
比如，`java.util.Calendar` 类使用了工厂模式来创建 `Calendar` 对象，其中的 `getInstance()` 方法返回一个 `Calendar` 实例。
3. 观察者模式：观察者模式定义了对象之间的一对多的依赖关系，当一个对象状态发生改变时，其相关依赖对象会收到通知并自动更新。
一个典型的例子是使用 `java.util.Observable` 类和 `java.util.Observer`接口进行监听和通知。
4. 装饰者模式：装饰者模式通过动态地将新功能附加到对象上，为对象提供了灵活的扩展方式，不需要修改原始对象的结构。
比如，`java.io` 包中的各种装饰者类可以用来扩展输入输出功能。
5. 策略模式：策略模式定义了一组算法，并将每个算法封装到可互换的对象中，使得算法的变化不会影响到使用算法的客户端。
一个常见的例子是使用 `parator` 接口来实现不同的比较策略。
6. 适配器模式：适配器模式将一个类的接口转换成客户端所期望的另一个接口，使得原本不兼容的类可以一起工作。
比如，`java.util.Arrays` 类中的 `asList()` 方法返回的是一个适配器，可以将数组转换成 List。
通过学习这些设计模式，我们可以更好地组织和设计代码，提高代码的可读性和可维护性。
在实际的开发中，我们可以针对具体的需求选择合适的设计模式，并根据需要进行一定的修改和定制。
Java的23种开发模式
1、工厂模式：客户类和工厂类分开。
消费者任何时候需要某种产品，只需向工厂请求即可。
消费者无须修改就可以接纳新产品。
缺点是当产品修改时，工厂类也要做相应的修改。
如：如何创建及如何向客户端提供。
2、建造模式：将产品的内部表象和产品的生成过程分割开来，从而使一个建造过程生成具有不同的内部表象的产品对象。
建造模式使得产品内部表象可以独立的变化，客户不必知道产品内部组成的细节。
建造模式可以强制实行一种分步骤进行的建造过程。
3、工厂方法模式：核心工厂类不再负责所有产品的创建，而是将具体创建的工作交给子类去做，成为一个抽象工厂角色，仅负责给出具体工厂类必须实现的接口，而不接触哪一个产品类应当被实例化这种细节。
4、原始模型模式：通过给出一个原型对象来指明所要创建的对象的类型，然后用复制这个原型对象的方法创建出更多同类型的对象。
原始模型模式允许动态的增加或减少产品类，产品类不需要非得有任何事先确定的等级结构，原始模型模式适用于任何的等级结构。
缺点是每一个类都必须配备一个克隆方法。
5、单例模式：单例模式确保某一个类只有一个实例，而且自行实例化并向整个系统提供这个实例单例模式。
单例模式只应在有真正的“单一实例”的需求时才可使用。
6、适配器(变压器)模式：把一个类的接口变换成客户端所期待的另一种接口，从而使原本因接口原因不匹配而无法一起工作的两个类能够一起工作。
适配类可以根据参数返还一个合适的实例给客户端。
7、桥梁模式：将抽象化与实现化脱耦，使得二者可以独立的变化，也就是说将他们之间的强关联变成弱关联，也就是指在一个软件系统的抽象化和实现化之间使用组合/聚合关系而不是继承关系，从而使两者可以独立的变化。
8、合成模式：合成模式将对象组织到树结构中，可以用来描述整体与部分的关系。
合成模式就是一个处理对象的树结构的模式。
合成模式把部分与整体的关系用树结构表示出来。
合成模式使得客户端把一个个单独的成分对象和由他们复合而成的合成对象同等看待。
java最常用的六种设计模式及举例
java最常用的六种设计模式及举例
1. 单例模式（Singleton Pattern）：保证一个类只有一个实例，并提供一个全局访问点。
例如，数据库连接池的设计使用了单例模式。
2. 工厂模式（Factory Pattern）：通过使用工厂方法来创建对象，而不是直接调用构造函数，从而实现封装和解耦的目的。
例如，Java中的Calendar类的getInstance()方法返回一个Calendar对象。
3. 观察者模式（Observer Pattern）：定义对象间的一种一对多的依赖关系，当一个对象的状态改变时，所有依赖于它的对象都会自动接收到通知并更新。
例如，Java中的事件处理机制，使用了观察者模式。
4. 装饰者模式（Decorator Pattern）：动态地给一个对象添加一些额外的职责，同时又不改变其结构。
例如，Java IO中的InputStream类是一个抽象类，而以其为基础的FileInputStream 类和BufferedInputStream类则是具体的装饰者。
5. 适配器模式（Adapter Pattern）：将一个类的接口转换成客户希望的另外一个接口。
例如，Java中的Collections类中的方法Arrays.asList()可以将数组转换为List类型。
6. 策略模式（Strategy Pattern）：封装一系列的算法，使得它们可以互相替换，而不影响使用它们的客户端。
例如，Java中
的Comparator接口和Comparable接口，用于定义排序算法的策略。
二十三种设计模式[3]-生成器模式（BuilderPattern）
![二十三种设计模式[3]-生成器模式（BuilderPattern）](https://img.taocdn.com/s3/m/f71ff7c429ea81c758f5f61fb7360b4c2e3f2afd.png)
⼆⼗三种设计模式[3]-⽣成器模式（BuilderPattern）前⾔⽣成器，⼜名建造者模式，属于创建型模式。
在《设计模式 - 可复⽤的⾯向对象软件》⼀书中对它的描述为“ 将⼀个复杂对象的构建与他的表⽰分离，使得同样的构建过程可以创建不同的表⽰ ”。
与和不同的是，⼯⼚⽅法侧重于将类的实例化延迟到⼦类，由⼦类决定⼯⼚的创建，从⽽得到⼀个产品，抽象⼯⼚则是⼀个包含了多个⼯⼚⽅法的⼤型⼯⼚，更侧重于⼀系列产品的创建，⽽⽣成器在创建产品同时，更加关注于产品的创建逻辑。
由于它们的侧重点不同，⼯⼚⽅法适合创建复杂的产品，⽣成器适合创建更加复杂的产品。
⼀个简单的例⼦。
抽象⼯⼚代表了⼀个⽣产多种产品的代⼯⼚，⼯⼚⽅法代表了某个产品的⽣产车间，⽣成器则代表了某个产品的⽣产线。
结构在⽣成器中，需要如下⼏种⾓⾊的⽀持：IBuilder(⽣成器接⼝)：⽤来定义创建⼀个产品实例所需要的各个函数；ConcreteBuilder(⽣成器接⼝实现)：实现创建产品实例所需要的各个函数；Director(导向器)：使⽤⽣成器来创建产品，封装了产品的实例化逻辑；Product(产品)：被导向器创建的产品对象；实现所谓“ 将⼀个复杂对象的构建与它的表⽰分离 ”是指由导向器去处理产品的实例化逻辑⽽不是⽣成器来处理。
再由各个不同的⽣成器分别实现创建产品实例所需要的各个函数，从⽽实现“ 同样的构建过程创建不同的表⽰ ”。
⽐如，在⼀个键⿏套装中包含了⼀个键盘和⼀个⿏标,不同的键⿏套装内⼜有不同品牌、型号的键盘和⿏标。
可以通过不同的组合⽅式得到⼀个完整的键⿏套装。
public interface IMouse{string GetBrand();}public class LogitechMouse : IMouse{public string GetBrand(){return "罗技-Logitech G903";}}public class RazeMouse : IMouse{public string GetBrand(){return "雷蛇-Raze 蝰蛇";}}public interface IKeyBoard{string GetBrand();}public class LogitechKeyboard : IKeyBoard{public string GetBrand(){return "罗技-Logitech G910 RGB";}}public class RazeKeyboard : IKeyBoard{public string GetBrand(){return "雷蛇-Raze 萨诺狼蛛";}}public class Kit{public IMouse Mouse { set; get; } = null;public IKeyBoard Keyboard { set; get; } = null; }public interface IKitBuilder{void BuildMouse();void BuildKeyboard();Kit GetKit();}public class LogitechKitBuilder : IKitBuilder{private Kit _kit = null;public LogitechKitBuilder(){this._kit = new Kit();}public void BuildMouse(){this._kit.Mouse = new LogitechMouse();}public void BuildKeyboard(){this._kit.Keyboard = new LogitechKeyboard(); }public Kit GetKit(){return this._kit;}}public class RazeKitBuilder : IKitBuilder{private Kit _kit = null;public RazeKitBuilder(){this._kit = new Kit();}public void BuildMouse(){this._kit.Mouse = new RazeMouse();}public void BuildKeyboard(){this._kit.Keyboard = new RazeKeyboard();}public Kit GetKit(){return this._kit;}}public class KitDirector{public Kit ConstructKit(IKitBuilder builder){if(builder == null){return null;}builder.BuildMouse();builder.BuildKeyboard();return builder.GetKit();}}class Program{static void Main(string[] args){//创建⽣成器IKitBuilder builder = new LogitechKitBuilder();//IKitBuilder builder = new RazeKitBuilder();//创建导向器KitDirector director = new KitDirector();//导向器通过注⼊的⽣成器创建产品实体Kit kit = director.ConstructKit(builder);Console.WriteLine($"当前套装内的⿏标是：{kit.Mouse.GetBrand()}");Console.WriteLine($"当前套装内的键盘是：{kit.Keyboard.GetBrand()}");Console.ReadKey();}}上述代码中，我们通过将不同的⽣成器（IKitBuilder）实体注⼊到同⼀导向器（KitDirector）来获得不同的Kit实体，从⽽达到“ 同样的构建过程创建不同的表⽰ ”的⽬的。
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（状态模式）：对象的行为随状态的改变而改变。
二十三种设计模式的通俗理解
二十三种设计模式的通俗理解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块钱一份，你要不要）原始模型模式：通过给出一个原型对象来指明所要创建的对象的类型，然后用复制这个原型对象的方法创建出更多同类型的对象。
23种设计模式范文
23种设计模式范文设计模式是软件开发中常用的解决方案模式，它们代表了在面对特定问题时的最佳实践和经验总结。
设计模式可以帮助我们更好地组织和设计代码，提高代码的可读性、可维护性和可扩展性。
在本文中，我们将介绍23种常用的设计模式，并分别讨论它们的实现原理和在实际开发中的应用场景。
1. 单例模式（Singleton Pattern）单例模式是最简单的设计模式之一，它确保一个类只有一个实例，并提供一个全局访问点。
在实现上，可以通过将构造函数私有化，然后提供一个静态方法返回实例来实现单例。
应用场景：在需要实现全局唯一访问点的场景下，比如线程池、配置管理器等。
2. 工厂模式（Factory Pattern）工厂模式是用来创建对象的一种模式，它将对象的创建和实现分离，使得代码更易于维护和扩展。
工厂模式有简单工厂模式、工厂方法模式和抽象工厂模式等几种不同的变体。
应用场景：在需要根据不同条件创建不同对象的场景下，比如数据库连接、日志记录等。
3. 抽象工厂模式（Abstract Factory Pattern）抽象工厂模式是工厂模式的一种扩展，它提供一个创建一系列相关或相互依赖对象的接口，而无需指定实际的类。
抽象工厂模式将一组工厂类封装起来，使其可以交换或者替换。
应用场景：在需要创建一组相关对象（如界面主题、操作系统等）并且需要保持一致性的场景下。
4. 建造者模式（Builder Pattern）建造者模式是用来生成复杂对象的一种模式，它将对象的构建与其表现分离，采用逐步构建的方式生成对象，可以让客户端不需要知道具体的构建细节。
应用场景：在构造过程比较复杂，需要多个组件协同工作的场景下，比如构建复杂的UI界面。
5. 原型模式（Prototype Pattern）原型模式是用来克隆对象的一种模式，它通过复制已有对象的原型来创建新的对象，避免了通过构造函数创建对象和初始化成员变量的重复过程。
应用场景：在需要创建大量相似对象或者初始化成本较高的对象时，可以使用原型模式。
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. 访问者模式：统一访问集合中对象，易扩展，易维护。
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
通过实际的示例代码来演示设计模式的实际
结构性设计模式
组合模式
将对象组织成树状结构，以表示“整体-部分”的层次关 系。
桥接模式
将抽象部分和实现部分分离，以便它们可以独立地变 化。
适配器模式
将一个类的接口转换成客户希望的另一个接口，从而
代理模式
为其他对象提供一个代理，以控制对这个对象的访问。
java设计模式面试题
java设计模式面试题一、设计模式概述设计模式是软件工程中的一套被广泛认可的解决特定问题的模板。
它们是在多年的软件开发实践中总结出的有效方法。
在Java开发中，设计模式可以帮助开发者更加高效地编写代码，提高代码的可维护性和可扩展性。
本文将介绍几种常见的Java设计模式，并提供相关的面试题供参考。
二、创建型模式1. 单例模式（Singleton Pattern）单例模式确保一个类只有一个实例，并提供一个全局访问点。
这种模式在需要全局常量或者需要频繁创建和销毁对象时非常有用。
面试题：请描述单例模式的实现方式，并说明其优缺点。
2. 工厂方法模式（Factory Method Pattern）工厂方法模式定义了一个创建对象的接口，但由子类决定要实例化的类是哪一个。
这种模式让类的实例化推迟到子类进行。
面试题：解释工厂方法模式与简单工厂模式的区别，并举例说明何时使用它们。
3. 抽象工厂模式（Abstract Factory Pattern）抽象工厂模式提供了一个接口，用于创建相关或依赖对象的家族，而不需要明确指定具体类。
这种模式主要用于处理多个相关类的设计。
面试题：何时应该使用抽象工厂模式而不是工厂方法模式？三、结构型模式1. 适配器模式（Adapter Pattern）适配器模式允许将一个类的接口转换成客户希望的另一个接口。
适配器模式使得原本由于接口不兼容而不能一起工作的那些类可以一起工作。
面试题：描述适配器模式的实现原理，并给出一个实际应用场景。
2. 装饰器模式（Decorator Pattern）装饰器模式动态地给一个对象添加一些额外的职责，就增加功能来说，装饰器模式比生成子类更为灵活。
面试题：解释装饰器模式与继承的区别，并说明装饰器模式的优势。
3. 组合模式（Composite Pattern）组合模式允许用户将对象组合成树形结构以表示“部分-整体”的层次结构。
组合模式使得用户对单个对象和组合对象的使用具有一致性。
软件设计模式(Java版)
第1章 软件设计模式基础
内容简介
• 本章教学目标： 了解软件设计模式的产生背景； 掌握软件设计模式的概念、意义和基本要素； 明白GoF的23种设计模式的分类与特点； 理解UML类之间的关系，并学会类图的画法； 正确理解面向对象的七种设计原则。 • 本章重点内容： GoF的23种设计模式的分类与特点； UML中的类之间的关系； UML中的类图的画法； 面向对象的七种设计原则。
• 1.2.3 类之间的关系 2.关联（Association）关系 关联关系是对象之间的一种引用关系，用于表示一类对象与另一类 对象之间的联系，如老师和学生、师傅和徒弟、丈夫和妻子等。关联关 系分为一般关联关系、聚合关系和组合关系，我们先介绍一般关联。关 联可以是双向的，也可以是单向的。
软件设计模式（Java版）、
软件设计模式（Java版）、
1.1 软件设计模式概述(续)
• 1.1.2 软件设计模式的概念与意义 1.什么是软件设计模式？ 软件设计模式（Software Design pattern ），又称设计模式， 是一套被反复使用、多数人知晓的、经过分类编目的、代码设计经验 的总结。 2.学习设计模式的意义 ⑴ 可以提高程序员的思维能力、编程能力和设计能力。 ⑵ 使程序设计更加标准化、代码编制更加工程化，使软件开发 效率大大提高，从而缩短软件的开发周期。 ⑶ 使设计的代码可重用性高、可读性强、可靠性高、灵活性好、 可维护性强。
软件设计模式（Java版）、
二十三种设计模式
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.单例模式（Singleton Pattern）定义：Ensure a class has only one instance, and provide a global point of access to it.（确保某⼀个类只有⼀个实例，⽽且⾃⾏实例化并向整个系统提供这个实例。
）通⽤代码：（是线程安全的）public class Singleton {private static final Singleton singleton = new Singleton();//限制产⽣多个对象private Singleton(){}//通过该⽅法获得实例对象public static Singleton getSingleton(){return singleton;}//类中其他⽅法，尽量是staticpublic static void doSomething(){}}使⽤场景：●要求⽣成唯⼀序列号的环境；●在整个项⽬中需要⼀个共享访问点或共享数据，例如⼀个Web页⾯上的计数器，可以不⽤把每次刷新都记录到数据库中，使⽤单例模式保持计数器的值，并确保是线程安全的；●创建⼀个对象需要消耗的资源过多，如要访问IO和数据库等资源；●需要定义⼤量的静态常量和静态⽅法（如⼯具类）的环境，可以采⽤单例模式（当然，也可以直接声明为static的⽅式）。
线程不安全实例：public class Singleton {private static Singleton singleton = null;//限制产⽣多个对象private Singleton(){}//通过该⽅法获得实例对象public static Singleton getSingleton(){if(singleton == null){singleton = new Singleton();}return singleton;}}解决办法：在getSingleton⽅法前加synchronized关键字，也可以在getSingleton⽅法内增加synchronized来实现。
java设计模式及应用场景
java设计模式及应用场景Java设计模式指的是在软件设计中，为了解决某一类问题而经过实践总结出来的一套实用的设计思路和方法。
这些设计模式不仅可以提高程序的可读性、可维护性和可扩展性，还可以提高程序的性能和可靠性。
在Java编程中，常用的设计模式有23种，它们分别是：1. 工厂模式2. 抽象工厂模式3. 单例模式4. 原型模式5. 建造者模式6. 适配器模式7. 桥梁模式8. 组合模式9. 装饰器模式10. 外观模式11. 享元模式12. 代理模式13. 责任链模式14. 命令模式15. 解释器模式16. 迭代器模式17. 中介者模式18. 备忘录模式19. 观察者模式20. 状态模式21. 策略模式22. 模板方法模式23. 访问者模式这些设计模式的应用场景各不相同。
举个例子，工厂模式适用于需要创建某些类型的对象的场景。
抽象工厂模式用于解决多个工厂实现类的问题。
单例模式适用于需要保证系统中某个实例只有一个的场景。
桥梁模式适用于需要将抽象和实现分离的场景。
外观模式适用于需要简化复杂代码的场景。
代理模式适用于需要在访问某个对象之前或之后添加一些逻辑的场景。
策略模式适用于需要根据不同情况采用不同的算法的场景。
以上只是众多设计模式中的一部分，每个设计模式都有其应用场景和优点，需要开发者根据实际情况进行选择。
在实际开发中，我们可以根据具体问题采用不同的设计模式。
比如在Web开发中，我们可以使用观察者模式来处理数据变化事件；在游戏开发中，我们可以使用状态模式来处理游戏中的各种状态；在GUI 开发中，我们可以使用装饰器模式来实现复杂的界面效果；在数据库访问中，我们可以使用代理模式来处理数据访问的安全性和性能问题等等。
总之，Java设计模式是一种非常重要的开发思想，它可以帮助我们解决各种软件开发中的问题，提高代码的质量和复用性，同时也为我们节约了大量的开发时间和成本。
因此，作为Java开发者，我们应该学好这些设计模式，并在实际开发中灵活运用，才能打造出更加高效、健壮、可维护的Java应用程序。
在JavaWeb中常用的10种设计模式,提高编程技巧
在JavaWeb中常用的10种设计模式，提高编程技巧JavaWeb开发中，设计模式是必不可少的一部分，设计模式是指在特定情境中重复出现的问题所提供的通用解决方案。
好的设计模式可以让我们更高效地进行开发，有助于开发出可重用、易于维护、可扩展性强的应用程序。
本文将介绍JavaWeb中常用的10种设计模式，希望能够对JavaWeb 开发者提高编程技巧有所帮助。
1. 工厂模式工厂模式是一种创建类的模式，它提供了一种创建对象的最佳方法。
在Java Web开发中，工厂模式被广泛应用。
通过工厂模式，我们可以将对象的创建与具体的类相分离，使得代码更加灵活且具有扩展性。
例如，我们可以使用工厂模式来创建数据库连接对象，这样可以解决数据库连接的管理和使用问题。
2. 单例模式单例模式是一种创建类的模式，它保证一个类只有一个实例，并提供对该实例的全局访问。
在Java Web开发中，单例模式用于创建全局对象或全局状态。
例如，我们可以使用单例模式来缓存静态数据或共享资源对象。
3. 适配器模式适配器模式是一种结构模式，它用于将一个类的接口转换为另一个类的接口。
在Java Web开发中，适配器模式常用于将不同版本的类或不同厂商的类进行接口标准化。
例如，我们可以使用适配器模式将不同的Java数据库API（如JDBC和Hibernate）进行接口标准化，以便于在应用程序中进行快速切换。
4. 桥接模式桥接模式是一种结构模式，它将接口和实现分离以便于它们可以各自独立地变化。
在Java Web开发中，桥接模式常用于减少类的复杂度并提高类的可维护性。
例如，我们可以使用桥接模式将一个大类分解成多个小类，这样可以使得各个小类之间的耦合度降低。
5. 建造者模式建造者模式是一种创建模式，它在复杂对象的构建过程中提供了分步骤的控制。
在JavaWeb开发中，建造者模式常用于构建复杂的数据结构或对象。
例如，我们可以使用建造者模式构建一个HTTP请求对象，这样可以使得其构建过程更加灵活且易于描述。
java23种设计模式及其应用场景
创建型模式•单例模式（Singleton）：确保一个类只有一个实例。
–应用场景：数据库连接池、日志记录、缓存系统。
•工厂方法模式（Factory Method）：定义一个创建对象的接口，但让子类决定实例化哪个类。
–应用场景：提供创建对象的灵活性，允许在不改变代码的情况下更换创建逻辑。
•抽象工厂模式（Abstract Factory）：提供一个创建一系列相关或依赖对象的接口，而无需指定具体的类。
–应用场景：创建复杂的对象结构，需要保持多个对象之间的一致性。
•建造者模式（Builder）：将一个复杂对象的构建与它的表示分离，使其能够一步一步创建。
–应用场景：创建复杂的对象，需要自定义不同的配置或属性。
•原型模式（Prototype）：通过复制一个现有的对象来创建新的对象。
–应用场景：创建大量相似对象时，避免重复创建的开销。
结构型模式•适配器模式（Adapter）：将一个类的接口转换成另一个类所期望的接口。
–应用场景：将不兼容的类或系统集成在一起。
•桥接模式（Bridge）：将抽象部分与实现部分解耦，使它们可以独立变化。
–应用场景：当需要在抽象层和实现层之间引入灵活性时。
•组合模式（Composite）：将对象组织成树形结构，以便以类似的方式处理单个对象和组合对象。
–应用场景：表示部分与整体之间的层次关系。
•装饰器模式（Decorator）：在不改变对象自身的情况下，向对象添加新的功能。
–应用场景：向对象添加可选项功能，避免创建新的子类。
•外观模式（Facade）：提供一个统一的界面来访问一个子系统，隐藏其内部复杂性。
–应用场景：简化对复杂系统的访问，降低客户端与子系统之间的耦合。
•享元模式（Flyweight）：使用共享的对象来减少内存开销和对象数量。
–应用场景：需要创建大量相同或相似对象时。
•代理模式（Proxy）：为另一个对象提供一个代理或替身，以便控制对该对象的访问。
–应用场景：为对象添加额外的功能，如访问控制、缓存、日志记录。
设计模式(Design Patterns)可复用面向对象软件的基础
设计模式（Design pattern）是一套被反复使用、多数人知晓的、经过分类编目的、代码设计经验的总结。
使用设计模式是为了可重用代码、让代码更容易被他人理解、保证代码可靠性。
毫无疑问，设计模式于己于他人于系统都是多赢的，设计模式使代码编制真正工程化，设计模式是软件工程的基石，如同大厦的一块块砖石一样。
项目中合理的运用设计模式可以完美的解决很多问题，每种模式在现在中都有相应的原理来与之对应，每一个模式描述了一个在我们周围不断重复发生的问题，以及该问题的核心解决方案，这也是它能被广泛应用的原因。
本章系Java之美[从菜鸟到高手演变]系列之设计模式，我们会以理论与实践相结合的方式来进行本章的学习，希望广大程序爱好者，学好设计模式，做一个优秀的软件工程师！一、设计模式的分类总体来说设计模式分为三大类：创建型模式，共五种：工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式。
结构型模式，共七种：适配器模式、装饰器模式、代理模式、外观模式、桥接模式、组合模式、享元模式。
行为型模式，共十一种：策略模式、模板方法模式、观察者模式、迭代子模式、责任链模式、命令模式、备忘录模式、状态模式、访问者模式、中介者模式、解释器模式。
其实还有两类：并发型模式和线程池模式。
用一个图片来整体描述一下：二、设计模式的六大原则1、开闭原则（Open Close Principle）开闭原则就是说对扩展开放，对修改关闭。
在程序需要进行拓展的时候，不能去修改原有的代码，实现一个热插拔的效果。
所以一句话概括就是：为了使程序的扩展性好，易于维护和升级。
想要达到这样的效果，我们需要使用接口和抽象类，后面的具体设计中我们会提到这点。
2、里氏代换原则（Liskov Substitution Principle）里氏代换原则(Liskov Substitution Principle LSP)面向对象设计的基本原则之一。
里氏代换原则中说，任何基类可以出现的地方，子类一定可以出现。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
Java设计模式一共23种哦，赵寰分享必属经典O(∩_∩)O~，让我们一起在Java的海洋里翱翔吧(*^__^*)嘻嘻……貌似这句话有语病，矮油，无所谓了，回复看所有的设计模式吧
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块钱一份，你要不要）
原始模型模式：通过给出一个原型对象来指明所要创建的对象的类型，然后用复制这个原型对象的方法创建出更多同类型的对象。
原始模型模式允许动态的增加或减少产品类，产品类不需要非得有任何事先确定的等级结构，原始模型模式适用于任何的等级结构。
缺点是每一个类都必须配备一个克隆方法。
[hide]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，最终都在修饰我这个人呀，怎么样，看懂了吗？
装饰模式：装饰模式以对客户端透明的方式扩展对象的功能，是继承关系的一个替代方案，提供比继承更多的灵活性。
动态给一个对象增加功能，这些功能可以再动态的撤消。
增加由一些基本功能的排列组合而产生的非常大量的功能。
10、FACADE—我有一个专业的Nikon相机，我就喜欢自己手动调光圈、快门，这样照出来的照片才专业，但MM可不懂这些，教了半天也不会。
幸好相机有Facade设计模式，把相机调整到自动担?灰?宰寄勘臧纯烀啪托辛耍?磺杏上嗷?远?髡??庋鵐M也可以用这个相机给我拍张照片了。
门面模式：外部与一个子系统的通信必须通过一个统一的门面对象进行。
门面模式提供一个高层次的接口，使得子系统更易于使用。
每一
个子系统只有一个门面类，而且此门面类只有一个实例，也就是说它是一个单例模式。
但整个系统可以有多个门面类。
更多精彩，请点击查看。