程序员面试知识点超全整理之设计模式

原创不易，如果需要转载请附上本连接

设计模式

创建型：涉及到将对象实例化，和类模式都提供一个方法，将客户从需要实例化的对象中解耦出来

行为型：只要是行为型模式，都涉及到类和对象如何交互及分配职责

结构型：结构型模式可以让你把类或对象组合到更大的结构中

创建型

1. 单例模式

单例模式是一种常用的设计模式，主要指在程序运行过程中，一个类有且仅有一个实例，并且向外提供获取该实例的接口

实现单例模式有三个要点：

1. 类只能有一个实例
2. 类自行创建这个实例
3. 类自行向整个系统提供这个实例

#include <iostream>

class Singleton
{
private:
    Singleton() { std::cout << "Constructor!" << std::endl; };
    Singleton(Singleton&) = delete;
    Singleton& operator=(const Singleton&) = delete;
public:
    ~Singleton() { std::cout << "Destructor!" << std::endl; };
    static Singleton& instance()
    {
        static Singleton ins;//静态局部变量，内存中只有一个，且只会被初始化一次
        return ins;
    }
    void Fun() { std::cout << "Fun" << std::endl; };//其他公有接口
};

深入理解设计模式（一）：单例模式
静态变量和单例模式
关于与单例与采用静态变量引用一个对象的区别

---

2. 简单工厂模式

简单工厂模式又称为静态工厂模式，实质是由一个工厂类根据传入的参数，动态决定应该创建哪一个产品类（这些产品类继承自一个父类或接口）的实例。简单工厂模式的创建目标，所有创建的对象都是充当这个角色的某个具体类的实例

其实就是将一个具体类的实例化交给一个静态工厂方法来执行，它不属于GOF的23种设计模式，但现实中却经常会用到，而且思想也非常简单

public class RuleConfigParserFactory {
  private static final Map<String, RuleConfigParser> cachedParsers = new HashMap<>();

  static {
    cachedParsers.put("json", new JsonRuleConfigParser());
    cachedParsers.put("xml", new XmlRuleConfigParser());
    cachedParsers.put("yaml", new YamlRuleConfigParser());
    cachedParsers.put("properties", new PropertiesRuleConfigParser());
  }

  public static IRuleConfigParser createParser(String configFormat) {
    if (configFormat == null || configFormat.isEmpty()) {
      return null;//返回null还是IllegalArgumentException全凭你自己说了算
    }
    IRuleConfigParser parser = cachedParsers.get(configFormat.toLowerCase());
    return parser;
  }
}

工厂模式–简单工厂模式
深入理解设计模式（二）：简单工厂模式

---

行为型

3. 模板方法模式

模板方法模式 在一个方法中定义一个算法的骨架，而将一些步骤的实现延迟到子类中。模板方法使得子类可以在不改变算法结构的情况下，重新定义算法中某些步骤的具体实现

模板方法模式（Template Method Pattern） 实际上是封装了一个固定流程，该流程由几个步骤组成，具体步骤可以由子类进行不同实现，从而让固定的流程产生不同的结果

模板方法模式 非常简单，其实就是类的继承机制，但它却是一个应用非常广泛的模式

模板方法模式 本质：抽象封装流程，具体进行实现

class Client {
    public static void main(String[] args) {
        AbstractClass abc = new ConcreteClassA();
        abc.templateMehthod();
        abc = new ConcreteClassB();
        abc.templateMehthod();
    }
    // 抽象模板类
    static abstract class AbstractClass {
        protected void step1() {
            System.out.println("AbstractClass:step1");
        }
        protected void step2() {
            System.out.println("AbstractClass:step2");
        }
        protected void step3() {
            System.out.println("AbstractClass:step3");
        }
        // 声明为final方法，避免子类覆写
        public final void templateMehthod() {
            this.step1();
            this.step2();
            this.step3();
        }
    }
    // 具体实现类A
    static class ConcreteClassA extends AbstractClass {
        @Override
        protected void step1() {
            System.out.println("ConcreateClassA:step1");
        }
    }
    // 具体实现类B
    static class ConcreteClassB extends AbstractClass {
        @Override
        protected void step2() {
            System.out.println("ConcreateClassB:step2");
        }
    }
}

模板方法模式
深入理解设计模式（九）：模板方法模式

---

4. 状态模式

状态模式的含义是将对象的状态封装成一个独立的类，并将动作行为委托到代表当前状态的对象，行为会随着内部的状态而改变。状态模式是通过状态对象来改变动作行为，而不同的状态对象里不同的动作行为表现会不一样，这使得它看起来就像在改变它的类一样

// 先定义一个State抽象状态类，里面定义了一个接口以封装 与Context的一个特定状态相关的行为
public abstract class State {
    public abstract void Handle(Context context);
}

// 声明一个ConcreteState具体状态类，每一个子类实现一个与Context的一个状态的相关的行为
public class ConcreteStateA extends State{
    @Override
    public void Handle(Context context) {
        context.setState(new ConcreteStateB()); //设置A的下一个状态是B 
    }
}
class ConcreteStateB extends State{
    @Override
    public void Handle(Context context) {
        context.setState(new ConcreteStateA()); //设置B的下一个状态是A
    }
    
}
// Context类，维护一个ConcreteState子类的实例，这个实例定义当前的状态
public class Context {
    State state;
    public Context(State state) { //定义Context的初始状态
        super();
        this.state = state;
    }
    public State getState() {
        return state;
    }
    public void setState(State state) {
        this.state = state;
        System.out.println("当前状态为"+state);
    }
    public void request(){
        state.Handle(this); //对请求做处理并且指向下一个状态
    }
}

（二十一）状态模式详解（DOTA版）
设计模式之状态模式

---

5. 观察者模式

观察者模式（又被称为发布-订阅（Publish/Subscribe）模式，属于行为型模式的一种，它定义了一种一对多的依赖关系，让多个观察者对象同时监听某一个主题对象。这个主题对象在状态变化时，会通知所有的观察者对象，使他们能够自动更新自己

// 抽象观察者
public interface Observer {
    public void update(String message);
}

// 抽象被观察者
public interface Subject {
    /** 增加订阅者 */
    public void attach(Observer observer);
    /** 删除订阅者 */
    public void detach(Observer observer);
    /** 通知订阅者更新消息 */
    public void notify(String message);
}

设计模式（五）观察者模式
设计模式之观察者模式