设计模式之六大设计原则

阿里云国内75折 回扣 微信号：monov8
阿里云国际，腾讯云国际，低至75折。AWS 93折 免费开户实名账号 代冲值 优惠多多 微信号：monov8 飞机：@monov6

设计模式之设计原则

文章目录

一、单一职责原则

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

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

实例

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 + "在天空上运行");
    }
}

二、接口隔离原则

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

改进办法

将这一个接口拆分成三个接口这样让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());
    }
  }
}
阿里云国内75折 回扣 微信号：monov8
阿里云国际，腾讯云国际，低至75折。AWS 93折 免费开户实名账号 代冲值 优惠多多 微信号：monov8 飞机：@monov6
返回列表

上一篇：为什么流媒体直播的延迟很高

下一篇：【洛谷】P2345 [USACO04OPEN] MooFest G

“设计模式之六大设计原则” 的相关文章

【深度学习】常用PyTorch CUDA版本whl下载及在线安装命令1年前 (2023-02-02)
《安富莱嵌入式周报》第299期：IAR发布嵌入式软开发基础问题PDF，树莓派单片机运行Verilog，纯汇编实现的游戏, 电磁辐射频谱图, 乐鑫ESP32-P41年前 (2023-02-02)
【Linux】Linux命令行git的使用1年前 (2023-02-02)
System1年前 (2023-02-02)
web自动化测试入门篇03——selenium使用教程1年前 (2023-02-02)
学习黑客十余年，如何成为一名安全工程师？1年前 (2023-02-02)
最新版 Proteus 8.15 Professional 图文安装教程 [ 附安装包 ]1年前 (2023-02-02)
万字详解，吃透 MongoDB！1年前 (2023-02-02)
【计算几何】向量叉积和凸包 | 引射线法 | 判断点是否在多边形内部 | 葛立恒扫描法 | Cross Product and Convex Hul1年前 (2023-02-02)
12.ThreadLocal的那点小秘密1年前 (2023-02-02)

阿里云国际版