设计模式：七大设计原则

最新推荐文章于 2024-02-19 11:30:24 发布
最新推荐文章于 2024-02-19 11:30:24 发布
阅读量218 收藏 1
点赞数
分类专栏： 设计模式 文章标签： 设计模式七大设计原则
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44718865/article/details/118581191
版权

1、设计模式的目的

1.1、目的

编写软件过程中，程序员面临着来自耦合性，内聚性以及可维护性，可扩展性，重用性，灵活性等多方面的挑战，设计模式是为了让程序（软件），具有更好
1）代码重用性（即：相同功能的代码，不用多次编写）
2）可读性（即：编程规范性，便于其他程序员的阅读和理解）
3）可扩展性（即：当需要增加新的功能时，非常的方便，称为可维护）
4）可靠性（即：当我们增加新的功能后，对原来的功能没有影响）
5）使程序呈现高内聚，低耦合的特性
分析金句：
设计模式包含了面向对象的精髓，“懂了设计模式，你就懂了面向对象分析和设计（OOA/D）的精要”

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

1.2、设计原则核心思想

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

2、面向对象的“六原则一法则”：

单一职责原则、开闭原则、依赖倒转原则、里氏替换原则、接口隔离原则、合成聚合复用原则和迪米特法则。

2.1、单一职责原则★★★★☆

2.1.1、基本介绍

  • 对类来说的，即一个类应该只负责一项职责。如类A负责两个不同职责：职责1，职责2。当职责1需求变更而改变A时，可能造成职责2执行错误，所以需要将类A的粒度分解为A1，A2
  • 单一职责原则想表达的就是"高内聚"，写代码最终极的原则只有六个字"高内聚、低耦合"，就如同葵花宝典或辟邪剑谱的中心思想就八个字"欲练此功必先自宫"，所谓的高内聚就是一个代码模块只完成一项功能，在面向对象中，如果只让一个类完成它该做的事，而不涉及与它无关的领域就是践行了高内聚的原则，这个类就只有单一职责。。

2.1.2、应用实例–交通工具案例讲解

方案1：

package Seven_principles.singleresponsibility;

public class SingleResponsibility1 {
    public static void main(String[] args) {
        Vehicle vehicle = new Vehicle();
        vehicle.run("自行车");
        vehicle.run("");
        vehicle.run("飞机");
    }
}
//工具类
//方式一：
//方式一分析：
//1.在方式一的run方法中，违反了单一职责原则
    //2.解决的方案非常的简单，根据交通工具运行方法不同，分解成不同类即可
    class Vehicle{
    public void run(String vehicle) {
        System.out.println(vehicle + "在公路上运行。。。");
    }

}
/*
运行结果：
摩托车在公路上运行。。。
汽车在公路上运行。。。
飞机在公路上运行。。。
 */

方案2：

package Seven_principles.singleresponsibility;

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

//三个工具类
//方式二：
//方式二的分析：
//1.遵守单一职责原则
//2.但是这样做的改动很大，即将类分解，同时修改客户端
//3.改进：直接修改Vehicle类，改动的代码会比较少=》方式三
class RoadVehicle{
    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 + "在水路上运行。。。");
    }

}

/*
运行结果：
摩托车在公路上运行。。。
飞机在天空上运行。。。
轮船在水路上运行。。。
 */

方案3：

package Seven_principles.singleresponsibility;

public class SingleResponsibility3 {
    public static void main(String[] args) {
        Vehicle2 vehicle2 = new Vehicle2();
        vehicle2.run("摩托车");
        vehicle2.runAir("飞机");
        vehicle2.runWater("轮船");
    }
}

//工具类
//方式三：
//方式三分析：
//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 + "在水路上运行。。。");
    }

}

/*
运行结果：
摩托车在公路上运行。。。
飞机在天空上运行。。。
轮船在水路上运行。。。
 */

2.1.3、注意事项和细节

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

2.2、接口隔离原则★★☆☆☆

2.2.1、基本介绍

  1. 客户端不应该依赖它不需要的接口，即一个类对另一个类的依赖应该建立在最小的接口上
  2. 先看一张图：
    在这里插入图片描述
  3. 类A通过接口Interface1依赖类B，类c通过接口Interface1依赖类D，如果接口Interface1对于类A和类c来说不是最小接口那么类B和类D必须去实现他们不需要的方法。
  4. 按隔离原则应当这样处理：将接口Interface1拆分为独立的几个接口，类A和类c分别与他们需要的接口建立依赖关系。也就是采用接口隔离原则
  5. 接口要小而专，绝不能大而全。
  6. 臃肿的接口是对接口的污染，既然接口表示能力，那么一个接口只应该描述一种能力，接口也应该是高度内聚的。例如，琴棋书画就应该分别设计为四个接口，而不应设计成一个接口中的四个方法，因为如果设计成一个接口中的四个方法，那么这个接口很难用，毕竟琴棋书画四样都精通的人还是少数，而如果设计成四个接口，会几项就实现几个接口，这样的话每个接口被复用的可能性是很高的。Java中的接口代表能力、代表约定、代表角色，能否正确的使用接口一定是编程水平高低的重要标识。

2.2.2、应用实例

类A通过接口Interface1依赖类B，类C通过接口Interface1依赖类D，请编写代码完成此应用实例。

package Seven_principles.segregation;

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 depend2(Interface1 interface1) {
        interface1.operation4();
    }
    public void depend3(Interface1 interface1) {
        interface1.operation5();
    }
}

应传统方法的问题和使用接口隔离原则改进

1）类A通过接口Interface1依赖类B，类c通过接口Interface1依赖类D，如果接口Interface1对于类A和类C来说不是最小接口，那么类B和类D必须去实现他们不需要的方法
2）将接口Interface1拆分为独立的几个接口，类A和类C分别与他们需要的接口建立依赖关系。也就是采用接口隔离原则
3）接口Interface1中出现的方法，根据实际情况拆分为三个接口4）代码实现

package Seven_principles.segregation.improve;

public class Segregation2 {
    public static void main(String[] args) {
//        使用一下
        A a = new A();
        a.depend1(new B());//A类通过接口去依赖B类
        a.depend2(new B());//A类通过接口去依赖B类
        a.depend3(new B());//A类通过接口去依赖B类

        C c = new C();
        c.depend1(new D());//C类通过接口去依赖D类
        c.depend2(new D());
        c.depend3(new D());

    }
}

//接口1
interface Interface1 {
    void operation1();
}
//接口2
interface Interface2 {
    void operation2();
    void operation3();
}
//接口3
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 interface2) {
        interface2.operation2();
    }
    public void depend3(Interface2 interface2) {
        interface2.operation3();
    }
}

//C 类通过接口Interface1  Interface3依赖（使用）D类，但是只会用到1,4,5方法。
class C {
    public void depend1(Interface1 interface1) {
        interface1.operation1();
    }
    public void depend2(Interface3 interface3) {
        interface3.operation4();
    }
    public void depend3(Interface3 interface3) {
        interface3.operation5();
    }
}
/*
执行结果：
B 实现了operation1
B 实现了operation2
B 实现了operation3
D 实现了operation1
D 实现了operation4
D 实现了operation5
 */

2.3、依赖倒转原则★★★★★

2.3.1、基本介绍

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

  • 针对接口编程，不要针对实现编程
  • 高层模块不应该依赖底层模块，抽象不应该依赖细节，细节应该依赖抽象。
  • 传递参数或者关联关系的时候尽量使用层次高的抽象层类
  • 程序中尽量使用抽象层编码，而将具体类对象通过依赖注入的方法注入其它对象，使用到spring的依赖注入。

面向接口编程。

该原则说得直白和具体一些就是声明方法的参数类型、方法的返回类型、变量的引用类型时，尽可能使用抽象类型而不用具体类型，因为抽象类型可以被它的任何一个子类型所替代，请参考下面的里氏替换原则。

2.3.2、应用实例–Person发送消息的功能

方案1：

package Seven_principles.inversion;

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

    }
}

class Email {
    public String getInfo() {
        return "电子邮件信息：hello World";
    }
}
//完成Person接收消息的功能
//方式一
//方式一分析：
//1.简单，比较容易想到
//2.如果我们获取的对象是微信，短信等等，这新增类，同时Person也要增加相应的接收方法，
//3.解决思路：引入一个抽象的接口IReceiver，表示接受者，这样Person类与接口IReceiver发生依赖
//因为Email，WeiXin等等属于接收的范围，他们各自实现IReceiver接口即可，这样我们就符合依赖倒转原则
class Person {
    public void receive(Email email) {
        System.out.println(email.getInfo());

    }
}

方案2：

package Seven_principles.inversion.improve;

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

    }
}

//定义接口
interface IReceiver {
    public String getInfo();
}
//邮件
class Email implements IReceiver{
    public String getInfo() {
        return "电子邮件信息：hello World";
    }
}
//微信
class WeiXin implements IReceiver{
    public String getInfo() {
        return "微信信息：hello World";
    }
}

//完成Person接收消息的功能
//方式二
class Person {
    public void receive(IReceiver iReceiver) {
        System.out.println(iReceiver.getInfo());

    }
}
/*
执行结果：
电子邮件信息：hello World
微信信息：hello World
 */

2.3.3、依赖关系传递的三种方式和应用案例

package Seven_principles.inversion.improve;

public class DependecyInversion3 {
    public static void main(String[] args) {
//        测试方式一：通过接口传递依赖
//        ChangHong changHong = new ChangHong();
//        OpenAndClose openAndClose = new OpenAndClose();
//        openAndClose.open(changHong);
//        测试方式二：通过构造器传递依赖
//        ChangHong changHong = new ChangHong();
//        OpenAndClose openAndClose = new OpenAndClose(changHong);
//        openAndClose.open();
//        测试方式三：通过set方法传递依赖
        ChangHong changHong = new ChangHong();
        OpenAndClose openAndClose = new OpenAndClose();
        openAndClose.setTV(changHong);
        openAndClose.open();

    }
}

方式一：通过接口传递实现依赖
开关的接口
//interface IOpenAndClose {
//    public void open(ITV tv);//抽象方法，接收接口
//}
//
//interface ITV {
//    public void play();
//}
//
实现接口
//class OpenAndClose implements IOpenAndClose {
//
//    @Override
//    public void open(ITV tv) {
//        tv.play();
//    }
//}
//class ChangHong implements ITV {
//    @Override
//    public void play() {
//        System.out.println("长虹电视机：打开");
//    }
//}

方式二：通过构造方法传递依赖
开关的接口
//interface IOpenAndClose {
//    public void open();//抽象方法，接收接口
//}
//
//interface ITV {
//    public void play();
//}
//
实现接口
//class OpenAndClose implements IOpenAndClose {
//    public ITV itv;//成员
//
//    public OpenAndClose(ITV itv) {//构造器
//        this.itv = itv;
//    }
//
//    @Override
//    public void open() {
//        this.itv.play();
//    }
//}
//
//    class ChangHong implements ITV {
//        @Override
//        public void play() {
//            System.out.println("长虹电视机：打开");
//        }
//    }

//方式三：通过setting方法传递依赖
//开关的接口
interface IOpenAndClose {
    public void open();//抽象方法，接收接口

    public void setTV(ITV itv);
}

interface ITV {
    public void play();
}
//实现接口
class OpenAndClose implements IOpenAndClose {
    public ITV itv;

    @Override
    public void setTV(ITV itv) {
        this.itv = itv;
    }

    @Override
    public void open() {
        this.itv.play();
    }

}
class ChangHong implements ITV {
    @Override
    public void play() {
        System.out.println("长虹电视机：打开");
    }
}

/*
测试方式一结果：
长虹电视机：打开
测试方式二结果：
长虹电视机：打开
测试方式三结果：
长虹电视机：打开
 */

2.4、里氏替换原则★★★★★

2.4.1、OO中的继承性的思考和说明

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

  • 子类可以扩展父类的方法，但是不能改变父类的方法
  • 基类对象可以替换子类对象，反过来不成立
  • 里氏代换原则是实现开闭原则的重要方式之一，由于可以使用基类的地方都可以使用子类，所以在定义的时候尽量使用基类型，运行的时候再确定子类类型

2.4.2、基本介绍

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

这里说到子类A不能重写父类B，那还要继承干嘛，如果非要重写的话，那么就不要用A继承B，可以用聚合，组合和依赖要关联A和B,而不是继承关系关联，可以将A和B都是一个基类的子类，让他们的耦合性降低，把他们更加普通的方法放到这个基类中，这样子类A就不需要重写父类B中的普通方法。

单一职责原则：一个类一个方法；接口隔离原则：最小接口；依赖倒置原则：依赖抽象；里氏替换原则：继承

原始代码

package Seven_principles.liskov;

public class LisKov1 {
    public static void main(String[] args) {
        A a = new A();
        System.out.println("11-3=" + a.fun1(11, 3));
        System.out.println("1-8=" + a.fun1(1, 8));

        System.out.println("====================================");
        B b = new B();
        System.out.println("11-3="+b.fun1(11,3));
        System.out.println("1-8="+b.fun1(1,8));
        System.out.println("11+3+9=" + b.fun2(11, 3));
    }
}
//A类
class A {
//    返回两个数的差
    public int fun1(int num1, int num2) {
        return num1 - num2;
    }
}

//B类继承了A类
//增加了一个新功能：完成两个数相加，然后和9求和
class B extends A {
//    这里：重写了A类的方法
    public int fun1(int a, int b) {
        return a + b;
    }

    public int fun2(int a, int b) {
        return fun1(a, b) + 9;
    }
}
/*
执行结果：
11-3=8
1-8=-7
====================================
11-3=14
1-8=9
11+3+9=23
 */

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

改进代码：

package Seven_principles.liskov.improve;

public class LisKov2{
    public static void main(String[] args) {
        A a = new A();
        System.out.println("11-3=" + a.fun1(11, 3));
        System.out.println("1-8=" + a.fun1(1, 8));

        System.out.println("====================================");
        B b = new B();
//        增加基类Base之后，B类不再继承A类，因此调用者，不会再觉得fun1是求减法了
//        调用完成的功能就会很明确
        System.out.println("11+3="+b.fun1(11,3));
        System.out.println("1+8="+b.fun1(1,8));
        System.out.println("11+3+9=" + b.fun2(11, 3));
//        使用组合仍然可以使用到A类相关方法
        System.out.println("11-3=" + b.fun3(11, 3));
    }
}

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

//A类
class A extends Base{
//    返回两个数的差
    public int fun1(int num1, int num2) {
        return num1 - num2;
    }
}

//B类继承了A类
//增加了一个新功能：完成两个数相加，然后和9求和
class B extends Base {
    //    如果B需要使用到A类中的方法，使用组合关系
    private A a = new A();
//    这里：重写了A类的方法
    public int fun1(int a, int b) {
        return a + b;
    }

    public int fun2(int a, int b) {
        return fun1(a, b) + 9;
    }

    //    我们仍然想使用A的方法
    public int fun3(int a, int b) {
        return this.a.fun1(a, b);
    }
}
/*
执行结果：
11-3=8
1-8=-7
====================================
11+3=14
1+8=9
11+3+9=23
11-3=8
 */

2.5、开闭原则★★★★★

2.5.1、基本介绍

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

2.5.2、应用案例–绘制图形

方式一：

package Seven_principles.ocp;

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

    }
}

//这是一个用于绘图的类
class GraphicEditor {
    public void drawShape(Shape s) {
        if (s.m_type == 1) {
            drawRectangle(s);
        } else if (s.m_type == 2) {
            drawCircle(s);
        }
    }

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

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

class Shape {
    int m_type;
}

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

class Circle extends Shape {
    Circle() {
        super.m_type = 2;
    }
}
/*
执行结果：
绘制矩形
绘制圆形
 */

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

方式二：

package Seven_principles.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 {
    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("绘制三角形");
    }
}

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;
    }
}
/*
执行结果：
绘制矩形
绘制圆形
绘制三角形
 */

按照原始方法进行增加的时候违背了开闭原则

方式一的改进思路分析
思路：把创建Shape类做成抽象类，并提供一个抽象的draw方法，让子类去实现即可，这样我们有新的图形种类时，只需要让新的图形类继承Shape，并实现draw方法即可，使用方的代码就不需要修->满足了开闭原则

package Seven_principles.ocp.improvr;

public class Ocp2 {
    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 {
    public void drawShape(Shape s) {
       s.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.6、迪米特法则★★★☆☆

2.6.1、基本介绍

  1. 一个对象应该对其他对象保持最少的了解
  2. 类与类关系越密切，摄合度越大
  3. 迪米特法则（Demeter Principle）又叫最少知道原则，即一个类对自己依赖的类知道的越少越好。也就是说，对于被依赖的类不管多么复杂，都尽量将逻辑封装在类的内部。对外除了提供的public 方法，不对外泄露任何信
  4. 迪米特法则还有个更简单的定义：只与直接的朋友通
  5. 直接的朋友：每个对象都会与其他对象有耦合关系，只要两个对象之间有耦合关系，我们就说这两个对象之间是朋友关系。耦合的方式很多，依赖，关联，组合，聚合等。其中，我们称出现成员变量，方法参数，方法返回值中的类为直接的朋友，而出现在局部变量中的类不是直接的朋友。也就是说，陌生的类最好不要以局部变量的形式出现在类的内部。
  6. 迪米特法则简单的说就是如何做到"低耦合"，门面模式和调停者模式就是对迪米特法则的践行
  7. 门面模式可以举一个简单的例子，你去一家公司洽谈业务，你不需要了解这个公司内部是如何运作的，你甚至可以对这个公司一无所知，去的时候只需要找到公司入口处的前台美女，告诉她们你要做什么，她们会找到合适的人跟你接洽，前台的美女就是公司这个系统的门面。再复杂的系统都可以为用户提供一个简单的门面，Java Web开发中作为前端控制器的Servlet或Filter不就是一个门面吗，浏览器对服务器的运作方式一无所知，但是通过前端控制器就能够根据你的请求得到相应的服务。调停者模式也可以举一个简单的例子来说明，例如一台计算机，CPU、内存、硬盘、显卡、声卡各种设备需要相互配合才能很好的工作，但是如果这些东西都直接连接到一起，计算机的布线将异常复杂，在这种情况下，主板作为一个调停者的身份出现，它将各个设备连接在一起而不需要每个设备之间直接交换数据，这样就减小了系统的耦合度和复杂度。

2.6.2、应用实例

有一个学校，下属有各个学院和总部，现要求打印出学校总部员工ID和学院员工的id

package Seven_principles.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 CollecgeManager());

    }
}
//学习总部员工
class Employee{
    private String id;

    public void setId(String id) {
        this.id = id;
    }

    public String getId() {
        return id;
    }
}

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

    public String getId() {
        return id;
    }
}

//管理学院员工的管理类
class CollecgeManager {
    public List<CollegeEmployee> getAllEmployee() {
        ArrayList<CollegeEmployee> collegeEmployees = new ArrayList<>();
        for (int i = 0; i < 10; i++) {//增加了10个员工到list
            CollegeEmployee collegeEmployee = new CollegeEmployee();
            collegeEmployee.setId("学院员工id=" + i);
            collegeEmployees.add(collegeEmployee);
        }
        return collegeEmployees;
    }
}
//学校管理类
//分析SchoolManager类的直接朋友类有哪些Employee、CollegeManager
//CollegeEmployee 不是 直接朋友 而是一个陌生类，这样违背了迪米特法则
class SchoolManager {
//    返回学校总部员工
    public List<Employee> getAllEmployee() {
        ArrayList<Employee> employees = new ArrayList<Employee>();
        for (int i = 0; i < 5; i++) {//增加了5个员工到list
            Employee employee = new Employee();
            employee.setId("学院员工id=" + i);
            employees.add(employee);
        }
        return employees;
    }
//完成输出学校总部和学院员工信息
    void printAllEmployee(CollecgeManager collecgeManager) {
//        获取学院员工
//        分析：
//        1.这里的CollegeEmployee不是SchoolManager的直接朋友
//        2.CollegeEmployee 是以局部变量方式出现在SchoolManager类中
//        3.违反了迪米特法则
        List<CollegeEmployee> allEmployee = collecgeManager.getAllEmployee();
        System.out.println("========================分公司员工====================");
        for (CollegeEmployee collegeEmployee : allEmployee) {
            System.out.println(collegeEmployee.getId());
        }
//        获取学校总部员工
        List<Employee> allEmployee1 = this.getAllEmployee();
        System.out.println("===================学校总部员工=======================");
        for (Employee e : allEmployee1) {
            System.out.println(e.getId());

        }
    }
}
/*
执行结果：
========================分公司员工====================
学院员工id=0
学院员工id=1
学院员工id=2
学院员工id=3
学院员工id=4
学院员工id=5
学院员工id=6
学院员工id=7
学院员工id=8
学院员工id=9
===================学校总部员工=======================
学院员工id=0
学院员工id=1
学院员工id=2
学院员工id=3
学院员工id=4
 */

在这里插入图片描述
主要是这里违反了迪米特法则

应用实例改进

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

package Seven_principles.demeter.improve;

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

//客户端
public class Demeter2 {
    public static void main(String[] args) {
        System.out.println("~~~~使用迪米特法则改进~~~~");
//        创建了一个SchoolManager对象
        SchoolManager schoolManager = new SchoolManager();
//        输出学院的员工id和学校总部的员工信息
        schoolManager.printAllEmployee(new CollecgeManager());

    }
}

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

    public void setId(String id) {
        this.id = id;
    }

    public String getId() {
        return id;
    }
}

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

    public String getId() {
        return id;
    }
}

//管理学院员工的管理类
class CollecgeManager {
    public List<CollegeEmployee> getAllEmployee() {
        ArrayList<CollegeEmployee> collegeEmployees = new ArrayList<>();
        for (int i = 0; i < 10; i++) {//增加了10个员工到list
            CollegeEmployee collegeEmployee = new CollegeEmployee();
            collegeEmployee.setId("学院员工id=" + i);
            collegeEmployees.add(collegeEmployee);
        }
        return collegeEmployees;
    }
    public void printEmployee() {
        //        获取学院员工
        List<CollegeEmployee> allEmployee = this.getAllEmployee();
        System.out.println("========================分公司员工====================");
        for (CollegeEmployee collegeEmployee : allEmployee) {
            System.out.println(collegeEmployee.getId());
        }
    }

}

//学校管理类
//分析SchoolManager类的直接朋友类有哪些Employee、CollegeManager
//CollegeEmployee 不是 直接朋友 而是一个陌生类，这样违背了迪米特法则
class SchoolManager {
//    返回学校总部员工
    public List<Employee> getAllEmployee() {
        ArrayList<Employee> employees = new ArrayList<Employee>();
        for (int i = 0; i < 5; i++) {//增加了5个员工到list
            Employee employee = new Employee();
            employee.setId("学院员工id=" + i);
            employees.add(employee);
        }
        return employees;
    }
//完成输出学校总部
    void printAllEmployee(CollecgeManager collecgeManager) {
//        获取学院员工
//        分析：
//        1.将输出学院的员工方法，封装到CollegeManager
        collecgeManager.printEmployee();
//        获取学校总部员工
        List<Employee> allEmployee1 = this.getAllEmployee();
        System.out.println("===================学校总部员工=======================");
        for (Employee e : allEmployee1) {
            System.out.println(e.getId());

        }
    }
}
/*
执行结果：
~~~~使用迪米特法则改进~~~~
========================分公司员工====================
学院员工id=0
学院员工id=1
学院员工id=2
学院员工id=3
学院员工id=4
学院员工id=5
学院员工id=6
学院员工id=7
学院员工id=8
学院员工id=9
===================学校总部员工=======================
学院员工id=0
学院员工id=1
学院员工id=2
学院员工id=3
学院员工id=4
 */

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

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

2.7、合成复用原则★★★★☆

2.7.1、基本介绍

  • 原则是尽量使用合成/聚合的方式，而不是使用继承
  • 例如现在A和B类，B要使用A中的方法

继承
在这里插入图片描述
依赖
在这里插入图片描述
聚合

在这里插入图片描述
组合
在这里插入图片描述

优先使用聚合或合成关系复用代码。

  • 在一个新的对象里通过关联关系（包括组合关系和聚合关系）来使用一些已有的对象，使之成为新对象的一部分。
  • 新对象通过委派调用已有对象的方法达到复用功能的目的
  • 复用时尽量使用组合/聚合关系（关联关系），少用继承。

继承复用（白箱复用）：不灵活

组合/聚合复用（黑箱复用）：耦合度低，动态引用其他对象

优先使用对象组合，而不是继承来达到复用的目的。

dxj1016
关注
专栏目录
第一章设计模式与七大原则.doc
02-28
设计模式是软件工程中的一种重要思想，它是经验丰富的软件开发者在实践中提炼出来的一套解决方案模板。...在实际开发中，选择合适的设计模式和遵循设计原则，可以帮助我们构建出更加优雅、可扩展的系统。
Java设计模式七大原则-单一职责原则.md
08-13
设计模式
设计模式七大原则
java123456111的博客
05-18 4625
1、设计模式的目的 ​ 编写软件过程中，程序员面临着来自耦合性，内聚性以及可维护性，可扩展性，重用性，灵活性 等多方面的挑战，设计模式是为了让程序(软件)，具有更好 ​ 1) 代码重用性 (即：相同功能的代码，不用多次编写) ​ 2) 可读性 (即：编程规范性, 便于其他程序员的阅读和理解) ​ 3) 可扩展性 (即：当需要增加新的功能时，非常的方便，称为可维护) ​ 4) 可靠性 (即：当我们增加新的功能后，对原来的功能没有影响) ​ 5) 使程序呈现高内聚，低耦合的特性 2、设计模式七大原则 ​ 设计模
设计模式-七大原则
weixin_44748599的博客
09-06 217
七大原则七大原则单一职责接口隔离原则依赖倒转原则(DI) 七大原则 单一职责原则 接口隔离原则 依赖倒转原则(DI) 单一职责 一轮上一个类只应该负责一个职责, 但可以有多个方法. 好处: 降低复杂度 降低变更引起的风险 提高可读性, 可维护性 通常在代码足够简单时在类级别遵循单一职责, 复杂的情况下为较少代码, 在方法级别上遵循单一职责原则. /** * 单一职责原则1 * 不遵循单一职责原则 */ public class SingleResponsibility_1 { publ
详细介绍设计模式七大原则
m0_54187478的博客
02-19 2595
单一职责原则：一个类应该只有一个引起它变化的原因。开闭原则：软件实体应对扩展开放，对修改封闭。里氏替换原则：子类型必须能够替换掉它们的基类型。依赖倒置原则：高层模块不应依赖于低层模块，两者都应依赖于抽象；抽象不应依赖于细节，细节应依赖于抽象。接口隔离原则：使用多个专门的接口比使用单一的总接口更好。合成/聚合复用原则：尽量使用对象的组合/聚合，而不是继承关系达到复用的目的。迪米特法则（最少知道原则）：一个对象应对其他对象有尽可能少的了解。
设计模式——七大设计原则
weixin_43412762的博客
12-05 3076
设计模式的七大原则：开闭原则、里氏代换原则、依赖倒转原则、接口隔离原则、合成复用原则、迪米特法则
Java设计模式之七大设计原则
热门推荐
qq_49529322的博客
04-28 1万+
Java设计模式之七大设计原则 本文对Java设计模式中的七大设计原则进行汇总介绍，提炼最核心的概念。 设计模式总结笔记 一、设计模式七大原则 设计模式的目的： 代码可重用性：相同功能的代码，不用多次编写。 可读性：编程规范性，便于其他程序员的阅读和理解。 可扩展性：当需要增加新的功能的时候，非常方便，称为可扩展性。 可靠性：当我们新增功能后，对原来的功能没有影响。 使程序呈现高内聚、低耦合特性。 1.1、单一职责原则 不遵守单一职责原则： 对类来说的，就是一个类应该只负责一项职责。 比如：Us
设计模式七大原则——开闭原则
★★光亭★★
02-06 1万+
设计模式七大原则——开闭原则
设计模式七大原则——迪米特原则
★★光亭★★
02-06 8927
设计模式七大原则——迪米特原则
设计模式：七大原则
轻松的小希
03-01 3813
目录第一章 遵守原则介绍第二章 单一职责原则2.1、原则介绍2.2、错误示范2.3、正确示范第三章 开放封闭原则3.1、原则介绍3.2、错误示范3.3、正确示范第四章 里氏替换原则4.1、原则介绍4.2、错误示范4.3、正确示范第五章 接口隔离原则5.1、原则介绍5.2、错误示范5.3、正确示范第六章 依赖倒转原则6.1、原则介绍6.2、错误示范6.3、正确示范第七章 其他两大原则7.1、合成复用原则7.2、最少知识原则 项目地址：https://gitee.com/caochenlei/design-
设计模式七大原则——依赖倒转原则
★★光亭★★
02-05 6035
设计模式七大原则——依赖倒转原则
12-附录 1 设计模式的七大原则(1).html
04-01
在书中，作者们将这二十三种设计模式分成了三类，分别是创建型模式、结构型模式和行为型模式。 创建型模式包含了： 工厂方法模式（ Factory Method ） 抽象工厂模式（ Abstract Factory ） 单例模式（ Singleton ...
Java设计模式七大原则-合成聚合复用原则.md
08-13
java八股文
【超强组合】基于淘金优化算法GRO-BP-Adaboost的数据分类预测算法Matlab实现.rar
最新发布
10-08
1.版本：matlab2014/2019a/2024a 2.附赠案例数据可直接运行matlab程序。 3.代码特点：参数化编程、参数可方便更改、代码编程思路清晰、注释明细。 4.适用对象：计算机，电子信息工程、数学等专业的大学生课程设计、期末大作业和毕业设计。 替换数据可以直接使用，注释清楚，适合新手
VMware Workstation Pro 和 VMware Fusion 安装与配置指南
10-08
内容概要：本文档详细指导了如何在不同的主机环境下，通过 VMWare 的两款产品——Workstation Pro 和 Fusion 进行新虚拟机的构建流程以及具体的操作要点说明。 适用人群：希望在单一机器上部署多操作系统的工作环境或学习测试场景的技术人员和学生。 使用场景及目标：旨在帮助初学者搭建属于自己的虚拟机实验平台，从而方便进行软件测试或者研究操作系统相关的新特性等任务，同时也有利于团队间的协作和资源调配。 注意事项：文中涉及的具体操作如下载源文件、配置网络参数时要注意版权合法性问题和技术安全防范。此外还需依据各自电脑的软硬件条件适当增减虚拟机的资源设定。
科研经费管理系统 SSM毕业设计 源码+数据库+论文（JAVA+SpringBoot+Vue.JS）.zip
10-08
科研经费管理系统 SSM毕业设计 源码+数据库+论文（JAVA+SpringBoot+Vue.JS） 启动教程：https://www.bilibili.com/video/BV1GK1iYyE2B
使用Python Matplotlib进行图形输出与保存详解（包含详细的完整的程序和数据）
10-08
内容概要：本文详细介绍了使用 Python 的 Matplotlib 库来输出和保存图形的方法。不仅涉及了基本流程，如生成图表并将之导出成PNG、PDF和SVG等不同格式的内容，还包括高级话题如设置透明度、分辨率以及制作包含图形元素的HTML页面等。文章通过一个具体的示例代码讲解了各个环节的关键细节和技术要点。 适用人群：对数据可视化有兴趣的初学者及具有一定基础想要深入学习 Matplotlib 使用技巧的技术人员。 使用场景及目标：适用于需要掌握 Matplotlib 不同输出选项及其特点的应用场合，尤其是当需要生成用于打印或网页展示的高质量、可自定义外观的图形时。
【数字信号分离】基于matlab自然梯度算法盲信号分离（含串音信号 变步长）【含Matlab源码 8813期】.zip
10-08
CSDN海神之光上传的代码均可运行，亲测可用，直接替换数据即可，适合小白； 1、代码压缩包内容 主函数：main.m； 调用函数：其他m文件；无需运行 运行结果效果图； 2、代码运行版本 Matlab 2019b或2023b；若运行有误，根据提示修改；若不会，私信博主； 3、运行操作步骤 步骤一：将所有文件放到Matlab的当前文件夹中； 步骤二：双击打开main.m文件； 步骤三：点击运行，等程序运行完得到结果； 4、仿真咨询 如需其他服务，可私信博主或扫描博客文章底部QQ名片； 4.1 博客或资源的完整代码提供 4.2 期刊或参考文献复现 4.3 Matlab程序定制 4.4 科研合作 功率谱估计： 故障诊断分析： 雷达通信：雷达LFM、MIMO、成像、定位、干扰、检测、信号分析、脉冲压缩 滤波估计：SOC估计 目标定位：WSN定位、滤波跟踪、目标定位 生物电信号：肌电信号EMG、脑电信号EEG、心电信号ECG 通信系统：DOA估计、编码译码、变分模态分解、管道泄漏、滤波器、数字信号处理+传输+分析+去噪（CEEMDAN）、数字信号调制、误码率、信号估计、DTMF、信号检测识别融合、LEACH协议、信号检测、水声通信
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值