java 七大设计原则之单一职责,接口隔离原则(文字代码相结合理解)

java 七大设计原则之单一职责,接口隔离原则(文字代码相结合理解)

Android小彩虹2021-07-16 5:40:2580A+A-

java 设计模式之七大设计原则,文字代码相结合理解

每做一事,最好只追求一个最在乎的目标,其余都可让步,这样达成目标的机会才高。比方:做这事,最在乎是学经验,那就别计较钱;做那事,最要紧是钱,那就别计较面子。以此类推。若做一事,又想学经验,又要赚得多,又要有面子。如此美事,有得等啊。

一款高效的app来自于程序员对细节的处理,以及对代码的规范,可读性等,经常听到要使用设计模式,设计模式有七大设计原则,所有的设计模式都必须遵守这七大设计原则来展开,今天带大家了解一下七大设计原则.

七大设计原则有哪些?

  • 单一职责原则
  • 接口隔离原则
  • 依赖倒转原则
  • 里氏替换原则
  • 开闭原则
  • 迪米特法则
  • 合成复用原则

通常大家理解的是前六个,并没有合成复用原则

为什么要使用七大设计原则?

  • 代码重用性(相同的代码不用多次编写);
  • 可读性(编程的规范性,便于其他程序员的阅读和理解);
  • 可拓展性(当需要添加新的功能时,非常的方便也称为可维护性);
  • 可靠性(当我们添加新的功能后对原来的功能没有影响);
  • 使程序呈现高内聚,低耦合等特性;

单一职责原则

我的电脑上只有android studio 所以运行的android项目,没有安装eclipse所以没有java项目

普通代码:

SingleBean singleBean = new SingleBean();
singleBean.run("小明");
singleBean.run("钢铁侠");

public class SingleBean {
    public void run(String title){
        Log.i("SingleBean",title+"在看电视..");
    }
}

效果图(1.1):
在这里插入图片描述

出现的问题:

  • 代码虽然没有问题,也不报错,但是呢如果这样写的话SingleBean这个类就有2个操作的逻辑,

    • 小明在看电视…
    • 钢铁侠在看电视…

如果说现在我想改代码逻辑为,小明在写作业呢?

SingleBean singleBean = new SingleBean();
singleBean.run("小明");
singleBean.run("钢铁侠");
        
public class SingleBean {
    public void run(String title){
        Log.i("SingleBean",title+"在写作业..");
    }
}

效果图(1.2):
在这里插入图片描述
可以看到,如果这样写的话代码就有问题了

我想改的是:小明在写作业 钢铁侠在看电视

修改代码,遵守单一职责原则:

方案一:

SingleBean singleBean = new SingleBean();
singleBean.run("小明");
singleBean.run2("钢铁侠");

public class SingleBean {
    public void run(String title){
        Log.i("SingleBean",title+"在写作业..");
    }
    public void run2(String title){
        Log.i("SingleBean",title+"在看电视..");
    }
}

效果图(1.3):
在这里插入图片描述
分析:

  • 这里虽然 没有在类上遵守单一职责原则,但是在方法上遵守了单一职责原则.

方案二:

SingleBean singleBean = new SingleBean();
singleBean.run("小明");
        
SingleBean2 singleBean2 = new SingleBean2();
singleBean2.run("钢铁侠");

public class SingleBean {
    public void run(String title){
        Log.i("SingleBean",title+"在写作业..");
    }
}

public class SingleBean2 {
    public void run(String title){
        Log.i("SingleBean",title+"在看电视..");
    }
}

分析:

  • 吧类拆开,增加了代码量,好处:代码可读性更高了
    效果图(1.4):
    在这里插入图片描述

总结:

  • 如果没有在类上准守单一职责原则,那么必须在方法上遵守单一职责原则.
  • 降低了类的复杂程度,一个类负责一项职责
  • 提高类的可读性,可维护性
  • 代码足够简单,或者重复性较高,才可以越过类,在方法上遵守单一职责原则.

简单粗暴理解:
一个类负责一项职责,而不是一个类负责一个职责
比如我现在要吃饭,包括买菜,做饭,吃饭,洗碗等(一个类负责一项职责)
而不是我要吃饭,只是单纯的吃饭,(一个类负责一个职责)

接口隔离原则

先来看看完成的事例图;

事例图(2.1):

在这里插入图片描述

  • 红色: A类,实现接口method1(),method4(),method5()方法
  • 黄色:B类,实现接口
  • 绿色:C类,实现接口method2(),method3(),method4()方法
  • 紫色:D类,实现接口
  • 蓝色:Iquarantine,接口隔离实现类,里面有5个方法 method1() 至 method5()
  • 黑色箭头:表示通过实现类来实现对应的方法
  • 灰色箭头:标识直接实现接口Iquarantine

来康康代码:

接口类:

public interface Iquarantine {
    void method1();
    void method2();
    void method3();
    void method4();
    void method5();
}

QuarantineA类:

public class QuarantineA {
  public void run(Iquarantine iquarantine){
      iquarantine.method1();
      iquarantine.method4();
      iquarantine.method5();
  }
}

QuarantineB类:

public class QuarantineB implements Iquarantine{
    @Override
    public void method1() {
        Log.i("Quarantine","QuarantineB类 method1()实现");
    }

    @Override
    public void method2() {
        Log.i("Quarantine","QuarantineB类 method2()实现");
    }

    @Override
    public void method3() {
        Log.i("Quarantine","QuarantineB类 method3()实现");
    }

    @Override
    public void method4() {
        Log.i("Quarantine","QuarantineB类 method4()实现");
    }

    @Override
    public void method5() {
        Log.i("Quarantine","QuarantineB类 method5()实现");
    }
}

QuarantineC类:

public class QuarantineC {
    public void run(Iquarantine iquarantine){
        iquarantine.method2();
        iquarantine.method3();
        iquarantine.method4();
    }
}

QuarantineD类:

public class QuarantineD implements Iquarantine{
    @Override
    public void method1() {
        Log.i("Quarantine","QuarantineD类 method1()实现");
    }

    @Override
    public void method2() {
        Log.i("Quarantine","QuarantineD类 method2()实现");
    }

    @Override
    public void method3() {
        Log.i("Quarantine","QuarantineD类 method3()实现");
    }

    @Override
    public void method4() {
        Log.i("Quarantine","QuarantineD类 method4()实现");
    }

    @Override
    public void method5() {
        Log.i("Quarantine","QuarantineD类 method5()实现");
    }
}

实现方法:

//接口隔离原则
QuarantineA quarantineA = new QuarantineA();
quarantineA.run(new QuarantineB());

QuarantineC quarantineC = new QuarantineC();
quarantineC.run(new QuarantineD());

QuarantineA的run()方法需要传递一个Iquarantine接口,QuarantineB实现了Iquarantine这个接口,所以直接run时传递QuarantineB()即可.

来看看结果:

效果图(1.5):
在这里插入图片描述
这段代码的问题显而易见:

没有遵守接口隔离原则:

QuarantineB类实现的时候,因为QuarantineA类只需要
method1(),method4(),method5()方法,method2()和method3()是多余的!

QuarantineD类实现的时候,method1()和method5()又是多余的

接口隔离原则定义:

  • 客户端不应该依赖它不需要的接口
  • 类之间的依赖关系应该建立在最小的接口上

接口隔离原则定义解释:

  • 接口隔离原则是对接口的使用进行约束规范的一个原则,它告诉我们要想把接口用好,关键在于隔离。隔离,指断绝接触、断绝往来。
  • 那么我们使用接口时,要隔离什么东西呢?“客户端不应该- 依赖它不需要的接口”,这里的隔离是指客户端和它不需要的接口隔离,也就是客户端不要使用它不需要的接口
  • “类间的依赖关系应该建立在最小的接口上”,它要求“最小的接口”,也就是该接口中没有多余的方法,所以这里的隔离是指和多余的方法隔离

接口隔离原则告诉我们,不要把一大堆方法塞进一个接口里,导致这个接口变得臃肿无比。应该要根据实际需要,让接口中只有用得上的方法,也就是说要细化我们的接口

使用接口隔离代码:

分为三个接口:

interface IquarantineA {
    void method1();
    void method5();
}

interface IquarantineB {
    void method4();
}

 interface IquarantineC {
    void method2();
    void method3();
}

QuarantineA类:

public class QuarantineA {
  public void run(QuarantineB quarantineB){
      quarantineB.method1();
      quarantineB.method4();
      quarantineB.method5();
  }
}

QuarantineB类,实现IquarantineA,IquarantineB:

public class QuarantineB implements IquarantineA,IquarantineB{
    @Override
    public void method1() {
        Log.i("Quarantine","QuarantineB类 method1()实现");
    }

    @Override
    public void method4() {
        Log.i("Quarantine","QuarantineB类 method4()实现");
    }

    @Override
    public void method5() {
        Log.i("Quarantine","QuarantineB类 method5()实现");
    }
}

QuarantineC类:

public class QuarantineC {
    public void run(QuarantineD quarantineD){
        quarantineD.method2();
        quarantineD.method3();
        quarantineD.method4();
    }
}

QuarantineD类,实现IquarantineB,IquarantineC接口:

public class QuarantineD implements IquarantineB,IquarantineC{

    @Override
    public void method2() {
        Log.i("Quarantine","QuarantineD类 method2()实现");
    }

    @Override
    public void method3() {
        Log.i("Quarantine","QuarantineD类 method3()实现");
    }

    @Override
    public void method4() {
        Log.i("Quarantine","QuarantineD类 method4()实现");
    }
}

这样一写,对应的类实现了对应的方法,接口也没有臃肿,遵守了接口隔离原则!

效果图(1.6):
在这里插入图片描述

总结:

  • 避免了接口带来的数据污染,
  • 提高了代码的灵活性,一个类实现多个接口的,所以将一个臃肿的接口分割为若干个小接口,通过小接口的不同组合可以满足更多的需求
  • 高内聚,高内聚就是提高接口、类、模块的处理能力,减少对外的交互

单一职责原则代码

接口隔离原则代码

猜你喜欢:

java 七大设计原则之依赖倒置,里氏替换原则(文字代码相结合理解)

java 七大设计原则之迪米特原则,开闭原则,合成复用原则(文字代码相结合理解)

Android studio UML建模

去设计模式/设计原则目录页

原创不易,您的点赞就是对我最大的支持,点个赞支持一下吧~

点击这里复制本文地址 以上内容由权冠洲的博客整理呈现,请务必在转载分享时注明本文地址!如对内容有疑问,请联系我们,谢谢!

支持Ctrl+Enter提交

联系我们| 本站介绍| 留言建议 | 交换友链 | 域名展示
本站资源来自互联网收集,仅供用于学习和交流,请遵循相关法律法规,本站一切资源不代表本站立场,如有侵权、后门、不妥请联系本站删除

权冠洲的博客 © All Rights Reserved.  Copyright quanguanzhou.top All Rights Reserved
苏公网安备 32030302000848号   苏ICP备20033101号-1

联系我们