（2）泛型的优点。
在jdk 1.5之前
package java，lang；
public interface Comparable{
public int compareTo(Object o);
}
在jdk1.5开始及其以后
package java.lang;
public interface Comparable<T>{
public int compareTo(T t);
}
1、泛型使得程序更加可靠。
Comparable c = new Date();
System.out.println(c.compareTo("red"));
Comparable<Date> c = new Date();
System.out.println(c.compareTo("red"));
62 中一个时间和一个String字符串去做比较，但是在编译期不会有任何问题。但是在运行时会报错。
65 中在编译的时候就会报错，因为Comparable中使用了泛型，并且在64行指定为Date类型。
注意：
泛型类型必须是应用类型，不能用像int double或char这样的基本类型来替换泛型类型。例如下面的语句是错误的：
ArrayList<int> list = new ArrayList<int>();
必须是ArrayList<Integer> list = new ArrayList<Integer>();
2、无需类型转换。
例如：
ArrayList<String> strList = new ArrayList<String>();
strList.add("one");
strList.add("two");
String str = strList.get(0);
91 行不需要这样 String str = (String)strList.get(0);
(3) 泛型的几种常见形式。
1、泛型类（抽象类）：
public class GenericStack<E>{
private java.util.ArrayList<E> list = new java.util.ArrayList<E>();
public int getSize(){
return list.size();
}
public E peek(){
return list.get(getSize()-1);
}
public void push(E e){
list.add(e);
}
public E pop(){
E o = list.get(getSize()-1);
list.remove(getSize()-1);
return o;
}
public boolean isEmpty(){
return list.isEmpty();
}
}
或者是：
public class GenericStack<E extends A>{
private java.util.ArrayList<E> list = new java.util.ArrayList<E>();
public int getSize(){
return list.size();
}
public E peek(){
return list.get(getSize()-1);
}
public void push(E e){
list.add(e);
}
public E pop(){
E o = list.get(getSize()-1);
list.remove(getSize()-1);
return o;
}
public boolean isEmpty(){
return list.isEmpty();
}
}
其中A为一个类。
2、泛型接口：
public interface Comparable<T>{
public int compareTo(T t);
}
或者是：
public interface Comparable<T extends A>{
public int compareTo(T t);
}
其中A为一个类。
3、泛型方法：
public class MyTest{
// 注意<T>在方法的返回值类型之前
public <T>void one(T t){
}
}
或者：
public class MyTest{
// 注意<T>在方法的返回值类型之前
public <T extends A>void one(T t){
}
}
其中A为一个类。
（4）通配泛型：
以95行的类做前置准备。
为啥需要通配泛型？
pulic class demo1{
public static void main(String[] args){
GenericStack<Integer> stack = new GenericStack<Integer>();
stack.add(1);
stack.add(2);
stack.add(3);
System.out.println("The max number is"+max(stack));
}
public static double max(GenericStack<Number> stack){
double max = stack.pop().doubleValue();
while(!stack.isEmpty()){
double value = stack.pop().doubleValue();
if(max < value){
max = value;
}
}
return max;
}
}
其中208会出现编译错误，虽然Integer是Number的子类，但是GenericStack<Integer> 不是GenericStack<Number>的子类.
这个时候通配泛型登场了。
上面的代码稍加改动就可以消除208的编译错误。
修改：211-221
public static double max(GenericStack<? extends Number> stack){
double max = stack.pop().doubleValue();
while(!stack.isEmpty()){
double value = stack.pop().doubleValue();
if(max < value){
max = value;
}
}
return max;
}
1、通配泛型的分类：
第一类：？（非受限通配） 相当于 ？extends Object。
例子：
pulic class demo2{
public static void main(String[] args){
GenericStack<Integer> stack = new GenericStack<Integer>();
stack.add(1);
stack.add(2);
stack.add(3);
print(stack);
}
public static double print(GenericStack<?> stack){
