时间戳

首页 > 技术文章 > 设计模式(二)

设计模式(二)

wyzstudy 2021-11-01 10:06 原文

里氏替换原则

继承包含这样一层含义：父类中凡是已经实现好的方法，实际上是在设定规范和契约，虽然它不强制要求所有的子类必须遵循这些契约，但是如果子类对这些已经实现的方法任意修改，就会对整个继承体系造成破坏。继承在给程序设计带来便利的同时，也带来了弊端。比如使用继承会给程序带来侵入性，程序的可移植性降低，增加对象间的耦合性，如果一个类被其他的类所继承， 则当这个类需要修改时，必须考虑到所有的子类，并且父类修改后，所有涉及到子类的功能都有可能产生故障。问题提出：在编程中，如何正确的使用继承? => 里氏替换原则

基本介绍

  1. 里氏替换原则(Liskov Substitution Principle)在1988年，由麻省理工学院的以为姓里的女士提出的。
  2. 如果对每个类型为T1的对象o1，都有类型为T2的对象o2，使得以T1定义的所有程序P在所有的对象o1都代换成o2时，程序P的行为没有发生变化，那么类型T2是类型T1 的子类型。换句话说，所有引用基类的地方必须能透明地使用其子类的对象。
  3. 在使用继承时，遵循里氏替换原则，在子类中尽量不要重写父类的方法
  4. 里氏替换原则告诉我们，继承实际上让两个类耦合性增强了，在适当的情况下，可以通过聚合，组合，依赖来解决问题。
class A{
    public int fun1(int a,int b){
        return a-b;
    }
}
class B extends A{
   //类B无意重写方法B
    @Override
    public int fun1(int a, int b) {
        return a+b;
    }
    
    public int fun2(int a,int b){
        return fun1(a,b) + 9;
    }
}

//改进
class Base {}
class A extends Base{
    public int fun1(int a,int b){
        return a-b;
    }
}
class B extends Base{
    //通过聚合使用类A
    private A a = new A();
    public int fun1(int a,int b){
        return a+b;
    }
    
    public int fun2(int a,int b){
        return fun1(a,b)+9;
    }
    
    public int fun3(int a,int b){
        return this.a.fun1(a,b);
    }
}

开闭原则

基本介绍

  1. 开闭原则（Open Closed Principle）是编程中最基础、最重要的设计原则。
  2. 一个软件实体如类，模块和函数应该对扩展开放(对提供方)，对修改关闭(对使用方)。用抽象构建框架，用实现扩展细节。
  3. 当软件需要变化时，尽量通过扩展软件实体的行为来实现变化，而不是通过修改已有的代码来实现变化。
  4. 编程中遵循其它原则，以及使用设计模式的目的就是遵循开闭原则。
//图像基类
class Shape{
    int m_type;
}
class Rectangle extends Shape{
    public Rectangle() {
        super.m_type = 1;
    }
}
class Circle extends Shape{
    public Circle() {
        super.m_type = 2;
    }
}
//使用方
class GraphicEditor{
    public void drawShape(Shape shape){
        if(shape.m_type == 1){
            drawRectangle();
        }else if(shape.m_type == 2){
            drawCircle();
        }
    }

    public void drawRectangle(){
        System.out.println("绘制长方形");
    }
    public void drawCircle(){
        System.out.println("绘制圆形");
    }
}
//测试代码
GraphicEditor graphicEditor = new GraphicEditor();
graphicEditor.drawShape(new Rectangle());
graphicEditor.drawShape(new Circle());

当我们新增一个三角形绘制的时候，就需要修改使用方的代码，违背了开闭原则，我们对代码进行改进：

//图像基类
abstract class Shape{
    int m_type;
    public abstract void draw();
    
}
class Rectangle extends Shape{
    public Rectangle() {
        super.m_type = 1;
    }

    @Override
    public void draw() {
        System.out.println("绘制矩形");
    }
}
class Circle extends Shape{
    public Circle() {
        super.m_type = 2;
    }

    @Override
    public void draw() {
        System.out.println("绘制圆形");
    }
}
//新增
class Triangle extends Shape{
    public Triangle(){
        super.m_type = 3;
    }
    @Override
    public void draw() {
        System.out.println("绘制三角形");
    }
}
//使用方
class GraphicEditor{
    public void drawShape(Shape shape){
        shape.draw();
    }
}
//测试代码
GraphicEditor graphicEditor = new GraphicEditor();
graphicEditor.drawShape(new Rectangle());
graphicEditor.drawShape(new Circle());
graphicEditor.drawShape(new Triangle());

迪米特法则

基本介绍

  1. 一个对象应该对其他对象保持最少的了解
  2. 类与类关系越密切，耦合度越大
  3. 迪米特法则(Demeter Principle)又叫最少知道原则，即一个类对自己依赖的类知道的越少越好。也就是说，对于被依赖的类不管多么复杂，都尽量将逻辑封装在类的内部。对外除了提供的public 方法，不对外泄露任何信息
  4. 迪米特法则还有个更简单的定义：只与直接的朋友通信
  5. 直接的朋友：每个对象都会与其他对象有耦合关系，只要两个对象之间有耦合关系， 我们就说这两个对象之间是朋友关系。耦合的方式很多，依赖，关联，组合，聚合 等。其中，我们称出现成员变量，方法参数，方法返回值中的类为直接的朋友，而 出现在局部变量中的类不是直接的朋友。也就是说，陌生的类最好不要以局部变量的形式出现在类的内部。

代码演示

//学校总部员工类
class Employee{
    private String id;

    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }
}
//学院员工类
class CollegeEmployee{
    private String id;

    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }
}
//学院类
class CollegeManager {
    public List<CollegeEmployee> getAllEmployee() {
        List<CollegeEmployee> list = new ArrayList<CollegeEmployee>();
        for (int i = 0; i < 10; i++) {
            CollegeEmployee emp = new CollegeEmployee();
            emp.setId("学院员工id= " + i);
            list.add(emp);
        }
        return list;
    }
}
//学校总部类
class SchoolManager {
    public List<Employee> getAllEmployee() {
        List<Employee> list = new ArrayList<Employee>();

        for (int i = 0; i < 5; i++) {
            Employee emp = new Employee();
            emp.setId("学校总部员工id= " + i);
            list.add(emp);
        }
        return list;
    }

    public void printAllEmployee(CollegeManager sub) {
        List<CollegeEmployee> list1 = sub.getAllEmployee();
        System.out.println("------------分公司员工------------");
        for (CollegeEmployee e : list1) {
            System.out.println(e.getId());
        }
        List<Employee> list2 = this.getAllEmployee();
        System.out.println("------------学校总部员工------------");
        for (Employee e : list2) {
            System.out.println(e.getId());
        }
    }
}
//测试
SchoolManager schoolManager = new SchoolManager();
schoolManager.printAllEmployee(new CollegeManager());

存在问题，在SchoolManager类中，跟Employee,CollegeManager，CollegeEmployee类存在耦合关系，其中Employee，CollegeManager为直接朋友，CollegeEmployee为非直接朋友，违背迪米特法则。

//学院类
class CollegeManager {
    public List<CollegeEmployee> getAllEmployee() {
        List<CollegeEmployee> list = new ArrayList<CollegeEmployee>();
        for (int i = 0; i < 10; i++) {
            CollegeEmployee emp = new CollegeEmployee();
            emp.setId("学院员工id= " + i);
            list.add(emp);
        }
        return list;
    }
    //在学院管理类内部处理输出，对外提供接口，不必让外界知道输出的细节
    public void printAllEmployee(){
        List<CollegeEmployee> list = getAllEmployee();
        for(CollegeEmployee c : list){
            System.out.println(c.getId());
        }
    }
}
//学校总部类
class SchoolManager {
    public List<Employee> getAllEmployee() {
        List<Employee> list = new ArrayList<Employee>();

        for (int i = 0; i < 5; i++) {
            Employee emp = new Employee();
            emp.setId("学校总部员工id= " + i);
            list.add(emp);
        }
        return list;
    }

    public void printAllEmployee(CollegeManager sub) {
        sub.printAllEmployee();
        List<Employee> list2 = this.getAllEmployee();
        System.out.println("------------学校总部员工------------");
        for (Employee e : list2) {
            System.out.println(e.getId());
        }
    }
}

我们在学院管理类的内部提供输出学院员工类的方法，不在学校总部的输出方法中处理输出，对其依赖的类保持最少的了解。按照迪米特法则，应该避免类中出现这样非直接朋友关系的耦合。

注意事项和细节

  1. 迪米特法则的核心是降低类之间的耦合
  2. 但是注意：由于每个类都减少了不必要的依赖，因此迪米特法则只是要求降低类间(对象间)耦合关系， 并不是要求完全没有依赖关系

合成复用原则

基本介绍

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

设计原则核心思想

  1. 找出应用中可能需要变化之处，把它们独立出来，不要和那些不需要变化的代码混在一起。
  2. 针对接口编程，而不是针对实现编程。
  3. 为了交互对象之间的松耦合设计而努力

UML类图

UML基本介绍

  1. UML——Unified modeling language UML (统一建模语言)，是一种用于软件系统 分析和设计的语言工具，它用于帮助软 件开发人员进行思考和记录思路的结果
  2. UML本身是一套符号的规定，就像数学 符号和化学符号一样，这些符号用于描 述软件模型中的各个元素和他们之间的 关系，比如类、接口、实现、泛化、依 赖、组合、聚合等
  3. 使用UML来建模，常用的工具有 Rational Rose , 也可以使用一些插件来建模

UML图

画UML图与写文章差不多，都是把自己的思想描述给别人看，关键在于思路和条理， UML图分类：

  • 用例图(use case)
  • 静态结构图：类图、对象图、包图、组件图、部署图
  • 动态行为图：交互图（时序图与协作图）、状态图、活动图

UML类图

  1. 用于描述系统中的类(对象)本身的组成和类(对象)之间的各种静态关系。
  2. 类之间的关系：依赖、泛化（继承）、实现、关联、聚合与组合

依赖：只要是在类中用到了对方，那么他们之间就存在依赖关系。如果没有对方，连编绎都通过不了。

  • 类中用到了对方
  • 如果是类的成员属性
  • 如果是方法的返回类型
  • 是方法接收的参数类型
  • 方法中使用到

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

实现:实现关系实际上就是A类实现B接口，他是依赖关系的特例

关联:关联关系实际上就是类与类之间的联系，他是依赖关系的特例,关联具有导航性：即双向关系或单向关系,关系具有多重性：如“1”（表示有且仅有一个），“0...”（表示0个或者多个）， “0，1”（表示0个或者一个），“n...m”(表示n到 m个都可以),“m...*”（表示至少m 个）。

聚合:聚合关系（Aggregation）表示的是整体和部分的关系，整体与部分可以分开。聚 合关系是关联关系的特例，所以他具有关联的导航性与多重性。

组合：也是整体与部分的关系，但是整体与部分不可以分开。

推荐阅读