绪论

1. 什么是设计模式：程序设计的方法论

2. 为什么参考设计模式：让面向对象编程的程序保持程序结构良好

3. 面向对象设计 5 大基本原则

   1. 单一职责原则：单一模块只负责单一功能

   2. 开放封闭原则：封闭内部功能，开放功能扩展

   3. 里氏替换原则：子类应当具备替换父类的能力

   4. 依赖倒置原则：如果底层模块需要应用顶层模块的功能，需要先将顶层模块的功能抽象为底层方法，再进行调用

   5. 接口分离原则：模块间通过抽象接口类进行隔离

构建型模式

基本概念

1. 什么是构建型模式：控制对象生命周期的设计模式

2. 为什么需要构建型模式：避免硬编码，增强代码的可维护性与可扩展性

工厂模式

1. 什么是工厂模式：将类的创建过程封装到工厂类中

2. 怎么实现工厂模式：

   1. 每一个类都对应一个工厂类负责创建过程管理

   2. 调用者使用公共的工厂接口调用工厂类

3. 为什么使用工厂模式：

   1. 单一职责原则：创建对象由工厂类负责，修改创建过程不需要更改创建者的代码

   2. 开闭原则： 相比于把所有类的创建过程放在一个类中统一管理，工厂方法模式在进行类的扩展时更加符合开闭原则。

   3. 接口分离原则：使用接口有利于工厂的横向扩展

4. Java实现工厂方法模式

//工厂接口
public interface IFactory {
    Fruit create();
}
// 构造工厂
public class AppleFactory implements IFactory {
    @Override
    public Fruit create(){
        return new Apple();
    }
}

public class PearFactory implements Ifactory {
    public Fruit create(){
        return new Pear();
    }
}
// 调用工厂
public class User {
    private void eat(){
        IFactory appleFactory = new AppleFactory();
        Fruit apple = appleFactory.create();
        IFactory pearFactory = new PearFactory();
        Fruit pear = pearFactory.create();
        apple.eat();
        pear.eat();
    }
}

单例模式

1. 什么是单例模式：全局只能存在一个实例对象的类

2. 为什么需要单例模式：

   1. 避免重复创建：某些特殊场景要求只能存在一个对象(ID生成器)

   2. 减少内存开销：某些类的创建需要消耗大量资源，同时该类没有高并发需求

3. 怎么实现单例模式：

   1. 饿汉式单例模式：在全局静态域初始化单例

   2. 懒汉式单例模式：在需要单例时再创建该单例

Java实现饿汉式单例

public class Singleton {
    // 在全局静态域初始化该单例
    private static Singleton instance = new Singleton();
    // 该单例无法被其它对象实例化
    private Singleton() {
    }
    // 封装调用方法
    public static Singleton getInstance() {
        return instance;
    }
}

Java实现懒汉式单例

public class Singleton {
    // 在全局静态域初预留该实例的位置，但是不初始化
    private static Singleton instance = null;
    // 该单例无法被其它对象实例化
    private Singleton() {
    }
    // 调用时如果没初始化则进行初始化，否则返回实例
    public static Singleton getInstance() {
        // 使用双检锁的方式初始化实例，保障线程安全
        if (instance == null) {
            synchronized (Singleton.class) {
                if (instance == null) {
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }
}

• 双检锁

  • 为什么synchronized写在if里面：因为只有创建的时候会进入if，如果锁住了if会使得创建后每次if都上锁，效率低

  • 为什么synchronized里面又有一个if：防止两个线程同时创建

结构型模式

基本概念

1. 什么是结构型模式：控制对象之间关系的设计模式

2. 为什么需要结构型模式：简化系统设计，提高代码的复用性

代理模式

1. 什么是代理模式：给某对象提供一个代理以控制该对象的访问

2. 为什么需要代理模式：

   1. 单一职责原则，对象的控制(日志，调度)是独立于对象功能本身

3. 代理模式的应用：

   1. 远程代理

适配器模式

1. 什么是适配器模式：对于两个需要进行耦合的对象使用适配器进行包装+转换

2. 为什么需要适配器模式：

   1. 单一职责原则，两个需要耦合的功能类不需要负责类的衔接功能。如果两个需要耦合的类接口不匹配，可以创建适配器类实现两个类的接口的转换。

行为型模式

基本概念

1. 什么是行为型模式：控制对象之间责任划分的设计模式

2. 为什么需要行为型模式：简化系统的控制流

责任链模式

1. 什么是责任链模式：对于多个承担相同任务，但是服务范围不同的子类，当存在需要处理的业务时，发送业务方不使用if判断语句遍历适配子类，而是将事务按照子类的服务范围的顺序，依次流过每一个子类，形成责任链，使得适配的子类自己进行处理。

2. 为什么需要责任链模式：

   1. 发送方不适用if判断语句，可以将发送方与处理方进行解耦

   2. 简化处理逻辑，剔除了"任务分配者"的角色

   3. 符合开闭原则，子类的扩展不需要修改其他类的代码

观察者模式

1. 什么是观察者模式：对于需要被监听的对象，维护一个观察者表，每当该被观察对象有变化，则调用方法向观察者表内的对象发送消息。

2. 为什么需要观察者模式：响应式编程的业务需求

模板方法模式

1. 什么是模板方法模式：将方法的框架写在父类中，框架的实现细节使用子类实现