设计模式软件设计的七大原则

Posted 2021-09-03 Feyl

软件设计七大原则

开闭原则

• 定义：一个软件实体如类、模块和函数应该对扩展开放，对修改关闭。
• 用抽象构建框架，用实现扩展细节。
• 优点：提高软件系统的可复用性及可维护性。

代码示例

接口：

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

基类：

public class JavaCourse implements ICourse{
    private Integer id;
    private String name;
    private 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;
    }

    @Override
    public String toString() {
        return "JavaCourse{" +
                "id=" + id +
                ", name=\'" + name + \'\\\'\' +
                ", price=" + price +
                \'}\';
    }
}

扩展类（子类）：

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

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

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

测试：

public class OpenCloseTest {
    @Test
    public void openCloseTest(){
        ICourse iCourse = new JavaDiscountCourse(99, "Java从零到企业级开发", 348d);
        JavaDiscountCourse javaDiscountCourse = (JavaDiscountCourse) iCourse;
        System.out.println("课程ID: "+javaDiscountCourse.getId()+"  课程名称: "+javaDiscountCourse.getName()+
                "  价格: "+javaDiscountCourse.getPrice() + "  初始价格: "+javaDiscountCourse.getOriginPrice());
    }
}

原则分析

应用场景：打折销售

需求：需要增加网站的网课打折 功能。

实现：直接在“应用层”上扩展（继承）了基类，而不是直接对“底层”的接口或者基类进行修改。

原因：如果接口的方法较多，基类实现的逻辑比较复杂，对其进行直接修改会存在 风险扩散，容易引起Bug。越低层次的模块（或越基础的模块）的修改，影响的范围越大；相反越高层次的模块的修改，影响的范围越小。

举例：如果Dao层中的一个模块被多个Service层模块使用，对Dao层的该模块进行修改会影响到多个Service层模块，甚至影响到Controller 层。

依赖倒置原则

• 定义：高层模块不应该依赖低层模块，二者都应该依赖其抽象。
• 抽象不应该依赖细节；细节应该依赖抽象。
• 针对接口编程，不要针对实现编程。
• 优点：可以减少类间的耦合性、提高系统稳定性，提高代码可读性和可维护性，可降低修改程序所造成的风险。

代码示例

实体类：

public class Feyl {
    private ICourse icourse;

    public void setICourse(ICourse icourse) {
        this.icourse = icourse;
    }

    public void studyCourse(){
        icourse.studyCourse();
    }
}

接口：

public interface ICourse {
    void studyCourse();
}

实现类:

public class ArithmeticCourse implements ICourse{
    @Override
    public void studyCourse() {
        System.out.println("Feyl is learning Arithmetic course!");
    }
}

public class JavaCourse implements ICourse{
    @Override
    public void studyCourse() {
        System.out.println("Feyl is learning Java course!");
    }
}

public class FECourse implements ICourse{
    @Override
    public void studyCourse() {
        System.out.println("Feyl is learning FECourse!");
    }
}

测试类：

public class DependencyInversionTest {    
    @Test
    public void DependencyInversionTest(){
        Feyl feyl = new Feyl();
        feyl.setICourse(new ArithmeticCourse());
        feyl.studyCourse();
        feyl.setICourse(new JavaCourse());
        feyl.studyCourse();
        feyl.setICourse(new FECourse());
        feyl.studyCourse();
    }
}

原则分析

应用场景：增加学习的课程

需求：增加实体类（人）学习的课程 功能。

实现：通过ICourse接口将实体类（人）与具体学习的课程相联系。增加具体课程时，让增加的课程直接实现接口，此过程不需要对具体的实体类（人）进行修改。

单一职责原则

• 定义：不要存在多于一个导致类变更的原因
• 一个类/接口/方法只负责一项职责
• 优点：降低类的复杂度、提高类的可读性、提高系统的可维护性、降低变更引起的风险

代码示例

类的单一职责：

public class ICourse {
}

public interface ICourseManager {
    void studyCourse();
    void refundCourse();
}

public interface ICourseContent {
    String courseName();
    byte[] courseVideo();
}

public class ICourseImpl implements ICourseManager,ICourseContent{
    @Override
    public String courseName() {
        return null;
    }

    @Override
    public byte[] courseVideo() {
        return new byte[0];
    }

    @Override
    public void studyCourse() {

    }

    @Override
    public void refundCourse() {

    }
}

方法的单一职责：

public class Method {
    public void updateUserInfo(String username, String address){
        username = "Feyl";
        address = "HeNan";
    }

    public void updateUserInfo(String username, String... properties){
        username = "Feyl";
//        properties = ;
    }
    public void updateUsername(String username){
        username = "Feyl";
    }

    public void updateAddress(String address){
        address = "HeNan";
    }
}

接口隔离原则

• 定义：用多个专门的接口，而不使用单一的总接口，客户端不应该依赖它不需要的接口
• 一个类对一个类的依赖应该建立在最小的接口上
• 建立单一接口，不要建立庞大臃肿的接口
• 尽量细化接口，接口中的方法尽量少
• 注意适度原则，一定要适度
• 优点：符合我们常说的高内聚低耦合的设计思想，从而使得类具有很好的可读性、可扩展性和可维护性。

代码示例

反例：

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

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

    }

    @Override
    public void fly() {

    }

    @Override
    public void swim() {

    }
}

范例：

public interface IEatAnimalAction {
    void eat();
}

public interface IFlyAnimalAction {
    void fly();
}

public interface ISwimAnimalAction {
    void swim();
}

public class Dog implements ISwimAnimalAction,IEatAnimalAction{
    @Override
    public void eat() {

    }

    @Override
    public void swim() {

    }
}

迪米特原则

• 定义：一个对象应该对其他对象保持最少的了解。又叫最少知道原则
• 尽量降低类与类之间的耦合
• 优点：降低类之间的耦合
• 强调只和朋友交流,不和陌生人说话
• 朋友：出现在成员变量、方法的输入、输出参数中的类称为成员朋友类，而出现在方法体内部的类不属于朋友类。

代码示例

反例：

public class Course {}

public class TeamLeader {
    public void checkNumberOfCourse(List<Course> courses){
        System.out.println("在线课程的数量："+courses.size());
    }
}

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

测试类：

public class DemeterTest {
    @Test
    public void demeterTest() {
        new Boss().commandCheckNumber(new TeamLeader());
    }
}

范例：

public class TeamLeader {
    public void checkNumberOfCourse(){
        List<Course> courses = new ArrayList<Course>();
        for (int i = 0; i < 20; i++) {
            courses.add(new Course());
        }
        System.out.println("在线课程的数量："+courses.size());
    }
}

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

里氏替换原则

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

定义扩展：一个软件实体如果适用一个父类的话，那一定适用于其子类，所有引用父类的地方必须能透明地使用其子类的对象，子类对象能够替换父类对象，而程序逻辑不变。

引申意义：子类可以扩展父类的功能，但不能改变父类原有的功能。

含义1：子类可以实现父类的抽象方法，但不能覆盖父类的非抽象方法 。

含义2：子类中可以增加自己特有的方法。

含义3：当子类的方法重载父类的方法时，方法的前置条件（即方法的输入/入参）要比父类方法的输入参数更宽松。

含义4：当子类的方法实现父类的方法时（重写/重载或实现抽象方法），方法的后置条件（即方法的输出/返回值）要比父类更严格或相等。

优点1：约束继承泛滥，开闭原则的一种体现。

优点2：加强程序的健壮性，同时变更时也可以做到非常好的兼容性，提高程序的维护性、扩展性。降低需求变更时引入的风险。

对开闭原则代码修改使其符和里氏替换原则：

// ICourse接口、JavaCourse类保持不变

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

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

测试类：

public class OpenCloseTest {
    @Test
    public void openCloseTest(){
        ICourse iCourse = new JavaDiscountCourse(99, "Java从零到企业级开发", 348d);
        JavaDiscountCourse javaDiscountCourse = (JavaDiscountCourse) iCourse;
        System.out.println("课程ID: "+javaDiscountCourse.getId()+"  课程名称: "+javaDiscountCourse.getName()+
                "  价格: "+javaDiscountCourse.getDiscountPrice() + "  初始价格: "+javaDiscountCourse.getPrice());
    }
}

代码示例

反例：

public class Rectangle {
    private long length;

    public long getLength() {
        return length;
    }

    public void setLength(long length) {
        this.length = length;
    }

    public long getWidth() {
        return width;
    }

    public void setWidth(long width) {
        this.width = width;
    }

    private long width;
}

public class Square extends Rectangle{
    private long sideLength;

    public long getSideLength() {
        return sideLength;
    }

    public void setSideLength(long sideLength) {
        this.sideLength = sideLength;
    }

    @Override
    public long getLength() {
        return getSideLength();
    }

    @Override
    public void setLength(long length) {
        setSideLength(length);
    }

    @Override
    public long getWidth() {
        return getSideLength();
    }

    @Override
    public void setWidth(long width) {
        setSideLength(width);
    }
}

测试类：

public class Test {
    public static void resize(Rectangle rectangle){
        while(rectangle.getWidth() <= rectangle.getLength()){
            rectangle.setWidth(rectangle.getWidth()+1);
            System.out.println("Width: " + rectangle.getWidth()+"\\t Length: "+rectangle.getLength());
        }
        System.out.println("resize方法结束: Width: "+rectangle.getWidth()+"\\tLength: "+rectangle.getLength());
    }

    public static void main(String[] args) {
        /*Rectangle rectangle = new Rectangle();
        rectangle.setWidth(10);
        rectangle.setLength(20);
        resize(rectangle);*/
        Square square = new Square();
        square.setLength(10);
        resize(square);
    }
}

范例：

public interface Quadrangle {
    long getWidth();
    long getLength();
}

public class Rectangle implements Quadrangle{
    private long width;
    private long length;

    @Override
    public long getWidth() {
        return 0;
    }

    @Override
    public long getLength() {
        return 0;
    }

    public void setWidth(long width) {
        this.width = width;
    }

    public void setLength(long length) {
        this.length = length;
    }
}

public class Square implements Quadrangle{
    private long sideLength;

    @Override
    public long getWidth() {
        return sideLength;
    }

    @Override
    public long getLength() {
        return sideLength;
    }

    public long getSideLength() {
        return sideLength;
    }

    public void setSideLength(long sideLength) {
        this.sideLength = sideLength;
    }
}

Test测试类中的
//        square.setLength(10);
//        resize(square);
会抛异常。
若将 resize(Rectangle rectangle) 改为 resize(Quadrangle quadrangle)，方法中的set方法也不能满足要求。
由此看来，反例中的继承关系违反了里氏替换原则。

方法重载（入参）：

public class Base {
    public void method(HashMap map){
        System.out.println("父类的HashMap方法被执行。");
    }
}

public class Child extends Base {
/*    @Override
    public void method(HashMap map) {
        System.out.println("子类的HashMap入参方法被调用了!");
    }*/

    public void method(Map map){
        System.out.println("子类的Map入参方法被调用了!");
    }
}

方法重载（返回值）：

public abstract class Base {
    public abstract Map method();
}

public class Child extends Base{
    @Override
    public HashMap method() {
        HashMap<String,String> hashMap = new HashMap<>();
        System.out.println("子类的HashMap被调用!");
        hashMap.put("msg","子类的HashMap被调用!");
        return hashMap;
    }
}

合成(组合)/聚合复用原则

• 定义：尽量使用对象组合/聚合，而不是继承关系达到软件复用的目的
• 聚合has-A和组合contains-A
• 优点：可以使系统更加灵活,降低类与类之间的耦合度，一个类的变化对其他类造成的影响相对较少
• 何时使用合成/聚合、继承
• 聚合has-A、组合contains-A 继承is-A

代码示例

public abstract class DBConnection {
    /*public String getConnection(){
        return "mysql数据库连接";
    }*/
    public abstract String getDBConnection();
}

public class MySQLConnection extends DBConnection{
    @Override
    public String getDBConnection() {
        return "MySQL数据库连接";
    }
}

public class PostgreSQLConnection extends DBConnection{
    @Override
    public String getDBConnection() {
        return "PostgreSQL数据库连接";
    }
}

public class ProductDao{
    private DBConnection dbConnection;

    public void setDbConnection(DBConnection dbConnection) {
        this.dbConnection = dbConnection;
    }

    public void addProduct(){
        String conn = dbConnection.getDBConnection();
        System.out.println("使用"+conn+"增加产品");
    }
}

测试代码：

public class CompositionAggregationTest {
    @Test
    public void compositionAggregationTest(){
        ProductDao productDao = new ProductDao();
//        productDao.setDbConnection(new MySQLConnection());
        productDao.setDbConnection(new PostgreSQLConnection());
        productDao.addProduct();
    }
}