亲宝软件园·资讯

展开

java传递代码方案

玉带林中挂 人气:0

行为参数化:它意味着拿出一个代码块,把它准备好但是不执行,可以推迟该代码块的执行,比如将代码块作为参数,需要的时候再内部执行。
下面我来通过例子来描述什么是行为参数化:
现在来写一个有关筛选苹果的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()));

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

总结:

以上几个例子依次展示了如何做好抽象,完成更灵活的代码,也展示了由变量到接口到匿名类到lambda表达式的演进,这都是慢慢演化过来的,最主要的还是要明白最初的写法,在优秀的代码也是站在最初的思路上进行优化的。

加载全部内容

相关教程
猜你喜欢
用户评论