范型编程（一）

初次学习，概念比较多，整理一下：

1 通配符类型 wildcard tyoe：

2 范型类 generic class：具有一个或多个类型变量的类。

3 范型方法：  <T> 叫做类型变量，放在修饰符的后面，返回类型的前面。

pubic static <T> T getMiddle(T[] a) {
       //...
}

 4 类型变量的限定。 T叫做类型参数，Comparable叫做限定类型。

class ArrayAlg {

	public static <T extends Comparable> Pair<T> minmax(T[] a) {
		if (a == null || a.length == 0)
			return null;
		T min = a[0];
		T max = a[0];
		for (int i = 1; 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<T>(min, max);
	}
}

 

5 原始类型：只要定义了范型类型，相应的原始类型都被自动地提供。原始类型的名字就是删除了类型参数的范型类型的名字；类型变量被擦除，并用其限定类型（没有限定的变量用Object）替换。原始类型用类型变量的第一个限定来替换。

 

public class Interval<T extends Comparable & Serializable> implements
		Serializable {
	public Interval(T first, T second) {
		if (first.compareTo(second) <= 0) {
			lower = first;
			upper = second;
		} else {
			lower = second;
			upper = first;
		}
	}

	private T lower;
	private T upper;
}

 Interval<T extends Comparable & Serializable> 的原始类型是

public class Interval implements Serializable {
	public Interval(Comparable first, Comparable second) {
		if (first.compareTo(second) <= 0) {
			lower = first;
			upper = second;
		} else {
			lower = second;
			upper = first;
		}
	}

	private Comparable lower;
	private Comparable upper;
}

 6 异常：

不能抛出 不能捕获 范型类的对象。范型类扩展Throwable不合法。

 

7 数组

不能声明参数化类型的数组

Pair<String>[] table = new Pair<String>[10]; // Error

 

		Pair<String>[] table = new Pair[10];
		Object[] objTable = table;
		objTable[0] = "hello"; //抛出异常，运行时
		System.out.println(table[0]);

 

Exception in thread "main" java.lang.ArrayStoreException: java.lang.String

 

8 实例化

不能实例化范型类型

public Pair() {
           first = new T();   //ERROR
           second = new T();  //ERROR
}

 

9 不能建立一个范型数组：

public <T> T[] minMax(T[] a) { T[] mm = new T[2];} //ERROR

 

10 静态上下文

不能在静态域或方法中引用类型变量

public class singleton {
                public static T getSingleton() {
                           if (singleInstance == null) {...}
                          return singleInstance;
                }
                 private static T singleInstance;
}

 11 要支持擦除的转换，需要起那个姓限制一个类或者类型变量不能同时成为两个接口的子类，而这两个接口是同一接口的不同参数化。

class Calendar implements Comparable<Calendar>{}
class GregorianCalendar extends Calendar implements Comparable<GregorianCalendar> {...} //ERROR

 GregorianCalendar  会实现统一接口Comparable的不同参数化。

 

12 通配符类型

Pair<? extends Employee>

  表示任何范型Pair类型，他的类型参数是Employee的子类。