面经：设计模式

23种设计模式
添加链接描述

零. 设计模式的七大原则

1. 开闭原则

在对程序进行更新迭代的过程中，应当合理的避免修改类或方法的内部代码，而是优先选择通过继承、扩展等方式来实现。简而言之，就是：对扩展开放，对修改关闭。

2. 里氏替换原则

在实现子类的定义时，应该让它完全拥有替代父类进行工作的能力。简而言之，就是：子类对外要具与父类一致的方法或接口。

3. 依赖倒置原则

在对象或类的依赖关系定义上，父类或者其他上层实现不应该依赖于子类或者其他下层实现，通过这样，来避免依赖关系的耦合。

4. 单一职责原则

在程序结构和依赖关系的定义上，要将类的功能职责充分理清，尽力减少类之间的耦合。避免对某个类进行修改时，牵一发动全身的连锁反应。

5. 接口隔离原则

在对外接口的定义上，要避免庞大而臃肿的接口，而是进行责任细化的区分，避免冗余的代码实现。这对于提高内聚，提升系统灵活度是非常有效果的。

6. 最少知识原则

在分配类的职责和建立依赖关系时，应该只关注于自身的功能实现和周围与之接触类的交互方式。避免类去考虑整个系统结构和处理流程，让类的职责清晰化，让系统的耦合度降低。

7. 合成复用原则

在扩展功能的时候，要优先考虑水平形式的新增类或方法，而不是通过继承去实现。也就是通过功能的组合实现类，而不是通过基础去实现新的功能。这样可以提高类的可扩展性，减少系统的层次。

一. 设计模式类型

• 概念
  
• 分类
  

二. 单例模式

1. 概念

2. 饿汉式(静态常量)

构造器私有化(防止new)
类的内部创建对象
向外暴露一个静态的公共方法。getInstance
单线程可以使用

package Singleton;

public class test01 {
    public static void main(String[] args) {
        Singleton1 instance = Singleton1.getInstance();
        Singleton1 instance2 = Singleton1.getInstance();
        System.out.println(instance == instance2);
        System.out.println(instance.hashCode());
        System.out.println(instance2.hashCode());
//true
//668386784
//668386784
    }

}
class Singleton1{
    private Singleton1(){
        //构造器私有化
    }
    private final static Singleton1 instance = new Singleton1();
    public static Singleton1 getInstance(){
        return instance;
    }
}

3. 饿汉式（静态代码块）

package Singleton;

public class test01 {
    public static void main(String[] args) {
        Singleton2 instance = Singleton2.getInstance();
        Singleton2 instance2 = Singleton2.getInstance();
        System.out.println(instance == instance2);
        System.out.println(instance.hashCode());
        System.out.println(instance2.hashCode());
    }
class Singleton2{
    /**
     * 2.饿汉式(静态代码块)
     */
    private Singleton2(){

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

3. 懒汉式(线程不安全)

/**
 * 3.懒汉式 线程不安全
 */
class Singleton3{
    private Singleton3(){

    }
    private static Singleton3 instance;
    //只有在调用该方法的时候才会去创建该实例
    public static Singleton3 getInstance(){
        if(instance==null){
            instance = new Singleton3();
        }
        return instance;
    }
}

4. 懒汉式(线程安全,效率低)

class Singleton4{
    private Singleton4(){

    }
    private static Singleton4 instance;
    //只有在调用该方法的时候才会去创建该实例
    public static synchronized Singleton4 getInstance(){
        if(instance==null){
            instance = new Singleton4();
        }
        return instance;
    }
}

5. 懒汉式 (静态代码块)

不能这么写，还是会造成线程安全问题的

/**
 * 5.懒汉式 同步代码块
 */
class Singleton5{
    private Singleton5(){

    }
    private static Singleton5 instance;
    //只有在调用该方法的时候才会去创建该实例
    public static Singleton5 getInstance(){
        if(instance==null){
            synchronized (Singleton5.class){
                instance = new Singleton5();
            }
        }
        return instance;
    }
}

6. 双重检查(推荐使用)

假如有100个线程来查询，刚好都到达第一次instance是否为空的判断,此时若不加锁就会创建多个实例;拿到锁后，只需要第一个线程去进行创建实例，因此需要再做一次判断(不做判断就是懒汉式的静态代码模式)
主要要加volatile关键字
对象的创建可能发生指令的重排序，使用 volatile 可以禁止指令的重排序，保证多线程环境内的系统安全。

/**
 * 6.双重检查
 */
class Singleton6{
    private static volatile Singleton6 instance;//volatile刷新更新后的值
    private Singleton6(){}
    public static Singleton6 getInstance(){
        if(instance==null){//检查是否存在实例,不存在再加锁(防止高并发)
            synchronized (Singleton6.class){
                if(instance==null){//拿到锁后再判断是否存在实例
                    instance = new Singleton6();
                }
            }
        }
        return instance;
    }

}

7. 静态内部类(推荐使用)

/**
 * 7.静态内部类
 */
class Singleton7{
    private Singleton7(){}//构造器私有化
    private static class SingleInstance{//静态内部类 里面包含有一个静态属性
        private final static Singleton7 INSTANCE = new Singleton7();
    }
    public static Singleton7 getInstance(){
        return SingleInstance.INSTANCE;
    }
}

8. 枚举方式

/**
 * 8. 枚举
 */
enum Singleton8{
    INSTANCE;
    public void sayOK(){
        System.out.println("ok");
    }
}

9. 单例模式总结

• 在JDK源码分析
  
• 使用注意细节
  

10. 破坏单例模式

在单例模式的实现中，除去 枚举 方法实现的单例模式，其它的实现都可以利用反射构造新的对象，从而破坏单例模式，但是枚举就不行。
破坏单例的方式有 3 种，反射、克隆以及序列化，
添加链接描述

三. 装饰者模式(包装模式)

1. 定义及简单理解

资料1
资料2

2.应用场景

Spring 中配置 DataSource 的时候，DataSource 可能是不同的数据库和数据源。我们能否根据客户的需求在少修改原有类的代码下动态切换不同的数据源？这个时候就要用到装饰者模式

四. 工厂模式

参考资料

1. 简单工厂模式

该模式对对象创建管理方式最为简单，因为其仅仅简单的对不同类对象的创建进行了一层薄薄的封装

2. 工厂方法模式

和简单工厂模式中工厂负责生产所有产品相比，工厂方法模式将生成具体产品的任务分发给具体的产品工厂

3. 抽象工厂模式

抽象工厂模式通过在AbstarctFactory中增加创建产品的接口，并在具体子工厂中实现新加产品的创建，当然前提是子工厂支持生产该产品。否则继承的这个接口可以什么也不干。

五. 代理模式

参考视频

1. 静态代理

• 定义一个接口及其实现类；
• 创建一个代理类同样实现这个接口
• 将目标对象注入进代理类，然后在代理类的对应方法调用目标类中的对应方法
  与动态代理区别就是,目标类和代理类都需要实现接口，而JDK动态代理只需要目标类实现接口就好。

2. JDK动态代理

3. CGLIB动态代理

六. 职责链模式

1. 引入

2. 基本概念

3. 职责链模式在Spring MVC中的应用

4. 注意事项

七. 原型模式

原型模式（Prototype Pattern） ，是 GoF 的 23 种设计模式的一种，是用于创建重复的对象，同时又能保证性能。属于创建型模式，提供创建对象的最佳方式。

原型（Prototype），在制造业中通常是指大批量生产开始之前研发出的概念模型，并基于各种参数指标对其进行检验，如果达到了质量要求，即可参照这个原型进行批量生产。原型模式达到以原型实例创建副本实例的目的即可，并不需要知道其原始类，也就是说，原型模式可以用对象创建对象，而不是用类创建对象，以此达到效率的提升。
添加链接描述

常考面试题

1. 适配器模式，装饰模式，代理模式的区别

添加链接描述