一、开闭原则

1.1 概念

开闭原则是设计模式中最重要也是最基本的原则，可以说其它的原则都是为了开闭原则进行服务的。

核心概念：

  1. 一个软件实体如类，模块和函数应该对扩展开放(对提供方)，对修改关闭(对使用方)。对抽象构建框架，用实现扩展细节。
  2. 当软件需要实现时，尽量通过扩展软件实体的行为来实现变化，而不是通过修改已有的代码来实现变化。
  3. 编程中遵循其它原则，以及使用设计模式的目的就是遵循开闭原则。

综合：对扩展新功能是开放的，对修改原有功能是关闭的。也就说，在对功能进行扩展时，是对原有的类上进行扩展(继承、接口设计等等)

1.2 实例演示

需求：商家可以卖不同类型的车以及各种促销活动。

对Car的类设计：

1
2
3
4
5
6
7
public class Car {
    private String brand;
    private double price;
    private String color;
    private boolean louYou;
	// 省略getter和setter及toString()方法
}

现在对该类的正常使用，表明正常构造的一辆车。

1
2
3
4
5
6
7
8
9
10
public class AppTest {
    public static void main(String[] args) {
        Car car = new Car(); 
        car.setBrand("奔驰");
        car.setColor("black");
        car.setLouYou(true);
        car.setPrice(6666666);
        System.out.println(car);
    }
}

现在变化出现了。如果商家需要对，所有车进行打折、促销活动，在原价格的基础上*0.8。

此时，要符合开闭原则，就是对修改关闭，对扩展开放。所以，我们不能在源代码上进行修改，而是在对源代码不改变的基础上，进行类功能的扩展。所以，我们可以扩展出一个DiscountCar来继承Car，即对Car的功能的扩展。

1
2
3
4
5
6
public class DiscountCar extends Car {
    @Override
    public double getPrice() {
        return super.getPrice()*0.8;
    }
}

此时：

1
2
3
4
5
6
7
8
9
10
public class AppTest {
    public static void main(String[] args) {
        Car car = new DiscountCar(); // 向上转型，调用方法，只和new 的对象有关
        car.setBrand("奔驰");
        car.setColor("black");
        car.setLouYou(true);
        car.setPrice(6666666);
        System.out.println(car);
    }
}

这里的DiscountCar是对源代码的扩展，而没有修改源代码，所以符合开闭原则。

二、迪米特法则

2.1 介绍

迪米特法则也叫最少知道原则。即一个类，对于其他类，要知道的越少越好，只和朋友进行通信。

  1. 一个对象应该对其他对象保持最少的了解

  2. 类与类的关系越密切，耦合度越大

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

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

    具体看一看什么不是朋友。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    public class Demo {
        public void test(B b) {
            A a = b.getA(); // 此时a是局部变量就不是test方法中的朋友，不能直接使用a的方法
            // 如果要想使用a，该怎么办？
            f1(a);// 即将对其使用的逻辑再进行封装成一个方法，将其作为朋友传入。此时a就是f1中的朋友，可以对其直接使用
        }
        
        public void f1(A a){
            // 处理逻辑 此时a是f1的朋友，可以任意调用其方法
        }
    }

    class A { 
    }

    class B {
        public A getA() {
            return new A();
        }
    }

2.2 实例

需求：给用户生产一台电脑供用户使用(只实现简单的关机功能)。

看下面这段代码：

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
public class AppTest {

}

class Computer {
    public void saveDate() {
        System.out.println("保存数据");
    }

    public void killProcess() {
        System.out.println("关闭程序");
    }

    public void closeScreen() {
        System.out.println("关闭屏幕");
    }

    public void powerOff() {
        System.out.println("断电");
    }
}

class Person { //
    private Computer computer = new Computer();
    // 此时，这个Person对于Computer的细节就知道的太多了。实际意义是：让用户关个机，他自己需要做那么多步骤才能够关机
    // 对于Person，只需要知道，关机按钮在哪里就行了，不需要知道如何保存数据，如果关闭程序...
    // 这样的话，代码的复杂度就提升了，万一用户操作错误，就会出现错误
    public void shutDown() {
        computer.saveDate();
        computer.killProcess();
        computer.closeScreen();
        computer.powerOff();
    }
}

将生产的电脑交给用户使用，但是对于用户来说，它知道的太多了，就是说这个用户拿到电脑时，要想对电脑关机，需要按下四个按钮才能将电脑关闭。

正确的设计，就是将上面的四个功能封装到一个接口中，交给用户这一个接口使用就可以了。

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
public class AppTest {
    
}

class Computer {
    public void saveDate() {
        System.out.println("保存数据");
    }

    public void killProcess() {
        System.out.println("关闭程序");
    }

    public void closeScreen() {
        System.out.println("关闭屏幕");
    }

    public void powerOff() {
        System.out.println("断电");
    }

    // 直接将上面的关机步骤进行封装
    public void shutDown() {
        saveDate();
        killProcess();
        closeScreen();
        powerOff();
    }
}

class Person { //
    private Computer computer = new Computer();
    public void shutDown() {
        computer.shutDown(); // 直接点击关机按钮即可
    }
}

2.3 注意事项和细节

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

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

其实迪米特法则讲究的就是一个封装。


博客内容遵循 署名-非商业性使用-相同方式共享 4.0 国际 (CC BY-NC-SA 4.0) 协议

本文永久链接是：https://chemlez.github.io/2021/07/10/%E8%AE%BE%E8%AE%A1%E6%A8%A1%E5%BC%8F%E4%B9%8B%E5%BC%80%E9%97%AD%E5%8E%9F%E5%88%99/

相关文章

Comment