面向对象设计原则

深入浅出DDR系列(二)--DDR工作原理 学习完了DDR的基本组成和硬件结构原理之后,从整体上了解了DDR的特性和静态图,包括原理、管脚图等。那么本章就要从动态的角度来分析时序结构,包括read/write的整个过程到数据返回发生了什么,其中包括以下内容 DDR是如何完成Read、Write 等的操作 DDR的基本命令 DDR的时序参数 DDR的性能分析 1. DRAM基本组成 对于DRAM,其主要由行和列组成,每一个bit中都是由类似右下图的类晶体管的结构组成,对于sdram的数据,可以通过控制column和row就可以访问sd 阅读详情

一 Single Responsibility Principle——单一职责原则

核心思想: 一个类应该只有一个引起它变化的原因.

假设存在这样的设计. Rectangle类具有两个方法,一个方法是计算矩形的面积 , 另一个方法是把矩形绘制在屏幕上.

CaculateArea方法只会进行简单的数学运算,而Draw方法则调用GUI组件实现绘制矩形的功能. 显然,这个类就包含了两个不同的职责了. 那这样又会带来什么问题呢? 考虑这样一个场景:现在有一个几何学应用程序调用了这一个类,已便实现计算面积的功能,在这个程序中不需要用到绘制矩形的功能. 问题一:部署几何应用程序需要把GUI组件一同部署,而且这个组件根本没有使用到.问题二:对Rectangle类的改变,比如Draw方法改用另外一套GUI组件,必须对几何应用程序进行一次重新部署.

可见,一个类如果承担的职责过多,就等于把职责耦合在一起了,容易导致脆弱的设计,带来额外的麻烦. 在实际开发中, 业务规则的处理和数据持久化一般是不同时存在同一个类中的,业务规则往往会频繁地变化,而持久化的方式却不会经常性地变化.如果这两个职责混合在同一个类中,业务规则频繁变化导致类的修改,只调用持久化方法的类也必须跟着重新编译,部署的次数常常会超过我们希望的次数. 对业务规则和持久化任务的职责分离就是遵循单一职责原则的体现.

对上述Recangle类可进行这样的修改:

二 Open Closed Principle——开放封闭原则

核心思想:对扩展开放,对修改封闭.

"需求总是变化的." 拥抱变化似乎就是软件开发的真理之一. 经常会有这样令人沮丧的情景出现:新的需求来了,对不起,我的代码设计必须大幅度推倒重来. 设计的坏味道让我们深受其害,那么怎样的设计才能面对需求的改变却可以保持相对稳定呢?

针对这样的问题,OCP给了我们如下的建议:在发生变化的时候,不要修改类的源代码,要通过添加新代码来增强现有类的行为.

对扩展开放,对修改封闭,这两个特征似乎就是相互矛盾的. 通常观念来讲,扩展不就是修改源代码吗?怎么可能在不改动源代码的情况下去更改它的行为呢?

答案就是抽象(Interface 和 抽象基类).实现OCP的核心思想就是对抽象编程. 让类依赖于固定的抽象,对修改就是封闭的; 而通过面向对象的继承和多态机制,通过覆写方法改变固有行为,实现新的扩展方法,对于扩展就是开放的.

来看一个例子. 实现一个能够根据客户端的调用要求绘制圆形和长方形的应用程序. 初始设计如下:

View Code
复制代码
public class Draw
{
    public void DrawRectangle()
    {
        //绘制长方形
    }

    public void DrawCircle()
    {
        //绘制圆形
    }
}

public enum Sharp
{
    /// <summary>
    /// 长方形
    /// </summary>
    Rectangle ,

    /// <summary>
    /// 圆形
    /// </summary>
    Circle ,
}

public class DrawProcess
{
    private Draw _draw = new Draw();

    public void Draw(Sharp sharp)
    {
        switch (sharp)
        {
            case Sharp.Rectangle:
                _draw.DrawRectangle();
                break;
            case Sharp.Circle:
                _draw.DrawCircle();
                break;
            default:
                throw new Exception("调用出错!");
        }
    }
}

//调用代码
DrawProcess draw = new DrawProcess();
draw.Draw(Sharp.Circle);
复制代码

 现在的代码可以正确地运行. 一切似乎都趋近于理想. 然而,需求的变更总是让人防不胜防. 现在程序要求要实现可以绘制正方形. 在原本的代码设计下,必须做如下的改动.

View Code
复制代码
//在Draw类中添加
public void DrawSquare()
{
     //绘制正方形
}

//在枚举Sharp中添加
 /// <summary>
 /// 正方形
 /// </summary>
 Square ,

//在DrawProcess类的switch判断中添加
case Sharp.Square:
     _draw.DrawSquare();
     break;
复制代码

 需求的改动产生了一系列相关模块的改动,设计的坏味道悠然而生. 现在运用OCP, 来看一下如何对代码进行一次重构.

View Code
复制代码
/// <summary>
/// 绘制接口
/// </summary>
public interface IDraw
{
    void Draw();
}

public class Circle:IDraw
{
    public void Draw()
    {
        //绘制圆形
    }
}

public class Rectangle:IDraw
{
    public void Draw()
    {
        //绘制长方形
    }
}

public class DrawProcess
{
    private IDraw _draw;

    public IDraw Draw { set { _draw = value; } }
    
    private DrawProcess() { }

    public DrawProcess(IDraw draw)
    {
        _draw = draw;
    }

    public void DrawSharp()
    {
        _draw.Draw();
    }
} 


//调用代码
IDraw circle = new Circle();
DrawProcess draw = new DrawProcess(circle);
draw.DrawSharp();
复制代码

假如现在需要有绘制正方形的功能,则只需添加一个类Square 即可.

View Code
复制代码
public class Square:IDraw
{
    public void Draw()
    {
        //绘制正方形
    }
}
复制代码

只需新增加一个类且对其他的任何模块完全没有影响,OCP出色地完成了任务.

如果一开始就采用第二种代码设计,在需求的暴雨来临时,你会欣喜地发现你已经到家了, 躲过了被淋一身湿的悲剧. 所以在一开始设计的时候,就要时刻地思考,根据对应用领域的理解来判断最有可能变化的种类,然后构造抽象来隔离那些变化. 经验在这个时候会显得非常宝贵,可能会帮上你的大忙.

OCP很美好,然而绝对的对修改关闭是不可能的,都会有无法对之封闭的变化. 同时必须清楚认识到遵循OCP的代价也是昂贵的,创建适当的抽象是要花费开发时间和精力的. 如果滥用抽象的话,无疑引入了更大的复杂性,增加维护难度.

三 Liskov Subsitution Principle——里氏替换原则

核心思想: 子类必须能够替换掉它们的父类型.

考虑如下情况: 

View Code
复制代码
public class ProgrammerToy
{
    private int _state;

    public  int State
    {
        get { return _state; }
    }

    public virtual void SetState(int state)
    {
        _state = state;
    }
}

public class CustomProgrammerToy:ProgrammerToy
{
    public override void SetState(int state)
    {
        //派生类缺乏完整访问能力,即无法访问父类的私有成员_state
        //因此该类型也许不能完成其父类型能够满足的契约
    }
} 




//控制台应用程序代码
class Program
{
    static void Main(string[] args)
    {
        ProgrammerToy toy = new CustomProgrammerToy();
        toy.SetState(5);
        Console.Write(toy.State.ToString());
    }
}
复制代码

从语法的角度来看, 代码没有任何问题. 不过从行为的角度来看 , 二者却存在不同. 在使用CustomProgrammerToy替换父类的时候, 输出的是0而不是5, 与既定的目标相差千里. 所以不是所有的子类都能安全地替换其父类使用. 

前面谈到的开发封闭原则和里氏替换原则存在着密切的关系. 实现OCP的核心是对抽象编程, 由于子类型的可替换性才使得使用父类类型的模块在无需修改的情况下就可以扩展, 所以违反了里氏替换原则也必定违反了开放封闭原则.

庆幸的是, 里氏替换原则还是有规律可循的.父类尽可能使用接口或抽象类来实现,同时必须从客户的角度理解,按照客户程序的预期来保证子类和父类在行为上的相容.

四 InterFace Segregation Principle——接口隔离原则

核心思想:使用多个小的专门的接口,而不要使用一个大的总接口.

直接来看一个例子: 假设有一个使用电脑的接口

            

程序员类实现接口IComputerUse, 玩游戏,编程,看电影, 多好的事情.

现在有一个游戏发烧友,他也要使用电脑, 为了重用代码 , 实现OCP, 他也实现接口IComputerUse

 

看出什么问题了吗? GamePlayer PlayGame无可厚非,WatchMovies小消遣, 但要编程干什么?

这就是胖接口带来的弊端,会导致实现的类必须完全实现接口的所有方法, 而有些方法对客户来说是无任何用处的,在设计上这是一种"浪费". 同时,如果对胖接口进行修改, 比如程序员要使用电脑配置为服务器, 在IComputerUse上添加Server方法, 同样GamePlayer也要修改(这种修改对GamePlayer是毫无作用的),是不是就引入了额外的麻烦?

所以应该避免出现胖接口,要使接口实现高内聚(高内聚是指一个模块中各个部分都是为完成一项具体功能而协同工作,紧密联系,不可分割). 当出现了胖接口,就要考虑重构.优先推荐的方法是使用多重继承分离,即实现小接口.

将IComputerUse拆分为IComputerBeFun和IComputerProgram, Progammer类则同时实现IComputerBeFun和IComputerProgram接口,现在就各取所需了.

与OCP类似, 接口也并非拆分地越小越好, 因为太多的接口会影响程序的可读性和维护性,带来难以琢磨的麻烦. 所以设计接口的时刻要着重考虑高内聚性, 如果接口中的方法都归属于同一个逻辑划分而协同工作,那么这个接口就不应该再拆分.

五 Dependency Inversion Principle——依赖倒置原则

核心思想: 高层模块不应该依赖底层模块,两者都应该依赖抽象。抽象不应该依赖细节,细节应该依赖抽象。

当一个类A存在指向另一个具体类B的引用的时候,类A就依赖于类B了。如:

View Code
复制代码
/// <summary>
/// 商品类
/// </summary>
public class Product
{
    public int Id { get; set; }
}

/// <summary>
/// 商品持久化类
/// </summary>
public class ProductRepository
{
    public IList<Product> FindAll()
    {
        //假设从SQL Server数据库中获取数据
        return null;
    }
}

/// <summary>
/// 商品服务类
/// </summary>
public class ProductService
{
    private ProductRepository _productRepository;

    public IList<Product> GetProducts()
    {
        _productRepository = new ProductRepository();

        return _productRepository.FindAll();
    }
}
复制代码

 (在前面单一职责原则中有提到,业务逻辑处理和对象持久化分属两个职责,所以应该拆分为两个类。)高层模块ProductService类中引用了底层模块具体类ProductRepository,所以ProductService类就直接依赖于ProductRepository了。那么这样的依赖会带来什么问题呢?

"需求总是那么不期而至"。原本ProductRepository是从SQL Server数据库中读存数据,现在要求从MySQL数据库中读存数据。由于高层模块依赖于底层模块,现在底层模块ProductRepository发生了更改,高层模块ProductService也需要跟着一起修改,回顾之前谈到的设计原则,这是不是就违反了OCP呢?OCP的核心思想是对抽象编程,DIP的思想是依赖于抽象,这也让我们更清楚地认识到,面向对象设计的时候,要综合所有的设计原则考虑。DIP给出了解决方案:在依赖之间定义一个接口,使得高层模块调用接口,而底层模块实现接口,以此来控制耦合关系。(在上面OCP的例子中,也是使用了这一个方法。)所以可以对代码做如下的重构:

View Code
复制代码
/// <summary>
/// 商品持久化接口
/// </summary>
public interface IProductRepository
{
    List<Product> FindAll();
}

/// <summary>
/// 商品持久化类
/// </summary>
public class ProductRepository:IProductRepository
{
    public IList<Product> FindAll()
    {
        //假设从SQL Server数据库中获取数据
        return null;
    }
}

/// <summary>
/// 商品服务类
/// </summary>
public class ProductService
{
    private IProductRepository _productRepository;

    private ProductService() { }

    //使用构造函数依赖注入
    public ProductService(IProductRepository productRepository)
    {
        _productRepository = productRepository;
    }

    public IList<Product> GetProducts()
    {
        return _productRepository.FindAll();
    }
}
复制代码

现在已对变化进行了抽象隔离,再根据OCP,我相信实现从MySQL数据库中读存数据的需求已经可以被轻松地解决掉了。

EUV光源技术路线深度解析 EUV光刻技术的关键瓶颈在于13.5纳米光源的稳定高效获取。主流技术路线从DPP放电等离子体发展为LPP激光等离子体方案,后者通过激光轰击锡液滴实现更高功率输出。新出现的LDP技术综合激光预热与放电优势,虽功率扩展性有限,但为光源技术提供了有益补充。目前LPP仍是唯一通过量产验证的方案,而LDP可能作为过渡技术应用于特定场景。EUV光源的发展实质是能量转化效率与系统可靠性的持续优化过程,各种技术路线的探索共同推动着这一核心工艺的进步。 阅读详情

相关推荐

【01】Canoe零基础手把手教学 --- Canoe安装

Canoe零基础手把手教学

jaytinlove的博客 7793

面向对象设计模式5大基本原则

“宇宙万物之中,没有一样东西能像思想那么顽固。” 一爱默生 首先明确模式是针对面向对象的,它的三大特性,封装、继承、多态。 面向对象设计模式有5大基本原则:单一职责原则、开发封闭原则、依赖倒置原则、接口隔离原则、Liskov替换原则。 而设计模式都是在面向对象的特性以及5大基本原则的基础上衍生而来的具体实现。 1、单一职责原则(SRP):   1.1,SRP(Single Responsibilities Principle)的定义:就一个类而言,应该仅有一个引起它变化的原...

LQ19900221的博客 4326

Bertopic库安装(二)

Bertopic库安装

weixin_43392789的博客 4896

面向对象设计的五大基本原则

通过这些代码示例,可以更直观地理解如何将 SOLID 原则落地到实际项目中。:修改存储或权限逻辑时,只需调整对应类,无需影响。:新增支付方式只需添加新类,无需修改已有代码。:通过抽象基类定义公共行为,子类自行实现逻辑。:若数据库表结构或权限规则变化,需频繁修改。:新增支付方式需修改原有类,可能引入风险。:客户端被迫依赖不需要的方法(如。:客户端只需依赖实际需要的接口。)与日志实现解耦,便于扩展。:切换日志存储方式需修改。

zhaoyepeng290643的博客 1089

为什么你的ESXI无法识别移动硬盘?一步步教你解决USB存储挂载问题

本文深入解析了ESXi无法识别移动硬盘的根本原因,并提供了从诊断到解决的完整方案。核心在于理解ESXi的USB Arbitrator服务机制,通过检查服务状态、内核设备识别及分区表,逐步定位问题。文章详细指导了如何禁用USB仲裁服务以在主机挂载USB存储,或将其直通给虚拟机,并针对大容量硬盘、USB 3.0兼容性等进阶问题给出了实用建议。

qq_27496129的博客 332

COMSOL仿真避坑指南:列管反应器模拟中多孔介质与化学反应设置的5个常见错误

本文详细解析了COMSOL仿真中列管反应器模拟的5个常见错误,包括多孔介质模型选择、化学反应接口配置、对流扩散方程处理、薄层热阻设置及网格独立性验证。特别针对多孔介质与化学反应设置的误区,提供了实用的判断标准和修正方法,帮助工程师避免计算偏差,提升仿真精度。

weixin_29597551的博客 325

面向对象的五大基本原则

面向对象的五大基本原则

泡^泡 3042

STM32单片机入门学习(六)-光敏传感器控制LED

光敏传感模块一DO端接B13,GND接GND,VCC接VCC,AO不接。LED负极接B12,正极接VCC。

指尖魔法师 4368

面向对象编程中的五大设计原则-----常看

面向对象的五大设计原则

mankeywang的博客 635

LVGL字体优化实战:如何将中文字库放到外部SPI Flash并动态加载(节省内部RAM)

本文详细介绍了LVGL在嵌入式UI开发中如何通过外部SPI Flash存储中文字库并动态加载,以节省内部RAM资源。通过对比不同存储介质和字库格式,提供多种实现方案及性能优化技巧,帮助开发者在资源受限设备上实现高效的中文显示。

weixin_28693683的博客 348

带你一分钟了解电感与磁珠的区别

在电路设计中会经常使用到电感和磁珠,虽然在电路中的作用有所不同,但它们都属于磁性电子元器件,本文简单介绍下电感和磁珠的区别电感和磁珠电感和磁珠的结构主要由磁性材料金属线圈和外壳组成,具体结构如下图所示:电感磁珠结构图电感其实是金属线圈缠绕在磁芯上,而磁珠是在内部折叠后外围包裹着铁氧体磁性材料。电感器(Inductor)又称扼流器、电抗器、动态电抗器是储能器件,能够把电能转化为磁能而存储起来的元件。磁珠则是能量转换(消耗)器件,将流过他的高频信号以热能的形式消耗掉。

攻城狮鹏哥 1410

面向对象设计的五大原则(SOLID 原则)

面向对象设计的五大原则(SOLID 原则)是指导我们设计可维护、灵活且易扩展的面向对象系统的核心准则。这些原则帮助开发者避免常见的设计陷阱,使代码更具可读性和可维护性。

alittlefish1的博客 1841

Mac mini M2 部署 OpenClaw:最稳 7×24 本地 AI 服务器

Mac mini M2 凭借其强大的 M2 芯片、低功耗和静音特性,成为部署 OpenClaw AI 服务器的理想平台。本文详细介绍了从系统配置到 OpenClaw 部署的全过程,包括 Docker 环境搭建、docker-compose 编排、性能优化方案以及开机自启设置。通过统一内存架构和高效 SSD,M2 版 Mac mini 在 AI 推理速度上显著优于前代产品,同时保持极低的功耗(仅 8W),适合 7×24 小时稳定运行。部署方案充分利用了容器化技术,确保了服务的可靠性和可维护性。

一键难忘的博客 2955

面向对象的编码设计原则

10之前谈DDD时提及过当下很多标榜面向对象的语言,却是以面向过程来实现的问题。这里就从编码设计的角度来顺一下面向对象设计的一些思维。其实就像我正在梳理的设计模式一样,都是些老生常谈的东西,可是往往在实践的时候,这些老生常谈的东西会被“反刍”,总会有种常看常新的感觉。1。

sdgfafg_25的博客 1414

visio安装包

Microsoft Office Visio 是一款专业的制图软件。利用经过更新的形状、协作工具和数据链接图表,创建专业级图表以简化复杂的信息。

IEM模型,地表粗糙度模拟

利用微波反演土壤水分时候,利用IEM模型可以实现对随机地表的模拟

面向对象设计原则概述

对于面向对象软件系统的设计而言,在支持可维护性的同时,提高系统的可复用性是一个至关重要的问题,如何同时提高一个软件系统的可维护性和可复用性是面向对象设计需要解决的核心问题之一。在面向对象设计中,可维护性的复用是以设计原则为基础的。每一个原则都蕴含一些面向对象设计的思想,可以从不同的角度提升一个软件结构的设计水平。       面向对象设计原则为支持可维护性复用而诞生,这些原则蕴含在很多设计模式中

刘伟技术博客 4万+

Camera2Demo

在Camera2 的基础上进行封装,使得Camera2一堆初始化逻辑与Activity分离,降低耦合度,完成预览拍照并保存的操作

面向对象十大设计原则

事实上,KISS 原则是较为广泛的原则,譬如其应用在建筑上面叫做轻奢,而应用在手机设计上面叫做极简风,他们所遵循的都是简单原则。那么在编程中的 KISS 原则,具体讲的是什么的简单呢?可能有人对此做严格定义,代码行数少的、或者说逻辑简单的,就是符合KISS 原则。但实际上,KISS 原则和之前的设计原则一样,都是。

angus52630的博客 1190

VC中sqlite的使用

在VC中对sqlite的使用,实现数据库大批数据的快速插入,读取数据库中的数据在ListCtrl中显示

面向对象的七大设计原则

经艺术设计过的接口,就像蝴蝶一样在指尖翩翩起舞,令人沉醉....

2302_80067378的博客 2177

[OOP] 面向对象设计原则

面向对象六大设计原则: 单一职责原则 SRP:Single Responsibility Principle 里氏替换原则 LSP:Liskov SubStitution Principle 依赖倒置原则 DIP:Dependency Inversion Principle 接口分离原则 ISP:Interface Segregation Principle 最小知识原则 LKP:Least Knowledge Principle 开闭原则 OCP:Open-Close Principle

米碎师兄 698

[C++设计模式] 深入理解面向对象设计原则

深入理解面向对象的设计,简略讲解关于面向对象的设计原则。

kevin_blog 1349

面向对象的设计原则

强烈推荐一个大神的人工智能的教程:http://www.captainbed.net/zhanghan 作为一个学编程的新手,总是习惯于将所有的代码写在一个窗体里,在想复用的时候几乎就是不可能!这在以后的维护过程中将是一个令人头疼的事情,所以编程有一个好的习惯是“高内聚、低耦合”,我的理解是:类内部联系紧密,类与类之间的联系要松,就是松耦合。21世纪是什么时代?是一个...

至尊宝 2万+

面向对象设计原则 - 详解

面向对象设计原则有助于我们构建灵活、可维护的系统。理解并应用这些原则可以帮助开发者在设计复杂系统时作出更好的决策,减少错误,增加代码的复用性。每个原则解决特定的问题,并为设计提供了一个明确的方向。通过实际的代码示例,可以更好地理解这些原则在实际开发中的应用。

weixin_48113275的博客 1027

面向对象编程的设计原则与实践

1.背景介绍 面向对象编程(Object-Oriented Programming, OOP)是一种编程范式,它将计算机程序的实体(entity)模型为对象(object),将其行为(behavior)模型为消息传递(message passing)。这种编程范式强调“继承”(inheritance)、“多态”(polymorphism)和“封装”(encapsulation)等概念。 面向对...

AI天才研究院 1144
上一篇: 网易邮箱前端技术分享之javascript编码规范(二)类规范
下一篇: JavaScript 组合模式
esocket
博客等级 码龄19年 1粉丝 4原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值