Java泛型学习笔记

　　泛型是Java5引进的新特征，是类和接口的一种拓展机制，主要实现参数化类型机制。Java的泛型，跟C++的类模板有很多相似的地方，或者说，就是C++类模板的升级版。

泛型类

　　在开发过程中，我们或许要设计一个“节点”类，在过去，我们需要为int型数据定义一个类，然后再为double类型数据定义一个点类，还需要为String类设计一个类，这样，我们就需要定义好多的类，但其实，这些类有很多相同的地方，他们只是数据的类型不同而已。有了泛型类之后，我们就不需要设计那么多的类了，只需要设计一个类，然后再根据存入的数据的类型决定创建什么类型的对象。比如，例1-1

class Node<T>{
	private T value;
	public Node() {}
	public Node(T value) {
		this.value = value;
	}
	public T getNode() {
		return value;
	}
	public void setNode(T value) {
		this.value = value;
	}
}

　　

　　通过泛型类，我们可以通过一行简单的代码就可以创建各种不同类型的对象。

Node<Integer> intNode = new Node<Integer>();//创建整型节点
Node<Double> douNode = new Node<Double>();//double节点
Node<String> strNode = new Node<String>();//字符串节点

　　怎么样，是不是很方便了？其实不仅仅方便，还比较安全，怎么个安全法呢？

　　在上面的代码中，我们创建了intNode对象，它是int类型的，如果我们要调用它的setNode（"test"），系统就会在编译的时候给我们报错。从而在编译阶段就保证了类型的安全。

　　由于编译器能够从上下文推断出泛型参数的类型，所以从Java se 7开始，在创建泛型类型时可以用菱形语法。上述创建语句可以写成

Node<Integer> intNode = new Node<>();
Node<Double> douNode = new Node<>();
Node<String> strNode = new Node<>();

　　按照约定，类型参数名要使用单个大写字母表示，常用的类型参数名有E（表示元素）、K（便是键）、T（表示类型）、N（表示数字）、V（表示值）等。泛型可能有多个类型参数，但是在类或者接口的声明中，每个参数名必须时唯一的。

　　好了，现在我们已经认识了泛型类。下面，让我们来看看泛型接口。

　　这是Entry接口

public interface Entry<K, V>{
	public K getKey();
	public V getValue();
}

　　

class Pair<K, V> implements Entry<K, V>{
	private K key;
	private V value;
	public Pair(K key, V value) {
		this.key = key;
		this.value = value;
	}
	public void setKey(K key) {
		this.key = key;
	}
	public void setValue(V value) {
		this.value = value;
	}
	public K getKey() {
		return key;
	}
	public V getValue() {
		return value;
	}
}

　　看到这，也就基本了解Java泛型类是什么了东西了。下面，我们来看看一个例子。

　　

class Point<T> {
	T x;
	T y;
	public Point() {}
	public Point(T x, T y) {
		this.x = x;
		this.y = y;
	}
	public T getX() {
		return x;
	}
	public T getY() {
		return y;
	}
	public void setX(T x) {
		this.x = x;
	}
	public void setY(T y) {
		this.y = y;
	}
	public void translate(T x, T y) {
		this.x = x;
		this.y = y;
	}
	@Override
	public String toString() {
		return "(" + x +", " + y + ")";
	}
}
public class test11_01 {
	public static void main(String[] args) {
		Point<Integer> intPoint = new Point<Integer>(3, 5);
		System.out.println(intPoint);

		Point<Double> doublePoint = new Point<Double>(3.2, 5.5);
		System.out.println(doublePoint);

		Point<String> strPoint = new Point(3.2, 5.5);//这里用String作为类型来创建了一个泛型类对象，但实际上我们日常使用中的并不怎么使用非数字的坐标
		System.out.println(strPoint);
	}
}

　　这个程序没有报错，相反，还可以运行。运行结果如下：

(3, 5)
(3.2, 5.5)
(3.2, 5.5)　　

　　但是，如果我们在最后加上那么一句的话

System.out.println(strPoint.getX());

　　结果就是下面这个样子

(3, 5)
(3.2, 5.5)
(3.2, 5.5)
Exception in thread "main" java.lang.ClassCastException: java.lang.Double cannot be cast to java.lang.String
	at demo.test11_01.main(test11_01.java:79)

　　也就是说，在编译的时候，没有报错，但是在运行的时候发生了错误，这就存在了安全隐患。那要怎样才能解决呢？

　　如果我们可以规定，类型参数只能数Number类型，那么在创建泛型类的时候传入的是String类型的时候，就会报错吧。那么，我们要怎么样规定泛型类参数呢？这就要介绍到Java中的有界类型参数了。有界类型参数分为上界，和下界。上界用extends来指定，下界用super来指定。比如上述的二维坐标类

将

class Point<T>  
/*改成*/ 
class Point<T extends Number>

就可以在编译的时候就阻止了String类型作为参数来创建对象。

　　我们再来看一个例子。假如有以下代码：

List<Object> list1 = new ArrayList<Object>();
List<String> list2 = new ArrayList<String>();

　　在这个例子中，尽管String类是Object的一个字类，但是，List<Object> 和List<Object>却没有一点关系，如果调用下面的方法的话，会发生编译错误

public static void printList(List<Object> list) {
　　for(Object element : list)
　　　　System.out.println(element);
}

　　这时候，我们就需要用到通配符（？）将上诉代码改写成

public static void printList(List<?> list) {
　　for(Object element : list)
　　　　System.out.println(element);
}

　再调用这个静态方法的时候，就不会报错了。使用通配符，表示该方法可以接受的元素是任何类型的List对象。

一般来说，类和方法总是关系紧密的，既然类有泛型类，那么泛型方法，也是存在的。

泛型方法

泛型方法，就是带有类型参数的方法，类的成员和构造方法都可以定义为泛型方法。泛型方法的定义可以是静态的，也可以是非静态的。

比如：

public static <T> void swap(T[] arrary, int i, int j) {
	T temp = arrary[i];
	arrary[i] = arrary[j];
	arrary[j] = temp;
}