当前位置：首页 > news >正文

设计模式-面试题

news 来源：原创 2025/7/20 11:35:27

摘要：
1、通俗易懂，适合小白
2、仅做面试复习用，部分来源网络，博文免费，知识无价，侵权请联系！

1. 什么是设计模式？

设计模式是在软件开发过程中，针对反复出现的问题所总结归纳出的通用解决方案。它就像是建筑领域里的经典建筑结构，能帮助开发者更高效、更合理地组织代码，提升软件的可维护性、可扩展性和可复用性。

2. 为什么要使用设计模式？

可维护性：设计模式使代码结构更清晰，模块职责更明确，便于理解和修改代码。
可扩展性：能轻松应对需求变化，在不破坏原有系统结构的前提下添加新功能。
可复用性：模式中的代码结构和逻辑可在不同项目或模块中重复使用，减少重复开发。

3. 设计模式有多少种，都有哪些设计模式？

设计模式一般分为三种类型，共 23 种：

创建型模式（5 种）：单例模式、工厂方法模式、抽象工厂模式、建造者模式、原型模式。
结构型模式（7 种）：代理模式、适配器模式、装饰器模式、桥接模式、组合模式、外观模式、享元模式。
行为型模式（11 种）：策略模式、模板方法模式、观察者模式、迭代子模式、责任链模式、命令模式、备忘录模式、状态模式、访问者模式、中介者模式、解释器模式。

4. 设计模式的六大原则是什么？

单一职责原则（SRP）：一个类应该只负责一项职责，避免一个类承担过多功能。
里氏替换原则（LSP）：所有引用基类的地方必须能透明地使用其子类对象，子类可扩展父类功能，但不能改变父类原有功能的语义。
依赖倒置原则（DIP）：高层模块不应该依赖低层模块，二者都应该依赖抽象；抽象不应该依赖细节，细节应该依赖抽象。
接口隔离原则（ISP）：客户端不应该依赖它不需要的接口，一个类对另一个类的依赖应该建立在最小的接口上。
迪米特法则（LoD）：一个对象应该对其他对象保持最少的了解，降低对象之间的耦合度。
开闭原则（OCP）：软件实体（类、模块、函数等）应该对扩展开放，对修改关闭。

5. 什么是高内聚、低耦合？

高内聚：指一个模块内的各个元素之间联系紧密，完成单一且明确的功能。比如一个用户信息处理模块，只专注于用户信息的增删改查等相关操作，模块内代码围绕这一核心功能紧密协作。
低耦合：模块与模块之间相互依赖程度低，一个模块的修改不会或很少影响其他模块。例如用户模块和订单模块，二者相对独立，用户模块的业务逻辑变化基本不影响订单模块。

6. 什么是单例模式？

单例模式是一种创建型设计模式，确保一个类只有一个实例，并提供全局访问点。比如在数据库连接管理中，整个应用程序只需一个数据库连接实例，通过单例模式可以保证在任何地方获取到的都是同一个数据库连接对象。

7. 单例模式中俄汉式和懒汉式有什么区别？

饿汉式：类加载时就创建实例，线程安全。因为在类初始化阶段实例就已创建，不存在多线程并发创建的问题。例如：

public class EagerSingleton {private static final EagerSingleton instance = new EagerSingleton();private EagerSingleton() {}public static EagerSingleton getInstance() {return instance;}}

懒汉式：在第一次调用获取实例方法时才创建实例。但在多线程环境下若不做同步处理会出现多个实例的问题，所以通常需要加锁保证线程安全。比如：

public class LazySingleton {private static LazySingleton instance;private LazySingleton() {}public static synchronized LazySingleton getInstance() {if (instance == null) {instance = new LazySingleton();}return instance;}}

8. 单例模式都有哪些应用场景？

日志记录器：整个应用程序只需一个日志记录器实例，用于统一记录日志信息。
配置管理器：管理应用程序的配置信息，保证各处获取的配置一致。
数据库连接池：维护一个数据库连接池实例，供多个模块复用数据库连接。

9. 什么是代理模式？

代理模式是一种结构型设计模式，为其他对象提供一种代理以控制对这个对象的访问。代理对象和目标对象实现相同接口，客户端通过代理对象间接访问目标对象。比如在网络访问中，代理服务器可以代替客户端去访问目标网站，在访问前可以进行权限检查、缓存处理等操作。

10. Java 中代理模式如何实现静态代理？

静态代理需要代理类和目标类实现相同接口，在代理类中持有目标类对象，通过构造函数传入。示例代码如下：

// 定义接口interface Subject {void request();}// 目标类class RealSubject implements Subject {@Overridepublic void request() {System.out.println("RealSubject handling request");}}// 代理类class Proxy implements Subject {private RealSubject realSubject;public Proxy(RealSubject realSubject) {this.realSubject = realSubject;}@Overridepublic void request() {System.out.println("Proxy pre - processing");realSubject.request();System.out.println("Proxy post - processing");}}

使用时：

RealSubject realSubject = new RealSubject();Proxy proxy = new Proxy(realSubject);proxy.request();

11. Java 中代理模式如何实现动态代理？

Java 动态代理通过 java.lang.reflect.Proxy 和 InvocationHandler 接口实现。步骤如下：

定义目标接口和目标类。
实现 InvocationHandler 接口，在 invoke 方法中编写代理逻辑，处理目标方法调用。
使用 Proxy.newProxyInstance 方法创建代理对象。示例代码：

// 目标接口interface Subject {void request();}// 目标类class RealSubject implements Subject {@Overridepublic void request() {System.out.println("RealSubject handling request");}}// 实现InvocationHandlerclass MyInvocationHandler implements InvocationHandler {private Object target;public MyInvocationHandler(Object target) {this.target = target;}@Overridepublic Object invoke(Object proxy, Method method, Object\[] args) throws Throwable {System.out.println("Dynamic proxy pre - processing");Object result = method.invoke(target, args);System.out.println("Dynamic proxy post - processing");return result;}}// 创建动态代理对象Subject realSubject = new RealSubject();Subject proxy = (Subject) Proxy.newProxyInstance(realSubject.getClass().getClassLoader(),realSubject.getClass().getInterfaces(),new MyInvocationHandler(realSubject));proxy.request();

12. Java 中什么是解释器模式？

解释器模式是一种行为型设计模式，给定一个语言，定义它的文法的一种表示，并定义一个解释器，这个解释器使用该表示来解释语言中的句子。在 Java 中，比如表达式解析场景，通过定义文法规则和解释器来解析并计算表达式的值。

13. Java 中如何实现解释器模式？

定义抽象表达式类，声明解释方法 interpret。
实现终结符表达式类和非终结符表达式类，分别对应文法中的终结符和非终结符，实现 interpret 方法。
客户端调用解释器进行表达式解释。示例代码（简单算术表达式解释）：

// 抽象表达式abstract class Expression {public abstract int interpret();}// 终结符表达式（数字）class NumberExpression extends Expression {private int number;public NumberExpression(int number) {this.number = number;}@Overridepublic int interpret() {return number;}}// 非终结符表达式（加法）class AddExpression extends Expression {private Expression left;private Expression right;public AddExpression(Expression left, Expression right) {this.left = left;this.right = right;}@Overridepublic int interpret() {return left.interpret() + right.interpret();}}// 客户端调用Expression expression = new AddExpression(new NumberExpression(3), new NumberExpression(4));int result = expression.interpret();System.out.println("Result: " + result);

14. Java 中什么是替换法则（LSP）?

里氏替换原则（LSP）规定，所有引用基类的地方必须能透明地使用其子类对象。子类必须能够完全替代父类，且在替换后程序的正确性和行为不能被改变。子类可以扩展父类功能，但不能改变父类方法的前置条件和后置条件。

15. Java 中为什么不允许从静态方法中访问非静态变量？

静态方法属于类本身，在类加载时就存在，不依赖于类的实例。而非静态变量属于类的实例，只有在创建对象后才存在。如果允许静态方法访问非静态变量，就会出现静态方法执行时非静态变量可能还未初始化的情况，导致逻辑错误和内存问题。

16. 微服务架构的六种常用设计模式是什么？

服务发现模式：解决微服务实例的注册与发现问题，如使用 Eureka、Consul 等组件，让客户端能找到服务实例的地址。
断路器模式：防止服务调用中出现级联故障，当目标服务调用失败率达到一定阈值时，断路器自动断开，不再调用目标服务，避免消耗过多资源。
负载均衡模式：将请求均匀分配到多个服务实例上，提高系统的可用性和性能，常见的有 Nginx 负载均衡、Ribbon 负载均衡等。
API 网关模式：作为微服务的统一入口，负责请求路由、认证授权、流量控制等，对客户端隐藏内部微服务细节。
事件溯源模式：通过记录系统所有状态变化的事件，按顺序回放事件来重建系统状态，常用于需要追踪历史操作和审计的场景。
命令查询职责分离（CQRS）模式：将读操作（查询）和写操作（命令）分离，分别设计不同的接口和逻辑，提高系统的可扩展性和性能。

17. Java 中单例模式有什么优缺点？

优点
- 资源利用率高：避免频繁创建和销毁对象，像数据库连接单例，减少连接创建开销。
- 全局访问方便：提供全局唯一访问点，便于在不同模块获取同一实例。
缺点
- 扩展性差：不利于继承和扩展，修改单例类可能影响整个应用。
- 不利于测试：单例实例可能在测试前就已创建，难以进行单元测试隔离。
- 线程安全问题（懒汉式）：如果不处理好，懒汉式在多线程环境下可能创建多个实例。

18. Java 中单例模式使用时有哪些注意事项？

线程安全：如果是懒汉式单例，要确保在多线程环境下的线程安全，可通过同步锁或静态内部类等方式实现。
防止反射攻击：重写单例类的构造函数，防止通过反射创建多个实例。
序列化和反序列化：如果单例类实现了 Serializable 接口，要处理好序列化和反序列化过程，保证反序列化后还是同一个实例。

19. Java 中单例模式如何防止反射漏洞攻击？

在单例类的构造函数中添加判断逻辑，当发现已经创建过实例时，抛出异常阻止通过反射创建新实例。示例代码：

public class Singleton {private static Singleton instance;private Singleton() {if (instance != null) {throw new RuntimeException("Singleton instance already exists");}}public static Singleton getInstance() {if (instance == null) {instance = new Singleton();}return instance;}}

20. 什么是工厂模式？

工厂模式是一种创建型设计模式，它提供了一种创建对象的方式，将对象的创建和使用分离。通过工厂类来负责创建对象，调用者只需要关心如何使用对象，而不需要了解对象的创建细节。

21. Java 中工厂模式有什么优势？

解耦创建和使用：使代码的依赖关系更清晰，创建对象的逻辑集中在工厂类，使用方无需知道创建细节。
提高可维护性和可扩展性：如果创建对象的逻辑发生变化，只需要修改工厂类，不影响使用对象的其他代码。新增对象类型时，只需在工厂类中添加相应创建逻辑。
便于代码复用：工厂类可以被多个地方复用，提高代码复用率。

22. 说说你理解的 Spring 中工厂模式？

在 Spring 框架中，工厂模式广泛应用于 Bean 的创建。比如 BeanFactory 就是一个工厂，它负责根据配置信息创建和管理 Bean 实例。开发者通过配置文件或注解定义 Bean 的信息，BeanFactory 按照这些信息来创建 Bean，将对象的创建和使用分离，同时 Spring 还提供了 FactoryBean 接口，允许开发者自定义 Bean 的创建逻辑，进一步增强了创建对象的灵活性。

23. 为什么 Spring IOC 要使用工厂模式创建 Bean?

实现解耦：将 Bean 的创建逻辑从使用它的代码中分离出来，降低组件之间的耦合度。例如一个业务组件依赖其他服务组件，通过 IOC 容器（基于工厂模式）创建和注入服务组件，业务组件无需关心服务组件的创建细节。
便于管理和配置：IOC 容器可以统一管理 Bean 的生命周期、作用域等，通过配置文件或注解就能灵活配置 Bean 的创建方式、依赖关系等，方便应用程序的维护和扩展。
支持依赖注入：工厂模式为依赖注入提供了基础，能方便地将依赖的对象注入到目标对象中，实现对象之间的协作。

24. Java 中工厂模式分为哪几大类？

Java 中工厂模式主要分为三类：

简单工厂模式：简单工厂不是一种标准的设计模式，它是工厂方法模式的简化。有一个工厂类，根据传入的参数决定创建哪个具体产品类的实例。
工厂方法模式：定义一个用于创建对象的接口，让子类决定实例化哪一个类。工厂方法使一个类的实例化延迟到其子类。
抽象工厂模式：提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。

25. Java 中什么是简单工厂模式？

简单工厂模式有一个工厂类，它根据传入的参数来决定创建哪个具体产品类的实例。工厂类有一个创建对象的方法，该方法通常是静态的，通过条件判断（如 switch - case 语句）根据不同参数创建不同产品对象。例如创建不同类型的图形对象：

// 产品接口interface Shape {void draw();}// 具体产品类：圆形class Circle implements Shape {@Overridepublic void draw() {System.out.println("Drawing a circle");}}// 具体产品类：矩形class Rectangle implements Shape {@Overridepublic void draw() {System.out.println("Drawing a rectangle");}}// 简单工厂类class ShapeFactory {public static Shape createShape(String type) {if ("circle".equalsIgnoreCase(type)) {return new Circle();} else if ("rectangle".equalsIgnoreCase(type)) {return new Rectangle();}return null;}}

使用时：

Shape circle = ShapeFactory.createShape("circle");circle.draw();

26. Java 中简单工厂模式有什么优缺点？

优点
- 实现简单：工厂类集中了对象创建逻辑，使用方只需传入参数就能获取对象，代码简洁易懂。
- 解耦创建和使用：将对象创建和使用分离，提高了代码的可维护性。
缺点
- 不符合开闭原则：当需要新增产品类型时，需要修改工厂类的创建逻辑（如添加 switch - case 分支），违反了开闭原则。
- 职责过重：工厂类承担了所有对象的创建逻辑，当产品类型过多时，工厂类会变得复杂难以维护。

27. Java 中什么是工厂方法模式？

工厂方法模式定义一个用于创建对象的接口（抽象工厂方法），让子类决定实例化哪一个类。抽象工厂类声明抽象的工厂方法，具体工厂子类实现该方法来创建具体产品对象。比如：

// 产品接口interface Product {void operation();}// 具体产品类Aclass ConcreteProductA implements Product {@Overridepublic void operation() {System.out.println("ConcreteProductA operation");}}// 具体产品类Bclass ConcreteProductB implements Product {@Overridepublic void operation() {System.out.println("

51. Java 中什么是策略模式？

策略模式是一种行为型设计模式，它定义了一系列算法，将每个算法封装起来，并使它们可以相互替换。在 Java 中，通常是定义一个策略接口，不同的具体策略类实现该接口，从而实现不同的算法逻辑。这样做可以让使用算法的客户端在运行时动态选择不同的策略，而无需修改客户端代码本身。

52. Java 中策略模式有什么应用场景？

电商促销：在电商系统中，不同的促销活动（如满减、打折、赠品等）可以用策略模式实现。系统根据不同的活动规则选择对应的促销策略，方便活动的添加、修改和替换。
支付方式：支付模块中，多种支付方式（如微信支付、支付宝支付、银行卡支付等）可以分别封装成不同策略，客户端根据用户选择调用相应支付策略。
排序算法：在需要进行排序的场景中，不同的排序算法（冒泡排序、快速排序、归并排序等）可以实现为策略，根据实际需求（数据规模、数据特点等）选择合适的排序策略。

53. Java 中策略模式有什么优缺点？

优点
- 可维护性和可扩展性高：每个策略算法独立封装，新增或修改算法只需在对应的策略类中操作，不影响其他部分。
- 复用性好：具体策略类可以在不同场景下被复用。
- 符合开闭原则：可以在不修改原有代码的情况下，添加新的策略。
缺点
- 策略类数量可能过多：当算法较多时，会产生大量的策略类，增加代码管理难度。
- 客户端需要了解策略细节：客户端需要知道有哪些策略可供选择，增加了使用成本。

54. Java 中如何实现策略模式？

定义策略接口，声明算法方法。例如：

interface Strategy {int execute(int num1, int num2);}

实现具体策略类。比如加法策略和乘法策略：

class AdditionStrategy implements Strategy {@Overridepublic int execute(int num1, int num2) {return num1 + num2;}}class MultiplicationStrategy implements Strategy {@Overridepublic int execute(int num1, int num2) {return num1 \* num2;}}

创建上下文类，持有策略对象，并提供设置策略和执行策略的方法：

class Context {private Strategy strategy;public Context(Strategy strategy) {this.strategy = strategy;}public void setStrategy(Strategy strategy) {this.strategy = strategy;}public int executeStrategy(int num1, int num2) {return strategy.execute(num1, num2);}}

客户端使用：

Context context = new Context(new AdditionStrategy());int result = context.executeStrategy(3, 4);System.out.println(result);context.setStrategy(new MultiplicationStrategy());result = context.executeStrategy(3, 4);System.out.println(result);

55. Java 中什么是观察者模式？

观察者模式是一种行为型设计模式，它定义了对象之间的一对多依赖关系，当一个对象（被观察者）的状态发生改变时，所有依赖它的对象（观察者）都会得到通知并自动更新。在 Java 中，被观察者通常维护一个观察者列表，当自身状态改变时，遍历列表通知所有观察者。

56. Java 中实现观察者模式有哪两种方式？

**基于 JDK 内置的 java.util.Observer 和 **java.util.Observable ：Observable 类是被观察者的基类，它提供了添加、删除观察者以及通知观察者的方法。Observer 接口是观察者需要实现的接口，其中 update 方法用于接收被观察者的通知并进行处理。
自定义实现：不依赖 JDK 内置类，自己定义被观察者接口和实现类、观察者接口和实现类。被观察者接口中定义注册、注销观察者以及通知观察者的方法，观察者接口定义接收通知的方法。

57. Java 中观察者模式有什么应用场景？

事件监听：在图形界面编程中，按钮点击、窗口关闭等事件可以用观察者模式实现。组件作为被观察者，监听器作为观察者，当组件状态改变（如按钮被点击）时通知监听器。
消息推送：消息中心作为被观察者，订阅者作为观察者。当有新消息产生时，消息中心通知所有订阅者。
股市行情系统：股票价格作为被观察者，股民客户端作为观察者。当股票价格变动时，通知股民客户端更新行情。

58. Java 中如何实现观察者模式？

基于 JDK 内置的实现方式：

被观察者继承 Observable 类：

import java.util.Observable;class StockPrice extends Observable {private double price;public double getPrice() {return price;}public void setPrice(double price) {this.price = price;setChanged();notifyObservers(price);}}

观察者实现 Observer 接口：

import java.util.Observable;import java.util.Observer;class Investor implements Observer {@Overridepublic void update(Observable o, Object arg) {if (o instanceof StockPrice) {double newPrice = (double) arg;System.out.println("Stock price updated to: " + newPrice);}}}

客户端使用：

StockPrice stockPrice = new StockPrice();Investor investor = new Investor();stockPrice.addObserver(investor);stockPrice.setPrice(100.0);

自定义实现方式：

定义被观察者接口：

interface Subject {void registerObserver(Observer observer);void removeObserver(Observer observer);void notifyObservers(Object arg);}

实现被观察者类：

class WeatherStation implements Subject {private java.util.ArrayList\<Observer> observers = new java.util.ArrayList<>();private String weather;@Overridepublic void registerObserver(Observer observer) {observers.add(observer);}@Overridepublic void removeObserver(Observer observer) {observers.remove(observer);}@Overridepublic void notifyObservers(Object arg) {for (Observer observer : observers) {observer.update(arg);}}public void setWeather(String weather) {this.weather = weather;notifyObservers(weather);}}

定义观察者接口：

interface Observer {void update(Object arg);}

实现观察者类：

class Citizen implements Observer {@Overridepublic void update(Object arg) {if (arg instanceof String) {String weather = (String) arg;System.out.println("Weather updated: " + weather);}}}

客户端使用：

WeatherStation weatherStation = new WeatherStation();Citizen citizen = new Citizen();weatherStation.registerObserver(citizen);weatherStation.setWeather("Sunny");

59. Java 中解释器模式有什么优点？

可扩展性好：如果需要支持新的文法规则，只需要新增对应的终结符或非终结符表达式类，符合开闭原则。
语法分析和解释分离：将语言的语法定义和解释执行过程分离，使得代码结构清晰，便于理解和维护。
重用性高：表达式类可以在不同的解释场景中复用，只要符合相同的文法规则。

60. Java 中什么是适配器模式？

适配器模式是一种结构型设计模式，它将一个类的接口转换成客户希望的另一个接口，使原本由于接口不兼容而不能一起工作的那些类可以一起工作。在 Java 中，通常有类适配器和对象适配器两种实现方式，分别通过继承和组合的方式来实现接口转换。

61. Java 中适配器模式有什么应用场景？

第三方库整合：当引入第三方库时，如果第三方库的接口与现有系统接口不兼容，可使用适配器模式进行适配。比如一个支付系统要接入新的支付渠道，该渠道接口与现有系统接口不同，通过适配器模式可让新渠道融入现有系统。
旧系统升级：在对旧系统进行升级改造时，不改变旧系统代码的情况下，使用适配器模式适配新的接口要求，使旧系统能与新系统协同工作。
不同数据库操作：不同数据库的操作接口可能不同，使用适配器模式可以将不同数据库的操作接口适配成统一的操作接口，方便上层应用调用。

62. Java 中适配器模式有什么优缺点？

优点
- 提高兼容性：解决了不兼容接口之间的问题，使原本不能协同工作的类可以一起工作。
- 增强可维护性和可扩展性：将适配逻辑封装在适配器类中，不影响原有类的代码，后续如果接口变化，只需修改适配器类。
- 符合开闭原则：在不修改原有代码的基础上，通过添加适配器类实现功能扩展。
缺点
- 增加代码复杂度：引入了额外的适配器类，使代码结构变得复杂，增加了理解和维护成本。
- 过多使用可能导致混乱：如果系统中大量使用适配器模式，会使系统的接口关系变得混乱，难以理清。

63. Java 中实现适配器模式有几种方式？

类适配器：通过继承需要适配的类，同时实现目标接口来完成适配。它利用了继承的特性，在 Java 中一个类只能继承一个父类，这是类适配器的限制之一。
对象适配器：通过在适配器类中组合一个被适配类的对象，然后实现目标接口，在接口方法实现中调用被适配类对象的方法，实现接口转换。对象适配器更符合组合优于继承的原则，使用更为灵活。

64. Java 中如何实现类的适配器模式？

假设存在一个被适配类 Adaptee ，它有一个方法 specificRequest ，目标接口 Target 有一个方法 request ，实现类适配器如下：

// 被适配类class Adaptee {public void specificRequest() {System.out.println("Adaptee specific request");}}// 目标接口interface Target {void request();}// 类适配器class ClassAdapter extends Adaptee implements Target {@Overridepublic void request() {specificRequest();}}

客户端使用：

Target adapter = new ClassAdapter();adapter.request();

65. Java 中如何实现对象的适配器模式？

还是以上面的 Adaptee 和 Target 为例，实现对象适配器：

// 被适配类class Adaptee {public void specificRequest() {System.out.println("Adaptee specific request");}}// 目标接口interface Target {void request();}// 对象适配器class ObjectAdapter implements Target {private Adaptee adaptee;public ObjectAdapter(Adaptee adaptee) {this.adaptee = adaptee;}@Overridepublic void request() {adaptee.specificRequest();}}