Java 之23种设计模式解析_尚硅谷_宋红康

java 23种设计方式Java中常见的设计模式有23种，它们被划分为三个主要类别：创建型模式（Creational Patterns）、结构型模式（Structural Patterns）和行为型模式（Behavioral Patterns）。

以下是这23种设计模式的简要介绍：创建型模式（Creational Patterns）：* 单例模式（Singleton Pattern）：保证一个类只有一个实例，并提供全局访问点。

* 工厂方法模式（Factory Method Pattern）：定义一个用于创建对象的接口，但由子类决定要实例化的类。

* 抽象工厂模式（Abstract Factory Pattern）：提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们的具体类。

* 建造者模式（Builder Pattern）：将一个复杂对象的构建与其表示分离，使得同样的构建过程可以创建不同的表示。

* 原型模式（Prototype Pattern）：用原型实例指定创建对象的种类，并通过拷贝这些原型创建新的对象。

结构型模式（Structural Patterns）：* 适配器模式（Adapter Pattern）：将一个类的接口转换成客户希望的另外一个接口。

* 桥接模式（Bridge Pattern）：将抽象部分与它的实现部分分离，使它们都可以独立地变化。

* 组合模式（Composite Pattern）：将对象组合成树形结构以表示"部分-整体"的层次结构。

* 装饰器模式（Decorator Pattern）：动态地给一个对象添加一些额外的职责。

* 外观模式（Facade Pattern）：为子系统中的一组接口提供一个一致的界面，外观模式定义了一个高层接口，使得子系统更容易使用。

* 享元模式（Flyweight Pattern）：使用共享对象支持大量细粒度的对象。

行为型模式（Behavioral Patterns）：* 责任链模式（Chain of Responsibility Pattern）：使多个对象都有机会处理请求，从而避免请求的发送者和接收者之间的耦合。

Java设计模式目录1. 设计模式 (2)1.1 创建型模式 (2)1.1.1 工厂方法（FactoryMethod） (2)1.1.2 抽象工厂（AbstractFactory） (7)1.1.3 建造者模式（Builder） (14)1.1.4 单态模式（Singleton） (20)1.1.5 原型模式（Prototype） (23)1.2 结构型模式 (27)1.2.1 适配器模式（Adapter） (27)1.2.2 桥接模式（Bridge） (31)1.2.3 组合模式（Composite） (38)1.2.4 装饰模式（Decorator） (45)1.2.5 外观模式（Facade） (49)1.2.6 享元模式（Flyweight） (55)1.2.7 代理模式（Proxy） (60)1.3 行为型模式 (66)1.3.1 责任链模式（Chain of Responsibility） (67)1.3.2 命令模式（Command） (73)1.3.3 解释器模式（Interpreter） (80)1.3.4 迭代器模式（Iterator） (86)1.3.5 中介者模式（Mediator） (93)1.3.6 备忘录模式（Memento） (98)1.3.7 观察者模式（Observer） (103)1.3.8 状态模式（State） (110)1.3.9 策略模式（Strategy） (115)1.3.10 模板方法（TemplateMethod） (119)1.3.11 访问者模式（Visitor） (123)1. 设计模式容简介有感于设计模式在日常开发中的重要性，整理二十三种设计模式的理论部分，综合汇总成这份Java设计模式，希望对大家有所帮助。

本文档主要是为了向读者介绍二十三种设计模式，包括模式的描述，适用性，模式的组成部分，并附带有简单的例子和类*，目的是为了让读者了解二十三种设计模式，并能方便的查阅各种设计模式的用法及注意点。

[尚硅谷]_宋红康_Java之23种设计模式解析—————————————————————————————题目：Java 之23种设计模式解析一、设计模式概述总体来说设计模式分为三大类：创建型模式，共五种：工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式。

结构型模式，共七种：适配器模式、装饰器模式、代理模式、外观模式、桥接模式、组合模式、享元模式。

行为型模式，共十一种：策略模式、模板方法模式、观察者模式、迭代子模式、责任链模式、命令模式、备忘录模式、状态模式、访问者模式、中介者模式、解释器模式。

具体如下：其中创建型有：一、Singleton，单例模式：保证一个类只有一个实例，并提供一个访问它的全局访问点二、Abstract Factory，抽象工厂：提供一个创建一系列相关或相互依赖对象的接口，而无须指定它们的具体类。

三、Factory Method，工厂方法：定义一个用于创建对象的接口，让子类决定实例化哪一个类，Factory Method使一个类的实例化延迟到了子类。

四、Builder，建造模式：将一个复杂对象的构建与他的表示相分离，使得同样的构建过程可以创建不同的表示。

五、Prototype，原型模式：用原型实例指定创建对象的种类，并且通过拷贝这些原型来创建新的对象。

行为型有：六、Iterator，迭代器模式：提供一个方法顺序访问一个聚合对象的各个元素，而又不需要暴露该对象的内部表示。

七、Observer，观察者模式：定义对象间一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都得到通知自动更新。

八、Template Method，模板方法：定义一个操作中的算法的骨架，而将一些步骤延迟到子类中，TemplateMethod使得子类可以不改变一个算法的结构即可以重定义该算法得某些特定步骤。

九、Command，命令模式：将一个请求封装为一个对象，从而使你可以用不同的请求对客户进行参数化，对请求排队和记录请求日志，以及支持可撤销的操作。

Java设计模式疯狂Java联盟版目录1. 设计模式 (3)1.1 创建型模式 (4)1.1.1 工厂方法 (4)1.1.2 抽象工厂 (6)1.1.3 建造者模式 (10)1.1.4 单态模式 (13)1.1.5 原型模式 (15)1.2 结构型模式 (17)1.2.1 适配器模式 (17)1.2.2 桥接模式 (19)1.2.3 组合模式 (22)1.2.4 装饰模式 (26)1.2.5 外观模式 (28)1.2.6 享元模式 (31)1.2.7 代理模式 (34)1.3 行为型模式 (36)1.3.1 责任链模式 (37)1.3.2 命令模式 (40)1.3.3 解释器模式 (42)1.3.4 迭代器模式 (45)1.3.5 中介者模式 (49)1.3.6 备忘录模式 (52)1.3.7 观察者模式 (54)1.3.8 状态模式 (58)1.3.9 策略模式 (61)1.3.10 模板方法 (63)1.3.11 访问者模式 (65)1. 设计模式内容简介有感于设计模式在日常开发中的重要性，同时笔者也自觉对设计模式小有心得，故笔者撰写二十三种设计模式的简单例子、并整理二十三种设计模式的理论部分，综合汇总成这份Java设计模式（疯狂Java 联盟版），希望对大家有所帮助。

本份帮助文档主要是为了向读者介绍二十三种设计模式，包括模式的描述，适用性，模式的组成部分，并附带有简单的例子和类*，目的是为了让读者了解二十三种设计模式，并能方便的查阅各种设计模式的用法及注意点。

所附的例子非常简单，慢慢的引导读者从浅到深了解设计模式，并能从中享受设计的乐趣。

由于每个人对设计模式的理解都不尽一致，因此，可能本文档的例子中有不恰当的地方，还望各位读者指出不恰当的地方。

欢迎登录疯狂Java联盟进行技术交流，疯狂Java联盟的论坛宗旨是：所有的技术发帖，均有回复。

疯狂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设计模式目录1. 设计模式 (2)1.1 创建型模式 (2)1.1.1 工厂方法 (2)1.1.2 抽象工厂 (4)1.1.3 建造者模式 (8)1.1.4 单态模式 (11)1.1.5 原型模式 (13)1.2 结构型模式 (15)1.2.1 适配器模式 (15)1.2.2 桥接模式 (17)1.2.3 组合模式 (20)1.2.4 装饰模式 (24)1.2.5 外观模式 (26)1.2.6 享元模式 (30)1.2.7 代理模式 (32)1.3 行为型模式 (35)1.3.1 责任链模式 (35)1.3.2 命令模式 (38)1.3.3 解释器模式 (41)1.3.4 迭代器模式 (43)1.3.5 中介者模式 (47)1.3.6 备忘录模式 (50)1.3.7 观察者模式 (52)1.3.8 状态模式 (56)1.3.9 策略模式 (59)1.3.10 模板方法 (61)1.3.11 访问者模式 (63)1. 设计模式(超级详细)1.1 创建型模式AbstractFactory ( 抽象工厂)FactoryMethod ( 工厂方法)Singleton ( 单态模式)Builder ( 建造者模式)Protot*pe * 原型模式)1.1.1 工厂方法*义一个用于创建对象的接口，让子类决定实例化哪一个类。

FactoryMethod 使一个类的实例*延迟到其子类。

适用性1.当一个类不知道它所必须创建的对象的类的时候。

2.当一个类希望由它的子类来指定它所创建的对象的时候。

3.当*将创建对象的职责委托给多个帮助*类中的某一个，并且*希望将哪一个帮助子类是代理者这一信息局部化的时候。

参与者1.Product定义工厂方法所创建的对象的接口。

2.ConcreteProduct实现Product接口。

3.Creator声明工厂方法，该方法返回一个Product类型的对象*Creator也可以定义一个工厂方法的缺省实现，它返回一个缺省的ConcreteProduct对象。

Java设计模式：23种设计模式全⾯解析（超级详细）以及在源码中的应⽤从⽹络上找的设计模式, 很全⾯,只要把UML类图看懂了, 照着类图将代码实现是很容易的事情.步骤: 先看懂类图, 然后将代码实现, 之后再看⽂字7⼤设计原则:1: 单⼀职责原则: 类应该只有⼀个职责,或者功能2: 接⼝隔离原则: ⼀个类不应该依赖与他不相关,不需要的接⼝, ⼀个类对另⼀个类的依赖应该建⽴在最⼩的接⼝上3: 依赖倒置原则: 依赖抽象不依赖具体,思想是:⾯向接⼝编程4: ⾥⽒替换原则: java中的继承有弊端, 少⽤继承, 多使⽤聚合,组合,依赖, 因为⼦类继承后,很容易不⼩⼼将⽗类中的⽅法重写, ⽽⼦类不知道,调⽗类⽅法时候,容易混淆, 换句话就是:所有使⽤⽗类⽅法的地⽅,也能透明的使⽤其⼦类的对象, ⼦类尽量不要重写⽗类的⽅法, 可以将⽗类和⼦类都继承⼀个更通俗的⽗类,5: 开闭原则(ocp原则): 对扩展开放(提供⽅), 对修改关闭(使⽤⽅)6: 迪⽶特原则: 最少知道原则, ⼀个类对⾃⼰依赖的类知道越少越好,被依赖的类尽量将逻辑都封装到类中,只提供外⼀个⼊⼝就好, ⼜叫: 只和直接朋友通信,(直接朋友:成员变量,⽅法⼊参, ⽅法返回值中的类都是直接朋友, 局部变量中的类不是直接朋友, 也就是说陌⽣的类,不要以局部变量的⽅式出现在类中)7: 合成复⽤原则: 尽量使⽤聚合,组合的⽅式, 少⽤继承, 这样做⽬的是松耦合⼀: 1.1:简单⼯⼚模式(⼜叫静态⼯⼚模式): 是将各种对象的创建都交给⼀个⼯⼚类, client要使⽤各种对象时候,只需要在client中聚合这个⼯⼚类即可,⽐如这个图中,胡椒披萨,榴莲披萨,原味披萨, 都有⼀个共同的基类Pizza, ⼯⼚类SimpleFactory 根据不同类型返回对应的披萨对象,, OrderPizza这个就是client类, 在OrderPizza类中聚合⼯⼚类即可, 就可以根据不同类型创造不同⼝味的披萨了1.2: ⼯⼚⽅法模式: 假如有北京胡椒披萨,北京榴莲披萨,北京原味披萨, 伦敦胡椒披萨,伦敦榴莲披萨,伦敦原味披萨. 此时使⽤简单⼯⼚模式是不合适的, 等于在这个⼯⼚类中,要分别创建这6个披萨对象, 修改多,维护性,扩展性差 .解决⽅法: 简单⼯⼚模式是创建了⼀个⼯⼚类, ⼯⼚⽅法模式,是创建⼀个抽象⼯⼚类,他的实现是北京⼯⼚类, 伦敦⼯⼚类, 在实现类中完成对象的创建,这样等于是,将对象的创建交给⼦类取实现.uml类图如下:1.3: 抽象⼯⼚模式: ⼯⼚⽅法模式是创建了⼀个抽象⼯⼚类,让⼦类取实现,完成对象创建, 很相似抽象⼯⼚模式是定义⼀个接⼝, 对象的创建在⼦类中完成.client中聚合该接⼝类,uml类图如下⼯⼚模式再JDK源码中的应⽤Calendar date = Calendar.getInstance();public static Calendar getInstance(){return createCalendar(TimeZone.getDefault(), Locale.getDefault(Locale.Category.FORMAT));}再点进去private static Calendar createCalendar(TimeZone zone,Locale aLocale){CalendarProvider provider =LocaleProviderAdapter.getAdapter(CalendarProvider.class, aLocale).getCalendarProvider();if (provider != null) {try {return provider.getInstance(zone, aLocale);} catch (IllegalArgumentException iae) {// fall back to the default instantiation}}Calendar cal = null;if (aLocale.hasExtensions()) {//这⾥根据时区不同,来创建不同的对象String caltype = aLocale.getUnicodeLocaleType("ca");if (caltype != null) {switch (caltype) {case "buddhist":cal = new BuddhistCalendar(zone, aLocale);break;case "japanese":cal = new JapaneseImperialCalendar(zone, aLocale);break;case "gregory":cal = new GregorianCalendar(zone, aLocale);break;}}}if (cal == null) {// If no known calendar type is explicitly specified,// perform the traditional way to create a Calendar:// create a BuddhistCalendar for th_TH locale,// a JapaneseImperialCalendar for ja_JP_JP locale, or// a GregorianCalendar for any other locales.// NOTE: The language, country and variant strings are interned.if (aLocale.getLanguage() == "th" && aLocale.getCountry() == "TH") {cal = new BuddhistCalendar(zone, aLocale);} else if (aLocale.getVariant() == "JP" && aLocale.getLanguage() == "ja"&& aLocale.getCountry() == "JP") {cal = new JapaneseImperialCalendar(zone, aLocale);} else {cal = new GregorianCalendar(zone, aLocale);}}return cal;}⼆: 原型模式: 原型模式就是将⼀个对象复制出另⼀个对象来,除了内存地址不同,其余都相同, 使⽤Object类中的clone⽅法, 如果⼀个对象中的属性都是基本数据类型, 使⽤clone⽅法就可以实现对象的复制, 如果该对象中的属性,有引⽤数据类型(数组,另⼀个对象,list,)此时使⽤clone⽅法,不能实现对象的完全复制, 因为引⽤数据类型,使⽤clone⽅法,在内存中只是指针的引⽤,并没有重新复制出相同的对象来,,,, 建议使⽤流序列化的⽅式实现深拷贝原型模式在spring中的应⽤, spring中的bean的创建, xml⽂件中配置这⾥的 scope="prototype"就是指对象多例模式, 其实就是原型模式,复制⼀模⼀样的对象三: 建造者模式: 将复杂对象的建造过程抽象出来, 从⽽他的实现类可以构造出不同属性的对象, ⽤户只需要指定复杂对象的类型和内容,就可以建造他们,不需要知道具体的建造过程. ⽐如房⼦建造过程: 打地基,砌墙,封顶, 他的实现类:普通房⼦实现类, 创建的对象:普通房⼦,地基150cm,墙厚15cm,顶是茅草顶, 另⼀个实现类:豪宅,创建的对象: 地基300cm,墙厚50cm,顶是⾦砖顶.有四个⾓⾊:1:产品(product)2:抽象建造者(builder), 创建⼀个product对象的各个部件指定的接⼝或抽象类3:具体建造者(concreateBuilder) 实现接⼝,构建和装配各个配件4:指挥者(director) , 构建⼀个使⽤ builder接⼝的对象,它主要创建⼀个复杂对象, 隔离了客户与产品的制造过程, 负责控制产品的制造流程uml类图如下:该图中,产品product 是组合到 builder抽象类中的,这样builder的实现类,都可以拿到product,从⽽对其属性,⽅法进⾏各⾃的实现, builder 和 director(指挥者)的关系是聚合, 同时,director类中,会有⼀个总的build⽅法,作为对外提供的接⼝, client端使⽤的时候,只需要使⽤ director类的 builder ⽅法,就可建造不同类型的产品了.建造者模式在 JDK 中的应⽤, ⽐如:StringBuilder建造者模式和抽象⼯⼚模式对⽐, 建造者模式是隔离了客户和产品建造过程, ⽽抽象⼯⼚模式,没有隔离,在client中调⽤时候,需要具体实现者⼀步⼀步建造产品, 这样如果再有⼀个房⼦的产品,地基500cm,墙600cm,没有顶, 相对于建造者模式来说,修改很容易, ⽽抽象⼯⼚模式来说,相当于⼜把建造流程写了⼀遍,不利于维护和扩展 uml对⽐如下四: 适配器模式: ⽬的是兼容, 将某个类的接⼝转换成客户期望的另⼀个接⼝表⽰,让原本因为接⼝不匹配⽽不能⼀起⼯作的⼆个类可以协同⼯作, 从客户的⾓度看不到适配过程,感觉只是和⽬标类接⼝交互,uml类图如下, 类之间的关系 Voltage5V这个是适配器接⼝,Voltage220V是被适配类, VoltageAdapter是适配器实现类, 实现适配器接⼝,并继承被适配类,类适配器UML类图之前说过继承不好,可以⽤聚合来代替, 对象适配器UML类图如下:类适配器模式, 对象适配器模式, 都是适配器接⼝, ⽽接⼝适配器模式, 是将适配器接⼝做成抽象类, 被适配类(220V)做成接⼝, 抽象类实现该接⼝, 这样client使⽤的时候,直接使⽤抽象类,并重写⽅法就可以了,很简单很灵活, 接⼝适配器模式UML类图如下:适配器模式在SpringMVC 中的应⽤: 相信这个图我们都很熟悉了,client发送请求到 DispatchServlet, ,,,,请求执⾏Hander, 这个请求就是发给了处理器适配器,HandlerAdapter, 因为处理器的类型很多,spring定义这个接⼝,使得每⼀种Controller都有对应的适配器实现类, 适配器代替controller执⾏相应的⽅法, controller和适配器的类图如下:五:桥接模式: 就是将抽象化(Abstraction) 和实现化(inplermentation) 分开,使⼆者可以独⽴变化, UMl类图如下:,⼀个很常见的场景是:发送提⽰消息, 消息类型有普通消息, 加急消息,特急消息, 消息发送⼿段⼜分为: 系统内短消息, ⼿机短消息, email使⽤桥接模式就是,将消息类型和消息发送⼿段分开, 让他们独⽴变化, 看下图实现类接⼝和抽象类的关系是聚合, client调⽤的时候,创建了抽象类实例化对象,设置已经聚合对象这样会很灵活, 消息类型和发送⼿段结合,,,既能满⾜需求, 也避免了类爆炸,再⽐如: ⼿机⽅式: 折叠,直板,侧滑, ⼿机品牌:⼩⽶,vivol,华为使⽤桥接模式的UML类图为:桥接模式在 JDBC源码中的使⽤1:JDBC驱动程序, 2:消息管理, 3: 银⾏的转账系统(⽹上转账,柜台转账,ATM转账)(普通⽤户,⾦卡⽤户,vip⽤户) JDBC类图如下,六: 装饰者模式: 动态的将新功能附加到对象上, 在对象功能扩展上, ⽐继承更灵活,也体现了ocp原则, , 也可以理解为实现了多种组合很多⼈分不清装饰者模式和代理模式的区别, 装饰者模式,是对同⼀个对象的功能加强, 代理模式是重新new了⼀个对象,这个新对象调⽤被调⽤者的⽅法功能.装饰者模式的UML类图如下:可以看到, 作料的实现类中,都聚合了饮料类, 这个饮料类属性也可以在作料抽象类中, 作料的实现类使⽤的时候,直接 supper就可以了装饰者模式在 JDK中的应⽤: I/O InputStream UML类图如下七:组合模式: ⼜叫部分整体模式, 他创建了对象组的树形结构,将对象组成树状结构来展⽰部分-整体的层次关系UML类图:⽐如: 展⽰⼀个学校院系结构, ⼀个学校有多个学院,⼀个学院有多个系, 学校,学院,系,都继承Component,抽象类中,增删⽅法. 系就是叶⼦节点(Leaf), 学校, 学院就是(Composite)⼦节点, 并且在⼦节点类中维护有⼀个存储⽅式List , 对应的UML类图为:组合模式在源码中的应⽤, ⽐如HashMap, 点进去后可以看到: 抽象类是Map 接⼝, 叶⼦节点是 Node(也实现了 Map接⼝), ⼦节点是 HashMap(也实现了Map接⼝,并在HashMap中维护了⼀个存储⽅式 node的数组:Node<K,V>[] table),对应的UML类图如下:这⾥只是解析了HashMap的组合模式,平常代码过程中,也要使⽤组合模式, 先定义⼀个抽象类或接⼝, 抽象类中定义⼀些通⽤功能, 接着定义⼀个中间构件(⼦节点)实现抽象类/接⼝,重写通⽤功能,并在⼦节点中维护⼀个存储结构,map,list 都可以, 最后定义⼀个叶⼦节点,同样继承/实现抽象构件,⾥⾯⽅法可以根据特殊需要重写.⼋: 外观模式: 打个⽐⽅: 电脑(包含了cpu, 硬盘,内存,屏幕)开机/关机,要依次将这四个部分开机/关机, ⽽实际上,我们只是点了开机按钮, 是由于电脑已经帮我们处理好了, 这四个部分就相当于⼦系统⾓⾊, 开机按钮,就是电脑提供给我们的统⼀界⾯, 相当于外观⾓⾊ . 外观模式就是定义⼀个⾼层的接⼝/类(外观⾓⾊), 给各个⼦系统⼀群接⼝(将各个⼦系统类,聚合到外观接⼝中),提供⼀个统⼀的对外访问接⼝, 客户直接和外观⾓⾊交互, 不和各个⼦系统的⼀群接⼝交互, 这样做避免了调⽤混乱, 对客户来说使⽤简单. 外观类中提供⼀个对外⽅法(⽅法中,各个⼦系统类⽅法依次执⾏),解决了多个⼦系统接⼝调⽤混乱的问题, 起到简化⽤户操作的⽬的, ⽐如java 的三层开发, 也是外观模式的应⽤,外观模式在源码中的应⽤:九: 享元模式: 分享对象模式: 各种各样的池技术, 常量池,线程池,连接池,缓冲池等等, ⽐如⽹络围棋,棋⼦对象,如果都要创建的话,⼀盘棋要创建⼏百个对象, 数百⼈都在线,⼜要创建多少对象,服务器内存才够, 显然这⾥的棋⼦对象很相似, 只是颜⾊和坐标不同⽽已, 此时就⽤到了池技术(享元模式)之后,只需要⼆个对象即可,减⼩服务器内存占⽤, 享元模式,要区分对象的内部状态, 和外部状态, 显然,对于棋⼦来说,颜⾊是内部状态, 坐标是外部状态,享元模式详解:⼗: 代理模式:静态代理: 需要代理对象,和被代理对象,都实现相同的接⼝或者继承相同⽗类, 并且,将被代理对象聚合到代理类中, 这样代理类,能重写⽗类的⽅法,在⽅法中,⼜因为聚合了被代理对象, 所以可以针对被代理对象的⽅法,实现前置, 后置修改. UML类图如下:JDK代理: 是 java 帮我们创建了⽬标对象的代理对象, 也是需要被代理对象有个接⼝, 利⽤Proxy.newProxyInstance(var1,var2,var3) ⽅法创建代理对象, var1:被代理对象的类加载器 classLoader, var2:被代理对象的接⼝类型, var3: InvocationHandler 事情处理，执⾏⽬标对象的⽅法时，会触发事情处理器⽅法, 会把当前执⾏的⽬标对象⽅法作为参数传⼊cglib动态代理:不需要⽗类接⼝, 只需要被代理对象实现 MethodInterceptor接⼝, 重写 intercept⽅法, 这个⽅法相当于⽅法拦截器, 可以在⽅法中,调⽤⽬标⽅法, 前置处理, 后置处理.相当于给被代理对象,⽣了⼀个⼉⼦,这个⼉⼦就是代理对象,⼗⼀: 模板⽅法模式: 这个⽐较简单, 抽象类中,定义整个流程的多个⽅法(抽象⽅法), 这些⽅法推迟到⼦类中实现,从⽽实现个性化模板⽅法模式在 SpringIOC容器初始化时候⽤到了模板⽅法模式, mybatis中的 BaseExcutor抽象类中⽤了模板⽅法模式, 这个抽象类实现了Excutor接⼝, Excutor接⼝中定义了⼀系列操作数据库的⽅法:⽐如查询,更新,创建缓存key,删除缓存,获取事务,关闭等等⽅法, BaseExcutor这个抽象类中实现了⼀些共性的⽅法⽐如缓存管理,事务管理⽅法,有四个⽅法,让他的⼦类去重写,⽐如:doUpdate() ⽅法、doQuery() ⽅法、doQueryCursor() ⽅法、doFlushStatement() ⽅法, 他的UML类图如下:⼗⼆:命令模式:⼗三: 访问者模式: 这个不太明⽩啊⼗四: 迭代器模式: 对外提供统⼀的集合迭代接⼝, ⽤统⼀的⽅法遍历集合元素, 不暴露内部结构⼗五: 观察者模式: ⼜叫发布-订阅模式⼗六: 中介者模式: 中介者模式: ⽤⼀个中介对象来封装⼀系列的对象交互, 中介者是各个对象不需要显式的相互引⽤, 从⽽使其松耦合,⽽且可以独⽴的改变他们之间的交互, ⽐如MVC模式.C(Controller控制器) 是M(Model模型)和V(view视图)的中介者,在前后端交互时起到了中间⼈作⽤, 中介者明细的特征是,每个同事对象都聚合了中介者, 中介者同时也聚合了每⼀个同事。

工厂模式，工厂方法模式，单例模式，外观（Facade）模式，观察者（Observer）模式，桥接（Bridge）模式都是比较常用的，不同的项目有不同的设计方向，可以参考的设计模式也不尽相同，没有定数，只是上面这几个模式用的比较多一些。

其他的模式我找了一下，都列出来了。

======================Java常用的设计模式创建型模式1、FACTORY—追MM少不了请吃饭了，麦当劳的鸡翅和肯德基的鸡翅都是MM爱吃的东西，虽然口味有所不同，但不管你带MM去麦当劳或肯德基，只管向服务员说“来四个鸡翅”就行了。

麦当劳和肯德基就是生产鸡翅的Factory工厂模式：客户类和工厂类分开。

消费者任何时候需要某种产品，只需向工厂请求即可。

消费者无须修改就可以接纳新产品。

缺点是当产品修改时，工厂类也要做相应的修改。

如：如何创建及如何向客户端提供。

2、BUILDER—MM最爱听的就是“我爱你”这句话了，见到不同地方的MM,要能够用她们的方言跟她说这句话哦，我有一个多种语言翻译机，上面每种语言都有一个按键，见到MM我只要按对应的键，它就能够用相应的语言说出“我爱你”这句话了，国外的MM 也可以轻松搞掂，这就是我的“我爱你”builder。

（这一定比美军在伊拉克用的翻译机好卖）建造模式：将产品的内部表象和产品的生成过程分割开来，从而使一个建造过程生成具有不同的内部表象的产品对象。

建造模式使得产品内部表象可以独立的变化，客户不必知道产品内部组成的细节。

建造模式可以强制实行一种分步骤进行的建造过程。

3、FACTORY METHOD—请MM去麦当劳吃汉堡，不同的MM有不同的口味，要每个都记住是一件烦人的事情，我一般采用Factory Method模式，带着MM到服务员那儿，说“要一个汉堡”，具体要什么样的汉堡呢，让MM直接跟服务员说就行了。

工厂方法模式：核心工厂类不再负责所有产品的创建，而是将具体创建的工作交给子类去做，成为一个抽象工厂角色，仅负责给出具体工厂类必须实现的接口，而不接触哪一个产品类应当被实例化这种细节。