面向对象设计七大原则-步骤资料
面向对象的主要6-7条编程原则并查阅常用设计模式
面向对象的主要6-7条编程原则并查阅常用设计模式面向对象的主要6-7条编程原则是 SOLID 原则，分别是单一责任原则、开闭原则、里氏替换原则、接口隔离原则、依赖倒置原则和最少知识原则。
1. 单一责任原则（Single Responsibility Principle，SRP）：单一责任原则要求一个类只负责一个功能或者只有一个引起它变化的原因。
一个类只应该有一个引起它变化的原因，这样可以提高类的可维护性、可扩展性和可测试性。
设计模式参考：观察者模式（Observer Pattern）观察者模式定义了一种一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都会得到通知并自动更新。
2. 开闭原则（Open-Closed Principle，OCP）：开闭原则要求对扩展开放，对修改关闭。
一个模块应该是可扩展的，而不是修改其源代码。
这样可以保证系统的稳定性和可维护性。
设计模式参考：策略模式（Strategy Pattern）策略模式定义了一系列算法，并将每个算法封装在独立的类中，使它们可以互相替换。
这样可以在不修改原有代码的情况下动态改变算法的行为。
3. 里氏替换原则（Liskov Substitution Principle，LSP）：里氏替换原则要求子类能够替换掉父类并保持程序逻辑的一致性。
子类应该能够完全替换父类并且不影响程序的正确性。
设计模式参考：模板方法模式（Template Method Pattern）模板方法模式定义了一个算法的骨架，将一些步骤延迟到子类中实现。
子类可以在不改变算法结构的情况下重新定义算法的某些步骤。
4. 接口隔离原则（Interface Segregation Principle，ISP）：接口隔离原则要求一个类对其他类只依赖于其需要的方法。
接口应该为其使用者提供最小的依赖接口，不应该强迫它们依赖于和它们无关的方法。
设计模式参考：适配器模式（Adapter Pattern）适配器模式将一个类的接口转换成客户端所期望的另一个接口。
面向对象设计的基本原则和实践建议
面向对象设计的基本原则：1 层次化抽象原则，按照问题域逻辑关系来识别类；2 责任均衡分配原则，避免出现God类和Idiot类；3 简单化原则，一个方法尽量只处理一种情况，把问题要求进行的处理进行划分，识别出多种不同情况；4 封装原则，一个类的属性都不可以让外部直接访问；5 局部化原则，类之间不要冗余存储相同的数据，方法之间不能够出现控制耦合；6 完整性原则，一个类需要提供针对相应数据进行处理的完整方法集。
完整是个相对概念，一般来说是相对于问题域需求。
7 重用原则（共性抽取原则），把不同类之间具有的共性数据或处理抽象成继承关系，避免冗余；8 显式表达原则，显式表达所有想要表达的数据或逻辑，不使用数组存储位置或者常量来隐含表示某个特定状态或数据；9 信任原则，一个方法被调用时，调用者需要检查和确保方法的基本要求能够被满足，获得调用结果后需要按照约定的多种情况分别进行处理；10 懂我原则，所有类、对象、变量、方法等的命名做到“顾名思义”。
面向对象设计实践建议：(1) 首先问题结构分析和抽象表达：识别出几个关键类及其关系，这时候和具体的数据表示和结构都没有关系；(2) 根据问题要满足的功能，定义每个类外部可访问的行为，不涉及类的内部行为和数据，并规划这些类如何协同来完成系统功能，逐层分解。
(3) 对每个类，定义它应该保存的属性及类型，和相应的数据控制行为（外部可见），从而满足对外部可见行为的实现；(4) 系统输入和输出的处理。
分析输入和输出的层次性和模式特征。
如果如层次性，则按照相应模式分层进行处理。
顶层一般可交给主类进行处理；往下各个层次应该交给对输入分析结果感兴趣的类去处理，减少信息耦合度。
(5) 检查得到的设计结果是否出现违背相关原则的问题。
面向对象程序设计的七大原则
面向对象程序设计的七大原则是软件开发中的基本原则，也被称为“SOLID原则”。
这七个原则是由Robert C. Martin所提出的，是为了确保软件系统具有可扩展性、可维护性、可重用性和可测试性等优良的质量属性。
一、单一职责原则(SRP)单一职责原则指的是一个类应该有且只有一个引起它变化的原因。
换言之，一个类只承担一种职责或功能。
如果一个类具有多个职责，那么当其中一个职责变化时，可能影响其他职责的正确性和稳定性，从而导致软件系统出现难以预测的错误。
二、开放封闭原则(OCP)开放封闭原则指的是软件实体（类、模块等）应该是可扩展的，但不可修改的。
这意味着应该允许修改软件实体的行为，但不允许直接修改其源代码。
相反，应该通过添加新代码来扩展其功能。
通过遵循该原则，可以使软件系统更加稳定和易于维护。
三、里氏替换原则(LSP)里氏替换原则指的是，任何基类可以被替换为其子类，而不会影响软件系统的正确性。
换言之，一个子类应该能够替换掉其父类，同时保持其原有的行为和功能。
遵循该原则可以提高软件系统的灵活性和可扩展性。
四、接口隔离原则(ISP)接口隔离原则指的是，不应该限制一个类必须实现其不需要的接口。
接口应该是精简的，只包含其实现类所需要的方法和属性。
这样可以避免代码冗余和不必要的复杂性，从而提高代码的可读性和可维护性。
五、依赖倒置原则(DIP)依赖倒置原则指的是高层模块不应该依赖于低层模块，它们应该依赖于抽象接口。
同时，抽象接口也不应该依赖于具体实现类。
换言之，应该依赖于抽象而不是具体实现。
遵循该原则可以提高代码的灵活性和可重用性。
六、迪米特法则(Law of Demeter)迪米特法则，也被称为最少知识原则(LSP)，其指导思想是一个对象应该尽量不去了解其它对象的内部实现细节。
这意味着一个对象只能与其直接联系的对象发生交互。
这样可以降低对象之间的耦合度，提高代码的可维护性和可测试性。
七、组合/聚合复用原则(CARP)组合/聚合复用原则是建立在利用继承和实现来实现代码重用的六大原则之外的一种方式。
面向对象程序设计之设计原则与方法
面向对象程序设计之设计原则与方法面向对象程序设计是一种先进的程序设计范式，关键在于建立一个具有自主行为和自我描述能力的程序体系结构，它可以非常自然的模拟现实世界中的对象和关系，提升程序的可读性、可扩展性和可维护性，其重要性不言而喻。
在面向对象的程序设计中，设计原则和设计方法是非常重要的，以下是我对其的理解和分析。
一、设计原则设计原则是设计过程中最重要的指导方针。
它可以帮助开发人员做出更好的设计决策，确保程序具有高内聚性和低耦合性，以此提高程序的可扩展性、可维护性和可重用性。
下面是一些常用的面向对象设计原则：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）接口隔离原则是指一个类不应该依赖一个它不需要的接口。
也就是说，一个接口应该只提供它的客户端需要的方法，而不应该强迫它们实现它们不需要的方法。
面向对象设计应遵循那些准则
面向对象设计应遵循那些准则
1. 单一职责原则（SRP）：一个类或对象只应该有一个单一的职责或目的。
2. 开闭原则（OCP）：开放扩展、封闭修改，即设计应该尽可能地支持拓展，而不是修改现有代码。
3. 里式替换原则（LSP）：任何父类出现的地方，都可以用其子类替换，而不会影响程序的正确性。
4. 接口隔离原则（ISP）：不应该强制一个类实现它用不到的接口，而是应该将接口细分为更小、更具体的接口。
5. 依赖倒置原则（DIP）：高层模块不应该依赖低层模块，两者都应该依赖于抽象接口，即程序设计的抽象应该依赖于细节，而不是细节依赖于抽象。
6. 迪米特法则（LoD）：一个对象应该仅知道与其相关的对象，而不应该知道与其无关的对象。
7. 组合/聚合复用原则（CARP）：优先使用组合或聚合的方式实现代码复用，而不是继承。
面向对象开发中的七大设计原则和23种设计模式
⾯向对象开发中的七⼤设计原则和23种设计模式⼀、⾯向对象开发中的七⼤设计原则 软件开发中最核⼼的思想就是“⾼内聚，低耦合”，主要的⽬的也是为了⽅便后期的维护和变更。
下⾯的设计原则也是依靠这个核⼼思想衍⽣出来的。
1、单⼀职责原则【SINGLE RESPONSIBILITY PRINCIPLE】：单⼀职责原则想表达的核⼼思想就是“⾼内聚”，⼀个模块只完成⼀项功能。
在⾯向对象设计中，⼀个类只应该负责⼀项职责，如果同时承担太多职责，就等于把这些职责耦合在了⼀起。
后⾯很可能因为某项职责的变更⽽导致其他职责的削弱或者抑制其他职责的能⼒。
2、⾥⽒替换原则【LISKOV SUBSTITUTION PRINCIPLE】：任何时候都可以⽤⼦类型来替换⽗类型。
3、依赖倒置原则【DEPENDENCE INVERSION PRINCIPLE】：⾯向接⼝编程，声明⽅法的参数类型、⽅法的返回类型、变量的引⽤类型时，尽可能使⽤抽象类型⽽不⽤具体类型，因为抽象类型可以被它的任何⼀个⼦类型所替代，请参考下⾯的⾥⽒替换原则。
4、接⼝隔离原则【INTERFACE SEGREGATION PRINCIPLE】：建⽴单⼀接⼝，不要建⽴庞⼤臃肿的接⼝，尽量细化接⼝。
5、迪⽶特法则【LOW OF DEMETER】：迪⽶特法则⼜叫最少知识原则，⼀个对象应当对其他对象有尽可能少的了解。
(低耦合) 6、开闭原则【OPEN CLOSE PRINCIPLE】⼀个软件实体如类、模块和函数应该对扩展开放，对修改关闭。
7、组合/聚合复⽤原则【Composition/Aggregation Reuse Principle(CARP) 】：尽量使⽤组合和聚合，少使⽤继承的关系来达到复⽤的原则。
类与类之间简单的说有三种关系，IS-A关系、HAS-A关系、USE-A关系，分别代表继承、关联和依赖。
其中，关联关系根据其关联的强度⼜可以进⼀步划分为关联、聚合和合成，但说⽩了都是HAS-A关系，合成聚合复⽤原则想表达的是优先考虑HAS-A关系⽽不是IS-A关系复⽤代码⼆、23种设计模式 设计模式是⼀套被反复使⽤的代码设计经验的总结,是对上⾯的设计原则的进⼀步细化，使⽤设计模式是为了可重⽤代码、让代码更容易被他⼈理解、保证代码可靠性。
面向对象基础设计原则
面向对象基础设计原则
1.单一职责原则(SRP)：一个类应该只有一个引起变化的原因。
换句话说，一个类应该只有一个责任。
2.开放封闭原则(OCP)：一个模块应该对扩展开放，对修改关闭。
也就是说，一个模块的行为应该是可扩展的，而不是通过修改代码来实现。
3.里氏替换原则(LSP)：子类必须完全替换其父类。
换句话说，如果一个函数期望父类，那么它必须以其子类作为参数。
4.依赖倒置原则(DIP)：高级模块不应该依赖于低级模块，两者都应该依赖于抽象接口。
抽象接口不应该依赖于实现细节，而实现细节应该依赖于抽象接口。
5.接口隔离原则(ISP)：不应该强迫客户端实现它们不需要的方法。
接口应该根据使用者的需求而设计，而不是根据实现者的需求而设计。
6.合成/聚合复用原则(CARP)：通过合成/聚合来实现代码复用，而不是继承。
这样做可以避免继承的一些缺点，如紧密耦合和脆弱性。
面向对象7大原则
面向对象7大原则1.单一职责原则（SRP）一个类应该只有一个引起它变化的原因。
也就是说，一个类只负责一项职责。
例如，一个“员工信息管理类”，它就只应该负责员工信息（如姓名、年龄、职位等）的增删改查操作，而不应该同时处理工资计算等其他功能。
这样可以使类的职责更加明确，当系统功能需要改变时，只需要修改对应的职责类，降低类之间的耦合度。
2.开闭原则（OCP）软件实体（类、模块、函数等）应该对扩展开放，对修改关闭。
比如开发一个图形绘制系统，一开始有绘制圆形的功能，用一个“圆形绘制类”来实现。
当需要增加绘制矩形的功能时，不应该修改“圆形绘制类”，而是通过新建一个“矩形绘制类”来扩展系统功能。
这样可以保证原有代码的稳定性，减少修改可能带来的风险。
3.里氏替换原则（LSP）所有引用基类（父类）的地方必须能透明地使用其子类的对象。
例如有一个“交通工具”基类，有“行驶”方法，“汽车”和“自行车”是它的子类。
在程序中如果有一个使用“交通工具”类型的方法（如计算行驶里程），那么“汽车”和“自行车”的对象都可以正确地代入这个方法中，并且不改变程序的正确性。
这保证了继承关系的正确性和代码的可维护性。
4.依赖倒置原则（DIP）高层模块不应该依赖低层模块，二者都应该依赖其抽象；抽象不应该依赖细节，细节应该依赖抽象。
比如在一个电商系统中，“订单处理模块”（高层模块）不应该直接依赖“数据库存储模块”（低层模块）。
而是定义一个“数据存储接口”，“订单处理模块”依赖这个接口，“数据库存储模块”实现这个接口。
这样可以降低模块之间的耦合度，方便系统的扩展和维护。
5.接口隔离原则（ISP）客户端不应该被迫依赖于它不需要的接口。
例如，在一个系统中有“用户管理接口”，里面包含了用户的增删改查、用户权限设置等多个方法。
但对于一个只负责用户信息显示的模块，它只需要用户的查询方法，那就应该把这个接口拆分成更小的接口，如“用户查询接口”和“用户操作接口”，让这个模块只依赖它需要的“用户查询接口”，避免引入不需要的方法和依赖。
面向对象的七大原则
2.举例说明：
四、 里氏代换原则（LSP）
Liskov Substitution Principle 1. 定义： ①如果对每一个类型为S的对象o1，都有类型为T的对 象o2，使得以T定义的所有程序P在所有的对象o1都代换成 o2时，程序P的行为没有变化，那么类型S是类型T的子类 型。 ②所有引用基类（父类）的地方必须能透明地使用其 子类的对象。 *注：子类可以扩展父类的功能，但不能改变父类原有的功 能。 2.举例说明：
二、依赖倒转原则(DIP)
Dependence Inversion Principle 1. 定义 ： 简单来说，依赖倒转原则就是指：代码要依赖于抽象 的类，而不要依赖于具体的类；要针对接口或抽象类编 程，而不是针对具体类编程。
2.举例说明：
三、单一职责原则 (SRP)
Single Response Principle 1. 定义 ： ①一个对象应该只包含单一的职责，并且该职责被完 整地封装在一个类中。
面向对象的七大原则
主要内容：
1) 开闭原则（OCP）
2) 依赖倒转原则（DIP） 3) 单一职责原则（SRP）
4) 里氏转换原则（LSP）
5) 组合/聚合复用原则（CARP） 6) 迪米特原则（LoD或LKP）
7) 接口隔离原则（ISP）
七大原则总脉络图
Page 2
六、迪米பைடு நூலகம்法则(LoD或LKP)
Law of Demeter，LoD或LKP（Least Knowledge Principle） 1. 定义： 每一个软件单位对其他的单位都只有最少的知识，而 且局限于那些与本单位密切相关的软件单位。
七种设计原则
七种设计原则设计模式（⾯向对象）有七⼤原则，分别是： 1.开放-封闭原则 2.单⼀职责原则 3.依赖倒转原则 4.迪⽶特法则（也称为最⼩知识原则） 5.接⼝隔离原则 6.合成/聚合复⽤原则 7.⾥⽒代换原则开放-封闭原则具有理想主义的⾊彩，他是⾯向对象设计的终极⽬标。
其他⼏条则可以看做是开放-封闭原则的实现⽅法。
设计模式就是实现了这些原则，从⽽达到了代码复⽤，增加可维护性的⽬的。
⼀.开放-封闭原则 概念：⼀个软件实体如类、模块和函数应该对扩展开放，对修改关闭。
模块应该尽量在不修改原代码的情况下进⾏扩展。
在软件周期内，因为变化、升级和维护等原因需要对软件原有代码进⾏修改时，可能会给代码引⼊错误，也可能会使我们不得不对整个功能进⾏重构，并且需要原有代码经过重新测试。
当软件需求变化时，尽量通过扩展软件实体的⾏为来实现变化，⽽不是通过修改已有代码来实现变化。
开放封闭原则是⾯向对象设计的核⼼所在，遵循这个原则可以带来⾯向对象技术所声称的巨⼤好处，也就是可维护、可扩展、可复⽤、灵活性好。
开发⼈员应该仅对程序中呈现的频繁变化的那些部分作出抽象，然⽽，对于应⽤程序中的每个部分都刻意的进⾏抽象同样不是⼀个好主意。
拒绝不成熟的抽象和抽象本⾝⼀样重要。
注意事项： 1.通过接⼝或者抽象类约束扩展，对扩展进⾏边界限定，不允许出现在接⼝或抽象类中不存在的public⽅法。
2.参数类型、引⽤对象尽量使⽤接⼝或者抽象类，⽽不是实现类 3.抽象层尽量保持稳定，⼀旦确定不允许修改。
⼆.单⼀职责原则 概念：就⼀个类⽽⾔，应该仅有⼀个引起它变化的原因。
当我们在做编程的时候，很⾃然的回个⼀个类加上各种各样的功能。
这样意味着，⽆论任何需求要来，你都需要更改这个类，这样其实是很糟糕的，维护⿇烦，复⽤不可能，也缺乏灵活性。
如果⼀个类承担的职责过多，就等于把这些职责耦合起来，⼀个职责变化可能会削弱或者抑制这个类完成其他职责的能⼒。
这种耦合会导致脆弱的设计，当变化发⽣时，设计会遭到很多意想不到的破坏。
面向对象基本原则
面向对象基本原则面向对象软件开发技术已经在计算机行业中应用了几十年，是一种构建软件系统的有效方法。
它被认为是一种自我描述的行为，允许程序员将数据和行为封装到单个对象中，而另一组技术将设计的对象链接在一起，以创建复杂的软件系统。
解决问题的核心就是在软件设计过程中，思考并定义对象的有效接口、行为和系统结构。
而这其中的许多原则和技术可以用来指导此工作。
其中，面向对象的基本原则也就是这其中的一种。
面向对象的基本原则的概念面向对象基本原则以“对对象的事物进行抽象”为出发点，以“重用性”为目标，从中找出一种形式，试图解决软件设计中经常遇到的复杂问题。
据说面向对象的基本原则建立在“模块化”和“面向接口”的基础上，推荐形式，以便将复杂的软件设计中的问题解决。
面向对象基本原则主要提出了以下7个原则：1、单一职责原则（SRP）：一个类只负责一项职责，并保证其功能，而不涉及其它职责。
2、开放封闭原则（OCP）：一个软件实体应该是可扩展的，但不能修改。
3、里氏替换原则（LSP）：子类应该能够替换它们的父类，而不破坏对程序的其他部分的正确性。
4、依赖倒置原则（DIP）：高层模块不应该依赖于低层模块，应当建立在抽象的基础上。
5、接口隔离原则（ISP）：类之间的耦合应该降到最低。
这意味着客户端不应该依赖它不需要的接口。
6、迪米特法则（LoD）：一个对象应该对其它对象有最少的了解。
7、合成复用原则（CRP）：尽量使用对象组合，而不是继承来达到复用的目的。
应用对于软件设计，面向对象基本原则具有重要作用。
以LDPC码为例，面向对象设计的原则将帮助我们更好地理解以LDPC码为基础的软件设计。
当设计LDPC码的软件时，应遵守单一职责原则。
LDPC码的软件应完成信息传输的功能，因此它应该专注于实现信息传输的功能，而不应涉及其他任务。
此外，应当考虑开放封闭原则。
在设计LDPC码的软件时，应确保软件可扩展，但不能修改，可以通过增加新的功能来满足新的需求，而不会影响旧的功能。
面向对象七大原则——肖文斌精品文档13页
1. 单一职责原则（SRP）单一职责原则（SRP），就一个类而言，应该仅有一个引起它变化的原因。
也就是说，不要把变化原因各不相同的职责放在一起，因为不同的变化会影响到不相干的职责。
再通俗一点地说就是，不该你管的事情你不要管，管好自己的事情就可以了，多管闲事害了自己也害了别人。
在软件设计中，如果一个类承担的职责过多，就等于吧这些职责耦合在一起，而一个职责的变化可能会削弱和抑制这个类完成其他职责的能力。
这耦合会导致脆弱的设计，当变化发生时，设计会遭受到意想不到的破坏。
软件设计真正要做的许多内容，就是发现职责并把那些职责相互分离。
如果多于一个的动机去改变一个类，那么这个类就具有多余一个的职责，就应该要考虑类的职责分离。
2. 开放-封闭原则（The Open-Closed Principle 简称OCP）开放-封闭原则，或叫开-闭原则，是说软件实体(类、模块、函数等)应该是可以扩展的，但是不可修改。
不修改的意思就是是“你可以随便增加新的类，但是不要修改原来的类”。
从这个角度去理解就好多了，其实这里还是一个隔离变化的问题。
这个原则的两个特征：一个是对于扩展是开放的；另一个是对于更改是封闭的。
我们在设计开发任何系统时，都不可能指望系统一开始就需求确定，就不再变化（要这样就太幸福了，哈哈），这是不现实的也是不科学的想法。
既然需求是有一定变化的，那么如何在面对需求变化时，设计的程序可以相对容易的修改，不至于说，新需求一来，就要把整个程序推倒重来(这样会让程序员疯了不可，哈哈，你不想疯吧)。
怎样的设计才能面对需求的改变却可以保持相对稳定，从而使得系统可以在第一个版本以后不断推出的新版本呢？开放-封闭原则就是我们的答案。
在程序设计时，我们要时刻考虑尽量把类设计的足够好，写好了就不要去修改，如果有新的需求来了，我们增加一些类来完成新的需求，原来的代码能不动就不动。
绝对的对修改关闭是不可能的，无论模块是多么的封闭，都会存在一些无法对之封闭的变化，既然不能完全封闭，设计人员必须对他设计的模块应该对那种变化封闭做出抉择、他必须事先猜测出最有可能发生变化的变化种类，然后构建抽象来隔离那些变化。
面向对象七大原则
面向对象七大原则一、☆面向对象的七大原则：1)开闭原则；------面向扩展开放，面向修改关闭。
2)里氏转换原则；------超类存在的地方，子类是可以替换的。
3)依赖倒转原则；------实现尽量依赖抽象，不依赖具体实现。
4)接口隔离原则；------应当为客户端提供尽可能小的单独的接口，而不是提供大的总的接口。
5)组合/聚合复用原则；------尽量使用合成/聚合达到复用，尽量少用继承。
原则：一个类中有另一个类的对象。
6)“迪米特”法则；------又叫最少知识原则，一个软件实体应当尽可能少的与其他实体发生相互作用。
7)单一职责原则。
-----每一个类应该专注于做一件事情。
二、开闭原则OCP：开闭原则是设计原则基础的基础，是java面向对象的核心原则，其它原则均围绕开闭原则进行展开。
开闭原则指的是一个软件实体应对对扩展开放，对修改关闭(Software entities should be open for extension, but closed for modification)。
这个原则是说在设计一个模块的时候，应对使这个模块可以在不被修改的前提下被扩展，换言之，应对可以不必修改源代码的情况下改变这个模块的行为。
☆满足开闭原则的软件系统的优越性：①通过扩展已有的软件系统，可以提供新的行为，以满足对软件的新需求，使变化中的软件系统有一定的适应性和灵活性。
②已有的软件模块，特别是最重要的抽象层模块不能再修改，这就使变化中的软件系统有一定的稳定性和延续性。
☆实现开闭原则的关键抽象化是解决问题的关键，在面向对象的编程语言里，可以给系统定义出一套相对较为固定的抽象设计，此设计允许无穷无尽的行为在实现层被实现。
在语言里，可以给出一个或多个抽象类或者接口，规定出所有的具体类必须提供的方法的特征作为系统设计的抽象层。
这个抽象层预见了所有的可扩展性，因此，在任何扩展情况下都不会改变。
这就使得系统的抽象不需要修改，从而满足了开闭原则的第二条，对修改关闭。
面向对象的七大基本原则和实例详解
⾯向对象的七⼤基本原则和实例详解单⼀职责原则定义：⼀个类只负责⼀个领域的相应职责。
开闭原则定义：软件实体应对扩展开放，⽽对修改关闭。
⾥⽒替换原则定义：所有引⽤基类的对象能够透明的使⽤其⼦类的对象。
依赖倒转原则定义：抽象不应该依赖于细节，细节依赖于抽象。
接⼝隔离原则定义：使⽤多个专门的接⼝，⽽不是使⽤单⼀总接⼝。
合成复⽤原则定义：尽量使⽤对象组合，⽽不是继承来达到复合⽬的。
迪⽶特法则定义：⼀个软件实体应当尽可能少的与其它实体发⽣相互作⽤。
1.单⼀职责原则：每个类型（包括接⼝和抽象）功能要求单⼀，只对外负责⼀件事情，应该仅有⼀个原因引起类的变更。
不要让⼀个类存在多个改变的理由。
只应该做和⼀个任务相关的业务，不应该把过多的业务放在⼀个类中完成。
单⼀职责原则不只是⾯向对象编程思想所特有的，只要是模块化的程序设计，都适⽤单⼀职责原则。
⽂件：把不同类型的⽂件放在不同的⽂件夹⾥做区分，不同功能的⽂件的划分，⽂件之间相互引⽤代码：/*** @author 刘贵⽣* @date:2018-11-2* @information:页⾯初始化数据* @param: model 搜索条件*/pageInit: function ({dispatch},model) {// 返回⼀个promise，先去请求表头数据，成功之后去请求表格数据和三个考勤率return new Promise ((resolve,reject) => {dispatch('getHeaderData')resolve()}).then (() => {let p1 = new Promise ((resolve,reject) => {dispatch('getTableData',model)resolve()})let p2 = new Promise ((resolve,reject) => {dispatch('searchPercentage',model)resolve()})Promise.all([p1,p2])})},/*** @author 刘贵⽣* @date:2018-11-8* @infromation: 请求表头数据*/getHeaderData: function ({commit}) {request.searchTableHeader().then(res => {commit(type.TABLEHEADER,res.data.result)})},/*** @author 刘贵⽣* @date:2018-11-2* @information: 请求表格数据* @param: model 查询的条件*/getTableData: function ({state,commit},model) {// 打开正在加载state.loading = truelet obj = {query:model,pages:state.pages,sort: state.sort}return request.searchTableData(obj).then(res => {// 表格数据和总条数let { data, totalSize } = res.data.result// 获取每页请求多少条let { size } = state.pages// 保存数据的总长度let num = data.length// 如果数据⼤于0条并且⼩于每页显⽰条数，⽤空数据补齐if(num > 0 && num < size) {}// 向mutation提交状态commit(type.TABLEDATA, data)commit(type.TOTALSIZE, totalSize)// 关闭正在加载state.loading = false})},/*** @author 刘贵⽣* @date:2018-11-06* @information: 查询三个考勤率*/searchPercentage: function ({ commit },model) {request.searchPercentage(model).then(res => {commit(type.PERCENTAGE,res.data.result)})},按照最⼩单位，拆分不同功能的发法，⽅法之间项⽬调⽤原因：这也是灵活的前提，类被修改的⼏率很⼤，因此应该专注于单⼀的功能。
面向对象编程中的设计原则
面向对象编程中的设计原则
面向对象编程中的设计原则如下：
1.单一职责原则：一个类只负责一个职责，且该职责被完整封装在一个类中。
2.开闭原则：软件实体应尽量在不改变原有的代码的情况下进行扩展。
该原则一般通过在原有模块中添加抽象层来实现，是其他原则的基础，其他原则是实现开闭原则的具体措施。
3.里氏替换原则：在运用里氏替换原则时应将父类设计为抽象类或者接口，让子类继承父类或实现父类接口，并实现父类中声明的方法，在运行时子类实例替换父类实例，可以很方便的扩展系统的功能，无需修改子类原有的代码。
4.依赖倒转原则：它要求针对接口编程，不要针对实现编程。
即在程序代码中传递参数或关联关系中应引用层次高的抽象层，即使用接口和抽象类进行变量类型声明、参数类型声明、方法返回值声明，以及数据转换声明等，而不要使用具体类来做这些事情。
[06]一些面向对象的设计原则
![[06]一些面向对象的设计原则](https://img.taocdn.com/s3/m/5ba042da28ea81c758f57831.png)
把对实体的依赖改为对抽象的依赖就行了。下面的例子说明了这个过程： 05赛季的时候，一辆F1赛车有一台V10引擎。但是到了06赛季，国际汽联修 改了规则，一辆F1赛车只能安装一台V8引擎。车队很快投入了新赛车的研发， 不幸的是，从工程师那里得到消息，旧车身的设计不能够装进新研发的引擎。 我们不得不为新的引擎重新打造车身，于是一辆新的赛车诞生了。但是，麻 烦的事接踵而来，国际汽联频频修改规则，搞得设计师在“赛车”上改了又 改，最终变得不成样子，只能把它废弃。
面向对象的设计原则
1.开闭原则(OCP) 2.里氏代换原则（LSP）
3.依赖倒转原则（DIP）
4.接口隔离原则（ISP） 5.合成聚合复用原则（CARP） 6.迪米特法则（LoD） 7.单责任原则（SRP）
开闭原则（OCP）
开闭原则是面向对象程序设计的第一原则，这个 原则最早由Bertrand Meyer提出：“Software entities should be open for extension,but closed for modification”，即一个软件实体应该对扩展开放，对 修改关闭。也就是说，当一个软件需要增加或者修改 某些功能时候，应该尽可能的只是在原来的实体中增 加代码，而不是修改代码。开闭原则保证了系统具有 一定的稳定性，同时保证了系统的灵活性。开闭原则 的另外一个叫法称为“对可变性的封装原则”。
鸵鸟不是鸟 好了，所有的类都设计完成，我们把类Bird提供给了其它的代码（消费者）使用。
第二个例子：鸵鸟不是鸟
如果我们拿一种飞鸟来测试这段代码，没有问题，结果正确，符合我 们的预期，系统输出了飞鸟飞越黄河的所需要的时间；如果我们再拿 鸵鸟来测试这段代码，结果代码发生了系统除零的异常，明显不符合 我们的预期。 对于TestBird类而言，它只是Bird类的一个消费者，它在使用Bird 类的时候，只需要根据Bird类提供的方法进行相应的使用，根本不会 关心鸵鸟会不会飞这样的问题，而且也无须知道。它就是要按照“所 需时间 = 黄河的宽度 / 鸟的飞行速度”的规则来计算鸟飞越黄河所 需要的时间。 我们得出结论：在calcFlyTime方法中，Bird类型的参数是不能被 Ostrich类型的参数所代替，如果进行了替换就得不到预期结果。因此， Ostrich类和Bird类之间的继承关系违反了里氏代换原则，它们之间的 继承关系不成立，鸵鸟不是鸟。
面向对象设计方法
面向对象设计方法面向对象设计方法是一种软件开发方法，主要用于设计和实现面向对象的软件系统。
它通过将现实世界的问题抽象成对象，并将对象彼此之间的关系抽象成类与类之间的关系来实现系统的可维护性、可复用性和扩展性。
下面将详细介绍面向对象设计方法的原则和步骤。
首先，面向对象设计方法有几个基本原则。
其中，最重要的是单一职责原则（SRP）。
该原则认为一个类或模块应该有且只有一个引起它变化的原因。
这样可以保证系统的稳定性和可维护性。
另一个重要原则是开闭原则（OCP），它指出软件实体应该对扩展开放，对修改关闭。
这样可以实现系统的可复用性和可扩展性。
其他原则还包括里氏替换原则（LSP）、依赖倒置原则（DIP）和接口隔离原则（ISP）等。
面向对象设计方法一般包括以下几个步骤。
首先是需求分析，即对问题领域进行调查和分析，找出问题的本质和需求。
然后是对象设计，将需求分解成一系列对象，并定义它们的属性和行为。
在对象设计的过程中，我们需要考虑对象之间的关系，如继承、组合、关联和依赖等。
接下来是类设计，根据对象设计中的对象和关系定义类和类之间的关系。
在类设计中，我们需要注意类的封装性、继承性和多态性等特性。
最后是系统设计，将类组织成一个层次结构，形成一个系统。
面向对象设计方法的一个重要的工具是类图。
类图用于可视化对象和类之间的关系。
它包括类名、属性名和方法名等元素，并用箭头表示对象之间的关系。
类图是对系统进行抽象和建模的一种工具，可以帮助我们更好地理解和设计系统。
面向对象设计方法在软件开发中有很多优点。
首先，它可以将复杂的问题分解成简单的对象，并通过定义对象的行为来解决问题。
其次，面向对象设计方法可以实现系统的可复用性。
我们可以通过继承和组合等方式来复用已经存在的对象和类。
此外，面向对象设计方法还可以提高系统的可维护性和可扩展性。
当需求发生变化时，我们只需要修改相关的对象和类，而不需要修改整个系统。
然而，面向对象设计方法也有一些局限性。
C#面向对象设计的七大原则
C#⾯向对象设计的七⼤原则本⽂我们要谈的七⼤原则，即：单⼀职责，⾥⽒替换，迪⽶特法则，依赖倒转，接⼝隔离，合成/聚合原则，开放-封闭。
1. 开闭原则(Open-Closed Principle, OCP)定义：软件实体应当对扩展开放，对修改关闭。
这句话说得有点专业，更通俗⼀点讲，也就是：软件系统中包含的各种组件，例如模块（Modules）、类（Classes）以及功能（Functions）等等，应该在不修改现有代码的基础上，去扩展新功能。
开闭原则中原有“开”，是指对于组件功能的扩展是开放的，是允许对其进⾏功能扩展的；开闭原则中“闭”，是指对于代码的修改是封闭的，即不应该修改原有的代码。
问题由来：凡事的产⽣都有缘由。
我们来看看，开闭原则的产⽣缘由。
在软件的⽣命周期内，因为变化、升级和维护等原因需要对软件原有代码进⾏修改时，可能会给旧代码中引⼊错误，也可能会使我们不得不对整个功能进⾏重构，并且需要原有代码经过重新测试。
这就对我们的整个系统的影响特别⼤，这也充分展现出了系统的耦合性如果太⾼，会⼤⼤的增加后期的扩展，维护。
为了解决这个问题，故⼈们总结出了开闭原则。
解决开闭原则的根本其实还是在解耦合。
所以，我们⾯向对象的开发，我们最根本的任务就是解耦合。
解决⽅法：当软件需要变化时，尽量通过扩展软件实体的⾏为来实现变化，⽽不是通过修改已有的代码来实现变化。
⼩结：开闭原则具有理想主义的⾊彩，说的很抽象，它是⾯向对象设计的终极⽬标。
其他⼏条原则，则可以看做是开闭原则的实现。
我们要⽤抽象构建框架，⽤实现扩展细节。
2. 单⼀职责原则（Single Responsibility Principle）定义：⼀个类，只有⼀个引起它变化的原因。
即：应该只有⼀个职责。
每⼀个职责都是变化的⼀个轴线，如果⼀个类有⼀个以上的职责，这些职责就耦合在了⼀起。
这会导致脆弱的设计。
当⼀个职责发⽣变化时，可能会影响其它的职责。
另外，多个职责耦合在⼀起，会影响复⽤性。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
面向对象设计原则
A. 面向对象设计七大原则
a) 开闭原则
Ø 软件实体对扩展开发，对修改关闭。
Ø 当软件系统面对着新的需求的时候，系统的设计是稳定的。
Ø 满足“开-闭”原则系统的优点：
1. 通过扩展已有的模块，提供新的行为，满足新需求,使得变化中的软件系统有一定的适应性和灵活性
2. 已有的软件模块，特别是最重要的抽象层模块不能再修改，这就使得变化中的模块有一定的稳定性和延续性.
Ø 怎样才能做到开闭原则？
1. 抽象化，为系统定义一个不再更改的抽象设计，这个设计预见了所有可能的变化。
满足了开闭原则的“闭”
2. 找到系统中变化的部分，把可变性封装起来。
使用继承或者其他方式来封装变化，将变化封装在一个方法中或者一个类中。
b) “里氏转换”原则（LSP）
Ø 定义：如果一个软件实体使用一个基类的话，那么一定适合于它的子类。
也就是基类出现的地方，子类一定可以出现,替换后软件行为不会发生变化,而且它根本不能识别出基类和子类对象的区别。
Ø 里氏转换原则是对开-闭原则的补充。
违反了里氏原则，有就违反了开闭原则；反之不成立。
Ø 里氏转换原则是继承复用的基础.只有当衍生类可以替换掉基类，软件功能不会受到影响的时候，基类才能被真正复用，而衍生类才能在基类的基础上增加新的行为。
Ø 理氏转换原则是代理模式成立的基础.代理模式和真实主题模式都是抽象主题角色的子类。
客户端只知道抽象主题，而代理主题可以替代抽象主题出现在任何地方
c) “依赖倒转”原则
Ø 抽象不应该依赖于细节,细节应该依赖于抽象.
Ø (高层模块不应该依赖于底层模块，两个都依赖于抽象)
Ø 通俗地说：面向接口编程,不要对实现编程.
d) “接口隔离”原则
Ø 使用专门的接口比使用一个总的接口好；一个类对另外一个类的依赖性应当建立在最小的接口上的.
Ø 接口理解成角色,一个接口就只是代表一个角色,每个角色都有它特定的一个接口,这里的这个原则可以叫做"角色隔离原则".
Ø OOD设计的时候，准确的划分角色以及角色对应的接口。
将没有关系的接口合并在一起，就会对接口和角色构成污染。
e) “组合/聚合复用”原则
Ø 要尽量使用合成/聚合达到复用,尽量少用继承。
Ø 将一个已经有的对象纳入新对象中,使之成为新对象的一部分,新对象可以调用引入的旧对象的方法和功能.
Ø 优势:
1. 新对象存取成分对象的唯一方法是通过成分对象的接口。
2. 这种对象的复用是黑箱复用，因为成分对象的内部实现细节对于新的对象是看不见的。
3. 这种复用支持包装。
4. 新对象可以在运行的时候动态的引用于成分对象类型相同的对象。
f) “组合/聚合复用”原则
Ø 继承复用的优势:
1. 新的实现较为容易，因为超类的大部分功能可以通过继承关系自动进入子类。
2. 修改或者扩展继承而来的实现比较容易。
Ø 继承复用的缺点:
1. 继承复用破坏包装。
将超类的实现细节暴露给子类。
超类的内部细节常常对子类是透明的，白箱复用。
2. 超类的实现发生了改变，子类的实现也不得不改变
3. 超类继承而来的是静态的，不可能在运行时间内发生改变。
因此没有足够的灵活性。
g) “迪米特”原则
Ø 又叫最少知识原则；
Ø 一个对象应当对其他对象有尽可能少的了解。
Ø 只与你的朋友们通信，不要和陌生人说话；
Ø 不相往来: 将被统治的对象隔离开来，使它们没有直接的通信，可以达到分化瓦解，继而分而治之的效果
Ø 迪米特法则能够减少耦合.类之间的耦合越小，越有利于复用。
Ø “定制服务”设计原则，只向客户端提供客户端需要的方法，其他的不需要的不提供，这也是符合迪米特法则的。
h) 单一职责原则
Ø 就一个类而言，应该仅有一个引起他变化的原因。
Ø 如果一个类承担的职责过多，就等于把这些职责耦合在一起，一个职责的变化可能会削弱或者抑制这个类完成其他职责的能力。
这种耦合会导致脆弱的设计。
当变化发生的时候，设计会遭受意想不到的破坏。
Ø 对设计而言，就是发现职责并把这些职责分离。
B. 面向对象系统设计（OOD）
a) OOD的步骤:
Ø 细化重组类
Ø 细化和实现类之间的关系，明确其可见性.
Ø 增加属性,指定属性的类型和可见性.
Ø 分配职责,定义执行每个职责的方法.
Ø 对消息驱动的系统,明确消息传递的方式.
Ø 利用设计模式进行局部设计.
Ø 画出详细的类图和时序图。