Java软件七大设计原则

约定不等于承诺〃 2022-11-17 14:52 197阅读 0赞

### 文章目录 ###

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

# 七大设计原则 #

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

## 开闭原则（Open-Closed Principle） ##

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

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3l1bHUzMg_size_16_color_FFFFFF_t_70_pic_center]

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） ##

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

类图：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3l1bHUzMg_size_16_color_FFFFFF_t_70_pic_center 1]

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） ##

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

类图：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3l1bHUzMg_size_16_color_FFFFFF_t_70_pic_center 2]

示例代码：  
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） ##

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

类图：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3l1bHUzMg_size_16_color_FFFFFF_t_70_pic_center 3]

示例代码：  
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**
 *  优点：可以是系统更加灵活，降低类与类之间的耦合度，一个累的变化对其他类造成的变化相对较小。

类图：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3l1bHUzMg_size_16_color_FFFFFF_t_70_pic_center 4]

示例代码：  
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();
    
    
        }
    }

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3l1bHUzMg_size_16_color_FFFFFF_t_70_pic_center]: /images/20221022/4ad797ca753c44849c70bc01d619a91a.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3l1bHUzMg_size_16_color_FFFFFF_t_70_pic_center 1]: /images/20221022/17219d7e8eea4fe4820e90f23cf82646.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3l1bHUzMg_size_16_color_FFFFFF_t_70_pic_center 2]: /images/20221022/305d3a5e70564a918680965c6816cad4.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3l1bHUzMg_size_16_color_FFFFFF_t_70_pic_center 3]: /images/20221022/3910d5b78577471e85f40002a7cfc11a.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3l1bHUzMg_size_16_color_FFFFFF_t_70_pic_center 4]: /images/20221022/10a385421626448faa01ea1c2f254051.png