【Java设计模式】Java设计模式之设计模式的原则

谁借莪１个温暖的怀抱￠ 2022-12-18 03:58 120阅读 0赞

设计模式原则，其实就是程序员在编程时，应当遵守的原则，也是各种设计模式的基础（即：设计模式为什么是这样设计的依据）。

简单概括：**单接依里开迪合。（迪里接合依开单 ---- 迪里**热巴**接合**蔡**依**林**开单**啥的啦，方便记忆就行。**）**

> 1.  **单：单一职责原则**
> 2.  **接：接口隔离原则**
> 3.  **依：依赖倒置原则**
> 4.  **里：里氏替换原则**
> 5.  **开：开闭原则**
> 6.  **迪：迪米特法则**
> 7.  **合：合成复用原则**

下面分别讲解每个原则。记住，重要的是其中蕴含的思想，介绍和代码都是为了方便理解其中的思想而设计的。

# 一、单一职责原则 #

**基本介绍**

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

**单一职责原则注意事项和细节**

> 1.  降低类的复杂度，一个类只负责一项职责
> 2.  提高类的可读性，可维护性
> 3.  降低变更引起的风险
> 4.  通常情况下，我们应当遵守单一职责原则，只有逻辑足够简单，才可以在代码级别违反单一职责原则；只有类中方法数量足够少，可以在方法级别保持单一职责。

# 二、接口隔离原则 #

**基本介绍**

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

**如图所示**

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDI5OTAyNw_size_16_color_FFFFFF_t_70][]

类A通过接口Interface1依赖类B，类C通过接口Interface1依赖类D，如果接口Interface1对于类A和类C来说不是最小接口，那么类B和类D必须去实现他们不需要的方法。

按隔离原则应当这样处理：将接口Interface1拆分为独立的几个接口，类A和类C分别与他们需要的接口建立依赖关系，也就是采用接口隔离原则。 如上图所示的示例，就需要将接口Interface1拆分成接口Interface1包含方法1，接口Interface2包含方法2和方法3，以及接口Interface3包含方法4和方法5，然后类A只需同时实现Interface1和Interface2即可，类C只需要同时实现Interface1和Interface3即可。

接口隔离原则的代码示例如下：

public interface Interface1 {
        void operation1();
    }
    
    interface Interface2{
        void operation2();
        void operation3();
    }
    
    interface Interface3{
        void operation4();
        void operation5();
    }
    
    class A implements Interface1, Interface2{
        @Override
        public void operation1() {
            
        }
    
        @Override
        public void operation2() {
    
        }
    
        @Override
        public void operation3() {
    
        }
    }
    
    class C implements Interface1, Interface3 {
        @Override
        public void operation1() {
            
        }
    
        @Override
        public void operation4() {
    
        }
    
        @Override
        public void operation5() {
    
        }
    }

**其实，我认为的接口隔离原则就是对接口进行拆分，把不同的方法放在不同的接口中，然后通过类去分别或者同时实现几个接口。 **

# 三、依赖倒置原则 #

**基本介绍**

依赖倒转原则（Dependence Inversion Principle）是指：

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

**依赖关系传递的三种方式**

> 1.  接口传递
> 2.  构造方法传递
> 3.  setter方式传递

**依赖倒置原则的注意事项和细节**

> 1.  低层模块尽量都要有抽象类或者接口，或者两者都有，程序稳定性更好。
> 2.  变量的声明类型尽量是抽象类或者接口，这样我们的变量引用和实际对象间，就存在一个缓冲层，利于程序的扩展和优化。
> 3.  继承时遵循里氏替换原则。

# 四、里氏替换原则  #

基本介绍

> 1.  里氏替换原则（Liskov Substitution Principle）在1988年，由麻省理工学院的一位姓里的女士提出的。
> 2.  如果对每一个类型为 T1的对象 o1，都有类型为 T2 的对象o2，使得以 T1定义的所有程序 P 在所有的对象 o1 都代换成 o2 时，程序 P 的行为没有发生变化，那么类型 T2 是类型 T1 的子类型。换句话说，**所有引用基类的地方必须能够透明的使用其子类对象。**
> 3.  在使用继承时，遵循里氏替换原则，在子类中**尽量**不要重写父类的方法。
> 4.  里氏替换原则告诉我们，继承实际上让两个类耦合性增强了，**在适当的情况下，可以通过聚合，组合，依赖解决问题。**

解决方案

> 1.  子类可以实现父类的抽象方法，但不能覆盖父类的非抽象方法。
> 2.  子类中可以增加自己特有的方法。
> 3.  当子类的方法重载父类的方法时，方法的前置条件（即方法的形参）要比父类方法的输入参数更宽松。
> 4.  当子类的方法实现父类的抽象方法时，方法的后置条件（即方法的返回值）要比父类更严格。
> 5.  继承实际上让两个类的耦合度增强了，在适当的情况下，可以通过聚合、组合、依赖来解决问题。

里氏替换的代码示例如下：替换之前

里氏替换的代码示例如下：替换之后

public class Liskov {
    
        public static void main(String[] args) {
            A a = new A();
            System.out.println("8 - 5 = " + a.function1(8, 5));
            System.out.println("6 - 9 = " + a.function1(6, 9));
            System.out.println("**********************************");
    
            B b = new B();
            // 因为B类不再继承A类，因此调用者，不会再用function1求减法
            // 调用完成的功能就会很明确
            System.out.println("8 - 5 = " + b.function1(8, 5));
            System.out.println("6 - 9 = " + b.function1(6, 9));
            System.out.println("8 - 5 + 3 = " + b.function2(8, 5));
            
            // 使用组合仍然可以使用到A类的相关方法
            System.out.println("8 - 5 = " + b.function3(8, 5));
        }
    }
    
    // 创建一个更加基础的基类
    class Base {
        // 把更加基础的方法和成员写到Base类中
    }
    
    
    class A extends Base{
        // 返回两个数的差
        public int function1(int a, int b) {
            return a - b;
        }
    }
    
    // 增加了一个新功能：完成两个数相加，然后和3相加
    class B extends Base{
        // 如果B类需要使用A类的方法，使用组合关系
        private A a = new A();
    
        // 这里重写了A类的方法，可能是无意识的
        public int function1(int a, int b) {
            return a + b;
        }
    
        public int function2(int a, int b) {
            return function1(a, b) + 3;
        }
    
        // 仍然使用A类的方法
        public int function3(int c, int d) {
            return a.function1(c, d);
        }
    }

五、迪米特法则

六、开闭原则

七、合成复用原则

完结！

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDI5OTAyNw_size_16_color_FFFFFF_t_70]: /images/20221122/f37f37653e4b4a61aedd37541abd78d9.png