JAVA架构师之路一：七大软件设计原则

迷南。 2022-11-20 06:00 138阅读 0赞

### 七大软件设计原则 ###

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

> **矩不正，不可为方；规不正，不可为圆.——淮南子**

任何行业或者圈子都有自己的规则，遵从规则是在这个行业立足的根本，不然你就会被这个行业淘汰。软件设计同样有自己的原则。遵循这样的原则，你的代码软件才能更容易被接受，才会使你更专业。

## 1. 开闭原则 ##

定义

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

优点

> 提高软件的可复用性及可维护性

代码

/** * The interface Boo k. */
    public interface Book { 
    
        /** * Gets id. * * @return the id */
        Integer getId();
    
        /** * Gets name. * * @return the name */
        String getName();
    
        /** * Gets price. * * @return the price */
        Double getPrice();
    }

/** * The type Java book. */
    public class JavaBook implements Book { 
    
        private Integer id;
    
        private String name;
    
        private Double price;
    
        /** * Instantiates a new Java book. * * @param id the id * @param name the name * @param price the price */
        public JavaBook(Integer id, String name, Double price) { 
            this.id = id;
            this.name = name;
            this.price = price;
        }
    
        /** * Sets id. * * @param id the id */
        public void setId(Integer id) { 
            this.id = id;
        }
    
        /** * Sets name. * * @param name the name */
        public void setName(String name) { 
            this.name = name;
        }
    
        /** * Sets price. * * @param price the price */
        public void setPrice(Double price) { 
            this.price = price;
        }
    
        @Override
        public Integer getId() { 
            return this.id;
        }
    
        @Override
        public String getName() { 
            return this.name;
        }
    
        @Override
        public Double getPrice() { 
            return this.price;
        }

/** * The type Discount java book. */
    public class DiscountJavaBook extends JavaBook { 
        /** * Instantiates a new Java book. * * @param id the id * @param name the name * @param price the price */
        public DiscountJavaBook(Integer id, String name, Double price) { 
            super(id, name, price);
        }
    
        @Override
        public Double getPrice() { 
            return super.getPrice() * 0.5;
        }
    }

public class Test { 
    
        public static void main(String[] args) { 
            Book book = new JavaBook(1, "《Java开发指南》", 79.9);
            System.out.println("书本Id: " + book.getId() +
                    "\n书本名字: " + book.getName() +
                    "\n书本售价: " + book.getPrice() + "元");
    
            Book book1 = new DiscountJavaBook(1, "《Java开发指南》", 79.9);
            System.out.println("书本Id: " + book1.getId() +
                    "\n书本名字: " + book1.getName() +
                    "\n书本打折后售价: " + book1.getPrice() + "元");
        }
    }

书本Id: 1
    书本名字: 《Java开发指南》
    书本售价: 79.9元
    书本Id: 1
    书本名字: 《Java开发指南》
    书本打折后售价: 39.95元

类图

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

## 2. 依赖倒置原则 ##

定义

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

优点

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

代码

/** * The interface Boo k. */
    public interface Book { 
    
        /** * Buy. */
        void buy();
    }

/** * The type Java book. */
    public class JavaBook implements Book { 
        @Override
        public void buy() { 
            System.out.println("我要买一本Java的书籍");
        }
    }

/** * The type Python book. */
    public class PythonBook implements Book { 
        @Override
        public void buy() { 
            System.out.println("我要买一本Python的书籍");
        }
    }

/** * The type James. */
    public class James { 
    
        private Book book;
    
        /** * Instantiates a new James. * * @param book the book */
        public James(Book book) { 
            this.book = book;
        }
    
        /** * Instantiates a new James. */
        public James() { 
    
        }
    
        /** * Buy java book. */
        public void buyJavaBook() { 
            System.out.println("我要买一本Java的书籍");
        }
    
        /** * Buy python book. */
        public void buyPythonBook() { 
            System.out.println("我要买一本Python的书籍");
        }
    
        /** * Buy. * * @param book the book */
        public void buy(Book book) { 
            book.buy();
        }
    
        /** * Buy. */
        public void buy() { 
            this.book.buy();
        }
    
        /** * Sets book. * * @param book the book */
        public void setBook(Book book) { 
            this.book = book;
        }
    }

/** * The type Test. */
    public class Test { 
    
        /** * The entry point of application. * * @param args the input arguments */
        public static void main(String[] args) { 
            //--------------v1-------------------
            James james1 = new James();
            james1.buyJavaBook();
            james1.buyPythonBook();
            //--------------v2-------------------
            James james2 = new James();
            james2.buy(new JavaBook());
            james2.buy(new PythonBook());
            //--------------v3-------------------
            James james3 = new James(new JavaBook());
            james3.buy();
            //--------------v4-------------------
            James james4 = new James();
            james4.setBook(new PythonBook());
            james4.buy();
        }
    }

我要买一本Java的书籍
    我要买一本Python的书籍
    我要买一本Java的书籍
    我要买一本Python的书籍
    我要买一本Java的书籍
    我要买一本Python的书籍

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

## 3. 单一职责原则 ##

定义

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

优点

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

代码

/** * The interface Book. */
    public interface IBook { 
    
        /** * Read. */
        void read();
    
        /** * Write. */
        void write();
    }

/** * The interface Book read. */
    public interface IBookRead { 
    
        /** * Read. */
        void read();
    }

/** * The interface Book write. */
    public interface IBookWrite { 
    
        /** * Write. */
        void write();
    }

/** * The type Book. */
    public class BookImpl implements IBookRead, IBookWrite { 
    
        @Override
        public void read() { 
    
        }
    
        @Override
        public void write() { 
    
        }
    }

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

## 4. 接口隔离原则 ##

定义

> 用多个专门的接口，而不是使用单一的总接口，客户端不应该依赖它不需要的接口；  
> 一个类对应一个类的依赖应该建立在最小的接口上  
> 建立单一接口，不要建立庞大臃肿的解耦  
> 尽量细化接口，接口中的方法尽量少  
> 注意适度原则，一定要适度

优点

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

代码

/** * The interface Fly aminal. */
    public interface IFlyAminal { 
    
        /** * Fly. */
        void fly();
    }

/** * The interface Eat aminal. */
    public interface IEatAminal { 
    
        /** * Eat. */
        void eat();
    }

/** * The interface Swim aminal. */
    public interface ISwimAminal { 
    
        /** * Swim. */
        void swim();
    }

/** * The type Bird. */
    public class Bird implements IFlyAminal, IEatAminal { 
        @Override
        public void eat() { 
    
        }
    
        @Override
        public void fly() { 
    
        }
    }

/** * The type Dog. */
    public class Dog implements IEatAminal, ISwimAminal { 
        @Override
        public void eat() { 
    
        }
    
        @Override
        public void swim() { 
    
        }
    }

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

## 5. 迪米特法则 ##

定义

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

优点

> 降低类之间的耦合

代码

/** * The type Crouse. */
    public class Crouse { 
    }

/** * The type Team leader. */
    public class TeamLeader { 
    
        /** * Check crouse num. * * @param employee the employee */
        public void checkCrouseNum(Employee employee){ 
            employee.crouseNum();
        }
    }

/** * The type Employee. */
    public class Employee { 
    
        /** * Crouse num. */
        public void crouseNum(){ 
            List<Crouse> list = new ArrayList<>();
            for (int i = 0; i < 20; i++) { 
                list.add(new Crouse());
            }
            System.out.println("课程总数为：" + list.size());
        }
    }

/** * The type Test. */
    public class Test { 
    
        /** * The entry point of application. * * @param args the input arguments */
        public static void main(String[] args) { 
            TeamLeader leader = new TeamLeader();
            Employee employee = new Employee();
            leader.checkCrouseNum(employee);
        }
    }

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

## 6. 里氏替换原则 ##

定义

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

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

> 引申意义：子类可以扩展父类的功能，但不能改变父类原有的功能。  
> 含义1：子类可以实现父类的抽象方法，但是不能覆盖父类的非抽象方法  
> 含义2：子类可以增加自己特有的方法。  
> 含义3：当子类的方法重载父类的方法时，方法的前置条件(即方法的输入、入参) 要比父类方法的输入参数更宽泛。  
> 当子类的方法实现父类的方法时(重写、重载或实现扩展抽象方法)，方法的后置条件(即方法的输出、返回值)要比父类更严格或者相等。

优点

> 1.约束继承泛滥，开闭原则的一种体现。  
> 2.加强程序的健壮性，同事变更时也可以做到非常好的兼容性，提高程序的维护性，扩展性。加你各地需求变成时引入的风险。

代码

/** * The type Base. */
    public class Base { 
    
        /** * Method. * * @param map the map */
        public void method(HashMap map) { 
            System.out.println("执行父类");
        }
    }

public class Child extends Base { 
    
        /*@Override public void method(HashMap map) { System.out.println("执行子类HashMap"); }*/
    
        public void method(Map map) { 
            System.out.println("执行子类");
        }
    }

public class Test { 
    
        public static void main(String[] args) { 
            Child child = new Child();
            HashMap hashMap = new HashMap();
            child.method(hashMap);
    
            Base child1 = new Child();
            HashMap hashMap1 = new HashMap();
            child1.method(hashMap1);
        }
    }

执行父类
    执行父类

类图  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2N1aXhoYW8xMTA_size_16_color_FFFFFF_t_70_pic_center 5]

## 7. 合成复用原则 ##

定义

> 尽量使用对象组合、聚合、而不是继承关系达到软件复用的目的，聚合has-a 和组合contains-a

优点

> 可以使系统更加灵活，降低类与类之间的耦合度，一个类的变化对其他类造成的影响相对较少。

代码

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

public class MysqlConneciotn extends DBConnection { 
        @Override
        String getConneciotn() { 
            return "获取mysql连接";
        }
    }

public class OracleConnection extends DBConnection { 
        @Override
        String getConneciotn() { 
            return "获得oracle连接";
        }
    }

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

public class Issue { 
    
        private DBConnection dbConnection;
    
        public void setDbConnection(DBConnection dbConnection) { 
            this.dbConnection = dbConnection;
        }
    
        public void addIssue() { 
            String conn = dbConnection.getConneciotn();
            System.out.println(conn);
        }
    }

public class Test { 
        public static void main(String[] args) { 
            Issue issue = new Issue();
            issue.setDbConnection(new MysqlConneciotn());
            issue.addIssue();
        }
    }

类图  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2N1aXhoYW8xMTA_size_16_color_FFFFFF_t_70_pic_center 6]  
**感谢您阅读本文，如果您觉得文章写的对您有用的话，请您点击上面的“关注”，点个赞，这样您就可以持续收到《JAVA架构师之路》的最新文章了。文章内容属于自己的一点点心得，难免有不对的地方，欢迎在下方评论区探讨，你们的关注是我创作优质文章的动力。**

[**JAVA架构师之路二：设计模式之工厂模式**][JAVA]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2N1aXhoYW8xMTA_size_16_color_FFFFFF_t_70_pic_center]: /images/20221120/1ac841994230436b99c0f9dcffcbad1a.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2N1aXhoYW8xMTA_size_16_color_FFFFFF_t_70_pic_center 1]: /images/20221120/3fa3f6ad3d5748f28ab7b009de4ea4cb.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2N1aXhoYW8xMTA_size_16_color_FFFFFF_t_70_pic_center 2]: /images/20221120/461482f3bfb147a6ac6b110b14b803a7.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2N1aXhoYW8xMTA_size_16_color_FFFFFF_t_70_pic_center 3]: /images/20221120/93cf77aaad12455da9b86b37ced3387a.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2N1aXhoYW8xMTA_size_16_color_FFFFFF_t_70_pic_center 4]: /images/20221120/988df234d3df4d61adbde621f4f863d9.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2N1aXhoYW8xMTA_size_16_color_FFFFFF_t_70_pic_center 5]: /images/20221120/7332b99543774e238b9264f993b8086b.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2N1aXhoYW8xMTA_size_16_color_FFFFFF_t_70_pic_center 6]: /images/20221120/59f849ced1f542bbaf8d8c45d86e9735.png
[JAVA]: https://blog.csdn.net/cuixhao110/article/details/109713782