依賴倒置原則（Dependence Inversion Principle），簡稱DIP

定義

High level modules should depend upon low level modules. Both should depend upon abstractions. Abstractions should not depend upon details. Details should depend upon abstractions.

即

1、高層模塊不應(yīng)該依賴低層模塊，兩者都應(yīng)該依賴于抽象（抽象類或接口）

2、抽象（抽象類或接口）不應(yīng)該依賴于細(xì)節(jié)（具體實現(xiàn)類）

3、細(xì)節(jié)（具體實現(xiàn)類）應(yīng)該依賴抽象

抽象：即抽象類或接口，兩者是不能夠?qū)嵗摹?/p>

細(xì)節(jié)：即具體的實現(xiàn)類，實現(xiàn)接口或者繼承抽象類所產(chǎn)生的類，兩者可以通過關(guān)鍵字new直接被實例化。

而依賴倒置原則的本質(zhì)騎士就是通過抽象（抽象類或接口）使各個類或模塊的實現(xiàn)彼此獨立，不相互影響，實現(xiàn)模塊間的松耦合。但是這個原則也是6個設(shè)計原則中最難以實現(xiàn)的了，如果沒有實現(xiàn)這個原則，那么也就意味著開閉原則（對擴(kuò)展開發(fā)，對修改關(guān)閉）也無法實現(xiàn)。

依賴倒置有三種方式來實現(xiàn)

1、通過構(gòu)造函數(shù)傳遞依賴對象

比如在構(gòu)造函數(shù)中的需要傳遞的參數(shù)是抽象類或接口的方式實現(xiàn)。

2、通過setter方法傳遞依賴對象

即在我們設(shè)置的setXXX方法中的參數(shù)為抽象類或接口，來實現(xiàn)傳遞依賴對象

3、接口聲明實現(xiàn)依賴對象

例如下面的例子

涂涂是個女僧

public class Tutu {  
    //涂涂是個女孩，會煮面  
    public void cook(Noodles noodles)  
    {  
        noodles.eat();  
    }  
} 

面條（目前只會煮面）

public class Noodles {  
    //吃面條  
    public void eat()  
    {  
        System.out.println("涂涂吃面條...");  
    }  
} 

涂涂坐在家里吃面（場景類）

public class Home {  
    public static void main(String args[])  
    {  
        Tutu tutu = new Tutu();  
        Noodles food = new Noodles();  
        tutu.cook(food);  
    }  
} 

運行結(jié)果：涂涂吃面條...

但是這有個問題，涂涂只會做面條，不可能每次都吃面條吧，天天吃面吃死你，所以在上面的Tutu類中的cook方法中，如果涂涂會做其他吃的，那豈不是更好。于是她向家庭主婦邁進(jìn)了一步，使用了依賴倒置原則。

也就是涂涂通過學(xué)習(xí)還可以燜米飯，炒魷魚（雖然聽著不爽，但是很好吃），京醬肉絲啊等等。要想在代碼中實現(xiàn)，就需要實現(xiàn)兩個接口：ITutu和IFood

public interface ITutu {  
    //這樣就會做很多飯菜了  
    public void cook(IFood food);  
} 

實現(xiàn)類

public class Tutu implements ITutu {  
   
    @Override 
    public void cook(IFood food) {  
        food.eat();  
    }  
   
} 

食物接口

public interface IFood {  
    public void eat();  
} 

這樣就為擴(kuò)展留出了很大的空間，方面擴(kuò)展其他的類。也不會對細(xì)節(jié)有變動。以后涂涂想吃什么學(xué)一下就可以自己做了

實現(xiàn)面條

public class Noodles implements IFood {  
   
    @Override 
    public void eat() {  
        System.out.println("涂涂吃面條...");  
    }  
   
} 

實現(xiàn)米飯

public class Rice implements IFood {  
   
    @Override 
    public void eat() {  
        System.out.println("涂涂吃米飯（終于吃上米飯了）...");  
    }  
} 

場景類：涂涂在家里開吃了，想吃什么直接做就是了

public class Home {  
    public static void main(String args[])  
    {  
        //接口使不能實例化滴  
        ITutu tutu = new Tutu();  
        //實例化米飯，涂涂可以吃米飯了  
        IFood rice = new Rice();  
        //吃面條  
        //IFood noodles = new Noodles();  
        tutu.cook(rice);  
    }  
}   

這樣各個類或模塊的實現(xiàn)彼此獨立，不互相影響，實現(xiàn)了。

原文鏈接：http://www.cnblogs.com/loulijun/archive/2012/03/05/2380524.html

【編輯推薦】

1. 關(guān)于讀寫鎖算法的Java實現(xiàn)及思考
2. 6個提高Java開發(fā)者效率的工具
3. Java并發(fā)：juc Executor框架詳解
4. 設(shè)計Java應(yīng)用程序的平滑停止
5. Spock 0.6發(fā)布 Java測試框架