java七大设计原则

1.开闭原则(Open Close Principle)

定义:一个软件实体如类、模块和函数应该对扩展开放,对修改关闭。

开放-封闭原则的意思就是说,你设计的时候,时刻要考虑,尽量让这个类是足够好,写好了就不要去修改了,如果新需求来,我们增加一些类就完事了,原来的代码能不动则不动。这个原则有两个特性,一个是说“对于扩展是开放的”,另一个是说“对于更改是封闭的”。面对需求,对程序的改动是通过增加新代码进行的,而不是更改现有的代码。这就是“开放-封闭原则”的精神所在

2.里氏代换原则(Liskov Substitution Principle)

定义1:如果对每一个类型为 T1的对象 o1,都有类型为 T2 的对象o2,使得以 T1定义的所有程序 P 在所有的对象 o1 都代换成 o2 时,程序 P 的行为没有发生变化,那么类型 T2 是类型 T1 的子类型。

定义2:子类型必须能够替换掉它们的父类型。
    描述:一个软件实体如果使用的是一个父类的话,那么一定适用于其子类,而且它察觉不出父类对象和子类对象的区别,也就是说,在软件里面,把父类都替换成它的子类,程序的行为没有变化
例子:在生物学分类上,企鹅是一种鸟,但在编程世界里,企鹅却不能继承鸟。在面向对象设计时,子类拥有父类所有非private的行为和属性,鸟会飞,但企鹅不会飞,所以企鹅不能继承鸟类。

只有当子类可以替换掉父类,软件单位的功能不受影响时,父类才能真正被复用,而子类也能够在父类的基础上增加新的行为,正是有里氏代换原则,使得继承复用成为了可能。正是由于子类型的可替换性才使得使用父类类型的模块在无需修改的情况下就可以扩展,不然还谈什么扩展开放,修改关闭呢

里氏替换原则通俗的来讲就是:子类可以扩展父类的功能,但不能改变父类原有的功能。它包含以下4层含义:

1.子类可以实现父类的抽象方法,但不能覆盖父类的非抽象方法。

2.子类中可以增加自己特有的方法。

3.当子类的方法重载父类的方法时,方法的前置条件(即方法的形参)要比父类方法的输入参数更宽松。

4.当子类的方法实现父类的抽象方法时,方法的后置条件(即方法的返回值)要比父类更严格。

看上去很不可思议,因为我们会发现在自己编程中常常会违反里氏替换原则,程序照样跑的好好的。所以大家都会产生这样的疑问,假如我非要不遵循里氏替换原则会有什么后果?

后果就是:你写的代码出问题的几率将会大大增加。

3.依赖倒转原则(Dependence Inversion Principle)

定义:高层模块不应该依赖低层模块,二者都应该依赖其抽象;抽象不应该依赖细节;细节应该依赖抽象。即针对接口编程,不要针对实现编程

依赖倒转其实就是谁也不要依靠谁,除了约定的接口,大家都可以灵活自如。依赖倒转可以说是面向对象设计的标志,用哪种语言来编写程序不重要,如果编写时考虑的都是如何针对抽象编程而不是针对细节编程,即程序中所有的依赖关系都是终止于抽象类或者接口,那就是面向对象的设计,反之那就是过程化的设计了。如果设计的各个部件或类相互依赖,这样就是耦合度高,难以维护和扩展,这也就体现不出面向对象的好处了。

依赖倒转原则,好比一个团队,有需求组,开发组,测试组,开发组和测试组都是面对同样的需求后,做自己相应的工作,而不应该是测试组按照开发组理解的需求去做测试用例,也就是说开发组和测试组都是直接面向需求组工作,大家的目的是一样的,保证产品按时上线,需求是不依赖于开发和测试的。

依赖倒置原则基于这样一个事实:相对于细节的多变性,抽象的东西要稳定的多。以抽象为基础搭建起来的架构比以细节为基础搭建起来的架构要稳定的多。在java中,抽象指的是接口或者抽象类,细节就是具体的实现类,使用接口或者抽象类的目的是制定好规范和契约,而不去涉及任何具体的操作,把展现细节的任务交给他们的实现类去完成。

依赖倒置原则的中心思想是面向接口编程,传递依赖关系有三种方式,以上的说的是是接口传递,另外还有两种传递方式:构造方法传递和setter方法传递,相信用过Spring框架的,对依赖的传递方式一定不会陌生。

在实际编程中,我们一般需要做到如下3点:

低层模块尽量都要有抽象类或接口,或者两者都有。

变量的声明类型尽量是抽象类或接口。

使用继承时遵循里氏替换原则。

总之,依赖倒置原则就是要我们面向接口编程,理解了面向接口编程,也就理解了依赖倒置。

4.接口隔离原则(Interface Segregation Principle)

接口隔离原则的含义是:建立单一接口,不要建立庞大臃肿的接口,尽量细化接口,接口中的方法尽量少。也就是说,我们要为各个类建立专用的接口,而不要试图去建立一个很庞大的接口供所有依赖它的类去调用。在程序设计中,依赖几个专用的接口要比依赖一个综合的接口更灵活。接口是设计时对外部设定的“契约”,通过分散定义多个接口,可以预防外来变更的扩散,提高系统的灵活性和可维护性。

说到这里,很多人会觉的接口隔离原则跟单一职责原则很相似,其实不然。其一,单一职责原则原注重的是职责;而接口隔离原则注重对接口依赖的隔离。其二,单一职责原则主要是约束类,其次才是接口和方法,它针对的是程序中的实现和细节;而接口隔离原则主要约束接口接口,主要针对抽象,针对程序整体框架的构建。

采用接口隔离原则对接口进行约束时,要注意以下几点:

1. 接口尽量小,但是要有限度。对接口进行细化可以提高程序设计灵活性是不挣的事实,但是如果过小,则会造成接口数量过多,使设计复杂化。所以一定要适度。

2. 为依赖接口的类定制服务,只暴露给调用的类它需要的方法,它不需要的方法则隐藏起来。只有专注地为一个模块提供定制服务,才能建立最小的依赖关系。

3. 提高内聚,减少对外交互。使接口用最少的方法去完成最多的事情。

运用接口隔离原则,一定要适度,接口设计的过大或过小都不好。设计接口的时候,只有多花些时间去思考和筹划,才能准确地实践这一原则。

4.组合/聚合复用原则

就是说要尽量的使用合成和聚合,而不是继承关系达到复用的目的
该原则就是在一个新的对象里面使用一些已有的对象,使之成为新对象的一部分:新的对象通过向这些对象的委派达到复用已有功能的目的。
      其实这里最终要的地方就是区分“has-a”和“is-a”的区别。相对于合成和聚合,
继承的缺点在于:父类的方法全部暴露给子类。父类如果发生变化,子类也得发生变化。聚合的复用的时候就对另外的类依赖的比较的少。。
合成/聚合复用
① 优点:
新对象存取成分对象的唯一方法是通过成分对象的接口;
 这种复用是黑箱复用,因为成分对象的内部细节是新对象所看不见的;

这种复用支持包装;
这种复用所需的依赖较少;
每一个新的类可以将焦点集中在一个任务上;
 这种复用可以在运行时动态进行,新对象可以使用合成/聚合关系将新的责任委派到合适的对象。
② 缺点:
通过这种方式复用建造的系统会有较多的对象需要管理。

继承复用
① 优点:
  新的实现较为容易,因为基类的大部分功能可以通过继承关系自动进入派生类;
  修改或扩展继承而来的实现较为容易。
② 缺点:
  继承复用破坏包装,因为继承将基类的实现细节暴露给派生类,这种复用也称为白箱复用;
  如果基类的实现发生改变,那么派生类的实现也不得不发生改变;
  从基类继承而来的实现是静态的,不可能在运行时发生改变,不够灵活。
6.迪米特法则(Law Of Demeter)

迪米特法则其根本思想,是强调了类之间的松耦合,类之间的耦合越弱,越有利于复用,一个处在弱耦合的类被修改,不会对有关系的类造成影响,也就是说,信息的隐藏促进了软件的复用。

自从我们接触编程开始,就知道了软件编程的总的原则:低耦合,高内聚。无论是面向过程编程还是面向对象编程,只有使各个模块之间的耦合尽量的低,才能提高代码的复用率。低耦合的优点不言而喻,但是怎么样编程才能做到低耦合呢?那正是迪米特法则要去完成的。

迪米特法则又叫最少知道原则,最早是在1987年由美国Northeastern University的Ian Holland提出。通俗的来讲,就是一个类对自己依赖的类知道的越少越好。也就是说,对于被依赖的类来说,无论逻辑多么复杂,都尽量地的将逻辑封装在类的内部,对外除了提供的public方法,不对外泄漏任何信息。迪米特法则还有一个更简单的定义:只与直接的朋友通信。首先来解释一下什么是直接的朋友:每个对象都会与其他对象有耦合关系,只要两个对象之间有耦合关系,我们就说这两个对象之间是朋友关系。耦合的方式很多,依赖、关联、组合、聚合等。其中,我们称出现成员变量、方法参数、方法返回值中的类为直接的朋友,而出现在局部变量中的类则不是直接的朋友。也就是说,陌生的类最好不要作为局部变量的形式出现在类的内部。

一句话总结就是:一个对象应该对其他对象保持最少的了解。

7.单一职责原则(Single Responsibility Principle)

定义:不要存在多于一个导致类变更的原因。通俗的说,即一个类只负责一项职责,应该仅有一个引起它变化的原因

说到单一职责原则,很多人都会不屑一顾。因为它太简单了。稍有经验的程序员即使从来没有读过设计模式、从来没有听说过单一职责原则,在设计软件时也会自觉的遵守这一重要原则,因为这是常识。在软件编程中,谁也不希望因为修改了一个功能导致其他的功能发生故障。而避免出现这一问题的方法便是遵循单一职责原则。虽然单一职责原则如此简单,并且被认为是常识,但是即便是经验丰富的程序员写出的程序,也会有违背这一原则的代码存在。为什么会出现这种现象呢?因为有职责扩散。所谓职责扩散,就是因为某种原因,职责P被分化为粒度更细的职责P1和P2。

遵循单一职责原的优点有:

1.可以降低类的复杂度,一个类只负责一项职责,其逻辑肯定要比负责多项职责简单的多;

2.提高类的可读性,提高系统的可维护性;

3.变更引起的风险降低,变更是必然的,如果单一职责原则遵守的好,当修改一个功能时,可以显著降低对其他功能的影响。

需要说明的一点是单一职责原则不只是面向对象编程思想所特有的,只要是模块化的程序设计,都需要遵循这一重要原则。

时间: 2024-10-10 03:00:38

java七大设计原则的相关文章

GOF 的23种JAVA常用设计模式总结 03 面向对象七大设计原则

在软件开发中,为了提高软件系统的可维护性和可复用性,增加软件的可扩展性和灵活性,程序员要尽量根据 7 条原则来开发程序,从而提高软件开发效率.节约软件开发成本和维护成本. 各位代码界的大佬们总结出的七大设计原则,还是需要好好了解一下 1.开闭原则 开闭原则(Open Closed Principle,OCP)由勃兰特·梅耶(Bertrand Meyer)提出,他在 1988 年的著作<面向对象软件构造>(Object Oriented Software Construction)中提出:软件实

24种设计模式及七大设计原则

设计模式 七大设计原则 : 单一职责原则:            Single Responsibility Principle                一个类只负责一项职责    SRP 里氏替换原则:            Liskov Substitution Principle                   所有引用基类的地方,必须能透明地使用其子类的对象    LSP 依赖倒置原则:            Dependence Inversion Principle   

面向对象的七大设计原则

面向对象七大设计原则 1.开闭原则(OCP:Open-Closed Principle) 2.里氏替换原则(LSP:Liskov Substitution Principle) 3.单一职责原则(SRP:Single responsibility principle) 4.接口隔离原则(ISP:Interface Segregation Principle) 5.依赖倒置原则(DIP:Dependence Inversion Principle) 6.迪米特法则(LOD:Law of Demet

浅谈Java六大设计原则

笔者刚接触设计原则的时候,觉得一头雾水,不知道他有什么用.在经历了一段时间的代码加上了解Java设计模式之后.笔者忽然觉得自己以前写的代码就是一堆*.所以,笔者认为设计原则和设计模式对于软件编程设计(非码农)来说是至关重要的事情.相信很多学习编程的人,和我有同样的感受. 我对设计模式和设计原则的理解是:如果把程序员比作武侠,那么设计模式就是修炼内功的易筋经,设计原则就是修炼内功的心法总纲,而具体的技术实现(代码编写)就是罗汉拳.如果你只想自保,那么会罗汉拳就可以了(能够用代码实现功能),不过如果

零散知识点(面向对象七大设计原则,jdbc--BaseDao,jsp九大内置对象。四个作用域)

面向对象七大设计原则: 1.开闭原则(OCP:Open-Closed Principle)2.里氏替换原则(LSP:Liskov Substitution Principle) 3.单一职责原则(SRP:Single responsibility principle)4.接口隔离原则(ISP:Interface Segregation Principle)5.依赖倒置原则(DIP:Dependence Inversion Principle)6.迪米特法则(LOD:Law of Demeter)

Java面向对象设计原则

面向对象设计原则是OOPS(Object-Oriented Programming System,面向对象的程序设计系统)编程的核心,但大多数Java程序员追逐像Singleton.Decorator.Observer这样的设计模式,而不重视面向对象的分析和设计.甚至还有经验丰富的Java程序员没有听说过OOPS和SOLID设计原则,他们根本不知道设计原则的好处,也不知道如何依照这些原则来进行编程. 众所周知,Java编程最基本的原则就是要追求高内聚和低耦合的解决方案和代码模块设计.查看Apac

多态、。。。七大设计原则。。。。

多态定义 不同的对象对于同意操作,做出的响应不同,就是多态 里氏替换: 在一个软件系统,如果子类出现在父类的位置,而整个软件功能又没有影响,那么咱们称为里氏替换 用父类变量,保存子类对象调用的事子类还是父类的 只有在多态的条件下,才调用子类的方法,其他都是调用父类的方法 七大设计原则 SRP:单一职责原则 定义 一个对象应该只包含单一的职责,并且该职责被完整地封装在一个类中 或者:就是一个类而言,应该仅有一个引起它变换的原因 分析 一个类(或者大到模块,小到方法)承担的职责越多,它被复用的可能性

面向对象开发中的七大设计原则和23种设计模式

一.面向对象开发中的七大设计原则 软件开发中最核心的思想就是"高内聚,低耦合",主要的目的也是为了方便后期的维护和变更.下面的设计原则也是依靠这个核心思想衍生出来的. 1.单一职责原则[SINGLE RESPONSIBILITY PRINCIPLE]:单一职责原则想表达的核心思想就是"高内聚",一个模块只完成一项功能.在面向对象设计中,一个类只应该负责一项职责,如果同时承担太多职责,就等于把这些职责耦合在了一起. 后面很可能因为某项职责的变更而导致其他职责的削弱或者

设计模式 - 七大设计原则(一)

设计模式 - 七大设计原则(一) 概述 简单介绍一下七大设计原则: 开闭原则:是所有面向对象设计的核心,对扩展开放,对修改关闭 依赖倒置原则:针对接口编程,依赖于抽象而不依赖于具体 单一职责原则:一个接口只负责一件事情,只能有一个原因导致类变化 接口隔离原则:使用多个专门的接口,而不是使用一个总接口 迪米特法则(最少知道原则):只和朋友交流(成员变量.方法输入输出参数),不和陌生人说话,控制好访问修饰符 里氏替换原则:子类可以扩展父类的功能,但不能改变父类原有的功能 合成复用原则:尽量使用对象组