欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识!
您现在的位置是: 首页  >  IT编程

设计模式 - 七大设计原则(一)

程序员文章站 2024-01-26 20:49:28
设计模式 七大设计原则(一) 概述 简单介绍一下七大设计原则: 开闭原则:是所有面向对象设计的核心,对扩展开放,对修改关闭 依赖倒置原则:针对接口编程,依赖于抽象而不依赖于具体 单一职责原则:一个接口只负责一件事情,只能有一个原因导致类变化 接口隔离原则:使用多个专门的接口,而不是使用一个总接口 迪 ......

设计模式 - 七大设计原则(一)

概述

简单介绍一下七大设计原则:
开闭原则:是所有面向对象设计的核心,对扩展开放,对修改关闭
依赖倒置原则:针对接口编程,依赖于抽象而不依赖于具体
单一职责原则:一个接口只负责一件事情,只能有一个原因导致类变化
接口隔离原则:使用多个专门的接口,而不是使用一个总接口
迪米特法则(最少知道原则):只和朋友交流(成员变量、方法输入输出参数),不和陌生人说话,控制好访问修饰符
里氏替换原则:子类可以扩展父类的功能,但不能改变父类原有的功能
合成复用原则:尽量使用对象组合(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;
    }
}

类结构图

设计模式 - 七大设计原则(一)


依赖倒置原则

定义

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

实例

我们以阅读书籍为例,先创建一个 eamon 类:

/**
 * @author eamon.zhang
 * @date 2019-09-25 上午11:09
 */
public class eamon {
    public void readnotredame(){
        system.out.println("eamon 在阅读 《巴黎圣母院》");
    }

    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 在阅读 《巴黎圣母院》");
    }
}

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

最终类图

设计模式 - 七大设计原则(一)

切记:以抽象为基准比以细节为基准搭建起来的架构要稳定得多,因此大家在拿到需求之后,要面向接口编程,先顶层再细节来设计代码结构。

声明

文中部分内容参考网络!

封面图源网络,侵删!

内容为原创,转发请注明出处!