【设计模式】六原则(三)依赖倒置原则

本文最后更新于：2021年12月13日 下午

依赖倒置原则

1、定义(Dependence Inversion Principle，DIP)

高层模块不应该依赖低层模块，应该依赖其抽象，抽象不应该依赖其细节，细节应该依赖其抽象

1
2
3
4
低层模块：java类
高层模块：各个java类组合而成，像service实现类
抽象：接口或抽象类
细节：接口或抽象类实现

2、优点

  1. 降低类间的耦合性；
  2. 提高系统的稳定性；
  3. 减少并行开发引起的风险；
  4. 提高代码的可读性和可维护性。

3、示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
package cc.niushuai.study.designpattern.sixprinciples.dip;

import lombok.AllArgsConstructor;
import lombok.Data;

/**
 * TODO
 *
 * @author niushuai
 * @date 2021/10/18 17:23:19
 */

class AShop {}
class BShop {}

@Data
@AllArgsConstructor
class Customer {
    private String name;
    public void shopping(AShop shop) {
        System.out.println(this.getName() + " 在 aShop shopping ...");
    }

    public void shopping(BShop shop) {
        System.out.println(this.getName() + " 在 bShop shopping ...");
    }
}

public class Main {
    public static void main(String[] args) {

        Customer customer = new Customer("张三");

        customer.shopping(new AShop());
        customer.shopping(new BShop());
    }
}

运行结果:

1
2
张三 在 aShop shopping ...
张三 在 bShop shopping ...

每个商店都是单独的一个实体类, 能不能抽象出Shop存在一个name

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
package cc.niushuai.study.designpattern.sixprinciples.dip.main1;

import lombok.AllArgsConstructor;
import lombok.Data;

/**
 * TODO
 *
 * @author niushuai
 * @date 2021/10/18 17:23:19
 */
interface Shop {
    String name();
    String sales();
}

class AShop implements Shop{

    @Override
    public String name() {
        return "AShop";
    }

    @Override
    public String sales() {
        return "铅笔";
    }
}

class BShop implements Shop{

    @Override
    public String name() {
        return "BShop";
    }

    @Override
    public String sales() {
        return "橡皮";
    }
}

@Data
@AllArgsConstructor
class Customer {
    private String name;

    public void shopping(Shop shop) {
        System.out.println(this.getName() + " 在 " + shop.name() + " shopping ... 买" + shop.sales());
    }
}

public class Main1 {
    public static void main(String[] args) {

        Customer customer = new Customer("张三");

        customer.shopping(new AShop());
        customer.shopping(new BShop());
    }
}

运行结果:

1
2
张三 在 AShop shopping ... 买铅笔
张三 在 BShop shopping ... 买橡皮

这样无论存在多少商店，只需要扩展商店的子类即可