java中通过行为参数化传递代码方案

行为参数化：它意味着拿出一个代码块，把它准备好但是不执行，可以推迟该代码块的执行，比如将代码块作为参数，需要的时候再内部执行。
下面我来通过例子来描述什么是行为参数化：
现在来写一个有关筛选苹果的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表达式的演进，这都是慢慢演化过来的，最主要的还是要明白最初的写法，在优秀的代码也是站在最初的思路上进行优化的。

到此这篇关于java中通过行为参数化传递代码方案的文章就介绍到这了,更多相关java传递代码方案内容请搜索以前的文章或继续浏览下面的相关文章希望大家以后多多支持！