java泛型基础－I

java泛型概念及作用

泛型是JDK 1.5的一项新特性，它的本质是参数化类型（Parameterized Type）的应用，那么参数化类型怎么理解呢？顾名思义，就是将类型由原来的具体的类型参数化，类似于方法中的变量参数，此时类型也定义成参数形式（可以称之为类型形参），然后在使用/调用时传入具体的类型（类型实参）。这种参数类型可以用在类、接口和方法的创建中，分别称为泛型类、泛型接口和泛型方法。java中的泛型基本上都是在编译器这个层次来实现的。在生成的Java字节码中是不包含泛型中的类型信息的。使用泛型的时候加上的类型参数，会在编译器在编译的时候去掉。这个过程就称为类型擦除。

泛型的作用：

1. 类型安全：通过泛型定义的变量类型限制，编译器可以在高程度上验证类型假设；
2. 消除强制类型转换：消除了编码过程中强制类型转换，大大减少了代码出错率；
3. 提高代码的重用率；

泛型的基本使用

1：泛型类定义和使用
泛型类就是一个具有一个或者多个类型变量的类。

public class Pair<T> {
	private T first;
	private T second;
	public T getFirst() {
		return first;
	}
	public Pair()
	{
		first=null;
		second=null;
	}
	public Pair(T first,T second)
	{
		this.first=first;
		this.second=second;
	}
	public void setFirst(T first) {
		this.first = first;
	}
	public T getSecond() {
		return second;
	}
	public void setSecond(T second) {
		this.second = second;
	}
}

public static Pair<String> minmax(String[] a)
	{
		if(a==null||a.length==0)
		{
			return null;
		}
		String min=a[0];
		String max=a[0];
		for(int i=0;i<a.length;i++)
		{
			if(min.compareTo(a[i])>0)
				min=a[i];
			if(max.compareTo(a[i])<0)
				max=a[i];
		}
		return new Pair<>(min,max);
	}

测试端

import java.util.Date;

public class PairTest1 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		String []a={"zhang","hao","zp","csu"};
		Pair<String> pair=ArrayUtil.minmax(a);
		System.out.println("min="+pair.getFirst());
		System.out.println("max="+pair.getSecond());
	}

}

运行结果：

min=csu
max=zp

2：泛型接口定义和使用

public interface Info <T,U>{
	public void show(T t,U u);
}

public class InfoImpl implements Info<String, Date> {

	@Override
	public void show(String t, Date u) {
		// TODO Auto-generated method stub
		System.out.println("信息内容："+t+"  "+"获取时间："+u);
	}
}

测试端：

public static void main(String[] args) {
		// TODO Auto-generated method stub
		InfoImpl infoImpl=new InfoImpl();
		infoImpl.show("下午打球", new Date());
	}

运行结果：

信息内容：下午打球  获取时间：Sat Apr 16 15:18:34 CST 2016

3：泛型方法

public static<T> T getMiddle(T...a)
	{
		return a[a.length/2];
	}

测试端1：

String middle=ArrayUtil.getMiddle("csu","fggt","private");
		System.out.println("middle="+middle);

运行结果：

middle=fggt

测试端2（注意这个不能编译通过）

double middle1=ArrayUtil.getMiddle(12.002,2,45);

运行结果：

Exception in thread "main" java.lang.Error: Unresolved compilation problem: 
	Type mismatch: cannot convert from Number&Comparable<?> to double at com.csu.fanxing.PairTest1.main(PairTest1.java:15)

结果分析：
主要是编译器将会自动打包参数为1个Double和两个Integer对象，然后寻找两个类的共同超类，Number&Comparable<?>。解决方案是将所有参数写为相同类型，例如double或int。
4：类型变量限定
有时候我们需要对类型变量加以约束，以确保类型变量满足某种需求，这个限定可以发生在类、接口、方法。
类型限定格式为<T extends 类名／接口名>
类型变量限定需要注意如下几点：

1. 不管是限定类名还是接口，均使用关键字extends；
2. 可以使用&符号给出多个限定；public static <T extends Comparable&Serializable> T get(T t1,T t2)
3. 限定既有接口也有类，那么类必须只有一个，并且放在首位置。public static <T extends Object&Comparable&Serializable> T get(T t1,T t2)

实例： 泛型方法中只有限定为Comparable接口实现的类才能使用compareTo

public static <T extends Comparable<T>>Pair<T> minmax2(T[] a)
	{
		if(a==null||a.length==0)
		{
			return null;
		}
		T min=a[0];
		T max=a[0];
		for(int i=0;i<a.length;i++)
		{
			if(min.compareTo(a[i])>0)
				min=a[i];
			if(max.compareTo(a[i])<0)
				max=a[i];
		}
		return new Pair<>(min,max);
	}

java泛型中转换总结：

• 虚拟机中没有泛型，只有普通的类和方法；
• 所有类型参数都用它们的限定类型替换；
• 桥方法被合成来保持多态；
• 为保持类型安全性，必要时插入强制类型转换；