JAVA 泛型接口和泛型方法

泛型接口

泛型也可以应用于接口，例如生成器，一种专门负责创建对象的类。这其实是工厂方法设计模式的一种应用。不过使用生成器创建对象时，不需要参数。而工厂方法一般是需要参数的。

package tik4.generic;

public interface Generator<T> {
	T next();
}

 一个Fibonacci数列实现

package tik4.generic;

public class Fibonacci implements Generator<Integer> {
	private int count;

	// 参数类型用Integer，使用int将不能编译
	// public int next() {
	// return 0;
	// }
	public Integer next() {
		return fib(count++);
	}

	private int fib(int n) {
		if (n < 2) return 1;
		return fib(n - 2) + fib(n - 1);
	}

	public static void main(String[] args) {
		Fibonacci gen = new Fibonacci();
		for (int i = 0; i <= 17; i++)
			System.out.print(gen.next() + " ");
	}
	/*
	 * Output: 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597 2584
	 */
}

 

泛型方法

可以在类中包含参数化方法，而这个方法所在的类可以是泛型类，也可以不是泛型类。是否拥有泛型方法，和所在的类是否泛型没有关系。泛型方法使得该方法能够独立于类而产生变化。以下是一个基本原则：如果泛型方法可以取代整个类的泛型化，就应该只使用泛型方法。另外，对于一个static方法而言，无法访问泛型

类的参数类型，所以static方法需要使用泛型能力，就必须成为泛型方法

package tik4.generic;

public class GenericMothod {
	public <T,M,N> void getTType(T t,M m,N n){
		/*
		 * 传入int,long ,double等基本类型时，自动打包机制
		 * 会将基本类型包装成相应的对象
		 */
		System.out.println(t.getClass().getName());
		System.out.println(m.getClass().getName());
		System.out.println(n.getClass().getName());
	}
	public static void main(String[] args) {
		//泛型类在创建对象时必须指定参数类型，而泛型方法则不需要在创建对象时指定参数类型T
		GenericMothod gm = new GenericMothod();
		gm.getTType("", 1, 1.0);
		gm.getTType(1.0F, 'c', gm);
	}/*
	 *Output: 
	java.lang.String
	java.lang.Integer
	java.lang.Double
	java.lang.Float
	java.lang.Character
	tik4.generic.GenericMothod
	*/
}

 

利用参数类型推断

问题：很烦这种写法是不是，老子在声明变量的的时候已经指明了参数类型，为毛还要在初始化对象时再指定？

Map<Integer, List<? extends Set<String>>> map = 
    new HashMap<Integer, List<? extends Set<String>>>();

解决：搞一个工具类

package tik4.generic;

import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;

public class New {
	public static <K, V> Map<K, V> hashMap() {
		return new HashMap<K, V>();
	}

	public static void main(String[] args) {
		Map<Integer, List<? extends Set<String>>> map = New.hashMap();
	}
}

 注意：

类型推断只对赋值操作有效，其他时候不起作用。如果你使用泛型方法调用的结果(例如：New.hashMap())作为参数，传递给其他方法，此时编译器不会执行类型推断。编译器认为，调用泛型方法之后，其返回值被赋给一个Object类型的变量。上代码：

package tik4.generic;

import java.util.List;
import java.util.Map;
import java.util.Set;

public class LimitsOfInference {
	static void f(Map<Integer, List<? extends Set<String>>> map){};
	public static void main(String[] args) {
		/*
		 * the mothed f(Map<Integer, List<? extends Set<String>>>
		 * is not applicable for arguments (Map<Object,Object>)
		 * 不能编译
		 */
//		f(New.hashMap());
	}
}

 

显示类型说明?? think in java4中是这么写的，但是我的机器上不能编译，难道书上是在扯淡

 在泛型方法中，可以显示的指定参数类型。在 点操作符 和 方法名之间插入尖括号，然后将类型置于括号内。如果是在定义该方法的类的内部，则在点操作符之前使用this关键字如果使用static方法，必须在点操作符之前加上类名。这种语法，可以解决LimitsOfInference.java中的问题。

package tik4.generic;

import java.util.List;
import java.util.Map;
import java.util.Set;

public class ExplicitTypeSpecification {
	static void f(Map<Integer, String> map){};
	
	public static void main(String[] args) {
                //java 5和java6 中均不能编译。
		f(New.<Map<Integer, String>>hashMap()); 
	}
}

 

 泛型推导在java7中已经实现了。

      List<String> list = new ArrayList<>();

     因为编译器可以从前面(List)推断出推断出类型参数，所以后面的ArrayList之后可以不用写泛型参数了，只用一对空着的尖括号就行。当然，你必须带着”菱形”<>，否则会有警告的。 

     Java SE7 只支持有限的类型推断：只有构造器的参数化类型在上下文中被显著的声明了，你才可以使用类型推断，否则不行。 看代码：

     List<String> list = new ArrayList<>();
     list.add("A");

     //这个不行
     list.addAll(new ArrayList<>());

     // 这个可以
     List<? extends String> list2 = new ArrayList<>();
     list.addAll(list2);