设计模式的七大原则

文章目录

  • 使用设计模式的目的
  • 设计模式要哪些原则?
    • 单一职责原则
      • 基本介绍
      • 单一职责原则需要注意的事项和细节
      • 举例
    • 接口隔离原则
      • 基本介绍
    • 依赖倒置原则
      • 基本介绍
      • 依赖倒置原则的主意事项和细节
      • 举例
    • 里氏替换原则
      • 基本介绍
      • 解决方法
      • 举例
    • 开闭原则
      • 基本介绍
      • 优点
      • 举例
    • 迪米特法则
      • 基本介绍
      • 迪米特法则注意事项和细节
      • 举例
    • 合成复用原则
      • 基本介绍
      • 设计原则核心思想

使用设计模式的目的

在编写软件过程中,程序员面临着来自 耦合性内聚性 以及 可维护性可扩展性重用性灵活性 等多方面的挑战,设计模式是为了让 程序(软件) 具有更好的:

  • 代码重用性(说明:相同功能的代码,不用多次编写)
  • 可读性(说明:编程的规范性,便于其他程序员的阅读和理解)
  • 可扩展性(说明:当需要增加新的功能时,非常的方便,称为可维护)
  • 可靠性 (说明:当我们增加新的功能后,对原来的功能没有影响)
  • 使程序呈现 高内聚低耦合 的特性

设计模式包含了面向对象的精髓,“懂得了设计模式,你就懂得了面向对象分析和设计(OOA/D)的精要”

设计模式要哪些原则?

设计模式原则,其实就是程序员在编程时,应当遵守的原则,也是各种设计模式的基础(即:设计模式为什么这样设计的依据)

设计模式常用的七大原则有:

  • 单一职责原则
  • 接口隔离原则
  • 依赖倒置原则
  • 里氏替换原则
  • 开闭原则
  • 迪米特法则
  • 合成复用原则

单一职责原则

基本介绍

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

单一职责原则需要注意的事项和细节

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

举例

package com.java.springtest.desginpattern;
/**
 * 单一职责原则
 */
public class SinglePattern {
    public static void main(String[] args) {
        Vehicle vehicle = new Vehicle();
        vehicle.runRoad("摩托车");
        vehicle.runAir("飞机");
        vehicle.runWater("轮船");
    }
}

// 交通工具类
class Vehicle {
    public void runRoad(String vehicle) {
        System.out.println(vehicle + " 在公路上运行");
    }

    public void runAir(String vehicle) {
        System.out.println(vehicle + " 在空中飞行");
    }

    public void runWater(String vehicle) {
        System.out.println(vehicle + " 在水中运行");
    }
}

输出:
在这里插入图片描述

接口隔离原则

基本介绍

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

设计模式的七大原则_第1张图片
从图中分析:

  • 类 A 通过接口 Interface1 依赖类B,类C 通过接口 Interface1 依赖类D,如果接口 Interface1 对于类A 和 类 C来说不是最小的接口,那么类B 和 类 D 必须去实现他们不需要的方法
  • 按隔离原则应该是这样的:将接口 Interface1 拆分为几个独立的接口,类 A 和 类 C 分别于他们需要的接口建立依赖关系。也就是采用接口隔离原则
package com.java.springtest.desginpattern;

/**
 * 接口隔离原则
 */
public class Segregation {
    public static void main(String[] args) {
        A a = new A();
        a.depend1(new B()); // A 类通过接口去依赖 B类
        a.depend2(new B());
        a.depend3(new B());

        C c = new C();
        c.depend1(new D());
        c.depend4(new D());
        c.depend5(new D()); // A 类通过接口去依赖 B类
    }
}

/**
 * 定义一个 Interface1 接口,并定义以下方法
 */
interface Interface1 {
    void operation1();
}

/**
 * 定义一个 Interface2 接口,并定义以下方法
 */
interface Interface2 {
    void operation2();
    void operation3();
}

/**
 * 定义一个 Interface3 接口,并定义以下方法
 */
interface Interface3 {
    void operation4();
    void operation5();
}

/**
 * 实现 Interface1 中的所有方法
 */
class B implements Interface1,Interface2 {
    @Override
    public void operation1() {
        System.out.println("B 中实现了 Opera1");
    }

    @Override
    public void operation2() {
        System.out.println("B 中实现了 Opera2");
    }

    @Override
    public void operation3() {
        System.out.println("B 中实现了 Opera3");
    }
}

/**
 * 实现 Interface1 中的所有方法
 */
class D implements Interface1,Interface3 {
    @Override
    public void operation1() {
        System.out.println("D 中实现了 Opera1");
    }

    @Override
    public void operation4() {
        System.out.println("D 中实现了 Opera4");
    }

    @Override
    public void operation5() {
        System.out.println("D 中实现了 Opera5");
    }
}

/**
 * A 类通过接口 Interface1,2 依赖(使用)B类,但是只会使用到接口中的 1,2,3 方法
 */
class A {
    public void depend1(Interface1 interface1) {
        interface1.operation1();
    }
    public void depend2(Interface2 interface1) {
        interface1.operation2();
    }
    public void depend3(Interface2 interface1) {
        interface1.operation3();
    }
}

/**
 * A 类通过接口 Interface1 依赖(使用)D类,但是只会使用到接口中的 1,4,5 方法
 */
class C {
    public void depend1(Interface1 interface1) {
        interface1.operation1();
    }
    public void depend4(Interface3 interface1) {
        interface1.operation4();
    }
    public void depend5(Interface3 interface1) {
        interface1.operation5();
    }
}

设计模式的七大原则_第2张图片

依赖倒置原则

基本介绍

依赖倒置原则是指:

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

依赖倒置原则的主意事项和细节

  • 低层模块尽量都要有抽象类或接口,或者两者都有,程序稳定性更好
  • 变量的声明类型尽量是抽象类或接口,这样我们的变量引用和实际对象间,就存在一个缓冲层,便利于程序扩展和优化
  • 继承时应该遵循里氏替换原则(下面会讲到)

举例

package com.java.springtest.desginpattern;

public class DependencyInversion {
    public static void main(String[] args) {
        Person person = new Person();
        person.receive(new Email());
        person.receive(new WeChat());
    }
}

/**
 * 定义一个接口
 */
interface IReceiver {
    String getInfo();
}

class Email implements IReceiver {
    public String getInfo() {
        return "电子邮件信息:Hello Email";
    }
}

class WeChat implements IReceiver {
    @Override
    public String getInfo() {
        return "微信消息:Hello WeChat";
    }
}

/**
 * 完成 Person 接收消息的功能
 */
class Person {
    // 这里是对解接口的依赖
    public void receive(IReceiver iReceiver) {
        System.out.println(iReceiver.getInfo());;
    }
}

输出:
在这里插入图片描述

里氏替换原则

OO 中继承性的思考和说明

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

基本介绍

  • 里氏替换原则在 1988 年,由麻省理工学院的以为姓里氏的女士提出的
  • 如果对每个类型为 T1 的对象 o1 ,都有类型为 T2 的对象 o2 ,使得以 T1 定义的所有程序 P 在所有的对象 o1 都替换成 o2 时,程序 P 的行为没有发生变化,那么类型 T2 是类型 T1 的子类型。换句话说所有的引用基类的地方必须能透明地使用其子类的对象
  • 在使用继承时,遵循里氏替换原则,在子类中 尽量 不要重写父类的方法
  • 里氏替换原则告诉我们,继承实际上是让两个类耦合性增强了,在适当的情况下,可以通过聚合,组合,依赖来解决问题

解决方法

  • 通用的做法是:原来的父类和子类都继承一个更通俗的基类,原有的继承关系去掉,采用依赖,聚合,组合等关系代替

举例

package com.java.springtest.desginpattern;

public class Liskov {
    public static void main(String[] args) {
        A1 a1 = new A1();
        System.out.println("11-3=" + a1.func1(11,3));
        System.out.println("1-8=" + a1.func1(1,8));
        System.out.println("---------------------------");
        B1 b1 = new B1();
        // 因为 B1 类不再继承 A1 类,因此调用者不会再认为func1是求减法了
        System.out.println("11+3=" + b1.func1(11,3));
        System.out.println("1+8=" + b1.func1(1,8));
        System.out.println("11+3+9=" + b1.func2(11,3));
        
        // 使用组合任然可以使用到 A1 的相关方法
        System.out.println("11-3=" + b1.func3(11,3));
    }
}

// 创建一个更加基础的基类
class Base {
    // 把更加基础的方法和成员写到 Base 类
}

// A1 类
class A1 extends Base{
    public int func1(int num1, int num2) {
        return num1 - num2;
    }
}

// B 类
// 增加了一个新的功能:完成两个数的相加,然后求和
class B1 extends Base {

    private A1 a = new A1();

    public int func1(int a, int b) {
        return a + b;
    }
    public int func2(int a, int b) {
        return func1(a,b) + 9;
    }

    public int func3(int a, int b) {
        return this.a.func1(a,b);
    }
}

设计模式的七大原则_第3张图片

开闭原则

基本介绍

  • 开闭原则是编程汇中最基础。最重要的设计原则
  • 一个软件实体,如类、模块和函数应该对扩展开放(对提供方),对修改关闭(对使用方)。用抽象构建框架,用实现扩展细节
  • 当软件需要变化时,尽量 通过扩展 软件实体的行为来实现变化,而 不是通过修改 已有的代码来实现变化
  • 编程中遵循其它原则,以及使用设计模式的目的就是遵循 开闭原则

优点

  • 优点是比较好的理解,简单易操作
  • 缺点是违反了设计模式的 OPC 原则,即 对扩展开放(提供方),对修改关闭(使用方)。即当我们给类增加新的功能的时候,尽量不要修改代码,或者尽可能少修改代码
  • 比如我们这时要新增一个图形种类,我们需要做修改的地方较多

举例

package com.java.springtest.desginpattern;

public class Ocp {
    public static void main(String[] args) {
        GraphicEditor graphicEditor = new GraphicEditor();
        graphicEditor.drawShape(new Rectangle());
        graphicEditor.drawShape(new Circle());
        graphicEditor.drawShape(new Triangle());
        graphicEditor.drawShape(new OtherGraphic());
    }
}

// Shape 是一个基类
abstract class Shape {
    int m_type;
    public abstract void draw(); // 抽象方法
}

// 新增矩形类
class Rectangle extends Shape {
    Rectangle() {
        super.m_type = 1;
    }

    @Override
    public void draw() {
        System.out.println("绘制矩形");
    }
}

// 新增圆形类
class Circle extends Shape {
    Circle() {
        super.m_type = 2;
    }

    @Override
    public void draw() {
        System.out.println("绘制圆形");
    }
}

// 新增三角形类
class Triangle extends Shape {
    Triangle() {
        super.m_type = 3;
    }

    @Override
    public void draw() {
        System.out.println("绘制三角形");
    }
}

class OtherGraphic extends Shape {

    OtherGraphic() {
        super.m_type = 4;
    }

    @Override
    public void draw() {
        System.out.println("绘制其他图形");
    }
}

// 这是一个用于绘图的类【使用方】
class GraphicEditor {
    // 接收Shape对象,然后根据type来绘制不同的矩形
    public void drawShape(Shape shape) {
        shape.draw();
    }
}

设计模式的七大原则_第4张图片

迪米特法则

基本介绍

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

迪米特法则注意事项和细节

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

举例

package com.java.springtest.desginpattern;

import java.util.ArrayList;
import java.util.List;

// 客户端
public class Demeter {
    public static void main(String[] args) {
        // 创建一个学校管理类
        SchoolManager schoolManager = new SchoolManager();
        // 调用打印方法
        schoolManager.printAllEmployee(new CollegeManager());
    }
}

// 学校总部员工
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<>();
        // 这里增加了 10 个员工到 list 集合中
        for (int i = 0; i < 10; i++) {
            CollegeEmployee collegeEmployee = new CollegeEmployee();
            collegeEmployee.setId("学院员工 id = " + i);
            list.add(collegeEmployee);
        }
        return list;
    }

    // 输出员工信息
    public void printEmployee() {
        // 获取到学院员工
        List<CollegeEmployee> allEmployee = getAllEmployee();
        System.out.println("---------------分公司员工----------------");
        for (CollegeEmployee collegeEmployee : allEmployee) {
            System.out.println(collegeEmployee.getId());
        }
    }
}

class SchoolManager {
    // 返回学校总部的员工
    public List<Employee> getAllEmployee() {
        List<Employee> list = new ArrayList<>();
        // 这里增加 5 个员工到 list 集合中
        for (int i = 0; i < 5; i++) {
            Employee employee = new Employee();
            employee.setId("学校总部员工 id = " + i);
            list.add(employee);
        }
        return list;
    }

    // 该方法完成输出学校总部和学院员工的信息
    void printAllEmployee(CollegeManager collegeManager) {

        collegeManager.printEmployee();

        // 获取到学校总部员工
        List<Employee> allEmployee1 = this.getAllEmployee();
        System.out.println("----------------学校总部员工--------------");
        for (Employee employee : allEmployee1) {
            System.out.println(employee.getId());
        }
    }
}

输出:
设计模式的七大原则_第5张图片

合成复用原则

基本介绍

合成复用原则的意思是尽量使用合成/聚合的方式,而不是使用继承
设计模式的七大原则_第6张图片

设计原则核心思想

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

你可能感兴趣的:(#,设计模式)