在軟件開發(fā)中，為了提高軟件系統(tǒng)的可維護性和可復用性，增加軟件的可擴展性和靈活性，程序員要盡量根據(jù)6條原則來開發(fā)程序，從而提高軟件開發(fā)效率、節(jié)約軟件開發(fā)成本和維護成本。
對擴展開放，對修改關(guān)閉。在程序需要進行拓展的時候，不能去修改原有的代碼，實現(xiàn)一個熱插拔的效果。簡言之，是為了使程序的擴展性好，易于維護和升級。
想要達到這樣的效果，我們需要使用接口和抽象類。
因為抽象靈活性好，適應性廣，只要抽象的合理，可以基本保持軟件架構(gòu)的穩(wěn)定。而軟件中易變的細節(jié)可以從抽象派生來的實現(xiàn)類來進行擴展，當軟件需要發(fā)生變化時，只需要根據(jù)需求重新派生一個實現(xiàn)類來擴展就可以了。
下面以 搜狗輸入法 的皮膚為例介紹開閉原則的應用。
【例】搜狗輸入法 的皮膚設計。
分析：搜狗輸入法 的皮膚是輸入法背景圖片、窗口顏色和聲音等元素的組合。用戶可以根據(jù)自己的喜愛更換自己的輸入法的皮膚，也可以從網(wǎng)上下載新的皮膚。這些皮膚有共同的特點，可以為其定義一個抽象類（AbstractSkin），而每個具體的皮膚（DefaultSpecificSkin和HeimaSpecificSkin）是其子類。用戶窗體可以根據(jù)需要選擇或者增加新的主題，而不需要修改原代碼，所以它是滿足開閉原則的。
/** * @version v1.0 * @ClassName: AbstractSkin * @Description: 抽象皮膚類 */public abstract class AbstractSkin {//顯示的方法 public abstract void display();}/** * @version v1.0 * @ClassName: GezishanSkin * @Description: 格子衫皮膚 * @Author: 格子衫程序員 */public class GezishanSkin extends AbstractSkin {public void display() {System.out.println("格子衫皮膚"); }}/** * @version v1.0 * @ClassName: SougouInput * @Description: 搜狗輸入法 */public class SougouInput {private AbstractSkin skin; public void setSkin(AbstractSkin skin) {this.skin = skin; } public void display() {skin.display(); }}public class Client {public static void main(String[] args) {//1,創(chuàng)建搜狗輸入法對象 SougouInput input = new SougouInput(); //2,創(chuàng)建皮膚對象 //DefaultSkin skin = new DefaultSkin(); HeimaSkin skin = new HeimaSkin(); //3,將皮膚設置到輸入法中 input.setSkin(skin); //4,顯示皮膚 input.display(); }}里氏代換原則是面向?qū)ο笤O計的基本原則之一。
里氏代換原則：任何基類可以出現(xiàn)的地方，子類一定可以出現(xiàn)。通俗理解：子類可以擴展父類的功能，但不能改變父類原有的功能。換句話說，子類繼承父類時，除添加新的方法完成新增功能外，盡量不要重寫父類的方法。
如果通過重寫父類的方法來完成新的功能，這樣寫起來雖然簡單，但是整個繼承體系的可復用性會比較差，特別是運用多態(tài)比較頻繁時，程序運行出錯的概率會非常大。
下面看一個里氏替換原則中經(jīng)典的一個例子
【例】正方形不是長方形。
在數(shù)學領(lǐng)域里，正方形毫無疑問是長方形，它是一個長寬相等的長方形。所以，我們開發(fā)的一個與幾何圖形相關(guān)的軟件系統(tǒng)，就可以順理成章的讓正方形繼承自長方形。
長方形類（Rectangle）：
public class Rectangle {private double length; private double width; public double getLength() {return length; } public void setLength(double length) {this.length = length; } public double getWidth() {return width; } public void setWidth(double width) {this.width = width; }}正方形（Square）：
由于正方形的長和寬相同，所以在方法setLength和setWidth中，對長度和寬度都需要賦相同值。
public class Square extends Rectangle { public void setWidth(double width) {super.setLength(width); super.setWidth(width); } public void setLength(double length) {super.setLength(length); super.setWidth(length); }}類RectangleDemo是我們的軟件系統(tǒng)中的一個組件，它有一個resize方法依賴基類Rectangle，resize方法是RectandleDemo類中的一個方法，用來實現(xiàn)寬度逐漸增長的效果。
public class RectangleDemo { public static void resize(Rectangle rectangle) {while (rectangle.getWidth() <= rectangle.getLength()) {rectangle.setWidth(rectangle.getWidth() 1); } } //打印長方形的長和寬 public static void printLengthAndWidth(Rectangle rectangle) {System.out.println(rectangle.getLength()); System.out.println(rectangle.getWidth()); } public static void main(String[] args) {Rectangle rectangle = new Rectangle(); rectangle.setLength(20); rectangle.setWidth(10); resize(rectangle); printLengthAndWidth(rectangle); System.out.println("============"); Rectangle rectangle1 = new Square(); rectangle1.setLength(10); resize(rectangle1); printLengthAndWidth(rectangle1); }}我們運行一下這段代碼就會發(fā)現(xiàn)，假如我們把一個普通長方形作為參數(shù)傳入resize方法，就會看到長方形寬度逐漸增長的效果，當寬度大于長度,代碼就會停止，這種行為的結(jié)果符合我們的預期；假如我們再把一個正方形作為參數(shù)傳入resize方法后，就會看到正方形的寬度和長度都在不斷增長，代碼會一直運行下去，直至系統(tǒng)產(chǎn)生溢出錯誤。所以，普通的長方形是適合這段代碼的，正方形不適合。
我們得出結(jié)論：在resize方法中，Rectangle類型的參數(shù)是不能被Square類型的參數(shù)所代替，如果進行了替換就得不到預期結(jié)果。因此，Square類和Rectangle類之間的繼承關(guān)系違反了里氏代換原則，它們之間的繼承關(guān)系不成立，正方形不是長方形。
如何改進呢？此時我們需要重新設計他們之間的關(guān)系。抽象出來一個四邊形接口(Quadrilateral)，讓Rectangle類和Square類實現(xiàn)Quadrilateral接口
高層模塊不應該依賴低層模塊，兩者都應該依賴其抽象；抽象不應該依賴細節(jié)，細節(jié)應該依賴抽象。簡單的說就是要求對抽象進行編程，不要對實現(xiàn)進行編程，這樣就降低了客戶與實現(xiàn)模塊間的耦合。
依賴倒轉(zhuǎn)原則是對開閉原則的具體實現(xiàn)。
下面看一個例子來理解依賴倒轉(zhuǎn)原則
【例】組裝電腦
現(xiàn)要組裝一臺電腦，需要配件cpu，硬盤，內(nèi)存條。只有這些配置都有了，計算機才能正常的運行。選擇cpu有很多選擇，如Intel，AMD等，硬盤可以選擇希捷，西數(shù)等，內(nèi)存條可以選擇金士頓，海盜船等。
類圖如下：
希捷硬盤類（XiJieHardDisk）:
public class XiJieHardDisk implements HardDisk {public void save(String data) {System.out.println("使用希捷硬盤存儲數(shù)據(jù)" data); } public String get() {System.out.println("使用希捷希捷硬盤取數(shù)據(jù)"); return "數(shù)據(jù)"; }}Intel處理器（IntelCpu）：
public class IntelCpu implements Cpu {public void run() {System.out.println("使用Intel處理器"); }}金士頓內(nèi)存條（KingstonMemory）：
public class KingstonMemory implements Memory {public void save() {System.out.println("使用金士頓作為內(nèi)存條"); }}電腦（Computer）：
public class Computer {private XiJieHardDisk hardDisk; private IntelCpu cpu; private KingstonMemory memory; public IntelCpu getCpu() {return cpu; } public void setCpu(IntelCpu cpu) {this.cpu = cpu; } public KingstonMemory getMemory() {return memory; } public void setMemory(KingstonMemory memory) {this.memory = memory; } public XiJieHardDisk getHardDisk() {return hardDisk; } public void setHardDisk(XiJieHardDisk hardDisk) {this.hardDisk = hardDisk; } public void run() {System.out.println("計算機工作"); cpu.run(); memory.save(); String data = hardDisk.get(); System.out.println("從硬盤中獲取的數(shù)據(jù)為：" data); }}測試類（TestComputer）：
測試類用來組裝電腦。
public class TestComputer {public static void main(String[] args) {Computer computer = new Computer(); computer.setHardDisk(new XiJieHardDisk()); computer.setCpu(new IntelCpu()); computer.setMemory(new KingstonMemory()); computer.run(); }}上面代碼可以看到已經(jīng)組裝了一臺電腦，但是似乎組裝的電腦的cpu只能是Intel的，內(nèi)存條只能是金士頓的，硬盤只能是希捷的，這對用戶肯定是不友好的，用戶有了機箱肯定是想按照自己的喜好，選擇自己喜歡的配件。
根據(jù)依賴倒轉(zhuǎn)原則進行改進：
代碼我們只需要修改Computer類，讓Computer類依賴抽象（各個配件的接口），而不是依賴于各個組件具體的實現(xiàn)類。
類圖如下：
public class Computer {private HardDisk hardDisk; private Cpu cpu; private Memory memory; public HardDisk getHardDisk() {return hardDisk; } public void setHardDisk(HardDisk hardDisk) {this.hardDisk = hardDisk; } public Cpu getCpu() {return cpu; } public void setCpu(Cpu cpu) {this.cpu = cpu; } public Memory getMemory() {return memory; } public void setMemory(Memory memory) {this.memory = memory; } public void run() {System.out.println("計算機工作"); }}面向?qū)ο蟮拈_發(fā)很好的解決了這個問題，一般情況下抽象的變化概率很小，讓用戶程序依賴于抽象，實現(xiàn)的細節(jié)也依賴于抽象。即使實現(xiàn)細節(jié)不斷變動，只要抽象不變，客戶程序就不需要變化。這大大降低了客戶程序與實現(xiàn)細節(jié)的耦合度。
客戶端不應該被迫依賴于它不使用的方法；一個類對另一個類的依賴應該建立在最小的接口上。
下面看一個例子來理解接口隔離原則
【例】安全門案例
我們需要創(chuàng)建一個黑馬品牌的安全門，該安全門具有防火、防水、防盜的功能。可以將防火，防水，防盜功能提取成一個接口，形成一套規(guī)范。類圖如下：
AntiTheft（接口）：
public interface AntiTheft {void antiTheft();}Fireproof（接口）：
public interface Fireproof {void fireproof();}Waterproof（接口）：
public interface Waterproof {void waterproof();}HeiMaSafetyDoor（類）：
public class HeiMaSafetyDoor implements AntiTheft,Fireproof,Waterproof {public void antiTheft() {System.out.println("防盜"); } public void fireproof() {System.out.println("防火"); } public void waterproof() {System.out.println("防水"); }}ItcastSafetyDoor（類）：
public class ItcastSafetyDoor implements AntiTheft,Fireproof {public void antiTheft() {System.out.println("防盜"); } public void fireproof() {System.out.println("防火"); }}迪米特法則又叫最少知識原則。
只和你的直接朋友交談，不跟“陌生人”說話（Talk only to your immediate friends and not to strangers）。
其含義是：如果兩個軟件實體無須直接通信，那么就不應當發(fā)生直接的相互調(diào)用，可以通過第三方轉(zhuǎn)發(fā)該調(diào)用。其目的是降低類之間的耦合度，提高模塊的相對獨立性。
迪米特法則中的“朋友”是指：當前對象本身、當前對象的成員對象、當前對象所創(chuàng)建的對象、當前對象的方法參數(shù)等，這些對象同當前對象存在關(guān)聯(lián)、聚合或組合關(guān)系，可以直接訪問這些對象的方法。
下面看一個例子來理解迪米特法則
【例】明星與經(jīng)紀人的關(guān)系實例
明星由于全身心投入藝術(shù)，所以許多日常事務由經(jīng)紀人負責處理，如和粉絲的見面會，和媒體公司的業(yè)務洽淡等。這里的經(jīng)紀人是明星的朋友，而粉絲和媒體公司是陌生人，所以適合使用迪米特法則。
類圖如下：
明星類（Star）
public class Star {private String name; public Star(String name) {this.name=name; } public String getName() {return name; }}粉絲類（Fans）
public class Fans {private String name; public Fans(String name) {this.name=name; } public String getName() {return name; }}媒體公司類（Company）
public class Company {private String name; public Company(String name) {this.name=name; } public String getName() {return name; }}經(jīng)紀人類（Agent）
public class Agent {private Star star; private Fans fans; private Company company; public void setStar(Star star) {this.star = star; } public void setFans(Fans fans) {this.fans = fans; } public void setCompany(Company company) {this.company = company; } public void meeting() {System.out.println(fans.getName() "與明星" star.getName() "見面了。"); } public void business() {System.out.println(company.getName() "與明星" star.getName() "洽淡業(yè)務。"); }}合成復用原則是指：盡量先使用組合或者聚合等關(guān)聯(lián)關(guān)系來實現(xiàn)，其次才考慮使用繼承關(guān)系來實現(xiàn)。
通常類的復用分為繼承復用和合成復用兩種。
繼承復用雖然有簡單和易實現(xiàn)的優(yōu)點，但它也存在以下缺點：
繼承復用破壞了類的封裝性。因為繼承會將父類的實現(xiàn)細節(jié)暴露給子類，父類對子類是透明的，所以這種復用又稱為“白箱”復用。
子類與父類的耦合度高。父類的實現(xiàn)的任何改變都會導致子類的實現(xiàn)發(fā)生變化，這不利于類的擴展與維護。
它限制了復用的靈活性。從父類繼承而來的實現(xiàn)是靜態(tài)的，在編譯時已經(jīng)定義，所以在運行時不可能發(fā)生變化。
采用組合或聚合復用時，可以將已有對象納入新對象中，使之成為新對象的一部分，新對象可以調(diào)用已有對象的功能，它有以下優(yōu)點：
它維持了類的封裝性。因為成分對象的內(nèi)部細節(jié)是新對象看不見的，所以這種復用又稱為“黑箱”復用。
對象間的耦合度低?？梢栽陬惖某蓡T位置聲明抽象。
復用的靈活性高。這種復用可以在運行時動態(tài)進行，新對象可以動態(tài)地引用與成分對象類型相同的對象。
下面看一個例子來理解合成復用原則
【例】汽車分類管理程序
汽車按“動力源”劃分可分為汽油汽車、電動汽車等；按“顏色”劃分可分為白色汽車、黑色汽車和紅色汽車等。如果同時考慮這兩種分類，其組合就很多。類圖如下：
聯(lián)系客服
