标签：依赖倒置原则 根据 extends 耦合 添加 打折 替换 ide xtend
模块、类和函数应该对扩展开发，对修改关闭。
用抽象构建框架，用实现扩展细节。
优点：提高软件系统的可重用性和可维护性。
开发的软件正在构建一个复杂的结构，一旦我们完成了它的一部分，不应该再修改它，而是应该在它的基础之上继续建设。
最好的办法是尝试在完成后保持模块不变，并通过继承和多态扩展来添加新功能。开闭原则是最重要的设计原则之一，是大多数设计模式的基础。
如图所示，假设现在有一个课程接口ICourse，有一门课程JavaCourse继承该接口，并实现了接口中的方法。后续有一个课程打折的新需求，由于之前的接口和课程类已经写好，对于新需求不应该直接修改接口或者已经实现好的类，而是选择新建一个打折类JavaDiscountCourse继承JavaCourse，实现打折功能。实现代码如下：
//ICourse.java
public interface ICourse {
Integer getId();
String getName();
Double getPrice();
}
//JavaCourse.java
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.java
public class JavaDiscountCourse extends JavaCourse {
public JavaDiscountCourse(Integer id, String name, Double price) {
super(id, name, price);
}
public Double getDiscountPrice(){
return super.getPrice()*0.8;
}
}
//Test.java
public class Test {
public static void main(String[] args) {
ICourse course = new JavaDiscountCourse(23,"JAVA",100.0);
JavaDiscountCourse jdCourse = (JavaDiscountCourse) course;
System.out.println(jdCourse.getId()+","+jdCourse.getName()+","+jdCourse.getPrice()+","+jdCourse.getDiscountPrice());
}
}
高层模块不应该依赖低层模块，二者都应该依赖其抽象。
抽象不应该依赖细节；细节应该依赖抽象。
针对接口编程，不要针对实现编程。
优点：可以减少类间的耦合性、提高系统稳定性，提高代码可读性和可维护性，可降低修改程序所造成的风险。
耦合是指软件系统的模块彼此依赖的程度。依赖度越低，维护和扩展系统就越容易。有不同的方法来解耦系统的组件。其中一个办法是将高级逻辑与低级模块分开。这样做时，可以尝试让它们都依赖于抽象进而减少二者之间的依赖关系。如此就可以替换或扩展其中任何一个模块而不影响其他模块。
如图所示，现在需求是学生要学习不同的课程，但是不是通过让学生直接依赖具体的课程，然后调用课程的学习方法。而是让学生依赖课程接口ICourse，而具体的课程PythonCourse，JavaCourse同样依赖ICourse，这就是高层模块Student依赖抽象，低层模块具体实现也依赖于抽象。然后以抽象接口为桥梁，高层模块通过抽象接口中的方法调用具体的实现细节。实现代码如下：
//ICourse.java
public interface ICourse {
void studyCourse();
}
//JavaCourse,java
public class JavaCourse implements ICourse{
public void studyCourse() {
System.out.println("study java");
}
}
//PythonCourse.java
public class PythonCourse implements ICourse{
public void studyCourse() {
System.out.println("study python");
}
}
//Student.java
public class Student {
private ICourse iCourse;
public Student(ICourse iCourse){
this.iCourse=iCourse;
}
public void studyCourse(){
iCourse.studyCourse();
}
}
//Test.java
public class Test {
public static void main(String[] args) {
Student s1 = new Student(new JavaCourse());
s1.studyCourse();
Student s2 = new Student(new PythonCourse());
s2.studyCourse();
}
}
一个类/接口/方法只负责一项职责,不要存在多于一个导致类变更的原因。
有点：降低类的复杂度、提高类的可读性提高系统的可维护性、降低变更引起的风险
假设有一个现在需求还是对课程的操作，有获取课程内容的操作，有学习课程操作和课程退款操作等。定义一个ICourse接口如下：
//ICourse.java
public interface ICourse {
String getCourseName();
byte[] getCourseVideo();
void studyCourse();
void refundCourse();
}
这样将获取课程内容的方法和课程管理相关的方法放在一个接口中，根据单一职责原则，应该将其分开，如下所示，分别新建课程内容ICourseContent接口和课程管理ICourseManager接口：
//ICourseContent.java
public interface ICourseContent {
String getCourseName();
byte[] getCourseVideo();
}
//ICourseManager.java
public interface ICourseManager {
void studyCourse();
void refundCourse();
}
PS：实际设计中，要考虑实际情况，因为遵循单一职责原则会造成接口，类数量的增多，开发成本增大，最后应该是各种软件设计原则和开发成本，后期维护的综合权衡。
客户端不应该依赖于它所不需要的接口。（用多个专门的接口，而不是单一的总接口）
一个类对一个类的依赖应该建立在最小的接口上。建立单一的接口，不要建立臃肿庞大的接口。接口中的方法尽量少。
假设现在要建立一个动物的行为接口IAnimalAction，动物可以吃，飞，和游泳。现在有动物狗Dog，鸟Bird继承该接口，就会有它不需要的方法。如下所示：
//IAnimalAction.java
public interface IAnimalAction {
void eat();
void fly();
void swim();
}
//Bird.java
public class Bird implements IAnimalAction {
@Override
public void eat() {
}
@Override
public void fly() {
}
@Override
public void swim() {
}
}
//Dog.java
public class Dog implements IAnimalAction {
@Override
public void eat() {
}
//狗不会飞，不需要该方法
@Override
public void fly() {
}
@Override
public void swim() {
}
}
解决上述问题的办法是将不同的行为单独建立接口IEatAnimalAction，IFlyAnimalAction，ISwimAnimalAction，然后动物分别继承它们需要的接口。
//IEatAnimalAction.java
public interface IEatAnimalAction {
void eat();
}
//IFlyAnimalAction.java
public interface IFlyAnimalAction {
void fly();
}
//ISwimAnimalAction.java
public interface ISwimAnimalAction {
void swim();
}
//Dog.java
public class Dog implements ISwimAnimalAction,IEatAnimalAction {
@Override
public void eat() {
}
@Override
public void swim() {
}
}
PS：对于接口隔离原则，同意需要主要适度，设计太多的接口会增加开发成本，还会造成接口数量的增多。
强调只和朋友交流，不和陌生人说话。
朋友：出现在成员变量，方法的输入、输出参数中的类称为成员朋友类，而出现在方法体内部的类不属于朋友类。
现假设有一个Boss类需要通过一个TeamLeader类了解课程数量
//TeamLeader.java
public class TeamLeader {
public void checkNumberOfCourse(List<Coures> couresList){
System.out.println("在线课程的数量是："+couresList.size());
}
}
//Coures.java
public class Coures {
}
//Boss.java
public class Boss {
public void commandCheakNumber(TeamLeader teamLeader){
List<Coures> couresList = new ArrayList<>();
for (int i=0;i<20;i++){
couresList.add(new Coures());
}
teamLeader.checkNumberOfCourse(couresList);
}
}
此时Boss类中直接依赖课程类，不符合迪米特原则，可以将课程相关操作移动到TeamLeader类中
//Boss.java
public class Boss {
public void commandCheckNumber(TeamLeader teamLeader){
teamLeader.checkNumberOfCourses();
}
}
//TeamLeader.java
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());
}
}
如果对每一个类型为T1的对象o1，都有类型为T2的对象o2，使得以T1定义的所有程序P在所有的对象o1都替换成o2时，程序P的行为没有发生变化，那么类型T2是类型T1的子类型。
一个软件实体如果适用一个父类的话，那一定适用于其子类，所有引用父类的地方必须能透明的使用其子类的对象，子类对象能够替换父类对象，而程序逻辑不变。
尽量使用对象组合/聚合，而不是继承关系达到软件复用的目的。
聚合 has-A和组合contains-A
优点：可以使系统更加灵活，降低类与类之间的耦合度，一个类的变化对其他类造成的影响相对较少。
标签：依赖倒置原则 根据 extends 耦合 添加 打折 替换 ide xtend
原文地址：https://www.cnblogs.com/Wenjin-Liu/p/13776081.html
