面向对象设计原则

面向对象设计原则实验报告1.1实验目的1. 通过实例深入理解和掌握所学的面向对象设计原则。

2．熟练使用面向对象设计原则对系统进行重构。

3．熟练绘制重构后的结构图(类图)。

1.2实验内容1.在某绘图软件中提供了多种大小不同的画笔(Pen),并且可以给画笔指定不同颜色，某设计人员针对画笔的结构设计了如图1-1所示的初始类图。

通过仔细分析,设计人员发现该类图存在非常严重的问题,即如果需要增加一种新的大小或颜色的笔,就需要增加很多子类,例如增加一种绿色的笔,则对应每一种大小的笔都需要增加一支绿色笔,系统中类的个数急剧增加。

试根据依赖倒转原则和合成复用原则对该设计方案进行重构,使得增加新的大小或颜色的笔都较为方便,请绘制重构之后的结构图(类图)。

2．在某公司财务系统的初始设计方案中存在如图1-2所示的Employee类, 该类包含员工编号(ID),姓名(name),年龄(age).性别(gender)、薪水(salary)、每月工作时数( workHoursPerMonth),每月请假天数(leaveDaysPerMonth)等属性。

该公司的员工包括全职和兼职两类,其中每月工作时数用于存储兼职员工每个月工作的小时数,每月请假天数用于存储全职员工每个月请假的天数。

系统中两类员工计算工资的万法也不一样,全职员工按照工作日数计算工资﹐兼职员工按照工.作时数计算上资﹐内此在 Employee 类中提供了两个方法calculateSalaryByDays()和calculateSalaryByHours(),分别用于按照大数和时数计算工资,此外,还提供了方法displaySalary()用于显示工资。

试采用所学面向对象设计原则分析图1-2中Employee类存在的问题并对其进行重构绘制重构之后的类图。

3.在某图形界面中存在如下代码片段,组件类之间有较为复杂的相互引用关系:如果在上述系统中增加一个新的组件类,则必须修改与之交互的其他组件类的源代码,将导致多个类的源代码需要修改。

面向对象设计的三大原则，理解并能举例
面向对象编程设计有三大原则，分别是封装（Encapsulation）、继承（Inheritance）和多态（Polymorphism）。

1. 封装（Encapsulation）：封装是将数据和相关行为（方法）
组合在一个类中，以实现隐藏内部实现细节的原则。

通过封装，可以将一组数据和对它们的操作封装在一个类中，对外部只暴露必要的接口，隐藏了实现的细节，提高了代码的安全性和可维护性。

例如，一个汽车类可以封装了颜色、品牌、速度等变量和加速、刹车等方法，对外只提供加速和刹车的接口，而隐藏了内部细节。

2. 继承（Inheritance）：继承是指创建一个新类（子类）从已
有的类（父类）中继承属性和方法的过程。

子类可以通过继承父类的特性来扩展和增强功能，并且可以重用已有的代码。

例如，有一个动物类，定义了一些公共属性和方法，然后创建了狗类和猫类继承动物类，狗类和猫类就可以共享动物类的一些功能，同时可以根据需要添加自己的特定功能。

3. 多态（Polymorphism）：多态是指同一类对象在不同情况下
可以表现出不同的行为。

对象多态性使用继承和接口实现，通过动态绑定和方法重写，允许不同的对象对同一个方法做出不同的响应。

例如，一个动物类中有一个叫声的方法，猫类和狗类都继承了动物类，并重写了叫声的方法，当通过调用叫声方法时，猫和狗的叫声不同，实现了多态性。

这三个原则是面向对象设计的基石，有助于实现代码的可重用性、可扩展性和灵活性。

里氏代换原则
里氏代换原则，即Liskov Substitution Principle，是面向对象设计的基本原则之一。

原则的核心思想是：子类可以扩展父类的功能，但不能改变父类原有的功能。

这意味着子类的行为必须与父类的行为保持一致。

里氏代换原则被广泛应用于面向对象软件设计，它可以帮助开发人员更好地开发可维护、可扩展、可复用的面向对象软件系统。

如果开发人员在设计系统时不遵守里氏代换原则，则可能出现以下问题：
1. 子类的行为与父类的行为不一致，将导致系统出现潜在的问题;
2. 如果子类破坏了父类的行为，则可能会使程序出现不可预料的行为，并导致系统崩溃;
3. 如果父类的行为被子类破坏，则可能会使开发人员在修改程序时产生困惑，从而增加调试和维护成本。

因此，里氏代换原则是面向对象设计的基本原则，它可以帮助开发人员设计出可维护、可扩展、可复用的面向对象软件系统。

它的实施可以帮助开发人员避免程序出现潜在的错误，从而降低调试和维护成本。

面向对象设计的基本原则和模式面向对象设计是一种软件开发的方法论，它将现实世界中的事物抽象成对象，然后通过对象之间的交互来完成软件系统的设计和开发。

面向对象设计的基本原则和模式是其核心，它们是设计和开发高质量、可维护、可扩展软件系统的基石。

本文将会首先介绍面向对象设计的基本原则，然后再介绍面向对象设计的基本模式。

一、面向对象设计的基本原则面向对象设计的基本原则是一些通用的、普遍适用的软件设计规则，它们有助于设计出高质量、可维护、可扩展的软件系统。

下面是面向对象设计的基本原则：1.单一责任原则(SRP)单一责任原则是面向对象设计的一个基本原则，它规定一个类应该只有一个引起它变化的原因。

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

这样可以降低类的复杂度，使得类更容易理解、维护和重用。

2.开放-封闭原则(OCP)开放-封闭原则是指一个软件实体（类、模块、函数等）应该对扩展开放，对修改封闭。

这意味着当需要改变一个软件实体的行为时，不应该修改它的源代码，而是应该通过扩展它来实现。

3.里氏替换原则(LSP)里氏替换原则是指一个子类型（派生类）必须能够替换掉它的父类型（基类）而不影响系统的功能性和可靠性。

这意味着一个接口实现的任何地方都可以被子类型替换。

4.依赖倒置原则(DIP)依赖倒置原则是指高层模块不应该依赖于低层模块，二者都应该依赖于抽象。

具体来说就是，抽象不应该依赖于细节，而细节应该依赖于抽象。

5.接口隔离原则(ISP)接口隔离原则是指一个类不应该依赖它不需要的接口，换句话说，一个类应该尽可能多地使用它所需要的接口，而不是多余的接口。

6.迪米特原则(LoD)迪米特原则是指一个对象应该尽可能少地了解其他对象，它应该只与其直接的朋友通信。

这可以降低对象之间的耦合度，使得系统更易于维护和扩展。

以上就是面向对象设计的基本原则，它们是设计和开发高质量、可维护、可扩展软件系统的重要指导。

下面我们将介绍面向对象设计的基本模式。

面向对象设计六大原则面向对象设计的原则是面向对象思想的提炼，它比面向对象思想的核心要素更具可操作性，但与设计模式相比，却又更加的抽象，是设计精神要义的抽象概括。

形象地将，面向对象思想像法理的精神，设计原则则相对于基本宪法，而设计模式就好比各式各样的具体法律条文了。

面向对象设计原则有6个：开放封闭原则，单一职责原则，依赖倒置原则，Liskov替换原则，迪米特法则和接口隔离原则或合成/聚合复用原则（不同资料略有不同，这里对7个都做了整理）。

1单一职责原则(Single Responsibility Principle SRP)There should never be more than one reason for a class to change. 什么意思呢？所谓单一职责原则就是一个类只负责一个职责，只有一个引起变化的原因。

如果一个类承担的职责过多，就等于把这些职责耦合在一起，一个职责的变化会削弱或抑制这个类完成其他职责的能力，这个耦合会导致脆弱的设计。

软件设计真正要做的许多内容，就是发现职责并把这些职责相互分离；如果能够想到多于一个动机去改变一个类，那么这个类就具有多于一个职责，就应该考虑类的分离。

以调制解调器为例如下图：从上述类图里面我们发现有四个方法Dial(拨通电话)，Hangup(挂电话)，Receive(收到信息)，Send(发送信息)，经过分析不难判断出，实际上Dial(拨通电话)和Hangup(挂电话)是属于连接的范畴，而Receive(收到信息)和Send(发送信息)是属于数据传送的范畴。

这里类包括两个职责，显然违反了SRP。

这样做有潜在的隐患，如果要改变连接的方式，势必要修改Modem，而修改Modem 类的结果导致凡事依赖Modem类可能都需要修改，这样就需要重新编译和部署，不管数据传输这部分是否需要修改。

因此要重构Modem类，从中抽象出两个接口，一个专门负责连接，另一个专门负责数据传送。

面向对象程序设计课程描述一、课程概述面向对象程序设计是计算机科学中的一个重要分支，它是一种编程范式，通过把数据和操作封装在对象中，实现程序的模块化和复用。

本课程旨在帮助学生掌握面向对象程序设计的基本概念、原则和技术，并能够运用所学知识设计、实现和维护高质量的面向对象程序。

二、课程内容1. 面向对象基础介绍面向对象编程的基本概念，包括类、对象、继承、多态等。

讲解如何使用类定义数据类型，并通过封装、继承和多态等机制来实现代码复用和灵活性。

2. 面向对象设计原则介绍常见的面向对象设计原则，包括单一职责原则、开放封闭原则、里氏替换原则等。

讲解如何根据这些原则进行系统架构设计和代码编写。

3. 面向对象分析与设计介绍面向对象分析与设计方法，包括UML建模语言和常用建模工具。

讲解如何使用UML图形化表示系统需求和结构，并通过UML类图来描述系统组成部分及其相互关系。

4. 面向对象编程语言介绍面向对象编程语言的特点和常见语言的使用，包括Java、C++、Python等。

讲解如何使用这些语言实现面向对象程序设计，并介绍常用的开发工具和框架。

5. 面向对象设计模式介绍常见的面向对象设计模式，包括工厂模式、单例模式、观察者模式等。

讲解如何根据不同场景选择合适的设计模式，并通过实例演示如何应用。

三、教学方法1. 理论讲授老师将通过课堂讲解和PPT展示，系统全面地介绍课程内容和案例分析，帮助学生理解相关概念和原理。

2. 实践操作课程中将安排一定量的编程实践环节，帮助学生巩固所学知识并提高编程能力。

实践环节将涉及到面向对象程序设计的各个方面，包括类定义、封装、继承、多态等。

3. 课程项目本课程将安排一个小型项目作为期末考核，要求学生运用所学知识完成一个具有一定规模和复杂度的面向对象程序，并在最后一次课堂上进行演示和评分。

四、评分方式1. 平时成绩包括课堂出勤、作业完成情况、实验报告等，占总成绩的30%。

2. 期中考试考察学生对课程内容的掌握程度，占总成绩的30%。

⾯向对象设计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图：⼩结：开放封闭原则是⾯向对象设计的核⼼所在。

⾯向对象六⼤基本原则的理解在学习设计模式的时候，总是被推荐先学习⼀下⾯向对象的六⼤原则，学习后果然受益匪浅。

以下完全是我对六⼤基本原则的理解，和官⽹解释可能有出路，⽽且我更多是站在设计模式的⾓度，⽽不是⾯向对象的⾓度理解，如果有什么错误，敬亲谅解。

1.开闭原则很多教程都把开闭原则作为这六⼤原则中最基本的原则，也就是说他是各个原则的核⼼。

开闭原则指的是，⼀个软件实体如类、模块和函数应该对扩展开放，对修改关闭。

⾄于这个具体怎么理解，我也看了很多教程，有些教程说当我们遇到新的需求，就需要我们对我们模块继承的形式进⾏扩展，⽽不是修改代码。

这样的解释貌似有道理，但是如果真的这样做了，程序结构只会更加复杂，业务逻辑只会更不清晰，完全是⼀种作死的做法。

当业务发⽣改变的时候，肯定是要修改代码的，不需要的东西留着只会让程序臃肿，让维护者搞不清什么是有⽤的代码，什么是已经过时的代码。

我不太相信开闭原则的真谛是让我们⾛向这样⼀个死胡同。

对于开闭原则，我的理解是，我们在设计软件的时候，⾸先要搞清楚程序当中什么是未来可能变化的，什么是未来不会变化的。

对于可能变化的东西，我们要提前给与可以对应的扩展接⼝。

当然实际开发中，即便是我们认为这些不会变化的地⽅，未来还是可能变化的，这种变化就只能改代码了，但是这种修改仅仅只是改变个别细节，整体架构往往不会变化。

⽽对于可能变化的地⽅，我们要给出可以⾜够扩展的空间，让其能够⾃由扩展，基本发⽣了重⼤的需求变更，整体架构也不会受影响。

例如：⼯⼚模式中，我们将创建对象的过程封装了起来，这样创建对象对的过程中，创建的代码就和调⽤的代码尽可能地解除了耦合。

创建过程可能是变化的，⽽调⽤过程往往是不变的。

我们创建⼀个对象之后，需要为其初始化，设定⼀些配置，这个过程需要我们给出可以扩展的余地，⽽且要求扩展的时候不能影响调⽤部分，所以需要使⽤⼯⼚模式，将可变的创建过程封装起来，供不变的调⽤模块。

这样说来，开闭原则的核⼼是解耦了？没错，我认为开闭原则讲的就是解构，但是他要求我们在设计的时候，重点要预判出什么地⽅是会发⽣变化的，并要为变化的地⽅留出余地。

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

⾯向对象设计七⼤原则1. 单⼀职责原则（Single Responsibility Principle）每⼀个类应该专注于做⼀件事情。

2. ⾥⽒替换原则（Liskov Substitution Principle）超类存在的地⽅，⼦类是可以替换的。

3. 依赖倒置原则（Dependence Inversion Principle）实现尽量依赖抽象，不依赖具体实现。

4. 接⼝隔离原则（Interface Segregation Principle）应当为客户端提供尽可能⼩的单独的接⼝，⽽不是提供⼤的总的接⼝。

5. 迪⽶特法则（Law Of Demeter）⼜叫最少知识原则，⼀个软件实体应当尽可能少的与其他实体发⽣相互作⽤。

6. 开闭原则（Open Close Principle）⾯向扩展开放，⾯向修改关闭。

7. 组合/聚合复⽤原则（Composite/Aggregate Reuse Principle CARP）尽量使⽤合成/聚合达到复⽤，尽量少⽤继承。

原则：⼀个类中有另⼀个类的对象。

细则单⼀职责原则（Single Responsibility Principle）因为：可以降低类的复杂度，⼀个类只负责⼀项职责，其逻辑肯定要⽐负责多项职责简单的多；提⾼类的可读性，提⾼系统的可维护性；变更引起的风险降低，变更是必然的，如果单⼀职责原则遵守的好，当修改⼀个功能时，可以显著降低对其他功能的影响。

需要说明的⼀点是单⼀职责原则不只是⾯向对象编程思想所特有的，只要是模块化的程序设计，都适⽤单⼀职责原则。

所以：从⼤局上看Android中的Paint和Canvas等类都遵守单⼀职责原则，Paint和Canvas各司其职。

⾥⽒替换原则（Liskov Substitution Principle）因为：⾥⽒替换原则告诉我们，在软件中将⼀个基类对象替换成它的⼦类对象，程序将不会产⽣任何错误和异常，反过来则不成⽴，如果⼀个软件实体使⽤的是⼀个⼦类对象的话，那么它不⼀定能够使⽤基类对象。

面向对象七大基本设计原则面向对象设计原则是OOPS（Object-Oriented Programming System，面向对象的程序设计系统）编程的核心。

在设计面向对象的程序的时，模式不是一定要套的，但是有一些原则最好是遵守。

这些原则已知的有七个，包括：单一职责原则、开闭原则、里氏代换原则、依赖注入（倒转）原则、接口分离原则、迪米特原则、合成聚合复用原则。

原则一单一职责原则单一职责原则（SRP：Single responsibility principle）又称单一功能原则核心：解耦和增强内聚性（高内聚，低耦合）。

描述：类被修改的几率很大，因此应该专注于单一的功能。

如果你把多个功能放在同一个类中，功能之间就形成了关联，改变其中一个功能，有可能中止另一个功能，这时就需要新一轮的测试来避免可能出现的问题。

原则二里氏替换原则里氏替换原则（LSP：Liskov Substitution Principle）核心：在任何父类出现的地方都可以用他的子类来替代（子类应当可以替换父类并出现在父类能够出现的任何地方）四层含义：（1）子类必须完全实现父类的方法。

在类中调用其他类是务必要使用父类或接口，如果不能使用父类或接口，则说明类的设计已经违背了LSP原则。

（2）子类可以有自己的个性。

子类当然可以有自己的行为和外观了，也就是方法和属性（3）覆盖或实现父类的方法时输入参数可以被放大。

即子类可以重载父类的方法，但输入参数应比父类方法中的大，这样在子类代替父类的时候，调用的仍然是父类的方法。

即以子类中方法的前置条件必须与超类中被覆盖的方法的前置条件相同或者更宽松。

（4）覆盖或实现父类的方法时输出结果可以被缩小。

原则三依赖注入原则依赖注入原则（DIP：Dependence Inversion Principle）别名：依赖倒置原则或依赖反转原则核心：要依赖于抽象，不要依赖于具体的实现三层含义：（1）高层模块不应该依赖低层模块，两者都应该依赖其抽象（抽象类或接口）；（2）抽象不应该依赖细节（具体实现）；（3）细节（具体实现）应该依赖抽象。

软件设计知识点总结一、面向对象设计面向对象设计是面向对象编程的基础，是软件设计中的重要知识点。

面向对象设计包括以下内容：1. 类和对象：类是对象的抽象，对象是类的实例。

在面向对象设计中，需要对系统中的各种实体进行抽象，形成不同的类，然后通过类来创建对象。

2. 封装和继承：封装是指将数据和行为打包在一个对象中，通过接口来访问对象的数据和行为。

继承是指一个类可以派生出另一个类，继承了父类的属性和行为。

3. 多态：多态是指同样的消息可以发送给不同的对象，对象可以根据消息的不同做出不同的响应。

4. 设计原则：如单一责任原则、开闭原则、依赖倒置原则等。

二、设计模式设计模式是软件设计中常用的解决问题的方法和经验总结。

设计模式包括以下内容：1. 创建型模式：包括单例模式、工厂模式、抽象工厂模式等。

2. 结构型模式：包括适配器模式、装饰器模式、代理模式等。

3. 行为型模式：包括观察者模式、模板方法模式、策略模式等。

设计模式能够帮助软件设计人员解决常见的设计问题，提高软件的设计质量和重用性。

三、架构设计架构设计是指对软件系统整体结构的设计。

架构设计包括以下内容：1. 分层架构：将软件系统划分为不同的层次，如表示层、业务逻辑层、数据访问层等。

2. 微服务架构：将软件系统划分为多个小型的、相互独立的服务，每个服务都有自己的数据库。

3. 领域驱动设计：将软件系统划分为多个领域，每个领域都有自己的模型、服务和数据。

4. 架构风格：包括RESTful架构、消息驱动架构、事件驱动架构等。

架构设计可以帮助软件设计人员对软件系统整体结构有一个清晰的认识，从而能够更好地进行详细设计和开发。

四、数据库设计数据库设计是指对软件系统的数据库进行详细的设计。

数据库设计包括以下内容：1. 实体-关系模型：对系统中的实体和实体之间的关系进行建模。

2. 范式：包括第一范式、第二范式、第三范式等。

3. 性能设计：包括索引设计、分区设计、缓存设计等。

Java⾯向对象设计的六⼤原则这是设计模式系列开篇的第⼀篇⽂章。

也是我学习设计模式过程中的总结。

这篇⽂章主要讲的是⾯向对象设计中，我们应该遵循的六⼤原则。

只有掌握了这些原则，我们才能更好的理解设计模式。

我们接下来要介绍以下6个内容。

单⼀职责原则——SRP开闭原则——OCP⾥式替换原则——LSP依赖倒置原则——DIP接⼝隔离原则——ISP迪⽶特原则——LOD单⼀职责原则单⼀职责原则的定义是就⼀个类⽽⾔，应该仅有⼀个引起他变化的原因。

也就是说⼀个类应该只负责⼀件事情。

如果⼀个类负责了⽅法M1,⽅法M2两个不同的事情，当M1⽅法发⽣变化的时候，我们需要修改这个类的M1⽅法，但是这个时候就有可能导致M2⽅法不能⼯作。

这个不是我们期待的，但是由于这种设计却很有可能发⽣。

所以这个时候，我们需要把M1⽅法，M2⽅法单独分离成两个类。

让每个类只专⼼处理⾃⼰的⽅法。

单⼀职责原则的好处如下：可以降低类的复杂度，⼀个类只负责⼀项职责，这样逻辑也简单很多提⾼类的可读性，和系统的维护性，因为不会有其他奇怪的⽅法来⼲扰我们理解这个类的含义当发⽣变化的时候，能将变化的影响降到最⼩，因为只会在这个类中做出修改。

开闭原则开闭原则和单⼀职责原则⼀样，是⾮常基础⽽且⼀般是常识的原则。

开闭原则的定义是软件中的对象(类，模块，函数等)应该对于扩展是开放的，但是对于修改是关闭的。

当需求发⽣改变的时候，我们需要对代码进⾏修改，这个时候我们应该尽量去扩展原来的代码，⽽不是去修改原来的代码，因为这样可能会引起更多的问题。

这个准则和单⼀职责原则⼀样，是⼀个⼤家都这样去认为但是⼜没规定具体该如何去做的⼀种原则。

开闭原则我们可以⽤⼀种⽅式来确保他，我们⽤抽象去构建框架，⽤实现扩展细节。

这样当发⽣修改的时候，我们就直接⽤抽象了派⽣⼀个具体类去实现修改。

⾥⽒替换原则⾥⽒替换原则是⼀个⾮常有⽤的⼀个概念。

他的定义如果对每⼀个类型为T1的对象o1,都有类型为T2的对象o2,使得以T1定义的所有程序P在所有对象o1都替换成o2的时候，程序P的⾏为都没有发⽣变化，那么类型T2是类型T1的⼦类型。

⾯向对象设计的七⼤原则在上⼀篇⾥我们谈了谈为何设计模式，那接下来我们再浅谈⼀下在⾯向对象设计中我们常常要遵循的⼀些原则。

这些原则是经过⽆数的前⼈总结出来的经验的结晶。

仅仅有遵循这些原则。

你才有可能涉及出优秀的代码。

今天我们要谈的原则有七⼤原则，即：单⼀职责。

⾥⽒替换。

迪⽶特法则，依赖倒转，接⼝隔离，合成/聚合原则。

开放-封闭。

1. 开闭原则定义：软件实体应当对扩展开放，对改动关闭。

这句话说得有点专业。

更通俗⼀点讲，也就是：软件系统中包括的各种组件，⽐如模块（Modules）、类（Classes）以及功能（Functions）等等。

应该在不改动现有代码的基础上。

去扩展新功能。

开闭原则中“开”。

是指对于组件功能的扩展是开放的。

是同意对其进⾏功能扩展的。

开闭原则中“闭”。

是指对于原有代码的改动是封闭的，即不应该改动原有的代码。

问题由来：凡事的产⽣都有缘由。

我们来看看。

开闭原则的产⽣缘由。

在软件的⽣命周期内，由于变化、升级和维护等原因须要对软件原有代码进⾏改动时。

可能会给旧代码中引⼊错误，也可能会使我们不得不正确整个功能进⾏重构，⽽且须要原有代码经过⼜⼀次測试。

这就对我们的整个系统的影响特别⼤。

这也充分展现出了系统的耦合性假设太⾼，会⼤⼤的添加后期的扩展。

维护。

为了解决问题，故⼈们总结出了开闭原则。

解决开闭原则的根本事实上还是在解耦合。

所以。

我们⾯向对象的开发，我们最根本的任务就是解耦合。

解决⽅法：当软件须要变化时。

尽量通过扩展软件实体的⾏为来实现变化。

⽽不是通过改动已有的代码来实现变化。

⼩结：开闭原则具有理想主义的⾊彩。

说的⾮常抽象，它是⾯向对象设计的终极⽬标。

其它⼏条原则，则能够看做是开闭原则的实现。

我们要⽤抽象构建框架，⽤实现扩展细节。

2. 单⼀职责原则（Single Responsibility Principle）定义：⼀个类。

仅仅有⼀个引起它变化的原因。

即：应该仅仅有⼀个职责。

每个职责都是变化的⼀个轴线。