泛型（3）：泛型方法

傷城~ 2023-07-15 02:51 1阅读 0赞

到目前为止，我们看到的泛型，都是应用于整个类上。但同样可以在类中包含参数化方法，而这个方法所在的类可以是泛型类，也可以不是泛型类。也就是说，是否拥有泛型方法，与其所在的类是否是泛型没有关系。

泛型方法使得该方法能够独立于类而产生变化。以下是一个基本的指导原则：无论何时，只要你能够做到，你就应该尽量使用泛型方法。也就是说，如果使用泛型方法可以取代整个类泛型化，那么就应该只使用泛型方法，因为它可以使事情更清楚明白。另外，对于一个static的方法而言，无法访问泛型类的类型参数，所以，如果static方法需要使用泛型能力，就必须使其成为泛型方法。

要定义泛型方法，只需将泛型参数列表置于返回值之前，就像下面这样：

public class GenericMethods {
    	public <T> void f(T x) {
    		System.out.println(x.getClass().getName());
    	}
    
    	public static void main(String[] args) {
    		GenericMethods gm = new GenericMethods();
    		gm.f("");
    		gm.f(1);
    		gm.f(1.0);
    		gm.f(1.0F);
    		gm.f('c');
    		gm.f(gm);
    	}
    }

GenericMethods并不是参数化的，尽管这个类和其内部类的方法可以被同时参数化，但是在这个例子中，只有方法f()拥有类型参数。这是由该方法的返回类型前面的类型参数列表指明的。

注意，当使用泛型类时，必须在创建对象的时候指定类型参数的值，而使用泛型方法的时候，通常不必指明参数类型，因为编译器会为我们找出具体的类型。这称为类型参数推断（type argument inference）。因此，我们可以像调用普通方法一样调用f()，而且就好像是f()被无限次地重载过。它甚至可以接受GenericMethods作为其类型参数。

如果调用f()时传入基本类型，自动打包机制就会介入其中，将基本类型的值包装为对应的对象。事实上，泛型方法与自动打包避免了许多以前我们不得不自己编写出来的代码。

### 一、可变参数与泛型方法 ###

泛型方法与可变参数列表能够很好地共存：

import java.util.ArrayList;
    import java.util.List;
    
    public class GenericVarargs {
    	public static <T> List<T> makeList(T... args) {
    		List<T> result = new ArrayList<>();
    		for (T t : args)
    			result.add(t);
    		return result;
    	}
    
    	public static void main(String[] args) {
    		List<String> ls = makeList("A");
    		System.out.println(ls);
    		ls = makeList("A", "B", "C");
    		System.out.println(ls);
    		ls = makeList("ABCDEFGHIJKLMNOPQRSTUVWXYZ".split(""));
    		System.out.println(ls);
    	}
    }

makeList()方法展示了与标准库中java.util.Arrays.asList()方法相同的功能。

### 二、用于Generator的泛型方法 ###

利用生成器，我们可以很方便地填充一个Collection，而泛型化这种操作是具有实际意义的：

import java.util.ArrayList;
    import java.util.Collection;
    
    import com.buba.util.Generator;
    
    import generics.coffee.Coffee;
    import generics.coffee.CoffeeGenerator;
    
    public class Generators {
    	public static <T> Collection<T> fill(Collection<T> coll, Generator<T> gen, int n) {
    		for (int i = 0; i < n; i++)
    			coll.add(gen.next());
    		return coll;
    	}
    
    	public static void main(String[] args) {
    		Collection<Coffee> coffee = fill(new ArrayList<Coffee>(), new CoffeeGenerator(), 4);
    		for (Coffee c : coffee)
    			System.out.println(c);
    		Collection<Integer> fnumbers = fill(new ArrayList<Integer>(), new Fibonacci(), 12);
    		for (Integer i : fnumbers)
    			System.out.print(i + ", ");
    	}
    }

请注意，fill()方法是如何透明地应用于Coffee和Integer的容器和生成器。

### 三、一个通用的Generator ###

下面的程序可以为任何类构造一个Generator，只要该类具有默认的构造器。为了减少类型声明，它提供了一个泛型方法，用以生成BasicGenerator：

public class BasicGenerator<T> implements Generator<T> {
    
    	private Class<T> type;
    
    	public BasicGenerator(Class<T> type) {
    		this.type = type;
    	}
    
    	@Override
    	public T next() {
    		try {
    			return type.newInstance();
    		} catch (InstantiationException e) {
    			throw new RuntimeException(e);
    		} catch (IllegalAccessException e) {
    			throw new RuntimeException(e);
    		}
    	}
    
    	public static <T> Generator<T> create(Class<T> type) {
    		return new BasicGenerator<T>(type);
    	}
    }

这个类提供了一个基本实现，用以生成某个类的对象。这个类必需具备两个特点：

1.  它必须声明为public。（因为BasicGenerator与要处理的类在不同的包中，所以该类必须声明为public，并且不只具有包内访问权限。）
2.  它必须具备默认的构造器（无参数的构造器）。要创建这样的BasicGenerator对象，只需调用create()方法，并传入想要生成的类型。泛型化的create()方法允许执行BasicGenerator.create(MyType.class)，而不必执行麻烦的new BasicGenerator<MyType>(MyType.class)。

例如，下面是一个具有默认构造器的简单的类：

public class CountedObject {
    	private static long counter = 0;
    	private final long id = counter++;
    
    	public long id() {
    		return id;
    	}
    
    	public String toString() {
    		return "CountedObject " + id;
    	}
    }

CountedObject类能够记录下它创建了多少个CountedObject实例，并通过toString()方法告诉我们其编号。

使用BasicGenerator，你可以很容易地为CountedObject创建一个Generator：

import com.buba.util.BasicGenerator;
    import com.buba.util.Generator;
    
    public class BasicGeneratorDemo {
    	public static void main(String[] args) {
    		Generator<CountedObject> gen = BasicGenerator.create(CountedObject.class);
    		for (int i = 0; i < 5; i++) {
    			System.out.println(gen.next());
    		}
    	}
    }

可以看到，使用泛型方法创建Generator对象，大大减少了我们要编写的代码。java泛型要求传入Class对象，以便也可以在create()方法中用它进行类型推断。

### 四、简化元组的使用 ###

有了类型参数推断，再加上static方法，我们可以重新编写之前看到的元组工具，使其成为更通用的工具类库。在这个类中，我们通过重载static方法创建元组：

public class Tuple {
    	public static <A, B> TwoTuple<A, B> tuple(A a, B b) {
    		return new TwoTuple<A, B>(a, b);
    	}
    
    	public static <A, B, C> ThreeTuple<A, B, C> tuple(A a, B b, C c) {
    		return new ThreeTuple<A, B, C>(a, b, c);
    	}
    
    	public static <A, B, C, D> FourTuple<A, B, C, D> tuple(A a, B b, C c, D d) {
    		return new FourTuple<A, B, C, D>(a, b, c, d);
    	}
    
    	public static <A, B, C, D, E> FiveTuple<A, B, C, D, E> tuple(A a, B b, C c, D d, E e) {
    		return new FiveTuple<A, B, C, D, E>(a, b, c, d, e);
    	}
    }

下面是修改后的TupleTest.java，用来测试Tuple.java：

import static com.buba.util.Tuple.tuple;
    
    import com.buba.util.FiveTuple;
    import com.buba.util.FourTuple;
    import com.buba.util.ThreeTuple;
    import com.buba.util.TwoTuple;
    
    public class TupleTest2 {
    	static TwoTuple<String, Integer> f() {
    		return tuple("hi", 14);
    	}
    
    	static TwoTuple f2() {
    		return tuple("hi", 14);
    	}
    
    	static ThreeTuple<Amphibian, String, Integer> g() {
    		return tuple(new Amphibian(), "hi", 14);
    	}
    
    	static FourTuple<Vehicle, Amphibian, String, Integer> h() {
    		return tuple(new Vehicle(), new Amphibian(), "hi", 14);
    	}
    
    	static FiveTuple<Vehicle, Amphibian, String, Integer, Double> k() {
    		return tuple(new Vehicle(), new Amphibian(), "hi", 14, 11.1);
    	}
    
    	public static void main(String[] args) {
    		TwoTuple<String, Integer> ttsi = f();
    		System.out.println(ttsi);
    		System.out.println(f2());
    		System.out.println(g());
    		System.out.println(h());
    		System.out.println(k());
    	}
    }

注意，方法f()返回一个参数化的TwoTuple对象，而f2()返回的是非参数化的TwoTuple对象。在这个例子中，编译器并没有关于f2()的警告信息，因为我们并没有将其返回值作为参数化对象使用。在某种意义上，它被“向上转型”为一个非参数化的TwoTuple。然而，如果试图将f2()的返回值转型为参数化的TwoTuple，编译器就会发出警告。

### 五、一个Set实用工具 ###

作为泛型方法的另一个示例，我们看看如何用Set来表达数学中的关系式。通过使用泛型方法，可以很方便地做到这一点，而且可以应用于多种类型：

import java.util.HashSet;
    import java.util.Set;
    
    public class Sets {
    
    	public static <T> Set<T> union(Set<T> a, Set<T> b) {
    		Set<T> result = new HashSet<T>(a);
    		result.addAll(b);
    		return result;
    	}
    
    	public static <T> Set<T> intersection(Set<T> a, Set<T> b) {
    		Set<T> result = new HashSet<T>(a);
    		result.retainAll(b);
    		return result;
    	}
    
    	public static <T> Set<T> difference(Set<T> superset, Set<T> subset) {
    		Set<T> result = new HashSet<T>(superset);
    		result.removeAll(subset);
    		return result;
    	}
    
    	public static <T> Set<T> complement(Set<T> a, Set<T> b) {
    		return difference(union(a, b), intersection(a, b));
    	}
    }

在前三个方法中，都将第一个参数Set复制一份，将Set中的所有引用都存入一个新的HashSet对象中，因此，我们并未直接修改参数中的Set。返回的值是一个全新的Set对象。

这四个方法表达了如下的数学集合操作：union()返回一个Set，它将两个参数合并在一起；intersection()返回的是Set只包含两个参数共有的部分；difference()方法从superset中移除subset包含的元素；complement()返回的Set包含除了交集之外的所有元素。下面提供了一个enum，它包含各种水彩画的颜色。我们将用它来演示以上这些方法的功能和效果。

public enum Watercolors {
    	ZINC, LEMON_YELLOW, MEDIUM_YELLOW, DEEP_YELLOW, ORANGE, BRILLIANT_RED, CRIMSON, MAGENTA, ROSE_MADDER, VIOLET,
    	CERULEAN_BLUE_HUE, PHTHALO_BLUE, ULTRAMARINE, COBALT_BLUE_HUE, PERMANENT_GREEN, VIRIDIAN_HUE, SAP_GREEN,
    	YELLOW_OCHRE, BURNT_SIENNA, RAW_UMBER, BURNT_UMBER, PAYNES_GRAY, IVORY_BLACK
    }

为了方便起见（可以直接使用enum中的元素名），下面的示例以static的方式引入Watercolors。这个示例使用了EnumSet，这是java SE5中的新工具，用来从enum直接创建Set。在这里，我们向static方法EnumSet.range()传入某个范围的第一个元素与最后一个元素，然后它将返回一个Set，其中包含该范围内的所有元素：

import java.util.EnumSet;
    
    import generics.watercolors.Watercolors;
    import static com.buba.util.Sets.*;
    import static generics.watercolors.Watercolors.*;
    
    public class WatercolorsSets {
    	public static void main(String[] args) {
    		EnumSet<Watercolors> set1 = EnumSet.range(BRILLIANT_RED, VIRIDIAN_HUE);
    		EnumSet<Watercolors> set2 = EnumSet.range(CERULEAN_BLUE_HUE, BURNT_UMBER);
    		System.out.println("set1: " + set1);
    		System.out.println("set2: " + set2);
    		System.out.println("union(set1, set2): " + union(set1, set2));
    		System.out.println("intersection(set1, set2): " + intersection(set1, set2));
    		System.out.println("difference(set1, set2): " + difference(set1, set2));
    		System.out.println("complement(set1, set2): " + complement(set1, set2));
    	}
    }

我们可以在输出中看到各种关系运算的结果。

下面的示例使用Sets.difference()打印出java.util包中各种Collection类与Map类之间方法的差异：

import java.lang.reflect.Method;
    import java.util.ArrayList;
    import java.util.Collection;
    import java.util.HashMap;
    import java.util.HashSet;
    import java.util.LinkedHashSet;
    import java.util.LinkedList;
    import java.util.List;
    import java.util.Map;
    import java.util.PriorityQueue;
    import java.util.Queue;
    import java.util.Set;
    import java.util.SortedMap;
    import java.util.TreeMap;
    import java.util.TreeSet;
    
    public class ContainerMethodDifferences {
    	static Set<String> methodSet(Class<?> type) {
    		Set<String> result = new TreeSet<>();
    		for (Method m : type.getMethods())
    			result.add(m.getName());
    		return result;
    	}
    
    	static void interfaces(Class<?> type) {
    		System.out.print("Interfaces in " + type.getSimpleName() + ": ");
    		List<String> result = new ArrayList<>();
    		for (Class<?> c : type.getInterfaces())
    			result.add(c.getSimpleName());
    		System.out.println(result);
    	}
    
    	static Set<String> object = methodSet(Object.class);
    	static {
    		object.add("clone");
    	}
    
    	static void difference(Class<?> superset, Class<?> subset) {
    		System.out.print(superset.getSimpleName() + " extends " + subset.getSimpleName() + ", adds: ");
    		Set<String> comp = Sets.difference(methodSet(superset), methodSet(subset));
    		comp.removeAll(object);
    		System.out.println(comp);
    		interfaces(superset);
    	}
    
    	public static void main(String[] args) {
    		System.out.println("Collection: " + methodSet(Collection.class));
    		interfaces(Collection.class);
    		difference(Set.class, Collection.class);
    		difference(HashSet.class, Set.class);
    		difference(LinkedHashSet.class, HashSet.class);
    		difference(TreeSet.class, Set.class);
    		difference(List.class, Collection.class);
    		difference(ArrayList.class, List.class);
    		difference(LinkedList.class, List.class);
    		difference(Queue.class, Collection.class);
    		difference(PriorityQueue.class, Queue.class);
    		System.out.println("Map: " + methodSet(Map.class));
    		difference(HashMap.class, Map.class);
    		difference(SortedMap.class, Map.class);
    		difference(TreeMap.class, Map.class);
    	}
    }

**如果本文对您有很大的帮助，还请点赞关注一下。**