Solid 原则

合集下载

Solid-原则

Solid-原则

开闭原则的讨论
软件实体应该是可扩展,而不可修改的。也就是说,对扩展是 开放的,而对修改是封闭的。这个原则是诸多面向对象编程原 则中最抽象、最难理解的一个。
对扩展开放,意味着有新的需求或变化时,可以对现有代码进 行扩展,以适应新的情况。
对修改封闭,意味着类一旦设计完成,就可以独立完成其工作, 而不要对类进行任何修改。
SOLID
I 接口隔离原则 :接口隔离原则 认为“多个特 定客户端接口要好于一个宽泛用途的接口”的 概念。
SOLID
D 依赖反转原则: 依赖反转原则 认为一个方 法应该遵从“依赖于抽象而不是一个实例” 的概念。依赖注入是该原则的一种实现方式。
单一功能原则的讨论
当需要修改某个类的时候原因有且只有一个(THERE SHOULD NEVER BE MORE THAN ONE REASON FOR A CLASS TO CHANGE)。换句话说就是让一个类只做一种类 型责任,当这个类需要承担其他类型的责任的时候,就需要分解这个类。在所有 的SOLID原则中,这是大多数开发人员感到最能完全理解的一条。严格来说,这也 可能是违反最频繁的一条原则了。 单一责任原则可以看作是低耦合、高内聚在面向对象原则上的引申,将责任定义 为引起变化的原因,以提高内聚性来减少引起变化的原因。责任过多,可能引 起 它变化的原因就越多,这将导致责任依赖,相互之间就产生影响,从而极大的损 伤其内聚性和耦合度。单一责任,通常意味着单一的功能,因此不要为一个模块 实 现过多的功能点,以保证实体只有一个引起它变化的原因。
于是,问题变为:"那么,如果我需要修改这个基类的工作方式,那应当怎么 做呢?"OCP的另一部分中给出这一答案;基类应当开放,可进行扩充。在这 里,扩充是指创建一个由此基类继承而来的派生类,它可以扩充或重载基类 功能,以提供使用者所需要的特定功能。这样,使用者就能使用类的修改版 本,而不会影响到类的其他使用者。使用者还可以在将来更轻松地使用基类 的升级版本,因为他们不用担心丢失自己的修改内容。

altium designer 中的铺铜 solid、hatched的选用原则

altium designer 中的铺铜 solid、hatched的选用原则

在Altium Designer中,铺铜的选用原则主要基于以下因素:
电路板信号频率:如果电路板信号频率较高,通常建议使用Hatched模式,因为这种模式可以更好地抑制高频信号的干扰。

电路板大小和形状:如果电路板较小,形状较为复杂,建议使用Solid模式,因为这种模式可以更好地填充不规则形状的区域。

电路板接地设计:如果电路板的接地设计较为复杂,建议使用Hatched模式,因为这种模式可以在不连接的区域提供更好的隔离。

电路板布线需求:如果电路板的布线需求较高,建议使用Solid模式,因为这种模式可以更好地控制布线走向和连接点位置。

综上所述,在Altium Designer中铺铜的选用原则主要基于电路板信号频率、电路板大小和形状、电路板接地设计和电路板布线需求等因素进行综合考虑。

在具体的实践中,还需要根据具体情况进行试验和调整,以达到最佳的电路性能和可靠性。

软件设计6大原则

软件设计6大原则

软件设计6大原则软件设计的六大原则是一组指导性原则,有助于开发高质量、易维护和可扩展的软件系统。

这些原则有时被称为"SOLID"原则,其中"SOLID"是每个原则的首字母缩写。

以下是这六大原则:1.单一职责原则(Single Responsibility Principle - SRP):每个类或模块应该具有单一的职责,即一个类应该只有一个改变的理由。

这有助于确保代码的清晰性和可维护性。

2.开闭原则(Open/Closed Principle - OCP):软件实体(类、模块、函数等)应该对扩展开放,对修改关闭。

这意味着应该能够通过添加新的代码来扩展系统功能,而不是修改现有的代码。

3.里氏替换原则(Liskov Substitution Principle - LSP):子类应该能够替代其基类,而不会引发错误或破坏程序的正确性。

这确保了继承体系的正确性和一致性。

4.接口隔离原则(Interface Segregation Principle - ISP):不应该强迫客户端依赖它们不使用的接口。

接口应该小而专一,以满足特定的客户端需求。

5.依赖反转原则(Dependency Inversion Principle - DIP):高级模块不应该依赖于低级模块,两者都应该依赖于抽象。

此外,抽象不应该依赖于细节,细节应该依赖于抽象。

这鼓励使用依赖注入和接口来解耦组件。

6.迪米特法则(Law of Demeter - LoD):一个对象应该与其相关的直接朋友交互,而不应该与陌生的对象交互。

这有助于减少耦合性,提高系统的模块化程度。

这些原则在面向对象编程和软件设计中非常有用,有助于创建可维护、灵活和高质量的代码。

它们通常被视为良好的编程实践,有助于避免常见的设计缺陷和问题。

当软件工程师遵循这些原则时,他们更有可能开发出具有良好结构的软件系统。

软件建模与设计知识点总结

软件建模与设计知识点总结

软件建模与设计知识点总结软件建模与设计是软件开发过程中非常重要的一环,它涉及了软件系统的整体结构和功能组成,是构建高质量软件的基础。

本文将对软件建模与设计中的一些重要知识点进行总结,以帮助读者更好地理解和应用这些知识。

一、软件建模软件建模是指通过不同的建模技术和方法,对软件系统的需求、结构和行为进行抽象和描述。

以下是几种常见的软件建模技术:1. UML(统一建模语言)UML是一种用于软件建模的标准化语言,提供了一套用于描述和设计软件系统的图形化符号和建模技术。

常用的UML图包括用例图、类图、序列图、状态图等,每种图形都有特定的用途和表达能力,可以帮助开发人员更好地理解和描述软件系统的不同方面。

2. 数据流图数据流图是一种描述软件系统功能流程的图形化工具。

它以数据流和处理过程为核心元素,将系统中的功能模块和数据流之间的关系进行可视化表示。

数据流图能够清晰地展示软件系统的输入、输出、处理过程以及数据流之间的相互关系,有助于分析和设计系统的功能和过程流程。

3. 状态转换图状态转换图是一种描述系统状态变化和状态转换关系的图形工具。

它通过定义系统的不同状态以及触发状态转换的条件和动作,可以描述系统在不同条件下的行为和响应。

状态转换图能够帮助开发人员理清系统的状态变化规则,从而更好地设计系统的状态转换逻辑。

二、软件设计软件设计是在建模的基础上,根据软件系统的需求和建模结果,进行系统的详细设计和组织架构的过程。

以下是几个常用的软件设计原则和方法:1. 设计原则:SOLID原则SOLID原则是面向对象设计中的五个基本原则,分别是单一职责原则、开闭原则、里氏替换原则、接口隔离原则和依赖倒置原则。

这些原则旨在指导开发人员设计出符合高内聚低耦合的软件系统结构,提高软件的维护性、扩展性和可复用性。

2. 设计模式设计模式是在软件设计中反复出现的问题和解决方案的总结和归纳。

常见的设计模式包括单例模式、工厂模式、观察者模式等,每种模式都为特定的设计问题提供了一种优雅和可重复使用的解决方案。

六大设计原则超详细介绍

六大设计原则超详细介绍

六大设计原则超详细介绍软件设计最大的难题就是应对需求的变化,但是纷繁复杂的需求变化又是不可预料的,我们要为不可预料的变化做好准备,这本身是一件非常痛苦的事情,但好在有大师们已经给我们提出了非常好的六大设计原则和23种设计模式来“封装”未来的变化。

本文只针对六大设计原则进行介绍,设计模式放在后面的文章进行详解。

六大设计原则六大设计原则主要是指:单一职责原则(Single Responsibility Principle);开闭原则(Open Closed Principle);里氏替换原则(Liskov Substitution Principle);迪米特法则(Law of Demeter),又叫“最少知道法则”;接口隔离原则(Interface Segregation Principle);依赖倒置原则(Dependence Inversion Principle)。

把这6个原则的首字母(里氏替换原则和迪米特法则的首字母重复,只取一个)联合起来就是:SOLID(稳定的),其代表的含义也就是把这6个原则结合使用的好处:建立稳定、灵活、健壮的设计。

单一职责原则单一职责原则的定义是:应该有且仅有一个原因引起类的变更。

没错,单一职责原则就这一句话,不懂没关系,我们举个例子。

我们以打电话为例,电话通话的时候有4个过程发生:拨号、通话、回应、挂机。

那我们写一个接口,类图如下:代码为:我们看这个接口有没有问题?相信大部分同学会觉得没问题,因为平常我们就是这么写的。

没错,这个接口接近于完美,注意,是“接近”。

单一职责原则要求一个接口或一个类只能有一个原因引起变化,也就是一个接口或者类只能有一个职责,它就负责一件事情,看看上面的接口只负责一件事情吗?明显不是。

IPhone这个接口包含了两个职责:协议管理和数据传送。

dial和hangup这两个方法实现的是协议管理,分别负责拨号接通和挂机,chat方法实现的是数据传送。

《架构整洁之道》读书笔记(三)

《架构整洁之道》读书笔记(三)

《架构整洁之道》读书笔记(三)1、整洁架构常见系统架构,六边形架构(端⼝与适配器架构)、DCI架构、BCE架构。

共同设计⽬标:按照不同关注点对软件进⾏切割。

核⼼点:分层 + 依赖规则分析:1、分层:关注点分离思想分层:这些架构都会将软件切割成不同的层,⾄少有⼀个层是只包含软件的业务逻辑的,⽤户接⼝、系统接⼝属于其他层。

2、依赖规则代码依赖只能使由外向内,内层结构的代码不能包含有任何外层结构的信息1、越靠近圆⼼即越是稳定的,即代表⾼层策略,越外围表⽰是低层组件,2、依赖⽅式:从图中也可以看出,低层组件依赖⾼层组件(策略)3、业务实体层:包含业务实体,即应⽤的业务对象,封装最通⽤最⾼层的业务逻辑(单独某个业务实体的逻辑),它不应该受外界影响4、⽤户⽤例层:实现⽤户某个⽤例场景的业务逻辑封装,是对业务实体的组装、封装5、接⼝适配层:⽬的是进⾏数据的交换,包含有⽹关、控制器、展⽰器,如:实体层和⽤户实例层使⽤的数据转化成为持久层能使⽤的数据,⽐如数据库6、框架与驱动层:包含数据库、⽤户界⾯、web框架等每⼀种架构⼀定能在写系统的业务逻辑的时候有以下特征:1、与框架分离:系统架构不依赖于某个功能丰富的框架中的某个函数,框架被当作⼯具使⽤,不需要让让系统来适应框架。

2、可测试性:系统的业务逻辑可以脱离UI、数据库、Web服务及其他外部元素来测试。

3、与UI分离:UI必须能⾮常容易独⽴地修改。

⽽不能在改变UI的同时需要改变系统其他部分。

⽐如当把系统的UI从Web UI改成控制台UI,你并不需要改变任何业务逻辑的代码。

4、与数据库分离:能很⽅便地在Oracle,SQL Server,Mongo DB,BigTable,CouchDB或者其他数据库中进⾏切换和改变。

业务逻辑决不能依赖这些数据库。

个⼈思考:⽬前公司⼀直使⽤某种数据库,这个在⼀定时间内改变的可能性⽐较⼩!5、与外部结构分离:系统的业务逻辑并不需要知道任何外部的结构。

软件工程的七条原则

软件工程的七条原则

软件工程中有许多原则和最佳实践,用于指导软件开发过程,提高软件质量、可维护性和可重用性。

以下是七条常见的软件工程原则:1. KISS原则(Keep It Simple, Stupid):保持简单原则。

即在设计和开发过程中,尽量保持简单,避免过度复杂化。

简单的设计更易于理解、维护和扩展。

2. DRY原则(Don't Repeat Yourself):不要重复自己原则。

即在代码中避免重复的逻辑或功能,尽量通过抽象和模块化来实现代码的重用。

3. YAGNI原则(You Ain't Gonna Need It):你不会需要它原则。

即在开发过程中不要过度设计,只关注当前需求,不要添加不必要的功能,以避免浪费时间和资源。

4. SOLID原则:SOLID是一组面向对象设计的五个原则的首字母缩写,分别是:单一职责原则(Single Responsibility Principle):一个类应该只有一个引起变化的原因。

开放封闭原则(Open/Closed Principle):软件实体应该是可扩展的,但不可修改的。

里氏替换原则(Liskov Substitution Principle):子类应该能够替换父类,而不会影响程序的正确性。

接口隔离原则(Interface Segregation Principle):多个专门的接口比一个通用的接口要好。

依赖反转原则(Dependency Inversion Principle):高层模块不应该依赖低层模块,二者都应该依赖抽象。

5. 面向对象原则:面向对象编程的原则包括封装、继承、多态。

封装将数据和操作封装在一个对象中,继承通过继承机制实现代码重用,多态通过子类的多态性来实现动态绑定。

6. 高内聚低耦合:高内聚指模块内部的元素彼此关联紧密,低耦合指模块与模块之间的关联尽可能松散。

这样的设计有助于提高模块的独立性和可维护性。

7. 面向测试编程(Test-Driven Development, TDD):先写测试用例,然后再编写代码使其通过测试。

java里氏替换原则举例说明

java里氏替换原则举例说明

java里氏替换原则举例说明Java里氏替换原则是SOLID原则中的一条,指任何基类可以出现的地方,子类一定可以出现。

也就是说,子类可以扩展父类的功能,但不能改变父类原有的功能。

下面列举十个例子来说明Java里氏替换原则:1. 父类为图形类,子类为矩形、圆形等具体形状类,子类可以重写父类计算面积的方法,但不能改变计算面积的方式。

2. 父类为动物类,子类为猫、狗等具体动物类,子类可以重写父类发出叫声的方法,但不能改变叫声的类型。

3. 父类为食品类,子类为水果、蔬菜等具体食品类,子类可以重写父类获取营养成分的方法,但不能改变营养成分的计算方式。

4. 父类为人类,子类为男人、女人等具体人类,子类可以重写父类的生育能力方法,但不能改变生育的方式。

5. 父类为汽车类,子类为轿车、卡车等具体汽车类,子类可以重写父类的驾驶方法,但不能改变驾驶的基本操作。

6. 父类为数据库类,子类为MySQL、Oracle等具体数据库类,子类可以重写父类的连接方法,但不能改变连接数据库的方式。

7. 父类为动态语言类,子类为JavaScript、Python等具体动态语言类,子类可以重写父类的变量声明方式,但不能改变变量的基本类型。

8. 父类为水果类,子类为苹果、香蕉等具体水果类,子类可以重写父类获取价格的方法,但不能改变价格的计算方式。

9. 父类为人类,子类为成年人、儿童等具体人类,子类可以重写父类的语言交流方法,但不能改变语言的基本规则。

10. 父类为数学类,子类为加法、减法等具体数学类,子类可以重写父类的运算方法,但不能改变运算的基本规则。

以上是关于Java里氏替换原则的十个例子,通过这些例子可以更好的理解Java里氏替换原则的具体应用。

在实际开发中,遵循这个原则可以提高代码的可维护性和可扩展性,减少代码的重复和冗余,提高代码的质量和效率。

  1. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。

依赖反转原则


依赖倒臵原则(Dependency Inversion Principle,DIP)规定:代码应当取决 于抽象概念,而不是具体实现。 高层模块不应该依赖于低层模块,二者都应该依赖于抽象 抽象不应该依赖于细节,细节应该依赖于抽象 类可能依赖于其他类来执行其工作。但是,它们不应当依赖于该类的特定 具体实现,而应当是它的抽象。这个原则实在是太重要了,社会的分工化, 标准化都 是这个设计原则的体现。显然,这一概念会大大提高系统的灵 活性。如果类只关心它们用于支持特定契约而不是特定类型的组件,就可 以快速而轻松地修改这些低级 服务的功能,同时最大限度地降低对系统 其余部分的影响。 本原则的应用: 举个例子,墙面的开关不应该依赖于电灯的开关实现,而是应该依赖于一 个抽象的开关的标准接口,这样,当我们扩展程序的时候,我们的开关同 样可以控制 其它不同的灯,甚至不同的电器。也就是说,电灯和其它电 器继承并实现我们的标准开关接口,而我们的开关产商就可不需要关于其 要控制什么样的设备,只需要关 心那个标准的开关标准。这就是依赖倒 臵原则。这就好像浏览器并不依赖于后面的web服务器,其只依赖于HTTP 协议。
SOLID

S 单一功能原则 :单一功能原则 认为对象应 闭原则 :开闭原则 认为“软件体应该是 对于扩展开放的,但是对于修改封闭的”的概 念。
SOLID

L 里氏替换原则 :里氏替换原则 认为“程序 中的对象应该是可以在不改变程序正确性的前 提下被它的子类所替换的”的概念。



开闭原则的讨论


OCP的要点在于:作为开发人员,别人偶尔会向我们提供基类,偶尔也会为其 他开发人员生成基类框架,供其使用。这些使用者应当仅能使用这些基类, 但 不能对其进行修改。这一点是必要的,因为其他使用者也可能依赖于由基 类提供的功能。如果允许使用者修改这些基类,可能会导致连锁反应,不仅 会影响到应用程 序中的各方面,还会影响到企业内的应用程序。还有一个问 题,使用者有时可能会收到基类的升级版本。使用者在升级之前,必须找出 一种方法用来处理其对该基类 先前版本中所做的自定义。 于是,问题变为:"那么,如果我需要修改这个基类的工作方式,那应当怎么 做呢?"OCP的另一部分中给出这一答案;基类应当开放,可进行扩充。在这 里,扩充是指创建一个由此基类继承而来的派生类,它可以扩充或重载基类 功能,以提供使用者所需要的特定功能。这样,使用者就能使用类的修改版 本,而不会影响到类的其他使用者。使用者还可以在将来更轻松地使用基类 的升级版本,因为他们不用担心丢失自己的修改内容。 本原则的应用: 对于面向对象来说,需要你依赖抽象,而不是实现,23个经典设计模式中的 “策略模式”就是这个实现。对于非面向对象编程,一些API需要你传入一个 你可以扩展的函数,比如我们的C语言的qsort()允许你提供一个“比较器”, STL中的容器类的内存分配,ACE中的多线程的各种锁。对于软件方面,浏览 器的各种插件属于这个原则的实践。
SOLID

I 接口隔离原则 :接口隔离原则 认为“多个特 定客户端接口要好于一个宽泛用途的接口”的 概念。
SOLID

D 依赖反转原则: 依赖反转原则 认为一个方 法应该遵从“依赖于抽象而不是一个实例” 的概念。依赖注入是该原则的一种实现方式。
单一功能原则的讨论


当需要修改某个类的时候原因有且只有一个(THERE SHOULD NEVER BE MORE THAN ONE REASON FOR A CLASS TO CHANGE)。换句话说就是让一个类只做一种 类型责任,当这个类需要承担其他类型的责任的时候,就需要分解这个类。在所 有的SOLID原则中,这是大多数开发人员感到最能完全理解的一条。严格来说,这 也可能是违反最频繁的一条原则了。 单一责任原则可以看作是低耦合、高内聚在面向对象原则上的引申,将责任定义 为引起变化的原因,以提高内聚性来减少引起变化的原因。责任过多,可能引 起 它变化的原因就越多,这将导致责任依赖,相互之间就产生影响,从而极大的损 伤其内聚性和耦合度。单一责任,通常意味着单一的功能,因此不要为一个模块 实 现过多的功能点,以保证实体只有一个引起它变化的原因。 本原则的应用: Unix/Linux是这一原则的完美体现者。各个程序都独立负责一个单一的事。 Windows是这一原则的反面示例。几乎所有的程序都交织耦合在一起。 另外举个例子:报表的内容和报表的格式都会变化改变,但是这两种变化的性质 不同,一个是实质内在,一个是表面上的,SRP认为这是问题的两个方面, 其实 代表不同的责任,应该将它们分离放入不同的类或模块中,而不应该放在一起, 否则的话,因为不同原因发生变化,导致对方变动,比如报表格式变新的样式, 这个变化是不应该涉及到内容的。
接口隔离原则


不能强迫用户去依赖那些他们不使用的接口。换句话说,使用多个专门的 接口比使用单一的总接口总要好。注意:在代码中应用ISP并不一定意味 着服务就是绝对安全的。仍然需要采用良好的编码实践,以确保正确的验 证与授权。 这个原则起源于施乐公司,他们需要建立了一个新的打印机系统,可以执 行诸如装订的印刷品一套,传真多种任务。此系统软件创建从底层开始编 制,并实现了这些 任务功能,但是不断增长的软件功能却使软件本身越 来越难适应变化和维护。每一次改变,即使是最小的变化,有人可能需要 近一个小时的重新编译和重新部署。这 是几乎不可能再继续发展,所以 他们聘请罗伯特Robert帮助他们。他们首先设计了一个主要类Job,几乎能 够用于实现所有任务功能。只要调用Job类的 一个方法就可以实现一个功 能,Job类就变动非常大,是一个胖模型啊,对于客户端如果只需要一个 打印功能,但是其他无关打印的方法功能也和其耦合,ISP 原则建议在客 户端和Job类之间增加一个接口层,对于不同功能有不同接口,比如打印 功能就是Print接口,然后将大的Job类切分为继承不同接口的子 类,这样 有一个Print Job类,等等。

里氏替换原则的讨论


软件工程大师Robert C. Martin把里氏替换原则最终简化为一句话: “Subtypes must be substitutable for their base types”。也就是,子 类必须能够替换成它们的基类。即:子类应该可以替换任何基类能 够出现的地方,并且经过替换以后,代码还能正常工作。另外,不 应该 在代码中出现if/else之类对子类类型进行判断的条件。里氏替 换原则LSP是使代码符合开闭原则的一个重要保证。正是由于子类 型的可替换性才使得父类 型的模块在无需修改的情况下就可以扩 展。在很多情况下,在设计初期我们类之间的关系不是很明确, LSP则给了我们一个判断和设计类之间关系的基准:需不需 要继承, 以及怎样设计继承关系。 当一个子类的实例应该能够替换任何其超类的实例时,它们之间才 具有is-A关系。继承对于OCP,就相当于多态性对于里氏替换原则。 子类可以代替基类,客户使用基类,他们不需要知道派生类所做的 事情。这是一个针对行为职责可替代的原则,如果S是T的子类型, 那么S对象就应该在不改变任何抽象属性情况下替换所有T对象。
SOLID 原则
基本概念

程序设计领域, SOLID (单一功能、开闭原则、 里氏替换、接口隔离以及依赖反转)是由罗伯 特•C•马丁在21世纪早期 引入的记忆术首字 母缩略字,指代了面向对象编程和面向对象设 计的五个基本原则。当这些原则被一起应用时, 它们使得一个程序员开发一个容易进行软件维 护和扩展的系统变得更加可能SOLID被典型的 应用在测试驱动开发上,并且是敏捷开发以及 自适应软件开发的基本原则的重要组成部分。
开闭原则的讨论

软件实体应该是可扩展,而不可修改的。也就是说,对扩展是 开放的,而对修改是封闭的。这个原则是诸多面向对象编程原 则中最抽象、最难理解的一个。 对扩展开放,意味着有新的需求或变化时,可以对现有代码进 行扩展,以适应新的情况。 对修改封闭,意味着类一旦设计完成,就可以独立完成其工作, 而不要对类进行任何修改。 可以使用变化和不变来说明:封装不变部分,开放变化部分, 一般使用接口继承实现方式来实现“开放”应对变化,说大白 话就是:你不是要变化吗?,那么我就让你继承实现一个对象, 用一个接口来抽象你的职责,你变化越多,继承实现的子类就 越多。
相关文档
最新文档