effective java（21） 之用函数对象表示策略

effective java 之用函数对象表示策略

1、有些语言支持函数指针（function pointer）、代理（delegate）、lambda表达式（lambda expression），或者支持类似的机制，允许程序把“调用特殊函数的能力”存储起来并传递这种能力。这种机制通常用于允许函数的调用者通过传入第二个函数，来指定自己的行为。
函数对象：调用操作符的类，其对象常称为函数对象（function object），即它们是行为类似函数的对象。


2、Java没有提供函数指针，但是可以通过对象引用实现同样的功能。调用对象上的方法通常是执行该对象（the object）上的某项操作。然而，我们也可能定义这样的一种对象，它的方法执行其他对象（other objects）（这些对象被显式传递给这些方法）上的操作。如果一个类仅仅导出这样的一个方法，它的实例实际上就等同于一个指向该方法的指针。这样的实例被成为函数对象（function object）
例如，考虑下面的类：


public class StringLengthComparator  
{  
public int compare(String s1, String s2)  
{  
return s1.length() - s2.length();  
}  
}  


指向StringLengthComparator对象的引用可以被当作一个指向该比较器的“函数指针（function pointer）”，可以在任意一对字符串上被调用。换句话说。StringLengthComparator实例适用于字符串比较操作的具体策略（concrete strategy）。


作为典型的具体策略类，StringLengthComparator类是无状态的（staeless）：它没有域，所以，这个类的所有实例在功能上都是相互等价的。因此，它作为一个Singleton是非常合适的，可以节省不必要的对象创建开销：


public class StringLengthComparator  
{  
private static final StringLengthComparator INSTANCE = new StringLengthComparator();  
 
public int compare(String s1, String s2)  
{  
return s1.length() - s2.length();  
}  
} 


为了把StringLengthComparator实例传递给方法，需要适当的参数类型。使用StringLengthComparator并不好，因为客户端将无法传递任何其他的策略。相反，我们需要定义一个Comparator接，并修改StringLengthComparator来实现这个接口。换句话说，我们在设计具体策略类时，还需要一个策略接口（strangey interface），如下所示


public interface Comparator<T>  
{  
public int compare(T t1, T t2);  
}  


它的compare方法的两个类型参数为T（它正常的类型参数），而不是String。只要声明前面所示的StringLengthComparator类要这么做，就可以实现Comparator<String>接口：


public class StringLengthComparator implements Comparator<String>  
{  
          
    public int compare(String s1, String s2)  
    {  
        return s1.length() - s2.length();  
    }  
} 


具体的策略类往往会使用匿名类声明。下面的语句根据长度对一个字符串数组进行排序：


Arrays.sort(stringArray, new Comparator<String>()  
{  
<span style="white-space:pre">  </span>@Override  
    public int compare(String s1, String s2)  
    {  
    <span style="white-space:pre">  </span>return s1.length() - s2.length();;  
    }  
              
});  


但是注意，以这种方式使用的匿名类时，将会在每次执行调用的时候都会创建一个新的实例。如果它被重复执行，考虑将函数对象存储到一个私有的静态final域里，并重用它。这样做的另一种好处是，可以为这个函数对象取一个有意义的域名称。
因为策略接口被用做所有具体策略实例的类型，所以我怕们并不需要为了导出具体策略，而把具体策略类做成共有的。相反，“宿主类（host class）”还可以导出共有的静态域（或者静态工厂方法），其类型为策略接口，具体的策略类可以是宿主类的私有嵌套类。线面的例子使用静态成员类，而不是匿名类，以便允许具体的策略类实现第二个几口Serializable：

	public class Host {
		private static class StrLenCmp implements Comparator<String>, Serializable {


			@Override
			public int compare(String s1, String s2) {
				return s1.length() - s2.length();
			}
		}


		public static final Comparator<String> STRING_LENGTH_COMPARATOR = new StrLenCmp();


		public static void main(String[] args) {
			String s1 = "";
			String s2 = "";
			int result = Host.STRING_LENGTH_COMPARATOR.compare(s1, s2);
			System.out.println(result);
		}
	} 

String类利用这种模式，通过它的CASE_INSENSITIVE_ORDER域，导出一个不区分大小写的字符串比较器。

简而言之，函数指针的主要用途就是实现策略（Strategy）模式。为了在Java中实现这种模式，要声明一个接口来表示该策略，并且为每个具体策略生命一个实现了该接口的类。当一个具体策略被使用一次时。通常使用匿名类来声明和实例化这个具体策略类。当一个具体策略是设计用来重复使用的时候，它的类通常就要被实现为私有的静态成员类，并通过公有的静态final域导出，其类型为该策略接口。

每天努力一点，每天都在进步。