Java8实战-通过行为参数化传递代码

简介: Java8实战-通过行为参数化传递代码

行为参数化

在《Java8实战》第二章主要介绍的是通过行为参数化传递代码,那么就来了解一下什么是行为参数化吧。

在软件工程中,一个从所周知的问题就是,不管你做什么,用户的需求总是会变的(PM的需求总是会变的)。比方说,有个应用程序是帮助农民了解自己的库存。这位农民可能想有一个查找库存中所有绿色苹果的功能。但是到了第二天,他突然告诉你:“其实我还想找出所有重量超过150克的苹果。”,你一想简单嘛不就是改一下条件而已。于是过了两天,他又说:“要是我可以筛选即使绿色的苹果,重量也超过150克的苹果。”,这样频繁的改需求也不太好,面对这样的情况理想状态下应该把工作量降到最低。此外,类似的功能实现起来应该还是很简单,而且利于长期维护。

行为参数化就是要帮助你处理频繁更变的需求的一种软件开发模式。一言以蔽之,它意味着拿出一个代码块,把它准备好却不去执行它。这个代码块以后可以被你程序的其他部分调用,这意味着你可以推迟这块代码的执行。例如,你可以将代码块作为参数传递给另外一个方法,稍后再去执行它。这样,这个方法的行为就基于那块代码被参数化了。

应对不断变化的需求

想要编写能应对变化的需求并不容易。让我们来看一个例子,我们将会逐渐的改进这个例子,以展示一些让代码更灵活的做法。就像农场库存程序而言,你需要实现一个从列表中筛选绿苹果的功能。

筛选苹果

  1. 筛选绿苹果,可能你选择最初的解决方案就是这样:
private static List<Apple> filterGreenApples(List<Apple> apples) {
    List<Apple> appleList = new ArrayList<Apple>();
    for (Apple apple : apples) {
        if ("green".equals(apple.getColor())) {
            appleList.add(apple);
        }
    }
    return appleList;
}
复制代码

现在代码中就是筛选绿苹果。但现在农民改主意了,他还想要筛选红苹果。按照最简单的方法就是,把方法复制一下并且改一下条件为筛选红苹果的条件。是的,这样做起来很简单,要是农民想要筛选多种颜色:青色、深红、淡红...这种方法就不太适合了。

  1. 优化代码,通过颜色作为参数筛选苹果:
private static List<Apple> filterApplesByColor(List<Apple> apples, String color) {
    List<Apple> appleList = new ArrayList<Apple>();
    for (Apple apple : apples) {
        if (color.equals(apple.getColor())) {
            appleList.add(apple);
        }
    }
    return appleList;
}
复制代码

很简单对吧。现在,农民又有想法:“能筛选出轻苹果和重苹果就好啦!一般重苹果的重量是150克。”你可能早就想到了需要通过重量来筛选苹果,于是你又把参数穿进来作为条件进行筛选。

  1. 将重量作为参数,进行重苹果筛选:
private static List<Apple> filterApplesByWeight(List<Apple> apples, int weight) {
    List<Apple> appleList = new ArrayList<Apple>();
    for (Apple apple : apples) {
        if (apple.getWeight() > weight) {
            appleList.add(apple);
        }
    }
    return appleList;
}
复制代码

是的,解决方法很简单,但是你复制了大部分的代码来实现遍历库存,并对每个苹果应用筛选条件。这样破坏了DRY(Don't Repeat Yourself 不要重复自己)的软件工程原则。或许,你一下就想到了这办法,将所有的参数都放在一个方法中,这样就可以简化很多代码了。

  1. 第三次尝试,对你能想到的每个属性做筛选:
private static List<Apple> filterApples(List<Apple> apples, String color, int weight, boolean flag) {
    List<Apple> appleList = new ArrayList<Apple>();
    for (Apple apple : apples) {
        boolean result = (flag && apple.getWeight() > weight) || (!flag && color.equals(apple.getColor()));
        if (result) {
            appleList.add(apple);
        }
    }
    return appleList;
}
复制代码

代码看起来很简单,但是感觉却是不太好。如果不把注释写清楚,别人阅读你代码时根本就不知道flag是干嘛用的。要是,农民突然又有个想法,需用通过大小、形状、产地等条件来进行筛选怎么办?所以,我们需要利用行为参数化来解决这个问题,提高代码的灵活性。

行为参数化

目前,你需要一种比添加很多参数更好的方法来应对变化的需求。让我们退一步来看看更高层次的抽象。一种可能解决方案是对你的悬着标准建模:你考虑的是苹果,需要根据Apple的某些属性(比如它是绿色的吗?重量超过150克吗?)来返回一个boolean值。是的,你可能已经想到了第一章中介绍到了的谓词。

根据谓词进行筛选

首先,我们应该定义一个接口来对选择标准建模:

public interface ApplePredicate {
    /**
     * 根据给定的参数计算此谓词。
     *
     * @param apple
     * @return
     */
    boolean test(Apple apple);
}
复制代码

可以用ApplePredicate的实现类来代表不同的选择标准:

只筛选绿苹果

public class AppleGreenColorPredicate implements ApplePredicate {
    @Override
    public boolean test(Apple apple) {
        return "green".equals(apple.getColor());
    }
}
复制代码

只筛选重苹果

public class AppleHeavyWeightPredicate implements ApplePredicate {
    @Override
    public boolean test(Apple apple) {
        return apple.getWeight() > 150;
    }
}
复制代码

你可以把这些标准看作filter的不同行为。这就像策略设计模式一样,它让你定义一组方法,把它们封装起来,然后在运行时选择一个方法。这里,方法就是ApplePredicate,不同的策略就是AppleHeavyWeightPredicate和AppleGreenColorPredicate。

你可以将filterApples方法接受一个ApplePredicate对象,对Apple做条件测试。这样就是行为参数化:让方法接受多种行为作为参数,并在内部使用,来完成不同的行为。

根据抽象条件筛选

private static List<Apple> filterApples(List<Apple> apples, ApplePredicate<Apple> applePredicate) {
    List<Apple> appleList = new ArrayList<>();
    for (Apple apple : apples) {
        if (applePredicate.test(apple)) {
            appleList.add(apple);
        }
    }
    return appleList;
}
复制代码

代码的传递/行为

酷,这段代码看起来很多了,读起来、用起来也更容易!现在你可以创建不同的ApplePredicate对象,并将它们传递给filterApples方法。这样就可以根据不同的条件来创建一个类并且实现ApplePredicate就可以了。

现在,农民要求需要筛选红苹果。那么,我们就可以根据条件创建一个类并且实现ApplePredicate:

public class AppleRedAndHeavyPredicate implements ApplePredicate {
    @Override
    public boolean test(Apple apple) {
        return "red".equals(apple.getColor()) && apple.getWeight() > 150;
    }
}
复制代码
List<Apple> filterApples2 = filterApples(apples, new AppleRedAndHeavyPredicate());
System.out.println("通过谓词筛选红苹果并且是重苹果:" + filterApples2);
复制代码

酷,现在filterApples方法的行为已经取决于通过ApplePredicate对象来实现了。这就是行为参数化了!

但是,你有没有发现,我们每次新增一个条件就需要新增一个类。这样做有点太过于麻烦,或许我们可以通过Lambda,将表达式传递给filterApples方法,这样就无需定义多个ApplePredicate类,从而去掉不必要的代码,并减轻工作量。

多种行为,一个参数

行为参数化的好处在与你可以把迭代要筛选的集合的逻辑与对集合中每个元素应用的行为区分开来。这样你就可以重复使用同一个方法,给它不同的行为来达到不同的目的。

为了能够对参数化行为运用自如,并且简化代码,我们来尝试将参数通过Lambda的方式传递给filterApples。

通过Lambda的方式来筛选红苹果:

List<Apple> filterApples3 = filterApples(apples, apple -> "red".equals(apple.getColor()));
复制代码

通过Lambda的方式来筛选红苹果并且是重苹果:

List<Apple> filterApples4 = filterApples(apples, apple -> "red".equals(apple.getColor()) && apple.getWeight() > 150);
复制代码

是的,使用的已经还是原来的条件,并且不再需要根据不同的条件再去实现一个ApplePredicate类了,这样极大的简化了代码。但是,农民又有一个需求了:“现在,不只是需要对苹果进行筛选了,还需要对香蕉、橘子、草莓进行筛选了。”

但是,我们目前的代码只能够对苹果进行筛选而已,为了解决这个问题,我们可以将类型定义为泛型,这样就不只是只能对苹果进行筛选了。

使用谓词

其实,我们可以不需要去定义谓词,因为在Java中就一个了Predicate了,我们可以使用它并且实现我们的功能。

定义一个泛型的filter方法:

private 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> heavyApples = filter(apples, (Apple apple) -> apple.getWeight() > 150);
复制代码

筛选能被2整除的数:

List<Integer> numbers = Arrays.asList(10, 11, 8, 5, 1, 2, 29, 18);
List<Integer> integerList = filter(numbers, number -> number % 2 == 0);
复制代码

是不是很酷?现在的代码简洁性和灵活性都很高,在Java8之前这些都是不可能做到的!

现在,你已经感觉到了行为参数化是一个很有用的模式,它能够轻松地适应不断变化的需求。在Java中很多方法都可以用不同的行为来参数化,比如使用Comparator排序,用Runnable执行一个代码块等等。

使用Comparator来排序:

apples.sort((Apple a1, Apple a2) -> a1.getWeight().compareTo(a2.getWeight()));
复制代码

或者这样:

apples.sort(Comparator.comparing(Apple::getWeight));
复制代码

使用Runnable执行某个代码块:

Thread t = new Thread(() -> System.out.println("HelloWorld"));
复制代码

总结

  1. 行为参数化,就是一个方法接受多个不同的行为作为参数,并在内部使用它们,完成不同行为的能力。
  2. 行为参数化可以让代码更好的适应不断变化的要求,减轻工作量。
  3. 传递代码,就是将新行为作为参数传递给方法。但在Java8之前这实现起来很啰嗦。为接口生命许多只是用一次的实体类而造成的啰嗦代码,在Java8之前采用匿名类来减少。
  4. JavaAPI包含了很多可以用不同行为进行参数化的方法,包括排序、线程等。
目录
相关文章
|
12天前
|
缓存 安全 算法
Java面试题:如何通过JVM参数调整GC行为以优化应用性能?如何使用synchronized和volatile关键字解决并发问题?如何使用ConcurrentHashMap实现线程安全的缓存?
Java面试题:如何通过JVM参数调整GC行为以优化应用性能?如何使用synchronized和volatile关键字解决并发问题?如何使用ConcurrentHashMap实现线程安全的缓存?
11 0
|
7天前
|
缓存 监控 Java
Java虚拟机(JVM)性能调优实战指南
在追求软件开发卓越的征途中,Java虚拟机(JVM)性能调优是一个不可或缺的环节。本文将通过具体的数据和案例,深入探讨JVM性能调优的理论基础与实践技巧,旨在为广大Java开发者提供一套系统化的性能优化方案。文章首先剖析了JVM内存管理机制的工作原理,然后通过对比分析不同垃圾收集器的适用场景及性能表现,为读者揭示了选择合适垃圾回收策略的数据支持。接下来,结合线程管理和JIT编译优化等高级话题,文章详细阐述了如何利用现代JVM提供的丰富工具进行问题诊断和性能监控。最后,通过实际案例分析,展示了性能调优过程中可能遇到的挑战及应对策略,确保读者能够将理论运用于实践,有效提升Java应用的性能。 【
39 10
|
2天前
|
JSON Java BI
一次Java性能调优实践【代码+JVM 性能提升70%】
这是我第一次对系统进行调优,涉及代码和JVM层面的调优。如果你能看到最后的话,或许会对你日常的开发有帮助,可以避免像我一样,犯一些低级别的错误。本次调优的代码是埋点系统中的报表分析功能,小公司,开发结束后,没有Code Review环节,所以下面某些问题,也许在Code Review环节就可以避免。
34 0
一次Java性能调优实践【代码+JVM 性能提升70%】
|
6天前
|
存储 缓存 JavaScript
|
6天前
|
SQL Java 数据处理
实时计算 Flink版产品使用问题之使用MavenShadePlugin进行relocation并遇到只包含了Java代码而未包含Scala代码,该怎么办
实时计算Flink版作为一种强大的流处理和批处理统一的计算框架,广泛应用于各种需要实时数据处理和分析的场景。实时计算Flink版通常结合SQL接口、DataStream API、以及与上下游数据源和存储系统的丰富连接器,提供了一套全面的解决方案,以应对各种实时计算需求。其低延迟、高吞吐、容错性强的特点,使其成为众多企业和组织实时数据处理首选的技术平台。以下是实时计算Flink版的一些典型使用合集。
|
11天前
|
Java 编译器 API
Java中的Lambda表达式:简化代码,提升性能
在Java 8中,Lambda表达式的引入为开发者提供了一种更加简洁、灵活的编程方式。本文将深入探讨Lambda表达式的概念、语法、使用场景及其在Java中的应用示例,帮助读者更好地理解和掌握这一强大工具,从而优化代码结构,提高开发效率。
|
12天前
|
算法 Java 开发者
Java面试题:Java内存探秘与多线程并发实战,Java内存模型及分区:理解Java堆、栈、方法区等内存区域的作用,垃圾收集机制:掌握常见的垃圾收集算法及其优缺点
Java面试题:Java内存探秘与多线程并发实战,Java内存模型及分区:理解Java堆、栈、方法区等内存区域的作用,垃圾收集机制:掌握常见的垃圾收集算法及其优缺点
13 0
|
12天前
|
安全 Java 调度
Java面试题:Java内存优化、多线程安全与并发框架实战,如何在Java应用中实现内存优化?在多线程环境下,如何保证数据的线程安全?使用Java并发工具包中的哪些工具可以帮助解决并发问题?
Java面试题:Java内存优化、多线程安全与并发框架实战,如何在Java应用中实现内存优化?在多线程环境下,如何保证数据的线程安全?使用Java并发工具包中的哪些工具可以帮助解决并发问题?
12 0
|
12天前
|
Java 调度
Java线程的六种状态
Java线程有六种状态: 初始(NEW)、运行(RUNNABLE)、阻塞(BLOCKED)、等待(WAITING)、超时等待(TIMED_WAITING)、终止(TERMINATED)。
30 1
|
12天前
|
存储 安全 Java
Java面试题:请解释Java内存模型(JMM)是什么,它如何保证线程安全?
Java面试题:请解释Java内存模型(JMM)是什么,它如何保证线程安全?
56 13