面向接口編程

接口的定義及功能

這里從java介入吧，在java中，接口是一種特殊的類，接口里面的量都是常量，接口的方法只有定義而沒有實現(xiàn)，換句話說，接口就像一個菜單，它只會告知你我有什么菜，而并不會有實際的菜品，所以通常用接口來定義實現(xiàn)類的外觀，根據(jù)外部應用所需要的功能，約定實現(xiàn)類的能力（類的功能不僅限于接口約束）。通過接口，可以實現(xiàn)不相關類的相同功能，而不考慮這些類之間的層次關系，接口就是實現(xiàn)類對外的外觀。

上面那樣說，可能顯得很裝13，那千言萬語化成一句人話就是：1、定義功能，對外暴露 2、對內(nèi)約束實現(xiàn)類的行為

面向接口編程的意義

所謂面向接口去編程的核心含義就是為了——“封裝隔離”

通常的封裝，是指對數(shù)據(jù)結(jié)構(gòu)的封裝，將幾種數(shù)據(jù)類型整到一塊，組成一個新的數(shù)據(jù)類型；而java中的封裝，包含對數(shù)據(jù)和行為進行抽象，然后定義出一個類，這個類即封裝了數(shù)據(jù)和行為，但接口這里的封裝，更多的是指對于行為（能力、方法）的封裝，是一種“對被隔離體能力的封裝”，而隔離對應的就是，外部的調(diào)用以及內(nèi)部的實現(xiàn)，外部只根據(jù)接口來調(diào)用方法（根據(jù)菜單來點菜，具體填飽肚子的菜是內(nèi)部去做），外部調(diào)用是不知道內(nèi)部你是用什么方式實現(xiàn)的，舉個例子，就像我有一個計算器，計算器的加減乘除按鍵就是我提供給用戶的接口，用戶只知道我有加減乘除的能力，但當他用乘法按鍵去運算的時候，后臺具體是用二進制運算，還是逐個數(shù)累加或者其他什么方式來完成這個乘法功能，用戶是不知道的。也就是外部調(diào)用和內(nèi)部實現(xiàn)是被隔離開的。

既然外部調(diào)用和內(nèi)部實現(xiàn)被隔離開了，那么只要接口不變，內(nèi)部實現(xiàn)怎么變化都不會影響外部應用對這個接口的調(diào)用，從而讓系統(tǒng)更加的靈活，更便于擴展和維護，也就是傳說中的“接口是系統(tǒng)可插拔的保證”。

說到這里插一段題外話，emmm……個人感覺編程是一個人的事，很多時候1+1<2，因為人這個不可控因素，每個程序員的思想深度，技術(shù)水平，都是不相同的，所以往往會出現(xiàn) “ 一個程序員A費勁心力，設計了面向?qū)ο蟮哪K化代碼結(jié)構(gòu)，并完成了一部分功能，而后面有別的需求介入，另一個的程序員B加入了研發(fā)過程，基于這個代碼進行改動的時候，并讀不懂A的結(jié)構(gòu)和A事先預留的擴展方式，直接用他的方式去硬編碼，強行破壞了整個結(jié)構(gòu)”。以上這種情況往往很令人崩潰，所以對于水平參差不齊的團隊來說，集體勞作的質(zhì)量（單指代碼）并不那么友好

總之，在開發(fā)中，優(yōu)先選擇使用接口，在即要定義子類的行為，又要為子類提供公共方法的時候選擇抽象類。

從設計上來體會接口的意義

這里咱們從我個人比較熟悉的java入手，在java的設計中，經(jīng)常出現(xiàn)的層的概念和模塊的概念，個人經(jīng)常做java Web的程序，我們以此為例，最經(jīng)典的MVC結(jié)構(gòu)，抽象一點理解，也就是控制、邏輯、數(shù)據(jù)三層，它們之間全部通過接口來通信。

在每一層里，又包含很多模塊，每個模塊對外則是一個整體，所以一個模塊應該對外提供接口，其他地方需要某個功能時，可根據(jù)接口直接調(diào)用模塊，也就是上面的 “ 接口是被其隔離部分的外觀”。

設計中經(jīng)常會提到組件，模塊，其實不論是組件還是模塊，都可以理解為 封裝了一定功能的集合體， 一個類，一個功能塊，一個插件，一個系統(tǒng)，都可以理解成組件、模塊，因為，一個類可能是一個功能塊的一部分，一個功能塊可能是一個插件的一部分，一個插件可能是一個系統(tǒng)的一部分，小系統(tǒng)放到大系統(tǒng)中，也就是個組件罷了，就是組合的關系，從設計的角度，系統(tǒng)，子系統(tǒng)，插件、模塊、組件等，其實說的就是一個東西，就是完成一定功能的封裝體。

簡單工廠

前面咧咧了那么多，看官們肯定看煩了，差評差評！這里我上面說了那么多接口的東西，總得用來看看吧，我們用一個例子來切入主題，這里我打算寫一個功能，就是比對兩個字符串相似的程度，肯定會有人說了，你這真廢話，直接 equals() 它不香么！香是香，可是它不能展示(讓我裝13啊)呀，我們以java的方式來搞個相似度計算。

上面說了接口，那我們先定義接口：

public interface MatcherAlg {

    /**
     * 計算兩個串的相似度
     * @param srcStr
     * @param dstStr
     * @return Float 相似值
     */
   public Float CalculateSimilarityRatioValue(String srcStr,String dstStr);



}

接口已經(jīng)約束了我們這個功能只有一個方法，那么我們來內(nèi)部實現(xiàn)一下：

public class JaccardMatcher implements MatcherAlg {

    @Override
    public Float CalculateSimilarityRatioValue(String srcStr, String dstStr) {
        if(srcStr == null && dstStr ==null){
            return 1f;
        }
        if(srcStr == null || dstStr == null){
            return 0f;
        }
        Set<Integer> aChar = srcStr.chars().boxed().collect(Collectors.toSet());
        Set<Integer> bChar = dstStr.chars().boxed().collect(Collectors.toSet());

        int intersection = SetUtils.intersection(aChar,bChar).size();
        if(intersection == 0){
            return 0f;
        }
        int union =  SetUtils.union(aChar,bChar).size();
        return ((float)intersection/(float)union);
    }
}

這時候我們要用它了，來比較兩個字符串相似程度：

public class Test{
  
   public static void main(String args[]){
        String str= "sdfsf";
        String dst= "1234d";
        MatcherAlg matcher = new JaccardMatcher();
        Float result = matcher.CalculateSimilarityRatioValue(str,dst);
    }

}

運行一下，也十分正常，完美落地，可是仔細看下來，這樣我定義那個MatcherAlg 接口，后面又

MatcherAlg matcher = new JaccardMatcher();

好像是在 “脫了褲子放p”，沒事找事。干嘛不直接定義JaccardMatcher類，然后：

JaccardMatcher matcher = new JaccardMatcher();

但是上面說過了，我們應該面向接口編程，接口的核心就為了 “封裝隔離”，實現(xiàn)類JaccardMatcher應該是被接口 MatcherAlg封裝并同客戶端隔離開來。

客戶端根本不應該知道JaccardMatcher的存在，更不用說 newJaccardMatcher（）這種“脫褲放p”操作了。但是問題又來了，如果客戶端沒有newJaccardMatcher（），只有MatcherAlg接口的定義，那么后面的代碼是無法使用的。

于是糾結(jié)的地方出現(xiàn)了，上面花了那么大篇幅說怎么怎么面向接口，純面向接口了你又不能運行了，能運行又違反了“隔離封裝”了， 問題進入死環(huán)了。

所以“脫褲放p”的操作是對應這個死環(huán)一種蹩腳的寫法（它可以運行，但專業(yè)的我們不認）。

這個死環(huán)如何解決，我們先看一下設計模式中的一段話，它是這樣說的 ：提供一個創(chuàng)建對象實例的功能，而無需關系其具體的實現(xiàn)。被創(chuàng)建實例的類型可以是接口、抽象類、也可以是具體的類。

受到那句話的啟發(fā)，我們嘗試得出一個解開上面那個死環(huán)的方案：我們在模塊內(nèi)部建一個類，這個類的功能就是創(chuàng)建可使用的接口，并且把創(chuàng)建的接口提供給客戶端，這一客戶只需要根據(jù)這個類來獲取相應的接口對象，于此同時，接口具體使用哪個實現(xiàn)，我們就可以抽離到這個類里面，給我們提供了一個控制 使用哪個類的 隔離擴展區(qū)，客戶端也不需要關心他用的這個類是對應哪種實現(xiàn)，如何實現(xiàn)的。

上面這套思想，設計模式中稱之為 “工廠”

簡單工廠的模式結(jié)構(gòu)

樣例代碼：

//客戶端類
public class Client {
    public static void main(String[] args) {
        Product p = SimpleFactory.makeProduct(Const.PRODUCT_A);
        p.show();
    }
}

//抽象產(chǎn)品
    public interface Product {
        void show();
    }
    //具體產(chǎn)品：ProductA
    public class ConcreteProduct1 implements Product {
        public void show() {
            System.out.println("具體產(chǎn)品1顯示...");
        }
    }
    //具體產(chǎn)品：ProductB
    public class ConcreteProduct2 implements Product {
        public void show() {
            System.out.println("具體產(chǎn)品2顯示...");
        }
    }

 //枚舉
   public final class Const {
        static final int PRODUCT_A = 0;
        static final int PRODUCT_B = 1;
        static final int PRODUCT_C = 2;
    }
　　//工廠
    public class SimpleFactory {
        public static Product makeProduct(int kind) {
            switch (kind) {
                case Const.PRODUCT_A:
                    return new ConcreteProduct1();
                case Const.PRODUCT_B:
                    return new ConcreteProduct2();
            }
            return null;
        }
    }

對簡單工廠的理解

簡單工廠的意義

首先看上面簡單工廠的樣例代碼，有人會困惑，不就是把new操作從客戶端移動到了額外的類里去了么，本質(zhì)還是new 了一個實現(xiàn)類，這里我們再次回到原點，我們前面提到的接口，接口是用來封裝隔離的，目的就是讓客戶端不要知道封裝體內(nèi)的具體實現(xiàn)，簡單工廠的位置是處于封裝體內(nèi)的，簡單工廠跟接口的具體實現(xiàn)在一起，算是封裝體內(nèi)部的一個類，所以簡單工廠知道具體的實現(xiàn)類是沒有關系的，我們再來看一下簡單工廠的類圖：

圖中淺藍色的虛線框即為一個封裝的邊界，表示接口、工廠、實現(xiàn)類組合成了一個組件，在這個組件中，只有接口和工廠是對外的，也只有這倆，外界可以使用和訪問到，但是具體的實現(xiàn)類，完全是內(nèi)部的，對外透明的，不可見的，所以它被全包裹進藍框，對于客戶端而言，它只知道這個Alg接口和生產(chǎn)含有Alg功能實例的工廠，通過Factory就能獲取Alg的能力了，所以，new操作劃在工廠內(nèi)，在設計和隔離的意義上，有了質(zhì)的變化。

簡單工廠的別稱

靜態(tài)工廠

所謂靜態(tài)工廠，就是我們使用工廠的時候，不需要實例化工廠了，直接將生產(chǎn)的方法設為靜態(tài)方法，通過類名即可調(diào)用，或者做成單例的模式，也就是說簡單工廠的方法通常都是靜態(tài)的，所以稱之為靜態(tài)工廠。

萬能工廠

一個簡單工廠可以包含很多用來構(gòu)建東西的方法，這些方法可以創(chuàng)建不同的接口、實力類，一個簡單的工廠理論上可以構(gòu)造任何東西，所以又稱之為“萬能工廠”

簡單工廠的本質(zhì)

簡單工廠的本質(zhì)是：選擇實現(xiàn)

選擇實現(xiàn)，重點在于選擇，實現(xiàn)是已經(jīng)做好了的，就算實現(xiàn)再簡單（哪怕是new實例）也要由具體的實現(xiàn)類來實現(xiàn)，而不是在簡單工廠里面來實現(xiàn)，簡單工廠的目的在為客戶端提供一個選擇，選擇哪種實現(xiàn)，從而使客戶端和具體的實現(xiàn)之間解耦。這樣具體實現(xiàn)無論如何變動，都不需要客戶端隨之變動，這個變動會在工廠這一層里被吸收和隔斷。

實現(xiàn)簡單工廠的難點在于“選擇”的實現(xiàn)，可以通過傳參，也可以通過動態(tài)的參數(shù)，比如在運行期間去讀取配置文件或數(shù)據(jù)庫、內(nèi)存中的某個值，根據(jù)這個值來進行具體的實現(xiàn)。

擴展簡單工廠：提供可配置的簡單工廠

基本的實現(xiàn)套路，已經(jīng)有較為明確的模板了，現(xiàn)在有一個問題，就是如果MatcherAlg的實現(xiàn)類不止一個，我們可以通過在工廠的方法中傳入?yún)?shù)來處理

public Class Factory{

  public static MatcherAlg createAlg(String type){

        if( type.equals("a") ){
            return new aAlg();
        }else if ( type.equals("b") ){
            return new bAlg();
        }else{
               ……
        }

}
}

可是，當我們又又擴展了新的實現(xiàn)類的時候，if else 又需要擴展一句，同時對客戶端也要告知，這樣對于Factory這個類來說，嚴重違反了開閉原則。

為了解決這個問題，我們可以通過配置文件的形式來解決，當有了新的實現(xiàn)類或者需要默認指定用哪一個實現(xiàn)的時候，只需要通過配置文件的配置項即可，通過配置文件的方式，多需要使用java的反射來支持動態(tài)建立對象。這里摘取自己的一個代碼來作為一個樣例：

/**
 * 基礎工廠，其他組件工廠的實現(xiàn)可用基于該類進行擴展
 * 功能：根據(jù)配置文件動態(tài)生成對象
 * @author GCC
 */
public abstract class AbstractFactory {

    private static Logger logger = Logger.getLogger(AbstractFactory.class);

    //默認自帶的類控制配置文件
    private final static String DEFAULTCONFIG_FILE_URL = "factoryconfig.ini";

    //默認的配置文件
    static URL defaultConfigFileUrl = AbstractFactory.class.getClassLoader().getResource(DEFAULTCONFIG_FILE_URL);

    /**
     * 根據(jù)配置文件以及key值，獲取對象的類路徑
     * @param url   配置文件路徑
     * @param key   關鍵字
     * @return  String 類路徑
     */
    static String getClassUrl(String url,String key){
        ConfigUtil config = new ConfigUtil(url);
        return config.getValueByConfigkey(key);
    }

    /**
     * 根據(jù)指定配置文件及指定關鍵字生成對象
     * @param url   配置文件路徑
     * @param key   關鍵字
     * @return  Object 具體對象
     */
    static Object getObject(String url,String key){
        String classurl = getClassUrl(url,key);
        try{
            Class oneclass = Class.forName(classurl);
            return oneclass.newInstance();
        }catch (Exception e){
            logger.error(e.getMessage() +" plase check"+ DEFAULTCONFIG_FILE_URL );
        }
        return null;
    }



}

配置文件（.ini文件）內(nèi)容：

#matcher.algclassurl:算法類地址
matcher.algclassurl=org.gds.matcher.impl.LevenshteinMacther

簡單工廠的缺陷

簡單工廠實現(xiàn)簡單，非常友好的提供了一套實現(xiàn)組件封裝的功能，同時也解決了客戶端何內(nèi)部實現(xiàn)類的強耦合，實現(xiàn)了解耦。這是簡單工廠的優(yōu)點，但世事都是兩面的，它也有不可避免地缺點：

首先，它增加了客戶端的復雜程度，如果通過客戶端的參數(shù)來選擇具體的實現(xiàn)類，那客戶端必須額外需要一份枚舉表或者字典，并且知道每個枚舉的意義，這樣會增加客戶端的復雜程度，同時一定程度上暴露了內(nèi)部的實現(xiàn)（雖然可配置方案一定程度上可以對沖這一問題）。

其次，簡單工廠使用靜態(tài)方法（又叫靜態(tài)工廠）來創(chuàng)建接口，當面臨一些復雜的組件創(chuàng)建，靜態(tài)方法會非常龐大，無法通過繼承來擴展創(chuàng)建接口的方法的行為了。

以上就是如何從Java接口的角度切入靜態(tài)工廠模式的詳細內(nèi)容，更多關于從Java接口的角度切入靜態(tài)工廠模式的資料請關注腳本之家其它相關文章！

最新評論