使用為抽象操作而生的接口：接口只定義抽象的方法，具體的方法實(shí)現(xiàn)可以有不同的類來實(shí)現(xiàn)。如果把這些操作放到繼承了一般篩選器的不同篩選方法的篩選器中去就會(huì)有一個(gè)典型的面向?qū)ο笫降慕鉀Q方案了：

interface AppleFilter {
    public List filterByRules(List apples);
}

class RedAppleFilter implements AppleFilter{

    @Override
    public List filterByRules(List apples) {
        List redApples = new ArrayList<>();
        for (Apple apple:
                apples) {
            if("red".equals(apple.getColor())){
                redApples.add(apple);
            }
        }
        return redApples;
    }
}

class GreenAppleFilter implements AppleFilter{

    @Override
    public List filterByRules(List apples) {
        List greenApples = new ArrayList<>();
        for (Apple apple:
                apples) {
            if("green".equals(apple.getColor())){
                greenApples.add(apple);
            }
        }
        return greenApples;
    }
}

我們發(fā)現(xiàn)雖然使用了面向?qū)ο蟮木幊谭椒m然可以使得邏輯結(jié)構(gòu)更為清晰：子類蘋果篩選器實(shí)現(xiàn)了一般蘋果篩選器的抽象方法，但仍然會(huì)有大量的代碼是出現(xiàn)多次的。
這就是典型的壞代碼的味道，重復(fù)編寫了兩個(gè)基本一樣的代碼，所以我們要怎么修改才能使得代碼應(yīng)對(duì)變化的需求呢，比如可以應(yīng)對(duì)篩選其他顏色的蘋果，不要某些顏色的蘋果，可以篩選某些重量范圍的蘋果等等，而不是每個(gè)確定的篩選都需要編寫?yīng)毩⑶一具壿嬒嗤拇a呢？

我們來看一下重復(fù)的代碼究竟是哪些：

List greenApples = new ArrayList<>();
   for (Apple apple:
           apples) {
       ... ...
   }
   return greenApples;

不重復(fù)的代碼有哪些：

if("green".equals(apple.getColor())){
    
}

其實(shí)對(duì)于循環(huán)列表這部分是對(duì)篩選這一邏輯的公用代碼，而真正不同的是篩選的具體邏輯：根據(jù)紅色篩選、綠色篩選等等。

而造成現(xiàn)在局面的原因就在于僅僅對(duì)大的篩選方法的實(shí)現(xiàn)的抽象層級(jí)太低了，所以就會(huì)編寫太多的代碼，如果篩選的抽象層級(jí)定位到篩選策略這一級(jí)就會(huì)大大提升代碼的抽象能力。

所謂策略的范圍就是我們上面找到的這個(gè)“不重復(fù)的代碼”：在這個(gè)問題里面就是什么樣的蘋果是可以經(jīng)過篩選的。所以我們需要的這個(gè)策略就是用于確定什么樣的蘋果是可以被選出來的。我們定義一個(gè)這樣的接口：給一個(gè)蘋果用于判斷，在test方法里對(duì)這個(gè)蘋果進(jìn)行檢測(cè)，然后給出是否被選出的結(jié)果。

interface AppleTester{
    public Boolean test(Apple apple);
}

比如我們可以通過實(shí)現(xiàn)上述接口，重寫這個(gè)test方法使之成為選擇紅蘋果的方法，然后我們就可以得到一個(gè)紅蘋果選擇器：

class RedAppleTester implements AppleTester{
    @Override
    public Boolean test(Apple apple) {
        return "red".equals(apple.getColor());
    }
}

再比如我們可以通過實(shí)現(xiàn)上述接口，重寫這個(gè)test方法使之成為選擇大蘋果的方法，然后我們就可以得到一個(gè)大蘋果選擇器：

class BigAppleTester implements AppleTester{
    @Override
    public Boolean test(Apple apple) {
        return apple.getWeight()>150;
    }
}

有了這個(gè)選擇器，我們就可以把這個(gè)選擇器，亦即我們上面提到的篩選策略，傳給我們的篩選器，以此進(jìn)行相應(yīng)需求的篩選，只要改變選擇器，就可以更換篩選策略：

public static List filterSomeApple(List apples,AppleTester tester){
        ArrayList resList = new ArrayList<>();
        for (Apple apple
                : apples) {
            if(tester.test(apple))
                resList.add(apple);
        }
        return resList;
    }

List redApples = filterSomeApple(apples,new RedAppleTester());

List bigApples = filterSomeApple(apples,new BigAppleTester());

通過使用Java的匿名類來實(shí)現(xiàn)選擇器接口，我們可以不顯式地定義RedAppleTester，BigAppleTester，而進(jìn)一步簡(jiǎn)潔代碼：

List redApples = filterSomeApple(apples, new AppleTester() {
            @Override
            public Boolean test(Apple apple) {
                return "red".equals(apple.getColor());
            }
        });

List bigApples = filterSomeApple(apples, new AppleTester() {
            @Override
            public Boolean test(Apple apple) {
                return apple.getWeight()>150;            
            }
        });

所以我們已經(jīng)從上面的說明中看到，我們定義的策略是：一個(gè)實(shí)現(xiàn)了一般蘋果選擇器接口的抽象方法的特殊蘋果選擇器類的對(duì)象，因?yàn)槭菍?duì)象，所以當(dāng)然是可以在代碼里作為參數(shù)來傳遞的。這也就是我們反復(fù)提到的在函數(shù)式編程里的策略傳遞，在原書中叫做「行為參數(shù)化的目的是傳遞代碼」。

說到這里，其實(shí)這種函數(shù)式編程的解決思路并未出現(xiàn)什么Java8的新特性，在低版本的Java上即可實(shí)現(xiàn)這個(gè)過程，因?yàn)樗悸冯m然很繞，但是說到底使用的就是簡(jiǎn)單的接口實(shí)現(xiàn)和方法重寫。實(shí)際上呢，借助Java 8新的特性，我們可以更方便地使用語法糖來編寫更簡(jiǎn)潔、更易懂的代碼。

我們上面定義的這種單方法接口叫做函數(shù)式接口：

interface AppleTester{
    public Boolean test(Apple apple);
}

函數(shù)式接口的這個(gè)方法就是這個(gè)函數(shù)式接口的函數(shù)，這個(gè)函數(shù)的「參數(shù)-返回值」類型描述叫做函數(shù)描述符，test函數(shù)的描述符是 Apple->Boolean。
而lambda表達(dá)式其實(shí)是一種語法糖現(xiàn)象，它是對(duì)函數(shù)實(shí)現(xiàn)的簡(jiǎn)單表述，比如我們上文的一個(gè)函數(shù)實(shí)現(xiàn)，即實(shí)現(xiàn)了AppleTester接口的RedAppleTester:

class RedAppleTester implements AppleTester{
    @Override
    public Boolean test(Apple apple) {
            return "red".equals(apple.getColor());
    }
}

這個(gè)實(shí)現(xiàn)類可以用lambda表達(dá)式
(Apple a) -> "red".equals(a.getColor())
或者
(Apple a) -> {return "red".equals(a.getColor());}
來代替。->前是參數(shù)列表，后面是表達(dá)式或命令。

在有上下文的情況下，甚至有更簡(jiǎn)潔的寫法：
AppleTester tester = a -> "red".equals(a.getColor());
可以這樣寫的原因在于編譯器可以根據(jù)上下文來推斷參數(shù)類型:AppleTester作為函數(shù)式接口只定義了單一抽象方法：public Boolean test(Apple apple)，所以可以很容易地推斷出其抽象方法實(shí)現(xiàn)的參數(shù)類型。

如果AppleUtils工具類直接定義了判定紅蘋果的方法：

class AppleUtils {
    public static Boolean isRedApple(Apple apple) {
        return "red".equals(apple.getColor());
    }
}

我們會(huì)發(fā)現(xiàn)isRedApple方法的方法描述符和函數(shù)式接口AppleTester定義的單一抽象方法的函數(shù)描述符是一樣的：Apple->Boolean，因此我們可以采用一種叫做方法引用的語法糖來進(jìn)一步化簡(jiǎn)這個(gè)lambda表達(dá)式，不需要在lambda表達(dá)式中重復(fù)寫已經(jīng)定義過的方法：

AppleTester tester = AppleUtils::isRedApple

方法引用之所以可以起作用，就是因?yàn)檫@個(gè)被引用的方法具有和引用它的函數(shù)式接口的函數(shù)描述符相同的方法描述符。在實(shí)際創(chuàng)建那個(gè)實(shí)現(xiàn)了抽象方法的匿名類對(duì)象時(shí)會(huì)將被引用的方法體嵌入到這個(gè)實(shí)現(xiàn)方法中去：

雖然寫起來簡(jiǎn)潔了，但是在本質(zhì)上編譯器會(huì)將lambda表達(dá)式編譯成一個(gè)這樣的實(shí)現(xiàn)了接口抽象方法的匿名類的對(duì)象。
基于lambda表達(dá)式簡(jiǎn)潔而強(qiáng)大的表達(dá)能力，可以很容易把上面的這段代碼：

List redApples = filterSomeApple(apples, new AppleTester() {
            @Override
            public Boolean test(Apple apple) {
                return "red".equals(apple.getColor());
            }
        });

改寫為Java8版本的：

List redApples = filterSomeApple(apples, AppleUtils::isRedApple);

如你所見，這樣的寫法瞬間將代碼改到Java8前無法企及的簡(jiǎn)潔程度。

我們?cè)谏衔慕榻B的這個(gè)函數(shù)式接口：

interface AppleTester{
    public Boolean test(Apple apple);
}

它的作用僅僅是對(duì)蘋果進(jìn)行選擇，通過實(shí)現(xiàn)test抽象方法來作出具體的選擇器。
但是其實(shí)在我們的應(yīng)用環(huán)境中，很多需求是泛化的，比如上文中的給一個(gè)對(duì)象（文中是蘋果）以判斷其是否能滿足某些需求，這個(gè)場(chǎng)景一經(jīng)泛化即可被許多場(chǎng)景所使用，可以使用泛型來對(duì)接口進(jìn)行泛化：

interface ChooseStrategy{
    public Boolean test(T t);
}

public Boolean test(T t)的函數(shù)描述符是T->Boolean，所以只要說滿足這個(gè)描述符的方法都可以作為方法引用。

同時(shí)我們需要一個(gè)泛化的filter方法：

    public static  List filter(List ts, ChooseStrategy strategy){
        ArrayList resList = new ArrayList<>();
        for (T t
                : ts) {
            if(strategy.test(t))
                resList.add(t);
        }
        return resList;
    }

List redApples = filter(apples,AppleUtils::isRedApple);

除了這種在類型上的泛型來泛化使用定義的函數(shù)式接口外，甚至有一些公用的場(chǎng)景Java8 為我們定義了一整套的函數(shù)式接口API來涵蓋這些使用場(chǎng)景中需要的函數(shù)式接口。我們的編程中甚至不需要自己定義這些函數(shù)式接口：

java.util.function.Predicate
函數(shù)描述符：T->boolean

java.util.function.Consumer
函數(shù)描述符：T->void

java.util.function.Function
函數(shù)描述符：T->R

java.util.function.Supplier
函數(shù)描述符：()->T

java.util.function.UnaryOperator
函數(shù)描述符：T->T

java.util.function.BinaryOperator
函數(shù)描述符：(T,T)->T

java.util.function.BiPredicate
函數(shù)描述符：(L,R)->boolean

java.util.function.BiConsumer
函數(shù)描述符：(T,U)->void

java.util.function.BiFunction
函數(shù)描述符：(T,U)->R

Java8通過接口抽象方法實(shí)現(xiàn)、lambda表達(dá)式來實(shí)現(xiàn)了策略對(duì)象的傳遞，使得函數(shù)成為了第一公民，并以此來將函數(shù)式編程帶入了Java世界中。
有了策略傳遞后，使用具體的策略來完成任務(wù)，比如本文中篩選蘋果的filter過程，Java8則依靠StreamAPI來實(shí)現(xiàn)，一系列泛化的任務(wù)過程定義在這些API中，這也將是本系列文章的后續(xù)的關(guān)注。