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的子类型。

这样说有点复杂,其实有一个简单的定义

所有引用基类的地方必须能够透明地使用其子类的对象。

里氏替换原则通俗的去讲就是:子类可以去扩展父类的功能,但是不能改变父类原有的功能。他包含以下几层意思:

  • 子类可以实现父类的抽象方法,但是不能覆盖父类的非抽象方法。
  • 子类可以增加自己独有的方法。
  • 当子类的方法重载父类的方法时候,方法的形参要比父类的方法的输入参数更加宽松。
  • 当子类的方法实现父类的抽象方法时,方法的返回值要比父类更严格。

里氏替换原则之所以这样要求是因为继承有很多缺点,他虽然是复用代码的一种方法,但同时继承在一定程度上违反了封装。父类的属性和方法对子类都是透明的,子类可以随意修改父类的成员。这也导致了,如果需求变更,子类对父类的方法进行一些复写的时候,其他的子类无法正常工作。所以里氏替换法则被提出来。

确保程序遵循里氏替换原则可以要求我们的程序建立抽象,通过抽象去建立规范,然后用实现去扩展细节,这个是不是很耳熟,对,里氏替换原则和开闭原则往往是相互依存的。

依赖倒置原则

依赖倒置原则指的是一种特殊的解耦方式,使得高层次的模块不应该依赖于低层次的模块的实现细节的目的,依赖模块被颠倒了。这也是一个让人难懂的定义,他可以简单来说就是

高层模块不应该依赖底层模块,两者都应该依赖其抽象 抽象不应该依赖细节 细节应该依赖抽象

在Java 中抽象指的是接口或者抽象类,两者皆不能实例化。而细节就是实现类,也就是实现了接口或者继承了抽象类的类。他是可以被实例化的。高层模块指的是调用端,底层模块是具体的实现类。在Java中,依赖倒置原则是指模块间的依赖是通过抽象来发生的,实现类之间不发生直接的依赖关系,其依赖关系是通过接口是来实现的。这就是俗称的面向接口编程。

我们下面有一个例子来讲述这个问题。这个例子是工人用锤子来修理东西。我们的代码如下:

    

 1 public class Hammer {
 2     public String function(){
 3         return "用锤子修理东西";
 4     }
 5 }
 6
 7 public class Worker {
 8     public void fix(Hammer hammer){
 9         System.out.println("工人" + hammer.function());
10     }
11
12
13     public static void main(String[] args) {
14         new Worker().fix(new Hammer());
15     }
16 }

这个是一个很简单的例子,但是如果我们要新增加一个功能,工人用 螺丝刀来修理东西,在这个类,我们发现是很难做的。因为我们Worker类依赖于一个具体的实现类Hammer。所以我们用到面向接口编程的思想,改成如下的代码:

1 public interface Tools {
2     public String function();
3 }

然后我们的Worker是通过这个接口来于其他细节类进行依赖。代码如下:

 1 public class Worker {
 2     public void fix(Tools tool){
 3         System.out.println("工人" + tool.function());
 4     }
 5
 6
 7     public static void main(String[] args) {
 8         new Worker().fix(new Hammer());
 9         new Worker().fix(new Screwdriver());
10
11     }
12 }

我们的Hammer类与Screwdriver类实现这个接口

public class Hammer implements Tools{
    public String function(){
        return "用锤子修理东西";
    }
}

public class Screwdriver implements Tools{
    @Override
    public String function() {
        return "用螺丝刀修理东西";
    }
}

这样,通过面向接口编程,我们的代码就有了很高的扩展性,降低了代码之间的耦合度,提高了系统的稳定性。

接口隔离原则

接口隔离原则的定义是

客户端不应该依赖他不需要的接口

换一种说法就是类间的依赖关系应该建立在最小的接口上。这样说好像更难懂。我们通过一个例子来说明。我们知道在Java中一个具体类实现了一个接口,那必然就要实现接口中的所有方法。如果我们有一个类A和类B通过接口I来依赖,类B是对类A依赖的实现,这个接口I有5个方法。但是类A与类B只通过方法1,2,3依赖,然后类C与类D通过接口I来依赖,类D是对类C依赖的实现但是他们却是通过方法1,4,5依赖。那么是必在实现接口的时候,类B就要有实现他不需要的方法4和方法5 而类D就要实现他不需要的方法2,和方法3。这简直就是一个灾难的设计。

所以我们需要对接口进行拆分,就是把接口分成满足依赖关系的最小接口,类B与类D不需要去实现与他们无关接口方法。比如在这个例子中,我们可以把接口拆成3个,第一个是仅仅由方法1的接口,第二个接口是包含2,3方法的,第三个接口是包含4,5方法的。这样,我们的设计就满足了接口隔离原则。

以上这些设计思想用英文的第一个字母可以组成SOLID ,满足这个5个原则的程序也被称为满足了SOLID准则。

迪米特原则

迪米特原则也被称为最小知识原则,他的定义

一个对象应该对其他对象保持最小的了解。

因为类与类之间的关系越密切,耦合度越大,当一个类发生改变时,对另一个类的影响也越大,所以这也是我们提倡的软件编程的总的原则:低耦合,高内聚。迪米特法则还有一个更简单的定义

只与直接的朋友通信。首先来解释一下什么是直接的朋友:每个对象都会与其他对象有耦合关系,只要两个对象之间有耦合关系,我们就说这两个对象之间是朋友关系。耦合的方式很多,依赖、关联、组合、聚合等。其中,我们称出现成员变量、方法参数、方法返回值中的类为直接的朋友,而出现在局部变量中的类则不是直接的朋友。也就是说,陌生的类最好不要作为局部变量的形式出现在类的内部。

这里我们可以用一个现实生活中的例子来讲解一下。比如我们需要一张CD,我们可能去音像店去问老板有没有我们需要的那张CD,老板说现在没有,等有的时候你们来拿就行了。在这里我们不需要关心老板是从哪里,怎么获得的那张CD,我们只和老板(直接朋友)沟通,至于老板从他的朋友那里通过何种条件得到的CD,我们不关心,我们不和老板的朋友(陌生人)进行通信,这个就是迪米特的一个应用。说白了,就是一种中介的方式。我们通过老板这个中介来和真正提供CD的人发生联系。

总结

到这里,面向对象的六大原则,就写完了。我们看出来,这些原则其实都是应对不断改变的需求。每当需求变化的时候,我们利用这些原则来使我们的代码改动量最小,而且所造成的影响也是最小的。但是我们在看这些原则的时候,我们会发现很多原则并没有提供一种公式化的结论,而即使提供了公式化的结论的原则也只是建议去这样做。这是因为,这些设计原则本来就是从很多实际的代码中提取出来的,他是一个经验化的结论。怎么去用它,用好他,就要依靠设计者的经验。否则一味者去使用设计原则可能会使代码出现过度设计的情况。大多数的原则都是通过提取出抽象和接口来实现,如果发生过度的设计,就会出现很多抽象类和接口,增加了系统的复杂度。让本来很小的项目变得很庞大,当然这也是Java的特性(任何的小项目都会做成中型的项目)。

原文地址:https://www.cnblogs.com/geass-jango/p/11774976.html

时间: 2024-10-03 13:46:43

Java面向对象设计的六大原则的相关文章

面向对象设计的六大原则简介

实际上都是互补的,也就是说一些原则需要利用另一些原则来实现自己. 6大原则如下: 1)单一职责原则,一个合理的类,应该仅有一个引起它变化的原因,即单一职责,就是设计的这个类功能应该只有一个; 优点:消除耦合,减小因需求变化引起代码僵化. 2) 开-闭原则,讲的是设计要对扩展有好的支持,而对修改要严格限制. 优点:降低了程序各部分之间的耦合性,其适应性.灵活性.稳定性都比较好.当已有软件系统需要增加新的功能时,不需要对作为系统基础的抽象层进行修改,只需要在原有基础上附加新的模块就能实现所需要添加的

Java面向对象设计原则

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

【转】面向对象设计的SOLID原则

面向对象设计的SOLID原则 http://www.cnblogs.com/shanyou/archive/2009/09/21/1570716.html S.O.L.I.D是面向对象设计和编程(OOD&OOP)中几个重要编码原则(Programming Priciple)的首字母缩写. SRP The Single Responsibility Principle 单一责任原则 OCP The Open Closed Principle  开放封闭原则 LSP The Liskov Subst

# 61条面向对象设计的经验原则-《OOD启思录》Arthur J.Riel

61条面向对象设计的经验原则-<OOD启思录>Arthur J.Riel 原文 http://blog.csdn.net/cpluser/article/details/129291 61条面向对象设计的经验原则 摘抄自<OOD 启思录>--Arthur J.Riel 著 鲍志云 译 "你不必严格遵守这些原则,违背它们也不会被处以宗教刑罚.但你应当把这些原则看成警铃,若违背了其中的一条,那么警铃就会响起." ----------Arthur J.Riel (1)

java面向对象设计的原则

一.针对java类的6大设计原则 1.单一职责原则(Single Responsibility Principle,SRP) 即:对一个类而言,有且仅有一个引起它变化的原因.否则的话就应该把这个类进行拆分.在设计时让一个类只负责一种类型的责任. 单一职责原则的核心就是控制类的粒度大小.将对象解耦.提高内聚性.如果遵循单一职责原则将有以下优点: 降低类的复杂度.一个类只负责一项职责,其逻辑肯定要比负责多项职责简单得多. 提高类的可读性.复杂性降低,其可读性自然会提高. 提高系统的可维护性.可读性提

初识设计模式、软件设计的六大原则

总结:本篇文字分为两个部分.第一部分:设计模式基本常识:第二部分:软件设计中的六大原则,并详细分析了单一职责原则.(本篇文章的时间轴参考:为知笔记支撑文件夹\Java设计模式(时间序列图).vsdx) 部分一:初识设计模式 什么是设计模式?James拿到这个论点时,很是迷惑! 模式?是不是一个模子?模式识别--计算机领域的经典问题? 设计模拟?软件的设计模式?不懂!!! 但是在实际编码.调试过程中,James的遇到过很是难解的问题:工程代码中有过多的冗余代码--代码复用性不高:需求一旦改变,需要

设计模式 之 设计的 六大原则(6) 开放封闭原则

  开放封闭原则  定义:一个软件实体如类.模块和函数应该对扩展开放,对修改关闭. 问题由来:在软件的生命周期内,因为变化.升级和维护等原因需要对软件原有代码进行修改时,可能会给旧代码中引入错误,也可能会使我们不得不对整个功能进行重构,并且需要原有代码经过重新测试. 解决方案:当软件需要变化时,尽量通过扩展软件实体的行为来实现变化,而不是通过修改已有的代码来实现变化. 开闭原则是面向对象设计中最基础的设计原则,它指导我们如何建立稳定灵活的系统.开闭原则可能是设计模式六项原则中定义最模糊的一个了,

面向对象编程的六大原则(1)--单一职责原则

什么是单一职责 单一职责原则(Single responsibility principle,简称SRP),顾名思义,是指一个类或者一个模块应该有且只有一个职责,它是面向对象编程六大原则之一. 单一职责的粒度 单一职责的粒度,可以是某个方法.某个类.某个程序包甚至某个功能.某个模块(甚至某个系统),每一个层次上都可以进行单一职责设计.下面来举个例子说明一下: 模块级别:某购物平台,包含如下几个模块:用户模块.商品模块.订单模块.库存模块.运输模块.支付模块,每一个模块都已本身的职责:用户模块负责

OOP面向对象编程的六大原则(上)

名词解释: OOA:面向对象分析 A:Analyze OOD:面向对象设计D:Design OOP:面向对象编程P:Program OOP六大原则(上):对象单一职责.里式替换原则.迪米特法则.开闭原则 对象单一职责:我们设计的对象必须职责明确,不能让他成为万能类,这里的对象可以是模块.类库,程序集,不单单指类. 1.特点:最常见的.比如分层:Model.业务层.UI层.把具有相同行为的类.放到一个模块,这个就是模块职责明确. 2.好处:每个类所包含的行为,属性都属于本身,后续的维护更具有针对性