设计模式 第一章 基本原则
文章目录
设计模式 第一章 基本原则前言一、单一职责原则1.介绍2.注意事项3.代码示例
二、接口隔离原则1.介绍2.注意事项3.代码示例
三、依赖倒转原则1.介绍2.注意事项3.代码示例
四、里式替换原则1.介绍2.注意事项3.代码示例
五、开闭原则1.介绍2.注意事项3.代码示例
六、迪米特法则1.介绍2.注意事项3.代码示例
七、合成复用原则1.介绍2.注意事项3.代码示例
前言
设计模式是对软件设计中普通存在的各种问题，
所提出的解决方案。编程过程中会面临耦合性，内聚性，
以及可维护性，可扩展性，重用性，灵活性等多方面的问题，
设计模式是为了解决上面的问题。
设计模式的七大原则：
1. 单一职责原则
2. 接口隔离原则
3. 依赖倒转原则
4. 里式替换原则
5. 开闭原则
6. 迪米特法则
7. 合成复用原则
一、单一职责原则
1.介绍
对类来说，即一个类应该只负责一项职责。
2.注意事项
1. 降低类的复杂度，一个类值负责一项职责
2. 提高类的可读性，可维护性
3. 降低变更引起的风险
4. 我们应当遵守单一职责原则，只有逻辑足够简单，才可以
在代码级别违反单一职责原则；只有类中的方法数量足够少，
可以在方法级别保持单一职责原则
3.代码示例
错误代码
class person{
public void eat(String v
){
return v
+ "吃大米";
}
public void fly(String v
){
return v
+ "在天上飞";
}
}
正确代码
class person{
public void eat(String v
){
return v
+ "吃大米";
}
}
class Air{
public void fly(String v
){
return v
+ "在天上飞";
}
}
二、接口隔离原则
1.介绍
对类来说，即一个类应该尽量不依赖其他类。
2.注意事项
1. 使用多个专门的接口取代统一的接口
3.代码示例
错误代码
interface A{
public void fun1(String v
);
public void fun2(String v
);
public void fun3(String v
);
}
class B implements A{
public void fun1(String v
){
return v
+ "B方法一";
}
public void fun2(String v
){
return v
+ "B方法二";
}
public void fun3(String v
){
return v
+ "B方法三";
}
}
class C implements A{
public void fun1(String v
){
return v
+ "C方法一";
}
public void fun2(String v
){
return v
+ "C方法二";
}
public void fun3(String v
){
return v
+ "C方法三";
}
}
正确代码
interface A{
public void fun1(String v
);
}
interface B{
public void fun2(String v
);
}
interface C{
public void fun3(String v
);
}
class D implements A,B
{
public void fun1(String v
){
return v
+ "D方法一";
}
public void fun2(String v
){
return v
+ "D方法二";
}
}
class E implements A,C
{
public void fun1(String v
){
return v
+ "E方法一";
}
public void fun3(String v
){
return v
+ "E方法三";
}
}
三、依赖倒转原则
1.介绍
面对接口编程，相对于细节的多变性，抽象更稳定
2.注意事项
1. 底层模板尽量使用抽象类或接口
2. 变量的声明类型尽量是抽象类或接口。有利于扩展和优化
3.代码示例
错误代码
calss A
{
public String
fun(){
return "飞机在飞";
}
}
class B {
public String
funB(A a
){
return a
.fun();
}
}
正确代码
interface A{
public String
fun();
}
class B implements A{
public String
fun(){
return "飞机在飞";
}
}
class C implements A{
public String
fun(){
return "鸟在飞";
}
}
class C{
public void funC(A a
){
return a
.fun();
}
}
四、里式替换原则
1.介绍
所有引用基类的地方必须能使用子类的对象，
子类尽量不要重写基类的方法。
2.注意事项
1. 继承实际上让2个类耦合性增加了，在适当的情况下，
可以通过聚合，组合，依赖来解决问题。
3.代码示例
错误代码
calss A
{
public int fun(int num1
,int num2
){
return num1
-num2
;
}
}
class B extends A{
public int fun(int num1
,int num2
){
return num1
+ num2
;
}
}
正确代码
calss A
{
public int fun(int num1
,int num2
){
return num1
-num2
;
}
}
class B {
private A a
= new A();
public int fun(int num1
,int num2
){
return a
.fun(num1
,num2
);
}
}
五、开闭原则
1.介绍
对扩展开放，对修改关闭。
2.注意事项
1. 扩展功能尽量不修改原代码
3.代码示例
错误代码
calss A
{
private int type
;
}
class B {
public void fun(A a
){
if(a
.type
== 1){
fun1();
}else (a
.type
== 2){
fun2();
}
}
public void fun1(){
return "fun1方法";
}
public void fun2(){
return "fun2方法";
}
}
正确代码
abstract calss A
{
private int type
;
public abstract void fun();
}
class B extends A{
B(){
super.type
= 1;
}
public void fun(){
return "方法B";
}
}
class C extends A{
C(){
super.type
= 2;
}
public void fun(){
return "方法C";
}
}
class D{
public void fun(A a
){
a
.fun();
}
}
六、迪米特法则
1.介绍
最少知道原则，即一个类对自己依赖的类知道的越少越好。
尽量与直接朋友通信，类的直接朋友出现在成员变量，
方法参数，方法返回值中。不要以局部变量形式出现在类中。
2.注意事项
2.1 在类的划分上，尽量创建松耦合的类。
2.2 在类的结构设计上，每一个类都应当尽量降
低对成员变量和成员函数的访问权限。
2.3 在类的设计上，只要有可能，一个类型设计成不变类。
2.4 在类的引用上，一个类应当降低对其他类的引用。
3.代码示例
错误代码
class A{
public void a(){
return "A方法";
}
}
class B{
public void b(){
A a
= New
A();
return "B方法引用" + a
.a();
}
}
正确代码
class A{
public void a(){
return "A方法";
}
}
class B{
public void b(A a
){
return "B方法引用" + a
.a();
}
}
七、合成复用原则
1.介绍
尽量使用合成/聚合的方法，而不是使用继承。
2.注意事项
2.1 继承复用，实现简单，易于扩展，破坏系统的封装性；、
2.2 组合/聚合，耦合度较低，选择性的调用成员对象的方法。
3.代码示例
错误代码
class A{
public void fun(){
return "A方法";
}
}
class B extens A
{
public void fun(){
return "B方法";
}
}
正确代码
class A{
public void a(){
return "A方法";
}
}
class B{
private A a
;
public setA(A a
){
this.a
= a
;
}
public void fun(){
return a
.a();
}
}
