精华内容
下载资源
问答
  • 面向对象程序设计原则总结

    千次阅读 2018-09-07 17:26:50
    单一职责原则 就一个类而言 应该仅有一个引起它变化的原因 如果一个类承担的职责过多 就等于把这些职责耦合在一起 一个职责的变化可能会削弱或者抑制这个类完成其他职责的能力 这种耦合会导致脆弱的设计 当变化...

    单一职责原则
    就一个类而言 应该仅有一个引起它变化的原因
    如果一个类承担的职责过多 就等于把这些职责耦合在一起 一个职责的变化可能会削弱或者抑制这个类完成其他职责的能力 这种耦合会导致脆弱的设计 当变化发生时 设计会遭受到意想不到的破坏
    软件设计真正要做的许多内容 就是发现职责并把那些职责相互分离 如果你能够想到多于一个的动机去改变一个类 那么这个类就具有多于一个的职责

    开放-封闭原则
    是说软件实体(类 模块 函数等等)应该可以扩展 但是不可修改
    对于扩展是开放的 对于更改是封闭的
    怎样的设计才能面对需求的改变却可以保持相对稳定 从而使得系统可以在第一个版本以后不断推出新的版本呢 开放-封闭给我们答案
    无论模块是多么的封闭 都会存在一些无法对之封闭的变化 既然不可能完全封闭 设计人员必须对于他设计的模块应该对哪种变化封闭做出选择 他必须先猜测出最有可能发生的变化种类 然后构造抽象来隔离那些变化
    等到变化发生时立即采取行动
    在我们最初编写代码时 假设变化不会发生 当变化发生时 我们就创建抽象来隔离以后发生的同类变化
    面对需求 对程序的改动是通过增加新代码进行的 而不是更改现有的代码
    我们希望的是在开发工作展开不久就知道可能发生的变化 查明可能发生的变化所等待的时间越长 要创建正确的抽象就越困难
    开放-封闭原则是面向对象设计的核心所在 遵循这个原则可以带来面向对象技术所声称的巨大好处 也就是可维护 可扩展 可复用 灵活性好 开发人员应该仅对程序中呈现出频繁变化的那些部分做出抽象 然而 对于应用程序中的每个部分都刻意地进行抽象同样不是一个好主意 拒绝不成熟的抽象和抽象本身一样重要

    依赖倒转原则
    抽象不应该依赖细节 细节应该依赖于抽象
    针对接口编程 不要对实现编程
    高层模块不应该依赖低层模块 两个都应该依赖抽象

    里氏代换原则
    子类型必须能够替换掉它们的父类型
    一个软件实体如果使用的是一个父类的话 那么一定适用于其子类 而且它察觉不出父类对象和子类对象的区别 也就是说 在软件里面 把父类都替换成它的子类 程序的行为没有变化
    只有当子类可以替换掉父类 软件单位的功能不受到影响时 父类才能真正被复用 而子类也能够在父类的基础上增加新的行为
    由于子类型的可替换性才使得使用父类类型的模块在无需修改的情况下就可以扩展
    依赖倒转其实可以说是面向对象设计的标志 用哪种语言来编写程序不重要 如果编写时考虑的都是如何针对抽象编程而不是针对细节编程 即程序中所有的依赖关系都是终止于抽象类或者接口 那就是面向对象的设计 反之那就是过程化的设计了

    迪米特法则
    也叫最少知识原则 如果两个类不必彼此直接通信 那么这两个类就不应当发生直接的相互作用 如果其中一个类需要调用另一个类的某一个方法的话 可以通过第三者转发这个调用
    在类的结构设计上 每一个类都应当尽量降低成员的访问权限
    迪米特法则其根本思想 是强调了类之间的松耦合
    类之间的耦合越弱 越有利于复用 一个处在弱耦合的类被修改 不会对有关系的类造成波及

    展开全文
  • 本人在公司演讲的有关面向对象设计远程,和一些模式设计上的注意点!
  • 面向对象程序设计原则 什么是面向对象 为什么要使用面向对象? 面向对象设计的原则 超越面向对象 相关书籍推荐
  • 面向对象程序设计六大原则

    千次阅读 2017-07-11 17:16:23
    面向对象程序设计原则也是我们用于评价一个设计模式的重要指标之一。在设计模式中,很多设计模式都遵守了这些原则。 单一职责原则(Single Responsibility Principle) 里氏替换原则(Liskov Substitution ...

    面向对象程序设计中,需要遵守的原则可总结为6个,这就是大名鼎鼎的六大原则。面向对象程序设计原则也是我们用于评价一个设计模式的重要指标之一。在设计模式中,很多设计模式都遵守了这些原则。

    1. 单一职责原则(Single Responsibility Principle)
    2. 里氏替换原则(Liskov Substitution Principle)
    3. 依赖倒置原则(Dependence Inversion Principle)
    4. 接口隔离原则(Interface Segregation Principle)
    5. 迪米特法则(Law Of Demeter)
    6. 开闭原则(Open Close Principle)

    单一职责原则

    什么是单一职责原则
    单一职责原则(Single Responsibility Principle, SRP):即一个类只负责相应领域的职责,即不要存在多于一个导致类变更的原因。(There should never be more than one reason for a class to change。)

    起源
    罗伯特·C·马丁(Robert C. Martin)于《敏捷软件开发:原则、模式和实践》一书中给出。马丁表示此原则是基于汤姆·狄马克(Tom DeMarco)和Meilir Page-Jones的著作中的内聚性原则发展出的。

    为什么要使用单一职责原则
    一个类承担的职责越多,当一个职责变化时,其他职责受到影响的可能性就越大,软件出现错误的可能性就越大。

    优点

    • 降低类的复杂度。一个只有一个职责的类肯定比有多个职责的类要简单。
    • 降低因职责修改带来的风险。

    缺点

    • 说是缺点其实不准确。在实际操作中,想要遵循单一职责原则总是受到种种约束。要注意,原则是死的,人是活的,要根据实际情况来决定是否要遵循单一职责原则。

    问题
    1.有哪些设计模式遵循了单一职责原则

    • 迭代器模式。将聚合器类的遍历职责剥离出来,使聚合器类遵守“单一职责原则”。

    欢迎补充。

    里氏替换原则

    什么是里氏替换原则(Liskov Substitution Principle,LSP)
    严格定义:如果对每一个类型为 T1的对象 o1,都有类型为 T2 的对象o2,使得以 T1定义的所有程序 P 在所有的对象 o1 都代换成 o2 时,程序 P 的行为没有发生变化,那么类型 T2 是类型 T1 的子类型。

    通俗定义:任何基类可以出现的地方,子类一定可以出现。

    为什么要遵守里氏替换原则
    LSP是继承复用的基石,只有当衍生类可以替换掉基类,软件单位的功能不受到影响时,基类才能真正被复用,而衍生类也能够在基类的基础上增加新的行为。

    如何遵守里氏替换原则
    在程序中尽量使用基类类型来对对象进行定义,而在运行时再确定其子类类型,用子类对象来替换父类对象。

    优点
    待补充

    缺点
    待补充

    问题
    1.有哪些设计模式遵循了里氏替换原则

    待补充。

    依赖倒置原则

    什么是依赖倒置原则(Dependency Inversion Principle, DIP)
    依赖倒置原则两个要点:

    • 高层次的模块不应该依赖于低层次的模块,两者应该依赖于抽象。
    • 抽象不应该依赖于具体实现,具体实现应该依赖于抽象。

    为什么要遵守依赖倒置原则
    依赖倒置原则(Dependence Inversion Principle)要求程序依赖于抽象接口,不要依赖于具体实现。简单的说就是要求对抽象进行编程。一般情况下抽象的变化概率很小,让用户程序依赖于抽象,实现的细节也依赖于抽象。即使实现细节不断变动,只要抽象不变,程序就不需要变化。这大大降低了调用方与实现细节的耦合度。

    如何遵守依赖倒置原则

    • 变量的声明类型尽量是抽象类或接口。
    • 被引用的模块尽量都要有抽象类或接口,或者两者都有,引用它们时使用它们的抽象。

    优点
    待补充

    缺点
    待补充

    问题
    1.有哪些设计模式遵循了依赖倒置原则

    欢迎补充。

    接口隔离原则

    什么是接口隔离原则(Interface Segregation Principle, ISP)

    • 客户端不应该依赖它不需要的接口。
    • 一个类对另一个类的依赖应该建立在最小的接口上。

    为什么要遵守接口隔离原则
    需要什么用什么,把客户端不需要用的东西放在接口里,对客户端没有好处,而且需要承担这些不需要的东西所带来的风险。

    如何遵守接口隔离原则
    尽量细化接口,接口中的方法尽量少。即为各个类建立专用的接口,而不要试图去建立一个很庞大的接口供所有依赖它的类去调用。

    优点
    待补充

    缺点
    待补充

    问题

    1.有哪些设计模式遵循了接口隔离原则
    欢迎补充。

    迪米特法则

    什么是迪米特法则
    迪米特法则(Law of Demeter,LoD),又叫作最少知道原则(Least Knowledge Principle,LKP)。就是说一个对象应当对其他对象保持最少的了解。

    为什么要遵守迪米特法则
    类与类之间的关系越密切,耦合度越大,当一个类发生改变时,对另一个类的影响也越大。如果一个系统符合迪米特法则,那么当其中某一个模块发生修改时,就会尽量少地影响其他模块,扩展会相对容易。

    如何遵守迪米特法则
    尽量降低类与类之间的耦合。

    优点
    待补充

    缺点
    待补充

    问题

    1.有哪些设计模式遵循了迪米特法则

    • 外观模式。外观模式对客户端屏蔽子系统,客户端不需要了解子系统,直接访问外观类即可。
    • 责任链模式。请求发送者只负责创建责任链,不需要知道请求被哪个处理者处理,怎样处理。
    • 命令模式。请求者和接受者之间不存在直接引用,实现了解耦。
    • 中介者模式。中介者模式将各同事解耦,实现了“一个对象应当对其他对象保持最少的了解”。
    • 观察者模式。观察者和目标是抽象耦合的。目标只是维持了一个观察者的集合,而不知道任何一个观察者是属于哪个具体的类的。这样目标和观察者之间的耦合是最小的。

    认知有限,欢迎补充。

    开闭原则

    什么是开闭原则
    开闭原则(Open Closed Principle):一个软件实体应该对扩展开放,对修改关闭。

    软件实体
    软件实体指的是如类、模块和函数。

    为什么要遵守开闭原则
    需求的变动是任何一软件系统都难以避免的问题,在需求变动时,如果软件系统遵守开闭原则,那么就能不修改原有代码,而是在现有的代码的基础上进行扩展。在软件规模越来越大,寿命越来越长的今天,遵守开闭原则变得尤其重要。

    如何遵守软件符合开闭原则
    抽象化。

    优点
    待补充

    缺点
    待补充

    问题

    1.有哪些设计模式遵循了开闭原则

    • 工厂方法模式。在工厂方法模式中,当需要新增一种产品时,只需要新增一个产品类和工厂类即可,不需要修改原有代码。
    • 抽象工厂模式。增加新的具体工厂和产品族很方便,无须修改已有系统。
    • 建造者模式。指挥者类针对抽象建造者类编程,增加新的具体建造者无须修改原有类库的代码,系统扩展方便。
    • 适配器模式。可以在不修改原有代码的基础上增加新的适配器类。
    • 桥接模式。在抽象部分和实现部分两个变化维度中任意扩展一个维度,都不需要修改原有代码。
    • 组合模式。在组合模式中新增叶子构件和容器构件都很方便。
    • 装饰模式。客户端可以根据具体需要添加具体构建类和具体装饰类,并进行组合。
    • 责任链模式。想要新增一个处理者,只需要在客户端中重新建立链即可,原有系统不需要修改。
    • 命令模式。加入新的具体命令类不会影响原有系统。
    • 解释器模式。在解释器模式中,增加新的解释表达式较为方便。如果需要增加新的解释表达式,只需要对应增加一个新的终结符表达式或非终结符表达式类,原有表达式类代码无须修改。
    • 迭代器模式。由于有抽象聚合类和抽象迭代器类,添加新的聚合类和迭代器都不需要修改原有代码。
    • 中介者模式。如果需要引入新的具体同事类,只需要继承抽象同事类并实现其中的方法即可,由于具体同事类之间并无直接的引用关系,因此原有所有同事类无须进行任何修改,它们与新增同事对象之间的交互可以通过修改或者增加具体中介者类来实现。如果需要增加新的具体中介者类,只需要继承抽象中介者类(或已有的具体中介者类)并覆盖其中定义的方法即可,在新的具体中介者中可以通过不同的方式来处理对象之间的交互,也可以增加对新增同事的引用和调用。
    • 观察者模式。可以在不修改原有系统的条件下灵活的新建新的策略。
    • 模板方法模式。可以在不修改原有代码的前提下灵活的新增具体子类。
    • 部分遵守开闭原则。为什么说部分遵守呢?因为新增新的访问操作很方便,仅需要增加一个新的访问者即可在一个对象结构上定义一个新的操作。但如果需要新增元素类,要在抽象访问者角色中增加一个新的抽象操作,并在每一个具体访问者类中增加相应的具体操作。

    欢迎补充。

    展开全文
  • Java面向对象程序设计杨晓燕面向对象基本原则和模式PPT教案学习.pptx
  • 面向对象程序设计原则
  • Java面向对象程序设计面向对象的几个基本原则PPT教案学习.pptx
  • 面向对象拥有丰富的特性(封装、抽象、继承、多态),可以实现很多复杂的设计思路,是很多设计原则、设计模式编码实现的基础。 2. 面向对象四大特性 “封装”,封装也叫作信息隐藏或者数据访问保护。类通过暴露有限...

    面向对象

    1. 面向对象概述

    现在主流的编程范式或编程风格有三种,分别是面向过程、面向对象和函数式编程。面向对象又是这其中最主流的,现在大部分编程语言都是面向对象编程语言。大部分项目也是基于面向对象风格开发的。面向对象拥有丰富的特性(封装、抽象、继承、多态),可以实现很多复杂的设计思路,是很多设计原则、设计模式编码实现的基础。

    2. 面向对象四大特性

    “封装”,封装也叫作信息隐藏或者数据访问保护。类通过暴露有限的访问接口,授权外部仅能通过类的方法来访问内部信息或者数据。它需要编程语言提供全新访问控制机制的语法来支持,例如Java中的private、protected、public关键字。封装特性存在的意义,一方面是保护数据不被随意修改,提高代码可维护性;另一方面是仅仅暴露有限的必要接口,提高类的易用性。

    “抽象”,如果说封装主要是如何隐藏信息、保护数据,那抽象就是如何隐藏方法的具体实现,让使用者只需要关心方法提供了哪些功能,不用了解方法功能的具体实现细节。抽象可以通过接口或者抽象类来实现。抽象存在的意义,一方面是修改实现不需要改变定义;另一方面,它也是处理复杂系统的有效手段,能有效地过滤掉不必要关注的信息。

    “继承”,继承用来表示类之间的is-a关系,分为两种模式:单继承和多继承。单继承表示一个子类只继承一个父类,多继承表示一个子类可以继承多个父类。继承主要是用来解决代码复用的问题。

    “多态”,多态是指子类可以替换父类,在实际代码运行过程中,调用子类的方法实现。比如继承、接口类、ducktyping。多态可以提高代码的扩展性和复用性,是很多设计模式、设计原则、编程技巧的代码实现基础。

    3. 面向对象 VS 面向过程

    面向对象编程相比面向过程编程的优势主要有三个。

    对于大规模复杂程序的开发,程序的处理流程并非单一的一条主线,而是错综复杂的网状结构。面向对象编程比起面向过程编程,更能应对这种复杂类型的程序开发。
    面向对象有更加丰富的特性(封装、抽象、继承、多态)。利用这些特性编写出来的代码更容易扩展、复用、维护。
    面向对象编程语言比起面向过程编程语言,更加人性化、高级、智能。

    4. 面向对象分析、设计与编程

    面向对象分析(OOA)、面向对象设计(OOD)、面向对象编程(OOP),是面向对象开发的三个主要环节。简单点讲,面向对象分析就是要搞清楚做什么,面向对象设计就是要搞清楚怎么做,面向对象编程就是将分析和设计的结果翻译成代码的过程。

    面向对象编程基本的判断标准就是让代码尽量地满足“松耦合”、“高内聚”、单一职责、对扩展开放对修改关闭,尽量做到代码可复用、易读、易扩展、易维护。

    5. 接口 VS 抽象类

    抽象类不允许被实例化,只能被继承。它可以包含属性和方法。方法可以包括代码实现,也可以是抽象方法。子类继承抽象类,必须实现抽象类中的所有抽象方法。接口不能包含属性(Java可以定义静态常量),只能声明方法,方法不能包含代码实现(java8后可以有默认实现)。类实现接口的时候,必须实现接口中声明的所有方法。

    什么时候用抽象类?什么时候用接口?

    如果要表示一种 is-a 的关系,并且为了解决代码复用问题,我们就用抽象类,但是抽象类不能有太多层,不然阅读和维护起来会出现很多问题;如果要表示一种 has-a 关系,并且是为了解决抽象而非代码复用问题,那我们就用接口。

    6. 基于接口而非实现编程

    应用这条原则,可以将接口和现实相分离,封装不稳定的实现,暴露稳定的接口。上游系统面向接口编程,不依赖不稳定的实现细节,实现代码发生变化的时候,上游系统的代码基本上不需要做改动,降低耦合性,提高扩展性。

    越抽象、越顶层、越脱离具体某一实现的设计,越能提高代码的灵活性,越能应对未来的需求变化。

    7. 多用组合少用继承

    为什么不推荐使用继承?

    继承是面向对象的四大特性之一,用来表示类之间的 is-a关系,可以解决代码复用的问题。虽然继承有很多好处,但是继承的层次过深、过复杂,也会影响到代码的可维护性。在这种情况下,应尽量少用继承,甚至不用。

    组合相比继承有哪些优势?

    继承主要有三个作用:表示 is-a关系、支持多态性、代码复用。而这三个作用都可以通过组合、接口、委托三个技术手段来达成。除此之外,利用组合还能解决层次过深、过复杂的继承关系影响代码可维护性的问题。

    如何判断该用组合还是继承?

    在实际开发中,要根据情况,来选择该用继承还是组合。如果类之间的继承结构稳定,层次比较浅,关系不复杂,还有一些设计模式、特殊的应用场景,会固定使用继承或者组合。

    设计模式

    1. SOLID原则:SRP单一职责原则

    一个类只负责完成一个职责或者功能。单一职责原则通过避免设计大而全的类,避免不相关的功能耦合在一起,来提高类的内聚性。同时,类职责单一,类依赖的和被依赖的其他类也会变少,减少代码耦合,实现代码的高内聚、松耦合。但是,拆分的过细,实际上会适得其反,反倒降低内聚性,也会影响代码的可维护性。

    不同的场景、不同阶段的需求、不同业务,对同一个类的职责是否单一,可能有不同的判定结果,比如,出现下面这些情况就有可能说明这个类设计的不满足单一职责原则:

    类中的代码行数、函数或者属性过多;
    类依赖的其他类过多或者依赖类的其他类过多;
    私有方法过多;
    比较难给类起一个合适的名字;
    类中大量的方法都是几种操作类中的某几个属性。

    2. SOLID原则:OCP开闭原则

    如何理解 “ 对扩展开放、修改关闭 ”?

    添加一个新功能,应该是通过在已有代码基础上扩展代码(新增模块、类、方法、属性等),而非修改已有代码(修改模块、类、方法、属性等)的方式来完成。有亮点需要注意,第一是,开闭原则并不是完全杜绝修改,而是以最小的修改代码的代价完成新功能的开发。第二点是,同样的代码改动,在粗代码粒度下,可能被认定为 ‘修改“;在细粒度下,节能又被认定为 “扩展”。

    如何做到 “对扩展开放、修改关闭”?

    要时刻具备扩展意识、抽象意识、封装意识。写代码的时候多思考代码未来有可能变更的地方,如何设计代码结构,事先留好扩展点,好方便未来需求变更的时候,在不改变代码整体结构、做到最小代码改动,将新代码灵活的插入到扩展点上。

    3. SOLID原则:LSP里氏替换原则

    子类对象能够替换程序中父类对象出现的任何地方,并且保证原来程序的逻辑行为不变及正确性不被破坏。

    里氏替换原则是用来指导继承关系中子类该如何设计的一个原则。理解里氏替换原则,最核心的就是理解 “ design by contract,按照协议来设计 ”这几个子。父类定义了函数的约定,那子类可以改变函数的内部实现逻辑,但不能改变函数的原有 “约定”。这里的“约定”包括:函数声明要实现的功能;对输入、输出、异常的约定;甚至包括注释中所罗列的任何特殊说明。

    还要理解里氏替换原则跟多态的区别。虽然从定义描述和代码实现上来看他们有点类似,但是他们关注的角度是不一样的。多态是面向对象编程的一大特性,也是面向对象编程的一种语法,是一种代码实现的思路。而里氏替换原则,是用来知道继承关系中该如何设计,子类的设计要保证在替换父类的时候,不改变原有程序的逻辑及不破坏原有程序的正确性。

    4. SOLID原则:ISP接口隔离原则

    接口隔离原则的描述是:客户端不应该强迫依赖它不需要的接口。其中的“客户端”,可以理解为接口的调用者。理解“接口隔离原则”的重点是理解其中的 “接口”二字。这里有三种不同的理解。

    如果把“接口”理解为一组接口集合,可以是某个微服务接口,也可以是某个类库的接口等。如果部分接口只被部分调用者使用,我们就需要将这部分接口隔离出来,单独给这部分调用者使用,而不强迫其他调用者也依赖这部分不会被用到的接口。

    如果把“接口”理解为单个API接口或函数,部分调用者只需要函数中的部分功能,那我们就需要把函数拆分成粒度更细的多个函数,让调用者只依赖它需要的哪个细粒度函数。

    如果把“接口”理解为OOP中的接口,也可以理解为面向对象编程语言中的接口语法。那接口的设计要尽量单一,不要让接口的实现类和调用者,依赖不需要的接口函数。

    5. SOLID原则:DIP依赖倒置原则

    控制反转:实际上,控制反转是一个比较笼统的设计思想,不是一种具体的实现方法,一般用来指导框架层面的设计。控制-指的是对程序执行流程的控制,而反转-指的是在没有使用框架之前,程序员自己控制整个程序的执行。在使用框架之后,程序的执行流程通过框架来控制。

    依赖注入:依赖注入和控制反转恰恰相反,它是一种具体的编码技巧。不通过new的方式在类内部创建依赖类的对象,而是将依赖的类对象在外部创建好之后,通过构造函数、函数参数等方式传递(或注入)给类来使用。

    依赖注入框架:通过依赖注入框架提供的扩展点,简单配置需要的类及其类与类之间的依赖关系,可以由框架自动创建对象、管理对象的生命周期、依赖注入等原来本需要程序员来做的事情。

    依赖反转原则:依赖反转原则也叫做依赖倒置原则。跟控制反转有点类似,用来指导框架层面的设计。高层模块不依赖底层模块,他们共同依赖同一个抽象。抽象不需要依赖具体实现细节,具体实现细节依赖抽象。

    6. KISS、YAGNI原则

    KISS原则的中文描述是:尽量保持简单。KISS原则是保持代码可读和可维护的重要手段。KISS原则中的“简单”并不是以代码行数来考量的。代码行数越少并不代表代码越简单,我们还要考虑逻辑复杂度、实现难度、代码可读性等。

    对于如何写出满足KISS原则的代码,大概有几条知道原则:

    不要使用同时可能不懂的技术来实现代码;
    不要重复造轮子,善于使用已经有的工具类库;
    不要过度优化。
    YAGIN原则翻译过来就是:你不会需要它。在软件开发中的时候,它的意思是:不要去设计当前用不到的功能;不要去编写当前用不到的代码。大概就是不要过度的设计。

    YAGIN原则跟KISS原则并非一回事。KISS原则讲的是“如何做”的问题(尽量保持简单),而YAGIN原则说的是“要不要做”的问题(当前不需要的就不要做)。

    7. DRY原则

    DRY原则中文描述是:不要重复自己,也就是不要写重复的代码。

    大概有三种俯冲的情况:实现逻辑重复、功能语义重复、代码执行重复。

    8. LOD原则

    如何理解“高内聚、松耦合”?

    高内聚、松耦合是一个非常重要的设计思想,能够有效提高代码的可读性和可维护性,缩小功能改动呆滞的代码改动范围。“高内聚”用来指导类本身的设计,“松耦合”用来指导类与类之间依赖关系的设计。所谓高内聚,就是指相近的功能应该放到同一个类中,不相近的功能不要放到同一个类中。所谓松耦合,就是在代码中,类与类之间的依赖关系简单清晰。即使两个类有依赖关系,一个类的代码改动也不会或者很少导致依赖类的代码改动。

    如何理解“迪米特法则”

    迪米特法则描述为:不该有直接依赖关系的类之间,不要有依赖;有依赖关系的类之间,尽量只依赖必要的接口。迪米特法则是希望减少类之间的耦合,让类越独立越好。每个类都应该少了解系统的其他部分。一旦发生变化,需要了解这一变化的类就会比较少。

    展开全文
  • 2010-1-10 1 * Java面向对象程序设计 第7章 配合面向对象程序设计>例子源代码一起使用 Power point 制作耿祥义 张跃平 面向对象的几个基本原则 2010-1-10 2 主要内容 UML类图简介 面向抽象原则 开-闭原则 多用组合少...
  • 面向对象程序设计原则

    1.面向对象与面向过程的区别

    我们常说C语言是面向过程的编程语言,而java、python、c++是面向对象的编程语言,那究竟什么是面向过程,什么是面向对象?

    1.1面向过程

    1.1.1 什么是面向过程

    以过程为中心,分析出解决问题所需要的步骤,然后用函数把这些步骤一步一步实现,使用的时候一个一个依次调用就可以了。

    1.2面向对象

    1.2.1 什么是面向对象

    面向对象是把构成问题事务分解成各个对象,建立对象的目的不是为了完成一个步骤,而是为了描叙某个事物在整个解决问题的步骤中的行为。

    1.2.2 为什么需要面向对象

    更符合人类认识现实世界的思维方式。面向过程中属性是属性,行为是行为,不是一个有机的整体,编写的代码难于维护与使用。
    面向对象的主要概念:抽象继承封装多态
    抽象是忽略问题中与当前目标无关的哪些方面,以便更充分地注意与当前目标有关的方面.
    所用的抽象有过程抽象数据抽象两类
    面向对象的软件开发方法的主要特点之一是采用了数据抽象的方法来构建程序的类与对象

    1.3面向过程(Procedure Oriented)与面向对象( object oriented)

    区别:
    面向过程:事物比较简单,可以用线性的思维去解决
    面向对象:事物比较复杂,使用简单的线性思维无法解决
    共同点
    都是解决实际问题的一种思维方式
    二者相辅相成,并不是对立
    解决复杂问题,通过面向对象方式便于我们宏观上把握事吴复杂的关心,方便我们分析整个系统;具体到微观操作,仍然使用面向过程方式来处理

    2.面向对象的三个基本特征

    2.1继承

    继承是指新的类可以获得已有类(基类或父类)的属性和行为,成新类为已有类的派生类(或子类)
    继承是一种联结类的层次模型,为类的重用提供了方便, 他提供了明确表述不同类之间共性的关系
    继承性有助于解决软件的可重用性问题,使用继承使程序结构清晰,降低了编码和维护的工作量
    继承特性中有多继承和单继承。单继承是指任何一个派生类都只有单一的直接父类;多继承是一个类可以用一个以上的直接父类。采用单继承的类层次结构为树状结构;采用多继承的类层次结构为网状结构,设计及实现复杂
    java语言只支持单继承

    2.2封装

    封装是一种信息隐蔽技术,是利用抽象数据类型将数据和基于数据的操作封装在一起.封装的目的在于将对象的使用者和设计者分开,使用者不必知道行为实现的细节,只需要使用设计者提供的消息来访问对象
    封装的定义
    1.清楚的边界,所有对象的内部信息被限定在这个边界内
    2.接口,即对象向外界提供的方法,外界可以通过这些方法与对象进行交互
    3.受保护的内部实现,即软件对象功能的实现细节,实现细节不能从类外访问
    好处
    由于封装特性禁止了外界直接操作类中的数据,模块与模块之间只能通过严格控制的接口进行交互,这使得模块之间的耦合度大大降低,从而保证了模块具有较好的独立性,使得程序维护和修改较为容易,保证了数据的安全性,隐藏了方法的实现细节,也方便了使用。

    2.3多态

    多态是指一个程序中同名的不同方法共存的情况。通过子类对父类的覆盖来实现多态。这样一来,不同类的对象响应同名的消息(方法)来完成特定的功能,但其具体的实现方法却可以不同
    多态性使语言具有灵活、抽象、行为共享、代码共享的优势,很好地解决了应用程序函数同名问题

    3.面向对象程序设计原则

    3.1单一职责原则(SRP)

    一个类,只有一个引起它变化的原因。应该只有一个职责。每一个职责都是变化的一个轴线,如果一个类有一个以上的职责,这些职责就耦合在了一起。这会导致脆弱的设计。当一个职责发生变化时,可能会影响其它的职责。另外,多个职责耦合在一起,会影响复用性
    原则的核心就是解耦和增强内聚性

    3.2开放封闭原则(OCP)

    设计要对扩展有好的支持,而对修改要严格限制。最重要、最为抽象的原则

    3.3里氏替换原则(LSP)

    子类必须能够替换基类,否则不应当设计为其子类。也就是说子类只能去扩展基类,而不是隐藏或覆盖基类。

    3.4依赖倒置原则(DIP)

    设计要依赖于抽象而不是具体化

    3.5接口隔离原则(ISP)

    将大的接口打散成多个小接口

    3.6迪米特法则或最少知识原则

    一个对象应当尽可能少的去了解其他对象

    3.7组合/聚合复用原则

    设计者首先应当考虑复合/聚合,而不是继承。这个就是所谓的“Favor Composition over Inheritance”,在实践中复合/聚合会带来比继承更大的利益,所以要优先考虑。

    展开全文
  • 面向对象程序设计语言和面向过程程序设计语言的区别由哪些? 面向对象的特点是:封装,继承,多态,其中多态又分为重载和重写,面向对象的编程思想更接近现实的事物 面向对象的优点:  1.编程更加容易,因为面向...
  • java面向对象程序设计的六(七)大基本原则
  • 可以快速学习到Java语言的精髓,和面向对象程序设计原则和思想
  • 一、面向抽象原则二、开闭原则三、多用组合少用继承原则四、高内聚低耦合原则
  • 第四部分 面向对象程序设计4.1 基本概念4.2 类的定义与使用4.3 self 参数4.4 类成员与实例成员4.4.1 修改属性的值4.5 成员4.6 方法4.7 继承机制4.7.1 子类的方法__init__()4.7.2 给子类定义属性和方法4.7.3 重写父类...
  • 面向对象程序设计中的概念主要包括:对象、类、数据抽象、继承、动态绑定、数据封装、多态性、消息传递。通过这些概念面向对象的思想得到了具体的体现。 面向对象编程(Object Oriented Programming,OOP,面向对象...
  • 面向对象设计原则

    千次阅读 2019-04-15 12:42:56
    文章目录一、设计原则概述1.1 面向对象设计原则概述:1.2 单一职责原则1.3 开闭原则1.4 里氏代换原则1.5 依赖倒转原则1.6 接口隔离原则1.7 合成复用原则1.8 迪米特法则 一、设计原则概述 1.1 面向对象设计原则概述...
  • C++基础---面向对象程序设计

    千次阅读 2015-09-13 16:12:40
    面向对象程序设计的一条基本原则是计算机程序是由单个能够起到子程序作用的单元或对象组合而成。 (2)面向对象程序设计是一种程序设计范型,同时也是一种程序开发的方法。对象指的是类的实例。它将
  • 面向对象程序设计六大原则总结

    千次阅读 2015-04-01 16:11:17
    原文... 一、“开-闭”原则(Open-Closed Principle,OCP)  1.1“开-闭”原则的定义及优点 1)定义:一个软件实体应当对扩展开放,对修改关闭( Software entities should be open for exte
  • 面向对象程序设计的五个基本原则

    千次阅读 热门讨论 2018-07-19 17:52:25
    面向对象程序设计一共有五个基本原则,分别是: 单一职责原则(SRP)、开放-封闭原则(OCP)、里氏替换原则(LSP)、依赖倒置原则(DIP)、接口隔离原则(ISP) 单一职责原则(SRP): WHAT:对于一个类而言,...
  • 带你了解面向对象设计原则

    千次阅读 2016-05-23 23:21:59
    一 摘要今天晚上给大家介绍一下面向对象设计原则,为什么要介绍这个呢,原因很简单,大家平时所接触的语言,无论是object-C,C++,JavaScrpt,C#等都是属于面向对象语言,既然是面向对象设计语言,那么就有必要去了解一下...
  • 面向对象设计原则

    万次阅读 2018-06-16 12:51:17
    面向对象设计原则 目前,笔者已知的23种设计模式(C++)都是要遵循面向对象设计原则。也就是说,面向对象设计原则是抽象类,而设计模式是一个具体的实例,我们也可以根据面向对象设计原则,设计出不同的设计模式。 ...
  • 【C++】面向对象程序设计

    千次阅读 2016-09-18 15:50:17
    面向对象程序设计 对象 面向对象的特征 封装 继承 多态
  • 七大面向对象设计原则开闭原则:面对需求,对程序的改动是通过增加新代码进行的,而不是改变原来的标题 依赖倒转原则:高层模块不应该依赖底层模块,两个都应该依赖与抽象;抽象不应该依赖于细节,细节应该依赖于...
  • 面向对象程序设计

    千次阅读 2011-10-23 22:26:22
    面向对象程序设计 求助编辑百科名片 面向对象编程(Object Oriented Programming,OOP,面向对象程序设计)是一种计算机编程架构。OOP 的一条基本原则是计算机程序是由单个能够起到子程序作用的单元或对象...
  • 程序架构师设计师必须掌握的面向对象程序设计原则    一个优秀的软件项目,除去优秀的界面设计和合理恰当的功能设计以外,其程序的架构设计也一定是优秀的,本文专门探讨面向对象的程序架构设计问题。这也是每一...
  • 面向对象设计模式设计原则 自己下了看吧,,面向对象程序设计时候的 几个基本原则了
  • 面向对象思想设计原则 •在实际的开发中,我们要想更深入的了解面向对象思想,就必须熟悉前人总结过的面向对象的思想的设计原则 •单一职责原则 •开闭原则 •里氏替换原则 •依赖注入原则 •接口分离原则 •...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 142,049
精华内容 56,819
关键字:

面向对象程序设计原则