java传递代码方案

玉带林中挂 2022-05-23 我要评论

行为参数化：它意味着拿出一个代码块，把它准备好但是不执行，可以推迟该代码块的执行，比如将代码块作为参数，需要的时候再内部执行。
下面我来通过例子来描述什么是行为参数化：
现在来写一个有关筛选苹果的demo，现在农民伯伯想要筛选红色的苹果，可以这样来做：

方案一

    public static List<Apple> filterGreenApples(List<Apple> inventory){
        List<Apple> result = new ArrayList<>();
        for (Apple apple : inventory) {
            if ("green".equals(apple.getColor())){
                result.add(apple);
            }
        }
        return result;
    }

现在有一个问题，当农民伯伯改变了主意，它还要筛选红色的苹果，我们是不是还要写一个以“red”为筛选条件的方法呢？是这些方法有很多重复的内容，这就非常冗余。

方案二

我们可以做一层抽象，将总是变化的东西抽出来，这里经常变的是颜色，我们当然可以把颜色抽出来作为一个参数传到筛选的方法里面：

 public static List<Apple> filterColorApples(List<Apple> inventory,String color){
        List<Apple> result = new ArrayList<>();
        for (Apple apple : inventory) {
            if (color.equals(apple.getColor())){
                result.add(apple);
            }
        }
        return result;
    }

这样即使农民伯伯要求五彩斑斓的黑色苹果，也可以筛选出来，但是如果农民伯伯还要筛选重量小于150g的苹果，那还要写有关重量的方法来进行筛选，这期间有很多重复的代码，如果要去除冗余，我们可再做一层抽象，将苹果抽象出来。

方案三

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

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

这样再进行筛选红色的苹果

 public static List<Apple> filterRedColorApples(List<Apple> inventory,ApplePredicate predicate){
        List<Apple> result = new ArrayList<>();
        for (Apple apple : inventory) {
            if (predicate.test(apple)){
                result.add(apple);
            }
        }
        return result;
    }

这样的代码就非常的灵活了，如果想要绿色代码，就创建一个AppleGeenColorPredicate类，如果想要重量大于150g的苹果，也是类似，创建一个AppleWeightPredicate类即可。

这其实就是行为参数化，让方法来接收多种行为做参数，并在内部使用，来完成不同的行为。
但是有些遗憾的是，filterRedColorApples方法只能接受对象，我们其实是将代码包裹在了ApplePredicate对象里面，每次还是需要创建好多的类来完成功能。我们可以通过匿名内部类来实现该功能。

方案四

 public static void main(String[] args) {

        List<Apple> apples = Arrays.asList(new Apple("red", 100), new Apple("green", 200));

        List<Apple> redColorApple = filterColorApples(apples, new ApplePredicate() {
            @Override
            public Boolean test(Apple apple) {
                return "red".equals(apple.getColor());
            }
        });
    }

我们还可以使用上面的方法，通过传一个匿名内部类来实现我们的功能，这样就不用写好多的实现类了，大大简化了代码~，但是还有一个缺点，就是匿名内部类看起来比较啰嗦，并且也不太好理解，我们可以使用java8的新特性–λ表达式。

方案五

 public static void main(String[] args) {

        List<Apple> apples = Arrays.asList(new Apple("red", 100), new Apple("green", 200));

        List<Apple> redColorApple = filterColorApples(apples, (Apple a) -> "red".equals(a.getColor()));
        
    }

这样看起来就简单多了，直接传一个lambda就OK了。
但是还有一个问题，万一农品伯伯想要再进行香蕉的筛选怎么办？我们可以使用泛型来实现，

方案六

   public static <T> List<T> filter(List<T> list, Predicate<T> predicate) {
        List<T> result = new ArrayList<>();
        for (T t : list) {
            if (predicate.test(t)) {
                result.add(t);
            }
        }
        return result;
    }

List<Apple> redColorApple = filterColorApples(apples, (Apple a) -> "red".equals(a.getColor()));

这样来起来就更加的灵活了。