Java行为参数化的演进

首先感谢《java8实战》一书作者某某某。

需求场景：

为一位果农设计一款软件，可以根据果农的需求筛选出相应的水果。

例如：

1. 根据颜色筛选
2. 根据重量筛选
3. 根据颜色和重量筛选

准备工作

1. 定义Apple类

   public class Apple
   {
       String color;
       double weight;
   
       public Apple(String color,double weight)
       {
           this.color=color;
           this.weight=weight;
       }
   }
   

2. 创建苹果库存

   List<Apple> inventory=new ArrayList<Apple>()
   {
       {
           add(new Apple("红色",200));
           add(new Apple("绿色",80));
           add(new Apple("红色",100));
           add(new Apple("绿色",210));
           add(new Apple("红色",105));
           add(new Apple("黄色",180));
           add(new Apple("红色",202));
           add(new Apple("红色",99));
       }
   };
   

阶段1：值参数化 - 为每一种行为定义一个单独的方法

筛选绿苹果

List<Apple> filterGreenApple(List<Apple> inventory)
{
    List<Apple> res=new ArrayList<Apple>();
    for(Apple apple: inventory)
    {
        if("绿色".equals(apple.color))
        {
            res.add(apple);
        }
    }
    return res;
}

筛选红苹果

List<Apple> filterHeavyApple(List<Apple> inventory)
{
    List<Apple> res=new ArrayList<Apple>();
    for(Apple apple: inventory)
    {
        if("红色".equals(apple.color))
        {
            res.add(apple);
        }
    }
    return res;
}

无需多言，这种方式很糟糕，如果再有其它需求，还得定义更多的这种方法，其中大部分的代码都是重复的。

阶段2：值参数化 - 将条件作为参数

根据颜色筛选苹果

List<Apple> filterAppleByColor(List<Apple> inventory,String color)
{
    List<Apple> res=new ArrayList<Apple>();
    for(Apple apple: inventory)
    {
        if(color.equals(apple.color))
        {
            res.add(apple);
        }
    }
    return res;
}

根据重量筛选苹果

List<Apple> filterAppleByWeight(List<Apple> inventory,double weight)
{
    List<Apple> res=new ArrayList<Apple>();
    for(Apple apple: inventory)
    {
        if(apple.weight>=weight)
        {
            res.add(apple);
        }
    }
    return res;
}

这种为每一种属性定义一个方法的写法，一定程度上解决了代码重复的问题。但是，还不够。

阶段3: 值参数化 - 为属性设置标志

根据颜色或重量筛选苹果

List<Apple> filterApple(List<Apple> inventory,String color,boolean flag)
{
    List<Apple> res=new ArrayList<Apple>();
    for(Apple apple: inventory)
    {
        if(flag && color.equals(apple.color) || (!flag && apple.weight>=150))
        {
            res.add(apple);
        }
    }
    return res;
}

这种方式解决了代码重复的问题，但是，当要筛选的属性很多时，需要添加过多的标志参数，使得单个方法中的代码过于复杂，容易出错。

阶段4: 行为参数化 - 使用接口对选择标准建模

定义行为接口

public interface IApplePredicate
{
    boolean test(Apple apple);
}

定义筛选绿色苹果的行为类

public class GreenApplePredicate implements IApplePredicate
{
    public boolean test(Apple apple)
    {
        return "绿色".equals(apple.color);
    }
}

定义筛选重量大于150克的苹果的行为类

public class HeavyApplePredicate implements IApplePredicate
{
    public boolean test(Apple apple)
    {
        return apple.weight>=150;
    }
}

定义筛选方法，接收行为接口的实例作为参数

List<Apple> filterApples(List<Apple> inventory,IApplePredicate predicate)
{
    List<Apple> res=new ArrayList<Apple>();
    for(Apple apple: inventory)
    {
        if(predicate.test(apple))
        {
            res.add(apple);
        }
    }
    return res;
}

筛选的时候，只需要传递行为类对象即可

List<Apple> greenApples=filterApples(inventory,new GreenApplePredicate());
List<Apple> heavyApples=filterApples(inventory,new HeavyApplePredicate());

通过上面这种方式，可以重复使用同一个方法，给她不同的行为来实现不同的目的。

代码结构清晰，很好。但是，必须为每一种行为定义一个类，还是比较繁琐。

阶段5: 行为参数化 - 使用匿名类避免单独定义行为类

不必为每一种行为都定义一个行为类，然后在使用具体方法的时候，传递它的对象。可以使用匿名类实现同样的效果

List<Apple> greenApples=filterApples(inventory,new IApplePredicate()
{
    public boolean test(Apple apple)
    {
        return "绿色".equals(apple.color);
    }
});
List<Apple> heavyApples=filterApples(inventory,new IApplePredicate()
{
    public boolean test(Apple apple)
    {
        return apple.weight>=150;
    }
});

阶段6: 行为参数化 - 使用lambda表达式代替匿名类

匿名类固然不错，但是，语法很是丑陋。在java8中，可以使用lambda表达式代替匿名类

List<Apple> greenApples=filterApples(inventory,apple->"绿色".equals(apple.color));
List<Apple> heavyApples=filterApples(inventory,apple -> apple.weight>=150);

阶段7: 行为参数化 - 使用泛型扩展行为的适用范围

目前为止，只能用来过滤苹果，如果想过滤梨子，就得重新定义梨的行为接口。

这样很不方便。这时，就可以使用泛型来解决这个问题。

定义泛型行为接口

public interface IPredicate<T>
{
    boolean test(T t);
}

将筛选方法改造为泛型方法

<T> List<T> filter(List<T> elements,IPredicate<T> predicate)
{
    List<T> res=new ArrayList<>();
    for(T t: elements)
    {
        if(predicate.test(t))
        {
            res.add(t);
        }
    }
    return res;
}

这样，筛选方法不止适用于苹果，还适用于梨子，甚至数字类型。

至此，使用行为参数化，完美的解决了需求多变的问题。