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) //丽颖 抹了粉底
结果我不仅通过抹的抽象类，创建了不同的细节，还创建不同的高层，不同的人通过抹的类创建了不同的细节，他们之间是不会相互影响的，这就是依赖倒置原则。