导航：首页 > 互联网科技 >

java设计模式的七大设计原则说明

发表于：2024-11-30 作者：千家信息网编辑

千家信息网最后更新 2024年11月30日，本篇内容介绍了"java设计模式的七大设计原则说明"的有关知识，在实际案例的操作过程中，不少人都会遇到这样的困境，接下来就让小编带领大家学习一下如何处理这些情况吧！希望大家仔细阅读，能够学有所成！概述

千家信息网最后更新 2024年11月30日java设计模式的七大设计原则说明

本篇内容介绍了"java设计模式的七大设计原则说明"的有关知识，在实际案例的操作过程中，不少人都会遇到这样的困境，接下来就让小编带领大家学习一下如何处理这些情况吧！希望大家仔细阅读，能够学有所成！

概述

简单介绍一下七大设计原则：

开闭原则：是所有面向对象设计的核心，对扩展开放，对修改关闭
依赖倒置原则：针对接口编程，依赖于抽象而不依赖于具体
单一职责原则：一个接口只负责一件事情，只能有一个原因导致类变化
接口隔离原则：使用多个专门的接口，而不是使用一个总接口
迪米特法则（最少知道原则）：只和朋友交流（成员变量、方法输入输出参数），不和陌生人说话，控制好访问修饰符
里氏替换原则：子类可以扩展父类的功能，但不能改变父类原有的功能
合成复用原则：尽量使用对象组合(has-a)/聚合(contanis-a)，而不是继承关系达到软件复用的目的

开闭原则

定义

指一个软件实体如类、模块和函数应该对扩展开放，对修改关闭。
所谓的开闭，也正是对扩展和修改两个行为的一个原则。强调的是用抽象构建框架，用实现扩展细节。可以提高软件系统的可复用性及可维护性。开闭原则，是面向对象设计中最基础的设计原则。它指导我们如何建立稳定灵活的系统，例如：我们版本更新，我尽可能不修改源代码，但是可以增加新功能。

在现实生活中对于开闭原则也有体现。比如，很多互联网公司都实行弹性制作息时间，规定每天工作 8 小时。意思就是说，对于每天工作 8 小时这个规定是关闭的，但是你什么时候来，什么时候走是开放的。早来早走，晚来晚走。

实例

实现开闭原则的核心思想就是面向抽象编程，接下来我们来看一段代码：

以书店销售书籍为例，创建书籍接口：

/** * @author eamon.zhang * @date 2019-09-25 上午10:26 */public interface IBook {    // 书籍名称    public String getName();    // 价格    public int getPrice();    // 作者    public String getAuthor();}

书籍分为很多类，比如有小说类等，创建小说类书籍：

/** * @author eamon.zhang * @date 2019-09-25 上午10:30 */public class NovelBook implements IBook {    // 书名    private String name;    // 售价    private int price;    // 作者    private String author;    // 通过构造函数传递数据数据    public NovelBook(String name, int price, String author) {        this.name = name;        this.price = price;        this.author = author;    }    // 获取书名    public String getName() {        return this.name;    }    // 获取价格    public int getPrice() {        return this.price;    }    // 获取作者    public String getAuthor() {        return this.author;    }}

现在我们要给小说类书籍做一个活动，价格优惠。如果修改 NovelBook 中的 getPrice()方法，则会存在一定的风险，可能影响其他地方的调用结果。我们如何在不修改原有代码前提前下，实现价格优惠这个功能呢？现在，我们再写一个处理优惠逻辑的类，NovelDiscountBook 类（思考一下为什么要叫 NovelDiscountBook，而不叫 DiscountBook）：

/** * @author eamon.zhang * @date 2019-09-25 上午10:36 */public class NovelDiscountBook extends NovelBook {    public NovelDiscountBook(String name, int price, String author) {        super(name, price, author);    }    public double getOriginPrice(){        return super.getPrice();    }    public double getPrice(){        return super.getPrice() * 0.85;    }}

类结构图

cdn.nlark.com/yuque/0/2019/png/239945/1569379306123-5eb0d472-aa9f-425e-9908-000af06a0c9e.png">

依赖倒置原则

定义

依赖倒置原则（DependenceInversionPrinciple,DIP）是指设计代码结构时，高层模块不应该依赖底层模块，二者都应该依赖其抽象。抽象不应该依赖细节；细节应该依赖抽象。通过依赖倒置，可以减少类与类之间的耦合性，提高系统的稳定性，提高代码的可读性和可维护性，并能够降低修改程序所造成的风险。

实例

我们以阅读书籍为例，先创建一个 Eamon 类：

/** * @author eamon.zhang * @date 2019-09-25 上午11:09 */public class Eamon {    public void readNotreDame(){        System.out.println("Eamon 在阅读 《巴黎圣MU院》");    }    public void readTheOldManAndTheSea(){        System.out.println("Eamon 在阅读 《老人与海》");    }}

写个测试类调用一下：

public static void main(String[] args) {    Eamon eamon = new Eamon();    eamon.readNotreDame();    eamon.readTheOldManAndTheSea();}

Eamon 目前正在阅读者两本书。但是学习是无止境的，Eamon 读完这些书之后还想读《天龙八部》。这个时候，业务扩展，我们的代码要从底层到高层（调用层）一次修改代码。在 Eamon 类中添加 readTianLongBaBu()的方法，在高层也要追加调用。如此一来，系统发布以后，实际上是非常不稳定的，在修改代码的同时也会带来意想不到的风险。接下来我们优化代码，创建一个课程的抽象 IBook 接口：

/** * @author eamon.zhang * @date 2019-09-25 上午11:20 */public interface IBook {    void read();}

然后写NotreDameBook类：

/** * @author eamon.zhang * @date 2019-09-25 上午11:22 */public class NotreDameBook implements IBook {    public void read() {        System.out.println("Eamon 在阅读 《巴黎圣MU院》");    }}

再写 TheOldManAndTheSeaBook 类：

/** * @author eamon.zhang * @date 2019-09-25 上午11:23 */public class TheOldManAndTheSeaBook implements IBook{    public void read() {        System.out.println("Eamon 在阅读 《老人与海》");    }}

修改Eamon类

/** * @author eamon.zhang * @date 2019-09-25 上午11:09 */public class Eamon {    public void read(IBook iBook){        iBook.read();    }}

来看调用：

public static void main(String[] args) {    Eamon eamon = new Eamon();    eamon.read(new NotreDameBook());    eamon.read(new TheOldManAndTheSeaBook());}

我们这时候再看来代码，Eamon 再想读任何书，对于新书，我只需要新建一个类，通过传参的方式告诉 Eamon，而不需要修改底层代码。实际上这是一种大家非常熟悉的方式，叫依赖注入。注入的方式还有构造器方式和 setter 方式。我们来看构造器注入方式：

/** * @author eamon.zhang * @date 2019-09-25 上午11:09 */public class Eamon {    public Eamon(IBook iBook) {        this.iBook = iBook;    }    private IBook iBook;     public void read(){        iBook.read();    }}

看调用代码：

public static void main(String[] args) {    Eamon eamon = new Eamon(new NotreDameBook());    eamon.read();}

根据构造器方式注入，在调用时，每次都要创建实例。那么，如果 Eamon 是全局单例，则我们就只能选择用 Setter 方式来注入，继续修改 Eamon 类的代码：

/** * @author eamon.zhang * @date 2019-09-25 上午11:09 */public class Eamon {    private IBook iBook;    public void setBook(IBook iBook) {        this.iBook = iBook;    }    public void read(){        iBook.read();    }}

看调用代码：

public static void main(String[] args) {    Eamon eamon = new Eamon();    eamon.setBook(new NotreDameBook());    eamon.read();    eamon.setBook(new TheOldManAndTheSeaBook());    eamon.read();}