面向对象的五大原则 之 单一职责和接口隔离原则

单一职责原则_{(Single-Responsibility）}

一个类，最好只做一件事，只有一个引起它的变化。

问题由来： 类T负责两个不同的职责：职责P1，职责P2。当由于职责P1需求发生改变而需要修改类T时，有可能会导致原本运行正常的职责P2功能发生故障。

在没有看到这个之前，其实在实际开发中已经在使用了~可以说是常识。

例如：用户修改密码时， 流程

1. 检查旧密码是否对得上
2. 更新密码
3. 记录操作日志

检查归检查，更新归更新，无论失败与否记录日志，各自执行各自，哪个环节出错找哪个环节，既：一环归一环。

1.不遵守单一职责原则

/**
 *
 *@author Saiuna
 *@date 2020/7/6 19:15
 */
public class SingleResponsibility1 {
    public static void main(String[] args) {
        Vehicle vehicle = new Vehicle();

        //显然飞机在公路上运行的不符合的。
        vehicle.run("汽车");
        vehicle.run("摩托车");
    }
}

class Vehicle{
    public void run(String vehicle) {
        System.out.println(vehicle + "在公路上运行。。。。");
    }
}

看似没啥问题，汽车/摩托在公路上运行，若是哪天来个飞机呢，那就变成了 飞机在公路上运行。。。。

走地ji？

2、在原来的类上进行修改添加不同的功能的方法，虽然在类级别上没有遵守单一职责原则，但在方法级别上俨然遵守了单一职责原则。

/**
 *
 *@author Saiuna
 *@date 2020/7/6 19:52
 */
public class SingleResponsibility3 {

    public static void main(String[] args) {
        Vehicle2 vehicle = new Vehicle2();
        vehicle.roadRun("汽车");
        vehicle.waterRun("轮船");
        vehicle.airRun("飞机");
    }
}

class Vehicle2{
    public void roadRun(String vehicle) {
        System.out.println(vehicle + "在公路上运行。。。。");
    }
    public void airRun(String vehicle) {
        System.out.println(vehicle + "在天空上运行。。。。");
    }
    public void waterRun(String vehicle) {
        System.out.println(vehicle + "在水上运行。。。。");
    }
}

单一职责原则可以看做是低耦合、高内聚在面向对象原则上的引申。

职责过多，可能引起它变化的原因就越多，这将导致职责依赖，相互之间就产生影响，从而大大损伤其内聚性和耦合度。

通常意义下的单一职责，就是指只有一种单一功能，不要为类实现过多的功能点，以保证实体只有一个引起它变化的原因。

但实际也不必过于追求单一职责，就好像数据库的三大范式,到后来也出现了逆范式总体而言，合适即可。

接口隔离原则_{（Interface-Segregation)}

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

使用多个小的专门的接口，而不要使用一个大的总接口。

看案例

public class Segregation1 {
    public static void main(String[] args) {
        A a = new A();
        a.depend1(new B());
        a.depend2(new B());
        a.depend3(new B());

        C c = new C();
        c.depend1(new D());
        c.depend4(new D());
    }
}

interface Intergface1{
    void operation1();
    void operation2();
    void operation3();
    void operation4();
}

class A{
    public void depend1(Intergface1 i){
        i.operation1();
    }
    public void depend2(Intergface1 i){
        i.operation2();
    }
    public void depend3(Intergface1 i){
        i.operation3();
    }
}

class C{
    public void depend1(Intergface1 i){
        i.operation1();
    }
    public void depend4(Intergface1 i){
        i.operation4();
    }
}
/**
 * 实现类中要实现接口的所有方法，这就导致原本不需要实现的方法也要实现， 
 * 导致代码冗余
 */
class B implements Intergface1{

    public void operation1() {
        System.out.println("B实现了operation1");
    }
    public void operation2() {
        System.out.println("B实现了operation2");
    }
    public void operation3() {
        System.out.println("B实现了operation3");
    }
    public void operation4() {
        System.out.println("B实现了operation4");
    }
}

class D implements Intergface1{

    public void operation1() {
        System.out.println("D实现了operation1");
    }

    public void operation2() {
        System.out.println("D实现了operation2");
    }

    public void operation3() {
        System.out.println("D实现了operation3");
    }

    public void operation4() {
        System.out.println("D实现了operation4");
    }
}

实现类中要实现当前接口的所有方法，这就导致原本不需要实现的方法也要实现，导致代码冗余，所以我们要对接口进行拆分，如下：

/**
 * @author saiuna
 * @date 2020/7/7 8:26
 */
public class Segregation2 {
    public static void main(String[] args) {

        A1 a1 = new A1();
        //A1通过接口使用B1的方法
        a1.depend1(new B1());
        a1.depend2(new B1());
        a1.depend3(new B1());

        C1 c1 = new C1();
        //C1通过接口使用D1的方法
        c1.depend1(new D1());
        c1.depend4(new D1());
    }
}

/**
 * 拆分为三个接口
 */
interface Intergface2_1{
    void operation1();
}
interface Intergface2_2{
    void operation2();
    void operation3();
}
interface Intergface2_3{
    void operation4();
    void operation5();
}

class A1{
    public void depend1(Intergface2_1 i){
        i.operation1();
    }
    public void depend2(Intergface2_2 i){
        i.operation2();
    }
    public void depend3(Intergface2_2 i){
        i.operation3();
    }
}

class C1{
    public void depend1(Intergface2_1 i){
        i.operation1();
    }
    public void depend4(Intergface2_3 i){
        i.operation4();
    }
}

class B1 implements Intergface2_1,Intergface2_2{

    public void operation1() {
        System.out.println("B实现了operation1");
    }
    public void operation2() {
        System.out.println("B实现了operation2");
    }
    public void operation3() {
        System.out.println("B实现了operation3");
    }

}

class D1 implements Intergface2_1,Intergface2_3{

    public void operation1() {
        System.out.println("D实现了operation1");
    }
    public void operation4() {
        System.out.println("D实现了operation4");
    }
}

接口隔离开来后，根据需求去实现不同的类，减少不必要的冗余。

将大接口分解为多个细化的方法，使得客户端仅仅依赖于它们的实际调用的方法

今天不学习，明天变辣鸡