中级：设计模式面试题全解析

一、引言

设计模式是解决软件设计中常见问题的通用模板，它们总结了经验丰富的软件开发者的最佳实践。在面试中，设计模式相关的问题旨在考察候选人是否具备良好的软件设计思想和模式应用能力，这对于开发高质量、可维护的软件系统至关重要。本文将深入剖析常见的设计模式面试题，结合实际开发场景，帮助读者全面掌握这些知识点。

二、单例模式

1. 面试题：什么是单例模式？如何实现线程安全的单例模式？
   • 答案 ：单例模式是一种创建型设计模式，确保一个类只有一个实例，并提供一个全局访问点。实现线程安全的单例模式可以通过双重检查锁定（Double-Check Locking）的方式，在实例化对象时进行同步控制。
   • 代码示例 ：

     • public class Singleton {
           private static volatile Singleton instance;
       
           private Singleton() {
           }
       
           public static Singleton getInstance() {
               if (instance == null) {
                   synchronized (Singleton.class) {
                       if (instance == null) {
                           instance = new Singleton();
                       }
                   }
               }
               return instance;
           }
       }
       

   • 踩坑经验 ：在实现单例模式时，需要注意线程安全问题，尤其是在多线程环境下。使用双重检查锁定可以避免同步方法带来的性能开销，同时确保线程安全。

三、工厂模式

1. 面试题：什么是工厂模式？工厂模式有哪些类型？
   • 答案 ：工厂模式是一种创建型设计模式，用于创建对象而不暴露创建逻辑。工厂模式主要有简单工厂模式、工厂方法模式和抽象工厂模式。
   • 代码示例（简单工厂模式） ：

     • public class SimpleFactory {
           public static Product createProduct(String type) {
               if ("A".equals(type)) {
                   return new ProductA();
               } else if ("B".equals(type)) {
                   return new ProductB();
               }
               return null;
           }
       }
       
       interface Product {
           void show();
       }
       
       class ProductA implements Product {
           public void show() {
               System.out.println("ProductA");
           }
       }
       
       class ProductB implements Product {
           public void show() {
               System.out.println("ProductB");
           }
       }
       
       public class FactoryTest {
           public static void main(String[] args) {
               Product product = SimpleFactory.createProduct("A");
               product.show();
           }
       }
       

   • 踩坑经验 ：简单工厂模式将对象的创建集中在一个工厂类中，但当产品类型较多时，工厂类可能会变得臃肿。工厂方法模式和抽象工厂模式则可以更好地解决这个问题，通过将创建对象的责任分散到各个子类中。

四、策略模式

1. 面试题：什么是策略模式？策略模式的优缺点是什么？
   • 答案 ：策略模式是一种行为型设计模式，定义一系列算法，把它们封装起来，使它们可以互相替换。策略模式的优点是可以动态地选择算法，增加新的算法方便；缺点是客户端需要了解不同的算法，选择合适的策略。
   • 代码示例 ：

     • interface Strategy {
           int calculate(int a, int b);
       }
       
       class AddStrategy implements Strategy {
           public int calculate(int a, int b) {
               return a + b;
           }
       }
       
       class SubtractStrategy implements Strategy {
           public int calculate(int a, int b) {
               return a - b;
           }
       }
       
       class Context {
           private Strategy strategy;
       
           public Context(Strategy strategy) {
               this.strategy = strategy;
           }
       
           public int executeStrategy(int a, int b) {
               return strategy.calculate(a, b);
           }
       }
       
       public class StrategyTest {
           public static void main(String[] args) {
               Context context = new Context(new AddStrategy());
               System.out.println(context.executeStrategy(10, 5)); // 输出15
       
               context = new Context(new SubtractStrategy());
               System.out.println(context.executeStrategy(10, 5)); // 输出5
           }
       }
       

   • 踩坑经验 ：在使用策略模式时，需要注意策略类的设计，确保每个策略类都具有相同的接口或抽象类作为基础。此外，当策略种类较多时，可以结合工厂模式来创建策略对象。

五、观察者模式

1. 面试题：什么是观察者模式？如何实现观察者模式？
   • 答案 ：观察者模式是一种行为型设计模式，定义对象间一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都得到通知并自动更新。在Java中，可以通过实现Observable类和Observer接口来实现观察者模式。
   • 代码示例 ：

     • import java.util.Observable;
       import java.util.Observer;
       
       class Subject extends Observable {
           private String state;
       
           public void setState(String state) {
               this.state = state;
               setChanged();
               notifyObservers();
           }
       
           public String getState() {
               return state;
           }
       }
       
       class Observer1 implements Observer {
           public void update(Observable o, Object arg) {
               Subject subject = (Subject) o;
               System.out.println("Observer1: " + subject.getState());
           }
       }
       
       class Observer2 implements Observer {
           public void update(Observable o, Object arg) {
               Subject subject = (Subject) o;
               System.out.println("Observer2: " + subject.getState());
           }
       }
       
       public class ObserverTest {
           public static void main(String[] args) {
               Subject subject = new Subject();
               subject.addObserver(new Observer1());
               subject.addObserver(new Observer2());
       
               subject.setState("状态改变");
           }
       }
       

   • 踩坑经验 ：在使用观察者模式时，需要注意被观察者和观察者之间的解耦，确保被观察者不需要知道观察者的具体实现。此外，当有多个观察者时，需要注意通知的顺序和线程安全问题。

六、总结

设计模式是软件开发中的重要知识，面试中对设计模式的考察主要集中在单例模式、工厂模式、策略模式、观察者模式等常用模式上。通过本文的学习，读者可以深入理解这些设计模式的概念、实现方法以及优缺点，并通过代码示例掌握其实际应用。在实际开发中，合理运用设计模式可以提高代码的可维护性、可扩展性和复用性。

如果你觉得这篇文章对你有帮助，欢迎点赞、评论和关注，我会持续输出更多优质的技术内容。