文章目录

七大设计原则
- 开闭原则（Open-Closed Principle）
- 依赖倒置原则（Dependence Inversion Principle）
- 单一职责原则（Single Responsibility Principle）
- 接口隔离原则（Interface Segregation Principle）
- 迪米特法则（Law of Demeter）
- 里式替换原则（Lisikov Substitution Principle）
- 合成复用原则（Composite&Aggregate Reuse Principle）

七大设计原则

开闭原则
依赖倒置原则
单一职责原则
接口隔离原则
迪米特法则（最少知道原则）
里氏替换原则
合成复用原则

开闭原则（Open-Closed Principle）

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

在这里插入图片描述

ICourse接口代码：

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

JavaCourse接口代码：

public class JavaCourse  implements ICourse{ 
    private Integer id;
    private String name;
    private Double price;
    public JavaCourse() { 
    }
    public JavaCourse(Integer id, String name, Double price) { 
        this.id = id;
        this.name = name;
        this.price = price;
    }
    public Integer getId() { 
        return this.id;
    }
    public String getName() { 
        return this.name;
    }
    public Double getPrice() { 
        return this.price;
    }
}

JavaDiscountCourse代码：

public class JavaDiscountCourse extends JavaCourse { 
    public JavaDiscountCourse() { 
    }
    public JavaDiscountCourse(Integer id, String name, Double price) { 
        super(id, name, price);
    }
    public Double getDiscountPrice(){ 
        return super.getPrice() * 0.6;
    }
}

测试代码：

public class OpenCloseTest { 
    public static void main(String[] args) { 
        ICourse iCourse = new JavaDiscountCourse(1,"Java架构",1111180d);
        JavaDiscountCourse javaDiscountCourse = (JavaDiscountCourse)iCourse;
        System.out.println("课程ID：" + javaDiscountCourse.getId() +
                "\n课程标题：《" + javaDiscountCourse.getName() + "》" +
                "\n原价：" + javaDiscountCourse.getPrice() +
                "\n售价：" + javaDiscountCourse.getDiscountPrice());
    }
}

依赖倒置原则（Dependence Inversion Principle）

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

类图：
在这里插入图片描述

ICourse代码：

public interface ICourse { 
    void study();
}

JavaCourse代码：

public class JavaCourse implements ICourse { 
    public void study() { 
        System.out.println("Tom正在学习Java");
    }
}

PythonCourse代码：

public class PythonCourse implements ICourse{ 
    public void study() { 
        System.out.println("Tom正在学习Python");
    }
}

Tom代码：

public class Tom { 
// public void studyJavaCourse(){ 
// System.out.println("Tom正在学习Java");
// }
//
// public void studyPythonCourse(){ 
// System.out.println("Tom正在学习Python");
// }
// public void study(ICourse course){ 
// course.study();
// }
    private ICourse iCourse;
// public Tom(ICourse iCourse) { 
// this.iCourse = iCourse;
// }
    public void study(){ 
        iCourse.study();
    }
    public void setiCourse(ICourse iCourse) { 
        this.iCourse = iCourse;
    }
}

测试类代码：

public class DipTest { 
    public static void main(String[] args) { 
        //================= V1.0 ============
// Tom tom = new Tom();
// tom.studyJavaCourse();
// tom.studyPythonCourse();
        //================= V2.0 ============
// Tom tom = new Tom();
// tom.study(new JavaCourse());
// tom.study(new PythonCourse());
        //================= V3.0 ============
// Tom tom = new Tom(new JavaCourse());
// tom.study();
        //================= V4.0 ============
        Tom tom = new Tom();
        tom.setiCourse(new PythonCourse());
        tom.study();
    }
}

单一职责原则（Single Responsibility Principle）

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

示例代码如下：

ICourse接口代码：

public interface ICourse { 
    String getCourseName();
    byte[] getCourseVideo();
    void studyCourse();
    void refundCourse();
}

ICourseInfo接口代码：

public interface ICourseInfo { 
    String getCourseName();
    byte[] getCourseVideo();
}

ICourseManage接口代码：

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

CourseImpl代码：

public class CourseImpl  implements ICourseInfo,ICourseManage{ 
    public String getCourseName() { 
        return null;
    }
    public byte[] getCourseVideo() { 
        return new byte[0];
    }
    public void studyCourse() { 
    }
    public void refundCourse() { 
    }
}

Method代码：

public class Method { 
    private void modifyUserInfo(String userName,String address){ 
        userName = "Tom";
        address = "Changsha";
    }
    private void modifyUserInfo(String suerName,String ... fileds){ 
    }
    private void modifyUserName(String userName){ }
    private void modifyUserAddress(String address){ }
}

接口隔离原则（Interface Segregation Principle）

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

类图：
在这里插入图片描述

示例代码：
IEatAminal代码：

public interface IEatAminal { 
    void eat();
}

IFlyAminal代码：

public interface IFlyAminal { 
    void fly();
}

ISwimAminal代码：

public interface ISwimAminal { 
    void swim();
}

Brid代码：

public class Brid implements IFlyAminal, IEatAminal { 
    public void fly() { 
    }
    public void eat() { 
    }
}

Dog代码：

public class Dog implements IEatAminal, ISwimAminal { 
    public void eat() { 
    }
    public void swim() { 
    }
}

迪米特法则（Law of Demeter）

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

类图：
在这里插入图片描述

示例代码：
Course代码：

public class Course { 
}

Employee代码：

public class Employee { 
    public void checkNumberOfCourse() { 
        List<Course> courseList = new ArrayList<Course>();
        for (int i = 0; i < 20; i++) { 
            courseList.add(new Course());
        }
        System.out.println("目前发布的课程数量:" + courseList.size());
    }
}

TeamLeader代码：

public class TeamLeader { 
    public void commandCheckNumber(Employee employee){ 
        employee.checkNumberOfCourse();
    }
}

测试类：

public class LodTest { 
    public static void main(String[] args) { 
        TeamLeader teamLeader = new TeamLeader();
        Employee employee = new Employee();
        teamLeader.commandCheckNumber(employee);
    }
}

里式替换原则（Lisikov Substitution Principle）

定义：如果每一个类型为T1的对象o1，都有类型为T2的对象o2，使得以T1定义的所有程序P在所有的对象o1都替换成o2时，程序P的行为没有发生变化，那么类型T2是类型T1的子类型。
定义扩展：一个软件实体如果适用一个父类的话，那一定适用于其子类，所有引用父类的地方必须能透明地适用其子类对象，子类对象能够替换其父类对象而程序逻辑不变。
引申意义：
1. 子类可以扩展父类的功能，但不能改变父类原有的功能。
2. 子类可以实现父类的抽象方法，但不能覆盖父类的非抽象方法。
3. 子类中可以增加自己特有的方法。
4. 当子类的方法重载父类的方法时，方法的前置条件（即方法的输入，入参）要比父类方法的输入参数更宽松。
5. 当子类方法实现父类的方法时，（重写，重载获取实现抽象方法），方法的后置条件（即方法的输出，返回值）要比父类更严格或相等。
优点：
- 约束继承泛滥，开闭原则的一种体现。
- 加强程序的健壮性，同时变更，同时也做到非常好的兼容性；提高程序的维护性和扩展性。降低需求变更时引入的风险。

合成复用原则（Composite&Aggregate Reuse Principle）

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

类图：
在这里插入图片描述

示例代码：
DBConnection代码：

public abstract class DBConnection { 
    public abstract String getConnection();
}

MySQLConnection代码：

public class MySQLConnection extends DBConnection { 
    @Override
    public String getConnection() { 
        return "MySQL连接";
    }
}

OracleConnection代码：

public class OracleConnection extends DBConnection { 
    @Override
    public String getConnection() { 
        return "Oracle连接";
    }
}

ProductDao代码：

public class ProductDao { 
    private DBConnection dbConnection;
    public void setConnection(DBConnection dbConnection){ 
        this.dbConnection = dbConnection;
    }
    public void addProduct(){ 
        String conn = dbConnection.getConnection();
        System.out.println("conn = " + conn);
    }
}

CopTest代码：

public class CopTest { 
    public static void main(String[] args) { 
        ProductDao productDao = new ProductDao();
        productDao.setConnection(new MySQLConnection());
        productDao.addProduct();
    }
}