java中六大设计原则

比眉伴天荒 2023-09-27 14:09 71阅读 0赞

**目录**

1.单一职责原则

2.接口隔离原则

3.依赖倒置原则

4.里氏替换原则

5.开闭原则

6. 迪米特法则

--------------------

### 1.单一职责原则 ###

对类来说的，即**一个类应该只负责一项职责**。如类A负责两个不同职责:职责1，职责2。当职责1需求变更而改变A时，可能造成职责2执行错误，所以需要将类A的粒度分解为A1，A2

示例：

User类和UserDao类，前者封装逻辑(name,id等)，后者用于封装数据库持久化操作类(create,update等)

### 2.接口隔离原则 ###

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

要以最小的依赖来创建接口，类实现接口时尽量保证接口内所有的方法对类都是有用的，不做没必要的实现，不满足的话就将这个接口拆分。

**建立单一接口，不要建立庞大臃肿的接口，尽量细化接口，接口中的方法尽量少**。

错误示例：

interface I {
        public void method1();
        public void method2();
        public void method3();
        public void method4();
        public void method5();
    }
    
    class A{
        public void depend1(I i){
            i.method1();
        }
        public void depend2(I i){
            i.method2();
        }
        public void depend3(I i){
            i.method3();
        }
    }
    
    class B implements I{
        public void method1() {
            System.out.println("类B实现接口I的方法1");
        }
        public void method2() {
            System.out.println("类B实现接口I的方法2");
        }
        public void method3() {
            System.out.println("类B实现接口I的方法3");
        }
        //对于类B来说，method4和method5不是必需的，但是由于接口A中有这两个方法，
        //所以在实现过程中即使这两个方法的方法体为空，也要将这两个没有作用的方法进行实现。
        public void method4() {}
        public void method5() {}
    }
    
    class C{
        public void depend1(I i){
            i.method1();
        }
        public void depend2(I i){
            i.method4();
        }
        public void depend3(I i){
            i.method5();
        }
    }
    
    class D implements I{
        public void method1() {
            System.out.println("类D实现接口I的方法1");
        }
        //对于类D来说，method2和method3不是必需的，但是由于接口A中有这两个方法，
        //所以在实现过程中即使这两个方法的方法体为空，也要将这两个没有作用的方法进行实现。
        public void method2() {}
        public void method3() {}
    
        public void method4() {
            System.out.println("类D实现接口I的方法4");
        }
        public void method5() {
            System.out.println("类D实现接口I的方法5");
        }
    }
    
    public class Client{
        public static void main(String[] args){
            A a = new A();
            a.depend1(new B());
            a.depend2(new B());
            a.depend3(new B());
            
            C c = new C();
            c.depend1(new D());
            c.depend2(new D());
            c.depend3(new D());
        }
    }

正确示例：

interface I1 {
        public void method1();
    }
    
    interface I2 {
        public void method2();
        public void method3();
    }
    
    interface I3 {
        public void method4();
        public void method5();
    }
    
    class A{
        public void depend1(I1 i){
            i.method1();
        }
        public void depend2(I2 i){
            i.method2();
        }
        public void depend3(I2 i){
            i.method3();
        }
    }
    
    class B implements I1, I2{
        public void method1() {
            System.out.println("类B实现接口I1的方法1");
        }
        public void method2() {
            System.out.println("类B实现接口I2的方法2");
        }
        public void method3() {
            System.out.println("类B实现接口I2的方法3");
        }
    }
    
    class C{
        public void depend1(I1 i){
            i.method1();
        }
        public void depend2(I3 i){
            i.method4();
        }
        public void depend3(I3 i){
            i.method5();
        }
    }
    
    class D implements I1, I3{
        public void method1() {
            System.out.println("类D实现接口I1的方法1");
        }
        public void method4() {
            System.out.println("类D实现接口I3的方法4");
        }
        public void method5() {
            System.out.println("类D实现接口I3的方法5");
        }
    }

### 3.依赖倒置原则 ###

*  高层模块不应该依赖低层模块，二者都应该依赖其抽象
 *  抽象不应该依赖细节，细节应该依赖抽象
 *  依赖倒置的中心思想是面向接口编程
 *  依赖倒转原则是基于这样的设计理念:相对于细节的多变性，抽象的东西要稳定的多。以抽象为基础搭建的架构比以细节为基础的架构要稳定的多。在java中，抽象指的是接口或抽象类，细节就是具体的实现类
 *  使用接口或抽象类的目的是制定好规范，而不涉及任何具体的操作，把展现细节的任务交给他们的实现类去完成

*  尽量使用抽象类和接口来实现低层代码，细节应该依赖于抽象，更加稳定。

### 4.里氏替换原则 ###

*  里氏替换原则(Liskov Substitution Principle)在1988年，由麻省理工学院的以为姓里的女士提出的
 *  如果对每个类型为Tl的对象ol，都有类型为T2的对象o2，使得以TI定义的所有程序Р在所有的对象ol都代换成o2时，程序Р的行为没有发生变化，那么类型T2是类型Tl的子类型。换句话说，所有引用基类的地方必须能透明地使用其子类的对象
 *  在使用继承时，遵循里氏替换原则，在子类中尽量不要重写父类的方法（防止子类不小心重写父类方法从而覆盖父类方法（父类已经实现，而不是抽象方法））
 *  里氏替换原则告诉我们，继承实际上让两个类耦合性增强了，在适当的情况下，可以通过聚合，组合，依赖来解决问题

解释：

定义1：如果对每一个类型为 T1的对象 o1，都有类型为 T2 的对象o2，使得以 T1定义的所有程序 P 在所有的对象 o1 都代换成 o2 时，程序 P 的行为没有发生变化，那么类型 T2 是类型 T1 的子类型。

定义2：所有引用基类的地方必须能透明地使用其子类的对象。

通俗简单的说就是：子类可以扩展父类的功能，但不能改变父类原有的功能。

**问题由来：**有一功能P1，由类A完成。现需要将功能P1进行扩展，扩展后的功能为P，其中P由原有功能P1与新功能P2组成。新功能P由类A的子类B来完成，则子类B在完成新功能P2的同时，有可能会导致原有功能P1发生故障。

解决方案：**当使用继承时，遵循里氏替换原则。类B继承类A时，除添加新的方法完成新增功能P2外，尽量不要重写父类A的方法，也尽量不要重载父类A的方法。【由时候我们可以采用final的手段强制来遵循】**

继承包含这样一层含义：父类中凡是已经实现好的方法（相对于抽象方法而言），实际上是在设定一系列的规范和契约，虽然它不强制要求所有的子类必须遵从这些契约，但是如果子类对这些非抽象方法任意修改，就会对整个继承体系造成破坏。而里氏替换原则就是表达了这一层含义。

继承作为面向对象三大特性之一，在给程序设计带来巨大便利的同时，也带来了弊端。比如使用继承会给程序带来侵入性，程序的可移植性降低，增加了对象间的耦合性，如果一个类被其他的类所继承，则当这个类需要修改时，必须考虑到所有的子类，并且父类修改后，所有涉及到子类的功能都有可能会产生故障。

### 5.开闭原则 ###

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

示例：

把基类做成抽象类，并提供一个抽象类的方法，让子类去实现即可，这样我们有了新的类时，只需要让新类继承基类，并实现抽象类方法即可，使用方的代码就不需要修改了。

### 6. 迪米特法则 ###

**定义：一个对象应该对其他对象保持最少的了解。**

问题由来：类与类之间的关系越密切，耦合度越大，当一个类发生改变时，对另一个类的影响也越大。

解决方案：尽量降低类与类之间的耦合。

自从我们接触编程开始，就知道了软件编程的总的原则：低耦合，高内聚。无论是面向过程编程还是面向对象编程，只有使各个模块之间的耦合尽量的低，才能提高代码的复用率。低耦合的优点不言而喻，但是怎么样编程才能做到低耦合呢？那正是迪米特法则要去完成的。

迪米特法则又叫最少知道原则，最早是在1987年由美国Northeastern University的Ian Holland提出。**通俗的来讲，就是一个类对自己依赖的类知道的越少越好。也就是说，对于被依赖的类来说，无论逻辑多么复杂，都尽量地的将逻辑封装在类的内部，对外除了提供的public方法，不对外泄漏任何信息。**迪米特法则还有一个更简单的定义：只与直接的朋友通信。首先来解释一下什么是直接的朋友：每个对象都会与其他对象有耦合关系，只要两个对象之间有耦合关系，我们就说这两个对象之间是朋友关系。耦合的方式很多，依赖、关联、组合、聚合等。其中，我们称出现成员变量、方法参数、方法返回值中的类为直接的朋友，而出现在局部变量中的类则不是直接的朋友。也就是说，陌生的类最好不要作为局部变量的形式出现在类的内部。

*  类似于Spring MVC里的Controller于Service的关系，Service在自己类里实现方法，Controller直接调用他的方法，不在自己类实现。

参照：[JAVA设计模式总结之六大设计原则 - pony1223 - 博客园][JAVA_ - pony1223 -]

[Java设计模式之六大设计原则\_一只小逸白的博客-CSDN博客\_六大设计原则][Java_-CSDN]

[JAVA_ - pony1223 -]: https://www.cnblogs.com/pony1223/p/7594803.html
[Java_-CSDN]: https://blog.csdn.net/qq_45911678/article/details/124546382