开闭原则

 一个软件实体如类、模块、函数应该对扩展开放，对修改关闭。用抽象构建框架，用实现扩展细节，面向抽象编程。（继承、多态）
 优点：提高软件系统的可复用性及可维护性。

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(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(Integer id, String name, Double price) {
        super(id, name, price);
    }

    public Double getOriginPrice() {
        return super.getPrice();
    }

    public Double getDiscountPrice(){
        return super.getPrice()*0.8;
    }
}

Test

public class Test {
    public static void main(String[] args) {
        ICourse iCourse = new JavaDiscountCourse(96, "Java从零到企业级电商开发", 348d);
        JavaDiscountCourse javaCourse = (JavaDiscountCourse) iCourse;
        System.out.println("课程ID:" + javaCourse.getId() +
                " 课程名称:" + javaCourse.getName() +
                " 课程原价:" + javaCourse.getOriginPrice() +
                " 课程折后价格:" + javaCourse.getDiscountPrice() + "元");
    }
}

依赖倒置原则

 高层模块不应该依赖于低层模块，二者都应该依赖其抽象。
 抽象不应该依赖细节；细节应该依赖抽象。
 针对接口编程，不要针对实现编程。
 相对于细节的多变性，抽象的东西要稳定的多。 面向接口编程。
 优点：可以减少类间的耦合性，提高系统稳定性，提高代码可读性和维护性，可降低修改程序所造成的风险。

ICourse

public interface ICourse {
    void studyCourse();
}

JavaCourse

public class JavaCourse implements ICourse {

    @Override
    public void studyCourse() {
        System.out.println("Geely在学习Java课程");
    }
}

PythonCourse

public class PythonCourse implements ICourse {
    @Override
    public void studyCourse() {
        System.out.println("Geely在学习Python课程");
    }
}

FECourse

public class FECourse implements ICourse {
    @Override
    public void studyCourse() {
        System.out.println("Geely在学习FE课程");
    }
}

Geely

public class Geely {
    private ICourse iCourse;

    //这里通过setXXX 方法，也可以通过构造方法注入。
    //面向接口编程
    public void setiCourse(ICourse iCourse) {
        this.iCourse = iCourse;
    }
  
    public void studyImoocCourse(){
        iCourse.studyCourse();
    }
}

Test

public class Test {
  
    public static void main(String[] args) {
        Geely geely = new Geely();
      
        //解耦 Geely 和 Test，将选择权交给高层模块 Test 类。
	//Geely 和 JavaCourse 解耦，Geely 依赖于 ICourse 
	//面向接口编程
        geely.setiCourse(new JavaCourse());
        geely.studyImoocCourse();

        geely.setiCourse(new FECourse());
        geely.studyImoocCourse();
    }
}

单一职责原则

 不要存在多于一个导致类变更的原因。
 一个类/接口/方法，只负责一项职责。
 在实际开发中尽量做到，接口、方法的单一职责。类的单一职责需要看实际情况。
 优点：降低类的复杂度、提高类的可读性，提高系统的可维护性、降低变更引起的风险。

类级别

FlyBird

public class FlyBird {
    public void mainMoveMode(String birdName){
        System.out.println(birdName+"用翅膀飞");
    }
}

WalkBird

public class WalkBird {
    public void mainMoveMode(String birdName){
        System.out.println(birdName+"用脚走");
    }
}

Test

public class Test {
    public static void main(String[] args) {
      
        FlyBird flyBird = new FlyBird();
        flyBird.mainMoveMode("大雁");

        WalkBird walkBird = new WalkBird();
        walkBird.mainMoveMode("鸵鸟");
    }
}

接口级别

ICourseContent

public interface ICourseContent {
    String getCourseName();
    byte[] getCourseVideo();
}

ICourseManager

public interface ICourseManager {
    void studyCourse();
    void refundCourse();
}

ICourse

public interface ICourse {
    String getCourseName();
    byte[] getCourseVideo();

    void studyCourse();
    void refundCourse();
}

方法级别

    private void updateUsername(String userName){
        userName = "geely";
    }
    private void updateUserAddress(String address){
        address = "beijing";
    }

接口隔离原则

 用多个专门的接口，而不使用单一的总接口，客户端不应该依赖它不需要的接口。
 适度原则，一定要适度（也不要太细化，这样会导致接口数量过多，提高程序设计的复杂性）。
 注意点：

* 一个类对一个类的依赖应该建立在最小的接口上
* 建立单一接口，不要建立庞大臃肿的接口
* 尽量细化接口，接口中的方法尽量少

 优点：符合我们常说的高内聚低耦合的设计思想，从而使得类具有很好的可读性，可扩展性和可维护性。

IEatAnimalAction

public interface IEatAnimalAction {
    void eat();
}

ISwimAnimalAction

public interface ISwimAnimalAction {
    void swim();
}

IFlyAnimalAction

public interface IFlyAnimalAction {
    void fly();
}

Dog

public class Dog implements ISwimAnimalAction,IEatAnimalAction {

    @Override
    public void eat() {
        System.out.println("eating ...");
    }
    @Override
    public void swim() {
        System.out.println("swimming ...");
    }
}

迪米特原则

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

Boss

public class Boss {

    public void commandCheckNumber(TeamLeader teamLeader){
        teamLeader.checkNumberOfCourses();
    }

}

TeamLeader

public class TeamLeader {
    public void checkNumberOfCourses(){
        List<Course> courseList = new ArrayList<Course>();
        for(int i = 0 ;i < 20;i++){
            courseList.add(new Course());
        }
        System.out.println("在线课程的数量是："+courseList.size());
    }
}

Course

public class Course {

}

Test

public class Test {
    public static void main(String[] args) {
        Boss boss = new Boss();
        TeamLeader teamLeader = new TeamLeader();
	//Boss 不需要再知道 Course
        boss.commandCheckNumber(teamLeader);
    }
}