设计模式 （一）设计模式七大原则，UML 基本介绍

目录

• 1 设计模式七大原则
  • 1.1 单一职责原则
  • 1.2 接口隔离原则
  • 1.3 依赖倒转原则
    • 1.3.1 依赖关系传递的三种方式
  • 1.4 里氏替换原则
    • 1.4.1 问题
    • 1.4.2 解决
  • 1.5 开闭原则
  • 1.6 迪米特法则
  • 1.7 合成复用原则
• 2 UML 基本介绍
  • 2.1 依赖
  • 2.2 泛化
  • 2.3 实现
  • 2.4 关联
  • 2.5 聚合
  • 2.6 组合

1 设计模式七大原则

● 1）单一职责原则 ● 2）接口隔离原则 ● 3）依赖倒转原则 ● 4）里氏替换原则 ● 5）开闭原则 ● 6）迪米特法则 ● 7）合成复用原则

1.1 单一职责原则

对类来说的，即一个类应该只负责一项职责。如类A负责两个不同职责：职责1，职责2。当职责1需求变更而改变A时，可能造成职责2执行错误，所以需要将类A的粒度分解为A1，A2

● 1）降低类的复杂度，一个类只负责一项职责 ● 2）提高类的可读性，可维护性 ● 3）降低变更引起的风险 ● 4）通常情况下，我们应当遵守单一职责原则，只有逻辑足够简单，才可以在代码级违反单一职责原则；只有类中方法数量足够少，可以在方法级别保持单一职责原则

1.2 接口隔离原则

客户端不应该依赖它不需要的接口，即一个类对另一个类的依赖应该建立在最小的接口上

1.3 依赖倒转原则

● 1）高层模块不应该依赖低层模块，二者都应该依赖其抽象 ● 2）抽象不应该依赖细节，细节应该依赖抽象 ● 3）依赖倒转（倒置）的中心思想是面向接口编程 ● 4）依赖倒转原则是基于这样的设计理念：相对于细节的多变性，抽象的东西要稳定的多。以抽象为基础搭建的架构比以细节为基础的架构要稳定的多。在java中，抽象指的是接口或抽象类，细节就是具体的实现类 ● 5）使用接口或抽象类的目的是制定好规范，而不涉及任何具体的操作，把展现细节的任务交给他们的实现类去完成

总之：

就是使用接口实现代码，比如，参数是接口类型

1  我们不使用这个原则，那么参数就是具体的类，那么只能使用特定的类对象了
   对象里面的方法也是特定的，这样不好
2  我们可以写一个接口，接口里面定义一个方法，让其他类实现这个接口，并且重写
   里面的方法，那么，作为参数，就有很多的实现类了

● 1）低层模块尽量都要有抽象类或接口，或者两者都有，程序稳定性更好 ● 2）变量的声明类型尽量是抽象类或接口，这样我们的变量引用和实际对象间，就存在一个缓冲层，利于程序扩展和优化 ● 3）继承时遵循里氏替换原则

1.3.1 依赖关系传递的三种方式

1 接口传递

//方式1：通过接口传递实现依赖
//开关的接口
interface IOpenAndClose {
    void open(ITV tv);//抽象方法，接收接口
}
//ITV接口
interface ITV {
    void play();
}
//实现接口
class OpenAndClose implements IOpenAndClose {
    public void open(ITV tv){
        tv.play();
    }
}

2 构造方法传递

//方式2：通过构造函数实现依赖
//开关的接口
interface IOpenAndClose {
    void open();//抽象方法
}
//ITV接口
interface ITV {
    public void play();
}
//实现接口
class OpenAndClose implements IOpenAndClose {
    private ITV tv; // 成员
    
    public OpenAndClose(ITV tv){ // 构造器
        this.tv = tv;
    }
    
    public void open(){
        this.tv.play();
    }
}

3 setter 方式传递

//方式3，通过setter方法传递
interface IOpenAndClose{
    void open();//抽象方法
    void setTv(ITV tv);
}
//ITV接口
interface ITV{
    void play();
}
//实现接口
class OpenAndClose implements IOpenAndClose{
    private ITV tv;
    public void setTv(ITV tv){
        this.tv=tv;
    }
    public void open(){
        this.tv.play();
    }
}

1.4 里氏替换原则

在使用继承时，遵循里氏替换原则，在子类中尽量不要重写父类的方法

1.4.1 问题

如果有的人就想重写父类里面的方法，咋办

1.4.2 解决

将方法提取出来到一个新类里面，比如C 是新类，让A ，B 继承C ，重写C里面的方法就可以了

• 1 如果 即使变成这样，A还是想用B里面的方法咋办 在A 类里面创建B的对象，自己新写一个方法，里面使用B里面的方法

1.5 开闭原则

我们一般在新增功能的时候，一般要修改代码，但是这个原则是尽量少修改，要新增代码，而不是修改原来的代码；

抽象类+接口 实现功能

1.6 迪米特法则

迪米特法则又叫最少知道原则，即一个类对自己依赖的类知道的越少越好。

1.7 合成复用原则

原则是尽量使用合成/聚合的方式，而不是使用继承；

2 UML 基本介绍

类之间的关系：依赖、泛化（继承）、实现、关联、聚合与组合

2.1 依赖

只要是在类中用到了对方，那么他们之间就存在依赖关系。如果没有对方，连编译都通过不了; 比如一个A类里面，属性是B类

● 1）类中用到了对方
● 2）类的成员属性
● 3）方法的返回类型
● 4）方法接收的参数类型
● 5）方法中使用到

2.2 泛化

泛化关系实际上就是继承关系，它是依赖关系的特例

● 1）泛化关系实际上就是继承关系
● 2）如果 A 类继承了 B 类，我们就说 A 和 B 存在泛化关系

2.3 实现

就是实现接口，它是依赖关系的特例

2.4 关联

它是依赖关系的特例；

关联关系实际上就是类与类之间的联系； 单向一对一； 双向一对一；

2.5 聚合

一个整体可以分离出来单独使用

2.6 组合

不能分离出来单独使用，共生共灭