设计模式

什么是设计模式？常⽤的设计模式有哪些？设计模式就是经过前⼈⽆数次的实践总结出的，设计过程中可以反复使⽤的、可以解决特定问题的设计⽅法。

单例(饱汉模式、饥汉模式)1、构造⽅法私有化，让出了⾃⼰类中能创建外其他地⽅都不能创建2、在⾃⼰的类中创建⼀个单实例（饱汉模式是⼀出来就创建创建单实例，⽽饥汉模式需要的时候才创建）3、提供⼀个⽅法获取该实例对象(创建时需要进⾏⽅法同步)⼯⼚模式:Spring IOC就是使⽤了⼯⼚模式.对象的创建交给⼀个⼯⼚去创建。

代理模式:Spring AOP就是使⽤的动态代理。

单例设计模式精讲定义：保证⼀个类只有⼀个实例，并且提供⼀个全局访问点场景：线程池，数据库连接池实现⽅式： 1.懒汉模式（只有使⽤的时候，再进⾏初始化，延迟加载） 2.饿汉模式 3.静态内部类 4.反射攻击 6.序列化 7.jdk源码1.懒汉模式实现的写法public class SingletonTest {public static void main(String[] args) {new Thread(new Runnable() {@Overridepublic void run() {LazySingleton lazySingleton = LazySingleton.getInstance();System.out.println(lazySingleton);}}).start();new Thread(new Runnable() {@Overridepublic void run() {LazySingleton lazySingleton = LazySingleton.getInstance();System.out.println(lazySingleton);}}).start();//两个线程打印出来的线程实例是同⼀个，说明是单例}}//使⽤的时候才开始实例化，JVM中⼀个实例class LazySingleton {private volatile static LazySingleton instance;public static LazySingleton getInstance() {if (instance == null) {synchronized (LazySingleton.class) {if (instance == null) {instance = new LazySingleton();}}}return instance;}private LazySingleton() {}}2.饿汉模式在类加载阶段完成了实例的初始化，通过类加载机制来保证线程的安全类的加载过程1加载=》加载对应的⼆进制⽂件，并且在⽅法区创建对应的数据结构连接：a.验证 b.准备 c.解析初始化：给静态属性赋值public class HungrySingletonTest {public static void main(String[] args) {HungrySingleton hungrySingleton = HungrySingleton.getInstance();}}class HungrySingleton {private static HungrySingleton instance = new HungrySingleton();public static HungrySingleton getInstance() {return instance;}private HungrySingleton() { }}3.基于静态内部类的单例public class AntiTest {public static void main(String[] args) throws NoSuchMethodException,IllegalAccessException, InvocationTargetException, InstantiationException{ InnerClassSingleton instance = InnerClassSingleton.getInstance();System.out.println(instance);//抛出异常，单例，不允许有多个实例Constructor<InnerClassSingleton> declaredConstructor = InnerClassSingleton.class.getDeclaredConstructor();declaredConstructor.setAccessible(true);InnerClassSingleton innerClassSingleton = declaredConstructor.newInstance();System.out.println(innerClassSingleton);}}class InnerClassSingleton{static class InnerClass{private static InnerClassSingleton instance = new InnerClassSingleton();}public static InnerClassSingleton getInstance(){return InnerClass.instance;}private InnerClassSingleton(){if ((InnerClass.instance!=null)){throw new RuntimeException("单例类，不允许多个实例！");}}}4.枚举单例public class EnumSingletonTest{public static void main(String[] args) {EnumSingleton instance = EnumSingleton.INSTANCE;EnumSingleton instance1 = EnumSingleton.INSTANCE;System.out.println(instance==instance1);//trueinstance.print();// 149928006instance1.print();// 149928006}}enum EnumSingleton {INSTANCE;public void print(){System.out.println(this.hashCode());}}。

设计模式及其应用场景
设计模式是指在编写一个应用程序时，应该考虑的常见问题的可重复使用的解决方案。

它们是软件设计过程中最重要的工具，并且能够提高程序的可扩展性，可重用性和可维护性。

设计模式的应用场景包括：
1. 工厂模式：工厂模式可用于创建一组相关或依赖对象，通常是使用一个工厂类来管理操作，以避免将创建代码集成到应用程序中。

2. 抽象工厂模式：抽象工厂模式是工厂模式的进一步抽象，它用于创建一组抽象产品对象，而不需要明确指定具体的产品类。

3. 单例模式：单例模式是一种将一个类的实例限制为一个的设计模式，它可以保证一个类只有一个实例，并且该实例易于访问，以满足特定需求。

4. 命令模式：命令模式是一种将动作封装到对象中的设计模式，它将请求、动作（action）和接收者（receiver）分离，从而使得发送者和接收者之间形成解耦。

5. 观察者模式：观察者模式是一种行为设计模式，它允许一个对象（观察者）注册另一个对象（主题）的更改，以便在主题更改时收到通知。

设计模式简答题1．什么是设计模式？设计模式的目标是什么？答：设计模式通常是对于某一类的软件设计问题的可重用的解决方案，将设计模式引入软件设计和开发过程，其目的就在于要充分利用已有的软件开发经验。

2．设计模式具有哪三大特点？答：(1) 在特定的场景下有可重用性，对相同类型不同问题的环境，其解决方案都有效。

(2) 可传授性，即问题出现的机会很多，解决问题的方案相同，人们相对可以接受。

(3) 有表示模式的名称。

3．GOF 设计模式常用的有几种？GOF 设计模式按照模式的目的可分为哪三类？答：行为型，结构型，创建型4．画出抽象工厂方法类图（这类题自己看书去。

）5.针对接口编程，不针对实现编程的意义。

答：主题与观察者都是用接口：观察者利用主题的接口向主题注册，而主题利用观察者接口通知观察者。

这样可以让两者之间运作正常，又同时具有松耦合的优点。

6.面向对象（OO）的原则有：答：1.封装变化2.多用组合，少用继承3.针对接口编程，不针对实现编程4.为交互对象之间的松耦合设计而努力5.对扩展开放，对修改关闭6.依赖抽象，不要依赖具体类7.只和朋友交谈8.别找我，我会找你9.类应该只有一个改变的理由7. 耦合分为几种？(1）内容耦合（2）公共耦合（3）外部耦合（4）控制耦合（5）标记耦合（6）数据耦合（7）非直接耦合8.GOF模式分为几种，每种包含哪些模式？答：分为3种。

创建型设计模式：简单工厂模式，工厂方法模式，抽象工厂模式，建造者模式，原型模式，单例模式；结构型设计模式：适配器模式，桥接模式，组合模式，装饰模式，外观模式，轻量级模式，代理模式；行为性设计模式：责任链模式，命令模式，解释器模式，迭代器模式，中介者模式，备忘录模式，观察者模式，状态模式，策略者模式，模板方法模式，访问者模式。

1．不要和陌生人说话”是(D)原则的通俗表述A．接口隔离B．里氏代换C．依赖倒转D．迪米特2．当一个抽象模型有两个方面，其中一个方面依赖于另一方面，将这两者封装在独立的对象中以使它们可以各自独立地改变和复用，可以考虑使用（A）A．观察者模式B．命令模式C．适配器模式D．单例模式3．对于某些类来说，只有一个实例是非常重要的，例如，系统中可以有都种类型的打印机，但是只能有一个打印机假脱机，只应该一个文件系统和一个窗口管理器，为此，可以使用（C）。

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接口，用于定义排序算法的策略。

23种设计模式考题设计模式是软件开发中常用的解决问题的方法论，它们提供了一套经过验证的解决方案，可以帮助开发者更好地组织和设计代码。

下面是23种常见的设计模式的考题及其回答：1. 单例模式：问，请解释什么是单例模式，并说明它的优缺点。

答，单例模式是一种创建型设计模式，它确保一个类只有一个实例，并提供一个全局访问点。

其优点是可以节省系统资源，提高性能；缺点是可能引入全局状态，使代码难以调试和测试。

2. 工厂模式：问，请解释什么是工厂模式，并列举其主要类型。

答，工厂模式是一种创建型设计模式，它将对象的创建过程封装在一个工厂类中。

主要类型包括简单工厂模式、工厂方法模式和抽象工厂模式。

3. 抽象工厂模式：问，请解释什么是抽象工厂模式，并说明它与工厂方法模式的区别。

答，抽象工厂模式是一种创建型设计模式，它提供一个接口，用于创建一系列相关或依赖对象的家族。

与工厂方法模式不同的是，抽象工厂模式强调创建一系列相关对象，而不是一个对象。

4. 建造者模式：问，请解释什么是建造者模式，并说明它的优势。

答，建造者模式是一种创建型设计模式，它将一个复杂对象的构建过程分解为多个简单的步骤，并通过一个指导者类来控制构建过程。

其优势是可以灵活地构建不同的产品，同时隐藏了产品的内部结构。

5. 原型模式：问，请解释什么是原型模式，并说明它的适用场景。

答，原型模式是一种创建型设计模式，它通过复制现有对象来创建新对象，而不是通过实例化类。

适用场景包括需要创建大量相似对象、对象的创建过程复杂或耗时等情况。

6. 适配器模式：问，请解释什么是适配器模式，并说明它的作用。

答，适配器模式是一种结构型设计模式，它将一个类的接口转换成客户端所期望的另一个接口。

它的作用是使原本不兼容的接口能够协同工作。

7. 桥接模式：问，请解释什么是桥接模式，并说明它与适配器模式的区别。

答，桥接模式是一种结构型设计模式，它将抽象部分与实现部分分离，使它们可以独立地变化。

系统架构设计师23种设计模式记忆口诀设计模式分为三种类型：创建型设计模式（4种：工厂模式（工厂模式、抽象工厂模式）、单例模式、原型模式、建造者模式）主要用户创建对象；创建型：创建模式创对象。

工厂模式要抽象；单例只有一个类；拷贝原型创对象；建造复杂的对象。

解释：创建模式主要用于创建对象。

工厂模式根据业务需要分为简单工厂模式、工厂方法模式和抽象工厂模式；原型模式用于创建重复的对象，通过拷贝这些原型创建新的对象；建造者模式使用多个简单的对象一步一步构建成一个复杂的对象。

------------------------------------------------------------------------------- 结构型设计模式（8种：代理模式、外观模式、装饰器模式、享元模式、组合模式、适配器模式、桥接模式、过滤器）主要关注类和对象的组合；结构型：结构组合类对象。

代理外观装饰器；享元组合适配器；桥接不能过滤器。

代理对象访问者；外观一致的接口；装饰动态添职责；享元共享搞对象。

组合对象像棵树；适配接口能兼容；桥接抽象与实现；不同标准来过滤。

解释：结构型设计模式主要关注类和对象的组合。

主要有代理模式、外观模式、装饰器模式、享元模式、组合模式、适配器模式、桥接模式不能继承，过滤器模式。

代理模式为其他对象提供一种代理以控制对这个对象的访问；外观模式通过为多个复杂的子系统提供一个一致的接口，而使这些子系统更加容易被访问的模式，这是典型的”迪米特原则“；装饰器模式动态地给一个对象添加一些额外的职责；享元模式运用共享技术来有效地支持大量细粒度对象的复用；组合模式将对象组合成树形结构以表示"部分-整体"的层次结构；适配器模式将一个类的接口转换成客户希望的另外一个接口，使得原本由于接口不兼容而不能一起工作的那些类可以一起工作；桥接模式将抽象部分与实现部分分离，使它们都可以独立的变化；过滤器模式允许开发人员使用不同的标准来过滤一组对象，通过逻辑运算以解耦的方式把它们连接起来行为型设计模式（11种：模板模式、策略模式、迭代器模式、中介模式、备忘录模式、解释器模式、观察者模式、访问者模式、状态模式、责任链模式、命令模式）主要关注对象间通信的问题。

什么是设计模式？设计模式（Design Patterns）是在软件设计中被反复使用的经过验证的解决问题的方法。

它们是由计算机科学家和软件工程师们根据他们在实践中的经验总结出来的，旨在解决常见的设计问题，提供可重用的解决方案。

设计模式提供了一种通用的语言和方法，使得开发人员能够更好地沟通、共享和理解彼此的设计思想。

它们可以帮助开发人员遵循面向对象设计的原则，提高代码的可维护性、可扩展性和可重用性。

设计模式通常被分为三个主要类别：创建型模式（Creational Patterns）、结构型模式（Structural Patterns）和行为型模式（Behavioral Patterns）。

1. 创建型模式：创建型模式涉及对象的实例化，提供了创建对象的机制，而不是直接实例化对象。

它们的目标是使系统独立于对象的创建、组合和表示方式，并提供了一种通用的方法来创建对象。

-工厂模式（Factory Pattern）: 通过使用一个公共的接口来创建对象，实现了对象的创建和使用的分离。

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

-单例模式（Singleton Pattern）: 保证一个类只有一个实例，并提供一个全局访问点来访问这个实例。

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

2. 结构型模式：结构型模式涉及类和对象的组合，用于形成更大的结构。

它们的目标是定义类和对象之间的关系，以便更好地组织代码，并提供了一种简化复杂系统的方法。

-适配器模式（Adapter Pattern）: 将一个类的接口转换成客户端期望的另一个接口，从而使得原本不兼容的类可以一起工作。

-装饰器模式（Decorator Pattern）: 动态地给对象添加额外的职责，而不影响其原始类。

面向对象设计的23个设计模式详解面向对象设计是一种广泛应用于软件开发的思想，其核心在于将数据和操作封装在一起形成对象，并通过各种方式进行交互和组合，从而实现复杂的功能。

在这一过程中，设计模式起到了非常重要的作用，可以有效地提高代码的可读性、可维护性和可扩展性。

本文将对23种常见的设计模式进行详解。

一、创建型模式1.简单工厂模式简单工厂模式属于创建型模式，其目的是提供一个工厂类，使得创建对象的过程更加简单。

在这种模式中，使用者只需要提供所需对象的参数，而无需关心对象的具体实现细节。

简单工厂模式适合于对象创建过程较为简单的情况。

2.工厂方法模式工厂方法模式是简单工厂模式的进一步扩展，其核心在于将工厂类进行接口抽象化，使得不同的工厂类可以创建不同的对象实例。

工厂方法模式适合于对象创建过程较为复杂的情况。

它可以为工厂类添加新的产品类型，而不会影响原有的代码。

3.抽象工厂模式抽象工厂模式是工厂方法模式的进一步扩展，其目的是提供一个可以创建一系列相关或者独立的对象的接口。

在抽象工厂模式中，使用者只需要关心所需对象组合的类型，而无需关注对象的具体实现过程。

4.建造者模式建造者模式也是一种创建型模式，其目的在于将复杂对象分解为多个简单的部分，并将其组装起来形成复杂对象实例。

在建造者模式中，使用者只需要关注所需对象以及它们的组合方式，而无需关心对象的具体实现过程。

5.原型模式原型模式是一种基于克隆的创建型模式，其核心在于通过复制现有的对象实例来创建新的对象。

在原型模式中，对象实例的创建过程与对象所包含的状态密切相关。

原型模式适合于创建复杂对象实例，且这些对象实例之间是相对独立的情况。

二、结构型模式6.适配器模式适配器模式是一种结构型模式，其目的在于将一个类的接口转换为另一个类所能使用的接口。

在适配器模式中，使用者可以通过不同的适配器实现对象之间的互相调用。

7.桥接模式桥接模式是一种结构型模式，其目的在于将抽象部分与实现部分相互分离，从而使得两者可以独立变化。

24种设计模式Factory Pattern(⼯⼚模式)：1. 创建对象的接⼝，封装对象的创建；2. 使具体化类的⼯作延迟到⼦类中。

（维护⼀类对象）AbstractFactory Pattern(抽象⼯⼚模型)：该模式将⼀组对象的创建封装到⼀个⽤于创建对象的类中。

（解决的问题：要创建⼀组或者相互依赖的对象）。

Singleton Pattern(单例模式)：该模式在⾯向纯粹的⾯向对象的范式中⽤于创建唯⼀的实例，值得注意的是Singleton不能被实例化，因此将其构造函数声明为protected或private类型。

Singleton Pattern经常与Factory Pattern结合使⽤，因为Factory对象只能有⼀个。

Builder Pattern(创建者模式)：将⼀个复杂的对象的构建与它的表⽰分离，使得同样的构建构成可以创建不同的表⽰。

如建筑师画图纸，⽽⼯⼈建造房屋。

Prototype Pattern(原型模式)：提供⼀个通过已存在对象进⾏新对象创建的接⼝（clone）。

（浅拷贝和深拷贝）Bridge Pattern(桥梁模式)：将抽象部分与实现部分分开实现，使他们都可以独⽴地变化，并使⽤组合的⽅式将多维度的抽象⽅法联系在⼀起。

⽐如咖啡分⼩杯、中杯、⼤杯以及加奶和不加奶，则抽象部分为：⼩杯、中杯、⼤杯，⾏为为：加奶和不加奶。

Adapter Pattern(适配器模式)：适配就是由“源”到“⽬标”的适配，⽽当中链接两者的关系就是适配器。

它负责把“源”过度到“⽬标”。

将⼀个类的接⼝转换成客户希望的另外⼀个接⼝。

Adapter模式使得原本由于接⼝不兼容⽽不能⼀起⼯作的那些类可以⼀起⼯作。

适配器模式分为两种：①⾯向类的设计模式；②⾯向对象的设计模式。

①⾯向类的适配器：该模式使⽤继承和接⼝实现的⽅式复⽤需要适配器的类。

②⾯向对象的适配器：该模式使⽤组合的⽅式实现需要复⽤的类。

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

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架构；银⾏⽇志管理：格式分类：操作⽇志、交易⽇志、异常⽇志距离分类：本地记录⽇志、异地记录⽇志⼈⼒资源系统中的奖⾦计算模块：奖⾦分类：个⼈奖⾦、团体奖⾦、激励奖⾦。

设计模式的分类设计模式是一种被广泛应用于软件工程领域的最佳实践，它为软件开发提供了一种适用于特定情境下的可重用解决方案，能够提高软件系统的可维护性、可扩展性和可重用性。

设计模式可以分为三大类：创建型模式、结构型模式和行为型模式。

一、创建型模式1. 单例模式单例模式是一种创建型模式，用于确保一个类只有一个实例，并提供全局访问点。

单例模式适用于那些需要唯一的对象来协调系统操作的情况，如配置管理器、日志记录器等。

实现单例模式的方法有饿汉式和懒汉式，其中饿汉式在类加载时就创建了实例，而懒汉式在第一次使用时才创建实例。

2. 工厂模式工厂模式是一种创建型模式，用于将对象的创建过程封装在一个工厂类中，并通过调用工厂类的方法来创建对象。

工厂模式适用于那些需要根据不同条件创建不同对象的情况，如数据库连接池。

实现工厂模式的方法有简单工厂模式、工厂方法模式和抽象工厂模式，其中简单工厂模式将对象的创建过程封装在一个工厂类的静态方法中，而工厂方法模式和抽象工厂模式则通过定义一个抽象的工厂类和具体的工厂类来实现。

3. 原型模式原型模式是一种创建型模式，用于通过克隆（深拷贝或浅拷贝）已有对象来创建新的对象，而不是通过调用构造函数创建。

原型模式适用于那些需要创建大量相似对象的情况，如游戏中的敌人。

实现原型模式的方法有浅拷贝和深拷贝，其中浅拷贝只复制对象的基本类型属性，而深拷贝则复制对象的所有属性。

二、结构型模式1. 适配器模式适配器模式是一种结构型模式，用于将一个类的接口转换成客户端所期望的另一个接口，从而使原本不兼容的类能够协同工作。

适配器模式适用于那些需要使用已有的类库或接口，但这些类库或接口与当前系统不兼容的情况，如国际化（I18N）处理。

实现适配器模式的方法有类适配器模式和对象适配器模式，其中类适配器模式通过多继承实现，而对象适配器模式通过组合实现。

2. 装饰器模式装饰器模式是一种结构型模式，用于动态地给对象添加功能，而不需要修改对象的代码。

十种常用的设计模式设计模式是在软件开发中经过实践总结出来的一套解决特定问题的模板。

它们提供了一种在软件设计中重用的方式，可以提高代码的可维护性、复用性和灵活性。

本文将介绍十种常用的设计模式，分别是单例模式、工厂模式、抽象工厂模式、建造者模式、原型模式、适配器模式、装饰器模式、代理模式、观察者模式和策略模式。

1. 单例模式单例模式确保某个类只有一个实例，并提供一个全局访问点。

它常用于数据库连接、日志记录器等需要唯一实例的场景。

单例模式可以通过私有化构造函数、静态方法和静态变量来实现。

2. 工厂模式工厂模式将对象的创建与使用分离，通过一个工厂类来创建对象。

工厂模式可以隐藏具体对象的实现细节，提供一个统一的接口来创建对象。

它常用于创建复杂对象或者需要根据条件来动态创建对象的场景。

3. 抽象工厂模式抽象工厂模式提供一个接口来创建一系列相关或依赖的对象，而不需要指定具体的类。

抽象工厂模式可以为客户端提供一组相互关联的产品，而不需要关心具体的实现细节。

它常用于创建一系列产品族的场景。

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

建造者模式可以通过一步一步地构建对象，灵活地组合各个部分来构建复杂的对象。

它常用于创建复杂的对象，尤其是对象的构建过程比较复杂的场景。

5. 原型模式原型模式通过复制现有对象来创建新的对象，而不需要通过调用构造函数来创建。

原型模式可以提高对象的创建效率，避免重复创建相似的对象。

它常用于创建成本较高的对象或者需要创建大量相似对象的场景。

6. 适配器模式适配器模式将一个类的接口转换成客户端所期望的另一个接口，使得原本不兼容的类可以一起工作。

适配器模式可以用来解决接口不兼容或者需要复用现有类的情况。

它常用于系统间接口的转换和现有类的复用。

7. 装饰器模式装饰器模式动态地给一个对象添加额外的职责，同时又不改变其接口。

装饰器模式可以在不修改原有对象的情况下，通过对对象进行包装来扩展其功能。