面向对象六大原则

 

 

 

 

这篇文章主要讲的是面向对象设计中，应该遵循的六大原则。只有掌握了这些原则，才能更好的理解设计模式。
咱们接下来要介绍如下6个内容。

• 单一职责原则——SRP

• 开闭原则——OCP

• 里氏替换原则——LSP

• 依赖倒置原则——DIP

• 接口隔离原则——ISP

• 迪米特原则——LOD

 

 

0x01: 单一职责原则

单一职责原则的定义是就一个类而言，应该仅有一个引发他变化的缘由。也就是说一个类应该只负责一件事情。若是一个类负责了方法M1,方法M2两个不一样的事情，当M1方法发生变化的时候，咱们须要修改这个类的M1方法，可是这个时候就有可能致使M2方法不能工做。这个不是咱们期待的，可是因为这种设计却颇有可能发生。因此这个时候，咱们须要把M1方法，M2方法单独分离成两个类。让每一个类只专心处理本身的方法。
单一职责原则的好处以下：

1. 能够下降类的复杂度，一个类只负责一项职责，这样逻辑也简单不少

2. 提升类的可读性，和系统的维护性，由于不会有其余奇怪的方法来干扰咱们理解这个类的含义

3. 当发生变化的时候，能将变化的影响降到最小，由于只会在这个类中作出修改。

0x02: 开闭原则

开闭原则和单一职责原则同样，是很是基础并且通常是常识的原则。开闭原则的定义是软件中的对象(类，模块，函数等)应该对于扩展是开放的，可是对于修改是关闭的。
当需求发生改变的时候，咱们须要对代码进行修改，这个时候咱们应该尽可能去扩展原来的代码，而不是去修改原来的代码，由于这样可能会引发更多的问题。
这个准则和单一职责原则同样，是一个你们都这样去认为可是又没规定具体该如何去作的一种原则。
开闭原则咱们能够用一种方式来确保他，咱们用抽象去构建框架，用实现扩展细节。这样当发生修改的时候，咱们就直接用抽象了派生一个具体类去实现修改。

0x03: 里氏替换原则

里氏替换原则是一个很是有用的一个概念。他的定义

若是对每个类型为T1的对象o1,都有类型为T2的对象o2,使得以T1定义的全部程序P在全部对象o1都替换成o2的时候，程序P的行为都没有发生变化，那么类型T2是类型T1的子类型。

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

全部引用基类的地方必须可以透明地使用其子类的对象。

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

• 子类能够实现父类的抽象方法，可是不能覆盖父类的非抽象方法。

• 子类能够增长本身独有的方法。

• 当子类的方法重载父类的方法时候，方法的形参要比父类的方法的输入参数更加宽松。

• 当子类的方法实现父类的抽象方法时，方法的返回值要比父类更严格。

里氏替换原则之因此这样要求是由于继承有不少缺点，他虽然是复用代码的一种方法，但同时继承在必定程度上违反了封装。父类的属性和方法对子类都是透明的，子类能够随意修改父类的成员。这也致使了，若是需求变动，子类对父类的方法进行一些复写的时候，其余的子类没法正常工做。因此里氏替换法则被提出来。
确保程序遵循里氏替换原则能够要求咱们的程序创建抽象，经过抽象去创建规范，而后用实现去扩展细节，这个是否是很耳熟，对，里氏替换原则和开闭原则每每是相互依存的。

0x04: 依赖倒置原则

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

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

在Java 中抽象指的是接口或者抽象类，二者皆不能实例化。而细节就是实现类，也就是实现了接口或者继承了抽象类的类。他是能够被实例化的。高层模块指的是调用端，底层模块是具体的实现类。在Java中，依赖倒置原则是指模块间的依赖是经过抽象来发生的，实现类之间不发生直接的依赖关系，其依赖关系是经过接口是来实现的。这就是俗称的面向接口编程。
下面有一个例子来说述这个问题。这个例子是工人用锤子来修理东西。代码以下：

 

 

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

public class Worker {
    public void fix(Hammer hammer){
        System.out.println("工人" + hammer.function());
    }


    public static void main(String[] args) {
        new Worker().fix(new Hammer());
    }
}

 

这个是一个很简单的例子，可是若是咱们要新增长一个功能，工人用 螺丝刀来修理东西，在这个类，咱们发现是很难作的。由于咱们Worker类依赖于一个具体的实现类Hammer。因此咱们用到面向接口编程的思想，改为以下的代码：

 

 

public interface Tools {
    public String function();
}

而后咱们的Worker是经过这个接口来于与其余细节类进行依赖。代码以下：

 

 

public class Worker {
    public void fix(Tools tool){
        System.out.println("工人" + tool.function());
    }


    public static void main(String[] args) {
        new Worker().fix(new Hammer());
        new Worker().fix(new Screwdriver());

    }
}

Hammer类与Screwdriver类实现这个接口

 

 

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

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

 

这样，经过面向接口编程，咱们的代码就有了很高的扩展性，下降了代码之间的耦合度，提升了系统的稳定性。

0x05: 接口隔离原则

接口隔离原则的定义是

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

换一种说法就是类间的依赖关系应该创建在最小的接口上。这样说好像更难懂。咱们经过一个例子来讲明。咱们知道在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准则。

0x06：迪米特原则

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

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

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

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

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

总结

到这里，面向对象的六大原则，就写完了。咱们看出来，这些原则其实都是应对不断改变的需求。每当需求变化的时候，咱们利用这些原则来使咱们的代码改动量最小，并且所形成的影响也是最小的。可是咱们在看这些原则的时候，咱们会发现不少原则并无提供一种公式化的结论，而即便提供了公式化的结论的原则也只是建议去这样作。这是由于，这些设计原则原本就是从不少实际的代码中提取出来的，他是一个经验化的结论。怎么去用它，用好它，就要依靠设计者的经验。不然一味着去使用设计原则可能会使代码出现过分设计的状况。大多数的原则都是经过提取出抽象和接口来实现，若是发生过分的设计，就会出现不少抽象类和接口，增长了系统的复杂度。让原本很小的项目变得很庞大，固然这也是Java的特性（任何的小项目都会作成中型的项目）。

Java 的知识面很是广，面试问的涉及也很是普遍，重点包括：Java 基础、Java 并发，JVM、MySQL、数据结构、算法、Spring、微服务、MQ 等等，涉及的知识点何其庞大，因此咱们在复习的时候也每每无从下手，今天小编给你们带来一套 Java 面试题，题库很是全面，包括 Java 基础、Java 集合、JVM、Java 并发、Spring全家桶、Redis、MySQL、Dubbo、Netty、MQ 等等，包含 Java 后端知识点 2000 + ，部分以下：

资料获取方式：关注公众号：“程序员白楠楠”获取上述资料