参数维度实现 java锁 java 参数化查询

文章目录

• 一、应对不断变化的需求

• 1. 初试牛刀：筛选绿苹果
• 2. 再展身手：把颜色作为参数
• 3. 第三次尝试：对你能想到的每个属性做筛选

• 二、行为参数化

• 1. 第四次尝试：根据抽象条件筛选

• （1）传递代码/行为
• （2）多种行为，一个参数

• 三、简化代码

• 1. 第五次尝试：使用匿名类
• 2. 第六次尝试：使用Lambda 表达式
• 3. 第七次尝试：将List 类型抽象化

• 四、真实的例子

• 1. 用Comparator 来排序
• 2. 用Runnable 执行代码块
• 3. GUI 事件处理

一、应对不断变化的需求

在软件工程中，一个众所周知的问题就是，不管你做什么，用户的需求肯定会变。比方说，有个应用程序是帮助农民了解自己的库存。这位农民可能想有一个查找库存中所有绿色苹果的功能。但到了第二天，他可能会告诉你：“其实我还想找出所有重量超过150克的苹果。”又过了两天，农民又跑回来补充道：“要是我可以找出所有既是绿色，重量也超过150克的苹果，那就太棒了。”你要如何应对这样不断变化的需求？理想的状态下，应该把你的工作量降到最少。此外，类似的新功能实现起来还应该很简单，而且易于长期维护。

行为参数化就是可以帮助你处理频繁变更的需求的一种软件开发模式。一言以蔽之，它意味着拿出一个代码块，把它准备好却不去执行它。这个代码块以后可以被你程序的其他部分调用，这意味着你可以推迟这块代码的执行。例如，你可以将代码块作为参数传递给另一个方法，稍后再去执行它。这样，这个方法的行为就基于那块代码被参数化了。例如，如果你要处理一个集合，可能会写一个方法：
 可以对列表中的每个元素做“某件事”
 可以在列表处理完后做“另一件事”
 遇到错误时可以做“另外一件事”

1. 初试牛刀：筛选绿苹果

第一个解决方案可能是下面这样的：

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

2. 再展身手：把颜色作为参数

一种做法是给方法加一个参数，把颜色变成参数，这样就能灵活地适应变化了：

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

现在，只要像下面这样调用方法，农民朋友就会满意了：

List<Apple> greenApples = filterApplesByColor(inventory, "green");
List<Apple> redApples = filterApplesByColor(inventory, "red");
…

这位农民又跑回来和你说：“要是能区分轻的苹果和重的苹果就太好了。重的苹果一般是重量大于150克。”于是你写了下面的方法，用另一个参数来应对不同的重量：

public static List<Apple> filterApplesByWeight(List<Apple> inventory, int weight) {
	List<Apple> result = new ArrayList<Apple>();
	For (Apple apple: inventory){
		if ( apple.getWeight() > weight ){
			result.add(apple);
		}
	}
	return result;
}

解决方案不错，但是请注意，你复制了大部分的代码来实现遍历库存，并对每个苹果应用筛选条件。这有点儿令人失望，因为它打破了DRY（Don’t Repeat Yourself，不要重复自己）的软件工程原则。如果你想要改变筛选遍历方式来提升性能呢？那就得修改所有方法的实现，而不是只改一个。从工程工作量的角度来看，这代价太大了。

你可以将颜色和重量结合为一个方法，称为filter。不过就算这样，你还是需要一种方式来区分想要筛选哪个属性。你可以加上一个标志来区分对颜色和重量的查询（但绝不要这样做！我们很快会解释为什么）。

3. 第三次尝试：对你能想到的每个属性做筛选

一种把所有属性结合起来的笨拙尝试如下所示：

public static List<Apple> filterApples(List<Apple> inventory, String color, int weight, boolean flag) {
	List<Apple> result = new ArrayList<Apple>();
	for (Apple apple: inventory){
		if ( (flag && apple.getColor().equals(color)) || (!flag && apple.getWeight() > weight) ){
			result.add(apple);
		}
	}
	return result;
}

你可以这么用（但真的很笨拙）：

List<Apple> greenApples = filterApples(inventory, "green", 0, true);
List<Apple> heavyApples = filterApples(inventory, "", 150, false);

这个解决方案再差不过了。首先，客户端代码看上去糟透了。true和false是什么意思？此外，这个解决方案还是不能很好地应对变化的需求。如果这位农民要求你对苹果的不同属性做筛选，比如大小、形状、产地等，又怎么办？而且，如果农民要求你组合属性，做更复杂的查询，比如绿色的重苹果，又该怎么办？你会有好多个重复的filter方法，或一个巨大的非常复杂的方法。到目前为止，你已经给filterApples方法加上了值（比如String、Integer或boolean）的参数。这对于某些确定性问题可能还不错。但如今这种情况下，你需要一种更好的方式，来把苹果的选择标准告诉你的filterApples方法。在下一节中，我们会介绍了如何利用行为参数化实现这种灵活性。

二、行为参数化

你在上一节中已经看到了，你需要一种比添加很多参数更好的方法来应对变化的需求。让我们后退一步来看看更高层次的抽象。一种可能的解决方案是对你的选择标准建模：你考虑的是苹果，需要根据Apple的某些属性（比如它是绿色的吗？重量超过150克吗？）来返回一个boolean值。我们把它称为谓词（即一个返回boolean值的函数）。让我们定义一个接口来对选择标准建模：

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

现在你就可以用ApplePredicate的多个实现代表不同的选择标准了，比如（如图2-1所示）：

public class AppleHeavyWeightPredicate implements ApplePredicate{
	public boolean test(Apple apple){
		return apple.getWeight() > 150;
	}
}
public class AppleGreenColorPredicate implements ApplePredicate{
	public boolean test(Apple apple){
		return "green".equals(apple.getColor());
	}
}

你可以把这些标准看作filter方法的不同行为。你刚做的这些和“策略设计模式”相关，它让你定义一族算法，把它们封装起来（称为“策略”），然后在运行时选择一个算法。在这里，算法族就是ApplePredicate，不同的策略就是AppleHeavyWeightPredicate和AppleGreen-ColorPredicate。

但是，该怎么利用ApplePredicate的不同实现呢？你需要filterApples方法接受ApplePredicate对象，对Apple做条件测试。这就是行为参数化：让方法接受多种行为（或策略）作为参数，并在内部使用，来完成不同的行为。

要在我们的例子中实现这一点，你要给filterApples方法添加一个参数，让它接受ApplePredicate对象。这在软件工程上有很大好处：现在你把filterApples方法迭代集合的逻辑与你要应用到集合中每个元素的行为（这里是一个谓词）区分开了。

1. 第四次尝试：根据抽象条件筛选

利用ApplePredicate改过之后，filter方法看起来是这样的：

public static List<Apple> filterApples(List<Apple> inventory, ApplePredicate p){
	List<Apple> result = new ArrayList<>();
	for(Apple apple: inventory){
		// 谓词对象封装了测试苹果的条件
		if(p.test(apple)){
			result.add(apple);
		}
	}
	return result;
}

（1）传递代码/行为

现在你可以创建不同的ApplePredicate对象，并将它们传递给filterApples方法。免费的灵活性！比如，如果农民让你找出所有重量超过150克的红苹果，你只需要创建一个类来实现ApplePredicate就行了。你的代码现在足够灵活，可以应对任何涉及苹果属性的需求变更了：

public class AppleRedAndHeavyPredicate implements ApplePredicate{
	public boolean test(Apple apple){
		return "red".equals(apple.getColor()) && apple.getWeight() > 150;
	}
}

List<Apple> redAndHeavyApples = filterApples(inventory, new AppleRedAndHeavyPredicate());

你已经做成了一件很酷的事：filterApples方法的行为取决于你通过ApplePredicate对象传递的代码。换句话说，你把filterApples方法的行为参数化了！

请注意，在上一个例子中，唯一重要的代码是test方法的实现，如图2-2所示；正是它定义了filterApples方法的新行为。但令人遗憾的是，由于该filterApples方法只能接受对象，所以你必须把代码包裹在ApplePredicate对象里。你的做法就类似于在内联“传递代码”，因为你是通过一个实现了test方法的对象来传递布尔表达式的。你将在后面看到，通过使用Lambda，你可以直接把表达式"red".equals(apple.getColor()) &&apple.getWeight() > 150传递给filterApples方法，而无需定义多个ApplePredicate类，从而去掉不必要的代码。

（2）多种行为，一个参数

正如我们先前解释的那样，行为参数化的好处在于你可以把迭代要筛选的集合的逻辑与对集合中每个元素应用的行为区分开来。这样你可以重复使用同一个方法，给它不同的行为来达到不同的目的，如图2-3所示。

为了保证你对行为参数化运用自如，看看测验2.1吧！

测验2.1：编写灵活的prettyPrintApple方法
编写一个prettyPrintApple方法，它接受一个Apple的List，并可以对它参数化，以多种方式根据苹果生成一个String输出（有点儿像多个可定制的toString方法）。例如，你可以告诉prettyPrintApple 方法， 只打印每个苹果的重量。此外， 你可以让prettyPrintApple方法分别打印每个苹果，然后说明它是重的还是轻的。解决方案和我们前面讨论的筛选的例子类似。为了帮你上手，我们提供了prettyPrintApple方法的一个粗略的框架：

public static void prettyPrintApple(List<Apple> inventory, ???){
	for(Apple apple: inventory) {
		String output = ???.???(apple);
		System.out.println(output);
	}
}

答案如下。
首先，你需要一种表示接受Apple并返回一个格式String值的方法。前面我们在编写ApplePredicate接口的时候，写过类似的东西：
public interface AppleFormatter{
String accept(Apple a);
}
现在你就可以通过实现AppleFormatter方法，来表示多种格式行为了：

public class AppleFancyFormatter implements AppleFormatter{
	public String accept(Apple apple){
		String characteristic = apple.getWeight() > 150 ? "heavy" : "light";
		return "A " + characteristic + " " + apple.getColor() +" apple";
	}
}

public class AppleSimpleFormatter implements AppleFormatter{
	public String accept(Apple apple){
		return "An apple of " + apple.getWeight() + "g";
	}
}

最后，你需要告诉prettyPrintApple方法接受AppleFormatter对象，并在内部使用它们。你可以给prettyPrintApple加上一个参数：

public static void prettyPrintApple(List<Apple> inventory, AppleFormatter formatter){
	for(Apple apple: inventory){
		String output = formatter.accept(apple);
		System.out.println(output);
	}
}

搞定啦！现在你就可以给prettyPrintApple方法传递多种行为了。为此，你首先要实例化AppleFormatter的实现，然后把它们作为参数传给prettyPrintApple：

prettyPrintApple(inventory, new AppleFancyFormatter());
这将产生一个类似于下面的输出：
A light green apple
A heavy red apple
…
或者试试这个：
prettyPrintApple(inventory, new AppleSimpleFormatter());
这将产生一个类似于下面的输出：
An apple of 80g
An apple of 155g
…

你已经看到，可以把行为抽象出来，让你的代码适应需求的变化，但这个过程很啰嗦，因为你需要声明很多只要实例化一次的类。让我们来看看可以怎样改进。

三、简化代码

目前，当要把新的行为传递给filterApples方法的时候，你不得不声明好几个实现ApplePredicate接口的类，然后实例化好几个只会提到一次的ApplePredicate对象。下面的程序总结了你目前看到的一切。这真是很啰嗦，很费时间！

行为参数化：用谓词筛选苹果

// 选择较重苹果的谓词
public class AppleHeavyWeightPredicate implements ApplePredicate{
	public boolean test(Apple apple){
		return apple.getWeight() > 150;
	}
}

// 选择绿苹果的谓词
public class AppleGreenColorPredicate implements ApplePredicate{
	public boolean test(Apple apple){
		return "green".equals(apple.getColor());
	}
}

public class FilteringApples{
	public static void main(String...args){
		List<Apple> inventory = Arrays.asList(new Apple(80,"green"), new Apple(155, "green"), new Apple(120, "red"));
		// 结果是一个包含一个155克Apple的List
		List<Apple> heavyApples = filterApples(inventory, new AppleHeavyWeightPredicate());
		// 结果是一个包含两个绿Apple的List
		List<Apple> greenApples = filterApples(inventory, new AppleGreenColorPredicate());
	}
	
	public static List<Apple> filterApples(List<Apple> inventory, ApplePredicate p) {
		List<Apple> result = new ArrayList<>();
		for (Apple apple : inventory){
		if (p.test(apple)){
			result.add(apple);
		}
	}
	
	return result;
	
	}
}

Java有一个机制称为匿名类，它可以让你同时声明和实例化一个类。它可以帮助你进一步改善代码，让它变得更简洁。但这也不完全令人满意。后面介绍了Lambda表达式如何让你的代码更易读。
匿名类和你熟悉的Java局部类（块中定义的类）差不多，但匿名类没有名字。它允许你同时声明并实例化一个类。换句话说，它允许你随用随建。

1. 第五次尝试：使用匿名类

下面的代码展示了如何通过创建一个用匿名类实现ApplePredicate的对象，重写筛选的例子：

List<Apple> redApples = filterApples(inventory, new ApplePredicate() {
	// 直接内联参数化filterapples方法的行为
	public boolean test(Apple apple){
		return "red".equals(apple.getColor());
	}
});

但匿名类还是不够好。它往往很笨重，因为它占用了很多空间。

2. 第六次尝试：使用Lambda 表达式

上面的代码在Java 8里可以用Lambda表达式重写为下面的样子：

List<Apple> result = filterApples(inventory, (Apple apple) -> "red".equals(apple.getColor()));

图2-4对我们到目前为止的工作做了一个小结。

3. 第七次尝试：将List 类型抽象化

在通往抽象的路上，我们还可以更进一步。目前，filterApples方法还只适用于Apple。你还可以将List类型抽象化，从而超越你眼前要处理的问题：

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

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

现在你可以把filter方法用在香蕉、桔子、Integer或是String的列表上了。这里有一个使用Lambda表达式的例子：

List<Apple> redApples = filter(inventory, (Apple apple) -> "red".equals(apple.getColor()));
List<Integer> evenNumbers = filter(numbers, (Integer i) -> i % 2 == 0);

四、真实的例子

你现在已经看到，行为参数化是一个很有用的模式，它能够轻松地适应不断变化的需求。这种模式可以把一个行为（一段代码）封装起来，并通过传递和使用创建的行为（例如对Apple的不同谓词）将方法的行为参数化。前面提到过，这种做法类似于策略设计模式。Java API中的很多方法都可以用不同的行为来参数化。这些方法往往与匿名类一起使用。我们会展示三个例子，这应该能帮助你巩固传递代码的思想了：用一个Comparator排序，用Runnable执行一个代码块，以及GUI事件处理。

1. 用Comparator 来排序

在Java 8中，List自带了一个sort方法（你也可以使用Collections.sort）。sort的行为可以用java.util.Comparator对象来参数化，它的接口如下：

// java.util.Comparator
public interface Comparator<T> {
	public int compare(T o1, T o2);
}

因此，你可以随时创建Comparator的实现，用sort方法表现出不同的行为。比如，你可以使用匿名类，按照重量升序对库存排序：

inventory.sort(new Comparator<Apple>() {
	public int compare(Apple a1, Apple a2){
		return a1.getWeight().compareTo(a2.getWeight());
	}
});

用Lambda表达式的话，看起来就是这样：

inventory.sort((Apple a1, Apple a2) -> a1.getWeight().compareTo(a2.getWeight()));

2. 用Runnable 执行代码块

线程就像是轻量级的进程：它们自己执行一个代码块。但是，怎么才能告诉线程要执行哪块代码呢？多个线程可能会运行不同的代码。我们需要一种方式来代表稍候执行的一段代码。在Java里，你可以使用Runnable接口表示一个要执行的代码块。请注意，代码不会返回任何结果（即void）：

// java.lang.Runnable
public interface Runnable{
	public void run();
}

你可以像下面这样，使用这个接口创建执行不同行为的线程：

Thread t = new Thread(new Runnable() {
	public void run(){
		System.out.println("Hello world");
	}
});

用Lambda表达式的话，看起来是这样：

Thread t = new Thread(() -> System.out.println("Hello world"));

3. GUI 事件处理

GUI编程的一个典型模式就是执行一个操作来响应特定事件，如鼠标单击或在文字上悬停。
例如，如果用户单击“发送”按钮，你可能想显示一个弹出式窗口，或把行为记录在一个文件中。你还是需要一种方法来应对变化；你应该能够作出任意形式的响应。在JavaFX中，你可以使用EventHandler，把它传给setOnAction来表示对事件的响应：

Button button = new Button("Send");
button.setOnAction(new EventHandler<ActionEvent>() {
	public void handle(ActionEvent event) {
		label.setText("Sent!!");
	}
});

这里，setOnAction方法的行为就用EventHandler参数化了。用Lambda表达式的话，看起来就是这样：

button.setOnAction((ActionEvent event) -> label.setText("Sent!!"));