Java的设计模式和应用场景.md · OwenWu/Java的设计模式

# Java的设计模式和应用场景

![image-20240630152007028](C:\Users\Lenovo\AppData\Roaming\Typora\typora-user-images\image-20240630152007028.png)

![d](C:\Users\Lenovo\AppData\Roaming\Typora\typora-user-images\image-20240630152040968.png)

## 序言

### 对象之间的关系

**Dependency（依赖）、Association（关联）、Generalization（泛化）、Realization（实现）、Aggregation（聚合）、Composite（组合）**

在面向对象编程（OOP）中，特别是在Java这样的语言中，上述术语（Dependency, Association, Generalization, Realization, Aggregation, Composite）通常用于描述类之间的关系，但它们在Java代码中并不直接体现为特定的语法结构，而是作为设计原则和设计模式的描述方式。下面是对这些术语在Java环境中的解释：

**1、Dependency（依赖）**：
依赖关系是一种表示一个类依赖于另一个类的声明、消息传递或方法调用的关系。在Java中，这通常通过在一个类中使用另一个类的实例或方法来实现。例如，一个类可能使用另一个类来执行某些任务或计算。

```java
public class Driver {  
    private Car car;

public void drive() {  
        car.move();  
    }  
}

public class Car {  
    public void move() {  
        System.out.println("Car is moving");  
    }  
}
```

在这里，`Driver`类依赖于`Car`类来执行`move`方法。

**2、Association（关联）**：
关联是两个或多个类之间的一种结构关系，其中一个类可以访问另一个类的属性或服务。这种关系比依赖更强，因为它通常表示两个类之间的长期关系。在Java中，这通常通过类的实例变量来实现。

```java
public class Student {  
    private Address address;

public void setAddress(Address address) {  
        this.address = address;  
    }  
}

public class Address {  
    private String street;  
    // ...  
}
```

这里，`Student`和`Address`之间存在关联关系。

**3、Generalization（泛化）**：
泛化是表示类与类之间的继承关系，也称为“is-a”关系。在Java中，这通过`extends`关键字实现，允许子类继承父类的属性和方法。

```java
public class Animal {  
    void eat() {  
        System.out.println("Animal is eating");  
    }  
}

public class Dog extends Animal {  
    void bark() {  
        System.out.println("Dog is barking");  
    }  
}
```

这里，`Dog`是`Animal`的一个泛化（或子类）。

**4、Realization（实现）**：
在UML中，实现关系用于表示类与接口之间的关系，即一个类实现了接口中定义的所有方法。在Java中，这通过`implements`关键字实现。

```java
public interface Animal {  
    void eat();  
}

public class Dog implements Animal {  
    public void eat() {  
        System.out.println("Dog is eating");  
    }  
}
```

这里，`Dog`类实现了`Animal`接口。

**5、Aggregation（聚合）**：
聚合是一种特殊类型的关联，表示整体与部分的关系，但整体与部分之间是可分离的。在Java中，这通常通过成员变量来实现，但与一般的关联关系相比，它更强调整体与部分之间的生命周期独立性。

```java
public class Car {  
    private Engine engine;

public Car(Engine engine) {  
        this.engine = engine;  
    }  
}

public class Engine {  
    // ...  
}
```

尽管`Car`和`Engine`之间存在紧密的关联，但它们的生命周期是独立的。

**6、Composite（组合）**：
组合是聚合的一种特殊形式，表示一种更强的拥有关系，即部分的生命周期完全依赖于整体的生命周期。在Java中，这通常通过成员变量和构造器来实现，但组合强调的是整体与部分之间的紧密关系。

```java
public class Body { 
 private List<Hand> hands = new ArrayList<>();

public void addHand(Hand hand) {  
        hands.add(hand);  
    }  
}

public class Hand {  
    // ...  
}
```

在这个例子中，`Hand`是`Body`的一部分，且`Hand`的生命周期依赖于`Body`的生命周期。

### 传参方式

**1. 接口传参**

接口传参通常不直接用于依赖注入，但它是实现依赖倒置的一种方式，通过接口来定义依赖关系。在方法调用时，可以传入实现了特定接口的实例。

```java
interface Engine {  
    void start();  
}  
  
class Car {  
    void drive(Engine engine) {  
        engine.start();  
        // 其他逻辑  
    }  
}  
  
class ElectricEngine implements Engine {  
    @Override  
    public void start() {  
        System.out.println("Electric engine started");  
    }  
}  
  
// 使用  
Car car = new Car();  
car.drive(new ElectricEngine());
```

**2. 构造器传参**

构造器传参是依赖注入的一种常见方式，特别是在构造函数中注入依赖项。

```java
class Car {  
    private Engine engine;  
  
    public Car(Engine engine) {  
        this.engine = engine;  
    }  
  
    void drive() {  
        engine.start();  
    }  
}  
  
// 使用  
Car car = new Car(new ElectricEngine());  
car.drive();
```

**3. Setter传参**

Setter传参允许在对象创建后注入依赖项。

```java
class Car {  
    private Engine engine;  
  
    public void setEngine(Engine engine) {  
        this.engine = engine;  
    }  
  
    void drive() {  
        if (engine != null) {  
            engine.start();  
        }  
    }  
}  
  
// 使用  
Car car = new Car();  
car.setEngine(new ElectricEngine());  
car.drive();
```

**4、SpringBoot 中的依赖注入**

在SpringBoot中，依赖注入通常是通过Spring框架的自动装配功能来实现的，不需要手动编写构造器或setter注入代码。

```java
@Component  
class Car {  
    private final Engine engine;  
  
    @Autowired  
    public Car(Engine engine) {  
        this.engine = engine;  
    }  
  
    void drive() {  
        engine.start();  
    }  
}  
  
@Component  
class ElectricEngine implements Engine {  
    @Override  
    public void start() {  
        System.out.println("Electric engine started");  
    }  
}  
  
// SpringBoot自动处理依赖注入，无需手动new对象
```

**5、使用工厂模式（特例）**

工厂模式是一种创建型设计模式，用于创建对象时不会对客户端暴露创建逻辑，并且是通过使用一个共同的接口来指向新创建的对象。在工厂模式中，我们可以在创建对象时注入依赖。

在工厂模式中，我们通常会定义一个工厂接口，然后创建具体的工厂类来实现这个接口。这些工厂类负责创建并配置特定类型的对象，这些对象可能包含了一些依赖项。

```java
// 定义一个接口，代表要创建的对象  
interface Product {  
    void use();  
}  
  
// 一个具体的产品类，实现了Product接口，并包含了一个依赖项  
class ConcreteProductA implements Product {  
    private final Dependency dependency;  
  
    // 通过构造函数注入依赖项  
    public ConcreteProductA(Dependency dependency) {  
        this.dependency = dependency;  
    }  
  
    @Override  
    public void use() {  
        dependency.performAction();  
        System.out.println("Using ConcreteProductA");  
    }  
}  
  
// 依赖项的接口  
interface Dependency {  
    void performAction();  
}  
  
// 依赖项的一个具体实现  
class ConcreteDependency implements Dependency {  
    @Override  
    public void performAction() {  
        System.out.println("Dependency action performed");  
    }  
}  
  
// 工厂接口  
interface Factory {  
    Product createProduct();  
}  
  
// 具体工厂类，实现了Factory接口，并创建了包含依赖项的对象  
class ConcreteFactoryA implements Factory {  
    @Override  
    public Product createProduct() {  
        // 创建依赖项  
        Dependency dependency = new ConcreteDependency();  
        // 使用依赖项创建产品  
        return new ConcreteProductA(dependency);  
    }  
}  
  
// 客户端代码  
public class Client {  
    public static void main(String[] args) {  
        // 通过工厂获取产品对象  
        Factory factory = new ConcreteFactoryA();  
        Product product = factory.createProduct();  
          
        // 使用产品对象，此时产品对象已经包含了配置好的依赖项  
        product.use();  
    }  
}
解释如下：
在这个示例中，ConcreteProductA是一个具体的产品类，它依赖于Dependency接口的实现。ConcreteFactoryA是一个具体的工厂类，它实现了Factory接口，并在createProduct方法中创建了ConcreteProductA的实例，同时为这个实例创建并注入了ConcreteDependency作为依赖项。
客户端代码通过ConcreteFactoryA工厂类来获取Product对象，而不需要直接知道ConcreteProductA和ConcreteDependency的具体实现。这样，工厂模式就间接地实现了依赖的传递，因为客户端代码不需要直接处理依赖项的创建和配置。
通过这种方式，工厂模式提高了代码的模块化和可维护性，因为依赖项的创建和配置被封装在工厂类中，客户端代码只需要知道如何使用产品对象，而不需要关心产品对象是如何被创建和配置的。
```

# 1、单一职责原则

定义：单一职责原则就是一个类只负责一件事，面向对象语言开发，类就是一个基本的单位，单一职责的原则就是封装的粒度，主要关注的单一类的实现的功能。

1-1、自己类中实现自己的方法，一个只负责自己的事情，且都比较单一，简单意味着稳定，意味这强大，这就是所谓的单一职责原则，

问题：那么究竟什么时候可以使用单一职责原则?如果类型复杂，方法多，这样建议使用单一职责!

问题：单一原则弊端：如下

1)：代码量的增加(拆分开类的代码明显比之前增加)

2)：使用成本就是所谓的理解成本增高(调用者要晓得不同的类)

类型：1)：方法级别的单一职责原则：一个方法只负责一件事(职责小方法，分支逻辑清晰)

2)：类级别的单一职责原则：一个类只负责一件事

3)：类库级别的单一原则：一个类库应职责清晰

4)：项目级别的单一原则：一个项目应职责清晰(客户端/管理后台/后台服务/定时任务/分布式引擎)

5)：系统级别的单一原则：为通用功能拆分系统(IP定位/日志/在线统计)

个人理解总结：单一职责原则是关注对象与职责的划分，而不是它与其他对象的交互。比如说：一个对象只负责这个功能前端结构，其他不负责。功能也是的。若发生变化，只改动该功能该方法该对象。注意class还是method。其一遵循单一原则

源码解释如下。例如用户管理这个业务实现单一设计原则

```java
public interface UserMapper { 
 User selectUserById(Integer id); 
 void insertUser(User user); 
 // ... 其他数据库操作方法 
}
@Service 
public class UserService { 
 @Autowired 
 private UserMapper userMapper; 
 
 @Autowired 
 private UserValidator userValidator; 
 
 public void registerUser(User user) { 
 // 验证用户信息 
 if (!userValidator.validate(user)) { 
 throw new ValidationException("用户信息验证失败"); 
 } 
 // 保存用户信息到数据库 
 userMapper.insertUser(user); 
 } 
 // ... 其他业务逻辑方法 
} 
 
@Component 
public class UserValidator { 
 public boolean validate(User user) { 
 // 验证用户名、密码、邮箱等是否合法 
 // ... 
 return isValid; 
 } 
}
@RestController 
@RequestMapping("/user") 
public class UserController { 
 @Autowired 
 private UserService userService; 
 
 @PostMapping("/register") 
 public ResponseEntity<?> registerUser(@RequestBody User user) { 
 try { 
 userService.registerUser(user); 
 return ResponseEntity.ok("用户注册成功"); 
 } catch (Exception e) { 
 // 处理异常并返回错误信息 
 return ResponseEntity.status(HttpStatus.BAD_REQUEST).body(e.getMessage());
 } 
 } 
 // ... 其他HTTP请求处理方法 
}
```

# 2、里氏替换原则

定义：1、如果每个类型为T1的对象o1，都有类型为T2的对象o2，使得以T1定义的所有程序程序P在所有的对象o1都换成o2时，程序P的行为没有发现发生变化，那么类型T2是类型T1的子类型。换句话说，所有引用基类的地方必须能透明地使用其子类的对象。

2、在使用继承时，遵循里氏替换原则，在子类尽量不要重写父类的方法

3、里氏替换原则告诉我们，继承实际上让两个类耦合性增强，在适当的情况下，可以通过耦合、组合、依赖来解决问题

总结：继承解耦。解决办法：可以通过耦合、组合、依赖、

源码解释如下：

```java
@SpringBootTest
public class RichterSubstitution2 {

@Test
    void runTest()
    {
        A1 a1 = new A1();
        System.out.println("11-3="+ a1.func1(11, 3));
        System.out.println("1-8=" + a1.func1(1, 8));
        System.out.println("---------------------------------------");
        B1 b1 = new B1();
        System.out.println("11+3="+ b1.func1(11, 3));
        System.out.println("1+8=" + b1.func1(1, 8));
        System.out.println("11+3+9="+ b1.func2(11, 3));

//使用组合仍然可以实现A的项目相关功能
        System.out.println("11-3="+ b1.func3(11, 3));//这里本意是11-3

}

//创建一个更加基础的基类
class  Base {
    //把更加基础的方法和成员写到base类中
}

class  A1 extends Base  {
    //差
    public int func1(int num1, int num2)
    {
        return num1 - num2;
    }
}

class B1 extends Base {
    //还想用到A1类方法 使用组合方法
    private A1 a1=new A1();
    public int func1(int a, int b)
    {
        return a + b;
    }
    public int func2(int a, int b)
    {
        return func1(a, b)+9;
    }
    //使用组合仍然可以实现A的项目相关功能
    public int func3(int num1, int num2){
        return this.a1.func1(num1,num2);
    }
}
```

# 3、迪米特米法则

介绍：1）、一个对象应该对其他保持最少的了解

2）、类与类关系越密切，耦合度越大

3）、迪米特法则又叫最少知道原则，即一个类对自己依赖的类知道的越少越好。也就是说，对于被依赖的类不管多复杂，都尽量将逻辑封装在类的内部。对外部提供pulic方法，不对外泄露任何信息

4）、迪米特法则还有个更简单的定义：只与直接朋友通信

5）、**直接的朋友**：每个对象都会与其他对象有耦合关系，只要两个对象之间有**耦合关系**，就说这两个对象之间是朋友关系。耦合的方式很多：依赖、关联、组合、聚合等。其中我们称为**出现成员变量、方法参数、方法返回值中的类**称为直接的朋友，**而出现在局部变量中的类不是直接朋友**。也就是说，陌生的类最好不要以局部变量的形式出现在类的内部。

总结：

1、迪米特法则的核心是降低类之间的耦合

2、注意：由于每个类都减少了不必要的依赖，因此迪米特法则只是要求降低类之间(对象间)的耦合关系，并不是要求完全没有依赖关系

源码解释如下：

```java
@SpringBootTest
public class Demeter2 {
    //客户端
    @Test
    public void test() {
        System.out.println("~~~使用迪米特法则的改进~~~");
        //创建一个SchoolManager对象
        SchoolManager2 schoolManager2 = new SchoolManager2();
        //输出学院的员工id和学校总部的员工信息
        schoolManager2.printAllEmployee(new CollegeManager2());
    }
}

//学校总部员工类
@Data
class Employee2 {
    private String id;
}
//学院的员工类
@Data
class collegeEmployee2 {
    private String id;
}

//管理学院员工的管理类
class CollegeManager2 {
 //返回学院的所有员工
 public List<collegeEmployee> getAllEmployee() {
 List<collegeEmployee> list = new ArrayList<collegeEmployee>();
 for (int i = 0; i < 10; i++) {//这里我们增加了10个员工到list
 collegeEmployee emp = new collegeEmployee();
 emp.setId("学院员工id= " + i);
 list.add(emp);
 }
 return list;
 }
 public void printAllEmployee() {
 //获取到学院员工
 List<collegeEmployee> list1 = getAllEmployee();
 System.out.println("------------学院员工信息---------------");
 for (collegeEmployee e : list1) {
 System.out.println(e.getId());
 }
 }

}
//学校管理类
/**
 * 分析
 * 1、SchoolManager类的直接朋友类有哪些Employee、CollegeManager
 * 2、collegeEmployee不是直接朋友，而是一个陌生类，这样违背了迪米特法则
 */
class SchoolManager2 {
 public List<Employee2> getAllEmployee() {
 //返回学校总部的员工
 List<Employee2> list = new ArrayList<Employee2>();
 for (int i = 0; i < 5; i++) {//这里我们增加了5个员工到list
 Employee2 emp = new Employee2();
 emp.setId("学校总部员工id= " + i);
 list.add(emp);
 }
 return list;
 }

//该方法完成输出学校总部和学院员工信息(使用)
 void printAllEmployee(CollegeManager2 sub) {
 //获取到学院员工
 sub.printAllEmployee();//迪米特法则的改进
 //获取学校总部员工
 List<Employee2> allEmployee2 = this.getAllEmployee();
 System.out.println("------------学校总部员工信息---------------");
 for (Employee2 e : allEmployee2) {
 System.out.println(e.getId());
 }
 }
}
```

# 4、依赖倒置原则

定义：1）、高层模块不应该依赖底层模块，二者都应该依赖其抽象

2）、抽象不应该依赖细节、细节应该依赖抽象

3）、依赖倒转(倒置)的中心思想是面向接口编程

4）、依赖倒置原则是基于这样设计理念：相对于细节的多变性，抽象的东西要稳定的多。以抽象为基础搭建的架构比以细节为基础的架要稳定的多。在Java中，抽象指的是接口或者抽象类，细节就是具体的实现类

5）、使用接口或者抽象类的目的是制定好规范，而不涉及任何具体的操作，把展现细节的任务交给他们的实现类去完成

源码解释如，例如：存储程序阿里云、腾讯云、华为云

```java
// 抽象类：定义云服务存储服务的基本接口  
public abstract class CloudStorageService {  
  
    // 通用方法：记录操作日志  
    protected void logOperation(String operationName) {  
        System.out.println("执行操作：" + operationName);  
    }  
  
    // 抽象方法：需要子类实现文件上传逻辑  
    public abstract void uploadFile(String bucketName, String fileName, byte[] fileContent);  
  
    // 抽象方法：需要子类实现文件下载逻辑  
    public abstract byte[] downloadFile(String bucketName, String fileName);  
}
// 阿里云云服务存储服务实现  
public class AliyunCloudStorageService extends CloudStorageService {  
  
    @Override  
    public void uploadFile(String bucketName, String fileName, byte[] fileContent) {  
        // 调用阿里云API上传文件  
        logOperation("阿里云上传文件");  
        System.out.println("在阿里云bucket: " + bucketName + " 中上传文件: " + fileName);  
        // 这里应该添加实际的上传逻辑  
    }  
  
    @Override  
    public byte[] downloadFile(String bucketName, String fileName) {  
        // 调用阿里云API下载文件  
        logOperation("阿里云下载文件");  
        System.out.println("从阿里云bucket: " + bucketName + " 中下载文件: " + fileName);  
        // 这里应该添加实际的下载逻辑，并返回文件内容  
        return new byte[0]; // 示例返回空字节数组  
    }  
}  
  
// 腾讯云云服务存储服务实现（省略具体实现）  
public class TencentCloudStorageService extends CloudStorageService {  
    // ... 实现上传和下载文件的逻辑
    @Override  
    public void uploadFile(String bucketName, String fileName, byte[] fileContent) {  
        // 调用阿里云API上传文件  
        logOperation("阿里云上传文件");  
        System.out.println("在阿里云bucket: " + bucketName + " 中上传文件: " + fileName);  
        // 这里应该添加实际的上传逻辑  
    }  
  
    @Override  
    public byte[] downloadFile(String bucketName, String fileName) {  
        // 调用阿里云API下载文件  
        logOperation("阿里云下载文件");  
        System.out.println("从阿里云bucket: " + bucketName + " 中下载文件: " + fileName);  
        // 这里应该添加实际的下载逻辑，并返回文件内容  
        return new byte[0]; // 示例返回空字节数组  
    }  
}  
  
// 华为云云服务存储服务实现（省略具体实现）  
public class HuaweiCloudStorageService extends CloudStorageService {  
    // ... 实现上传和下载文件的逻辑
    @Override  
    public void uploadFile(String bucketName, String fileName, byte[] fileContent) {  
        // 调用阿里云API上传文件  
        logOperation("阿里云上传文件");  
        System.out.println("在阿里云bucket: " + bucketName + " 中上传文件: " + fileName);  
        // 这里应该添加实际的上传逻辑  
    }  
  
    @Override  
    public byte[] downloadFile(String bucketName, String fileName) {  
        // 调用阿里云API下载文件  
        logOperation("阿里云下载文件");  
        System.out.println("从阿里云bucket: " + bucketName + " 中下载文件: " + fileName);  
        // 这里应该添加实际的下载逻辑，并返回文件内容  
        return new byte[0]; // 示例返回空字节数组  
    }  
}
// 业务逻辑服务类，依赖于CloudStorageService  
public class FileService {  
  
    private final CloudStorageService cloudStorageService;  
  
    // 通过构造函数注入具体的云服务存储服务实现  
    public FileService(CloudStorageService cloudStorageService) {  
        this.cloudStorageService = cloudStorageService;  
    }  
  
    public void uploadFile(String bucketName, String fileName, byte[] fileContent) {  
        cloudStorageService.uploadFile(bucketName, fileName, fileContent);  
    }  
  
    public byte[] downloadFile(String bucketName, String fileName) {  
        return cloudStorageService.downloadFile(bucketName, fileName);  
    }  
}
public class CloudStorageApp {  
  
    public static void main(String[] args) {  
        // 假设我们当前使用阿里云的服务  
        CloudStorageService aliyunService = new AliyunCloudStorageService();  
        FileService fileService = new FileService(aliyunService);  
  
        // 示例：上传文件  
        byte[] fileContent = "Hello, Cloud!".getBytes();  
        fileService.uploadFile("my-bucket", "hello.txt", fileContent);  
  
        // 示例：下载文件（这里仅作演示，不会实际返回文件内容）  
        byte[] downloadedContent = fileService.downloadFile("my-bucket", "hello.txt");  
        // 处理下载的文件内容...  
    }  
}
```

总结：

依赖倒置：1、接口传参；2、构造器传参；3、setter传参

注意细节

1、低层模块尽量都要有抽象或接口，或者两者都有，程序稳定性更好

2、变量的申明类型尽量是抽象类或接口，这样我们的变量引用和实际对象间，就存在一个缓冲层，利于程序扩展和优化

3、继承时遵循里氏替换原则

# 5、接口隔离原则

定义：客户端不应该依赖它不需要的接口，一个类对另一个类的依赖应该建立在最小的接口上；这个原则跟自己实际工作有很大的关系，总结下来可以通过以下几点来定义接口

5-1、既不能是大而全，会强迫实现没有的东西，也会依赖自己不需要的东西

5-2、也不能一个方法一个接口，这样面向对象也没有意思的

5-3、接口合并Map--定位/搜索/导航这种属于固定步骤，业务细节，尽量的内聚，在接口也不要暴露太多业务细节(就是密切相连的可以放在一个接口来实现，而不是分多个接口实现功能)

总结：客户端不应该依赖它不需要的接口，一个类对另一个类的依赖应该建立在最小的接口上

```java
public class InterfaceIsolation2 {
    public static void main(String[] args) {
        //A1类通过接口依赖(使用)B1类
        A1 a1 = new A1();
        a1.depend1(new B1());
        a1.depend2(new B1());
        a1.depend3(new B1());

//C1类通过接口依赖(使用)D1类
        C1 c1 = new C1();
        c1.depend1(new D1());
        c1.depend4(new D1());
        c1.depend5(new D1());

}
}

//接口
interface Interface11 {
    void operation1();
}

interface Interface22 {
    void operation2();
    void operation3();
}
interface Interface33 {
    void operation4();
    void operation5();
}
class B1 implements Interface11, Interface22 {
    @Override
    public void operation1() {
        System.out.println("B1 实现了 operation1");
    }

@Override
    public void operation2() {
        System.out.println("B1 实现了 operation2");
    }
    @Override
    public void operation3() {
        System.out.println("B1 实现了 operation3");
    }
}
class D1 implements Interface11, Interface33 {
    @Override
    public void operation1() {
        System.out.println("D1 实现了 operation1");
    }

@Override
    public void operation4() {
        System.out.println("D1 实现了 operation4");
    }

@Override
    public void operation5() {
        System.out.println("D1 实现了 operation5");
    }
}

class A1 { //A类通过接口Interface1依赖(使用)B类，但是只会用到1,2,3方法
    public void depend1(Interface11 i) {
        i.operation1();
    }

public void depend2(Interface22 i) {
        i.operation2();
    }

public void depend3(Interface22 i) {
        i.operation3();
    }
}

class C1{ //C类通过接口Interface1依赖(使用)D类，但是只会用到1,4,5方法
    public void depend1(Interface11 i) {
        i.operation1();
    }

public void depend4(Interface33 i) {
        i.operation4();
    }

public void depend5(Interface33 i) {
        i.operation5();
    }
}

```

# 6、开闭原则

定义：1、开闭原则是编程中最基础、最重要的原则

2、一个软件实体如类，模块和函数应该对扩展开放(对提供方开放)，对修改关闭(对使用方)。用抽象构建框架，用实现类扩展细节

3、当软件需要变化时，尽量通过扩展软件实体的行为来实现变化，而不是通过修改已有的代码来实现变化。

4、编程中遵循其他原则，以及使用设计模式的目的是遵循开闭原则

改进思路如下：

把创建Shape类做成抽象类，并提供一个抽象的draw方法，让子类去实现即可，这样我们有新的图形种类时，只需要让新的图形类继承Shape，并实现draw方法即可，使用方的代码就不需要修改->满足了开闭原则

总结：跟依赖倒置原则有相似之处

```java
public class Ocp2 {
    @Test
    void runTest() {
        GraphicEdito2 graphicEdito2 = new GraphicEdito2();
        graphicEdito2.drawShape(new Rectangle1());
        graphicEdito2.drawShape(new Circle1());
        graphicEdito2.drawShape(new Triangle1());
        graphicEdito2.drawShape(new OtherShape()); 
    }
}
//使用方 不能修改
class GraphicEdito2 {
    public void drawShape(Shape1 s1) {
      s1.draw();
    }
}
//基类
abstract class Shape1 {
    int m_type;
    public abstract void draw();
}
//提供方
class Rectangle1 extends Shape1 {
   Rectangle1() {
       super.m_type=1;
   }
    @Override
    public void draw() {
        System.out.println("画一个矩形");
    }
}
//提供方
class Circle1 extends Shape1 {
    Circle1() {
        super.m_type=2;
    }
    @Override
    public void draw() {
        System.out.println("画一个圆形");
    }
}
//提供方
class Triangle1 extends Shape1 {
    Triangle1() {
        super.m_type=3;
    }

@Override
    public void draw() {
        System.out.println("画一个三角形");
    }
}
//提供方
class OtherShape extends Shape1 {
    OtherShape() {
        super.m_type=4;
    }

@Override
    public void draw() {
        System.out.println("画一个其他形状");
    }
}
```

# 7、合成复用原则

原则是尽量使用使用**合成/聚合**的方式，而不是使用继承

### 设计原则核心思想

1、找出应用可能发生变化之处，把它们独立出来，不要和哪些不需要变化的代码混在一起

2、针对接口编程、而不是针对实现编程

3、为了交互对象之间的松耦合关系设计

4、设计原则本质**提高软件的维护性、通用性和扩展性，并降低软件的复杂度。**

5、也是重点。根据业务场景考虑是否存在软件得维护性、通用性、扩展性才能涉及设计模式。否则。比如说结果转换成前端想要结构结构，用上外观、装饰器、适配器，确实可以实现。但是。

# 8.设计模式23种分类

1）、创建型模式：单例模式、抽象工厂模式、原型模式、建造者模式、工厂模式。

2）、结构型模式：适配器模式、桥接模式、装饰模式、组合模式、外观模式、享元模式、代理模式。

3）、行为型模式：模板方法模式、命令模式、访问者模式、迭代器模式、观察者模式、中介者模式、备忘录模式、解释器模式、状态模式、策略模式、职责链模式。

## 8.1单例模式

八种方式

1）、饿汉式(静态常量) 2）、饿汉式(静态代码块)    3）、懒汉式（线程不安全） 4）、懒汉式(线程安全，同步方法)  5）、懒汉式(线程安全、同步代码块)

6）、双重检查(加了方法synchronized和变量的volatile关键)  7）、静态内部类  8）、枚举

单例模式注意和细节说明

1）、单例模式保证了系统内存种该类只存在一个对象，节省了系统资源，对于一些需要频繁创建销毁的对象，使用单例模式可以提高系统性能。

2）、当想实例化一个单类的时候，必须要记住使用相应的获取对象的方法，而不是使用new

3)、单例模式使用的场景：需要频繁的进行创建和销毁对象、创建对象时耗时过多或者耗费资源过多(即：重量级对象)，但又经常用到的对象、工具类对象、频繁访问数据或者文件的对象(比如数据库、session工厂等)

## 8.2工厂模式

### 8.2.1、简单工厂模式

a、简单工厂模式是属于创建型模式 ，是工厂模式的一种。 简单工厂模式是由一个工厂对象决定创建出哪一 种产品类 的实例 。简单工厂模式是工厂模式家族
中最简单实用的模 式
    b、简 工厂模式：定义了一个创建对象的类，由这个类来 封装实例化对象的行为代码
    c、在软件开发中，当我们会用到大量的创建某种、某类或者某批对象时，就会使用到工厂模式

源码解释如下：

```java
/**
 * @description 简单工厂 模式
 */
@SpringBootTest
public class SimpleFactoryTest {
    @Test
    void runTest() {
        new OrderPizza1(new SimpleFactory());
        System.out.println("------------退出程序--------------------");
    }
    //静态工程模式
    @Test
    void runTest2() {
        new OrderPizza2();
        System.out.println("------------退出程序--------------------");
    }
}
//简单工厂模式===静态工厂模式
class OrderPizza2 {
    Pizza1 pizza1=null;
    String orderType = ""; //用户输入的
    public OrderPizza2() {
        do {
            orderType = getType();
            pizza1 = SimpleFactory.createPizza2(orderType);
            //输出pizza
            if (pizza1 != null) { //订购成功
                pizza1.prepare();
                pizza1.bake();
                pizza1.cut();
                pizza1.box();
                System.out.println("您订购的" + pizza1.getName() + "准备完毕");
            } else {
                System.out.println("订购失败");
                break;
            }
        } while (true);
    }

//写一个方法，获取客户希望订购的披萨种类
    private String getType() {
        try {
            BufferedReader str = new BufferedReader(new InputStreamReader(System.in));
            System.out.println("请输入Pizza类型:");
            return str.readLine();
        } catch (IOException e) {
            e.printStackTrace();
            return "";
        }
    }
}

class OrderPizza1 {
     SimpleFactory simpleFactory;

Pizza1 pizza1;

public OrderPizza1(SimpleFactory simpleFactory) {
        setPizza1(simpleFactory);
    }
    public void setPizza1(SimpleFactory simpleFactory) {
        String orderType = ""; //用户输入的
        this.simpleFactory = simpleFactory;//设置简单工厂对象
        do {
            orderType = getType();
            pizza1 = this.simpleFactory.createPizza(orderType);
            //输出pizza
            if (pizza1 != null) { //订购成功
                pizza1.prepare();
                pizza1.bake();
                pizza1.cut();
                pizza1.box();
                System.out.println("您订购的" + pizza1.getName() + "准备完毕");
            } else {
                System.out.println("订购失败");
                break;
            }
        } while (true);

}
    //写一个方法，获取客户希望订购的披萨种类
    private String getType() {
        try {
            BufferedReader strin =
                    new BufferedReader(new InputStreamReader(System.in));
            System.out.println("请输入Pizza类型:");
            return strin.readLine();
        } catch (IOException e) {
            e.printStackTrace();
            return "";
        }
    }
}

//简单工厂类 给 orderPizza用的
class SimpleFactory {
    public Pizza1 createPizza(String orderType) {
        System.out.println("------------使用简单工厂模式--------------------");
        Pizza1 pizza = null;
        switch (orderType){
            case "greek":
                pizza = new GreekPizza1();
                pizza.setName("希腊披萨");
                break;
            case "cheese":
                pizza = new CheesePizza1();
                pizza.setName("奶酪披萨");
                break;
            case "pepper":
                pizza = new PepperPizza1();
                pizza.setName("胡椒披萨");
                break;
            case "a":
                pizza = new APizza1();
                pizza.setName("A披萨");
                break;
        }
        return pizza;
    }

public static Pizza1 createPizza2(String orderType) {
        System.out.println("------------使用简单工厂模式--------------------");
        Pizza1 pizza = null;
        switch (orderType){
            case "greek":
                pizza = new GreekPizza1();
                pizza.setName("希腊披萨");
                break;
            case "cheese":
                pizza = new CheesePizza1();
                pizza.setName("奶酪披萨");
                break;
            case "pepper":
                pizza = new PepperPizza1();
                pizza.setName("胡椒披萨");
                break;
            case "a":
                pizza = new APizza1();
                pizza.setName("A披萨");
                break;
        }
        return pizza;
    }
}

@Data
abstract class Pizza1 {
    //披萨类别的名字
    protected String name;
    //准备披萨 不同的披萨不一样 开始
    public abstract void prepare();
    //开始制作方法
    public void bake() {
        System.out.println(name + "=baking");
    }
    public void cut() {
        System.out.println(name + "=cutting");
    }
    //结束制作方法
    public void box() {
        System.out.println(name + "=boxing");
    }

}
class CheesePizza1 extends Pizza1 {
    @Override
    public void prepare() {
        System.out.println(name + "准备原材料");
    }
}
class GreekPizza1 extends Pizza1 {
    @Override
    public void prepare() {
        System.out.println(name + "=准备原材料");
    }
}
class PepperPizza1 extends Pizza1 {
    @Override
    public void prepare() {
        System.out.println(name + "准备原材料");
    }
}
class APizza1 extends Pizza1 {

@Override
    public void prepare() {
        System.out.println(name + "准备原材料");
    }
}

```

### 8.2.2、抽象方法模式

定义：定义了一个创建对象的抽象方法，由子类决定要实例化的类。工厂方法模式将 对象的实例化推迟到子类。

源码解释

```java
/**
 * @author
 * @description 工厂方法模式
 */
@SpringBootTest
public class SimpleFactoryMethodTest {

//客户端
    @Test
    public void pizzaOrderClientTest() {
        new LDOrderPizza2();
    }

//根据地址选择pizza
    @Test
    public void pizzaLocOrderClientTest() throws IOException {
        String location = null;
        BufferedReader strin =
                new BufferedReader(new InputStreamReader(System.in));
        System.out.println("请输入位置:");
        location = strin.readLine();
        switch (location){
            case "BJ":
                new BJOrderPizza2();
                break;
            case "LD":
                new LDOrderPizza2();
                break;
            default:
                break;
        }
    }

}

class LDOrderPizza2 extends OrderPizza2 {
    @Override
    Pizza2 createPizza(String orderType) {
        Pizza2 pizza=null;
        if (orderType.equals("cheese")){
            pizza = new LDChessePizza2();
        }else if (orderType.equals("pepper")){
            pizza = new LDPepperPizza2();
        }
        return pizza;
    }
}

class BJOrderPizza2 extends OrderPizza2 {
    @Override
    Pizza2 createPizza(String orderType) {
        Pizza2 pizza=null;
        if (orderType.equals("cheese")){
            pizza = new BJCheesePizza2();
        }else if (orderType.equals("pepper")){
            pizza = new BJPepperPizza2();
        }
        return pizza;
    }
}
abstract class OrderPizza2 {
    abstract Pizza2 createPizza(String orderType);
    public OrderPizza2() {
        Pizza2 pizza=null;
        String orderType = ""; //用户输入的
        do {
            orderType = getType();
            pizza=createPizza(orderType);//抽象方法 由工厂子类完成
            //输出pizza
            if (pizza != null) { //订购成功
                pizza.prepare();
                pizza.bake();
                pizza.cut();
                pizza.box();
                System.out.println("您订购的" + pizza.getName() + "准备完毕");
            } else {
                System.out.println("订购失败");
                break;
            }
        } while (true);
    }

//写一个方法，获取客户希望订购的披萨种类
    private String getType() {
        try {
            BufferedReader strin =
                    new BufferedReader(new InputStreamReader(System.in));
            System.out.println("请输入Pizza类型:");
            return strin.readLine();
        } catch (IOException e) {
            e.printStackTrace();
            return "";
        }
    }
}

@Data
abstract class Pizza2 {
    //披萨类别的名字
    protected String name;
    //准备披萨 不同的披萨不一样 开始
    public abstract void prepare();

//开始制作方法
    public void bake() {System.out.println(name + "=baking");}
    public void cut() {System.out.println(name + "=cutting");}
    //结束制作方法
    public void box() {
        System.out.println(name + "=boxing");
    }

public void setName(String name) {
        this.name = name;
    }
}
class BJCheesePizza2 extends Pizza2 {
    @Override
    public void prepare() {
        setName("北京的奶酪pizza");
        System.out.println("北京的奶酪pizza准备原材料");
    }
}
class BJPepperPizza2 extends Pizza2 {
    @Override
    public void prepare() {
        setName("北京的胡椒pizza");
        System.out.println("北京的胡椒pizza准备原材料");
    }
}
class LDPepperPizza2 extends Pizza2 {
    @Override
    public void prepare() {
        setName("伦敦的胡椒pizza");
        System.out.println("伦敦的胡椒pizza准备原材料");
    }
}
class LDChessePizza2 extends Pizza2 {
    @Override
    public void prepare() {
        setName("伦敦的奶酪pizza");
        System.out.println("伦敦的奶酪pizza准备原材料");
    }
}
```

### 8.2.3、抽象工厂模式

1）、抽象工厂模式：定义一个interface用于创建相关或有依赖关系的对象簇、而无需指明具体的类。

2）、抽象工厂模式可以**简化工厂模式**和**工厂方法模式**进行整合。

3）、从设计层面看，抽象工厂模式就是对简单工厂模式的改进（或者称为进一步的抽象）。

4）、将工厂抽象成两层、**AbsFactory（抽象工厂）**和具体实现的工厂子类。程序员可以根据创建对象类型使用对应的工厂子类。这样将单子的简单工厂变成了工厂簇，更利于代码的维护和扩展。

源码解释如下：

```java
/**
 * @description 工厂抽象模式
 */
@SpringBootTest
public class AbsFactoryTest {

//客户端
    @Test
    public void pizzaStoreTest() {
        //开闭原则
        new OrderPizza(new BJFactoryImpl());
    }

@Test
    public void pizzaStoreLocationTest() throws IOException {
        //开闭原则
        String location = null;
        BufferedReader strin =
                new BufferedReader(new InputStreamReader(System.in));
        System.out.println("请输入位置:");
        location = strin.readLine();
        AbsFactory  absFactory=null;
        switch (location){
            case "BJ":
                absFactory= new BJFactoryImpl();
                break;
            case "LD":
                absFactory = new LDFactoryImpl();
                break;
            default:
                break;
        }
        new OrderPizza(absFactory);
    }
}
public abstract class Pizza3 {

//披萨类别的名字
    protected String name;

//准备披萨 不同的披萨不一样 开始
    public abstract void prepare();

//开始制作方法
    public void bake() {System.out.println(name + "baking");}

public void cut() {
        System.out.println(name + "=cutting");
    }

//结束制作方法
    public void box() {
        System.out.println(name + "=boxing");
    }

public void setName(String name) {
        this.name = name;
    }

public String getName() {
        return name;
    }
}
public class BJCheesePizza3 extends Pizza3{
    @Override
    public void prepare() {
        setName("北京的奶酪pizza");
        System.out.println("北京的奶酪pizza准备原材料");
    }
}
public class BJPepperPizza3 extends Pizza3{
    @Override
    public void prepare() {
        setName("北京的胡椒pizza");
        System.out.println("北京的胡椒pizza准备原材料");
    }
}
public class LDChessePizza3 extends Pizza3{
    @Override
    public void prepare() {
        setName("伦敦的奶酪pizza");
        System.out.println("伦敦的奶酪pizza准备原材料");
    }
}
public class LDPepperPizza3 extends Pizza3{
    @Override
    public void prepare() {
        setName("伦敦的胡椒pizza");
        System.out.println("伦敦的胡椒pizza准备原材料");
    }
}
public class OrderPizza {

AbsFactory absFactory;//聚合

public OrderPizza(AbsFactory absFactory){
        setAbsFactory(absFactory);
    }

private void setAbsFactory(AbsFactory absFactory){
        Pizza3 pizza = null;
        String orderType = "";
        this.absFactory = absFactory;
        do {
            orderType = getType();
            pizza= absFactory.createPizza3(orderType);
            if (pizza != null){
                pizza.prepare();
                pizza.bake();
                pizza.cut();
                pizza.box();
                System.out.println("您订购的" + pizza.getName() + "准备完毕");
            } else {
                System.out.println("订购失败");
                break;
            }

}while (true);
    }
    
    //写一个方法，获取客户希望订购的披萨种类
    private String getType() {
        try {
            BufferedReader strin =
                    new BufferedReader(new InputStreamReader(System.in));
            System.out.println("请输入Pizza类型:");
            return strin.readLine();
        } catch (IOException e) {
            e.printStackTrace();
            return "";
        }
    }
    
}
public interface AbsFactory {
    Pizza3 createPizza3(String orderType);
}
public class LDFactoryImpl implements AbsFactory {
    @Override
    public Pizza3 createPizza3(String orderType) {
        System.out.println("~使用LD抽象工厂模式~");
        Pizza3 pizza=null;
        if (orderType.equals("cheese")){
            pizza=new LDChessePizza3();
        }else if (orderType.equals("pepper")){
            pizza=new LDPepperPizza3();
        }
        return pizza;
    }
}
public class BJFactoryImpl implements AbsFactory {
    @Override
    public Pizza3 createPizza3(String orderType) {
        System.out.println("~使用BJ抽象工厂模式~");
        Pizza3 pizza = null;
        if (orderType.equals("cheese")){
            pizza = new BJCheesePizza3();
        }else if (orderType.equals("pepper")){
            pizza = new BJPepperPizza3();
        }
        return pizza;
    }
}

```

总结：

工厂模式的意义

将实例化对象的代码提取出来，放在一个类中统一管理和维护，达到和主项目的依赖关系的解耦i。从而提高项目的扩展和维护性。

三种工厂模式：简单工厂模式、工厂方法模式、抽象工厂模式

设计模式的**依赖抽象**原则

创建对象实例时，不要直接new类。而是把这个new类的动作放在一个工厂的方法中，并返回。

不要让继承具体的类。而是继承抽象类或者实现interface接口

不要覆盖基类中已经实现的方法

# 9、原型模式

# 10、建造者模式

基本介绍

1)、建造者模式（ Builder Pattern 又叫生 成器模式，是一种对象构建模式。它可以
将复杂对象的建造过程抽象出来（抽象类别），使这个抽象过程的不同实现方
法可以构造出不同表现（属性）的对象。
2)、建造者模式 是一步一步创建一个复杂的对象，它允许用户只通过指定复杂对象
的类型和内容就可以构建它们，用户不需要知道内部的具体构建细节 。

建造者模式的四个角色

1）Product(产品角色)：一个的产品对象

2）Builder(抽象建造者)：创建一个Product对象的各个部件指定的接口或者抽象类

3）ConcentrateBuilder(具体建造者)：实现接口，构建和装配各个部件

4）Director(指挥者)：构建一个使用Builder接口的对象。它主要用于创建一个复杂的对象。它主要有两个作用：一是：隔离了客户与对象生产的过程，二是：负责控制产品对象的生产过程

建造者模式的注意事项和细节

1）客户端(使用程序)必须知道产品内部组成的细节，将产品的本身与产品的创建过程解耦，使得相同的创建过程可以创建不同的产品对象。

2）每一个具体建造者都有相对独立，而与其他的具体建造者无关，因此可以很方便第替换具体建造者对增加新的具体建造者，用户使用不同的具体建造者既可得到不同的产品对象

3）可以更加精细地控制产品的创建过程。将复杂产品的创建步骤分解不同的方法中，使得创建过程更加清晰，也更方便使用程序来控制创建过程

4）增加新的具体建造者无须修改原有类库代码，指挥者类针对抽象建造者类编程，系统扩展方便，**符合”开闭原则“**

5）建造者模式所创建的产品一般具有较多的共同点，其组成部分相似，如果产品之间的差异很大，则不适合使用建造者模式，因此其使用范围收到一定的限制。

6）如果产品的内部变化很大，可能会导致需要定义很多具体建造者类来实现这种变化，导致系统变得庞大，因此这种情况下要考虑选择建造者模式

**7）抽象工厂模式与建造者模式的对比**

抽象工厂模式实现对产品家族的创建，一个产品家族是这样是一系列产品：具有不同分类维度的产品组合，采用抽象工厂模式不需要关心构建过程，只关心什么产品由什么工厂生产即可。

而建造者模式则是要求按照指定的蓝图建造产品，它是主要目的是通过组装零件而生产一个新的产品。

源码解释如下：

```java
@Data
@Component
public class House {

/**
     * 打地基
     */
    private String basic;

/**
     * 砌墙
     */
    private String wall;

/**
     * 封顶
     */
    private String roofed;

}
public abstract class HouseBuilder {

protected House house = new House();

/**
     * 打地基
     * @author
     */
    public abstract void buildBasic();

/**
     * 砌墙
     * @author
     */
    public abstract void buildWall();

/**
     * 封顶
     * @author
     */
    public abstract void roofed();

/**
     * 构造流程
     * @author
     */
    public House buildHouse() {
        return house;
    }
    
}
public class HighBuilding extends HouseBuilder{
    /**
     * 打地基
     *
     * @author
     */
    @Override
    public void buildBasic() {
        System.out.println("高楼打地基100米");
    }

/**
     * 砌墙
     *
     * @author
     */
    @Override
    public void buildWall() {
        System.out.println("高楼砌墙20cm");
    }

/**
     * 封顶
     *
     * @author
     */
    @Override
    public void roofed() {
        System.out.println("高楼的透明屋顶");
    }

/**
     * 高楼私自加了院子
     *
     * @author wf
     */
    public void yard() {
        System.out.println("高楼私自加了院子");
    }
}
public class CommonHouse extends HouseBuilder{
    /**
     * 打地基
     *
     * @author
     */
    @Override
    public void buildBasic() {
        System.out.println("给普通房子打地基5米");
    }

/**
     * 砌墙
     *
     * @author
     */
    @Override
    public void buildWall() {
        System.out.println("给普通房子砌墙10厘米");
    }

/**
     * 封顶
     *
     * @author
     */
    @Override
    public void roofed() {
        System.out.println("给普通房子封顶");
    }
}
public class HouseDirector {

protected HouseBuilder houseBuilder = null;

protected HouseType houseType;

/**
     * 有参构造方法  构造器传入HouseBuilder
     *
     * @param houseBuilder
     */
    public HouseDirector(HouseBuilder houseBuilder) {
        this.houseBuilder = houseBuilder;
    }

/**
     * 通过setter方法传入HouseBuilder
     * @param houseBuilder
     * @author wf
     */
    public void setHouseBuilder(HouseBuilder houseBuilder) {
        this.houseBuilder = houseBuilder;
    }

public void setHouseType(HouseType houseType) {
        this.houseType = houseType;
    }

/**
     * 如何构建房子的流程交给指挥者
     * @return
     * @author
     */
    public House constructHouse() {
        houseBuilder.buildBasic();
        houseBuilder.buildWall();
        houseBuilder.roofed();
        if (houseBuilder instanceof HighBuilding) {
            ((HighBuilding) houseBuilder).yard();
        }
        return houseBuilder.buildHouse();
    }
}
@SpringBootTest
public class ClientTest {

@Test
    public void testCommonHouse() {
        CommonHouse commonHouse = new CommonHouse();
        HouseDirector houseDirector = new HouseDirector(commonHouse);
        //完成产品的建造 返回房子
        House house = houseDirector.constructHouse();
        System.out.println("---------------------------------------");
        HighBuilding highBuilding = new HighBuilding();
        houseDirector.setHouseBuilder(highBuilding);
         //完成产品的建造 返回房子
        house = houseDirector.constructHouse();
    }
}

```

# 11、适配器模式

基本介绍

1)、适配器模式将某个类的接口转换成客户端期望的另一个接口表示，主要的目的是兼容性，让原本接口不匹配不能一起工作的两个类可以协同工作。其别名为包装器

2)、适配器模式属于结构模式

3)、分为三类：类适配器模式、对象适配器模式、接口适配器模式

工作原理：

1)、适配器模式：将一个类的接口转换成另一个接口。让原本接口不兼容的类可以兼容

2)、从用户的角度看不到被适配者，是解耦的

3)、用户调用适配器转化出来的目标接口方法，适配器在调用被适配器者的相关接口方法

4)、用户收到反馈结果，感觉只是和目标接口交互，如图

![image-20240727095254223](C:\Users\Lenovo\AppData\Roaming\Typora\typora-user-images\image-20240727095254223.png)

## 11.1、类适配器模式

类适配器模式介绍
基本介绍： Adapter 类，通过**继承** src 类，**实现** dst 类接口，完成 src -->dst 的适配

注意事项和细节

1)、Java是单继承机制，所以类适配器需要集成src类这一点算是一个缺点，因为这要求dst必须是接口，有一定局限性。

2)、src类方法在Adapter中都会暴露出来，也会增加使用的成本

3)、由于继承src类，所以它可以根据需求重写src类的方法，使其Adapter的灵活性增强。

源码解释如下：

```java
/**
 * @author
 * @description 被适配器的类
 */
public class Voltage220V {

public int output220V() {
        int src = 220;
        System.out.println("电压=" + src + "伏");
        return src;
    }
}
/**
 * @author
 * @description 适配器接口
 */
public interface IVoltage5V {
    int output5V();
}
/**
 * @author
 * @description 适配类
 */
@Component
public class VoltageAdapter extends Voltage220V implements IVoltage5V{
    //转换过程
    @Override
    public int output5V() {
        int srcV = output220V(); //获取被适配器者的电压
        int dstV = srcV / 44;//转换过程 5V
        return dstV;
    }
}
/**
 * @author
 * @description  手机充电
 */
@Component
public class Phone {

private static final int VOLTAGE = 5; //5伏电压

public void charging(IVoltage5V iVoltage5V) {
        if (iVoltage5V.output5V() == VOLTAGE) {
            System.out.println("电压为5V，可以充电");
        } else {
            System.out.println("电压不为5V，不能充电");
        }
    }
}
@SpringBootTest
public class Client {

@Autowired
    private Phone phone;

@Autowired
    private VoltageAdapter  voltageAdapter;

@Test
    public void test() {
        System.out.println("==========使用类适配器模式=========");
        phone.charging(voltageAdapter);
    }
}
```

## 11.2、对象适配器模式

基本介绍（改变组合关系，不在是继承）

1)、基 本思路和类的适配器模式相同，只是将 Adapter 类作修改 ，不 是 继 承 src 类，而
是持有 src 类的实例，以解决兼容性的问题。 即 ：持有 src 类，实现 dst 类接口，
完成 src -->dst 的适 配
2)、根 据“合成复用原则”，在系统中尽量使用关联关系来替代继承关 系。
3)、对象适配器模式是适配器模式常用的一种

注意事项或细节

1)、对象适配器和类适配器其他算是一种思想。只不过实现方式不同。根据组合复用原则，使其组合替代继承，所以它解决了类适配器必须继承src的局限性问题，也不再要求dst必须是接口

2)、使用成本更低，更加灵活。

源码解释如下：

```java
/**
 * @author
 * @description 被适配器的类
 */
public class Voltage220V {

//输入220V的电压
    public int output220V() {
        int src = 220;
        System.out.println("电压=" + src + "伏");
        return src;
    }
}
/**
 * @author
 * @description 适配器接口
 */
public interface IVoltage5V {
    int output5V();
}
/**
 * @author
 * @description 适配类
 */
public class VoltageAdapter implements IVoltage5V {

private Voltage220V voltage220V; //关联关系-聚合关系

//构造器注入实例
    public VoltageAdapter(Voltage220V voltage220V) {
        this.voltage220V = voltage220V;
    }

//转换过程
    @Override
    public int output5V() {
        int dstV = 0;
        if (null != voltage220V) {
            int srcV = voltage220V.output220V(); //获取被适配器者的电压
            System.out.println("使用对象适配器，进行适配~~~");
            dstV = srcV / 44;
            System.out.println("适配完成，输出电压为=" + dstV + "伏");
        }
        return dstV;
    }
}
/**
 * @author
 * @description  手机充电
 */
public class Phone {

private static final int VOLTAGE = 5; //5伏电压

@Test
    public void test() {
        System.out.println("==========使用类适配器模式=========");
        Phone phone = new Phone();
        phone.charging(new VoltageAdapter(new Voltage220V()));
    }
}
```

## 11.3、接口适配器模式

接口适配器模式介绍
1)、一些书籍 称 为：适 配器模式 (Default Adapter 或缺省适配器模式。
2)、**当不需要全部实现接口提供的方法时，可先设计一个抽象类实现接口，并为该接口中每个方法提供一个默认实现（空方法），那么该抽象类的子类可有选择地 覆盖父类的某些方法来实现需求**
3)、**适 用于一个接口不想使用其所有的方法的情况。**

源码解释如下

```java
/**
 * @author
 * @description 接口适配器
 */
public interface InterfaceAdapter {
    void m1();
    void m2();
    void m3();

void m4();
}
/**
 * @author
 * @description 空实现。默认实现InterfaceAdapter接口方法
 */
public abstract class AbsAdapter implements InterfaceAdapter {
    @Override
    public void m1() {}
    @Override
    public void m2() {}
    
    @Override
    public void m3() {}
    
    @Override
    public void m4() {}
}
@SpringBootTest
public class Client {

@Test
    void test(){
        AbsAdapter absAdapter = new AbsAdapter() {
            @Override
            public void m1() {
                System.out.println("使用接口m1的方法");
            }
        };
        absAdapter.m1();
    }
}

```

我的理解：

使用一个抽象类实现接口。然后用匿名内部内实现该接口的功能。(注意不太准确。只是某种写法)

# 12、桥接模式

基本介绍

1）、桥接模式（Bridge模式）是指：将实现与抽象放在两个不同的类层次中，使两个层次可以独立改变。

2）、是一种结构型设计模式

3）、Bridge模式基于类的最小设计原则，通过使用封装、聚合及继承等行为让不同的类承担不同的职责。它的主要特点是把抽象（Abstraction）与行为实现、

（Implementation）分离开来，从而可以保持各部分的独立性以及应对他们的功能扩展。

原理图如下:

![image-20240727175124241](C:\Users\Lenovo\AppData\Roaming\Typora\typora-user-images\image-20240727175124241.png)

原理类图说明:

1）、Client类：桥接模式的调用者。

2）、抽象类（Abstraction）：维护了Implementod/即它的实现类ConcreteImplementorA...,二者是聚合关系，Abstraction充当桥接类。

3）、RefinedAbstraction：是Abstraction抽象类的子类。

4）、Implementor：行为实现类的接口。

5）、ConcreteImplementorA/B：行为的具体实现类。

6）、从UML图：这里的抽象类和接口是聚合的关系，其实调用和被调用关系。
源码解释如下：

```java
/**
 * @author
 * @description 手机品牌接口
 */
public interface Brand {
    /**
     * 打开手机
     * @author
     */
    void open();

/**
     * 关闭手机
     * @author
     */
    void close();

/**
     * 打电话
     * @author
     */
    void call();
}
/**
 * @author
 * @description vivo功能
 */
public class Vivo implements Brand{
    /**
     * 打开手机
     *
     * @author
     */
    @Override
    public void open() {
        System.out.println("vivo手机开机");
    }

/**
     * 关闭手机
     *
     * @author
     */
    @Override
    public void close() {
        System.out.println("vivo手机关机");
    }

/**
     * 打电话
     *
     * @author
     */
    @Override
    public void call() {
        System.out.println("vivo手机打电话");
    }
}
/**
 * @author
 * @description 小米手机功能类
 */
public class XiaoMi implements Brand {
    /**
     * 打开手机
     *
     * @author
     */
    @Override
    public void open() {
        System.out.println("小米手机开机");
    }

/**
     * 关闭手机
     *
     * @author
     */
    @Override
    public void close() {
        System.out.println("小米手机关机");
    }

/**
     * 打电话
     *
     * @author
     */
    @Override
    public void call() {
        System.out.println("小米手机打电话");
    }
}
/**
 * @author
 * @description 手机抽象类
 */
public abstract class Phone {
    //聚合 =>桥接关系
    private Brand brand;

//构造器
    public Phone(Brand brand) {
        this.brand = brand;
    }

protected void call() {
        brand.call();
    }

protected void close() {
        brand.close();
    }

protected void open() {
        brand.open();
    }
}
/**
 * @author
 * @description 手机样式折叠
 */
public class FoldedPhone extends Phone{
    //构造器
    public FoldedPhone(Brand brand) {
        super(brand);
    }

public void call() {
        super.call();
        System.out.println("折叠样式手机");
    }

public void close() {
        super.close();
        System.out.println("折叠样式手机");
    }

public void open() {
        super.open();
        System.out.println("折叠样式手机");
    }
}
/**
 * @author
 * @description 样式直板手机
 */
public class UpRightPhone extends Phone {
    //构造器
    public UpRightPhone(Brand brand) {
        super(brand);
    }

public void call() {
        super.call();
        System.out.println("直立样式手机");
    }

public void close() {
        super.close();
        System.out.println("直立样式手机");
    }

public void open() {
        super.open();
        System.out.println("直立样式手机");
    }
}
@SpringBootTest
public class Client {
    @Test
    void test() {
        //从关系来说多对多的关系
        //样式手机+品牌  针对品牌的
        System.out.println("=============样式手机+品牌  针对品牌的==================");
        Phone foldedPhone = new FoldedPhone(new XiaoMi());
        foldedPhone.open();
        foldedPhone.close();
        foldedPhone.call();
        System.out.println("===============================");
        Phone foldedPhone1 = new FoldedPhone(new Vivo());
        foldedPhone1.open();
        foldedPhone1.close();
        foldedPhone1.call();
        //样式手机+品牌  针对样式的
        System.out.println("=============样式手机+品牌  针对样式的==================");
        Phone upRightPhone = new UpRightPhone(new XiaoMi());
        upRightPhone.open();
        upRightPhone.close();
        upRightPhone.call();
    }
}

```

注意事项和细节如下：

1）、实现抽象和实现部分的分离，从而极大提供了系统的灵活性，让抽象部分和实际部分独立出来，这有助于系统分层设计，从而产生更好的结构化系统。

2）、对于系统的高层部分，只需要知道抽象部分和实现部分的接口就可以了，其他的部分由业务来完成。

3）、桥接模式替代多层继承方案，可以减少子类的个数，降低系统的管理和维护成本。

4）、桥接模式的引入增加了系统的系统理解和设计难度，由于聚合关系建立在抽象层，要求开发者针对抽象进行设计和编程。

5）、桥接模式要求正确识别系统中两个独立变化的维度，因此其使用范围有一定的局限性，即需要有这样的应用场景。

应用场景如下：

1）、对于那些不希望使用继承或因为多层次继承导致系统类的个数急剧增加的系统（类爆炸），桥接模式尤为适用。

2）、常见的应用场景：-JDBC程序

-银行转账系统

-消息管理

消息类型：即时消息、延时消息

消息分类：手机短信、邮件消息、QQ消息

# 13、装饰者模式。注意不是懂这块

定义：**动态的将新功能附加到对象上**。在对象功能扩展方面，它比继承更有弹性，装饰者模式也体现了开闭原则（ocp）

实现方法：可以实现内部内实现方法，看需求。

IO流的部分解析图如下：

![image-20240728155016245](C:\Users\Lenovo\AppData\Roaming\Typora\typora-user-images\image-20240728155016245.png)

源码解释如下：

```java
/**
 * @author
 * @description 最高层抽象 行为的最高层(暂时的理解)
 */
@Data
public abstract class Drink {

String description;

private float price=0.0f;

//计算费用的抽象方法 被子类实现
    public abstract float cost();
}
public class Coffee extends Drink{
    @Override
    public float cost() {
        return super.getPrice();
    }
}
/**
 * @author
 * @description 无因咖啡
 */
public class Decaf extends Coffee{

public Decaf() {
        setDescription("无因咖啡");
        setPrice(1.0f);
    }
}
/**
 * @author
 * @description 美式咖啡
 */
public class LongBlack extends Coffee{

public LongBlack() {
        setDescription("LongBlack");
        setPrice(5.0f);
    }
}
/**
 * @author
 * @description 装饰者
 */
public class Decorator extends Drink{

//组合+继承 构成装饰者
    private Drink drink;

public Decorator(Drink drink) { //组合
        this.drink = drink;
    }

/**
     * @return
     */
    @Override
    public float cost() {
        //自己价格
        return super.getPrice()+drink.cost();
    }

/**
     * @return
     */
    @Override
    public String getDescription() {
        //输出 父类描述+父类价格+被装饰者的信息
        return super.getDescription()+"-----"+super.getPrice()+" && "+drink.getDescription();
    }
}
/**
 * @author
 * @description 牛奶
 */
public class Milk extends Decorator{
    public Milk(Drink drink) {
        super(drink);
        setDescription("牛奶");
        setPrice(2.0f);
    }
}
/**
 * @author
 * @description 牛奶
 */
public class Milk extends Decorator{
    public Milk(Drink drink) {
        super(drink);
        setDescription("牛奶");
        setPrice(2.0f);
    }
}
/**
 * @author
 * @description 装饰者测试
 */
@SpringBootTest
public class CoffeeBar {

@Test
    void test() {
        //装饰者模式下的订单：2份巧克力+一份牛奶的LongBlack
        //1、点了一份LongBlack
        Drink order = new LongBlack();
        System.out.println("order LongBlack费用：" + order.cost());
        System.out.println("order LongBlack订单描述：" + order.getDescription());
        //2、加了一份牛奶
        order = new Milk(order);
        System.out.println("order LongBlack加了一份牛奶费用：" + order.cost());
        System.out.println("order LongBlack加了一份牛奶订单描述：" + order.getDescription());
        //3、加了一份巧克力
        order = new Chocolate(order);
        System.out.println("order LongBlack加了一份牛奶 LongBlack加了一份巧克力费用：" + order.cost());
        System.out.println("order LongBlack加了一份牛奶 LongBlack加了一份巧克力订单描述：" + order.getDescription());
        //4、又加了一份巧克力
        order = new Chocolate(order);
        System.out.println("order LongBlack加了一份牛奶 LongBlack加了2份巧克力费用：" + order.cost());
        System.out.println("order LongBlack加了一份牛奶 LongBlack加了2份巧克力订单描述：" + order.getDescription());
    }

@Test
    void test2() {
        Drink order2 = new Decaf();
        System.out.println("order2 无因咖啡费用：" + order2.cost());
        System.out.println("order2 无因咖啡订单描述：" + order2.getDescription());

order2 = new Milk(order2);
        System.out.println("order 无因咖啡加了一份牛奶费用：" + order2.cost());
        System.out.println("order 无因咖啡加了一份牛奶订单描述：" + order2.getDescription());
    }

@Test
    void test3() throws Exception {
        /**
         * 说明
         * 1.InputStream是抽象类，类似前面提到的Drink
         * 2.FileInputStream是InputStream的子类，类似前面提到的Decaf
         * 3.FilterInputStream是InputStream的子类，类似前面提到的Decorator修饰者
         * 4.DataInputStream是FileInputStream的子类，具体的修饰者，类似前面提到的Milk
         * 5.FilterInputStream类有protected volatile InputStream in;即含被装饰者
         * 6.分析得出在jdk的io体系中，就是使用装饰者模式
         */
        DataInputStream dis = new DataInputStream(new FileInputStream("d:abc.txt"));
        System.out.println(dis.read());
        dis.close();

}
}
```

# 13、组合模式

基本介绍

1）、组合模式又叫部分整体模式，它创建了对象组的树形结构，将对象组合成树状结构以表示”整体-部分“的层次关系。

2）、组合模式依据树形结构来组合对象，用来表示部分以及整体层次。

3）、这种类型的设计属于结构模式

4）、组合模式使得用户对单个对象和组合对象和访问具有一致性，即：组合能客户以一致得方式处理个别对象以及组合对象。

**组合模式的原理类图**

![image-20240804151433724](C:\Users\Lenovo\AppData\Roaming\Typora\typora-user-images\image-20240804151433724.png)

对原理结构图得说明-即(组合模式得角色及职责)

1）、Component：这个组合中对象声明接口，在适当情况下，实现所有类共有得接口默认行为，用于访问和管理(Component)子部件，Component可以是抽象类或接口。

2）、Leaf：在组合表示叶子节点，叶子节点没有子节点。

3）、Composite：非叶子子节点，用于存储子部件，在Component接口实现子部件得相关操作。比如增加（add）、删除（remove）。

角色的问题

1）、组合模式角色这样的问题，当我们的要处理的对象可以生成一颗树形结构，而要对树上的节点和叶子进行操作时，它能够提供一致的方式，而不用考虑它是节点还是叶子 。

2）、对应的示意图如下：

![image-20240804153316993](C:\Users\Lenovo\AppData\Roaming\Typora\typora-user-images\image-20240804153316993.png)

源码解释

```java
public abstract class OrganizationComponent {
    /**
     * 名字
     */
    private String name;
    /**
     * 说明
     */
    private String des;

protected void add(OrganizationComponent organizationComponent) {
        //默认实现
        throw new UnsupportedOperationException();
    }

protected void remove(OrganizationComponent organizationComponent) {
        //默认实现
        throw new UnsupportedOperationException();
    }

//构造器
    public OrganizationComponent(String name, String des) {
        super();
        this.name = name;
        this.des = des;
    }

public String getName() {
        return name;
    }

public void setName(String name) {
        this.name = name;
    }

public String getDes() {
        return des;
    }

public void setDes(String des) {
        this.des = des;
    }

/**
 * 每个子类都需要实现
 */
 public abstract void print();
}
public class University extends OrganizationComponent{
 
 List<OrganizationComponent> organizationComponents=new ArrayList<OrganizationComponent>();

public University(String name, String des) {
        super(name, des);
    }

/**
     * @param organizationComponent 
     */
    @Override
    protected void add(OrganizationComponent organizationComponent) {
        organizationComponents.add(organizationComponent);
    }

/**
     * @param organizationComponent 
     */
    @Override
    protected void remove(OrganizationComponent organizationComponent) {
        organizationComponents.remove(organizationComponent);
    }

/**
     * @return
     */
    @Override
    public String getName() {
        return super.getName();
    }

/**
     * @return
     */
    @Override
    public String getDes() {
        return super.getDes();
    }

/**
     * 每个子类都需要实现
     * 就是输出包含University的学院信息
     */
    @Override
    public void print() {
        System.out.println("----------" + getName() + "----------"  );
        //遍历list集合
        for (OrganizationComponent organizationComponent : organizationComponents) {
            organizationComponent.print();
        }

}
}
public class Department extends OrganizationComponent{
    public Department(String name, String des) {
        super(name, des);
    }

/**
     * @return
     */
    @Override
    public String getName() {
        return super.getName();
    }

/**
     * @return
     */
    @Override
    public String getDes() {
        return super.getDes();
    }

/**
 * 每个子类都需要实现
 */
 @Override
 public void print() {
 System.out.println(getName());
 }
}
public class College extends OrganizationComponent{
 List<OrganizationComponent> organizationComponents=new ArrayList<OrganizationComponent>();

public College(String name, String des) {
        super(name, des);
    }

/**
     * @param organizationComponent
     */
    @Override
    protected void add(OrganizationComponent organizationComponent) {
        organizationComponents.add(organizationComponent);
    }

/**
     * @param organizationComponent
     */
    @Override
    protected void remove(OrganizationComponent organizationComponent) {
        organizationComponents.remove(organizationComponent);
    }

/**
     * @return
     */
    @Override
    public String getName() {
        return super.getName();
    }

/**
     * @return
     */
    @Override
    public String getDes() {
        return super.getDes();
    }

/**
     * 每个子类都需要实现
     */
    @Override
    public void print() {
        System.out.println("----------" + getName() + "----------"  );
        //遍历list集合
        for (OrganizationComponent organizationComponent : organizationComponents) {
            organizationComponent.print();
        }

}
}
@SpringBootTest
public class Client {

@Test
    void client(){
        //创建大学
        OrganizationComponent university=new University("清华大学","中国顶级大学");
        //创建大学的学院
        OrganizationComponent computerCollege=new College("计算机学院","计算机学院");
        OrganizationComponent infoEngineerCollege=new College("信息学院","信息学院");
        //创建大学的各个学院的专业
        computerCollege.add(new Department("软件工程","软件工程专业"));
        computerCollege.add(new Department("网络工程","网络工程专业"));
        computerCollege.add(new Department("计算机科学与技术","计算机科学与技术专业"));

infoEngineerCollege.add(new Department("通信工程","通信工程专业"));
        infoEngineerCollege.add(new Department("信息工程","信息工程专业"));

//将学院加入到学校中
        university.add(computerCollege);
        university.add(infoEngineerCollege);

infoEngineerCollege.print();
    }

@Test
 void test2(){
 Map<Integer, String> hashMap = new HashMap<>();
 hashMap.put(0,"东游记");
 Map<Integer, String> map = new HashMap<>();
 map.put(1,"西游记");
 map.put(2,"三国演义");
 map.putAll(hashMap);
 System.out.println(map.get(0));

}
}
```

**组合模式的注意事项和细节**
1)、简 化客户端操作。客户端只需要面对一致的对象而不用考虑整体部分或者节点叶子的问题 。
2)、具 有较强的扩展性。当我们要更改组合对象时，我们只需要调整内部的层次关系，客户端不用做出任何改动
3)、方便创建出复杂的层次结构。客户端不用理会组合里面的组成细节，容易添加节点或者叶子从而创建出复杂的树形结 构
4)、需 要遍历组织机构，或者处理的对象具有树形结构 时 , 非常适合使用组合模式
5)、要求较高的抽象性， 如果节点和叶子有很多差异性的话 ，比如很多方法和属性都不一样 不适 合使用组合 模式

# 14、外观模式

基本介绍
1)、外观模式（ Facade 也叫 过程模式 ：外 观模 式为 子系统中的一组接口提供一个一致的界面，此模式定义了一个高层接口，这个接口使得这一子系统更加
       容易使用。
2)、外观模式通 过定义一个一致的接口，用以屏蔽内部子系统的细节，使得调用端只需跟这个接口发生调用，而无需关心这个子系统的内部细节

外观模式的原理类图

![image-20240804171236401](C:\Users\Lenovo\AppData\Roaming\Typora\typora-user-images\image-20240804171236401.png)

对原理类图的说明(外观模式角色)

1）、外观（Facede）:为调用断提供统一接口的调用接口，外观类知道哪些子系统负责处理请求，从而将调用端的请求代理给适当子系统对象。

2）、调用这（Cilent）：外观接口的调用者。

3）、子系统的集合：指模块或者子系统，处理Facade对象指派的任务，他是功能实际提供者。

源码解释

````java
public class Popcorn {
    private static Popcorn instance = new Popcorn();

public static Popcorn getInstance() {
        return instance;
    }

public void on() {
        System.out.println("Popcorn on");
    }

public void off() {
        System.out.println("Popcorn off");
    }

public void pop() {
        System.out.println("Popcorn is poping");
    }
    
}
public class Projector {

//使用饿汉式单例模式
    private static Projector instance = new Projector();

public static Projector getInstance() {
        return instance;
    }

public void on() {
        System.out.println("Projector is on");
    }

public void off() {
        System.out.println("Projector is off");
    }

public void pop() {
        System.out.println("Projector is poping");
    }

public void pause() {
        System.out.println("Projector is pausing");
    }

}
public class Screen {
    private static Screen instance = new Screen();

public static Screen getInstance() {
        return instance;
    }

public void up() {
        System.out.println("Screen up");
    }

public void down() {
        System.out.println("Screen down");
    }
}
public class Stereo {

//使用饿汉式单例模式
    private static Stereo instance = new Stereo();

public static Stereo getInstance() {
        return instance;
    }

public void on()
    {
        System.out.println("Stereo on");
    }
    public void off()
    {
        System.out.println("Stereo off");
    }

public void up()
    {
        System.out.println("Stereo up");
    }

public void down()
    {
        System.out.println("Stereo down");
    }
}
public class TheaterLight {

//使用饿汉式单例模式
    private static TheaterLight instance = new TheaterLight();

public static TheaterLight getInstance() {
        return instance;
    }

public void on() {
        System.out.println("TheaterLight on ");
    }

public void off() {
        System.out.println("TheaterLight off ");
    }

public void dim() {
        System.out.println("TheaterLight dim... ");
    }

public void bright() {
        System.out.println("TheaterLight bright... ");
    }
}
public class DVDPlayer {

//使用饿汉式单例模式
    private static DVDPlayer instance = new DVDPlayer();

public static DVDPlayer getInstance() {
        return instance;
    }

public void on() {
        System.out.println("DVD is on");
    }

public void off() {
        System.out.println("DVD is off");
    }

public void play() {
        System.out.println("DVD is playing");
    }

public void pause() {
        System.out.println("DVD  pause...");
    }

//.......
}
public class HomeTheaterFacade {

private TheaterLight theaterLight;
    private Popcorn popcorn;
    private Stereo stereo;
    private Projector projector;
    private Screen screen;
    private DVDPlayer dvdPlayer;

//无参构造函器
    public HomeTheaterFacade() {
        super();
        theaterLight = theaterLight.getInstance();
        popcorn = popcorn.getInstance();
        stereo = stereo.getInstance();
        projector = projector.getInstance();
        screen = screen.getInstance();
        dvdPlayer = dvdPlayer.getInstance();
    }

//操作分成四步
    public void ready() {
        popcorn.on();
        popcorn.pop();
        screen.down();
        projector.on();
        stereo.on();
        dvdPlayer.on();
        theaterLight.dim();
    }

public void play() {
        dvdPlayer.play();
    }

public void pause() {
        dvdPlayer.pause();
    }

public void end() {
        popcorn.off();
        theaterLight.bright();
        screen.up();
        projector.off();
        stereo.off();
        dvdPlayer.off();
    }
}
@SpringBootTest
public class ClientTest {

@Test
    void client() {
        HomeTheaterFacade homeTheaterFacade = new HomeTheaterFacade();
        homeTheaterFacade.ready();
        homeTheaterFacade.play();
        //homeTheaterFacade.pause();
        homeTheaterFacade.end();
    }
}
````

**外观模式的注意事项和细节**
1)、外观模式对外屏蔽了子系统的细节，因此外观模式降低了客户端对子系统使用的复杂性
2)、外 观模 式 对 客 户端与子系统的耦合关系，让子系统内部的模块更易维护和扩 展。
3)、通 过合理的使用外观模式，可以帮我们更好的划分访问的层 次。
4)、当系统需要进行分层设计 时 可 以考虑使用 Facade 模 式。
5)、在 维护一个遗留的大型系统时，可能这个系统已经变得非常难以维护和扩展，此时可以考虑为新系统开发一个 Facade 类，来提供遗留系统的比较清晰简单的    接口，让新系统与 Facade 类交 互， 提 高复用性
6)、不能过多的或者不合理的使用外观模 式，使用 外 观模式好 还 是直接调用模块 好。要以让系统有层次，利于维护为目的

# 15、享元模式(理解共享对象模式)

# 16、代理模式

# 17、模板模式

个人读源码说明

比如用RedisTemplate模板，这个模板使用规范一些操作redis的方法，比如opsForHash()。提供user使用

```java
RedisTemplate<String,Object> redisTemplate=null;
redisTemplate.opsForHash().putAll("", null);
redisTemplate.opsForValue().set("", "");
```

# 18、策略模式

个人阅读源码理解

总结一句话：根据需要选择合适的序列化策略，并通过配置RedisTemplate来使用这些策略。这样，您就可以在不修改RedisTemplate代码的情况下，灵活地适应不同储存方法。下面代码是配置redis的策略。如redis是根据String类型的策略模式序列化。

```java
@Configuration
public class RedisConfig {
 @Bean
 public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory factory) {
 RedisTemplate<String, Object> template = new RedisTemplate<>();
 // Key HashKey使用String序列化
 template.setKeySerializer(RedisSerializer.json());
 //template.setKeySerializer(RedisSerializer.string());
 template.setHashKeySerializer(RedisSerializer.byteArray());
 //template.setHashKeySerializer(RedisSerializer.string());

// Value HashValue使用Json序列化
        template.setValueSerializer(RedisSerializer.json());
        template.setHashValueSerializer(RedisSerializer.json());

template.setConnectionFactory(factory);
        return template;
    }
}
```

# 观察者模式

个人理解RabiitMq的部分实现就是观察者模式，发生端消费端

# 责任链模式

OwenWu/Java的设计模式

简介

发行版

贡献者

近期动态

OwenWu/Java的设计模式 .gitee-modal { width: 500px !important; }

简介

发行版

贡献者

近期动态

搜索帮助

OwenWu/Java的设计模式