README.md · th1nker/design_pattern

# 设计模式

> author：thinker
>
> 单独下载本文件时需要绑定下载目录中的assets文件夹

## 七大设计模式原则

### 开闭原则

软件中的对象（类，模块，函数等等）应该对于扩展是开放的，但是对于修改是封闭的

### 依赖倒转（倒置）原则

程序要依赖于抽象接口，不要依赖于具体实现

要对抽象进行编程，不要对实现进行编程

### 单一职责

就一个类而言，应该仅有一个引起它变化的原因，应该只有一个职责

### 接口隔离原则

客户端不应该依赖它不需要的接口

一个类对另一个类的依赖应该建立在最小的接口上

### 里氏代换原则

任何基类可以出现的地方，子类一定可以出现

只有当衍生类可以替换掉基类，软件单位的功能不受到影响时，基类才能真正被复用，而衍生类也能够在基类的基础上增加新的行为

对开闭原则的补充

### 迪米特法则（最少知识原则）

一个类对于其他类知道的越少越好

一个对象应当对其他对象有尽可能少的了解

只和朋友通信，不和陌生人说话

### 合成复用原则

软件复用时，要尽量先使用组合或者聚合等关联关系来实现，其次才考虑使用继承关系来实现。

## 创建型

### 简单工厂

#### 定义

由一个工厂对象决定创建出哪一种产品类的实例

不属于GOF23种设计模式

#### 适用场景

- 工厂类负责创建的对象比较少
- 客户端（应用层）只知道传入工厂类的参数，对于如何创建对象（逻辑）不关心

#### 优点

- 只需要传入一个正确的参数，就可以获取你所需要的对象，而无需知道其创建细节

#### 缺点

- 工厂类的职责相对过重，增加新的产品，需要修改工厂类的判断逻辑，违背开闭原则

#### 代码实例

##### 抽象产品Video

```java
package cloud.th1nker.designpattern.pattern.creational.simplefactory;

/**
 * @author Thinker
 * @create 2023/5/28 12:05
 * @since
 */
public abstract class Video {

public abstract void produce();
}
```

##### 具体产品JavaVideo

```java
package cloud.th1nker.designpattern.pattern.creational.simplefactory;

/**
 * @author Thinker
 * @create 2023/5/28 12:05
 * @since
 */
public class JavaVideo extends Video {
    public void produce() {
        System.out.println("录制java课程视频");
    }
}
```

##### 具体产品PythonVideo

```java
package cloud.th1nker.designpattern.pattern.creational.simplefactory;

/**
 * @author Thinker
 * @create 2023/5/28 12:05
 * @since
 */
public class PythonVideo extends Video {
    public void produce() {
        System.out.println("录制python课程视频");
    }
}

```

##### 工厂类VideoFactory

```java
package cloud.th1nker.designpattern.pattern.creational.simplefactory;

/**
 * @author Thinker
 * @create 2023/5/28 12:07
 * @since
 */
public class VideoFactory {

public Video getVideo(Class<? extends Video> c) {
        Video video;
        try {
            video = (Video) Class.forName(c.getName()).newInstance();
        } catch (InstantiationException | IllegalAccessException | ClassNotFoundException e) {
            throw new RuntimeException(e);
        }
        return video;
    }

public Video getVideo(String type) {
        if ("java".equalsIgnoreCase(type)) {
            return new JavaVideo();
        } else if ("python".equalsIgnoreCase(type)) {
            return new PythonVideo();
        } else {
            return null;
        }
    }
}
```

#### UML图

![简单工厂UML](./assets/简单工厂UML.png)

### 工厂方法模式

#### 定义

定义一个创建对象的接口

但让实现这个接口的类来决定实例化哪个类

工厂方法让类的实例化推迟到子类中进行

#### 适用场景

- 创建对象需要大量重复的代码
- 客户端（应用层）不依赖于产品类实例如何被创建、实现等细节
- 一个类通过其子类来指定创建哪个对象

#### 优点

- 用户只需要关心产品对应的工厂，无需关心创建细节
- 加入新产品复合开闭原则，提高可扩展性

#### 缺点

- 类的个数容易过多，增加复杂度
- 增加了系统的抽象性和理解难度

#### 代码实例

##### 抽象产品Video

```java
package cloud.th1nker.designpattern.pattern.creational.factorymethod;

/**
 * @author Thinker
 * @create 2023/5/28 12:05
 * @since
 */
public abstract class Video {

public abstract void produce();
}
```

##### 抽象工厂VideoFactory

```java
package cloud.th1nker.designpattern.pattern.creational.factorymethod;

/**
 * @author Thinker
 * @create 2023/5/28 12:07
 * @since
 */
public abstract class VideoFactory {

public abstract Video getVideo();
    
}
```

##### 具体产品JavaVideo

```java
package cloud.th1nker.designpattern.pattern.creational.factorymethod;

/**
 * @author Thinker
 * @create 2023/5/28 12:05
 */
public class JavaVideo extends Video {

public void produce() {
        System.out.println("录制java课程视频");
    }

}
```

##### 具体产品工厂JavaVideoFactory

```java
package cloud.th1nker.designpattern.pattern.creational.factorymethod;

/**
 * @author Thinker
 * @create 2023/5/28 12:46
 */
public class JavaVideoFactory extends VideoFactory {

public Video getVideo() {
        return new JavaVideo();
    }

}
```

##### 具体产品PythonVideo

```java
package cloud.th1nker.designpattern.pattern.creational.factorymethod;

/**
 * @author Thinker
 * @create 2023/5/28 12:05
 */
public class PythonVideo extends Video {

public void produce() {
        System.out.println("录制python课程视频");
    }

}
```

##### 具体产品工厂PythonVideoFactory

```java
package cloud.th1nker.designpattern.pattern.creational.factorymethod;

/**
 * @author Thinker
 * @create 2023/5/28 12:47
 */
public class PythonVideoFactory extends VideoFactory {

public Video getVideo() {
        return new PythonVideo();
    }

}
```

#### UML图

![工厂方法UML](./assets/工厂方法UML.png)

### 抽象工厂模式

#### 定义

提供一个创建一系列相关或者相互依赖对象的接口

无须指定他们具体的类

#### 适用场景

- 客户端（应用层）不依赖于产品类实例如何被创建、实现等细节
- 强调一系列相关的产品对象（属于同一产品族）一起使用创建对象需要大量重复的代码
- 提供一个产品类的库，所有的产品以同样的接口出现，从而使客户端不依赖于具体实现

#### 优点

- 具体产品在应用层隔离，无需关系创建细节
- 将一个系列的产品族统一到一起创建

#### 缺点

- 规定了所有可能被创建的产品集合，产品族中扩展新的产品困难，需要修改抽象工厂的接口
- 增加了系统的抽象性和理解难度

#### 产品族和产品结构

![产品族和产品结构](./assets/产品族和产品结构.png)

#### 代码实例

##### 抽象产品工厂CourseFactory