尚硅谷—韩顺平—图解 Java设计模式（1～27）

​视频链接

一.：设计模式面试题 & 课程介绍（1～4）

1.：原型设计模式的，几个经典面试题：

   1）请使用 UML 类图，画出原型模式核心角色？
   2）原型设计模式的深拷贝 & 浅拷贝是什么？
     并写出 深拷贝的，两种方式的源码？
    -1：重写 clone 方法，实现深拷贝。
    -2：使用序列化方式，实现深拷贝。
   3）在 Spring 框架中，哪里使用到原型模式，并对原吗进行分析：

   4）Spring 中，原型 Bean 的创建，就是原型模式的应用：
   5）代码分析 + Bebug源码：（要求比较高）

   6）设计模式的七大原则：要求：
    -1：七大设计原则核心思想。
    -2：能够以 UML 类图，说明设计原则。
    -3：在项目实际开发中，你在哪里使用到了 ocp 原则。（开闭原则）
    -4：设计模式，常用的 七大原则有：
      -1：单一职责原则
      -2：接口隔离原则
      -3：依赖倒转原则
      -4：里氏替换原则
      -5：开闭原则
      -6：迪米特法则
      -7：合成复用原则（可无）

   7）金融借贷平台项目：状态模式进行设计

   8）解释器设计模式：


   9）单例设计模式：

2.：何时会用到设计模式 & 重要性

   1）设计模式的重要性：
    -1：软件工程中：设计模式（design pattern），是对 软件设计中普遍存在（反复出现） 的各种问题，所提出的解决方案。
    -2：这个术语：是由 埃里希伽马 等人，在 1990 年代，从建筑设计领域，引入到计算机科学的。
    -3：当一个项目开发完成后，如果客户提出新增功能，怎么办。
    -4：目前：一线大厂，都会问你，在实际项目中，使用过什么设计模式，怎么样使用，解决了什么问题？
    -5：设计模式，在软件中哪里存在？
=> 面向对象(oo)
=> 功能模块【设计模式 + 算法（使用数据结构）】
=> 框架 【多种设计模式】
=> 架构【服务器集群】
    -6：如果想成为合格的软件工程师：那就花时间，来研究下设计模式，是非常必要的。

3.：内容 & 授课方式：

   1）课程亮点和授课方式：

   2）建造者模式，讲解流程：

二.：七大设计原则介绍（5～22）

七大设计原则 介绍：（单接依里开迪合）

   1）设计模式的目的：
  在 软件编写过程中，程序员面临着来自 【耦合性、内聚性、可维护性、可拓展性、重用性、灵活性】 等多方面的挑战。设计模式，是为了让 程序（软件），具有更好的：
    -1：代码复用性：即：相同功能的代码，不用多次编写。
    -2：可读性：即：编程规范性，便于其他程序员的阅读和理解。
    -3：可拓展性（可维护性）：即：当需要增加新的功能时，非常方便，成本低。
    -4：可靠性：即：当新增加功能后，对原来功能不会造成影响。
    -5：根本目的：使程序呈现高内聚、低耦合的特性：

   2）分析金句：
  1、设计模式，包含了面向对象的精髓，“懂了设计模式，你就懂了面向对象分析 和 设计（OOA/D）的精要”
  2、C++ 老手 和 新手的区别，就是前者手臂上，有很多伤疤。

   3）设计模式原则，其实就是：程序员在编程时，应当遵守的原则，也是各种设计模式的基础（即：设计模式为什么这样设计的依据）

   4）设计模式常用的七大原则有：
    -1：单一职责原则：
    -2：接口隔离原则：
    -3：依赖倒转原则：（依赖倒置原则）
    -4：里氏替换原则：
    -5：开闭原则：
    -6：迪米特法则：
    -7：合成复用原则：

   4）设计模式的核心思想：
    -1：找出应用中，可能需要变化之处，把他们独立起来，不要和那些不需要变化的代码，混在一起。
    -2：针对接口编程，而不是针对实现编程。
    -3：为了交互对象之间的松耦合设计而努力。
    -4：
    -5：

1.：单一职责原则：（SimpleResponsibility）

   1）基本介绍：
    -1：是对类来说的，即：一个类，应该只负责一项职责：
  1、如类A负责两个不同职责：职责1、职责2。
  2、当职责1需求变更而改变A时，可能造成职责2执行错误。
  3、所以需要将类A的粒度，分解为 A1、A2。

   2）应用实例：使用 3个方案，进行分析：
    -1：以交通工具 案例讲解：
    -2：看老师代码演示：
    -3：方案1【分析说明】

public class Singleresponsility01 {
   

    public static void main(String[] args) {
   
        Vehicle vehicle = new Vehicle();
        vehicle.run("自行车");
        vehicle.run("摩托车");
        // 飞机就不合适，在此处运行
        vehicle.run("飞机");  
    }
}

/**
 * 交通工具类
 * 方式1
 *      1、在方式1 的 run 方法中，违反了单一职责原则。
 *      2、解决方案非常简单，根据交通工具运行方法不同，分解成不同类即可。
 */
class Vehicle {
   
    public void run(String vehicle) {
   
        System.out.println(vehicle + "：在公路上运行");
    }
}

    -4：方案2【分析说明】

/**
 * @author zhangxudong@chunyu.me
 * @date 2022/3/1 11:43 上午
 */
public class Singleresponsility02 {
   

    public static void main(String[] args) {
   

        RoadVehicle roadVehicle = new RoadVehicle();
        roadVehicle.run("汽车");

        AirVehicle airVehicle = new AirVehicle();
        airVehicle.run("飞机");
    }
}

/**
 * 方案2分析：
 *      1、准守了单一职责原则
 *      2、但是这一做，改动很大。即：需要将类分解，同时修改客户端。
 * 改进：
 *      1、直接修改 01 类中 Vehicle 类，改动代码较少。
 */
class RoadVehicle {
   
    public void run(String vehicle) {
   
        System.out.println(vehicle + "：在 公路上运行。");
    }
}

class AirVehicle {
   
    public void run(String vehicle) {
   
        System.out.println(vehicle + "：在 天上运行。");
    }
}

    -5：方案3【分析说明】

/**
 * @author zhangxudong@chunyu.me
 * @date 2022/3/1 11:48 上午
 */
public class Singleresponsility03 {
   
    public static void main(String[] args) {
   
    
        Vehicle03 vehicle = new Vehicle03();
        vehicle.run("汽车");
        vehicle.runAir("飞机");
    }
}

/**
 * 方式 3 分析
 *      1、这种修改方法，没有对原来的类做大的修改，只是增加了方法。
 *      2、这里虽然，没有在类的级别上，遵守单一职责原则。但是在方法级别上，仍然遵守单一职责原则。
 */
class Vehicle03 {
   
    public void run(String vehicle) {
   
        System.out.println(vehicle + "：在公路上运行");
    }

    public void runAir(String vehicle) {
   
        System.out.println(vehicle + "：在天上运行");
    }
}

   3）单一职责原则，注意事项和细节：
    -1：降低类的复杂度：一个类，只负责一项职责。
    -2：提高类的可读性，可维护性：
    -3：降低变更，引起的风险：
    -4：通常情况下，我们应当遵守单一职责原则：只有逻辑足够简单，才可以在代码级，违反单一职责原则。只有类中方法数量足够少，可以在方法级别，保持单一职责原则。

2.：接口隔离原则：（Interface Segregation Principle）

   1）基本介绍：
    -1：客户端，不应该依赖它不需要的接口：即一个类对另一个类的依赖，应建立在最小的接口上。
    -2：先看一张图：

• （1）A类，通过 Interface1，会依赖（使用）B类。
  （2）但是 A中，只会使用到接口的 1 方法。（要使用 B类已经实现的 1方法）。
• （1）C类，通过 Interface1，会依赖（使用）D类。
  （2）但是 C中，只会使用到接口的 2 方法。（要使用 D类已经实现的 2方法）。
  
      -3：编码完成：

/**
 * @author zhangxudong@chunyu.me
 * @date 2022/3/1 3:57 下午
 */
interface Interface01 {
   
    void f1();
    void f2();
}

class B implements Interface01 {
   
    @Override
    public void f1() {
   
        System.out.println