面向对象五大设计原则

面向对象五大原则面向对象, 原则在写设计模式读书笔记之前，我想先总结一下自己对于面向对象设计五大原则的理解，他们分别是：SRP——单一职责原则；OCP——开放封闭原则；LSP——Liskov替换原则；DIP——依赖倒置原则；ISP——接口隔离原则。

1. 单一职责原则在《敏捷软件开发》中，把“职责”定义为“变化的原因”，也就是说，就一个类而言，应该只有一个引起它变化的原因。

在《UML与模式应用》一书中又提到，“职责”可以定义为“一个类或者类型的契约或者义务”，并把职责分成“知道”型职责和“做”型职责。

其中“做”型职责指的是一个对象自己完成某种动作或者和其他对象协同完成某个动作；“知道”型职责指的是一个对象需要了解哪些信息。

如果按照这种方式来定义“职责”的话，就与《敏》中对单一职责原则的定义不太相符了，所以还是理解为“变化的原因”比较恰当。

这个原则很好理解，但是既然谈到了职责，就不妨再来看看GRASP——通用职责分配软件模式（选自《UML与模式应用》）。

按照我自己的看法来讲，在下面这些职责分配模式中所涉及到的设计问题，是建立在现实世界抽象层次上的设计，从这个层次上进一步细化，才到了设计模式所说的针对接口编程和优先使用组合的两大原则。

在这个层次上的抽象，一定要按照现实生活中的思维方法来进行，从我们人类考虑问题的角度出发，把解决现实问题的思维方式逐渐转化成程序能够理解的思维方式，绝不允许在这一步考虑程序代码如何实现，那样子的架构就是基于程序实现逻辑，而不是从解决问题的角度出发来实现业务逻辑（参考“面向对象的思维方法”）。

1 专家模式。

在一个系统中可能存在成千上万个职责，在面向对象的设计中，定义对象的交互时，就要做出如何将职责分配给类的设计选择。

专家模式的解决方案就是：把一个职责分配给信息专家——掌握了为履行职责所必需的信息的类。

按照专家模式可以得到：一个对象所执行的操作通常是这个对象在现实世界中所代表的事物所执行的操作——这恰恰印证了我上面中的说法。

面向对象五大基本原则以前一直认为程序中的类有使用到封装继承多态就是面向对象设计,其实不然封装,继承,多态只是面向对象的三大特性,但是在设计程序的时候并不是说类的结构使用到了(或是体现出了)这三个特性就是面向对象,其实真正的面向对象设计是要符合下面的五大原则,面向对象的五大基本原则单一职责原则（SRP）开放封闭原则（OCP）里氏替换原则（LSP）依赖倒置原则（DIP）接口隔离原则（ISP）单一职责原则（SRP）•一个类应该仅有一个引起它变化的原因(最简单，最容易理解却最不容易做到的一个设计原则)职员类例子：比如在职员类里，将工程师、销售人员、销售经理这些情况都放在职员类里考虑，其结果将会非常混乱，在这个假设下，职员类里的每个方法都要if else判断是哪种情况，从类结构上来说将会十分臃肿，并且上述三种的职员类型，不论哪一种发生需求变化，都会改变职员类！这个是大家所不愿意看到的！开放封闭原则（OCP）•既开放又封闭，对扩展是开放的，对更改是封闭的！•扩展即扩展现行的模块，当我们软件的实际应用发生改变时，出现新的需求，就需要我们对模块进行扩展，使其能够满足新的需求！更改封闭即是在我们对模块进行扩展时，勿需对源有程序代码和DLL进行修改或重新编译文件！这个原则对我们在设计类的时候很有帮助，坚持这个原则就必须尽量考虑接口封装，抽象机制和多态技术！里氏替换原则（LSP）•子类可以替换父类并且出现在父类能够出现的任何地方•这个原则也是在贯彻GOF倡导的面向接口编程！在这个原则中父类应尽可能使用接口或者抽象类来实现！子类通过实现了父类接口，能够替父类的使用地方！通过这个原则，我们客户端在使用父类接口的时候，通过子类实现！意思就是说我们依赖父类接口，在客户端声明一个父类接口，通过其子类来实现这个时候就要求子类必须能够替换父类所出现的任何地方，这样做的好处就是，在根据新要求扩展父类接口的新子类的时候而不影响当前客户端的使用！依赖倒置原则（DIP）•传统的结构化编程中，最上层的模块通常都要依赖下面的子模块来实现，也称为高层依赖低层！所以DIP原则就是要逆转这种依赖关系，让高层模块不要依赖低层模块，所以称之为依赖倒置原则！ISP 接口隔离原则•这个原则的意思是：使用多个专门的接口比使用单个接口要好的多！实际编程中，为了减少接口的定义，将许多类似的方法都放在一个接口中，最后发现，维护和实现接口的时候花了太多精力，而接口所定义的操作相当于对客户端的一种承诺，这种承诺当然是越少越好，越精练越好，过多的承诺带来的就是你的大量精力和时间去维护！。

面向对象三大特性五大原则+ 低耦合高内聚面向对象的三大特性是"封装、"多态"、"继承"，五大原则是"单一职责原则"、"开放封闭原则"、"里氏替换原则"、"依赖倒置原则"、"接口分离原则"。

UML全称：UnifiedModelingLanguage，统一建模语言OOA的全称Object-Oriented Analysis 面向对象分析方法OOD的全称Object-Oriented Design 面向对象设计方法`OOP 的全称Object Oriented Programming 面向对象的程序设计SOA的全称service-oriented architecture 面向服务的架构OCP的全称Open-Closed Principle 开放封闭原则LSP的全称Liskov Substitution Principle 完全替换原则（里氏替换原则）DIP的全称Dependence Inversion Principle 依赖倒转原则CARP的全称Composite /Aggregate Reuse Principle 合成/聚合复用原则什么是面向对象面向对象(Object Oriented,OO)是软件开发方法。

面向对象的概念和应用已超越了程序设计和软件开发，扩展到如数据库系统、交互式界面、应用结构、应用平台、分布式系统、网络管理结构、CAD技术、人工智能等领域。

面向对象是一种对现实世界理解和抽象的方法，是计算机编程技术[1] 发展到一定阶段后的产物。

这里拿PHP 的OOP 举个编程实例。

三大基本特性：封装，继承，多态封装封装，就是把客观事物封装成抽象的类，并且类可以把自己的数据和方法只让可信的类或者对象操作，对不可信的进行信息隐藏。

一个类就是一个封装了数据以及操作这些数据的代码的逻辑实体。

⾯向对象设计5⼤基本原则⾯向对象设计模式有5⼤基本原则：单⼀职责原则、开发封闭原则、依赖倒置原则、接⼝隔离原则、Liskov替换原则。

1、单⼀职责原则(SRP)： 1.1，SRP(Single Responsibilities Principle)的定义：就⼀个类⽽⾔，应该仅有⼀个引起它变化的原因。

简⽽⾔之，就是功能要单⼀。

1.2，如果⼀个类承担的职责过多，就等于把这些职责耦合在⼀起，⼀个职责的变化可能会削弱或者抑制这个类完成其它职责的能⼒。

这种耦合会导致脆弱的设计，当变化发⽣时，设计会遭受到意想不到的破坏。

1.3，软件设计真正要做的许多内容，就是发现职责并把那些职责相互分离。

⼩结：单⼀职责原则可以看做是低耦合、⾼内聚在⾯向对象原则上的引申，将职责定义为引起变化的原因，以提⾼内聚性来减少引起变化的原因。

职责过多，可能引起它变化的原因就越多，这样导致职责依赖，相互之间就会产⽣原因，⼤⼤损伤其内聚性和耦合度。

2、开放-封闭原则(OCP)： 2.1，OCP(Open-Close Principle)的定义：就是说软件实体(类，⽅法等等)应该可以扩展，但是不能修改。

它是软件设计中也是最重要的⼀种设计原则。

2.2，OCP的两个特征： 2.2.1> 对于扩展是开放的。

2.2.2> 对于修改是封闭的。

2.3，什么时候应⽤OCP原则呢？ 在我们最初编写代码时，假设变化不会发⽣，当变化发⽣时，我们就创建抽象(⽐如抽象类，接⼝等等)来隔离以后发⽣的同类变化。

2.4，开放-封闭原则是⾯向对象设计的核⼼所在。

遵循这个原则可以带来⾯向对象技术所声称的巨⼤好处，也就是可维护，可扩展，可复⽤，灵活性好。

开发⼈员应该仅对程序中呈现出频繁变化的那些部分做出抽象，然⽽，对于应⽤程序中的每个部分都刻意地进⾏抽象同样不是⼀个好主意。

拒绝不成熟的抽象和抽象本⾝⼀样重要。

2.5，OCP的UML图：⼩结：开放封闭原则是⾯向对象设计的核⼼所在。

面向对象的5个基本设计原则：单一职责原则（Single-Resposibility Principle）其核心思想为：一个类，最好只做一件事，只有一个引起它的变化。

单一职责原则可以看做是低耦合、高内聚在面向对象原则上的引申，将职责定义为引起变化的原因，以提高内聚性来减少引起变化的原因。

职责过多，可能引起它变化的原因就越多，这将导致职责依赖，相互之间就产生影响，从而大大损伤其内聚性和耦合度。

通常意义下的单一职责，就是指只有一种单一功能，不要为类实现过多的功能点，以保证实体只有一个引起它变化的原因。

专注，是一个人优良的品质；同样的，单一也是一个类的优良设计。

交杂不清的职责将使得代码看起来特别别扭牵一发而动全身，有失美感和必然导致丑陋的系统错误风险。

开放封闭原则（Open-Closed principle）其核心思想是：软件实体应该是可扩展的，而不可修改的。

也就是，对扩展开放，对修改封闭的。

开放封闭原则主要体现在两个方面1、对扩展开放，意味着有新的需求或变化时，可以对现有代码进行扩展，以适应新的情况。

2、对修改封闭，意味着类一旦设计完成，就可以独立完成其工作，而不要对其进行任何尝试的修改。

实现开开放封闭原则的核心思想就是对抽象编程，而不对具体编程，因为抽象相对稳定。

让类依赖于固定的抽象，所以修改就是封闭的；而通过面向对象的继承和多态机制，又可以实现对抽象类的继承，通过覆写其方法来改变固有行为，实现新的拓展方法，所以就是开放的。

“需求总是变化”没有不变的软件，所以就需要用封闭开放原则来封闭变化满足需求，同时还能保持软件内部的封装体系稳定，不被需求的变化影响。

Liskov替换原则（Liskov-Substituion Principle）其核心思想是：子类必须能够替换其基类。

这一思想体现为对继承机制的约束规范，只有子类能够替换基类时，才能保证系统在运行期内识别子类，这是保证继承复用的基础。

在父类和子类的具体行为中，必须严格把握继承层次中的关系和特征，将基类替换为子类，程序的行为不会发生任何变化。

面向对象设计的5个原则Robert Martin在《敏捷软件开发：原则，模式和实践》提到了面向对象设计的5个原则，每个原则的第一个英文字母合在一起名为“SOLID”，这五个原则分别是：单一职责的原则（Single responsibility Principle），开闭原则（Open Close Principle），Liskov替换原则（Liskov substitution principle），“接口分离原则（Interface Segregation Principle），依赖倒置（Dependency Inversion principle）。

当然众多软件设计大师们其实提炼过更多的原则，但是从“SOLID”起步肯定是一个不赖的选择。

下面我们从一个简单的程序入手，通过逐步改进程序的方法，逐步体会这些原则在软件设计中作用。

1. 起步如果我们要做如图1这样一个简化的绘图程序，程序界面的上边是一个工具栏，工具栏中包含了基本图形（圆形，矩形，三角形，椭圆形）的按钮，在工具栏下方是一个画布。

用户使用这个绘图程序时，只要点击工具栏中的图形按钮，就可以在画布上绘制各种对应的图形。

图1. 一个极简单的绘图软件我们可以建一个名字叫画布（Canvas）的类，在类中建立以绘制各种基本图形的方法，然后由一个User类模拟用户使用这个程序绘制各种图形，如图2所示。

图2. 画布类绘制各种基本图形现在把上述设想变成代码，因为所有的程序都写的一个文件里，其中User类是public类，并且包含main()函数，所以程序的名称User.java。

我们的第一个程序如下：class Canvas {public void drawCircle(){//这里只打印了一个字符串模拟实现画圆的所有步骤System.out.println("Drew a Circle");}public void drawTriangle(){System.out.println("Drew a Triangle");}public void drawRactangle(){System.out.println("Drew a Ractangle");}public void drawEllipse(){System.out.println("Drew a Ellipse");}}public class User {public static void main(String[] args){Canvas canvas=new Canvas();//在这里模拟用户使用软件canvas.drawCircle();canvas.drawRactangle();}}当然这个程序做了极大的简化，通过打印字符串来模拟了画图形的所有复杂步骤。

面向对象的设计准则面向对象的设计准则是软件开发中的重要原则，它有助于创建高效、可维护和可扩展的软件系统。

以下是一些面向对象的设计准则：1.单一职责原则：一个类应该只有一个引起变化的原因。

这意味着一个类应该只负责一项功能或业务逻辑，这样可以提高代码的可维护性和可读性。

2.开闭原则：软件实体应该对扩展开放，对修改封闭。

也就是说，软件实体应该通过增加新代码而不是修改现有代码来增加新功能。

这样可以提高代码的可维护性和可重用性。

3.里氏替换原则：如果一个软件实体使用的是一个基类的引用或指针，那么这个实体不需要知道它实际引用或指向的是基类还是其子类的对象。

这样可以保证代码的灵活性和可扩展性。

4.依赖倒置原则：高层模块不应该依赖于低层模块，它们都应该依赖于抽象。

抽象不应该依赖于细节，细节应该依赖于抽象。

这样可以降低类之间的耦合度，提高代码的可维护性和可重用性。

5.接口隔离原则：客户端不应该强制依赖于它不使用的接口。

接口隔离原则有助于降低客户端和接口之间的耦合度，提高代码的可维护性和可重用性。

6.最少知识原则：一个对象应该对其他对象保持最少的了解。

也就是说，一个类应该只与直接相关的对象进行交互，而不是与其他不相关的对象进行交互。

这样可以降低类之间的耦合度，提高代码的可维护性和可重用性。

7.单一职责原则的进一步解释：这个原则也可以被理解为每个类都应该有一个明确的职责，并且这个职责应该被封装在一个类中。

这有助于提高代码的可读性和可维护性，因为每个类都有明确的职责和功能，使得代码更容易理解和修改。

以上是面向对象的设计准则，遵循这些准则可以设计出更加健壮、灵活和可维护的软件系统。

面向对象编程的五大原则单一职责原则开放封闭原则里氏替换原则依赖倒置原则接口隔离原则高层的实现不应该依赖底层，(父类可以替换掉任何子类)，具体说就是我们要针对接口抽象来编程，不要针对实现来编程，这样程序才能解耦。

一、"开-闭"原则(Open-Closed Principle,OCP)1.1"开-闭"原则的定义及优点1)定义：一个软件实体应当对扩展开放，对修改关闭(Software entities should be open for extension,but closed for modification.)。

即在设计一个模块的时候，应当使这个模块可以在不被修改的前提下被扩展。

2)满足"开-闭"原则的系统的优点a)通过扩展已有的软件系统，可以提供新的行为，以满足对软件的新需求，使变化中的软件系统有一定的适应性和灵活性。

b)已有的软件模块，特别是最重要的抽象层模块不能再修改，这就使变化中的软件系统有一定的稳定性和延续性。

c)这样的系统同时满足了可复用性与可维护性。

1.2如何实现"开-闭"原则在面向对象设计中，不允许更改的是系统的抽象层，而允许扩展的是系统的实现层。

换言之，定义一个一劳永逸的抽象设计层，允许尽可能多的行为在实现层被实现。

解决问题关键在于抽象化，抽象化是面向对象设计的第一个核心本质。

对一个事物抽象化，实质上是在概括归纳总结它的本质。

抽象让我们抓住最最重要的东西，从更高一层去思考。

这降低了思考的复杂度，我们不用同时考虑那么多的东西。

换言之，我们封装了事物的本质，看不到任何细节。

在面向对象编程中，通过抽象类及接口，规定了具体类的特征作为抽象层，相对稳定，不需更改，从而满足"对修改关闭"；而从抽象类导出的具体类可以改变系统的行为，从而满足"对扩展开放"。

对实体进行扩展时，不必改动软件的源代码或者二进制代码。

在面向对象设计中，如何通过很小的设计改变就可以应对设计需求的变化，这是令设计者极为关注的问题。

为此不少OO先驱提出了很多有关面向对象的设计原则用于指导OO的设计和开发。

下面是几条与类设计相关的设计原则。

1. 开闭原则(the Open Closed Principle OCP)一个模块在扩展性方面应该是开放的而在更改性方面应该是封闭的。

因此在进行面向对象设计时要尽量考虑接口封装机制、抽象机制和多态技术。

该原则同样适合于非面向对象设计的方法，是软件工程设计方法的重要原则之一。

我们以收音机的例子为例，讲述面向对象的开闭原则。

我们收听节目时需要打开收音机电源，对准电台频率和进行音量调节。

但是对于不同的收音机，实现这三个步骤的细节往往有所不同。

比如自动收缩电台的收音机和按钮式收缩在操作细节上并不相同。

因此，我们不太可能针对每种不同类型的收音机通过一个收音机类来实现(通过重载)这些不同的操作方式。

但是我们可以定义一个收音机接口，提供开机、关机、增加频率、降低频率、增加音量、降低音量六个抽象方法。

不同的收音机继承并实现这六个抽象方法。

这样新增收音机类型不会影响其它原有的收音机类型，收音机类型扩展极为方便。

此外，已存在的收音机类型在修改其操作方法时也不会影响到其它类型的收音机。

2. 替换原则 (the Liskov Substitution Principle LSP)子类应当可以替换父类并出现在父类能够出现的任何地方。

这个原则是Liskov于1987年提出的设计原则。

它同样可以从Bertrand Meyer 的DBC (Design by Contract) 的概念推出。

我们以学生为例，夜校生为学生的子类，因此在任何学生可以出现的地方，夜校生均可出现。

这个例子有些牵强，一个能够反映这个原则的例子时圆和椭圆，圆是椭圆的一个特殊子类。

因此任何出现椭圆的地方，圆均可以出现。

但反过来就可能行不通。

运用替换原则时，我们尽量把类B设计为抽象类或者接口，让C类继承类B(接口B)并实现操作A和操作B，运行时，类C实例替换B，这样我们即可进行新类的扩展(继承类B或接口B)，同时无须对类A进行修改。

简述面向对象设计的原则面向对象设计原则是一些指导原则，用于帮助开发者设计高质量、可维护、可扩展的面向对象程序。

这些原则是从实践中总结出来的，可以用于指导设计师在开发过程中做出正确的设计决策。

下面将详细介绍五个常用的面向对象设计原则。

1. 单一职责原则（Single Responsibility Principle，SRP）单一职责原则要求一个类应该只有一个引起它变化的原因。

换句话说，一个类应该只负责一项职责。

这样做的好处是，当需求发生变化时，只需修改与之相关的类，而不影响其他类。

这样可以降低类之间的耦合度，提高代码的可维护性和可复用性。

2. 开闭原则（Open-Closed Principle，OCP）开闭原则要求软件实体（类、模块、函数等）对扩展开放，对修改关闭。

这意味着，当需求发生变化时，应该通过扩展现有的实体来满足新的需求，而不是修改现有的代码。

通过使用抽象和接口来实现可扩展性，可以避免代码的大规模修改，减少出错的可能性。

3. 里氏替换原则（Liskov Substitution Principle，LSP）里氏替换原则要求子类型必须能够替换掉它们的父类型。

也就是说，父类型定义的所有功能在子类型中都应该可用，并且一致地实现。

这样才能确保代码的正确性和可靠性。

遵循里氏替换原则可以提高代码的可扩展性和可维护性，同时降低代码的复杂度。

4. 依赖倒置原则（Dependency Inversion Principle，DIP）依赖倒置原则要求高层模块不应该依赖于低层模块，二者都应该依赖于抽象。

换句话说，高层模块和低层模块都应该依赖于抽象类或接口，而不是具体的实现类。

这样可以降低模块之间的耦合度，提高代码的可扩展性和可重用性。

5. 接口隔离原则（Interface Segregation Principle，ISP）接口隔离原则要求一个类不应该依赖于它不需要的接口。

换句话说，一个类应该只关心它需要使用的方法，而不关心其他方法。

solid的五大原则SOLID 是面向对象编程的五大原则，包括单一职责原则（Single Responsibility Principle）、开闭原则（Open Closed Principle）、里氏替换原则（Liskov Substitution Principle）、接口隔离原则（Interface Segregation Principle）和依赖倒置原则（Dependency Inversion Principle）。

以下是对五大原则的简要描述，每个原则的解释都超过了 400 字：1. 单一职责原则：一个类应该只有一个引起它变化的原因。

这意味着每个类应该专注于完成一个特定的任务或职责，并且应该将不同的职责分离到不同的类中。

这样可以提高代码的可维护性和可读性，当需要修改某个特定功能时，只需要修改相关的类，而不会影响到其他类。

2. 开闭原则：软件实体（类、模块、函数等）应该对扩展开放，对修改关闭。

这意味着在设计软件系统时，应该尽可能地支持扩展新功能，而不需要修改现有的代码。

通过使用抽象和接口，可以在不修改现有代码的情况下添加新的行为或功能。

3. 里氏替换原则：子类型必须能够替换它们的父类型。

这意味着在继承关系中，子类应该能够在不修改父类使用者代码的情况下，替换父类并正常工作。

子类不能添加父类中不存在的新功能或修改父类的现有行为，否则会违反父类的契约。

4. 接口隔离原则：不应该强迫客户端依赖它们不需要的接口。

这意味着在设计接口时，应该将不同的功能分组到不同的接口中，使得客户端只需要依赖它们实际使用的接口。

这样可以降低耦合度，提高代码的灵活性和可维护性。

5. 依赖倒置原则：高层模块不应该依赖底层模块，它们都应该依赖于抽象。

这意味着代码的设计应该基于抽象（接口或抽象类），而不是具体的实现细节。

通过依赖倒置，可以实现模块之间的解耦，使代码更容易维护和扩展。

遵循 SOLID 原则可以帮助开发人员设计出更加灵活、可维护和可扩展的软件系统。

面向对象六大设计原则面向对象编程（Object Oriented Programming，OOP）是一种编程范式，它将代码组织成一系列相互关联的对象，每个对象代表现实世界中的一个实体或概念。

在面向对象编程中，有六大设计原则被广泛认可和遵循，它们是：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）：一个对象应该对其他对象保持最少的了解。

即在代码设计中，应该尽量减少对象之间的耦合，只暴露必要的接口和方法，以提高代码的可维护性和可复用性。

这些设计原则旨在帮助开发者编写高质量、可维护、可扩展的代码。

在实际编程中，遵循这些原则可以提高代码的可读性、可复用性和可维护性，降低代码的耦合度，提高系统的灵活性和可扩展性。

面向对象程序设计的设计原则及应用一、概述面向对象程序设计是一种流行的编程范例，其核心思想是将现实世界中的事物抽象成对象，并通过类和实例对它们进行描述和操作。

在面向对象程序设计中，设计原则是非常重要的指导思想，它们可以帮助开发人员准确、高效地实现代码。

本文将介绍面向对象程序设计的五个设计原则，即单一职责原则、开放封闭原则、里氏替换原则、接口隔离原则和依赖倒置原则，并通过具体案例说明它们的应用。

二、单一职责原则单一职责原则是指一个类或者模块应该只有一个单一的职责。

也就是说，一个类或者模块不应该承担太多的功能，而应该聚焦于它所需解决的问题。

这样可以方便代码的维护和扩展。

以人事信息系统为例，我们可以将其分为员工信息管理、工资管理、考勤管理等多个模块，每个模块只负责一个单一的职责。

这样，当需要修改某一模块时，其他模块不会受到影响，代码的维护成本大大降低。

三、开放封闭原则开放封闭原则是指一个类或者模块应该对扩展开放，对修改封闭。

这意味着我们应该尽可能地通过扩展代码来实现新的功能，而不是修改已有的代码。

这样可以保证代码的稳定性和可维护性。

以图形计算器为例，我们可以通过扩展添加新的形状类型（如圆形、三角形等），而不是直接修改计算逻辑。

这样当需要添加新的形状时，我们只需要添加新的类，无需修改原有的代码。

四、里氏替换原则里氏替换原则是指子类可以替换父类在程序中出现的任何地方，并且程序的逻辑不应该受到影响。

这个原则保证了继承关系的正确性，并提高了代码的复用性。

以图形计算器为例，我们可以通过继承Shape类来实现不同形状的计算。

由于继承的存在，我们可以将所有形状的计算逻辑放在Shape类中，从而简化代码的结构。

五、接口隔离原则接口隔离原则是指客户端不应该依赖它不需要的接口。

这个原则保证了代码的灵活性和可维护性。

以人员信息管理系统为例，我们可以将所有的接口都抽象成不同的接口类。

这样，每个模块只需要依赖它所需的接口，无需依赖整体的接口类。

面向对象基础设计原则
1.单一职责原则(SRP)：一个类应该只有一个引起变化的原因。

换句话说，一个类应该只有一个责任。

2.开放封闭原则(OCP)：一个模块应该对扩展开放，对修改关闭。

也就是说，一个模块的行为应该是可扩展的，而不是通过修改代码来实现。

3.里氏替换原则(LSP)：子类必须完全替换其父类。

换句话说，如果一个函数期望父类，那么它必须以其子类作为参数。

4.依赖倒置原则(DIP)：高级模块不应该依赖于低级模块，两者都应该依赖于抽象接口。

抽象接口不应该依赖于实现细节，而实现细节应该依赖于抽象接口。

5.接口隔离原则(ISP)：不应该强迫客户端实现它们不需要的方法。

接口应该根据使用者的需求而设计，而不是根据实现者的需求而设计。

6.合成/聚合复用原则(CARP)：通过合成/聚合来实现代码复用，而不是继承。

这样做可以避免继承的一些缺点，如紧密耦合和脆弱性。

⾯向对象的五⼤基本原则1.单⼀职责原则Single Responsibility Priciple 对于⼀个类⽽⾔，应该有⼀个引起它变化的原因。

要符合单⼀职责原则，那么就要将⼀个类中的各个功能分开。

⽐如图⽚加载控件，需要将图⽚的加载和缓存进⾏分开。

2.开闭原则Open Close Principle 软件中的对象对于扩展是开放的，但是对于修改是封闭的。

也就是说软件修改的时候，应该尽量⽤扩展进⾏变化，⽽不是通过修改已有的代码。

要符合开闭原则，那么创建接⼝规范，然后实现接⼝中的⽅法来进⾏修改代码。

⽐如图⽚加载框架中的图⽚的三级缓存，内存缓存，本地缓存。

3.⾥⽒替换原则Liskov Substitution Principle 所有引⽤某类的地⽅必须透明的使⽤其⼦类。

也就是使⽤了多态。

开闭原则和⾥⽒替换原则是配合使⽤的，结合使⽤就是策略模式。

继承的优点①代码重⽤，每个⼦类都有⽗类的⽅法和属性②⼦类和⽗类相似，但是⼜与⽗类有区别③提⾼代码的可扩展性继承的缺点①继承是侵⼊式的，只要继承就必须拥有⽗类的所有的属性和⽅法②可能造成⼦类代码冗余，缺少灵活性。

4.依赖倒置原则Dependence Inversion Principle①⾼层次的模块不应该依赖低层次的模块，应该依赖于其抽象。

②抽象不依赖于细节，细节依赖于抽象。

也就是在具体类中应该尽量使⽤类的抽象。

就像图⽚框架中共同使⽤ImageCache，⽽不使⽤其具体的实现类⼀样。

5.接⼝隔离原则Interface-Segregation Principle某个类不应该依赖它不需要的接⼝，应该建⽴在最⼩接⼝上。

简记：单⼀职责原则（SRP）开放封闭原则（OCP）⾥⽒替换原则（LSP）依赖倒置原则（DIP）接⼝隔离原则（ISP）s( Single-Resposibility Principle ): 单⼀职责原则o( Open-Closed principle ): 开放封闭原则l( Liskov-Substituion Principle ): ⾥⽒原则i( Interface-Segregation Principle ): 接⼝隔离原则d( Dependecy-Inversion Principle ): 依赖倒置原则⼀个单词：⽴⽅体(solid),很好记。

c++⾯向对象设计五⼤原则⾯向对象设计（OOD）是⾯向对象编程（OOP）必不可少的⼀个环节，只有好的设计，才能保障程序的质量。

⾯向对象设计的主要任务就是类的设计，不少⾯向对象（OO）的先驱和前辈已经提出了很多关于类的设计原则，⽤于指导OOP，其中就包括类设计的五项基本原则。

1.单⼀职责原则（Single Resposibility Principle，SRP）专注是⼀个⼈的优良品质，同样，单⼀职责也是⼀个类的优良设计。

单⼀职责的核⼼思想：⼀个类只做好⼀件事情。

单⼀职责原则可以看作是⾼内聚、低耦合在⾯向对象原则上的引申。

类的职责过多，容易导致类间职责依赖，提⾼耦合度，降低内聚性。

通常意义下的单⼀职责，指的是类只有⼀种单⼀功能，不要为类设计过多的功能，交杂不清的功能会使代码杂乱，提⾼程序开发的难度和系统出错的概率，降低系统的可维护性。

要举个体现单⼀职责原则的最常见的例⼦⽆疑就是STL中的迭代器的设计。

有些⼈觉得容器跟迭代器的分离是不好的设计，觉得增加了复杂度，不如直接把迭代器放在容器⾥更为简洁。

不过很多⼈还是不这样认为，因为类的数量越多并不代表就越复杂，另外迭代器如果放到容器⾥⾯，就会暴露容器的⼀些内部结构，不太符合封装的思想。

还有就是可扩展性的问题，因为对容器的访问遍历会有多种需求，如果把迭代器隔离开来你可以不修改容器类，再定义些特制的迭代器就⾏了，这样不管有什么奇怪的需求只要写个对应的迭代器出来就⾏了。

2.开放封闭原则（Open Closed Principle，OCP）开闭原则指的是开放封闭原则，即对扩展开放，对修改封闭。

所谓修改封闭，就是之前设计好的类，不要去修改。

⽐如删除掉⼀个成员函数、改变成员函数的形参列表或更改数据成员类型等。

实现对修改封闭，关键在于抽象化。

对⼀个事物抽象化，实质上是对⼀个事物进⾏概括、归纳、总结，将其本质特征抽象地⽤⼀个类来表⽰，这样类才会相对稳定，⽆需更改。

所谓扩展开放，就是在不改变已存在的类的前提下可以添加很多功能。