1、开闭原则（Open-closed Principle）
开闭原则，是面向设计中最基础的设计原则。
一个软件实体类、模块、函数应该对扩展开放、对修改关闭。
强调的是用抽象构建框架，用实现扩展细节。可以提高软件系统的可复用性和可维护性。
实例：
public interface ICourse {Integer getId();String getName();Double getPrice();}
public class JavaCourse implements ICourse{private Integer id;private String name;private Double price;public Integer getId() {return this.id;}public String getName() {return this.name;}public Double getPrice() {return this.price;}public JavaCourse(Integer id, String name, Double price) {this.id = id;this.name = name;this.price = price;}
}
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 getPrice() {return super.getPrice() * 0.6;}}
2、本末倒置原则（Dependence Inversion Principle）
高层模块不应该依赖底层模块，二者都应该依赖其抽象。
抽象不应该依赖细节，细节应该依赖抽象。
本末倒置可以减少类与类之间的耦合性，提高系统的稳定性，提高代码的可读性和可维护性，降低修改程序造成的风险。
实例：
public interface ICourse {void study();}
public class JavaCourse implements ICourse{@Overridepublic void study() {System.out.println("学习Java");}}
public class PythonCourse implements ICourse{@Overridepublic void study() {System.out.println("学习Python");}}
/*** 方式一：依赖注入，每次学习一个新课程就多创建一个类*/
public class PersonOne {public void study(ICourse iCourse){iCourse.study();}public static void main(String[] args) {PersonOne personOne = new PersonOne();personOne.study(new JavaCourse());personOne.study(new PythonCourse());}
}
/*** 方式二：构造器注入，调用时每次都要创建实例*/
public class PersonTwo {private ICourse iCourse;public PersonTwo(ICourse iCourse) {this.iCourse = iCourse;}public void study() {iCourse.study();}public static void main(String[] args) {PersonTwo personTwo = new PersonTwo(new JavaCourse());personTwo.study();}
}
/*** 方式三：Setter方式注入*/
public class PersonThree {private ICourse iCourse;public void setCourse(ICourse iCourse) {this.iCourse = iCourse;}public void study() {iCourse.study();}public static void main(String[] args) {PersonThree personTwo = new PersonThree();personTwo.setCourse(new JavaCourse());personTwo.study();}
}
3、单一职责（Simple Responsibility Principle）
不要存在多于一个导致类变更的原因
一个对象应该只包含单一的职责，并且该职责被完整地封装在一个类中。
/*** course存在两种处理逻辑，这个地方修改代码*/
public class Course {public void study(String name){if("直播".equals(name)){System.out.println("不能快进");}else {System.out.println("2xx倍速");}}public static void main(String[] args) {Course course = new Course();course.study("直播");}}
修改下的代码，这样把两个课程给分开控制。
public class LiveCourse {public void study(String name){System.out.println("不能快进");}
}
public class ReplayCourse {public void study(String name){System.out.println("2xx倍速");}
}
public class Test {public static void main(String[] args) {LiveCourse liveCourse = new LiveCourse();liveCourse.study("直播");ReplayCourse replayCourse = new ReplayCourse();replayCourse.study("测试");}}`在这里插入代码片`
4、接口隔离原则（Interface Segregation Principle）
用多个专门的接口，而不使用单一的接口，客户端不应该依赖它不需要的接口
- 一个类对一类的依赖应该建立在最小的接口上
- 建立单一接口，不要建立庞大的接口
- 尽量细化接口，接口中的方法尽量少
实例:
public interface Animal {void eat();void fly();void swimming();
}
public class Bird implements Animal{@Overridepublic void eat() {}@Overridepublic void fly() {}@Overridepublic void swimming() {}
}
public class Dag implements Animal{@Overridepublic void eat() {}@Overridepublic void fly() {}@Overridepublic void swimming() {}
}
当dog不能飞，鸟儿不能游泳的时候，这个方法就会空，这时候需要根据动物行为设计不同的接口
public interface EatAnimal {void eat();}
public interface FlyAnimal {void fly();}
public interface SwimmingAnimal {void swimming();}
public class Dog implements SwimmingAnimal, EatAnimal{@Overridepublic void eat() {}@Overridepublic void swimming() {}
}
5、迪米特法则（Law of demeter LoD）
一个对象应该对其他对象保持最少的了解。只和朋友交流，不喝陌生人说话。
出现在成员变量、方法的输入、输出参数中的类都可以称为成员朋友类，出现在方法体内内部的类不属于朋友类。
实例：
public class Course {
}
public class Employee {public void checkNumOfCourse(List<Course> courseList) {System.out.println("课程数量" + courseList.size());}
}
public class Leader {public void CommandCheckNumber(Employee employee){List<Course> courseList = new ArrayList<Course>();for (int i = 0; i < 20; i++) {courseList.add(new Course());}employee.checkNumOfCourse(courseList);}public static void main(String[] args) {Leader leader = new Leader();Employee employee = new Employee();leader.CommandCheckNumber(employee);}
}
根据迪米特法则，Leader只想要结果，不需要和Course有直接的接触，所以这个地方修改
public class EmployeeCp {public void checkNumOfCourse() {List<Course> courseList = new ArrayList<Course>();for (int i = 0; i < 20; i++) {courseList.add(new Course());}System.out.println("课程数量" + courseList.size());}
}
public class LeaderCp {public void CommandCheckNumber(EmployeeCp employee){employee.checkNumOfCourse();}public static void main(String[] args) {LeaderCp leader = new LeaderCp();EmployeeCp employee = new EmployeeCp();leader.CommandCheckNumber(employee);}
}
6、里氏替换原则（Liskov Substitution Priciple）
如果针对一个类型为T1的对象O1，都有类型T2的对象O2，使得以T1定义的所有程序P在所有的对象O1都替换成O2时，程序P的行为没有发生变化，那么类型T2还是类型T1的子类型。
1）子类可以实现父类的抽象方法，但不能覆盖父类的非抽象方法
2）子类仲可以增加自己特有的方法
3）当子类的方法重载父类的方法时，方法的前置条件（入参）要比父类方法的输入参数更宽松
4）当子类的方法实现
父类的方法时，方法的后置条件（输出/返回值）要比父类更严格或相等
优点：
1）约束继承泛滥，开闭原则的一种体现
2）加签程序的健壮性，同时变更也可以做到好的兼容，提高程序的维护性、扩展性，降低需求变更时的风险
实例：
public class Rectangle {private Long height;private Long width;public Long getHeight() {return height;}public Long getWidth() {return width;}public void setHeight(Long height) {this.height = height;}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;}@Overridepublic Long getHeight() {return getLength();}@Overridepublic void setHeight(Long height) {setLength(height);}@Overridepublic Long getWidth() {return getLength();}@Overridepublic void setWidth(Long width) {setLength(width);}}
public class Test {public static void resize(Rectangle rectangle){while (rectangle.getWidth() >= rectangle.getHeight()){rectangle.setHeight(rectangle.getHeight()+1);System.out.printf("width: %s, height:%s", rectangle.getWidth(), rectangle.getHeight());}System.out.printf("width: %s, height:%s", rectangle.getWidth(), rectangle.getHeight());}public static void main(String[] args) {Rectangle rectangle = new Rectangle();rectangle.setWidth(20L);rectangle.setHeight(10L);resize(rectangle);//死循环Square square = new Square();square.setLength(10L);resize(square);}
}
当是正方形的时候，陷入死循环，违背里氏替换原则，父类替换成子类后结果不是预期。
修改代码，创建一个抽象四边形
public interface QuadRectangle {Long getWidth();Long getHeight();
}
public class RectangleCp implements QuadRectangle{private Long height;private Long width;public Long getHeight() {return height;}public Long getWidth() {return width;}public void setHeight(Long height) {this.height = height;}public void setWidth(Long width) {this.width = width;}
}
public class SquareCp implements QuadRectangle {private Long length;public Long getLength() {return length;}public void setLength(Long length) {this.length = length;}@Overridepublic Long getHeight() {return getLength();}@Overridepublic Long getWidth() {return getLength();}}
7、合成复用原则（Composite Reuse Principle）
尽量使用对象组合（has-a）/聚合（contain-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("创建商品");}}
如果这时候不只是mysql还有其他类型的数据库，违反开闭原则
修改代码：
public abstract class DBConnectionCp {public abstract String getConnection();
}
public class MysqlConnection extends DBConnection{@Overridepublic String getConnection() {return "mysql";}
}
public class OracleConnection extends DBConnection{@Overridepublic String getConnection() {return "Oracle";}
}
)
)
