OOP 面向对象 七大原则 （一）
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.namethis.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.namethis.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 kouhongyanying = new yanyingfendi = new fendigong = new people('宮')liying = new people('麗穎')gong.gotoEat(kouhong) //宮 抹了口紅gong.gotoEat(yanying) //宮 抹了眼影gong.gotoEat(fendi) //宮 抹了粉底liying.gotoEat(fendi) //麗穎 抹了粉底
結果我不僅通過抹的抽象類，創建了不同的細節，還創建不同的高層，不同的人通過抹的類創建了不同的細節，他們之間是不會相互影響的，這就是依賴倒置原則。
轉載于:https://www.cnblogs.com/gongliying/p/11000060.html
總結
以上是生活随笔為你收集整理的OOP 面向对象 七大原则 （一）的全部內容，希望文章能夠幫你解決所遇到的問題。
