Java软件七大设计原则

七大设计原则

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

开闭原则（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();


    }
}