设计模式的七大原则-下

最新推荐文章于 2024-07-12 23:09:31 发布

穆慕文

最新推荐文章于 2024-07-12 23:09:31 发布

阅读量72

点赞数

分类专栏：设计模式文章标签：设计模式 java 开发语言

本文链接：https://blog.csdn.net/qq_44611090/article/details/125316469

版权

设计模式专栏收录该内容

6 篇文章 0 订阅

订阅专栏

还有四大原则，我们继续

开闭原则

定义

对扩展开放，对修改关闭。是设计模式的最基本原则

目的

就是增加拓展性，便于维护
当软件需要变化时，尽量通过扩展软件实体的行为来实现变化，而不是通过修改已有的代码来实现

这个原则理解一下概念，就不用代码展示了

里氏替换原则

定义

所有引用基类的地方必须能透明地使用其子类的对象，就是尽量不要重写父类的非抽象方法，做到透明化。通俗来讲，就是我们在调用基类的非抽象方法时，一定是基类方法的实现，因为根据原则我们保证了不重写基类的非抽象方法，避免造成不必要的问题

目的

避免系统继承体系被破坏，避免造成不必要的问题

具体实现

子类可以实现父类的抽象方法，但是不能覆盖父类的非抽象方法；
子类可以增加自己特有的方法；
当子类覆盖或实现父类的抽象方法时，方法的前置条件（即方法的形参）要比父类方法的输入参数更宽松；方法的后置条件（即方法的返回值）要比父类更严格。
如果子类不能完整地实现父类的方法，或者父类的一些方法在子类中已经发生畸形，则建议断开继承关系，采用依赖，聚合，组合等关系继承。

举个例子

反面例子

我们现在有两个类：A,B。A类有一个非抽象方法add；B类继承了A类，但是由于失误重写了add方法，并且实现和A类不一致

class A{
    int add(int a,int b){
        return a+b;
    }
}

class B extends A{

    // 我们在继承A类的时候，失误重写了A类的非抽象方法，这样的话其他消费者来调用这个add方法时，
    // 会觉得执行的是A类的add方法，而不会想到B类会重写add方法，造成不必要的问题
    int add(int a, int b) {
        return a + 10 * b;
    }
}

在写一个main方法充当调用端测试下

public static void main(String[] args) {
    A a = new A();
    System.out.println("9+5=" + a.add(9,5));

    A ab = new B();
    System.out.println("9+5=" + ab.add(9,5));
}

测试结果

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-vgiJsKyN-1655363211843)(https://p6-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/c1408699fda845159d02a73846dc3325~tplv-k3u1fbpfcp-watermark.image?)]

我们可以看到第二步就出现了问题

由于B继承了A类，也就的继承了add方法，调用方就会理所当然的认为调用的是A类的add方法。但是忽略了B类重写了add方法，然后造成数据结果不一致的问题。这就是类不透明化所带来的问题，那么我们怎么解决呢

改进版

既然我们需要A和B类都有add方法，并且实现不一样，那么我们可以在他们上面在抽象出一层基类，让他们分别集成这个基类，进行A,B类的解耦合，这样他们各自的add方法就不会被调用方误以为是同一个实现逻辑了，我们看下代码

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

class C extends Base{
    int add(int a, int b) {
        return a + 10 * b;
    }
}

class D extends Base{
    int add(int a, int b) {
        return a + 100 * b;
    }
}

测试一下

public static void main(String[] args) {

    // 解决上述问题,因为C类D类都继承了Base类，虽然C类D类中都有add方法，但是Base类中没有add方法，
    // 也就是说add方法肯定是自己类的独立实现，调用方就不会误认为方法一致，造成上述的问题
    C c = new C();
    System.out.println("9+10 * 5=" + c.add(9,5));
    D d = new D();
    System.out.println("9 + 100 * 5=" +d.add(9,5));
}

测试结果

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-NUfXCZ2s-1655363211844)(https://p9-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/46429da40dc8455cb857404b75497b56~tplv-k3u1fbpfcp-watermark.image?)]

迪米特原则

定义

迪米特法则又叫最少知道原则，即一个类对自己依赖的类知道的越少越好，对于依赖的类不管有多复杂，都尽量将逻辑封装在类的内部，对外除了提供public方法，不泄漏任何信息。

更简单的说法：只与直接朋友通信。

直接朋友的定义：

在成员变量中的类，
在方法参数中的类，
在方法返回值中的类
陌生的类不要以局部变量的形式出现在类的内部

目的

降低类之间的耦合度

举个例子

爸爸妈妈都想要知道儿子一周有哪些课，那么我们来看看他们都是怎么得知有哪些课程的呢

首先我们创建一个儿子类，有两个功能：获取课程表+说出有哪些课程

class Son{

    /**
     * 获取课程表
     * @return
     */
    public List<String> getCurriculum(){
        List<String> curriculumList = new ArrayList<>();
        curriculumList.add("语文课");
        curriculumList.add("数学课");
        curriculumList.add("英语课");
        curriculumList.add("美术课");
        curriculumList.add("体育课");
        curriculumList.add("书法课");
        return curriculumList;
    }

    /**
     * 说出哪些课程
     */
    public void sayCurriculumList(){
        System.out.println("儿子查看课程表");
        List<String> curriculumList = viewCurriculum();
        System.out.println("儿子：这周有");
        for (String s : curriculumList) {
            System.out.println(s);
        }
    }
}

然后我们看看爸爸是怎么得知儿子有哪些课程的

class Dad{

    public void askCurriculum(Son son){
        System.out.println("爸爸：儿子这周有哪些课啊");
        System.out.println("爸爸拿过儿子的课程表");
        List<String> curriculumList = son.getCurriculum();
        System.out.println("爸爸：儿子这周有");
        for (String s : curriculumList) {
            System.out.println(s);
        }
    }
}

main方法打印测试一下

public static void main(String[] args) {
    new Dad().askCurriculum(new Son());
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-XEk7AazK-1655363211845)(https://p3-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/826bce95b3ff4c1b974bc3b590a6f6f7~tplv-k3u1fbpfcp-watermark.image?)]

我们可以看到爸爸是先从儿子哪里拿到了课程表，然后一个个查看最终获取到了儿子一周的课程信息。这种就违反了迪米特原则，也就是最少知道原则，我们的本意是让儿子告诉我一周的课程就行了，不关系他的课程表，也不需要一个个查看他的课程表获取一周的课程信息。

那么，我们看看妈妈是怎么得知儿子一周的课程吧

class Mom{

    public void askCurriculum(Son son){
        System.out.println("妈妈：儿子这周有哪些课啊");
        son.sayCurriculumList();
    }
}

main方法打印测试一下

public static void main(String[] args) {
    new Mom().askCurriculum(new Son());
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-9TMvNnF8-1655363211845)(https://p6-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/1939c149352e4aecb4e3db48ef3ef137~tplv-k3u1fbpfcp-watermark.image?)]

我们可以看到妈妈获取儿子一周的课程信息是不是更加简洁明了呢，我只关心我想要的结果，至于你具体怎样的细节我并不关心，这就遵循了迪米特原则。另外说一句，从侧面看他们的实现方式，是不是也能看出爸爸妈妈各自在家庭中的地位，不知道自己以后成家了，家庭地位又如何^v

注意事项

在类的结构设计上，尽量降低类成员的访问权限；
在类的设计上，优先考虑将一个类设计成不变类；
在类的引用上，将引起其他类的次数降到最低；
不暴露类的属性成员，而应该提供相应的访问器（getter、setter）；
谨慎使用序列化（serializable）功能；
过分的使用迪米特原则，会产生大量这样的中介和传递类，类之间需要通信就通过第三方转发的方式，就会造成系统的不同模块之间的通信效率降低、使系统的不同模块之间不容易协调等缺点，同时大大增加了系统的复杂度。所以在釆用迪米特法则时需要反复权衡，确保高内聚和低耦合的同时，保证系统的结构清晰。