Java

设计模式七大原则

优秀的代码编写规范应当符合设计模式七大原则

计模式七大原则

七大原则是设计模式的基础，同时也是我们编程时应当遵守的规则

单一职责原则

单一职责原则（Single Responsibility Principle，SRP）:一个类应该只有一个引起它变化的原因。对于类来说但个类应该只负责一项职责

  • 降低类的复杂度，一个类只负责一项职责
  • 降低变更带来的风险

开放封闭原则

开放封闭原则（Open-Closed Principle，OCP）：一个类应该对扩展开放(对提供方)，对修改关闭(使用方)，用抽象构建框架，用实现扩展细节

里氏替换原则

里氏替换原则（Liskov Substitution Principle，LSP）：子类可以替换掉父类并且保证系统仍能正常运行。

  • 如何正确使用继承：也就是继承时子类尽量不要重写父类的方法，因为继承就是扩充父类的功能(不是那么绝对的)

依赖倒置原则

依赖倒置原则（Dependency Inversion Principle，DIP）：高层模块不应该依赖低层模块，它们都应该依赖抽象接口。抽象接口不应该依赖具体实现，具体实现应该依赖抽象接口。

  • 核心思想：面对接口编程(也就是接口和抽象类制定好规则)，而细节由子类去完成
  • 抽象不依赖细节，细节不依赖抽象

接口隔离原则

接口隔离原则（Interface Segregation Principle，ISP）：一个类不应该依赖它不需要的接口，而且它的接口应该尽量小。

迪米特法则

迪米特法则（Law of Demeter，LoD）：一个对象应该对其他对象有尽可能少的了解。也就是说，一个类应该尽可能地降低与其他类之间的耦合。

  • 又叫最少知道原则，也就是只与直接的朋友通信(定义在下方)，局部变量不要出现陌生的类，
  • 这个原则就是降低对象于对象的耦合性，对象与对象的关系越密切，耦合度越大，使用这个法则就是降低耦合度

image-20230417160124187

合成/聚合复用原则

合成/聚合复用原则（Composite/Aggregate Reuse Principle，CARP）：应该优先使用合成/聚合，而不是继承来达到复用的目的。

七大原则的核心思想

image-20230417160124187

描述类关系

继承关系

继承关系表示一个类可以继承另一个类的属性和方法，从而形成一种“是一个”（is-a）的关系。这是通过extends关键字实现的。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

class Animal {
    void eat() {
        System.out.println("吃");
    }
}

class Dog extends Animal {
    void bark() {
        System.out.println("汪汪汪");
    }
}

实现关系

实现关系用于接口与类之间，表示一个类实现了接口定义的方法，形成一种“可以做”（can-do）的关系。这是通过implements关键字实现的。

1
2
3
4
5
6
7
8
9

interface Drivable {
    void drive();
}

class Car implements Drivable {
    public void drive() {
        System.out.println("开车");
    }
}

组合关系

组合关系表示一个类包含另一个类的实例，表示一种“有一个”（has-a）的关系。组合是一种强依赖关系，部分不能单独存在于整体之外。例如：车由发动机等等组成可以说成车有发动机

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

class Engine {
    void start() {
        System.out.println("发动机启动。");
    }
}

class Car {
    private Engine engine = new Engine();

    void startCar() {
        engine.start();
        System.out.println("汽车启动。");
    }
}

聚合关系

聚合关系表示一个类包含另一个类的实例，但两者之间的关系是弱依赖的，即被包含的对象可以独立存在于整体之外，整体的生命周期不影响部分的生命周期。

 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

class Department {
    private String name;

    Department(String name) {
        this.name = name;
    }

    String getName() {
        return name;
    }
}

class University {
    private List<Department> departments;

    University() {
        this.departments = new ArrayList<>();
    }

    void addDepartment(Department department) {
        departments.add(department);
    }

    List<Department> getDepartments() {
        return departments;
    }
}

University（大学）包含多个Department（系）。这是一个聚合关系，因为： Department可以独立存在，离开了University，Department依然存在（例如，可能会被转移到另一所大学）。 University和Department有各自的生命周期，即使University被销毁，Department仍然可以存在。 聚合关系通常用来表示一种“部分-整体”关系，但这种关系是松散的，部分可以独立于整体存在

关联关系

关联关系表示一个类与另一个类之间的联系，通常是一种双向的关系。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

class Teacher {
    void teach(Student student) {
        System.out.println("老师授课" + student.getName());
    }
}

class Student {
    private String name;

    Student(String name) {
        this.name = name;
    }

    String getName() {
        return name;
    }
}

依赖关系

依赖关系表示一个类使用了另一个类，通常是在方法参数中体现出来的。这是一种临时的关系，通常意味着类之间有短暂的相互作用。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

class Printer {
    void print(Document doc) {
        System.out.println("打印文件: " + doc.getContent());
    }
}

class Document {
    private String content;

    Document(String content) {
        this.content = content;
    }

    String getContent() {
        return content;
    }
}