图解Java设计模式之设计模式七大原则

图解Java设计模式之设计模式七大原则

• 2.1 设计模式的目的
• 2.2 设计模式七大原则
• 2.3 单一职责原则
• 2.3.1 基本介绍
• 2.3.2 应用实例
• 2.4 接口隔离原则（Interface Segregation Principle）
• 2.4.1 基本介绍
• 2.4.2 应用实例
• 2.5 依赖倒转原则
• 2.5.1 基本介绍
• 2.5.2 应用实例
• 2.6 里氏替换原则
• 2.6.1 OO中的继承性的思考和说明
• 2.6.2 基本介绍
• 2.6.3 一个程序引出的问题和思考
• 2.6.4 解决方法
• 2.7 开闭原则
• 2.7.1 基本介绍
• 2.7.2 看下面一段代码
• 2.7.3 方式1的优缺点
• 2.7.4 改进的思路分析
• 2.8 迪米特法则
• 2.8.1 基本介绍
• 2.8.2 应用实例
• 2.8.3 应用实例改进
• 2.8.4 迪米特法则注意事项和细节
• 2.9 合成复用原则（Composite Reuse Principle）
• 设计原则核心思想

 

2.1 设计模式的目的

编写软件过程当中，程序员面临着来自耦合性，内聚性以及可维护性，可扩展性，重用性，灵活性等多方面的挑战，设计模式是为了让程序（软件）。具备更好
1）代码重用性（即：相同功能的代码，不用屡次编写）
2）可读性（即：编程规范性，便于其余程序员的阅读和理解）
3）可扩展性（即：当须要增长新的功能时，很是的方便，称为可维护）
4）可靠性（即：当咱们增长新的功能后，对原来的功能没有影响）
5）使程序呈现高内聚，低耦合的特性
6）设计模式包含了面向对象的精髓，“懂了设计模式，你就懂了面向对象分析和设计（OOA/D）的精要“
7）Scott Mayers 在其巨著《Effective C++》就曾经说过 ：C++老手和C++新手的区别就是前者手背上有不少伤疤

2.2 设计模式七大原则

设计模式原则，其实就是程序员在编程时，应当遵照的原则，也是各类设计模式的基础（即：设计模式为何这样设计的依据）
设计模式经常使用的七大原则有 ：
1）单一职责原则
2）接口隔离原则
3）依赖倒转（倒置）原则
4）里氏替换原则
5）开闭原则
6）迪米特法则
7）合成复用原则

2.3 单一职责原则

2.3.1 基本介绍

对类来讲的，即一个类应该只负责一项职责。如类A负责两个不一样职责 ：职责1，职责2。当职责1需求变动而改变A时，可能形成职责2执行错误，因此须要将类A的粒度分解为A1，A2

2.3.2 应用实例

以交通工具案例讲解

package com.example.testdemo.mode.principle; public class SingleResponsibility1 { public static void main(String[] args) { Vehicle vehicle = new Vehicle(); vehicle.run("摩托车"); vehicle.run("汽车"); vehicle.run("飞机"); } } // 交通工具类 /** * 方式1 ： * 1 。 在方式1的run方法中，违反了单一职责原则 * 2 。 解决的方案很是第二季简单，根据交通工具运行方法不一样，分解成不一样类便可 */ class Vehicle { public void run(String vehicle) { System.out.println(vehicle + " 在公路上运行。。。。。"); } } package com.example.testdemo.mode.principle; public class SingleResponsibility2 { public static void main(String[] args) { ReadVehicle readVehicle = new ReadVehicle(); readVehicle.run("摩托车"); readVehicle.run("汽车"); AirVehicle airVehicle = new AirVehicle(); airVehicle.run("飞机"); WaterVehicle waterVehicle = new WaterVehicle(); waterVehicle.run("轮船"); } } /** * 方案2分析 ： * 1 ：遵照单一职责原则 * 2 ：可是这样改动大，即将类分解，同时修改客户端 * 3 ：改进 ：直接修改Vehicle类，改动的代码会比较少 =》方案3 * */ class ReadVehicle { public void run(String vehicle) { System.out.println(vehicle + "公路运行"); } } class AirVehicle { public void run(String vehicle) { System.out.println(vehicle + "天空运行"); } } class WaterVehicle { public void run(String vehicle) { System.out.println(vehicle + "水中运行"); } } package com.example.testdemo.mode.principle; public class SingleResponsibility3 { public static void main(String[] args) { Vehicle2 vehicle2 = new Vehicle2(); vehicle2.run("汽车"); vehicle2.runAir("飞机"); vehicle2.runWater("轮船"); } } /** * 方案3的分析 ： * 1 ：这种修改方法没有对原来的类作大的修改，只是增长方法 * 2 ：这里虽然没有在类这个级别上遵照单一职责原则，可是在方法级别上，仍然是遵照单一职责 */ class Vehicle2 { public void run(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） 下降类的复杂度，一个类只负责一项职责。
（2）提升类的可读性，可维护性。
（3）下降变动引发的风险。
（4）一般状况下，咱们应当遵照单一职责原则，只有逻辑足够简单，才能够在代码级违反单一职责原则 ：只有类中方法数量足够少，能够在方法级别保存单一职责原则。

2.4 接口隔离原则（Interface Segregation Principle）

2.4.1 基本介绍

（1）客户端不该该依赖它不须要的接口，即一个类对另外一个类的依赖应该创建在最小的接口上
（2）先看一张图

（3）类A经过接口Interface1依赖类B，类C经过接口Interface1依赖类D，若是接口Interface1对于类A和类C来讲不是最小接口，那么类B和类C必须去实现他们不须要的方法。
（4）按隔离原则应当这样处理 ：
将接口Interface1拆分为独立的几个接口（这里咱们拆分3个接口），类A和类C分别与他们须要的接口创建依赖关系，也就是采用接口隔离原则

2.4.2 应用实例

1）类A经过接口Interface1依赖类B，类C经过接口Interface1依赖类D。
2）没有使用接口隔离原则的代码

package com.example.testdemo.mode.principle.segregation; import io.swagger.models.auth.In; public class Segregation1 { public static void main(String[] args) { } } /** * 接口 */ interface Interface1 { void operation1(); void operation2(); void operation3(); void operation4(); void operation5(); } class B implements Interface1 { @Override public void operation1() { System.out.println(" B 实现了 operation1"); } @Override public void operation2() { System.out.println(" B 实现了 operation2"); } @Override public void operation3() { System.out.println(" B 实现了 operation3"); } @Override public void operation4() { System.out.println(" B 实现了 operation4"); } @Override public void operation5() { System.out.println(" B 实现了 operation5"); } } class D implements Interface1 { @Override public void operation1() { System.out.println(" D 实现了 operation1"); } @Override public void operation2() { System.out.println(" D 实现了 operation2"); } @Override public void operation3() { System.out.println(" D 实现了 operation3"); } @Override public void operation4() { System.out.println(" D 实现了 operation4"); } @Override public void operation5() { System.out.println(" D 实现了 operation5"); } } /** * A 类经过接口Interface1 依赖（使用）B类，可是只会用到1，2，3方法 */ class A { public void depend1(Interface1 interface1) { interface1.operation1(); } public void depend2(Interface1 interface1) { interface1.operation2(); } public void depend3(Interface1 interface1) { interface1.operation3(); } } /** * C 类经过接口Interface1 依赖（使用）D类，可是只会用到1，4，5方法 */ class C { public void depend1(Interface1 interface1) { interface1.operation1(); } public void depend4(Interface1 interface1) { interface1.operation4(); } public void depend5(Interface1 interface1) { interface1.operation5(); } } 

• 应传统方法的问题和接口隔离原则改进
  （1）类A经过Interface1依赖类B，类C经过接口Interface1依赖类D，若是接口Interface1对于类A和类C来讲不是最小接口，那么类B和类C必须去实现他们不须要的方法。
  （2）将接口Interface1拆分为独立的几个接口，类A和类C分别与他们须要的接口创建依赖关系。也就是采用接口隔离原则。
  （3）接口Interface1中出现的方法，根据实际状况拆分为三个接口
  （4）代码实现
  

package com.example.testdemo.mode.principle.segregation1; public class Segregation2 { public static void main(String[] args) { // 使用一把 A a = new A(); // A 类经过接口去依赖B类 a.depend1(new B()); a.depend2(new B()); a.depend3(new B()); // C 类经过接口去依赖（使用）D类 C c = new C(); c.depend1(new D()); c.depend4(new D()); c.depend5(new D()); } } /** * 接口 */ interface Interface1 { void operation1(); } interface Interface2 { void operation2(); void operation3(); } interface Interface3 { void operation4(); void operation5(); } class B implements Interface1, Interface2 { @Override public void operation1() { System.out.println(" B 实现了 operation1"); } @Override public void operation2() { System.out.println(" B 实现了 operation2"); } @Override public void operation3() { System.out.println(" B 实现了 operation3"); } } class D implements Interface1, Interface3 { @Override public void operation1() { System.out.println(" D 实现了 operation1"); } @Override public void operation4() { System.out.println(" D 实现了 operation4"); } @Override public void operation5() { System.out.println(" D 实现了 operation5"); } } /** * A 类经过接口Interface1 ，Interface2 依赖（使用）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(); } } /** * C 类经过接口Interface1 ，Interface3 依赖（使用）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.5 依赖倒转原则

2.5.1 基本介绍

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

2.5.2 应用实例

1）方案1 + 分析说明

package com.example.testdemo.mode.principle.inversion; public class DependecyInversion { public static void main(String[] args) { Person person = new Person(); person.receive(new Email()); } } class Email { public String getInfo() { return "电子邮件信息 ：hello，world"; } } /** * 完成Person接收消息的功能 * 方式1分析 * 1。简单，比较容易想到 * 2。若是咱们获取的对象是微信，短信等等，则新增类，同时Persons也要增长相应的接收方法 * 3。解决思路 ：引入一个抽象的接口IReceiver，表示接收者，这样Person类与接口IReceiver发生依赖 * 由于Email，微信等等属于接收的范围，他们各自实现IReceiver接口就ok，这样咱们就符合依赖倒转原则 */ class Person { public void receive(Email email) { System.out.println(email.getInfo()); } } 

2）方案2（依赖倒转）+ 分析说明

package com.example.testdemo.mode.principle.inversion.inprove; public class DependecyInversion { public static void main(String[] args) { // 客户端无需改变 Person person = new Person(); person.receive(new Email()); person.receive(new WeiXin()); } } /** * 定义接口 */ interface IReceiver { String getInfo(); } class Email implements IReceiver{ @Override public String getInfo() { return "电子邮件信息 ：hello，world"; } } /** * 增长微信 */ class WeiXin implements IReceiver { @Override public String getInfo() { return "微信消息 ：hello ok"; } } /** * 方式2 */ class Person { /** * 这里是咱们对接口的依赖 * @param iReceiver */ public void receive(IReceiver iReceiver) { System.out.println(iReceiver.getInfo()); } } 

依赖关系传递的三种方式 ：
1）接口传递
2）构造方法传递
3）setter方法传递

package com.example.testdemo.mode.principle.inversion.inprove; public class Dependecy { public static void main(String[] args) { IOpenAndClose iOpenAndClose = new OpenAndClose(); iOpenAndClose.open(new ChangHong()); IOpenAndClose2 iOpenAndClose2 = new OpenAndClose2(new XiaoMi()); iOpenAndClose2.open(); IOpenAndClose3 iOpenAndClose3 = new OpenAndClose3(); iOpenAndClose3.setTv(new SanXing()); iOpenAndClose3.open(); } } /** * 方式1 ：经过接口传递实现依赖 */ interface IOpenAndClose { /** * 抽象方法，接收接口 * @param tv */ void open(ITV tv); } /** * ITV接口 */ interface ITV { void play(); } class ChangHong implements ITV { @Override public void play() { System.out.println("长虹电视机打开"); } } /** * 实现接口 */ class OpenAndClose implements IOpenAndClose { @Override public void open(ITV tv) { tv.play(); } } /** * 方式2 ：经过构造方法依赖传递 */ interface IOpenAndClose2 { /** * 抽象方法 */ void open(); } /** * ITV接口 */ interface ITV2 { void play(); } class XiaoMi implements ITV2 { @Override public void play() { System.out.println("小米电视机打开"); } } class OpenAndClose2 implements IOpenAndClose2 { /** * 成员属性 */ public ITV2 tv; /** * 构造方法 * @param itv2 */ public OpenAndClose2(ITV2 itv2) { this.tv = itv2; } @Override public void open() { this.tv.play(); } } /** * 方式3，经过setter方法传递 */ interface IOpenAndClose3 { /** * 抽象方法 */ void open(); void setTv(ITV3 tv); } /** * ITV接口 */ interface ITV3 { void play(); } class SanXing implements ITV3 { @Override public void play() { System.out.println("三星电视打开"); } } class OpenAndClose3 implements IOpenAndClose3 { private ITV3 itv3; @Override public void open() { this.itv3.play(); } @Override public void setTv(ITV3 tv) { this.itv3 = tv; } } 

依赖倒转原则的注意事项和细节
1）底层模块尽力都要有抽象类或接口，或者二者都有，程序稳定性更好。
2）变量的声明类型尽可能是抽象类或接口，这样咱们的变量引用和实际对象间，就存在一个缓存层，利于程序扩展和优化。
3）继承时遵循里氏替换原则。

2.6 里氏替换原则

2.6.1 OO中的继承性的思考和说明

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

2.6.2 基本介绍

1）里氏替换原则（Liskov Substitution Principle）在1988年，由麻省理工学院的一位姓里的女士提出的。
2）若是对每一个类型为T1的对象O1，都有类型为T2的对象O2，使得以T1定义的全部程序P在全部的对象O1都代换成O2时，程序P的行为没有变化，那么类型T2是类型T1的子类型。换句话说，全部引用基类的地方必须能透明地使用其子类的对象。
3）在使用继承时，遵循里氏替换原则，在子类中尽可能不要重写父类的方法。
4）里氏替换原则告诉咱们，继承实际上让两个类耦合性加强了，在适当的状况下，能够经过聚合、组合、依赖来解决问题。

2.6.3 一个程序引出的问题和思考

该看个程序，思考下问题和解决思路

package com.example.testdemo.mode.principle.liskov; public class Liskov { public static void main(String[] args) { A a = new A(); System.out.println("11 - 3 = " + a.funcl(11, 3)); System.out.println("1 - 8 = " + a.funcl(1, 8)); System.out.println("-----------------"); B b = new B(); // 这里本意是求出11 - 3 System.out.println("11 - 3 = " + b.funcl(11, 3)); // 1 - 8 System.out.println("1 - 8 = " + b.funcl(1, 8)); System.out.println("11 + 3 + 9 = " + b.func2(11, 3)); } } class A { /** * 返回两个数的差 * * @param num1 * @param num2 * @return */ public int funcl(int num1, int num2) { return num1 - num2; } } /** * B类继承类A * * 增长类一个新功能 ：完成两个数相加，而后和9 求和 */ class B extends A { /** * 这里，重写类A类的方法，多是无心识 * @param a * @param b * @return */ @Override public int funcl(int a, int b) { return a + b; } public int func2(int a, int b) { return funcl(a, b) + 9; } } 

2.6.4 解决方法

1）咱们发现原来运行正常的相减功能发生类错误。缘由就是类B无心中重写父类的方法，形成原有功能出现错误。在实际编程中，咱们经常会经过重写父类的方法完成新的功能，这样写起来虽然简单，但整个继承体系的复用性会比较差。特别是运行多态比较频繁的时候。
2）通用的作法是 ：原来的父类和子类都继承一个更通俗的基类，原有的继承关系去掉，采用依赖、聚合、组合等关系代替。
3）改进方案。

package com.example.testdemo.mode.principle.improve; public class Liskov { public static void main(String[] args) { A a = new A(); System.out.println("11 - 3 = " + a.func1(11, 3)); System.out.println("1 - 8 = " + a.func1(1, 8)); System.out.println("--------------------------"); B b = new B(); // 由于B类再也不继承A类，所以调用者，不会再funcl是求减法 // 调用完成的功能就会很明确 // 这里本意是求出 11 + 3 System.out.println("11 + 3 = " + b.func1(11, 3)); // 1 + 8 System.out.println("1 + 8 = " + b.func1(1, 8)); System.out.println("11 + 3 + 9 = " + b.func2(11, 3)); // 使用组合仍然可使用到A类相关方法 // 这里本意是求出 11 - 3 System.out.println("11 - 3 = " + b.func3(11, 3)); } } /** * 建立一个更加基础的基类 */ class Base { // 把更加基础的方法和成员写Base类 } /** * A 类 */ class A extends Base { /** * 返回两个数的差 * @param num1 * @param num2 * @return */ public int func1(int num1, int num2) { return num1 - num2; } } /** * B类 继承了 A * * 增长类一个新功能 ：完成两个数相加，而后和9 求和 */ class B extends Base { /** * 若是B须要使用A类的方法，使用组合关系 */ private A a = new A(); /** * 这里，重写了A类方法，多是无心识 * * @param a * @param b * @return */ public int func1(int a, int b) { return a + b; } public int func2(int a, int b) { return func1(a, b) + 9; } /** * 咱们仍然想使用A的方法 * @param a * @param b * @return */ public int func3(int a, int b) { return this.a.func1(a,b); } } 

2.7 开闭原则

2.7.1 基本介绍

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

2.7.2 看下面一段代码

看一个画图形的功能。
类图设计，以下 ：

package com.example.demo.ocp;

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());
    }

}

/**
 * 这是一个用于绘图的类（使用方）
 */
class GraphicEditor {

    /**
     * 接收Shape对象，而后根据type，来绘制不一样的图形
     * @param shape
     */
    public void drawShape(Shape shape) {
        if (shape.m_type == 1) {
            drawRectangle(shape);
        } else if (shape.m_type == 2) {
            drawCircle(shape);
        } else if (shape.m_type == 3) {
            drawTriangle(shape);
        }
    }

    /**
     * 绘制三角形
     * @param shape
     */
    private void drawTriangle(Shape shape) {
        System.out.println("绘制三角形");
    }

    /**
     * 绘制圆形
     * @param shape
     */
    private void drawCircle(Shape shape) {
        System.out.println("绘制圆形");
    }


    /**
     * 绘制矩形
     * @param shape
     */
    private void drawRectangle(Shape shape) {
        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 = 3;
    }
}

2.7.3 方式1的优缺点

1）优势是比较好理解，简单易操做。
2）缺点是违反了设计模式的ocp原则，即对扩展开放（提供方），对修改关闭（使用方）。即当咱们给类增长新功能的时候，尽可能不修改代码，或者尽量少修改代码。
3）好比咱们这时要新增长一个图形种类 三角形，咱们须要作不少修改，修改的地方比较多。

2.7.4 改进的思路分析

思路 ： 把建立Shape类作成抽象类，并提供一个抽象的draw方法，让子类去实现便可，这样咱们有新的图形种类时，只须要让新的图形类继承Shape，并实现draw方法便可，使用方的代码就不须要修改 -》
知足了开闭原则
改进后的代码 ：

package com.example.demo.ocp.improve;

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());
    }
}

/**
 * 这是一个用于绘图的类（使用方）
 */
class GraphicEditor {

    /**
     * 接收Shape对象，调用draw方法
     * @param shape
     */
    public void drawShape(Shape shape) {
        shape.draw();
    }
}

/**
 * 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("绘制其余图形");
    }
}

2.8 迪米特法则

2.8.1 基本介绍

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

2.8.2 应用实例

1）有一个学校，下属有各个学院和总部，现要求打印出学校总部员工ID和学院员工的id
2）编程实现上面的功能，看代码演示
3）代码演示

package com.example.demo.demeter;

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

/**
 * 客户端
 */
public class Demeter1 {

    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 {

    /**
     * 返回学院的全部员工
     * @return
     */
    public List<CollegeEmployee> getAllEmployee() {
        List<CollegeEmployee> employees = new ArrayList<>();
        // 这里咱们增长了10个员工到list
        for (int i = 0; i < 10; i++) {
            CollegeEmployee collegeEmployee = new CollegeEmployee();
            collegeEmployee.setId("学院员工 id = " + i);
            employees.add(collegeEmployee);
        }
        return employees;
    }
}

/**
 * 学校管理类
 *
 * 分析 SchoolManager 类的直接朋友类有哪些 Employee、CollegeManager
 * CollegeEmployee 不是 直接朋友，而是一个陌生类，这样违背了迪米特法则
 *
 */
class SchoolManager {

    /**
     * 返回学校总部的员工
     * @return
     */
    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;
    }

    /**
     * 该方法完成输出学校总部和学院员工信息 （id）
     * @param collegeManager
     */
    void printAllEmployee(CollegeManager collegeManager) {
        // 分析问题
        // 1. 这里的 CollegeEmployee 不是 SchoolManageer的直接朋友
        // 2. CollegeEmployee 是以局部变量方式出如今 SchoolManager
        // 3. 违反了 迪米特法则
        // 获取到学院员工
        List<CollegeEmployee> allEmployee = collegeManager.getAllEmployee();
        System.out.println("-------------学院员工-------------");
        for (CollegeEmployee collegeEmployee : allEmployee) {
            System.out.println(collegeEmployee.getId());
        }
        // 获取到学院总部员工
        List<Employee> employee = this.getAllEmployee();
        System.out.println("-----------学校总部员工-------------");
        for (Employee employee1 : employee) {
            System.out.println(employee1.getId());
        }
    }
}

2.8.3 应用实例改进

1）前面设计的问题在于SchoolManager中，CollegeEmployee类并非SchoolManager类的直接朋友（分析）
2）按照迪米特法则，应该避免类中出现这样非直接朋友关系的耦合
3）对代码按照迪米特法则进行改进。
4）代码演示

package com.example.demo.demeter.improve;

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

/**
 * 客户端
 */
public class Demeter1 {

    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 {

    /**
     * 返回学院的全部员工
     * @return
     */
    public List<CollegeEmployee> getAllEmployee() {
        List<CollegeEmployee> employees = new ArrayList<>();
        // 这里咱们增长了10个员工到list
        for (int i = 0; i < 10; i++) {
            CollegeEmployee collegeEmployee = new CollegeEmployee();
            collegeEmployee.setId("学院员工 id = " + i);
            employees.add(collegeEmployee);
        }
        return employees;
    }

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

/**
 * 学校管理类
 *
 * 分析 SchoolManager 类的直接朋友类有哪些 Employee、CollegeManager
 * CollegeEmployee 不是 直接朋友，而是一个陌生类，这样违背了迪米特法则
 *
 */
class SchoolManager {

    /**
     * 返回学校总部的员工
     * @return
     */
    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;
    }

    /**
     * 该方法完成输出学校总部和学院员工信息 （id）
     * @param collegeManager
     */
    void printAllEmployee(CollegeManager collegeManager) {
        // 分析问题
        // 1. 将输出学院的员工方法，封装到CollegeManager
        collegeManager.printEmployee();
        // 获取到学院总部员工
        List<Employee> employee = this.getAllEmployee();
        System.out.println("-----------学校总部员工-------------");
        for (Employee employee1 : employee) {
            System.out.println(employee1.getId());
        }
    }
}

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

1）迪米特法则的核心是下降类之间的耦合
2）可是注意 ：因为每一个类都减小了没必要要的依赖，所以迪米特法则只是要求下降类间（对象间）耦合关系，并非要求彻底没有依赖关系。

2.9 合成复用原则（Composite Reuse Principle）

基本介绍 ：原则是尽可能使用合成/聚合的方式，而不是使用继承。

设计原则核心思想

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