设计模式 - 七大原则

作者: NeuBLUE | 来源:发表于2020-07-25 15:13 被阅读0次

七大原则 / 24种设计模式
设计模式 - 七大设计原则（一）
设计模式七大原则
1 设计模式的简介
设计模式实践
设计模式之引言
设计模式
设计模式一：设计模式七大原则
2018-04-28
2020顺F面经

开闭原则

定义

一个软件实体，如类，模块和函数应该对扩展开放，对修改关闭。
用抽象构建框架，用实现扩展细节。

优点

提高软件系统的可复用性及可维护性。

package com.web.design.openclose;

public interface ICourse {
    Integer getId();
    String getName();
    Double getPrice();
}

package com.web.design.openclose;

public class JavaCourse implements ICourse {
    public Integer id;
    public String name;
    public Double price;

    public JavaCourse(Integer id, String name, Double price) {
        this.id = id;
        this.name = name;
        this.price = price;
    }

    @Override
    public Integer getId() {
        return this.id;
    }

    @Override
    public String getName() {
        return this.name;
    }

    @Override
    public Double getPrice() {
        return this.price;
    }
}

package com.web.design.openclose;

public class JavaDiscountCourse extends JavaCourse {
    public JavaDiscountCourse(Integer id, String name, Double price) {
        super(id, name, price);
    }

    public Double getPrice() {
        return super.getPrice();
    }

    public Double getDiscountPrice() {
        return super.getPrice() * 0.8;
    }
}

依赖倒置原则

定义

高层模块不应该依赖底层模块，二者都应该依赖其抽象
抽象不应该依赖细节，细节应该依赖抽象。
针对接口编程，不要针对实现编程

优点

可以减少类间的耦合性，提高系统稳定性，提高代码可读性和可维护性，可降低修改程序所造成的风险。

错误写法

package com.web.design.dependenceinversion;

public class People {
      //增加功能时，不可修改实现类
    public void studyJavaCourse() {
        System.out.println("Zhang san study Java");
    }

    public void studyPythonCourse() {
        System.out.println("Zhang san study Python");
    }
}

package com.web.design.dependenceinversion;

public class Test {
    public static void main(String[] args) {
        //v1 针对实现编程
        People people = new People();
        people.studyJavaCourse();
        people.studyPythonCourse();
    }
}

正确写法()

package com.web.design.dependenceinversion;

public interface ICourse {
    void studyCourse();
}

package com.web.design.dependenceinversion;

public class People {
    private ICourse iCourse;

    public People() {

    }

    public People(ICourse iCourse) {
        this.iCourse = iCourse;
    }
      //v1 增加功能时，不可修改实现类
//    public void studyJavaCourse() {
//        System.out.println("Zhang san study Java");
//    }
//
//    public void studyPythonCourse() {
//        System.out.println("Zhang san study Python");
//    }
    // v2
    public void studyCourse(ICourse iCourse) {
        iCourse.studyCourse();
    }

    //v3
    public void studyCourse() {
        iCourse.studyCourse();
    }

    //v4
    public void setICourse(ICourse iCourse) {
        this.iCourse = iCourse;
    }
}

package com.web.design.dependenceinversion;

public class JavaCourse implements ICourse {
    @Override
    public void studyCourse() {
        System.out.println("Zhang san study Java");
    }
}

package com.web.design.dependenceinversion;

public class PythonCourse implements ICourse {
    @Override
    public void studyCourse() {
        System.out.println("Zhang san study Python");
    }
}

package com.web.design.dependenceinversion;

public class Test {
    public static void main(String[] args) {
        //v1 针对实现编程
//        People people = new People();
//        people.studyJavaCourse();
//        people.studyPythonCourse();

        //v2 通过方法传参
        People people = new People();
        people.studyCourse(new JavaCourse());
        people.studyCourse(new PythonCourse());

        //v3 通过构造器传参
        People people1 = new People(new JavaCourse());
        people1.studyCourse();

        // v4 通过setter传参
        People people2 = new People();
        people2.setICourse(new PythonCourse());
        people2.studyCourse();
    }
}

单一职责原则

定义

不要存在多余一个导致类变更的原因
一个类/接口/方法只负责一项职责

优点

降低类的复杂度、提高类的可读性、提高系统的可维护性、降低变更引起的风险。

错误写法

package com.web.design.singleresponsibility;

public class Bird {
    public void mainMoveMode(String birdName) {
        //错误实现方式
        if (birdName.equals("鸵鸟")) {
            System.out.println(birdName + "用脚走");
        } else {
            System.out.println(birdName + "用翅膀飞");
        }
    }
}

package com.web.design.singleresponsibility;

public class Test {
    public static void main(String[] args) {
        Bird bird = new Bird();
        bird.mainMoveMode("大雁");
        bird.mainMoveMode("鸵鸟");
    }
}

正确写法

package com.web.design.singleresponsibility;

public class FlyBird {
    public void mainMoveMode(String birdName) {
        System.out.println(birdName + "用翅膀飞");
    }
}

package com.web.design.singleresponsibility;

public class WalkBird {
    public void mainMoveMode(String birdName) {
        System.out.println(birdName + "用脚走");
    }
}

package com.web.design.singleresponsibility;

public class Test {
    public static void main(String[] args) {
//        Bird bird = new Bird();
//        bird.mainMoveMode("大雁");
//        bird.mainMoveMode("鸵鸟");
        FlyBird flyBird = new FlyBird();
        flyBird.mainMoveMode("大雁");

        WalkBird walkBird = new WalkBird();
        walkBird.mainMoveMode("鸵鸟");
    }
}

接口隔离原则

定义

用多个专门的接口，而不使用单一的总接口，客户端不应该依赖它不需要的接口。
一个类对一个类的依赖应该建立在最小的接口上。
建立单一接口，不要建立庞大臃肿的接口。
尽量细化接口，接口中的方法尽量少。

优点

符合高内聚低耦合的设计思想，从而使得类具有很好的可读性，可扩展性和可维护性。

错误代码

package com.web.design.interfacesegregation;

public interface IAnimalAction {
    void eat();
    void fly();
    void swim();
}

package com.web.design.interfacesegregation;

public class Dog implements IAnimalAction {
    @Override
    public void eat() {

    }

    @Override
    public void fly() {
        //狗不会飞
    }

    @Override
    public void swim() {

    }
}

正确代码

package com.web.design.interfacesegregation;

public interface IEatAnimalAction {
   void eat();
}

package com.web.design.interfacesegregation;

public interface IEatAnimalAction {
    void eat();
}

package com.web.design.interfacesegregation;

public interface IFlyAnimalAction {
    void fly();
}

package com.web.design.interfacesegregation;

public interface ISwimAnimalAction {
    void swim();
}

package com.web.design.interfacesegregation;

public class Bird implements IEatAnimalAction, IFlyAnimalAction {
    @Override
    public void eat() {

    }

    @Override
    public void fly() {

    }
}

package com.web.design.interfacesegregation;

public class Dog implements IEatAnimalAction, ISwimAnimalAction {

    @Override
    public void eat() {

    }

    @Override
    public void swim() {

    }
}

迪米特原则

定义

一个对象应该对其他对象保持最少的了解。又叫最少知道原则。
尽量降低类与类之间的耦合。

优点

降低类之间的耦合、
强调只和朋友交流，不和陌生人说话。
朋友：
出现在成员变量、方法的输入、输出参数中的类称为成员朋友类，
而出现在方法体内部的类不属于朋友类。

错误代码

package com.web.design.demeter;


import java.util.ArrayList;
import java.util.List;

public class Boss {
    public void commandCheckNumber(TeamLeader teamLeader) {
        List<Course> courseList = new ArrayList<>();
        for (int i = 0; i < 20; i++) {
            courseList.add(new Course());
        }
        teamLeader.checkNumberOfCourse(courseList);
    }
}

package com.web.design.demeter;

import java.util.List;

public class TeamLeader {
    public void checkNumberOfCourse(List<Course> courseList) {
        System.out.println("course number is " + courseList.size());
    }
}

package com.web.design.demeter;

public class Course {

}

package com.web.design.demeter;

public class Test {
    public static void main(String[] args) {
        Boss boss = new Boss();
        TeamLeader teamLeader = new TeamLeader();
        boss.commandCheckNumber(teamLeader);
    }
}

正确代码

package com.web.design.demeter;

public class Boss {
    public void commandCheckNumber(TeamLeader teamLeader) {
        teamLeader.checkNumberOfCourse();
    }
}

package com.web.design.demeter;

import java.util.ArrayList;
import java.util.List;

public class TeamLeader {
    public void checkNumberOfCourse() {
        List<Course> courseList = new ArrayList<>();
        for (int i = 0; i < 20; i++) {
            courseList.add(new Course());
        }
        System.out.println("course number is " + courseList.size());
    }
}

package com.web.design.demeter;

public class Test {
    public static void main(String[] args) {
        Boss boss = new Boss();
        TeamLeader teamLeader = new TeamLeader();
        boss.commandCheckNumber(teamLeader);
    }
}

里氏替换原则

定义

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

里氏替换原则告诉我们，当使用继承时候，类 B 继承类 A 时，除添加新的方法完成新增功能 P2，尽量不要修改父类方法预期的行为。

里氏替换原则的重点在不影响原功能，而不是不覆盖原方法。

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

组合/聚合复用原则 CRP

定义

组合/聚合复用原则就是在一个新的对象里面使用一些已有的对象，使之成为新对象的一部分; 新的对象通过向这些对象的委派达到复用已有功能的目的。

在面向对象的设计中，如果直接继承基类，会破坏封装，因为继承将基类的实现细节暴露给子类；如果基类的实现发生了改变，则子类的实现也不得不改变；从基类继承而来的实现是静态的，不可能在运行时发生改变，没有足够的灵活性。于是就提出了组合/聚合复用原则，也就是在实际开发设计中，尽量使用组合/聚合，不要使用类继承。

举个简单的例子，在某家公司里的员工分为经理，工作者和销售者。如果画成 UML 图可以表示为：