一、开闭原则
开闭原则是指一个软件实体如类、模块和函数应该对扩展开放,对修改关闭。可以提高软件系统的可复用性及可维护性。开闭原则,是面向对象设计中最基础的设计原则。
以商品为例:
/**
* 商品通用接口
*/
public interface IShangPin {
String getName();//名字
Double getPrice();//价格
}
创建一个商品类实现商品接口
public class ShangPin implements IShangPin{
private String name;
private Double price;
public ShangPin(String name, Double price) {
this.name = name;
price = price;
}
@Override
public String getName() {
return this.name;
}
@Override
public Double getPrice() {
return this.price;
}
}
通过main方法可以获取商品的原价和名称。
public class test {
public static void main(String[] args) {
IShangPin pin = new ShangPin("茅台", 3000.0);
System.out.println("商品名称:"+ pin.getName()+ " 商品价格:"+ pin.getPrice());
//运行结果:商品名称:茅台 商品价格:3000.0
}
}
如果对固定商品打折,我们不可能在原来的基础上进行折扣,那样会影响其他的商品价格。
public class MaoTai extends ShangPin{
public MaoTai(String name, Double price) {
super(name, price);
}
public Double getPrice(){
//茅台打95折
return super.getPrice() * 0.95;
}
}
通过main方法可以获取商品的折后价和名称。
public class test {
public static void main(String[] args) {
IShangPin maoTai = new MaoTai("茅台", 3000.0);
System.out.println("商品名称:"+ maoTai.getName()+ " 折后价格:"+ maoTai.getPrice());
//运算结果:商品名称:茅台 折后价格:2850.0
}
}
代码结构图:
二、依赖倒置原则
依赖倒置原则是指设计代码结构时,高层模块不应该依赖底层模块,二者都应该依赖其抽象。抽象不应该依赖细节:细节应该依赖抽象。通过依赖倒置,可以减少类与类直接的耦合性,提高系统的稳定性,提高代码的可读性和可维护性,并降低修改程序所造成的风险。
接下来已课程为例,先创建一个类Tom:
public class Tom {
public void studyJavaCourse(){
System.out.println("Tom在学习Java课程");
}
public void studyPythonCourse(){
System.out.println("Tom在学习Python课程");
}
}
调用方法
public class test {
public static void main(String[] args) {
Tom tom = new Tom();
tom.studyJavaCourse();
tom.studyPythonCourse();
}
}
Tom目前正在学java课程和python课程,如果Tom还想学习其他课程,我们的代码就要从底层到高层(调用层)一次修改代码,会给代码带来意想不到的风险。
接下来优化代码,创建一个课程抽象ICourse接口:
public interface ICourse {
void study();
}
然后写JavaCourse类:
public class JavaCourse implements ICourse{
@Override
public void study() {
System.out.println("Tom在学习Java课程");
}
}
再写PythonCourse类:
public class PythonCourse implements ICourse{
@Override
public void study() {
System.out.println("Tom在学习Python课程");
}
}
修改Tom类:
public class Tom{
public void study(ICourse course){
course.study();
}
}
看main方法:
public class test {
public static void main(String[] args) {
Tom tom = new Tom();
tom.study(new JavaCourse());
tom.study(new PythonCourse());
}
}
对于新课程,只需要新建一个类,通过传参的方法告诉Tom,而不需要修改底层代码。实际上这是一种非常熟悉的方法,叫依赖注入。注入的方式还有构造器方式和setter方式。
切记:以抽象为基准比以细节为基准搭建起来的架构要稳定得多,因此大家拿到需求之后,要面向接口编程,先顶层再细节来设计代码的结构。
三、单一职责原则
单一职责是指不要存在多于一个导致类变更的原因。假设我们有一个Class负责两个职责,一旦发生需求变更,修改其中一个职责的逻辑代码,有可能会导致另一个职责的功能发生故障。这样一来,这个Class存在两个导致类变更的原因。如何解决这个问题呢?我们就要给两个职责分别用两个Class来实现,进行解耦。后期需求变更维护互不影响。这样的设计,可以降低类的复杂度,提高类的可读性,提高系统的可维护性,降低变更引起的风险。总体来说就是一个Class/Interface/Method 只负责一项职责。
四、接口隔离原则
接口隔离原则是指用多个专门的接口,而不使用单一的总接口,客服端不应该依赖它不需要的接口。这个原则指导我们在设计接口时应当注意一下己点:
- 一个类对一个类的依赖应该建立在最小接口之上。
- 建立单一接口,不要建立庞大臃肿的接口。
- 尽量细化接口,接口中的方法尽量少(不是越少越好,一定要适度)。
接口原则符合我们常说的高内聚低耦合的设计思想,从而使得类具有很好的可读性、可扩展性和可维护性。
五、迪米特原则
迪米特原则是指一个对象应该对其它对象保持最少的了解,又叫最少知道原则,尽量降低类与类之间的耦合。
六、里氏替换原则
里氏替换原则是指一个软件实体如果适用于一个父类的话,那么一定是适用于其子类,所有引用父类的地方必须能透明地使用其子类的对象,子类对象能替换父类对象,而逻辑不变。根据这个理解,我们总结一下:
引申含义:子类可以扩展父类的功能,但不能改变父类原有的功能。
- 子类可以实现父类的抽象方法,但不能覆盖父类的非抽象方法。
- 子类中可以增加自己特有的方法。
- 当子类的方法重载父类的方法时,方法的前置条件(即方法的输入/入参)要比父类方法的输入参数更宽松。
- 当子类的方法实现父类的方法时(重写/重载或实现抽象方法),方法的后置条件(即方法的输出/返回值)要比弗雷德更能严格或平等。
七、合成复用原则
合成复用原则(Composite Reuse Principle,CRP)又叫组合/聚合复用原则(Composition/Aggregate Reuse Principle,CARP)。它要求在软件复用时,要尽量先使用组合或者聚合等关联关系来实现,其次才考虑使用继承关系来实现。
如果要使用继承关系,则必须严格遵循里氏替换原则。合成复用原则同里氏替换原则相辅相成的,两者都是开闭原则的具体实现规范。