面试：设计模式

1、含义

设计模式是对大家实际工作中写的各种代码进行高层次抽象的总结，其中最出名的当属 Gang of Four (GoF：四人帮) 的分类了，他们将设计模式分类为 23 种经典的模式，根据用途我们又可以分为三大类，分别为创建型模式、结构型模式和行为型模式。

个人理解：由一些由经验的开发者，总结出来的一些有利于代码运行效率和有利于代码后期维护的代码开发规范

https://refactoringguru.cn/design-patterns/catalog

2、分类

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

3、遵循的七大原则

• 1、开闭原则
  对扩展开放，对修改关闭。需要对程序功能进行拓展的时候，应当在不修改原有功能的基础上进行扩展
• 2、里氏替换原则
  任何基类可以出现的地方，都可以用子类替换。因为子类继承自基类，具有基类的功能
• 3、依赖倒转原则
  应当依赖于接口或者抽象类，而不是具体的对象。 针对于接口编程，依赖于接口或者抽象类，这样体现出多态性
• 4、接口隔离原则
  针对不同功能的模块，用不同的接口进行隔离。这样有效减少代码的耦合度和依赖性，一个接口只干一件事，接口要精简单一
• 5、迪米特法则(最少知道原则)
  一个类尽量少的与其他类进行交互，只需要内部实现具体的功能，对外提供访问的接口(方法)即可，具体实现对外不可见
• 6、合成复用原则
  尽量使用合成复用的方式，少使用继承：比如相同功能的代码，可以提取出来，方便其他程序调用，而不是使用继承的方式
• 7、单一职责原则
  一个类只干一件事，实现类要单一

4、模式详解

1、单例模式

单例特点：

• 1、构造函数私有化（不允许自己构建对象）
• 2、对外提供获取当前对象的静态方法（获取对象的方法必须判空，否正并发容易出问题）

1、懒汉式：

对象一开始不构建，在调用获取当前对象的方法的时候，在创建当前对象（获取对象的静态方法必须判空，最好加上同步锁，做双重判空，对象属性加上Volatile属性）

Volatile：关键字，见另一边文章

//懒汉式单例类.在第一次调用的时候实例化自己 
public class Singleton {
    private Singleton() {}
    private static Singleton single=null;
    //静态工厂方法 
    public static Singleton getInstance() {
        if (singleton == null) {  
            synchronized (Singleton.class) {  
               if (singleton == null) {  
                  singleton = new Singleton(); 
               }  
'            }  
        }  
        return singleton; 
    }
}

2、饿汉式：

在类加载的时候，就创建了当前对象的实例，这种方案不会出现并发问题

//饿汉式单例类.在类初始化时，已经自行实例化
public class Singleton1 {
    private Singleton1() {}
    private static final Singleton1 single = new Singleton1();
    //静态工厂方法
    public static Singleton1 getInstance() {
    return single;
    }
}

2、工厂

1、简单工厂

特点：

• 1、产品接口，各个产品实现
• 2、只有一个工厂类，通过参数判断构建那个产品

缺点：

• 1、违背了开闭原则，增加产品的时候，需要修改工厂类，影响了原有功能

//产品接口
public interface Car {
    void name();
}
//产品实现1
public class Audi implements Car{
    public void name() {
        System.out.println("奥迪。。。");
    }
}
//产品实现2
public class Benz implements Car {
    public void name() {
        System.out.println("奔驰。。。");
    }
}
//工厂类
public class CarFactory {
    public static Car getCar(int type){
        switch (type){
            case 1:
                return new Audi();
            case 2:
                return new Benz();
            default:
                return null;
        }
    }
}

2、工厂方法

特点：

• 1、产品接口，各个产品实现
• 2、工厂接口，各个工厂接口的实现负责对应产品的构建，这样灵活性比较高，新增产品，无需改动之前工厂，只需要创建新的工厂类实现即可

缺点：

• 1、生成的产品单一，和产品绑定关系紧密

//产品接口
public interface Car {
    void name();
}
//产品实现1
public class Audi implements Car{
    public void name() {
        System.out.println("奥迪。。。");
    }
}
//产品实现2
public class Benz implements Car {
    public void name() {
        System.out.println("奔驰。。。");
    }
}
//工厂接口
public interface CarFactory {
    Car getCar();
}
// 具体的工厂创建实例1
public class AudiFactory implements CarFactory{
    public Car getCar() {
        return new Audi();
    }
}
// 具体的工厂创建实例2
public class BenzFactory implements CarFactory {
    public Car getCar() {
        return new Benz();
    }
}

3、抽象工厂

是工厂方法的升级
特点：

• 1、多个产品接口，各个产品实现
• 2、工厂接口，各个工厂接口的实现负责对应产品的构建，这样灵活性比较高，新增产品，无需改动之前工厂，只需要创建新的工厂类实现即可
• 3、提供了一个创建一系列相关或者相互依赖对象的接口，无需指定它们具体的类

//产品1接口
public interface Engine {
    void name();
}
//产品1实现1
public class AudiEngine implements Engine{
    public void name() {
        System.out.println("#### 奥迪引擎");
    }
}
//产品1实现2
public class BenzEngine implements Engine {
    public void name() {
        System.out.println("#### 奔驰引擎");
    }
}

//产品2接口
public interface GearBox {
    void name();
}
//产品2实现1
public class AudiGearBox implements GearBox {
    public void name() {
        System.out.println("奥迪变速箱");
    }
}
//产品2实现2
public class BenzGearBox implements GearBox {
    public void name() {
        System.out.println("奔驰变速箱");
    }
}

// 抽象工厂
public interface ProductFactory {
    // 生成引擎    
    Engine engineProduct();
    // 生成变速箱    
    GearBox gearboxProduct();
}
// 具体工厂实现
public class AudiFactory implements ProductFactory{
    public Engine engineProduct() {
        return new AudiEngine();
    }

    public GearBox gearboxProduct() {
        return new AudiGearBox();
    }
}
public class BenzFactory implements ProductFactory {
    public Engine engineProduct() {
        return new BenzEngine();
    }

    public GearBox gearboxProduct() {
        return new BenzGearBox();
    }
}

//测试
public class Test {
    public static void main(String[] args) {
        AudiFactory audiFactory = new AudiFactory();
        Engine engine = audiFactory.engineProduct();
        GearBox gearBox = audiFactory.gearboxProduct();
        engine.name();
        gearBox.name();

        BenzFactory benzFactory = new BenzFactory();
        Engine engine1 = benzFactory.engineProduct();
        GearBox gearBox1 = benzFactory.gearboxProduct();
        engine1.name();
        gearBox1.name();
    }
}