越学越上瘾   12.12 来百知学IT   课程全面升级

立刻报名学习

400-616-5551

您所在位置: 首页> 学习资讯> java培训 | JavaScript设计模式经典:面向对象中六大原则

java培训 | JavaScript设计模式经典:面向对象中六大原则

发布百知教育 来源:学习资讯 2019-11-22

1


主要学习JavaScript中的六大原则。那么六大原则还记得是什么了吗?六大原则指:单一职责原则(SRP),开放封闭原则(OCP),里氏替换原则(LSP),依赖倒置原则(DIP),接口分离原则(ISP),最少知识原则(LKP)。


  1. 单一职责原则

  2. 开放封闭原则

  3. 里氏替换原则

  4. 依赖倒置原则

  5. 接口分离原则

  6. 最少知识原则


那么什么是单一职责原则呢?单一职责原则,英文单词为:single responsable princple,原则体现为,一个对象或者是方法只做一件事。


从前车马很慢,书信很远,一生只够爱一个人。“从前的日色变得慢,车,马,邮件都慢,一生只够爱一个人  从前的锁也好看,钥匙精美有样子,你锁了,人家就懂了”(一个对象或者是方法只做一件事情)


如果一个方法承担了很多很多的职责,那么它在需求发生变化的过程中,需要改写这个方法的可能性就很大。


单一职责原则,一个类只提供一种功能,不要存在过多导致类变化的原因。从前,一个人负责两个不同的任务,为任务1,任务2,当任务1需要做调整时,而需要这个人做修整时,有可能会影响任务2的正常运行,会导致任务2没有办法完成。


遵循单一职责原则,就可以解决这种情况的发生,分别让两个人分别做任务1,任务2,让人1做任务1,让人2做任务2,这样,当需要改变任务1时,不会影响到任务2的正常运行,同理,任务2需要做修改时,人1做的事也不会发生影响。


里氏替换原则:所有引用基类的地方必须能够使用其子类的对象,从前有一个游戏玩家A,它有一个招式Z1,现在把这个招式Z1进行扩展,扩展后成为大招Z,其大招Z由原来的招式Z1和新功能Z2组成,新功能Z又由游戏玩家A的子类徒弟游戏玩家B去完成,那么这个子类徒弟游戏玩家B在完成这个新功能Z2的同时,有可能会影响到原来的招式Z1,而导致招式发生错误。


(迪米特法则:只与直接的朋友通信),每个对象都会和其他对象有耦合的关系,只要两个对象之间有耦合关系,就说这两个对象之间是朋友关系。




2


开放封闭原则,类,方法等应当对其扩展开放,对其修改封闭,在不修改的前提下进行扩展,扩展开发,当有新的需求出现的时候,我们可以对其进行扩展现有的方法,对象等已到达目的;修改关闭,不能对实体进行任何的修改。


不修改现有的功能方法,就可以进行实现各种变化的代码。



// 定义一个方法function da(x, y) { document.getElementById(x).style.color = y;}
// 调用方法dada('dashucoding', 'red');


// 开发封闭原则 -> 错误// 定义方法function da(x, y, z) { document.getElementById(x).style.color = y; document.getElementById(x).style.size = z;}
// 调用方法dada('dashucoding', 'red', '100px');


// 定义一个方法function da(x, y) { document.getElementById(x).style.color = y;}
// 不去动da这个方法function dada(x, y, z) { da(x,y); document.getElementById(x).style.size = z;}
// 正确使用开发封闭原则
function da(x, y) { document.getElementById(x).style.color = y;}
da('dashucoding', 'red');
function dada(x, y, z) { da(x,y); document.getElementById(x).style.size = z;}
dada('dashucoding', 'red', '100px');


单一职责原则,简介,就一个类而言,应该仅有一个引起它变化的原因。


开放封闭原则,简介,软件实体对扩展是开放的,但对修改是关闭的。即在不修改一个软件实体的基础上去扩展其功能。


里氏替换原则,简介,子类必须能够替换它们的基类。


依赖倒置原则,简介,高层次的模块不应该依赖于低层次的模块,他们都应该依赖于抽象。抽象不应该依赖于具体实现,具体实现应该依赖于抽象。作用,降低了客户与实现模块间的耦合。


接口分离原则,简介,使用多个专门的接口来取代一个统一的接口。


合成复用原则,简介,就是在一个新的对象里面使用一些已有的对象,使之成为新对象的一部分;新的对象通过向这些对象的委派达到复用已有功能的目的。简单来说就是,要尽量使用组合,尽量不要使用继承。


迪米特法则,简介,又叫做最少知识原则,就是说一个对象应当对其他对象有尽可能少的了解,不和陌生人说话。




3



里氏替换原则,就是对开发封闭原则进行补充,讲的是基类和子类的关系。理解里氏替换原则的最经典的例子是“正方形是长方形”,“鸵鸟不是鸟”等,拿正方形来说,上数学课的时候,我们就知道,正方形是长方形,它是一个长宽相等的长方形,那么由此可以看出,应该让正方形继承自长方形。



java培训班


public class Rectangle { private int height; private int width;  // 省略getter setter}
// 正方形长和宽始终一样 覆写public class Square extends Rectangle { @Override public void setWidth(int width) {  super.setWidth(width);  super.setHeight(width); }  @Override public void setHeight(int height) {  super.setWidth(height);  super.setHeight(height); }}


java培训班


依赖倒置原则,高层次的模块不应该依赖于低层次的模块,它们都应该依赖于抽象。抽象不应该依赖于具体实现,具体实现应该依赖于抽象。



java培训班


高层次模块依赖方向中层次模块,中层次模块依赖于低层次模块。高层次与低层次不相互依赖,低层次的任何修改都会影响高层次的模块。抽象层,高级层次,实现层次,具体实现依赖抽象层。



4



接口分离原则,客户端不应该依赖它不需要的接口,一个类对另一个类的依赖应该建立在最小的接口上。怎么说呢?


有三个客户端A,B,C都依赖于一个大的接口,这个大的接口有A(),B(),C(),但是客户端A只需要A()而已,其他不需要,这个时候就利用接口分离原则让客户端A只需要A(),让客户端B只需要B(),让客户端C只需要C()。


设计原则是指导思想,从思想上给我们指明程序设计的正确方向,设计模式是实现的手段,因此设计模式也是遵守这些原则的。达到高内聚低耦合,高内聚就是说模块内部要高度聚合,是模块内部的关系,低耦合是说模块与模块之间的耦合度要尽量低,是模块与模块之间的关系。


单一职责原则总结:一个对象只做一件事。


开放封闭原则总结:对扩展开放,对修改封闭。


迪米特法则,又叫做最少知识原则总结:一个对象应该对其他对象有最少的了解。


设计模式中的外观模式和中介模式,是迪米特法则应用的例子。


迪米特法简单就是,只与朋友说话,不与陌生人说话。缺点就是系统中会产生大量的小方法。


合成复用原则,多用组合,少用继承。继承是面向对象的三大特征,封装,继承,多态,继承实现简单,易于扩展,但是继承也是由缺陷的,父类变,子类必须变,继承破坏了封装,对父类来说,它的实现对子类来说是透明的,继承是一种强耦合的关系。


父类变,子类必须变;继承破坏了封装(子类是封装的,因父类的改变,导致父类破坏了子类的封装),对于子类来说,通过继承父类,是没有安全保障的,父类修改其内容,就会导致子类的功能被破坏;对于父类来说,子类继承父类,重写它的方法时,父类的方法是不可以任意修改的。


设计原则:


单一职责原则,一个方法只做一件事情;里氏替换原则,子类可以代替父类;依赖倒置原则,只依赖接口不依赖方法,不关心底层的实现方法;接口分离原则,把大的接口拆分成小的接口;迪米特法则,函数中传入的参数越少越好,开放封闭原则,面向扩展开放,面向修改关闭。




5



单一职责原则,优点:降低了单个类或者是对象的复杂程度,按照单一职责原则把对象分解成更小的单位,有利于代码的复用,也有利于进行单元测试,当一个职责需要改变的时候,不会影响到其他的职责。缺点:增加了编码的复杂程度,同时增加了对象之间的关联难度。


理解为不同类具备不同的职责。一个类只承担一个职责。


最少知识原则,优点:减少或消除对象之间耦合程度,提高复用性。缺点:需要封装对象或者是引入一个第三方对象来处理两者之间的关系,有时候第三方对象会很复杂,复杂到难以维护。


开放封闭原则,优点:程序的稳定性很高,容易变更的地方分离后更加容易维护。



// 单一职责原则// 

类

public class People {
 public void work() {
 
 System.out.println("work"); 
 
 }
 
public void eat() {  

System.out.println("eat"); 

} 

public void play() {  

System.out.println("play"); 

 }
 
}

// 一个类, 三个职责

// 单一职责原则

public interface workInter { 

public void work();

}

public interface eatInter { 

public void eat();

}

public interface playInter {

 public void play();
 
}

// 继承接口

public class People implements workInter, eatInter, playInter {

 public void work() {  
 
 System.out.println("work"); 
 
} 

public void eat() {  

System.out.println("eat"); 

} 

public void play() {  

System.out.println("play"); 

}

}


java培训班



里氏替换原则,所有引用基类的地方必须能透明地使用其子类的对象,子类必须完全实现父类的功能,凡是父类出现的地方,替换成子类也不会有问题。


里氏替换原则,我喜欢动物,那我一定喜欢狗,因狗是动物的子类;但是我说我喜欢狗,不能说我喜欢动物,因为我不喜欢其他小小小型动物。


子类必须完全实现父类的功能,举例没有实现的:


java培训班


依赖倒置原则,理解为使用接口或者是抽象类。模块之间的依赖是通过抽象发生的,实现类之间不能直接的依赖的关系,实现类的依赖关系是通过接口或者抽象类产生的,接口或者抽象类依赖于实现类,实现类要依赖于接口或者是抽象类。


java培训班


接口分离原则,如果一个类实现一个接口,但是这个接口有它不要的方法,就需要把这个接口拆分,把它需要的方法独立出来形成一个新的接口给这个类去实现。


单例模式:一个类只有一个实例,用一个变量去区别当前实例是否创建过



java培训班


java培训班:http://www.baizhiedu.com/java2019






上一篇:java培训班:Java学习总结“注解”

下一篇:大数据培训入门:什么是Spark?为什么要学Spark?

相关推荐