OOP 面向对象 七大原则 (一)
大家众所周知,面向对象有三大特征继承封装多态的同时,还具有这七大原则,三大特征上一篇已经详细说明,这一篇就为大家详解一下七大原则: 单一职责原则,开闭原则,里氏替换原则,依赖倒置原则,接口隔离原则,迪米特法则,组合聚合复用原则
单一职责原则:一个类只负责一个领域的内容,简而言之就是自己的类负责自己的事情,与别的类互不干涉
场景案例:女孩子购物
/**
* oop 单一原则实现
* @author gongliying
* @data 2019-06-10
*/
aaa(){
class People{
getAll(){
console.log("打车去Dior实体店买口红")
console.log("打车去Only实体店买裙子")
}
}
new People().getAll();
}
打车去实体店买口红跟打车去实体店买裙子,我虽然写在了同样一个方法里面,但是呢却不能同时进行
解决思路:面向对象单一职责,一个类只做一件事情,互不干涉
aaa(){
class People{
Dior(content){
console.log('打车去Dior实体店买' + content)
}
Only(content){
console.log('打车去Only实体店' + content)
}
getAll(){
this.JD('口红')
this.TM('裙子')
}
}
new People().getAll(); //打车去Dior实体店买口红
//打车去Only实体店买裙子
}
这样事情就解决了,一个类方法只做一件事情,我在Dior的方法中只能去买口红,不能去进行买裙子的操作,这就是单一原则
开闭原则:对修改关闭,对扩展开放
一个对象(模板,类,方法)只要是在生命周期内,都会发生变化,而开闭原则就是在不修改原有模块的基础上,扩展其功能
还以口红为例,商场中有一家店面里面之后Dior和CHANEL两个品牌,那么店员介绍的品牌不是Dior就是CHANEL,一般情况下都会这样写
/**
* oop 开闭原则实现
* @author 宫丽颖
* @date 2019-06-13
*/
achieve(){
let type ='dior'
if (type == 'dior') {
console.log('这是dior')
}else{
console.log('这是chanel')
}
}
//这是dior
这样写是没有什么问题的,但是呢,店面中又有新牌子了ysl,这就变成不是dior 不是CHANEL就是ysl了 随之我们的代码就又变成的这样
/**
* oop 开闭原则实现
* @author 宫丽颖
* @date 2019-06-13
*/
achieve(){
let type ='chanel'
if (type == 'dior') {
console.log('这是dior')
}else if(type == 'chanel'){
console.log('这是chanel')
}else{
console.log('这是ysl')
}
//这是chanel
},
随着商店店面更新的口红牌子越来越多,需求越来越多的时候,随之意味这样的代码,对原来代码的修改也越来越多,如果一不小心改错的话,可能整段就垮掉,为了解决这样的事件,建议使用开闭原则,对修改关闭,对扩展开放
/**
* oop 开闭原则实现
* @author 宫丽颖
* @date 2019-06-13
*/
achieve() {
let type = 'ysl'
if (type == 'dior') return this.dior.dior();
if (type == 'chanel') return this.chanel.chanel();
if (type == 'ysl') return this.ysl.ysl();
},
dior : {
dior() {
alert('这是dior')
}
},
chanel : {
chanel() {
alert('这是chanel')
}
},
ysl : {
ysl() {
alert('这是ysl')
}
} //结果为弹出 这是ysl
这样增加需求的时候直接在data里面定义一个就好了,再多的需求也不怕不怕啦~~~
里氏替换原则:父类能出现的地方,可以用子类代替,子类拥有父类的所有属性和方法,通俗来说子类拥有父类的功能,可以拓展父类的功能,但是不能修改父类的功能
口红为例?
/**
* oop 里氏替换原则实现
* @author 宫丽颖
* @date 2019-06-13
*/
achieve() {
class Kouhong{
constructor(e){
this.name=e.name
this.price=e.price
}
look(){
console.log(this.name,'的口红,一共',this.price,'元')
}
}
//子类
class Dior extends Kouhong{
look(){
console.log('这是',this.name,'的口红,一共',this.price)
}
}
var kouhong = new Kouhong({
name:"砖红色",
price:300
})
var dior =new Dior({
name:"脏橘色",
peice:280
})
kouhong.look() //砖红色 的口红,一共 300 元
dior.look() //这是 大红色 的口红,一共 280
},
这样写的话,你会发现子类直接覆盖了父类的内容,修改了父类的功能,虽然代码上没什么问题,但是对于以后的优化有着很大的影响,也违背了里氏替换原则,里氏替换原则要求拥有父类的所有方法,可以扩展父类的方法,但是不能修改,我用历史替换比较一下
/**
* oop 里氏替换原则实现
* @author 宫丽颖
* @date 2019-06-13
*/
achieve() {
class Kouhong{
constructor(e){
this.name=e.name
this.price=e.price
}
look(){
console.log(this.name,'的口红,一共',this.price,'元')
}
saw(){
console.log('口红很贵哦的!!')
}
}
//子类
class Dior extends Kouhong{
look(){
console.log('这是',this.name,'的口红,一共',this.price)
}
}
class CHANEL extends Kouhong{
see(){
console.log('这是',this.name,'的口红,一共',this.price,'元')
}
so(){
console.log('因为那么贵所以才买不起嘛!!!!')
}
}
var kouhong = new Kouhong({
name:"砖红色",
price:300
})
var dior =new Dior({
name:"脏橘色",
price:280
})
var chanel = new CHANEL({
name:"豆沙色",
price:320
})
kouhong.look() //砖红色 的口红,一共 300 元 父类本身
dior.look() //这是 脏橘色 的口红,一共 280 子类1继承父类将父类方法覆盖
chanel.look() //豆沙色 的口红,一共 320 元 子类2继承父类显示父类方法
chanel.see() //这是 豆沙色 的口红,一共 320 元 子类2在继承父类上扩展自己的方法
chanel.saw() //口红很贵哦的!! 子类2继承父类另一个方法 子类继承了父类的所有方法
chanel.so() //因为那么贵所以才买不起嘛!!!! 子类2扩展自己的另一个方法
},
由此可见,子类1在继承父类的时候将父类覆盖,但是子类2在继承父类的时候继承了父类的所有方法并扩展了自己的方法,这就是里氏替换原则
依赖倒置原则:程序要依赖于抽象接口,不要依赖于具体实现。简单的说就是要求对抽象进行编程,不要对实现进行编程,这样就降低了客户与实现模块间的耦合。(节选自百度百科)
emmmm,很官方的一句话 ,我用白话解释一下,就是说高层的模块不要依赖于低层的模块,不要靠比自己层级低的模块,高层低层应该同时依靠抽象,而抽象不应该依赖于细节而是应该细节依赖抽象 ,要是还没有懂的话,画张图把,当然还是口红为例了
这样看是不是看懂了呢 这个人就是高层,左图就是在说 高层依赖低层,如果这个高层抹口红就只能抹口红,不能在抹其他的 ,要是想在抹别的,就要再加方法,太啰嗦
而右图就是在说明定义了一个抽象类抹,如果没有口红了还可以抹眼影啊,粉底之类的,人与眼影之间依赖抹这个抽象类来实现,这个抹眼影 这个细节依赖于抽象抹这个类,而这个高层人也可以创建不同的高层话不多说,代码附上
class cosmetics{
daub(){
console.log('抹了什么?')
}
}
class kouhong extends cosmetics{
go(){
return "抹了口红"
}
}
class yanying extends cosmetics{
go(){
return "抹了眼影"
}
}
class fendi extends cosmetics{
go(){
return "抹了粉底"
}
}
class people {
constructor(name) {
this.name = name
}
gotoEat(mo) {
console.log(this.name, mo.go())
}
}
kouhong = new kouhong
yanying = new yanying
fendi = new fendi
gong = new people('宫')
liying = new people('丽颖')
gong.gotoEat(kouhong) //宫 抹了口红
gong.gotoEat(yanying) //宫 抹了眼影
gong.gotoEat(fendi) //宫 抹了粉底
liying.gotoEat(fendi) //丽颖 抹了粉底
结果我不仅通过抹的抽象类,创建了不同的细节,还创建不同的高层,不同的人通过抹的类创建了不同的细节,他们之间是不会相互影响的,这就是依赖倒置原则。