一、开闭原则
开闭原则（Open-Close Principle,OCP）是指软件实体，如类、模块、函数应该对扩展开放，对修改关闭的原则。强调的是用抽象构建框架，用实现扩展细节。可以提高软件系统的可复用性和可维护性，是面向对象设计中最基础的设计原则。例如，很多项目都是迭代开发，我们想增加新的功能，尽量不修改原有的类中代码进行扩展。实现开闭原则的核心就是面向抽象编程，下面用代码示例：
比如，以校外培训机构为例，有很多课程，比如英语课，数学课，物理课等，首先创建一个课程接口类，类中有三个方法，分别获取课程ID，课程名称，课程价格
/**
* @Author lixiangyang
* @Date 2019/12/13 0013 9:44
**/
//演示开闭原则，定义一个课程接口,它有三个方法
public interface ICourse {
Integer getId();
String getName();
Double getPrice();
}
然后，新建一个数学课程，继承这个课程接口
/**
* @Author lixiangyang
* @Date 2019/12/13 0013 9:46
**/
//演示开闭原则，用数学课实现类实现课程接口
public class MathCourese implements ICourse{
private Integer id;
private String name;
private Double price;
public MathCourese(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;
}
}
现在比如到了双十二，我们要给这个数学课程做活动，打5折，如果修改原有这个数学类的getPrice()方法有风险，万一别处也在调用。此时遵循开闭原则，不应在原有类中修改，可以新增一个MathDiscountCourse类，扩展原有数学类的功能，代码如下：
public class MathDiscountCourse extends MathCourese {
public MathDiscountCourse(Integer id, String name, Double price) {
super(id, name, price);
}
public Double getOriginPrice(){
//调用父类的方法
return super.getPrice();
}
public Double getDiscountPrice(){
return super.getPrice()*0.5;
}
}
在这里可以思考一下，为甚么这个类叫MathDiscountCoures，而不叫DiscountCourse???此时看下这个时候类图结构：
二、依赖倒置原则
依赖倒置原则（Dependence Inversion Principle,DIP）是指代码结构设计时，高层模块不依赖低层模块，二者都应该依赖于抽象。举个例子，笔记本电脑，主板上有内存接口，硬盘接口，风扇接口等，如果内存坏了，换个内存就好了，不需要把整块主板换掉，因为主板上有内存制定好的统一的标准接口，生成内存的厂商有很多，只要按照这个接口标准生产就可以了。通过依赖倒置，可以提高系统稳定性，代码的可读性和可维护性，并且能够降低迭代开发修改代码带来的风险。接下来，上代码：
首先新建一个JackMa类：
//演示依赖倒置原则
public class JackMa {
public void sing(){
System.out.println("马云在唱摇滚");
}
public void speech(){
System.out.println("马云在演讲");
}
}
在主线程中调用一下
public class JackMaTest {
public static void main(String[] args) {
JackMa jackMa = new JackMa();
jackMa.sing();
jackMa.sing();
}
}
随着年龄增大，马云爸爸的兴趣也越来越多，比如打高尔夫，拍电影，此时如果我们在JackMa类中新增方法，就需要从底层到高层，一次次的添加新增的方法，如此一来，代码复用性差，修改代码的风险也提高了，接下来优化我们的代码，新增一个兴趣爱好的抽象接口：
/**
* @Author lixiangyang
* @Date 2019/12/13 0013 13:49
**/
public interface Hobby {
void doSomthing();
}
然后写唱歌类SingHobby，演讲类SpeechHobby
/**
* @Author lixiangyang
* @Date 2019/12/13 0013 13:50
**/
public class SingHobby implements Hobby{
@Override
public void doSomthing() {
System.out.println("马云在唱歌");
}
}
/**
* @Author lixiangyang
* @Date 2019/12/13 0013 13:50
**/
public class SpeechHobby implements Hobby {
@Override
public void doSomthing() {
System.out.println("马云在演讲");
}
}
修改JackMa类：
//演示依赖倒置原则
public class JackMa {
public void doHobbyThing(Hobby hobby){
hobby.doSomthing();
}
}
最后来看调用：
/**
* @Author lixiangyang
* @Date 2019/12/13 0013 13:45
**/
public class JackMaTest {
public static void main(String[] args) {
JackMa jackMa = new JackMa();
jackMa.doHobbyThing(new SingHobby());
jackMa.doHobbyThing(new SpeechHobby());
}
}
这时候我们再看代码，无论马云的兴趣爱好多广泛，只要新增一个对应的爱好实现类，再调用的时候传参，而不需要修改底层代码就实现了扩展，其实这就是本质上的依赖注入。注入的方式还有构造器方式和Setter方式，我们来看构造器注入方式的代码：
public class JackMa {
private Hobby hobby;
public JackMa(Hobby hobby){
this.hobby=hobby;
}
public void doHobbyThing(){
hobby.doSomthing();
}
}
此时调用代码
public class JackMaTest {
public static void main(String[] args) {
JackMa jackMa = new JackMa(new SingHobby());
jackMa.doHobbyThing();
}
}
根据构造器注入，我们每次调用都要创建实例，如果JackMa是全局单例的，我们只能选择Setter方式注入了，修改JackMa代码：
public class JackMa {
private Hobby hobby;
public void setHobby(Hobby hobby) {
this.hobby = hobby;
}
public void doHobbyThing(){
hobby.doSomthing();
}
}
此时调用代码：
public class JackMaTest {
public static void main(String[] args) {
JackMa jackMa = new JackMa();
jackMa.setHobby(new SingHobby());
jackMa.doHobbyThing();
jackMa.setHobby(new SpeechHobby());
jackMa.doHobbyThing();
}
}
三、单一职责原则
单一职责（Simple Responsibility Pinciple，SRP）是指不要存在多于一个导致类变更的原因，通常一个类只做一件事。假设一个类中负责两个职责，其中一个职责需求的变更，需要修改代码，势必可能会影响到另一个职责的功能发生故障。如何解决呢，那就是这两个职责用两个类完成，实现解耦，易维护，后期需求变更互不影响，这样设计，可降低类的复杂度，提高代码可读性和可维护性，降低后期维护成本，接下来看代码：
用课程举例，比如有直播课和录播课之分，直播课只能在线直播观看，不能快进快退，录播课可以随意反复观看，功能职责不一样，很多人喜欢像下面这样写：
/**
* @Author lixiangyang
* @Date 2019/12/13 0013 14:11
**/
public class Course {
public void study(String couresName){
if ("直播课".equals(couresName)){
System.out.println(couresName+"不能快进");
}else{
System.out.println(couresName+"可以反复观看");
}
}
}
代码调用：
/**
* @Author lixiangyang
* @Date 2019/12/13 0013 14:13
**/
public class CourseTest {
public static void main(String[] args) {
Course course = new Course();
course.study("直播课");
course.study("录播课");
}
}
上面的代码，Course一个类完成了两个职责，假如现在直播课和录播课的加密方式不一样，需要修改代码，势必会相互影响造成不可控的风险。我们对职责进行解耦，拆分成ReplayCourse和LiveCourse
public class LiveCourse {
public void study(String couresName){
System.out.println(couresName+"不能快进");
}
}
public class ReplayCourse {
public void study(String couresName){
System.out.println(couresName+"可以反复观看");
}
}
调用代码：
public class CourseTest {
public static void main(String[] args) {
LiveCourse liveCourse = new LiveCourse();
liveCourse.study("直播课");
ReplayCourse replayCourse = new ReplayCourse();
replayCourse.study("录播课");
}
}
这样修改之后，开发简单，维护简单，在我们编写代码的过程中，尽量一个接口一个类一个方法只做一件事情，这样后期扩展维护起来比较容易。
四、接口隔离原则
接口隔离（Interface Segregation Principle, ISP）是指用多个专门的接口，而不是一个总接口，客户端不需要依赖它不需要的接口，这个原则指导我们在设计接口时应当注意以下几点：
1.一个类对另一个类的依赖应该建立在最小接口上；
2.建立单一接口，不要用臃肿庞大的接口；
3.尽量细化接口，一个接口中方法尽量少（不是越少越好，要适当）
接口隔离原则符合我们常说的低耦合高内聚的思想，从而使类具有很好的可读性、可扩展性、可维护性。我们在设计接口时，要多花时间思考，考虑业务模型，甚至以后随着业务的发展，后面对接口的可扩展性进行考虑。下面举个例子，定义一个动物animal抽象接口：
/**
* @Author lixiangyang
* @Date 2019/12/13 0013 14:46
**/
public interface IAnimal {
void eat();
void fly();
void swim();
}
Bird实现类：
public class Bird implements IAnimal {
@Override
public void eat() {}
@Override
public void fly() {}
@Override
public void swim() {}
}
Dog实现类：
public class Dog implements IAnimal {
@Override
public void eat() {}
@Override
public void fly() {}
@Override
public void swim() {}
}
可以看出，Bird不会游泳，它的swim（）方法只能空着，Dog不会飞，fly()方法只能空着。这时候可以针对不同动物的行为抽象成接口，分别设计IEatAnimal,IFlyAnimal,ISwimAnimal接口，代码如下：
public interface IEatAnimal {
void eat();
}
public interface IFlyAnimal {
void fly();
}
public interface ISwimAnimal {
void swim();
}
此时，Dog类只需要实现IEatAnimal和ISwimAnimal
public class Dog implements IEatAnimal,ISwimAnimal {
@Override
public void eat() {}
@Override
public void swim() {}
}
此时看下类图更加清晰，
五、迪米特法则
迪米特法则（Law of Demeter LoD）是指一个对象应该对其他对象保持最少的了解，又叫最少知道原则（Least Knowledge Principle,LKP），尽量降低类与类的耦合，迪米特原则主要强调和朋友交流，不和陌生人说话。
现在来设计一个权限系统，Boss 需要查看目前发布到线上的课程数量。这时候，Boss要找到 TeamLeader 去进行统计，TeamLeader 再把统计结果告诉 Boss。接下来我们还是来看代码：
/**
* @Author lixiangyang
* @Date 2019/12/13 0013 15:00
**/
public class Course {
}
public class TeamLeader {
public void checkNumberOfCourses(List courseList){
System.out.println("目前课程数量"+courseList.size());
}
}
public class Boss {
public void commandCheckNumber(TeamLeader teamLeader){
ArrayList courses = new ArrayList<>();
for (int i=0;i<20;i++){
courses.add(new Course());
}
teamLeader.checkNumberOfCourses(courses);
}
}
测试代码：
public class BossTest {
public static void main(String[] args) {
Boss boss = new Boss();
boss.commandCheckNumber(new TeamLeader());
}
}
写到这里，代码似乎已经完成了，但是根据迪米特法则，Boss只想知道结果，不需要关心Course，下面对代码进行改造。
TeamLeader类：
public class TeamLeader {
public void checkNumberOfCourses(){
ArrayList courses = new ArrayList<>();
for (int i=0;i<20;i++){
courses.add(new Course());
}
System.out.println("目前课程数量"+courses.size());
}
}
Boss类：
public class Boss {
public void commandCheckNumber(TeamLeader teamLeader){
teamLeader.checkNumberOfCourses();
}
}
这样Boss类就和Course类没有关系了，只需要关系TeamLeader。
六、里式替换原则
里式替换原则（Liskov Substitution Principle,LSP）是指如果对每一个类型为 T1 的对象 o1,都有类型为 T2 的对象 o2,使得以 T1 定义的所有程序 P 在所有的对象 o1 都替换成o2 时，程序 P 的行为没有发生变化，那么类型 T2 是类型 T1 的子类型，这样理解比较抽象。可以理解为一个软件实体如果适用一个父类的话，那一定是适用于其子类，所有引用父类的地方必须能透明地使用其子类的对象，子类对象能够替换父类对象，而程序逻辑不变。它有以下优点：
1.约束继承泛滥，开闭原则的一种体现；
2.加强程序的健壮性，提供程序的扩展性可维护性，降低需求变更引入的风险；
现在来描述一个经典的业务场景，用正方形，矩形，四边形的关系说明里式替换原则，我们都知道正方形是一个特殊的矩形，那么就可以创建一个矩形父类Rectangle 类：
public class Rectangle {
private Long height;
private Long weigh;
public Long getHeight() {
return height;
}
public void setHeight(Long height) {
this.height = height;
}
public Long getWeigh() {
return weigh;
}
public void setWeigh(Long weigh) {
this.weigh = weigh;
}
}
创建正方形 Square 类继承长方形：
public class Square extends Rectangle {
private Long length;
public Long getLength(){
return length;
}
public void setLength(Long length){
this.length=length;
}
@Override
public Long getHeight() {
return getLength();
}
@Override
public void setHeight(Long height) {
setLength(height);
}
@Override
public Long getWeigh() {
return getLength();
}
@Override
public void setWeigh(Long weigh) {
setLength(weigh);
}
}
在测试类中创建 resize()方法，根据逻辑长方形的宽应该大于等于高，我们让高一直自增，直到高等于宽变成正方形
public class TestDemo {
public static void resize(Rectangle rectangle){
while (rectangle.getWeigh()>=rectangle.getHeight()){
rectangle.setHeight(rectangle.getHeight()+1);
System.out.println("width:"+rectangle.getWeigh() + ",height:"+rectangle.getHeight());
}
System.out.println("resize 方法结束" + "width:"+rectangle.getWeigh() + ",height:"+rectangle.getHeight());
}
}
调用代码：
public class RectangleTest {
public static void main(String[] args) {
Rectangle rectangle = new Rectangle();
rectangle.setWeigh(20L);
rectangle.setHeight(10L);
TestDemo.resize(rectangle);
}
}
运行结果：
发现高比宽还大了，在长方形中是一种非常正常的情况。现在我们再来看下面的代码，把长方形 Rectangle 替换成它的子类正方形 Square，修改测试代码：
public class RectangleTest {
public static void main(String[] args) {
Square square = new Square();
square.setLength(10L);
TestDemo.resize(square);
}
}
这时候我们运行的时候就出现了死循环，违背了里氏替换原则，将父类替换为子类后，程序运行结果没有达到预期。因此，我们的代码设计是存在一定风险的。里氏替换原则只存在父类与子类之间，约束继承泛滥。我们再来创建一个基于长方形与正方形共同的抽象四边形 Quadrangle 接口：
public interface Quadrangle {
long getHeight();
long getWeigth();
}
修改长方形 Rectangle 类：
public class Rectangle implements Quadrangle {
private Long height;
private Long weigh;
@Override
public Long getHeight() {
return height;
}
public void setHeight(Long height) {
this.height = height;
}
@Override
public Long getWeigh() {
return weigh;
}
public void setWeigh(Long weigh) {
this.weigh = weigh;
}
}
修改正方形类 Square 类：
public class Square implements Quadrangle {
private Long length;
public Long getLength(){
return length;
}
public void setLength(Long length){
this.length=length;
}
@Override
public Long getHeight() {
return length;
}
@Override
public Long getWeigh() {
return length;
}
}
此时，如果我们把 resize()方法的参数换成四边形 Quadrangle 类，方法内部就会报错，因为正方形 Square 已经没有了 setWidth()和 setHeight()方法了。因此，为了约束继承泛滥，resize()的方法参数只能用 Rectangle 长方形。
七、合成复用原则
合成复用原则（Composite/Aggregate Reuse Principle,CARP）是指尽量使用对象组合(has-a)/聚合(contanis-a)，而不是继承关系达到软件复用的目的。可以使系统更加灵活，降低类与类之间的耦合度，一个类的变化对其他类造成的影响相对较少。继承我们叫做白箱复用，相当于把所有的实现细节暴露给子类。组合/聚合也称之为黑箱复用，对类以外的对象是无法获取到实现细节的。要根据具体的业务场景来做代码设计，其实也都需要遵循 OOP 模型。还是以数据库操作为例，先来创建 DBConnection 类：
public class DBConnection {
public String getConnection(){
return "MySQL 数据库连接";
}
}
创建 ProductDao 类：
public class ProductDao{
private DBConnection dbConnection;
public void setDbConnection(DBConnection dbConnection) {
this.dbConnection = dbConnection;
}
public void addProduct(){
String conn = dbConnection.getConnection();
System.out.println("使用"+conn+"增加产品");
}
}
这就是一种非常典型的合成复用原则应用场景。但是，目前的设计来说DBConnection还不是一种抽象，不便于系统扩展。目前的系统支持 MySQL 数据库连接，假设业务发生变化，数据库操作层要支持 Oracle 数据库。当然，我们可以在 DBConnection 中增加对Oracle 数据库支持的方法。但是违背了开闭原则。其实，我们可以不必修改 Dao 的代码，将 DBConnection 修改为 abstract，来看代码：
public abstract class DBConnection {
public abstract String getConnection();
}
然后，将 MySQL 的逻辑抽离：
public class MySQLConnection extends DBConnection {
@Override
public String getConnection() {
return "MySQL 数据库连接";
}
}
再创建 Oracle 支持的逻辑
public class OracleConnection extends DBConnection {
@Override
public String getConnection() {
return "Oracle 数据库连接";
}
}
最后看下类图结构，更加容易理解：
总结
平常日常开发中，业务代码写多了，容易忘记设计原则，导致后面新增需求或者需求变更时，扩展困难，难以维护，结果坑越来越多，也给后面接手的人留下来一堆烂摊子。所以在平时开发中，尽量要多想想，怎么设计更合理，这都是前人过来总结的经验，我们要站在巨人的肩膀上开发。