1.开闭原则

开闭原则(Open-Closed Principle,OCP)是指一个软件实体(类,模块和函数)应该对扩展性开放,对修改关闭,所谓的开闭,也正是对扩展和修改两个行为的一个原则,它强调的用抽象构建框架,用实现扩展细节,可以提高软件系统的可复用性及可维护性.开闭原则是面向对象设计中最基础的设计原则,它指导我们如何建立稳定,灵活的系统,例如版本更新,我们尽可能不修改源代码,但是可以增加新功能.

我们举例说明什么是开闭原则，以书店销售书籍为例，其类图如下：

public interface IBook{
  public String getName();
  public String getPrice();
  public String getAuthor();
}
public class NovelBook implements IBook{
   private String name;
   private int price;
   private String author;

   public NovelBook(String name,int price,String author){
     this.name = name;
     this.price = price;
     this.author = author;
   }

   public String getAutor(){
     return this.author;
   }

   public String getName(){
     return this.name;
   }  

   public int getPrice(){
     return this.price;
   } 
}

  public static void main(Strings[] args){
     IBook novel = new NovelBook("笑傲江湖",100,"金庸");
     System.out.println("书籍名字："+novel.getName()+"书籍作者："+novel.getAuthor()+"书籍价格："+novel.getPrice());
   }

项目投产生，书籍正常销售，但是我们经常因为各种原因，要打折来销售书籍，这是一个变化，我们要如何应对这样一个需求变化呢？

我们有下面三种方法可以解决此问题：

修改接口
在IBook接口中，增加一个方法getOffPrice(),专门用于进行打折处理，所有的实现类实现此方法。但是这样的一个修改方式，实现类NovelBook要修改，同时IBook接口应该是稳定且可靠，不应该经常发生改变，否则接口作为契约的作用就失去了。因此，此方案否定。

修改实现类
修改NovelBook类的方法，直接在getPrice()方法中实现打折处理。此方法是有问题的，例如我们如果getPrice()方法中只需要读取书籍的打折前的价格呢？这不是有问题吗？当然我们也可以再增加getOffPrice()方法，这也是可以实现其需求，但是这就有二个读取价格的方法，因此，该方案也不是一个最优方案。

通过扩展实现变化
我们可以增加一个子类OffNovelBook,覆写getPrice方法。此方法修改少，对现有的代码没有影响，风险少，是个好办法。
下面是修改后的类图：

public class OffNovelBook implements NovelBook{

   public OffNovelBook(String name,int price,String author){
      super(name,price,author);
   }

   //覆写价格方法，当价格大于40，就打8析，其他价格就打9析
   public int getPrice(){
     if(this.price > 40){
        return this.price * 0.8;
     }else{
        return this.price * 0.9;
     }     
   } 
}

2.依赖倒置原则

依赖倒置原则(Dependence Inversion Principle，DIP)是指设计代码结构时,高层模块不应该依赖低层模块,两者都应该依赖其抽象,抽象不应该依赖细节,细节应该依赖抽象,通过依赖倒置,可以减少类与类之间的耦合性,提高系统的稳定性,提高代码可读性和可维护性,并且能降低修改程序所造成的风险

spring里的依赖注入正是用的此原则
我正在学习java语言和python,学完之后我又想学go语言了,这个时候又得新加方法了,在高层的调用的时候也要追加,非常不稳定.

public class Student {

    public void javaLanguage() {
        System.out.println("我正在学习 Java语言");
    }

    public void pythonLanguage() {
        System.out.println("我正在学习 Python语言");
    }
        public static void main(String[] args) {
        Student student = new Student();
        student.javaLanguage();
        student.pythonLanguage();
    }

}

改善后的代码
这样不管我以后想学什么语言,只要添加一个实现类即可

public interface Language {
    void study();
}
public class JavaLanguage implements Language {
    @Override
    public void study() {
        System.out.println("我正在学习 Java语言");
    }
}
public class PythonLanguage implements Language {
    @Override
    public void study() {
        System.out.println("我正在学习 Python语言");
    }
}
public class Student {
    public void study(Language language) {
        language.study();
    }

    public static void main(String[] args) {
        Student student = new Student();
        student.study(new JavaLanguage());
        student.study(new PythonLanguage());
    }
}

3.单一职责

单一职责(Simple Reponsibility Pinciple,SRP)是指不要存在多于一个导致类变更的原因.

假设我们有一个类负责两个职责,一单发生需求变更,修改其中一个逻辑代码,有可能导致另一个职责的功能发生故障,这样一来,这个类就存在两个导致类变更的原因，如何解决这个问题,将两个职责用两个类实现,进行解耦,后期需求变更维护互不影响,这样的设计,可以降低类的复杂度,提高类的可读性,提高系统的可维护性,降低变更引起的风险。

由下代码能看到这个类处理了两种逻辑处理,假设需要修改其中一类处理逻辑,容易带来不可控的风险

public class Course {
    public void study(String courseName){
        if("直播课".equals(courseName)){
            System.out.println(courseName+"不能快进");
        }else{
            System.out.println(courseName+"可以快进");
        }
    }
}
   public static void main(String[] args) {
        Course course=new Course();
        course.study("直播课");
        course.study("录播课");
    }

解耦的代码

public class LiveCourse {
    public void study(String courseName) {
        System.out.println(courseName + "不能快进");
    }
}
public class ReplayCourse {
    public void study(String courseName) {
        System.out.println(courseName + "可以快进");
    }
}
   public static void main(String[] args) {
        LiveCourse liveCourse=new LiveCourse();
        liveCourse.study("直播课");
        ReplayCourse replayCourse=new ReplayCourse();
        replayCourse.study("录播课");
    }

4.接口隔离原则

接口隔离原理(Interface Segregation Principle,ISP)是指用多个专门的接口,而不使用单一的总接口,客户端不应该依赖它不需要的接口,这个原则指导我们在设计接口时应当注意以下几点

• (1.一个类对另一个类的依赖应该建立在最小的接口之上
• (2.建立单一接口,不要建立庞大臃肿的接口
• (3.经量细化接口,接口中的方法尽量少(不是越少越好,一定要适度)
  接口隔离原则符合我们常说的高内聚,低耦合的设计思想,可以使类具有很好的可读性,可扩展性,可维护性。我们在设计接口的时候,需多话时间去思考,要考虑业务模型,包括对一会可能发生变更的地方做一些预判，所以,对于抽象,对于业务模型的理解是非常重要

下面Animal接口定义动物的一些行为，但是鸟不会游泳,所以fly方法是一个空实现

public interface Animal {
    void eat();
    void fly();
    void swim();
}
public class Bird implements Animal {

    @Override
    public void eat() {
        System.out.println("鸟在吃饭");
    }
    @Override
    public void fly() {
        System.out.println("鸟在飞");
    }
    @Override
    public void swim() {
        //不会游泳
    }
}

针对不同的动物行为定义不同的接口

public interface EatAnimal {
    void eat();
}
public interface FlyAnimal {
    void fly();
}
public interface SwimAnimal {
    void swim();
}
public class NewBird implements EatAnimal,FlyAnimal {
    @Override
    public void eat() {
        System.out.println("鸟在吃饭");
    }
    @Override
    public void fly() {
        System.out.println("鸟在飞");
    }
}

5.迪米特原则

迪米特原则(Law ofDemeter LoD)是指一个对象应该对其他对象保持最少的了解,又叫最少知道原则(Least Know Principle,LKP),尽量降低类与类之间的耦合度。迪米特原则主要强调:只和朋友交流,不和陌生人交流.出现在成员变量,方法的输入,输出参数中的类都可以称为成员朋友类,而出现在方法体内部的类不属于朋友类.

public class Course {
}
public class TeamLeader {
    public void checkNumberOfCourses(List<Course> list) {
        System.out.println("目前已发布的课程数量是:" + list.size());
    }
}
public class Boss {
    public void commandCheckNumber(TeamLeader teamLeader) {
        List<Course> courseList = Arrays.asList(new Course());
        teamLeader.checkNumberOfCourses(courseList);
    }

    public static void main(String[] args) {
        Boss boss = new Boss();
        TeamLeader teamLeader = new TeamLeader();
        boss.commandCheckNumber(teamLeader);
    }
}

根据迪米特原则,Boss只想要结果,不需要跟Course直接交流,而TeamLeader统计需要用Course对象,Boss和Course并不是朋友.

优化后的代码

public class TeamLeader {
    public void checkNumberOfCourses() {
        List<Course> courseList = Arrays.asList(new Course());
        System.out.println("目前已发布的课程数量是:" + courseList.size());
    }
}
public class Boss {
    public void commandCheckNumber(TeamLeader teamLeader) {
        teamLeader.checkNumberOfCourses();
    }
    public static void main(String[] args) {
        Boss boss = new Boss();
        TeamLeader teamLeader = new TeamLeader();
        boss.commandCheckNumber(teamLeader);
    }
}

6.里氏替换原则

里氏替换原则(Liskov Substitution Principle,LSP)是指如果对每一个类型为T1的的对象O1都有类型为T2的对象O2,使得以T1定义的所有程序P在所有的对象O1替换成O2时,P的行为没有发生变化,那么类型T2是类型T1的子类型

子类可以替换父类
继承有一些优点

• 1.提高代码的重用性，子类拥有父类的方法和属性；
• 2.提高代码的可扩展性，子类可形似于父类，但异于父类，保留自我的特性；

缺点：侵入性、不够灵活、高耦合

• 1.继承是侵入性的，只要继承就必须拥有父类的所有方法和属性，在一定程度上约束了子类，降低了代码的灵活性；
• 2.增加了耦合，当父类的常量、变量或者方法被修改了，需要考虑子类的修改，所以一旦父类有了变动，很可能会造成
  非常糟糕的结果，要重构大量的代码。

任何基类可以出现的地方，子类一定可以出现。里氏替换原则是继承复用的基石，只有当衍生类可以替换基类，软件单位的功能不受到影响时，即基类随便怎么改动子类都不受此影响，那么基类才能真正被复用

因为继承带来的侵入性，增加了耦合性，也降低了代码灵活性，父类修改代码，子类也会受到影响，此时就需要里氏替换原则。

• 子类必须实现父类的抽象方法，但不得重写（覆盖）父类的非抽象（已实现）方法。
• 子类中可以增加自己特有的方法。
• 当子类覆盖或实现父类的方法时，方法的前置条件（即方法的形参）要比父类方法的输入参数更宽松。
• 当子类的方法实现父类的抽象方法时，方法的后置条件（即方法的返回值）要比父类更严格。

public class Rectangle {

    private long height;
    private long width;

    public long getHeight() {
        return height;
    }

    public void setHeight(long height) {
        this.height = height;
    }

    public long getWidth() {
        return width;
    }

    public void setWidth(long width) {
        this.width = width;
    }
}
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 super.getHeight();
    }

    @Override
    public void setHeight(long height) {
        super.setHeight(height);
    }

    @Override
    public long getWidth() {
        return super.getWidth();
    }

    @Override
    public void setWidth(long width) {
        super.setWidth(width);
    }
}
public class Main {
    public static void main(String[] args) {
        Rectangle rectangle=new Rectangle();
        rectangle.setWidth(20);
        rectangle.setHeight(10);
        resize(rectangle);

        Square square=new Square();
        square.setLength(10);
        resize(square);
    }
    public static  void resize(Rectangle rectangle){
        while (rectangle.getWidth()>=rectangle.getHeight()){
            rectangle.setHeight(rectangle.getHeight()+1);
            System.out.println("widht:"+rectangle.getWidth()+",height:"+rectangle.getHeight());
        }
        System.out.println("resize方法结束");
    }
}

7.合成复用原则

合成复用原则(Composite/Aggregate Reuse Principle,CARP)是指经量使用对象组合(has-a)/聚合(contanis-a)而不是继承关系达到软件复用的目的,可以使系统更灵活,降低类与类之间的耦合度,一个类的变化对其他类造成的

继承叫做白箱复用,相当于把所有的实现细节暴露给子类,组合/聚合称为黑箱复用,我们无法获取到类以外的对象的实现细节.

public class DBConnection {
    public  String getConnection(){
        return "MySQL数据库连接";
    }
}
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不是抽象,不便于系统扩展,如果数据库操作层需要指出Oracle数据，虽然我们在DBConnection中增加对Oracle数据库的支持,但是这违背了开闭原则,其实,我们可以不修改Dao的代码,而将DBConnection修改为"“abstract”

修改后的代码

public abstract class DBConnection {
    public abstract String getConnection();
}
public class MysqlConnection extends DBConnection {
    @Override
    public String getConnection() {
        return "MySql数据库连接";
    }
}
public class OracleConnection extends DBConnection {
    @Override
    public String getConnection() {
        return "Oracle数据库连接";
    }
}

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+"增加产品");
    }

    public static void main(String[] args) {
        ProductDao productDao=new ProductDao();
        productDao.setDbConnection(new OracleConnection());
        productDao.addProduct();
    }
}