设计模式之六大设计原则

最新推荐文章于 2024-09-20 21:23:30 发布
最新推荐文章于 2024-09-20 21:23:30 发布
阅读量707 收藏
点赞数
分类专栏： 设计模式 文章标签： 设计模式 java 前端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_27331467/article/details/128647785
版权

设计模式之设计原则

文章目录

一、单一职责原则

单一职责原则(Single Responsibility Principle, SRP)：一个类只负责一个功能领域中的相应职责，或者可以定义为：就一个类而言，应该只有一个引起它变化的原因。

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

实例

package sjms.demo.设计原则.单一职责原则;

/**
 * Created by IntelliJ IDEA.
 * User: LvHaoIT (lvhao)
 * Date: 2023/1/11
 * Time: 18:36
 * 单一职责
 */
public class 单一职责 {

    public static void main(String[] args) {
        Vehicle vehicle = new Vehicle();
        vehicle.run("摩托车");
        vehicle.run("飞机");
        vehicle.run("轮船");

    }


}

/**
 * 这里的run方法违反了单一职责原则
 */
class Vehicle {
    public void run(String s) {
        System.out.println(s + "在公路上运行");
    }
}

改进

package sjms.demo.设计原则.单一职责原则.improve;

/**
 * Created by IntelliJ IDEA.
 * User: LvHaoIT (lvhao)
 * Date: 2023/1/11
 * Time: 18:36
 * 单一职责
 */
public class 单一职责改进 {

    public static void main(String[] args) {
        RoadVehicle roadVehicle = new RoadVehicle();
        roadVehicle.run("摩托车");
        AirVehicle airVehicle = new AirVehicle();
        airVehicle.run("飞机");
    }


}

/**
 * 这里的run方法违反了单一职责原则
 */
class RoadVehicle {
    public void run(String s) {
        System.out.println(s + "在公路上运行");
    }
}

class AirVehicle {
    public void run(String s) {
        System.out.println(s + "在天空上运行");
    }
}

二、接口隔离原则

客户端不应该依赖它不需要的接口，即一个类对另一个类的依赖应该建立在最小的接口上。
即有一个接口有 fun1，fun2，fun3，fun4，fun5 五个需要实现的方法，现在有类A要使用其中的1,2，3，如果直接实现这个接口将需要重写其中的五个方法，但是我只需要使用三个，所以这造成了冗余。

改进办法

将这一个接口拆分成三个接口，这样让A实现123的接口，让b实现145的接口

实例

package sjms.demo.设计原则.接口隔离原则;

/**
 * Created by IntelliJ IDEA.
 * User: LvHaoIT (lvhao)
 * Date: 2023/1/10
 * Time: 12:42
 */
public class 接口隔离 {


    public static void main(String[] args) {
        A a = new A();
        a.fun1(new C());
        a.fun2(new C());
        a.fun3(new C());


        B b = new B();
        b.fun1(new D());
        b.fun2(new D());
        b.fun3(new D());
    }


}

interface interface1 {
    void method1();
}

interface interface2 {
    void method2();

    void method3();
}

interface interface3 {
    void method4();

    void method5();
}


class C implements interface1, interface2 {

    @Override
    public void method1() {
        System.out.println("C 实现了 method1");
    }

    @Override
    public void method2() {
        System.out.println("C 实现了 method2");

    }

    @Override
    public void method3() {
        System.out.println("C 实现了 method3");

    }
}

class D implements interface1, interface3 {

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

    @Override
    public void method4() {
        System.out.println("D 实现了 method4");

    }

    @Override
    public void method5() {
        System.out.println("D 实现了 method5");

    }
}

class A {
    public void fun1(interface1 int2) {
        System.out.println("A 调用了 ->");
        int2.method1();
    }

    public void fun2(interface2 int2) {
        System.out.println("A 调用了 ->");
        int2.method2();
    }

    public void fun3(interface2 int2) {
        System.out.println("A 调用了 ->");
        int2.method3();
    }
}

class B {
    public void fun1(interface1 int2) {
        System.out.println("B 调用了 ->");
        int2.method1();
    }

    public void fun2(interface3 int2) {
        System.out.println("B 调用了 ->");
        int2.method4();
    }

    public void fun3(interface3 int2) {
        System.out.println("B 调用了 ->");
        int2.method5();
    }
}

三、依赖倒转

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

实例

package sjms.demo.设计原则.接口隔离原则;

/**
 * Created by IntelliJ IDEA.
 * User: LvHaoIT (lvhao)
 * Date: 2023/1/10
 * Time: 12:42
 */
public class 接口隔离 {


    public static void main(String[] args) {
        A a = new A();
        a.fun1(new C());
        a.fun2(new C());
        a.fun3(new C());


        B b = new B();
        b.fun1(new D());
        b.fun2(new D());
        b.fun3(new D());
    }


}

interface interface1 {
    void method1();
}

interface interface2 {
    void method2();

    void method3();
}

interface interface3 {
    void method4();

    void method5();
}


class C implements interface1, interface2 {

    @Override
    public void method1() {
        System.out.println("C 实现了 method1");
    }

    @Override
    public void method2() {
        System.out.println("C 实现了 method2");

    }

    @Override
    public void method3() {
        System.out.println("C 实现了 method3");

    }
}

class D implements interface1, interface3 {

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

    @Override
    public void method4() {
        System.out.println("D 实现了 method4");

    }

    @Override
    public void method5() {
        System.out.println("D 实现了 method5");

    }
}

class A {
    public void fun1(interface1 int2) {
        System.out.println("A 调用了 ->");
        int2.method1();
    }

    public void fun2(interface2 int2) {
        System.out.println("A 调用了 ->");
        int2.method2();
    }

    public void fun3(interface2 int2) {
        System.out.println("A 调用了 ->");
        int2.method3();
    }
}

class B {
    public void fun1(interface1 int2) {
        System.out.println("B 调用了 ->");
        int2.method1();
    }

    public void fun2(interface3 int2) {
        System.out.println("B 调用了 ->");
        int2.method4();
    }

    public void fun3(interface3 int2) {
        System.out.println("B 调用了 ->");
        int2.method5();
    }
}

依赖关系传递三种方式

package sjms.demo.设计原则.依赖倒转原则;

/**
 * Created by IntelliJ IDEA.
 * User: LvHaoIT (lvhao)
 * Date: 2023/1/10
 * Time: 23:15
 * 依赖关系传递三种方式 接口传递，构造方法传递 setter方式传递
 */
public class 依赖关系传递三种方式 {
    public static void main(String[] args) {
        // 1 通过接口传递实现依赖
//        OpenAndClose openAndClose = new OpenAndClose();
//        openAndClose.open(new ChangHongTv());

        // 2.构造方法传递
//        OpenAndClose openAndClose = new OpenAndClose(new ChangHongTv());
//        openAndClose.open();

        //3.setter方式传入
        OpenAndClose openAndClose = new OpenAndClose();
        openAndClose.setItv(new ChangHongTv());
        openAndClose.open();

    }


}

// 方式1 通过接口传递实现依赖
//开关的接口
//interface IOpenAndClose {
//    public void open(ITV itv);
//
//}
//
电视的接口
//interface ITV {
//    //操控方式
//    public void play();
//}

class ChangHongTv implements ITV {

    @Override
    public void play() {
        System.out.printf("中兴电视：" + "利用遥控器");
    }
}

开启关闭实现类
//class OpenAndClose implements IOpenAndClose {
//    @Override
//    public void open(ITV itv) {
//        itv.play();
//        System.out.println(" 打开了电视");
//    }
//}

方式二 构造方法传递
//
//interface IOpenAndClose {
//    public void open();
//
//}
//
电视的接口
//interface ITV {
//    //操控方式
//    public void play();
//}
//
开启关闭实现类
//class OpenAndClose implements IOpenAndClose {
//    private ITV itv;
//
//    OpenAndClose(ITV itv) {
//        this.itv = itv;
//
//    }
//
//    @Override
//    public void open() {
//        itv.play();
//        System.out.println(" 打开了电视");
//    }
//}


//方式三 setter方法传递

interface IOpenAndClose {
    public void open();

}

//电视的接口
interface ITV {
    //操控方式
    public void play();
}

//开启关闭实现类
class OpenAndClose implements IOpenAndClose {
    private ITV itv;

    public void setItv(ITV itv) {
        this.itv = itv;
    }

    @Override
    public void open() {
        itv.play();
        System.out.println(" 打开了电视");
    }
}

四、里氏替换原则

通俗来说：子类可以扩展父类的功能，但不能改变父类原有的功能。

  1. 子类可以实现父类的抽象方法，但不能覆盖父类的非抽象方法。
  2. 子类中可以增加自己特有的方法。
  3. 当子类的方法重载父类的方法时，方法的前置条件（方法的输入，入参）要比父类的入参更宽松。
  4. 当子类的方法实现父类的方法时（重写，重载，实现抽象方法），方法的后置条件（输出、返回值）要比父类更严格或相等。

概念扩展：一个软件实体如果适用一个父类的话，那么一定适用其子类，所有引用父类的地方必须能透明的使用其子类的对象，子类对象能够替换其父类对象，而程序的逻辑不变。

实例

package sjms.demo.设计原则.迪米特法则;

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

/**
 * Created by IntelliJ IDEA.
 * User: LvHaoIT (lvhao)
 * Date: 2023/1/11
 * Time: 19:21
 * 一个类应该对其他的对象保持最少的了解
 * 只与直接朋友通信  依赖 关联 组合 聚合
 */
public class 迪米特法则 {
    public static void main(String[] args) {
        //创建了一个 SchoolManager 对象
        SchoolManager schoolManager = new SchoolManager();
        //输出学院的员工 id 和 学校总部的员工信息
        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 emp = new CollegeEmployee();
            emp.setId("学院员工 id= " + i);
            list.add(emp);
        }
        return list;
    }
}

/*
    1. 分析 SchoolManager 类的直接朋友类有 Employee、CollegeManager
    2. CollegeEmployee 不是 直接朋友 而是一个陌生类，这样违背了 迪米特法则
 */
//学校管理类
class SchoolManager {
    //返回学校总部的员工
    public List<Employee> getAllEmployee() {
        List<Employee> list = new ArrayList<Employee>();
        //增加 5 个员工到 list
        for (int i = 0; i < 5; i++) {
            Employee emp = new Employee();
            emp.setId("学校总部员工 id= " + i);
            list.add(emp);
        }
        return list;
    }

    //该方法完成输出学校总部和学院员工信息(id)
    void printAllEmployee(CollegeManager sub) {
        /*
        问题分析：
            1. 这里的 CollegeEmployee 不是 SchoolManager 的直接朋友
            2. CollegeEmployee 是以局部变量方式出现在 SchoolManager
            3. 违反了 迪米特法则
         */

        //获取到学院员工
        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());
        }
    }
}

优化

package sjms.demo.设计原则.迪米特法则.improve;

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

/**
 * Created by IntelliJ IDEA.
 * User: LvHaoIT (lvhao)
 * Date: 2023/1/11
 * Time: 19:21
 * 一个类应该对其他的对象保持最少的了解
 * 只与直接朋友通信  依赖 关联 组合 聚合
 */
public class 迪米特法则优化 {
    public static void main(String[] args) {
        //创建了一个 SchoolManager 对象
        SchoolManager schoolManager = new SchoolManager();
        //输出学院的员工 id 和 学校总部的员工信息
        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 emp = new CollegeEmployee();
            emp.setId("学院员工 id= " + i);
            list.add(emp);
        }
        return list;
    }

    public void printfAllEmployee() {
        List<CollegeEmployee> list1 = this.getAllEmployee();
        System.out.println("------------学院员工------------");
        for (CollegeEmployee e : list1) {
            System.out.println(e.getId());
        }
    }
}

/*
    1. 分析 SchoolManager 类的直接朋友类有 Employee、CollegeManager
    2. CollegeEmployee 不是 直接朋友 而是一个陌生类，这样违背了 迪米特法则
 */
//学校管理类
class SchoolManager {
    //返回学校总部的员工
    public List<Employee> getAllEmployee() {
        List<Employee> list = new ArrayList<Employee>();
        //增加 5 个员工到 list
        for (int i = 0; i < 5; i++) {
            Employee emp = new Employee();
            emp.setId("学校总部员工 id= " + i);
            list.add(emp);
        }
        return list;
    }

    //该方法完成输出学校总部和学院员工信息(id)
    void printAllEmployee(CollegeManager sub) {
        /*
        问题分析：
            1. 这里的 CollegeEmployee 不是 SchoolManager 的直接朋友
            2. CollegeEmployee 是以局部变量方式出现在 SchoolManager
            3. 违反了 迪米特法则
         */

        //获取到学院员工
        sub.printfAllEmployee();

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

五、开闭原则

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

实例

package sjms.demo.设计原则.开闭原则;

/**
 * Created by IntelliJ IDEA.
 * User: LvHaoIT (lvhao)
 * Date: 2023/1/11
 * Time: 19:09
 * 开闭原则是编程中最基础、最重要的设计原则
 * 一个实体如类，模块和函数 应该对扩展开放（对提供方），对修改关闭（对使用方）
 * 当软件需要变化时，尽量通过扩展软件实体的行为来实现变化，而不是通过修改过已有的代码来实现变化
 */
public class 开闭原则 {

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


//这是一个用于绘图的类 [使用方]
class GraphicEditor {
    //接收 Shape 对象，然后根据 type，来绘制不同的图形
    public void drawShape(Shape s) {
        if (s.m_type == 1) {
            drawRectangle(s);
        } else if (s.m_type == 2) {
            drawCircle(s);
        } else if (s.m_type == 3) {
            drawTriangle(s);
        }
    }

    //绘制矩形
    public void drawRectangle(Shape r) {
        System.out.println(" 绘制矩形 ");
    }

    //绘制圆形
    public void drawCircle(Shape r) {
        System.out.println(" 绘制圆形 ");
    }

    //绘制三角形
    public void drawTriangle(Shape r) {
        System.out.println(" 绘制三角形 ");
    }
}

//Shape 类，基类
class Shape {
    int m_type;
}

class Rectangle extends Shape {
    Rectangle() {
        super.m_type = 1;
    }
}

class Circle extends Shape {
    Circle() {
        super.m_type = 2;
    }
}

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

优化

package sjms.demo.设计原则.开闭原则.improve;

/**
 * Created by IntelliJ IDEA.
 * User: LvHaoIT (lvhao)
 * Date: 2023/1/11
 * Time: 19:09
 * 开闭原则是编程中最基础、最重要的设计原则
 * 一个实体如类，模块和函数 应该对扩展开放（对提供方），对修改关闭（对使用方）
 * 当软件需要变化时，尽量通过扩展软件实体的行为来实现变化，而不是通过修改过已有的代码来实现变化
 */
public class 开闭原则优化 {

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


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

    //绘制矩形

}

//Shape 类，基类
abstract class Shape {
    int m_type;

    abstract void draw();
}

class Rectangle extends Shape {
    Rectangle() {
        super.m_type = 1;
    }

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

class Circle extends Shape {
    Circle() {
        super.m_type = 2;
    }

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

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

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

六、迪米特法则

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

实例

package sjms.demo.设计原则.迪米特法则;

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

/**
* Created by IntelliJ IDEA.
* User: LvHaoIT (lvhao)
* Date: 2023/1/11
* Time: 19:21
* 一个类应该对其他的对象保持最少的了解
* 只与直接朋友通信  依赖 关联 组合 聚合
*/
public class 迪米特法则 {
public static void main(String[] args) {
//创建了一个 SchoolManager 对象
SchoolManager schoolManager = new SchoolManager();
//输出学院的员工 id 和 学校总部的员工信息
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 emp = new CollegeEmployee();
emp.setId("学院员工 id= " + i);
list.add(emp);
}
return list;
}
}

/*
1. 分析 SchoolManager 类的直接朋友类有 Employee、CollegeManager
2. CollegeEmployee 不是 直接朋友 而是一个陌生类，这样违背了 迪米特法则
*/
//学校管理类
class SchoolManager {
//返回学校总部的员工
public List<Employee> getAllEmployee() {
List<Employee> list = new ArrayList<Employee>();
//增加 5 个员工到 list
for (int i = 0; i < 5; i++) {
Employee emp = new Employee();
emp.setId("学校总部员工 id= " + i);
list.add(emp);
}
return list;
}

//该方法完成输出学校总部和学院员工信息(id)
void printAllEmployee(CollegeManager sub) {
/*
问题分析：
1. 这里的 CollegeEmployee 不是 SchoolManager 的直接朋友
2. CollegeEmployee 是以局部变量方式出现在 SchoolManager
3. 违反了 迪米特法则
*/

//获取到学院员工
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());
}
}
}

改进

package sjms.demo.设计原则.迪米特法则.improve;

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

/**
 * Created by IntelliJ IDEA.
 * User: LvHaoIT (lvhao)
 * Date: 2023/1/11
 * Time: 19:21
 * 一个类应该对其他的对象保持最少的了解
 * 只与直接朋友通信  依赖 关联 组合 聚合
 */
public class 迪米特法则优化 {
  public static void main(String[] args) {
    //创建了一个 SchoolManager 对象
    SchoolManager schoolManager = new SchoolManager();
    //输出学院的员工 id 和 学校总部的员工信息
    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 emp = new CollegeEmployee();
      emp.setId("学院员工 id= " + i);
      list.add(emp);
    }
    return list;
  }

  public void printfAllEmployee() {
    List<CollegeEmployee> list1 = this.getAllEmployee();
    System.out.println("------------学院员工------------");
    for (CollegeEmployee e : list1) {
      System.out.println(e.getId());
    }
  }
}

/*
    1. 分析 SchoolManager 类的直接朋友类有 Employee、CollegeManager
    2. CollegeEmployee 不是 直接朋友 而是一个陌生类，这样违背了 迪米特法则
 */
//学校管理类
class SchoolManager {
  //返回学校总部的员工
  public List<Employee> getAllEmployee() {
    List<Employee> list = new ArrayList<Employee>();
    //增加 5 个员工到 list
    for (int i = 0; i < 5; i++) {
      Employee emp = new Employee();
      emp.setId("学校总部员工 id= " + i);
      list.add(emp);
    }
    return list;
  }

  //该方法完成输出学校总部和学院员工信息(id)
  void printAllEmployee(CollegeManager sub) {
    /*
        问题分析：
            1. 这里的 CollegeEmployee 不是 SchoolManager 的直接朋友
            2. CollegeEmployee 是以局部变量方式出现在 SchoolManager
            3. 违反了 迪米特法则
         */

    //获取到学院员工
    sub.printfAllEmployee();

    //获取到学校总部员工
    List<Employee> list2 = this.getAllEmployee();
    System.out.println("------------学校总部员工------------");
    for (Employee e : list2) {
      System.out.println(e.getId());
    }
  }
}
LvhaoIT
关注
专栏目录
Java设计模式六大原则
流楚丶格念的博客
10-16 1538
单一职责原则：一个类，应当只有一个引起它变化的原因；即一个类应该只有一个职责里氏替换原则：所有引用基类的地方必须能透明地使用其子类对象。依赖倒置原则：高层模块不应该依赖低层模块，两者都依赖其抽象；抽象不依赖细节；细节应该依赖于抽象。接口隔离原则：客户端不应该依赖它不需要的接口，类间的依赖关系应该建立在最小的接口上。迪米特法则：是一个对象应当对其他对象尽可能少的了解，如果两个类不必彼此直接通信，那么这两个类就不应当发生直接的相互作用；
Android设计模式之六大设计原则
xiaokang666的博客
10-22 915
Android设计模式之六大设计原则
JAVA设计模式之六大设计原则
程铭程铭你快成名的博客
10-16 4920
在程序设计中，我们通常要遵循以下六大原则： 单一职责原则 官方定义： 就一个类(接口、结构体、方法等等)而言，有且仅有一个引起它变化的原因。 个人理解： 通俗的来讲做一件事就是专注做一件事，不可以三心二意。任务对象只是专注于一项职责，不去承担太多的责任。当任务对象的职责发生变化时，不会对其他的对象产生影响。 遵循单一职责原的优点： 可以大大降低耦合度。 降低类的复杂度。 提高类的...
设计模式六大原则详解
eyes++的博客
01-26 3520
Single-Responsibilitiy Principle（SRP）：对一个类而言，应该仅有一个引起它变化的原因。如果存在多于一个动机去改变一个类，那么这个类就具有多于一个的职责，就应该把多余的职责分离出去，再去创建一些类来完成每一个职责。
java设计模式的六大原则
m0_71674867的博客
07-24 2469
其中，我们称出现成员变量，方法参数，方法返回值中的类为直接的朋友，而出现在局部变量中的类不是直接的朋友。依赖倒转原则是基于这样的设计理念相对于细节的多变性，抽象的东西要稳定的多。用抽象构建框架，用实现扩展细节。里氏替换原则告诉我们，继承实际上让两个类耦合性增强了，在适当的情况下，可以通过聚合，组合，依赖来解决问题。使用接口或抽象类的目的是制定好规范，而不涉及任何具体的操作，把展现细节的任务交给他们的实现类去完成。客户端不应该依赖它不需要的接口，即一个类对另一个类的依赖应该建立在最小的接口上。...
设计模式六大原则
西京刀客
05-13 1万+
文章目录软件设计的六大原则1. 开放-封闭原则2. 单一职责原则举例3. 里氏替换原则4. 依赖倒置原则举例5. 接口隔离原则6. 迪米特原则举例 软件设计的六大原则 设计模式的六大原则 参考URL: https://zhuanlan.zhihu.com/p/92152190 1. 开放-封闭原则 Open-Close Principle（OCP）：一个软件实体如类、模块和函数应该对扩展开放，对修改关闭。目的就是保证程序的扩展性好，易于维护和升级。 对于扩展是开放的，对于更改是封闭的。 开放-封闭原则是面向
设计模式 - 六大设计原则之LSP（里氏替换）
热门推荐
小工匠
01-23 2万+
里氏替换原则（Liskov Substitution Principle , LSP） 由麻省理工学院计算机科学西教授 Barbara Liskov 于1987年提出， 她提出：继承必须确保超类所拥有的性质在子类中仍然成立。
设计模式与六大原则
kayyoo的博客
11-11 1286
设计模式6大原则
设计模式（一）——六大原则
m0_47743175的博客
11-28 3106
设计模式六大原则
设计模式之六大原则详解，Markdown笔记
11-18
详细介绍了设计模式六大原则，配有示例代码和图片，有开闭原则，单一职责原则，里氏替换原则，依赖倒置原则，接口隔离原则，迪米特法则等等。
面向对象程序设计
m0_38066007的博客
09-17 233
11。
C++设计模式
叫好与叫座虽然不是对立面，但想在同一个作品中达到双重效果很难。
09-15 1879
Abstract Factory 抽象工厂模式：提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。Adapter适配器模式：将一个类的接口转换成客户希望的另外一个接口。Adapter模式使得原本由于接口不兼容而不能一起工作的那些类可以一起工 作。Bridge桥接模式：将抽象部分与它的实现部分分离，使它们都可以独立地变 化。Builder建造者模式：将一个复杂对象的构建与它的表示分离，使得同样的构建 过程可以创建不同的表示。
设计模式--外观模式
最新发布
m0_62965917的博客
09-20 513
外观模式是一种有效的结构型设计模式，通过提供一个简单的接口来隐藏复杂的子系统。它简化了客户端的使用，提高了系统的可维护性和可扩展性。尽管可能会导致某些功能被隐藏，但在大多数情况下，外观模式为系统的使用提供了便利和清晰的界面。
vue MVC设计模式与MVVM设计模式
小白小白从不日别的博客
09-17 790
于是2009年Angular.js横空出世，带来了全新的MVVM设计模式，让开发者眼前一亮，除了M和V层以外，就是这个VM层啦，即：viewModel层。使用Vue框架开发前端项目，最大的优势就是再也不用进行复杂的DOM操作了，我们只要关心数据的变化即可，Vue框架会帮我们把复杂的DOM进行渲染，这背后都要归功于他的设计思想，即MVVM设计模式。随着Ajax技术的流行，前后端分离开发越来越流行，前端需要处理复杂的视图与数据，迫使前端也急需一种设计模式来进行分层处理，所以MVC设计模式开始进入前端领域。
【spring】spring框架中使用的设计模式有哪些，经典的设计模式应用，spring框架中哪些地方使用了哪些优秀的设计模式
xzb5566的专栏
09-15 975
Spring框架在设计和实现过程中，广泛使用了多种设计模式以增强其灵活性、可扩展性和易用性。此外，Spring框架还使用了其他设计模式，如组合模式、构建者模式等，这些设计模式的运用使得Spring框架更加灵活、可扩展和易于使用。【spring】spring框架中使用的设计模式有哪些，经典的设计模式应用，spring框架中哪些地方使用了哪些优秀的设计模式。
分布式系统的概念与设计模式
weixin_46619605的博客
09-20 979
分布式系统的概念与设计模式
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

LvhaoIT

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值