面向对象的几个基本原则讲义

在使用面向对象思想进行系统设计时，总结出了若干面向对象设计原则，分别是：单一职责原则、开闭原则、里氏替代原则、依赖注入原则、接口分离原则、迪米特原则和组合/聚合复用原则。

这些原则是面向对象设计的基石，坚持这些原则是增强系统扩展性、降低耦合性的重要保证。

下面介绍单一职能原则。

单一职能原则一、定义单一职责原则(SRP)，英文全称是Single Responsibility Principle,该原则的思想是：系统中的每一个类都应该只有一个单独的职责，而所有类所关注的就是自身职责的完成。

SRP中，把职责定义为“变化的原因”。

如果你能想到多个原因去改变一个类，那么这个类就具有多于一个的职责。

二、好处其实单一职责原则的意思就是开发人员经常说的“高内聚、低耦合”。

也就是说，每个类应该只有一个职责，对外只能提供一种功能，而引起类变化的原因应该只有一个。

如果一个类有一个以上的职责，这些职责就耦合在了一起，当一个职责发生变化时，可能会影响其它的职责。

另外，多个职责耦合在一起，会影响复用性，我们可能只需要复用该类的某一个职责，但这个职责跟其它职责耦合在了一起，很难分离出来。

单一职责原则简单而直观，但在实际应用中很难实现。

SRP中，把职责定义为“变化的原因”，这里说的“变化的原因”，只有实际发生时才有意义。

可能预测到会有多个原因引起这个类的变化，但rug仅仅是预测，并没有真的发生，这个类仍可看做具有单一职责，不需要分离职责。

如果分离，会带来不必要的复杂性。

单一职责原则的尺度如何掌握，是不是应该百分之百的做到呢？原则还是需求导向，即需求决定设计。

实际操作中，类设计时的职责划分和类粒度的确定不是一件很简单的事情，需要设计者经验的积累和对需求的仔细分析。

三、总结众所周知，面向对象编程语言可以提高程序的封装性、复用性、可维护性，但仅仅是“可以”。

能不能实现OOPL的这些优点，要看具体怎么做。

如果一个类的代码非常混乱，各种功能的代码都混在一起，封装性、复用性、可维护性无从谈起。

面向对象三原则
面向对象三原则是指信息隐藏原则、继承原则和多态原则。

这些原则是指导面向对象程序设计的基本原则，有助于提高代码的可维护性、可复用性和可扩展性。

1. 信息隐藏原则（Encapsulation）：将对象的内部状态和实现细节封装起来，只对外暴露必要的接口。

通过将数据和相关操作封装在一个类中，可以达到保护数据的目的，同时也能够隔离变化，提高代码的灵活性和可复用性。

2. 继承原则（Inheritance）：通过继承机制，可以在不修改已有代码的情况下，扩展和重用已有类的功能。

通过继承，子类可以继承父类的属性和方法，并且可以在其基础上进行扩展和修改。

3. 多态原则（Polymorphism）：允许不同对象以自己的方式响应共同的消息或方法调用。

即同一消息可以有多种不同的响应方式，不同的对象可以根据自己的特性来实现这个消息。

多态性可以提高代码的灵活性和可扩展性。

这些原则在面向对象编程中非常重要，可以帮助开发者设计出高质量、可复用和可扩展的代码。

面向对象编程原则面向对象编程是一种常见的软件开发方法，它将程序构建成相互关联的对象集合。

在面向对象编程中，有一些基本原则需要遵循，以确保代码的可维护性、可扩展性和可重用性。

本文将探讨面向对象编程的原则。

1. 单一职责原则（Single Responsibility Principle，SRP）单一职责原则指出一个类应该只负责一个职责或功能。

这意味着一个类应该只有一个引起它的变化的原因。

通过遵循单一职责原则，可以使类的设计更加灵活、可维护，并降低引入Bug的风险。

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

这意味着在添加新功能时，不需要修改已有的代码。

通过使用接口、抽象类和多态等技术，可以实现代码的可扩展性。

3. 里氏替换原则（Liskov Substitution Principle，LSP）里氏替换原则要求使用基类的代码可以在不知道子类的情况下正常工作。

换句话说，子类应该能够替换其基类而不引起错误或异常。

遵循里氏替换原则可以减少代码的耦合性，提高代码的可维护性和可扩展性。

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

这意味着在设计类之间的关系时，应该依赖于接口或抽象类，而不是具体实现。

通过遵循依赖倒置原则，可以实现代码之间的松耦合关系，提高代码的可测试性和可维护性。

5. 接口隔离原则（Interface Segregation Principle，ISP）接口隔离原则要求接口应该尽量小而精确，不应该包含不需要的操作。

这意味着一个类不应该强制实现它不需要的接口。

通过遵循接口隔离原则，可以提高代码的灵活性和可维护性，并减少不相关代码之间的耦合。

6. 迪米特法则（Law of Demeter，LoD）迪米特法则要求尽量减少对象之间的相互依赖关系。

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

深⼊理解⾯向对象——六⼤基本原则这六⼤原则任何⾯向对象的语⾔都应该遵守的，要想让你的代码易扩展⾼服⽤就尽量去满⾜这六⼤原则吧，不⼀定严格按照某种设计模式，但是如果你的代码符合这六⼤原则，那么你的代码就是好代码了，好的代码不⼀定是严格按照设计模式写的代码。

单⼀职责原则（SRP）Single Responsibility Principle，单⼀职责原则。

定义：不要存在多于⼀个导致类变更的原因。

通俗的说，即⼀个类只负责⼀项职责。

优点：可以降低类的复杂度，⼀个类只负责⼀项职责，逻辑简单；提⾼类的可读性，提⾼系统的可维护性；变更引起的风险降低，变更是必然的。

SRP其实也蕴含着深沉的⼈⽣智慧——任何事情要想做好就必须要专⼼致志地做。

⾥⽒替换原则（LSP）Liskov Substituition Principle，⾥⽒替换原则。

定义：⼦类可以扩展⽗类的功能，但不能改变⽗类原有的功能。

当使⽤继承时，遵循⾥⽒替换原则。

⼦类继承⽗类时，除添加新的⽅法完成新增功能外，尽量不要重写⽗类的⽅法，也尽量不要重载⽗类的⽅法。

依赖倒置原则（DIP）Dependence Inversion Principle，依赖倒置原则。

定义：⾼层模块不应该依赖低层模块，⼆者都应该依赖其抽象；抽象不应该依赖细节；细节应该依赖抽象。

例如，业务逻辑层相对于数据层是⾼层模块，因为业务逻辑层需要调⽤数据层去连接数据库，但是要做到可扩展⾼复⽤，尽量不要让业务逻辑层依赖数据层（如数据库类型mysql,pgsql），可以在数据层抽象出⼀个接⼝(如pdo)，让业务逻辑层依赖于这个抽象接⼝(统⼀操作数据库⽅法名)。

⽰例：interface DB{public function connect();public function add();public function update();public function query();public function del();}class Mysql implements DB{}class Sqlite implements DB{}开放封闭原则（OCP）Open-Close Principle，开-闭原则。

面向对象的四项基本原则这四项基本原则就像是面向对象编程这个大王国里的四位大管家，各管一摊，超级重要呢！1. 单一职责原则这个原则就好比是说，每个人都只干自己擅长的一件事儿，不要啥都揽着。

在面向对象里呢，就是一个类啊，它就只负责一个功能。

比如说，有个类是专门管计算长方形面积的，那就别让它再去管长方形周长的计算啦。

不然的话，这个类就变得很臃肿，就像一个人又要当厨师又要当司机又要当医生，肯定会乱套的呀。

2. 开闭原则这可是个很有趣的原则呢。

简单来说就是，对扩展开放，对修改关闭。

啥意思呢？就像是搭积木，你可以增加新的积木块（扩展功能），但是已经搭好的部分（原有的代码）就不要乱动啦。

比如说你写了个游戏，里面有各种角色，后来你想加个新的超级英雄角色，那你就直接写个新的类来表示这个超级英雄就好啦，不要去改原来那些角色类的代码。

这样可以保证之前的功能不会被破坏，而且新功能也能顺利加进去。

3. 里氏替换原则这个原则有点像角色扮演的游戏规则。

如果有个父类，然后有个子类，子类应该能够完全替代父类的位置，并且表现得很正常。

比如说，父类是动物，有个“叫”的方法，子类是狗，狗也是动物嘛。

那狗这个子类的“叫”方法就应该符合动物类的“叫”方法的逻辑。

不能说动物叫是“汪汪汪”，结果狗叫是“喵喵喵”，那就不对啦。

4. 依赖倒置原则这个原则像是一种关系的反转。

就是说高层模块不应该依赖低层模块，它们都应该依赖抽象。

比如说，有个高层模块是做蛋糕的，低层模块是提供面粉、鸡蛋这些材料的。

那做蛋糕这个模块不应该直接依赖于具体的面粉、鸡蛋的来源，而是依赖于一个抽象的“食材提供者”。

这样的话，如果换了食材的来源（比如从本地农场换成了进口供应商），做蛋糕的模块也不用改，只要这个新的供应商也符合“食材提供者”这个抽象的定义就好啦。

这四项基本原则在面向对象编程里就像指南针一样，指引着我们写出更好、更合理、更容易维护的代码呢。

面向对象编程的基本原则和技术应用一、概述面向对象编程（Object-Oriented Programming，OOP）是一种编程范式，它采用“对象”作为程序的基本单元，将数据和操作绑定在一起。

其基本思想是通过封装、继承和多态等特性来实现程序设计的灵活性、可组合性和可维护性。

二、基本原则1.封装封装是将对象的内部信息隐藏，只暴露有限的接口供其他对象访问，从而提高数据的安全性和可维护性。

封装可以通过使用private、protected和public关键字来实现。

2.继承继承是一种利用已有类作为基础，创建新类的机制。

新类可以继承基础类的属性和方法，并可以进行扩展和重写。

继承可以通过使用extends关键字来实现。

3.多态多态是指相同的方法在不同的对象上产生不同的行为。

实现多态的关键是方法的重写和方法的参数或返回类型的多态性。

三、技术应用1.类和对象的定义类是对具有相同属性和行为的对象的抽象。

对象是类的实例，具有类定义的属性和方法。

在Java中，定义类需要使用class关键字，定义对象需要使用new运算符。

2.构造函数和析构函数构造函数（Constructor）是在创建对象时调用的特殊方法，主要用于初始化对象的属性值。

析构函数（Destructor）是在释放对象时调用的方法，主要用于清理对象的资源。

在Java中，构造函数的名字必须与类名相同，而析构函数则不需要。

3.继承和接口继承是一种从现有类派生新的类的机制，从而实现代码的重用和扩展。

接口是一种定义了一组方法签名的规范，实现类必须实现这些方法。

Java中支持单继承和多实现的方式来定义类和接口。

4.重载和重写重载是指在同一个类中定义多个方法，方法名相同但参数列表不同，在调用时可以根据参数的不同自动匹配合适的方法。

重写是在子类中重写父类的方法，以实现不同的行为。

Java中支持方法的重载和重写机制。

四、总结面向对象编程采用灵活、可维护和可扩展的程序设计思想，通过封装、继承和多态等特性实现程序的高效和可靠。

面向对象七大原则
1.单一职责原则（SRP）：
一个类或者模块只应该有一个单一的功能或职责。

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

3.里氏替换原则（LSP）：
使用基类类型的对象应该能够在不知道子类的情况下正常工作。

4.依赖倒置原则（DIP）：
高层模块不应该依赖底层模块，二者都应该依赖其抽象。

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

6.最小知识原则（迪米特法则）（LoD）：
一个对象应该对其他对象有最少的了解。

7.合成复用原则（CRP）：
尽量使用对象组合而不是继承来达到代码复用的目的。

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

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

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

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

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

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

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

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

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

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

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

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

面向对象7大原则1.单一职责原则（SRP）一个类应该只有一个引起它变化的原因。

也就是说，一个类只负责一项职责。

例如，一个“员工信息管理类”，它就只应该负责员工信息（如姓名、年龄、职位等）的增删改查操作，而不应该同时处理工资计算等其他功能。

这样可以使类的职责更加明确，当系统功能需要改变时，只需要修改对应的职责类，降低类之间的耦合度。

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

比如开发一个图形绘制系统，一开始有绘制圆形的功能，用一个“圆形绘制类”来实现。

当需要增加绘制矩形的功能时，不应该修改“圆形绘制类”，而是通过新建一个“矩形绘制类”来扩展系统功能。

这样可以保证原有代码的稳定性，减少修改可能带来的风险。

3.里氏替换原则（LSP）所有引用基类（父类）的地方必须能透明地使用其子类的对象。

例如有一个“交通工具”基类，有“行驶”方法，“汽车”和“自行车”是它的子类。

在程序中如果有一个使用“交通工具”类型的方法（如计算行驶里程），那么“汽车”和“自行车”的对象都可以正确地代入这个方法中，并且不改变程序的正确性。

这保证了继承关系的正确性和代码的可维护性。

4.依赖倒置原则（DIP）高层模块不应该依赖低层模块，二者都应该依赖其抽象；抽象不应该依赖细节，细节应该依赖抽象。

比如在一个电商系统中，“订单处理模块”（高层模块）不应该直接依赖“数据库存储模块”（低层模块）。

而是定义一个“数据存储接口”，“订单处理模块”依赖这个接口，“数据库存储模块”实现这个接口。

这样可以降低模块之间的耦合度，方便系统的扩展和维护。

5.接口隔离原则（ISP）客户端不应该被迫依赖于它不需要的接口。

例如，在一个系统中有“用户管理接口”，里面包含了用户的增删改查、用户权限设置等多个方法。

但对于一个只负责用户信息显示的模块，它只需要用户的查询方法，那就应该把这个接口拆分成更小的接口，如“用户查询接口”和“用户操作接口”，让这个模块只依赖它需要的“用户查询接口”，避免引入不需要的方法和依赖。

简述面向对象设计的原则。

面向对象设计的原则以抽象的概念建立起软件系统，使用继承、封装、多态等特性来实现可重用的设计。

它可以让软件更易于维护和扩展，也能提供更容易理解和食用的软件。

面向对象设计也提高了软件的可读性，加快了软件开发的进程，为现有软件提供了可依赖的结构。

面向对象设计有六种原则，它们是：单一职责原则（SRP），开放封闭原则（OCP），里氏代换原则（LSP），接口隔离原则（ISP），依赖反转原则（DIP）以及合成复用原则（CRP）。

第一、单一职责原则（SRP），即一个类应该只完成一个功能。

它可以帮助我们实现模块的划分以及职责的分配，提高模块可替换性和可扩展性。

一个类只做一种事情，让代码可读性更强，维护和扩展更容易。

第二、开放封闭原则（OCP）,即一个软件实体（类，模块，函数等）应该可以扩展，但是不可修改。

这样可以降低程序的维护成本，以及增加软件的可扩展性。

第三、里氏代换原则（LSP）,它要求子类必须能够替换其父类，如果父类可以接受所有类型的对象，那么子类也必须遵守这个原则。

LSP可以帮助我们编写出可维护和扩展的程序。

第四、接口隔离原则（ISP）,它要求一个接口应该只有一个职责，每个接口应该尽量被保持小而聚焦。

Alisp引入了一种结构，将大的接口拆分为多个小接口，这样可以减少类的耦合，降低系统的复杂度，提高可维护性和可扩展性。

第五、依赖反转原则（DIP），最重要的原则之一，它强调高层模块不应该依赖低层模块，二者都应该依赖于抽象，同时也要鼓励以抽象为基础实现解耦，依赖反转从根本上决定了软件的可维护性，使用它可以使程序更具有弹性，可以更好地处理变化。

第六、合成复用原则，它要求对象组合，而非仅仅是继承。

这样的设计可以提高代码的复用性，并使得代码之间的耦合降低，这样可以把高层模块与低层模块分离，构成可维护和可拓展的软件体系结构。

面向对象设计的原则是软件设计的基本准则，它可以为软件开发建立一个结构，提高软件的可维护性以及可扩展性。

面向对象六大原则面向对象六大原则是指软件开发中的六个原则，通常缩写为SOLID。

这些原则是由Robert C. Martin于21世纪初提出的，旨在帮助开发人员编写可维护、可扩展、易于理解的软件。

SOLID原则分别指单一职责原则、开放-封闭原则、里氏替换原则、依赖倒置原则、接口隔离原则和迪米特法则。

下面将分别介绍这些原则：一、单一职责原则(SRP)单一职责原则是指每个类都应该只有一个单一的功能，或者说只有一个职责。

这样做的好处是使得类更加专注，更加容易维护和扩展。

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

这样做的好处是使得软件更加稳定、可靠，同时易于维护和扩展。

三、里氏替换原则(LSP)里氏替换原则是指程序中的对象应该能够被它们的子类替换。

也就是说，子类应该与其父类一样能够使用。

这样做的好处是提高代码的可读性和可维护性。

四、依赖倒置原则(DIP)依赖倒置原则是指高层模块不应该依赖于低层模块，它们应该依赖于抽象接口。

这样做的好处是提高代码的可扩展性和可复用性。

五、接口隔离原则(ISP)六、迪米特法则(LoD)迪米特法则是指一个对象应该只与其直接的邻居发生交互联系，而不应该与非直接的邻居发生交互联系。

这样做的好处是提高代码的可维护性和可扩展性。

总的来说，面向对象六大原则是一组非常重要的指导原则，它们可以帮助开发人员编写高质量、易于维护的软件代码。

如果你是一名软件开发人员，务必要熟练掌握这些原则，并在实践中加以应用。

面向对象设计的几大原则面向对象设计中的几大原则是软件开发中的基础原则，用于指导良好的设计和编码实践。

这些原则包括单一职责原则、开放封闭原则、里氏替换原则、依赖倒置原则和接口隔离原则。

下面将详细介绍每个原则的含义和相关参考内容。

1. 单一职责原则（Single Responsibility Principle，SRP）：单一职责原则指的是一个类或模块应该有且只有一个引起变化的原因，即一个类或模块只负责一个职责。

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

参考内容：- 《敏捷软件开发：原则、模式与实践》 - Robert C. Martin - 《重构：改善既有代码的设计》 - Martin Fowler2. 开放封闭原则（Open-Closed Principle，OCP）：开放封闭原则指的是软件实体（类、模块、函数等）应该是可扩展的，但是不可修改的。

也就是说，当需求发生变化时，应该通过添加新的代码来扩展，而不是修改原有的代码。

参考内容：- 《设计模式：可复用面向对象软件的基础》 - Erich Gamma, Richard Helm, Ralph Johnson, John Vlissides- 《重构与模式》 - Joshua Kerievsky3. 里氏替换原则（Liskov Substitution Principle，LSP）：里氏替换原则指的是子类应该能够替换掉父类并且表现出相同的行为，即使用父类对象的地方都可以用子类对象来代替。

这样可以确保继承关系的正确性和灵活性。

参考内容：- 《面向对象设计原则与模式》 - Craig Larman- 《C++多态和继承关系》 - Scott Meyers4. 依赖倒置原则（Dependency Inversion Principle，DIP）：依赖倒置原则指的是高层模块不应该依赖于低层模块，二者都应该依赖于抽象接口；抽象接口不应该依赖于具体实现，而具体实现应该依赖于抽象接口。

面向对象六大原则面向对象（Object-Oriented）是当今用于软件开发领域最流行的一种方法，因为它可以使程序员更有效地创建，维护和操纵软件系统。

此外，面向对象也是一种结构化的，有秩序的编程范例，它由六大原则组成，为程序员提供了一个明确的指导，以便他们可以写出更加有效的代码。

这六大原则分别是：单一职责原则（Single Responsibility Principle）、接口隔离原则（Interface Segregation Principle）、开闭原则（Open/Closed Principle）、传递依赖原则（Dependency Inversion Principle）、里氏替换原则（Liskov Substitution Principle）和合成复用原则（Composite Reuse Principle）。

首先，单一职责原则（Single Responsibility Principle）要求每一个类应该负责一个单独的职责，即一个类只负责一项功能。

这种原则的好处是，它可以防止程序员将太多的功能集中在一个类中，从而导致混乱和复杂。

其次，接口隔离原则（Interface Segregation Principle）强调的是，客户端不应该依赖它不需要的接口。

这种设计原则的目的是为了减少接口中方法的数量，程序员可以根据最终程序使用的功能，定义更加合理的接口，以避免多余的操作和负担。

第三，开闭原则（Open/Closed Principle）认为，程序应该对扩展开放，而对修改关闭。

这一原则提倡设计出可以在不修改源代码的情况下，通过扩展和重写模块来实现需求变化。

这样可以有效地避免源代码的修改，从而使软件的维护变得更加容易。

第四，传递依赖原则（Dependency Inversion Principle）要求，高层模块不应当依赖低层模块，两者都应当依赖其抽象，而抽象不应当依赖细节。

依赖倒置的好处在于，可以让高层模块和低层模块之间的耦合度较低，从而减少模块之间的连接性，提高软件系统的可维护性和可扩展性。

⾯向对象的七⼤基本原则和实例详解单⼀职责原则定义：⼀个类只负责⼀个领域的相应职责。

开闭原则定义：软件实体应对扩展开放，⽽对修改关闭。

⾥⽒替换原则定义：所有引⽤基类的对象能够透明的使⽤其⼦类的对象。

依赖倒转原则定义：抽象不应该依赖于细节，细节依赖于抽象。

接⼝隔离原则定义：使⽤多个专门的接⼝，⽽不是使⽤单⼀总接⼝。

合成复⽤原则定义：尽量使⽤对象组合，⽽不是继承来达到复合⽬的。

迪⽶特法则定义：⼀个软件实体应当尽可能少的与其它实体发⽣相互作⽤。

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) 接口隔离原则；---- 应当为客户端提供尽可能小的单独的接口，而不是提供大的总的接口。

5) 组合/聚合复用原则；尽量使用合成/聚合达到复用，尽量少用继承。

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

6) “迪米特”法则；----- 又叫最少知识原则，一个软件实体应当尽可能少的与其他实体发生相互作用。

7) 单一职责原则。

---- 每一个类应该专注于做一件事情。

二、开闭原则OCP：开闭原则是设计原则基础的基础，是java 面向对象的核心原则，其它原则均围绕开闭原则进行展开。

开闭原则指的是一个软件实体应对对扩展开放，对修改关闭(Software entities should be open for extension, but closed for modification) 。

这个原则是说在设计一个模块的时候，应对使这个模块可以在不被修改的前提下被扩展，换言之，应对可以不必修改源代码的情况下改变这个模块的行为。

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

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

☆实现开闭原则的关键抽象化是解决问题的关键，在面向对象的编程语言里，可以给系统定义出一套相对较为固定的抽象设计，此设计允许无穷无尽的行为在实现层被实现。

在语言里，可以给出个或多个抽象类或者接口，规定出所有的具体类必须提供的方法的特征作为系统设计的抽象层。

这个抽象层预见了所有的可扩展性，因此，在任何扩展情况下都不会改变。

这就使得系统的抽象不需要修改，从而满足了开闭原则的第二条，对修改关闭。