《设计模式》

置顶松鼠MaSaKi

已于 2022-04-01 17:19:59 修改

阅读量386

点赞数

CC 4.0 BY-SA版权

分类专栏： Design Patterns 文章标签：设计模式 java

于 2021-06-24 23:13:47 首次发布

本文链接：https://blog.csdn.net/qq_45337431/article/details/118198302

Design Patterns 专栏收录该内容

16 篇文章

订阅专栏

本文详细介绍了OOP的七大原则，包括开闭原则、依赖倒置原则、接口隔离原则、迪米特法则、合成复用原则、里氏替换原则和单一职责原则，并结合高内聚低耦合的概念进行了深入讲解。此外，还概述了设计模式的三大分类：创建型、结构型和行为型模式，列举了各自包含的具体模式。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

设计模式

一、OOP七大原则

1、开闭原则：对拓展开放，对修改关闭，是其他OOP原则的最终目的

2、依赖倒置原则：面向接口编程，不面向实现编程

3、接口隔离原则：各个类需有自己专用的接口

4、迪米特原则：一个类对自己依赖的类知道的越少越好，只与你的朋友交谈（中间类），而不要直接和“陌生人”交流

5、合成复用原则

（1）组合或聚合：就是一个类是另一个类的成员变量，即 has A

（2）继承关系：一个类是另一个类的一种，即 is A

（3）合成复用原则要求我们尽量多的使用 has A关系

6、如果使用继承，必须满足里氏替换原则：必须确保父类的属性在子类中仍然成立，无必要不重写

7、单一职责原则：每个类有自己的接口，每个接口有很多方法，而每个方法必须只实现一种功能

TIPS：迪米特法则+高内聚低耦合

高内聚的要求：相近功能放到同一个类中，修改集中，易维护。

低耦合的要求：一个类代码改动不会或很少导致依赖类的代码改动。比如DI，接口隔离和基于接口而非实现编程。

迪米特法则要求：

（1）不该有直接依赖关系的类不要有依赖，比如A类的方法仅仅依赖B类中的两个参数，那就没必要将B类都传入A类中，而只传两个参数值即可。

（2）有依赖关系的类之间，尽量只依赖必要的接口，比如A类只需要序列化方法，不需要反序列化方法，那在依赖B类序列化器的时候，就不应该将反序列化的也注入进来。

案例：搞一个序列化器，包含序列化和反序列化，有一个Merchant类，仅仅需要序列化方法。

/**
 * 序列化器
 */
class Serialization {

    /**
     * 序列化操作
     */
    public String serialize(Object object) {
        System.out.println("----序列化操作");
        return null;
    }

    /**
     * 反序列化操作
     */
    public Object deserialize(String json) {
        System.out.println("----反序列化操作");
        return null;
    }
}

/**
 * Merchant
 */
class Merchant {

    /**
     * 序列化器
     */
    private Serialization serialization = new Serialization();

    /**
     * 序列化操作
     */
    public String serialize(Object object) {
        serialization.serialize(object);
        return null;
    }
}

//测试
public class LODTest {
    /**
     * 序列化和反序列化(LOD+高内聚低耦合)
     */
    @Test
    public void testSerialization() {
        Merchant merchant = new Merchant();
        merchant.serialize(merchant);
    }
}

//打印
----序列化操作

这个代码首先违背了迪米特法则，Merchant类仅仅需要序列化，而依赖注入的Serilization却将反序列化也传进来，依赖了非必要的接口。

那么我们可以定义两个接口解决。

/**
 * 序列化接口
 */
interface Serialize {
    String serialize(Object object);
}

/**
 * 反序列化接口
 */
interface DeSerialize {
    Object deserialize(String json);
}

/**
 * Merchant
 */
class Merchant implements Serialize {

    /**
     * 序列化操作
     */
    @Override
    public String serialize(Object object) {
        System.out.println("----序列化操作");
        return null;
    }
}

但是这种方式违背了高内聚和低耦合，因为序列化和反序列化是相似的方法，如果我们将序列化方式改为了其他格式操作，对应的反序列化也必须修改，需要在代码中寻找到这两个接口，即相似的方法却没有放到一个类中，没有内聚。

我们可以使用组合Has-A模式处理。

/**
 * 序列化器
 */
class Serialization implements Serialize, DeSerialize {

    @Override
    public String serialize(Object object) {
        System.out.println("----序列化操作");
        return null;
    }

    @Override
    public Object deserialize(String json) {
        System.out.println("----反序列化操作");
        return null;
    }
}

/**
 * Merchant
 */
class Merchant {

    /**
     * 序列化器
     */
    private Serialization serialization = new Serialization();

    /**
     * 序列化操作
     */
    public String serialize(Object object) {
        serialization.serialize(object);
        return null;
    }
}

/**
 * DeMerchant
 */
class DeMerchant {

    /**
     * 序列化器
     */
    private Serialization serialization = new Serialization();

    /**
     * 序列化操作
     */
    public Object deserialize(String json) {
        serialization.deserialize(json);
        return null;
    }
}

/**
 * 序列化和反序列化(LOD+高内聚低耦合)
 */
@Test
public void testSerialization() {
    Merchant merchant = new Merchant();
    DeMerchant demerchant = new DeMerchant();
    merchant.serialize(merchant);
    demerchant.deserialize("{\"goodId\":1,\"goodName\":\"godds1\",\"goodPrice\":\"22.2\"}");
}

//打印
----序列化操作
----反序列化操作