Java 泛型

11.1 泛型的概念

11.1.1 泛型的引入

JDK1.5设计了泛型的概念。泛型即为“类型参数”，这个类型参数在声明它的类、接口或方法中，代表未知的通用的类型。 例如：

java.lang.Comparable接口和java.util.Comparator接口，是用于对象比较大小的规范接口，这两个接口只是限定了当一个对象大于另一个对象时返回正整数，小于返回负整数，等于返回0。但是并不确定是什么类型的对象比较大小，之前的时候只能用Object类型表示，使用时既麻烦又不安全，因此JDK1.5就给它们增加了泛型。

public interface Comparable<T>{
    int compareTo(T o) ;
}

public interface Comparator<T>{
     int compare(T o1, T o2) ;
}

其中就是类型参数，即泛型。

11.1.2 泛型的好处

示例代码：

JavaBean：圆类型

class Circle{
	private double radius;

	public Circle(double radius) {
		super();
		this.radius = radius;
	}

	public double getRadius() {
		return radius;
	}

	public void setRadius(double radius) {
		this.radius = radius;
	}

	@Override
	public String toString() {
		return "Circle [radius=" + radius + "]";
	}
	
}

比较器

import java.util.Comparator;

public class CircleComparator implements Comparator{

	@Override
	public int compare(Object o1, Object o2) {
		//强制类型转换
		Circle c1 = (Circle) o1;
		Circle c2 = (Circle) o2;
		return Double.compare(c1.getRadius(), c2.getRadius());
	}
	
}

测试类

public class TestGeneric {
	public static void main(String[] args) {
		CircleComparator com = new CircleComparator();
		System.out.println(com.compare(new Circle(1), new Circle(2)));
		
		System.out.println(com.compare("圆1", "圆2"));//运行时异常：ClassCastException
	}
}

那么我们在使用如上面这样的接口时，如果没有泛型或不指定泛型，很麻烦，而且有安全隐患。

因为在设计（编译）Comparator接口时，不知道它会用于哪种类型的对象比较，因此只能将compare方法的形参设计为Object类型，而实际在compare方法中需要向下转型为Circle，才能调用Circle类的getRadius()获取半径值进行比较。

使用泛型：

比较器：

class CircleComparator implements Comparator<Circle>{

	@Override
	public int compare(Circle o1, Circle o2) {
		//不再需要强制类型转换，代码更简洁
		return Double.compare(o1.getRadius(), o2.getRadius());
	}
	
}

测试类

import java.util.Comparator;

public class TestGeneric {
	public static void main(String[] args) {
		CircleComparator com = new CircleComparator();
		System.out.println(com.compare(new Circle(1), new Circle(2)));
		
//		System.out.println(com.compare("圆1", "圆2"));//编译错误，因为"圆1", "圆2"不是Circle类型，是String类型，编译器提前报错，而不是冒着风险在运行时再报错
	}
}

如果有了泛型并使用泛型，那么既能保证安全，又能简化代码。

因为把不安全的因素在编译期间就排除了；既然通过了编译，那么类型一定是符合要求的，就避免了类型转换。

11.1.3 泛型的相关术语

<数据类型>这种语法形式就叫泛型。其中数据类型只能是引用数据类型。

• TypeVariable：类型变量，例如：ArrayList中的E，Map中的K,V
• ParameterizedType：参数化类型，例如：Comparator，Comparator
• GenericArrayType：泛化的数组类型，即T[]
• WildcardType：通配符类型，例如：Comparator等

11.1.4 在哪里可以声明类型变量

• 声明类或接口时，在类名或接口名后面声明类型变量，我们把这样的类或接口称为泛型类或泛型接口

【修饰符】 class 类名<类型变量列表> 【extends 父类】 【implements 父接口们】{
    
}
【修饰符】 interface 接口名<类型变量列表> 【implements 父接口们】{
    
}

例如：
public class ArrayList<E>    
public interface Map<K,V>{
    ....
}    

• 声明方法时，在【修饰符】与返回值类型之间声明类型变量，我们把声明（是声明不是单纯的使用）了类型变量的方法称为泛型方法

【修饰符】 <类型变量列表> 返回值类型 方法名(【形参列表】)【throws 异常列表】{
    //...
}

例如：java.util.Arrays类中的
public static <T> List<T> asList(T... a){
    ....
}

11.2 自定义泛型结构

11.2.1 自定义泛型类和泛型接口

当我们在声明类或接口时，类或接口中定义某个成员时，该成员有些类型是不确定的，而这个类型需要在使用这个类或接口时才可以确定，那么我们可以使用泛型。

1. 声明泛型类

语法格式：

【修饰符】 class 类名<类型变量列表> {
	
}

注意：

• <类型变量列表>：可以是一个或多个类型变量，一般都是使用单个的大写字母表示。例如：、 等。

• 当类或接口上声明了<类型变量列表>时，其中的类型变量不能用于静态成员上。

示例：

   public class GerClass<T> {
    private T obj;//成员变量使用类上定义的类型变量T
   
       public T getObj() {//实例方法使用类上定义的类型变量T
           return obj;
       }
   
       public void setObj(T obj) {
        this.obj = obj;
       }
       
       //public static void test(T t){ }       //此时类型变量T不能用在静态成员上	
   }

2. 声明泛型接口

   语法格式：

   【修饰符】 interface 接口名<类型变量列表> 【implements 父接口们】{
       
   }
   

   示例：

   //泛型接口
   public interface GerInterface<T> {
       void show(T t);
   }
   

3. 泛型类和接口的子类或实现类

   泛型类和接口一样可以被继承或实现，一个类在继承父类或实现接口时分两种情况：

   • 子类或实现类明确泛型类的类型参数变量

     //定义实现类时，明确接口中声明的类型参数，此时实现类不再是泛型类
     public class GerInterfaceImpl implements GerInterface<String> {
     
         @Override
         public void show(String t) {
             System.out.println(t);
         }
     
     }
     

     public class User implements Comparable<User>{
         @Override
         public int compareTo(User u){
             
             return 0;
         }
     }
     

   • 子类不明确泛型类的类型参数变量

     //定义实现类时，实现类不明确接口中声明的类型参数，实现类仍然是泛型类
     public class GerInterfaceImpl<T> implements GerInterface<T> {
     
         @Override
         public void show(T t) {
             System.out.println(t);
         }
     
     }
     

     //ArrayList类实现了泛型接口，未明确泛型类型参数，依然是泛型类
     public class ArrayList<E> extends AbstractList<E>
         implements List<E>, RandomAccess, Cloneable, java.io.Serializable
     {
     }
     

4. 使用泛型类和接口

   • 在使用这种参数化的类与接口创建对象时，我们需要指定泛型变量的实际类型参数(必须是引用数据类型)

        public static void main(String[] args) {
            //使用泛型类或接口时，明确泛型参数类型为String
            GerInterface<String> gi = new GerInterfaceImpl<String>();
            //gi.show(123);//泛型确定了String，这里编译失败
            gi.show("hello");
        }
     

   • 指定泛型实参时，必须左右两边类型参数一致。JDK1.7后支持简写形式，右边类型参数可以省略：

     GerInterface<String> gi = new GerInterfaceImpl<>();//省略右边泛型类型
     

   • 当使用参数化类型的类或接口时，如果没有指定泛型，相当于Object类型。

     //实现类确定了泛型类型
     class Circle implements Comparable<Circle>{
         private double radius;
     
         public Circle(double radius) {
             super();
             this.radius = radius;
         }
     
         public double getRadius() {
             return radius;
         }
     
         public void setRadius(double radius) {
             this.radius = radius;
         }
     
         @Override
         public String toString() {
             return "Circle [radius=" + radius + "]";
         }
     
         @Override
         public int compareTo(Circle c){//参数类型确定
             return Double.compare(radius,c.radius);
         }
     }
     

        //类型擦除：
        public class CircleComparator implements Comparator{
            @Override
            public int compare(Object o1, Object o2) {
                //未指定泛型类型，默认为Object，使用时还要强制类型转换
                Circle c1 = (Circle) o1;
                Circle c2 = (Circle) o2;
                return Double.compare(c1.getRadius(), c2.getRadius());
            }
        }
     

练习：

我们要声明一个学生类，该学生包含姓名、成绩，而此时学生的成绩类型不确定，为什么呢，因为，语文老师希望成绩是“优秀”、“良好”、“及格”、“不及格”，数学老师希望成绩是89.5, 65.0，英语老师希望成绩是’A’,‘B’,‘C’,‘D’,‘E’。那么我们在设计这个学生类时，就可以使用泛型。

定义泛型类：

public class Student<T>{
	private String name;
	private T score;
	
	public Student() {
		super();
	}
	public Student(String name, T score) {
		super();
		this.name = name;
		this.score = score;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public T getScore() {
		return score;
	}
	public void setScore(T score) {
		this.score = score;
	}
	@Override
	public String toString() {
		return "姓名：" + name + ", 成绩：" + score;
	}
}

使用泛型类：

public class TestGeneric{
 public static void main(String[] args) {
     //语文老师使用时：
     Student<String> stu1 = new Student<String>("张三", "良好");

     //数学老师使用时：
     //Student stu2 = new Student("张三", 90.5);//错误，必须是引用数据类型
     Student<Double> stu2 = new Student<Double>("张三", 90.5);

     //英语老师使用时：
     Student<Character> stu3 = new Student<Character>("张三", 'C');

     //错误的指定
     //Student