开闭原则
定义
一个软件实体，如类，模块和函数应该对扩展开放，对修改关闭。
用抽象构建框架，用实现扩展细节。
优点
提高软件系统的可复用性及可维护性。
package com.web.design.openclose;
public interface ICourse {
Integer getId();
String getName();
Double getPrice();
}
package com.web.design.openclose;
public class JavaCourse implements ICourse {
public Integer id;
public String name;
public Double price;
public JavaCourse(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;
}
}
package com.web.design.openclose;
public class JavaDiscountCourse extends JavaCourse {
public JavaDiscountCourse(Integer id, String name, Double price) {
super(id, name, price);
}
public Double getPrice() {
return super.getPrice();
}
public Double getDiscountPrice() {
return super.getPrice() * 0.8;
}
}
依赖倒置原则
定义
高层模块不应该依赖底层模块，二者都应该依赖其抽象
抽象不应该依赖细节，细节应该依赖抽象。
针对接口编程，不要针对实现编程
优点
可以减少类间的耦合性，提高系统稳定性，提高代码可读性和可维护性，可降低修改程序所造成的风险。
错误写法
package com.web.design.dependenceinversion;
public class People {
//增加功能时，不可修改实现类
public void studyJavaCourse() {
System.out.println("Zhang san study Java");
}
public void studyPythonCourse() {
System.out.println("Zhang san study Python");
}
}
package com.web.design.dependenceinversion;
public class Test {
public static void main(String[] args) {
//v1 针对实现编程
People people = new People();
people.studyJavaCourse();
people.studyPythonCourse();
}
}
正确写法()
package com.web.design.dependenceinversion;
public interface ICourse {
void studyCourse();
}
package com.web.design.dependenceinversion;
public class People {
private ICourse iCourse;
public People() {
}
public People(ICourse iCourse) {
this.iCourse = iCourse;
}
//v1 增加功能时，不可修改实现类
// public void studyJavaCourse() {
// System.out.println("Zhang san study Java");
// }
//
// public void studyPythonCourse() {
// System.out.println("Zhang san study Python");
// }
// v2
public void studyCourse(ICourse iCourse) {
iCourse.studyCourse();
}
//v3
public void studyCourse() {
iCourse.studyCourse();
}
//v4
public void setICourse(ICourse iCourse) {
this.iCourse = iCourse;
}
}
package com.web.design.dependenceinversion;
public class JavaCourse implements ICourse {
@Override
public void studyCourse() {
System.out.println("Zhang san study Java");
}
}
package com.web.design.dependenceinversion;
public class PythonCourse implements ICourse {
@Override
public void studyCourse() {
System.out.println("Zhang san study Python");
}
}
package com.web.design.dependenceinversion;
public class Test {
public static void main(String[] args) {
//v1 针对实现编程
// People people = new People();
// people.studyJavaCourse();
// people.studyPythonCourse();
//v2 通过方法传参
People people = new People();
people.studyCourse(new JavaCourse());
people.studyCourse(new PythonCourse());
//v3 通过构造器传参
People people1 = new People(new JavaCourse());
people1.studyCourse();
// v4 通过setter传参
People people2 = new People();
people2.setICourse(new PythonCourse());
people2.studyCourse();
}
}
单一职责原则
定义
不要存在多余一个导致类变更的原因
一个类/接口/方法只负责一项职责
优点
降低类的复杂度、提高类的可读性、提高系统的可维护性、降低变更引起的风险。
错误写法
package com.web.design.singleresponsibility;
public class Bird {
public void mainMoveMode(String birdName) {
//错误实现方式
if (birdName.equals("鸵鸟")) {
System.out.println(birdName + "用脚走");
} else {
System.out.println(birdName + "用翅膀飞");
}
}
}
package com.web.design.singleresponsibility;
public class Test {
public static void main(String[] args) {
Bird bird = new Bird();
bird.mainMoveMode("大雁");
bird.mainMoveMode("鸵鸟");
}
}
正确写法
package com.web.design.singleresponsibility;
public class FlyBird {
public void mainMoveMode(String birdName) {
System.out.println(birdName + "用翅膀飞");
}
}
package com.web.design.singleresponsibility;
public class WalkBird {
public void mainMoveMode(String birdName) {
System.out.println(birdName + "用脚走");
}
}
package com.web.design.singleresponsibility;
public class Test {
public static void main(String[] args) {
// Bird bird = new Bird();
// bird.mainMoveMode("大雁");
// bird.mainMoveMode("鸵鸟");
FlyBird flyBird = new FlyBird();
flyBird.mainMoveMode("大雁");
WalkBird walkBird = new WalkBird();
walkBird.mainMoveMode("鸵鸟");
}
}
接口隔离原则
定义
用多个专门的接口，而不使用单一的总接口，客户端不应该依赖它不需要的接口。
一个类对一个类的依赖应该建立在最小的接口上。
建立单一接口，不要建立庞大臃肿的接口。
尽量细化接口，接口中的方法尽量少。
优点
符合高内聚低耦合的设计思想，从而使得类具有很好的可读性，可扩展性和可维护性。
错误代码
package com.web.design.interfacesegregation;
public interface IAnimalAction {
void eat();
void fly();
void swim();
}
package com.web.design.interfacesegregation;
public class Dog implements IAnimalAction {
@Override
public void eat() {
}
@Override
public void fly() {
//狗不会飞
}
@Override
public void swim() {
}
}
正确代码
package com.web.design.interfacesegregation;
public interface IEatAnimalAction {
void eat();
}
package com.web.design.interfacesegregation;
public interface IEatAnimalAction {
void eat();
}
package com.web.design.interfacesegregation;
public interface IFlyAnimalAction {
void fly();
}
package com.web.design.interfacesegregation;
public interface ISwimAnimalAction {
void swim();
}
package com.web.design.interfacesegregation;
public class Bird implements IEatAnimalAction, IFlyAnimalAction {
@Override
public void eat() {
}
@Override
public void fly() {
}
}
package com.web.design.interfacesegregation;
public class Dog implements IEatAnimalAction, ISwimAnimalAction {
@Override
public void eat() {
}
@Override
public void swim() {
}
}
迪米特原则
定义
一个对象应该对其他对象保持最少的了解。又叫最少知道原则。
尽量降低类与类之间的耦合。
优点
降低类之间的耦合、
强调只和朋友交流，不和陌生人说话。
朋友：
出现在成员变量、方法的输入、输出参数中的类称为成员朋友类，
而出现在方法体内部的类不属于朋友类。
错误代码
package com.web.design.demeter;
import java.util.ArrayList;
import java.util.List;
public class Boss {
public void commandCheckNumber(TeamLeader teamLeader) {
List<Course> courseList = new ArrayList<>();
for (int i = 0; i < 20; i++) {
courseList.add(new Course());
}
teamLeader.checkNumberOfCourse(courseList);
}
}
package com.web.design.demeter;
import java.util.List;
public class TeamLeader {
public void checkNumberOfCourse(List<Course> courseList) {
System.out.println("course number is " + courseList.size());
}
}
package com.web.design.demeter;
public class Course {
}
package com.web.design.demeter;
public class Test {
public static void main(String[] args) {
Boss boss = new Boss();
TeamLeader teamLeader = new TeamLeader();
boss.commandCheckNumber(teamLeader);
}
}
正确代码
package com.web.design.demeter;
public class Boss {
public void commandCheckNumber(TeamLeader teamLeader) {
teamLeader.checkNumberOfCourse();
}
}
package com.web.design.demeter;
import java.util.ArrayList;
import java.util.List;
public class TeamLeader {
public void checkNumberOfCourse() {
List<Course> courseList = new ArrayList<>();
for (int i = 0; i < 20; i++) {
courseList.add(new Course());
}
System.out.println("course number is " + courseList.size());
}
}
package com.web.design.demeter;
public class Test {
public static void main(String[] args) {
Boss boss = new Boss();
TeamLeader teamLeader = new TeamLeader();
boss.commandCheckNumber(teamLeader);
}
}
里氏替换原则
定义
在编程中常常会遇到这样的问题：有一功能 P1, 由类 A 完成，现需要将功能 P1 进行扩展，扩展后的功能为 P，其中P由原有功能P1与新功能P2组成。新功能P由类A的子类B来完成，则子类B在完成新功能P2的同时，有可能会导致原有功能P1发生故障。
里氏替换原则告诉我们，当使用继承时候，类 B 继承类 A 时，除添加新的方法完成新增功能 P2，尽量不要修改父类方法预期的行为。
里氏替换原则的重点在不影响原功能，而不是不覆盖原方法。
继承包含这样一层含义：父类中凡是已经实现好的方法（相对于抽象方法而言），实际上是在设定一系列的规范和契约，虽然它不强制要求所有的子类必须遵从这些契约，但是如果子类对这些非抽象方法任意修改，就会对整个继承体系造成破坏。而里氏替换原则就是表达了这一层含义。
组合/聚合复用原则 CRP
定义
组合/聚合复用原则就是在一个新的对象里面使用一些已有的对象，使之成为新对象的一部分; 新的对象通过向这些对象的委派达到复用已有功能的目的。
在面向对象的设计中，如果直接继承基类，会破坏封装，因为继承将基类的实现细节暴露给子类；如果基类的实现发生了改变，则子类的实现也不得不改变；从基类继承而来的实现是静态的，不可能在运行时发生改变，没有足够的灵活性。于是就提出了组合/聚合复用原则，也就是在实际开发设计中，尽量使用组合/聚合，不要使用类继承。
举个简单的例子，在某家公司里的员工分为经理，工作者和销售者。如果画成 UML 图可以表示为：
image.png
但是这样违背了组合聚合复用原则，继承会将 Employee 类中的方法暴露给子类。如果要遵守组合聚合复用原则，可以将其改为：
image.png
网友评论