本博客,来源于学习尚硅谷视频的总结笔记
设计模式(design pattern)–设计原则
设计模式的原则(规范约束)
- 单一职责原则
- 接口隔离原则
- 依赖倒转(倒置)原则
- 里氏替换原则
- 开闭原则
- 迪米特法则
- 合成复用原则
设计模式的目的
- 代码重用性 (即:相同功能的代码,不用多次编写)
- 可读性 (即:编程规范性, 便于其他程序员的阅读和理解)
- 可扩展性 (即:当需要增加新的功能时,非常的方便,称为可维护)
- 可靠性 (即:当我们增加新的功能后,对原来的功能没有影响)
- 使程序呈现高内聚,低耦合的特性
可以使用到的地方
1.功能模块中(设计模式+算法)
2.框架中(多种设计模式)
设计模式的实现(具体的模式)
二十三种设计模式:工厂模式等。。。
1. 单一职责原则
一个mapper管user就只管user,不需要再去操作count数据库中的数据,需要单一原则。
总结
各司其职,可以是类上的单一,也可以是方法上的单一。
- 降低类的复杂度,一个类只负责一项职责。
- 提高类的可读性,可维护性
- 降低变更引起的风险
- 通常情况下,我们应当遵守单一职责原则,只有逻辑足够简单,才可以在代码级违反单一职责原则;只有类中方法数量足够少,可以在方法级别保持单一职责原则
2.接口隔离原则
客户端不应该依赖它不需要的接口,即一个类对另一个类的依赖应该建立在最小的接口上
一个功能类A实现接口中的功能,那么一个使用类B在使用此接口调用方法的时候,若是A中实现的接口中的方法,在B类中不需要,那么就不符合接口隔离原则,就需要对接口进行抽离。
总结
就是一个接口类有很多接口,但是一个类为了去使用里面的一个方法,却要去实现里面的所有的,而使用的时候,却不会使用完,就是这个时候,就需要对接口进行拆分,进行接口隔离。
3.依赖倒转原则(Dependence Inversion Principle)
依赖倒转原则(Dependence Inversion Principle)是指:
-
高层模块不应该依赖低层模块,二者都应该依赖其抽象
-
抽象不应该依赖细节,细节应该依赖抽象
-
依赖倒转(倒置)的中心思想是面向接口编程
-
依赖倒转原则是基于这样的设计理念:相对于细节的多变性,抽象的东西要稳定的多。以抽象为基础搭建的架构比以细节为基础的架构要稳定的多。在 java 中,抽象指的是接口或抽象类,细节就是具体的实现类
-
使用接口或抽象类的目的是制定好规范(也就是设计),而不涉及任何具体的操作,把展现细节的任务交给他们的实现类去完成
总结
一般面向接口,抽象,都是向上抽取,接口在上面,具体实现类在下面,类依赖接口,所以叫依赖倒置。
使用接口,就是为了程序的课扩展性。
所谓依赖: 可以是类对接口实现的依赖。
也可以是一个A类中的方法,使用到了另一个B类中的方法,这个时候会引入B类,这种关系的依赖。此种方式,是A类对B类的依赖。
另外,也可以是A类中的方法,调用了D接口类中的抽象方法,而传入A类中的方法的B类,实现了D接口中的方法,此时相当于A类调用的是B类中的方法,而使用的却是接口。这个就是上面的接口隔离所说,也就是A类通过接口D依赖了B类。此种方法的依赖,因为是A类依赖的是D接口,而实际使用的是B类的实现的方法,相当于细节依赖抽象,所以可以说依赖倒置。
依赖关系的传递方式(接口的传递)
一般情况下,都是依赖倒置,所以一般直接依赖的都是接口,然后传递接口的实现类,就通过接口依赖了类。
所以依赖的传递方式,也可以说是接口的传递。
- 可以通过接口进行传递,就是通过方法中的形参,形参是一个接口的参数,然后调用的时候,传递他的实现类,就是传递依赖。
- 可以通过构造方法传递,构造方法的形参,设置成一个即可参数,在创建实体的时候,传递接口的实现,就传递了依赖。
- 可以通过setter方法传递,在创建实体后,然后通过set方法,传递接口的实现类,然后实现依赖的传递
依赖倒转的细节
-
低层模块尽量都要有抽象类或接口,或者两者都有,程序稳定性更好.
-
变量的声明类型尽量是抽象类或接口,如controller层调用业务层都是使用service接口, 这样我们的变量引用和实际对象间,就存在一个缓冲层,利于程序扩展和优化
-
继承时遵循里氏替换原则
4.里氏替换原则
OO(指面向对象) 中的继承性存在的一个问题
A类中有一个相减的方法,而B类继承了A类,无意间实现了A类的相减的方法,但是把实现的方法变成了相加。这就会出现,在程序中要使用A的子类B的父类的相减的方法的时候,却出现了相加的结果,就造成了错误。
public class Liskov {
public static void main(String[] args) {
Aa = new A();
System.out.println("11-3=" + a.func1(11, 3)); //调用相减的方法
Bb = new B();
System.out.println("11-3=" + b.func1(11, 3));//这里本意是求出 11-3
//因为已经知道了有继承的关系,所以也就知道能调用父方法,此处就是想调用父方法的相减的功能,
//但是字方法实现了父方法,并且还改成了相加,就造成了错误
}
}
// A 类
class A {
// 返回两个数的差
public int func1(int num1, int num2) { return num1 - num2;
}
}
// B 类继承了 A
// 增加了一个新功能:完成两个数相加,然后和 9 求和 class B extends A {
//这里,重写了 A 类的方法, 可能是无意识
public int func1(int a, int b) { return a + b;
}
public int func2(int a, int b) { return func1(a, b) + 9;
}
}
使用里氏替换原则解决这个问题
使用继承时,遵循里氏替换原则,在子类中尽量不要重写父类的方法
通用的做法是:原来的父类和子类都继承一个更通俗的基类(或者抽离成接口),原有的继承关系去掉,采用依赖,聚合,组合等关系代替
组合:就是在B类中要想使用A类的方法,就创建一个A类的对象,然后调用A类实体中的方法,这就是组合。
理解:不要直接通过继承去操作另一个类的方法,而是通过向上抽离然后依赖或者组合的方法
5.开闭原则(ocp)
介绍
-
开闭原则(Open Closed Principle)是编程中最基础、最重要的设计原则
-
一个软件实体如类,模块和函数应该对扩展开放**(对提供方),对修改关闭(对使用方)**。用抽象构建框架,用实现扩展细节。
-
当软件需要变化时,尽量通过扩展软件实体的行为来实现变化,而不是通过修改已有的代码来实现变化。
-
编程中遵循其它原则,以及使用设计模式的目的就是遵循开闭原则。
理解
在设计的时候,设计的程序,在以后扩展的时候,不能去修改源码,而是添加新的东西就能使用。
即,设计的程序,对扩展功能是开放的,但是在源码上面修改是关闭的。
面向接口的编程,设计原则基本都是围绕面向接口来说的。公共的抽象成接口。
通过接口依赖类,然后调用方法,然后实现功能的扩展。
使用接口抽离后,在接口上面扩展实现类是开放的(提供方),而通过接口,使用接口中的方法的使用方,修改使用方的源码是关闭的。
6.迪米特法则(Demeter Principle)
-
一个对象应该对其他对象保持最少的了解
-
类与类关系越密切,耦合度越大
-
迪米特法则(Demeter Principle)又叫最少知道原则,即一个类对自己依赖的类知道的越少越好。也就是说,对于被依赖的类不管多么复杂,都尽量将逻辑封装在类的内部。对外除了提供的 public 方法,不对外泄露任何信息
-
迪米特法则还有个更简单的定义:只与直接的朋友通信
-
直接的朋友:每个对象都会与其他对象有耦合关系,只要两个对象之间有耦合关系,我们就说这两个对象之间是朋友关系。耦合的方式很多,依赖,关联,组合,聚合等。其中,我们称出现成员变量,方法参数,方法返回值中的类为直接的朋友,而出现在局部变量中的类不是直接的朋友。也就是说,陌生的类最好不要以局部变量的形式出现在类的内部。
解决办法
若是在方法中,也即局部变量中使用了其他的类,那么就违背了迪米特法则,那么就可以进行改进,把违背的方法,进行封装,封装到直接朋友的类中,然后通过类进行调用方法。
注意事项和细节
-
迪米特法则的核心是降低类之间的耦合
-
但是注意:由于每个类都减少了不必要的依赖,因此迪米特法则只是要求降低类间(对象间)耦合关系,并不是要求完全没有依赖关系
7.合成复用原则(Composite Reuse Principle)
原则是尽量使用合成/聚合的方式,而不是使用继承
设计原则核心思想
-
找出应用中可能需要变化之处,把它们独立出来,不要和那些不需要变化的代码混在一起。
-
针对接口编程,而不是针对实现编程。
-
为了交互对象之间的松耦合设计而努力