java中的泛型

1、泛型的概念

  java语言的多态性让我们可以把某些只能在运行时确定的类型在编译时使用父类或者父接口表示，这确实解决了很多问题。但有时程序员在声明某些变量时不知道它的具体父类或父接口，只能选择公共父类Object类型，这很不方便。

  为了解决这个问题，JDK1.5引入了泛型的概念，让我们可以在程序中用某种方式表示完全未知的类型，使得程序顺利编写并通过编译，等到使用时再确定它的具体类型。泛型(Generics)指的就是泛化的类型，即用来表示一个未确定的类型。

2、泛型类或泛型接口

  如果某个类或接口在声明时，在类名和接口名后面加了泛型，那么就称它为泛型或泛型接口。JDK1.5把所有的集合类和接口都改写成了泛型类和泛型接口。

  示例代码：

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

public class HashMapTest {
    public static void main(String[] args) {
        HashMap<Integer, String> map = new HashMap<>();
        map.put(1,"codeleader1");
        map.put(2,"codeleader2");
        map.put(3,"codeleader3");

        Set<Integer> keySet = map.keySet();

        Iterator<Integer> iter = keySet.iterator();
        while (iter.hasNext()){
            Integer key = iter.next();
            System.out.println(key+"->"+map.get(key));
        }
    }
}

2.1 泛型类或接口的声明

  我们可以为任何类或接口增加泛型声明，并不是只有集合才能使用。泛型形参的命名一般使用单个的大写字母，如果有多个类型形参，那么中间使用逗号分隔，如Map。

  案例需求：现在需要定义一个学生类，这个学生类的成绩可以是如下几种类型：

• 整数
• 小数
• 字符串“优秀、良好、合格、不及格”

  这就意味着学生的成绩类型是不确定的，因此在声明学生类时，成绩类型要用等泛型字母表示。

  示例代码：

public class Student<T> {
    private String name;//姓名
    private T score;//成绩

    public Student(String name, T score) {
        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 "Student{" +
                "name='" + name + '\'' +
                ", score=" + score +
                '}';
    }
}

  测试类代码：

public class StudentTest {
    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);
    }
}

   从上面的代码可以看出，但我们把学生成绩的类型用泛型表示后，每次创建学生对象时可以由程序员指定成绩的具体类型，如、、等。

  定义在类或接口上的泛型类型，在整个接口或类体中可以当成普通类型使用，如可以用来表示属性类型、方法的形参类型、方法返回值类型等。

  但是请注意泛型类或泛型接口上声明的泛型等，不能用于声明静态变量，也不能用在静态方法中，因为静态成员的初始化是随着类的初始化而初始化的，此时泛型的具体类型还无法确定，那么泛型形参的类型就不确定，所以不要在静态成员上使用类或接口上的泛型形参类型。

2.2 泛型类或接口的使用

  当某个类或接口声明了泛型后，在使用它们时，应该尽量为其泛型指定具体的类型。

  另外，泛型实参类型的指定也有要求，它必须是引用数据类型，不能是基本数据类型，并且泛型类或接口后面声明了几个泛型，在使用时就要指定几个具体类型。

一般在什么时候指定泛型的具体类型？

• 在用泛型类、接口声明变量并创建对象时，可以指定泛型的具体类型。

  ArrayList<String> list=new ArrayList<>();
  

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

2.3 延续父类或接口的泛型

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

  例如，声明一个子类SubArrayList，让它继承ArrayList，但又希望SubArrayList仍然是一个泛型类，而且该泛型类仍然表示未知的元素类型。

  示例代码:

//SubArrayList和ArrayList保持一样的泛型字母即可
class SubArrayList<E> extends ArrayList<E>{
}

2.4 设定泛型的上限

  假如我们有一个新需求，要求学生类的成绩仍然是未确定的类型，但它必须是如下的数字类型之一，不能是String等其他非数字类型。

• Integer
• Float
• Double
• …

  示例代码：

public class Student<T extends Number> {
    private String name;    //姓名
    private T scode;        //成绩

    public Student(String name, T scode) {
        this.name = name;
        this.scode = scode;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public T getScode() {
        return scode;
    }

    public void setScode(T scode) {
        this.scode = scode;
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", scode=" + scode +
                '}';
    }
}

  测试类代码：

public class StudentUpperBoundTest {
    public static void main(String[] args) {
        Student<Integer> s1 = new Student<>("张三", 95);
        Student<Double> s2 = new Student<Double>("张三", 80.5);

       //编译报错，String不是Number的子类
//        Student s3 = new Student("张三", "优秀");
    }
}

  上面的示例代码将Student类的泛型设定了上限，那么就意味着只能指定为Number或其子类。如果此时指定为或其他非Number系列的类，那么编译器就会报错。

  如果泛型形参没有设定上限，那么泛型实参可以是任意引用数据类型，相当于默认上限是Object；如果泛型形参设定了上限(如T extends 父类上限)，那么就只能指定为该父类本身或其子类型。

  在一种更极端的情况下，程序需要为泛型设定多个上限，那么多个上限之间用&符号进行连接，并且规定在这多个上限中，至多有一个父类上限，但可以有多个接口上限，表明该类型形参必须是其父类的子类(包括其父类本身)，并且可以实现多个上限接口，父类在前接口在后。

  示例代码：

class Student<T extends Number & Cloneable>{
//...省略其他代码
}

   上面的示例代码表示该Studeng类的类必须指定为一个既继承了Number父类又实现了Cloneable父接口的类型。

2.5 案例：矩形对象管理

  声明一个矩形类(Rectangle)，包含长和宽，现在要求矩形类实现java.lang.Comparable接口，指定T为Rectangle类，重写抽象方法，按照矩形的面积大小排序。在测试类中创建Rectangle数组，然后调用Arrays.sort(Object[] arr)方法进行排序，遍历显示矩形对象信息。

  Rectangle类示例代码：

public class Rectangle implements Comparable<Rectangle> {

    private double length;//长
    private double width;//宽

    public Rectangle(double length, double width) {
        this.length = length;
        this.width = width;
    }

    public double getLength() {
        return length;
    }

    public void setLength(double length) {
        this.length = length;
    }

    public double getWidth() {
        return width;
    }

    public void setWidth(double width) {
        this.width = width;
    }
    //计算矩形的面积
    public double area(){
        return length*width;
    }

    @Override
    public int compareTo(Rectangle o) {
        return Double.compare(area(),o.area());
    }

    @Override
    public String toString() {
        return "Rectangle{" +
                "length=" + length +
                ", width=" + width +
                "area="+area()+
                '}';
    }
}

  测试类：

import java.util.Arrays;

public class RectangleTest {
    public static void main(String[] args) {
        Rectangle[] arr = new Rectangle[3];
         arr[0] = new Rectangle(1, 4);
         arr[1] = new Rectangle(2, 2);
         arr[2] = new Rectangle(1, 3);

        Arrays.sort(arr);

        for (Rectangle rectangle : arr) {
            System.out.println(rectangle);
        }
    }
}

3、泛型方法

  JDK1.5允许在类或接口上声明泛型，还允许单独在某个方法签名中声明泛型，这样的方法称为泛型方法。泛型方法可以是静态方法，也可以是非静态方法。

3.1 泛型方法的声明

  现在需要声明一个方法fromArrayToCollection()，该方法的功能是将一个对象数组的所有元素添加到一个对应类型的Collection集合。

public class TestMethod2 {
    public static <T> void fromArrayToCollection(T[] a, Collection<T> c){
        for (T t : a) {
            c.add(t);
        }
    }

    public static void main(String[] args) {
        String[] strings={"hello","world","java"};
        ArrayList<String> stringList = new ArrayList<>();

        fromArrayToCollection(strings,stringList);
        for (String s : stringList) {
            System.out.println("s="+s);
        }

        Integer[] integers={1,2,3,4,5};
        ArrayList<Integer> integerList = new ArrayList<>();
        fromArrayToCollection(integers,integerList);

        for (Integer integer : integerList) {
            System.out.println("integer="+integer);
        }

    }
}

   我们在调用fromArrayToCollection方法的时候没有手动指定的具体类型，这是因为编译器可以根据传入的实参自动进行类型推断。

  泛型方法的语法格式如下所示：

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

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

  与泛型类、泛型接口声明中定义的<泛型>不同，当前方法声明的<泛型>只能在当前方法中使用，和其他方法无关。另外，方法声明中定义的<泛型>不需要显示传入具体的类型参数，编译器可以根据调用方法时实参的类型自动推断。

3.2 设定泛型形参的上限

  在声明泛型类或泛型接口时，<泛型>是可以指定上限的，同样在声明泛型方法时，<泛型>也可以指定上限，这两种的语法格式和要求是一样的。如果没有指定上限，则默认上限为Object，如果有多个上限，则用&连接，并且父类在前，父接口在后，至多只能指定一个父类上限。

  案例需求：有一个图形的抽象类(Graphic)，包含抽象方法double getArea，返回图形面积。其中两个子类是圆型Circle和矩形Rectangle。现在需要声明一个pringArea方法可以遍历打印Collection系列集合中多个图形的面积。Collection系列集合的泛型可能是、、等图形类型，但不能是其他非图形类型。

  案例分析：pringArea方法的形参应该是Collection，因为具体是什么图形也不确定，但是需要又范围限制，必须是Graphic或其子类，因此在声明T时可以加上限，即。

  Graphic父类代码：

public abstract class Graphic {
    public abstract double getArea();
}

  Circle类代码：

public class Circle extends Graphic {
    private double radius;

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

    //重写getArea方法
    @Override
    public double getArea() {
        return Math.PI*radius*radius;
    }

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

  Rectangle类代码：

public class Rectangle extends Graphic {
    private double length;
    private double width;

    public Rectangle(double length, double width) {
        this.length = length;
        this.width = width;
    }
    //重写getArea方法
    @Override
    public double getArea() {
        return length*width;
    }

    @Override
    public String toString() {
        return "Rectangle{" +
                "length=" + length +
                ", width=" + width +
                '}';
    }
}

  测试类代码：

import java.util.ArrayList;
import java.util.Collection;

public class GraphicTest {
    //泛型方法，设定泛型上限为Graphic，则必须是Graphic或其子类
    public static <T extends Graphic> void printArea(Collection<T> graohics){
        for (T t : graohics) {
            System.out.println(t.getArea());
        }
    }

    public static void main(String[] args) {
        ArrayList<Circle> cList = new ArrayList<>();
        cList.add(new Circle(1.2));
        cList.add(new Circle(2.3));
        printArea(cList);

        ArrayList<Rectangle> rList = new ArrayList<>();
        rList.add(new Rectangle(1,2));
        rList.add(new Rectangle(2,3));
        printArea(rList);

        ArrayList<Graphic> gList = new ArrayList<>();
        gList.add(new Circle(1.2));
        gList.add(new Rectangle(2,3));
        printArea(gList);
    }
}

4、类型通配符

  当声明一个方法的某个形参类型是一个泛型类或泛型接口，但是不确定该泛型的实际类型时，如某个方法的形参类型是ArrayList，实参集合元素可能是任意类型，即此时形参无法将具体化。Java提供了类型通配符来解决这个问题。使用泛型类或泛型接口的类型声明其他变量时也是如此。

4.1 类型通配符的使用

  类型通配符用一个来表示，它代表任意引用数据类型。类型通配符只能出现在泛型类或泛型接口来声明变量或形参时。

  案例需求：声明一个disjoint方法，如果两个指定的Collection集合没有共同的元素，则返回true，否则返回false。

public class WildcardAnyTest {
    public static boolean disjoint(Collection<?> c1,Collection<?> c2){
        for (Object o1 : c1) {
            for (Object o2 : c2) {
                if(o1.equals(o2)){
                    return false;
                }
            }
        }
        return true;
    }

    public static void main(String[] args) {
        ArrayList<String> list1 = new ArrayList<>();
        list1.add("hello");
        list1.add("code");
        list1.add("leader");

        ArrayList<String> list2 = new ArrayList<>();
        list2.add("1");
        list2.add("2");
        list2.add("3");

        ArrayList<Integer> list3 = new ArrayList<>();
        list3.add(1);
        list3.add(2);
        list3.add(3);

        System.out.println(disjoint(list1,list2));
        System.out.println(disjoint(list2,list3));
    }
}

4.2 类型通配符的上限

  在声明时可以通过的方式限定"T"的上限，同样可以通过的方式限定"?"的上限，代表任意的引用数据类型，代表泛型类型必须是类型本身，或者是类型的子类。

4.3 类型通配符的下限

  我们在声明时之可以通过的形式指定其上限。但是在使用时，既可以通过的方法指定其上限，还可以通过的方式指定其下限。

  案例需求：假设需要声明一个处理两个Collection集合的静态方法，它可以将src集合中的元素剪切到dest集合中，并且返回被剪切的最后一个元素。

  案例分析：public static T cut(Collection dest,Collection src )。可以表示依赖关系，不管src集合元素类型中的T是什么，只要dest集合元素的类型是T或T的父类即可。而且如果此时dest的泛型是