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 七大设计原则之迪米特原则,开闭原则,合成复用原则(文字代码相结合理解)
原创不易,您的点赞就是对我最大的支持,点个赞支持一下吧~