Java 之 泛型的使用形式

泛型的使用形式有两种：

　　1、泛型类/泛型接口

　　2、泛型方法

一、泛型类/接口

　　下面先来看下 JDK1.5改写后的  ArrayList 类、Iterator 接口、Map的代码片段。

　　

 　　从上面的代码中，可以看出在定义接口、类时指定类型形参，如上面的E、K、V。

　　当使用这些集合时，就可以为E、K、V指定具体的类型实参。

　　Demo：

import java.util.HashMap;
import java.util.Iterator;
import java.util.Set;

public class TestHashMap {
    public static void main(String[] args) {
        HashMap<Integer,String> map = new HashMap<Integer,String>();
        map.put(1, "Hello");
        map.put(2, "World");
        Set<Integer> keySet = map.keySet();
        Iterator<Integer> iter = keySet.iterator();
        while(iter.hasNext()){
            Integer key = iter.next();
            System.out.println(key + "->" + map.get(key));
        }
    }
}

　　1、如何定义泛型类、接口？

　　　　我们可以为任何类和接口增加泛型声明，并不是只有集合类才可以使用泛型声明。

　　　　泛型形参的命名一般使用单个的大写字母，如果有多个类型形参，那么使用逗号分隔。

　　　　语法格式：

【修饰符】  class  类名<泛型形参列表>{}
【修饰符】  interface  接口名<泛型形参列表>{}

　　　　Demo：定义学生类，其中的学生成绩可以是如下各种类型：整数、小数、字符串（优秀，良好，合格，不合格）

public class TestStudent {
    public static void main(String[] args) {
        Student<Integer> s1 = new Student<Integer>("张三",95);
        Student<String> s2 = new Student<String>("张三","优秀");
        Student<Double> s3 = new Student<Double>("张三",80.5);
    }
}
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;
    }
}

　　  　　从上面的代码中，可以看出可以在定义接口、类时指定类型形参，类型形参在整个接口或类中可以当成类型使用，几乎所有可以使用其他普通类型的地方都可以使用这种类型形参，如：属性类型、方法的形参类型、方法返回值类型等。

　　　　Tips：

当创建带泛型声明的类时，为该类定义构造器时，构造器名还是原来的类名，不需要增加泛型声明。例如：Student<T>类定义的构造器依然是Student()，而不是Student<T>，但调用构造器时缺可以使用Student<T>的形式，而且应该为T类型形参传入实际的类型实参。

　　2、泛型类或泛型接口上的<泛型形参>这个类型可以用在哪些地方？

　　　　（1）可以用于属性、方法的数据形参、局部变量等的类型

　　　　（2）不能用于声明静态变量，不能用于静态成员上

　　　　　　  原因：因为静态成员的初始化是随着类的初始化而初始化的，此时泛型实参无法指定，那么泛型形参的类型就不确定。所以请不要在静态成员上使用类或接口上的泛型形参。

　　3、如何为泛型类、泛型接口指定泛型实参？

　　　　（1）泛型实参的要求

　　　　　　　泛型实参必须是引用数据类型，不能是基本数据类型。

　　　　　　　

　　　　（2）什么时候指定泛型实参

　　　　　　  a、在用泛型类、接口声明变量时　　

class EmployeeManager{
    private ArrayList<Employee> list;
}
//接口中的方法
public static void test(ArrayList<String> list){
    //....省略代码
}

　　　　　　  b、在继承泛型类或实现泛型接口时，如果子类不延续使用该泛型，那么必须明确指定实际类型，此时子类不再是泛型类了。

  

　　　　　　  c、在创建泛型类对象时

ArrayList<String> list = new ArrayList<String>();
ArrayList<String> list = new ArrayList<>();  （JDK1.7之后支持这种简化写法）

　　4、如何延续使用父类、父接口的泛型形参？

　　　　 如果继承泛型类、实现泛型接口时，想要继续保留父类、父接口的泛型，必须在父类、父接口和子类、子接口中都要保留泛型。

　　　　Demo：

 　　　集合中大量是这种情况：

 

 

　　5、设定泛型形参的上限？

　　　　语法格式：

<T extends 上限>     T的类型实参只能上限本身或上限的子类
<T extends 上限1 &  上限2 &....>   如果多个上限，都要满足

　　　　  Demo : 需求，定义学生类，其中的学生的成绩可以是数字类型，如Integer、Float、Double等

class Student<T extends Number> {
    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;
    }
}

　　　　如果泛型形参没有设定上限，那么泛型实参可以是任意引用数据类型。如果形参设定了上限（如：T extends 父类上限），那么只能指定为该父类本身或其各子类类型。

　　　　如：

public class TestStudentUpperBound {
    public static void main(String[] args) {
        Student<Integer> s1 = new Student<Integer>("张三", 95);
        Student<Double> s3 = new Student<Double>("张三", 80.5);
        //以下代码编译报错，因为String不是Number的子类
        Student<String> s2 = new Student<String>("张三", "优秀");
    }
}

　　　　在一种更极端的情况下，程序需要为形参设定多个上限（至多有一个父类上限，可以多个接口上限）表名该类型形参必须是其父类的子类（包括是父类本身也行），并且实现多个上限接口。

　　　 如：

class Student<T extends Number & Comparable & java.io.Serializable> {
    //...省略其他代码
}

　　　　与类同时继承父类、实现接口类似的是：为类型形参指定多个上限时，所有的接口上限必须位于类上限之后，也就是说，如果需要为类型形参指定类上限，类上限必须位于第一位。

　　6、泛型的形参一般代表什么的类型？

　　　　如：

　　　　　　ArrayList<E>: 这个E为element元素的缩写，代表集合的元素的类型

　　　　　　Map<K,V>:这个K代表Key的类型，V代表value的类型。

　　　　　　Comparable<T>：这个T为Type，表示要与当前对象比较的另一个对象的类型

　　　　　　Student<T>:这个T代表成绩的类型。

　　　　在声明泛型类或泛型接口，泛型形参最好见名知意。

二、泛型方法

　　1、什么情况下需要声明泛型方法？

　　　　上面介绍了在定义类、接口时可以使用类型形参，在该类的方法和属性定义、接口的方法定义中，这些类型形参可被当成普通类型来用。还有另外一些情况：

　　　　（1）如果定义类、接口是没有使用类型形参，但是某个方法定义时，想要自己定义类型形参；

　　　　（2）类和接口上的类型形参是不能用于静态方法中，那么当某个静态方法想要定义类型形参；

　　　　　JDK1.5之后，提供了泛型方法的支持。

　　2、如何声明泛型方法？

　　　　语法格式：

[修饰符]  <泛型形参列表>  返回类型  方法名([形参列表])  抛出的异常列表{
     //方法体...
}

　　　　　其中泛型形参列表，可以是一个或多个，如果多个，使用逗号分隔，和定义泛型类、接口时一样，而且<泛型形参列表>必须在修饰符和返回值类型之间。

　　　　　与接口、类声明中定义的泛型形参不同，方法声明中定义的泛型形参只能在当前方法中使用，和其他方法无关。

　　　　　与接口、类声明中定义的泛型形参不同，方法声明中定义的泛型形参无需显式传入实际类型参数，编译器可以根据实参类型直接推断形参的实际类型。

　　　　　Demo：编写一个方法负责将一个数组的所有元素添加到一个Collection集合中

    public static void fromArrayToCollection(Object[] a,Collection<Object> c){
        for (Object object : a) {
            c.add(object);
        }
    }

　　　　上面的这个方法没有任何问题，关键在于上面方法中的 c 形参，它的数据类型是 Collection<Object>。正如上面所说，Collection<Object> 不是 Collection<String> 类的父类——所以这个方法的功能非常有限，形参c只支持Collection<Object>类型的实参，不接收其他类型的实参。

        String[] array = {"hello","world","java"};
        Collection<String> coll = new ArrayList<String>();
        //编译报错，因为Collection<Object>形参不接收Collection<String>实参，因为它俩不是父子类关系
        fromArrayToCollection(array,coll);

　　　　为了解决上面的问题可以使用泛型方法。

    public static <T> void fromArrayToCollection(T[] a,Collection<T> c){
        for (T object : a) {
            c.add(object);
        }
    }
    public static void main(String[] args) {
        String[] array = {"hello","world","java"};
        Collection<String> coll = new ArrayList<String>();
        fromArrayToCollection(array,coll);
    }

　　3、什么时候给泛型方法指定类型实参？

　　　　调用这个方法时，编译器会根据方法的实参的类型，来确定泛型的类型实参的具体类型

　　4、如何设定泛型形参的上限？

　　　　泛型方法的<泛型形参列表>中的类型也可以指定上限

<T extends 上限>   T的类型实参只能上限本身或上限的子类
<T extends 上限1 &  上限2 & 。。。。>   如果多个上限，都要满足

　　　　Demo：

public abstract class Graphic{    //图形类
    public abstract double getArea();
}

//圆类
public class Circle extends Graphic{
    private double radius;

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

    @Override
    public double getArea() {
        return Math.PI * radius * radius;
    }    
}

//矩形类
public class Rectangle extends Graphic{
    private double length;
    private double width;
    public Rectangle(double length, double width) {
        super();
        this.length = length;
        this.width = width;
    }
    @Override
    public double getArea() {
        return length * width;
    }
}

import java.util.ArrayList;
import java.util.List;

public class TestGraphic {
        //定义一个方法，求多个图形的面积
    public static <T extends Graphic> void printArea(List<T> graphics){
        for (T t : graphics) {
            System.out.println(t.getArea());
        }
    }
    public static void main(String[] args) {
        ArrayList<Circle> cList = new ArrayList<Circle>();
        cList.add(new Circle(1.2));
        cList.add(new Circle(2.3));
        printArea(cList);
        
        ArrayList<Rectangle> rList = new ArrayList<Rectangle>();
        rList.add(new Rectangle(1,2));
        rList.add(new Rectangle(2,3));
        printArea(rList);
    }
}

　　Tips：其实没有设定泛型形参上限的，可以看成它的上限默认是Object。