第二十三天 泛型

1. 概述

泛型在java中有很重要的地位，在面向对象编程及各种设计模式中有非常广泛的应用。

什么是泛型？为什么要使用泛型？

泛型，即“参数化类型”。一提到参数，最熟悉的就是定义方法时有形参，然后调用此方法时传递实参。那么参数化类型怎么理解呢？

顾名思义，就是将原来的具体的类型参数化，类似于方法中的变量参数，此时类型也定义成参数形式（可以称之为类型形参），

然后在使用/调用时传入具体的类型（类型实参）。 泛型的本质是为了参数化类型（在不创建新的类型的情况下，通过泛型指定的不同类型来控制形参的类型，从而限制类型）。也就是说在泛型使用过程中，操作的数据类型被指定为一个参数，这种参数类型可以用在类、接口和方法中，分别被称为泛型类、泛型接口、泛型方法。

2. 例子说明

public class Demo {
    public static void main(String[] args) {
      List li = new ArrayList();
      li.add("abc");//往集合里存放一个字符串对象String
      li.add(100);//往集合里存放一个整数Integer
      
      for(int i=0;i<li.size();i++) {
          String str = (String) li.get(i);//报错
          System.out.println(str);//原因添加了一个String类型，添加了一个Integer类型，再使用时都以String的方式使用，因此程序崩溃了。
          //为了解决类似这样的问题（在编译阶段就可以解决），泛型应运而生。
      }
    }
}

毫无疑问，程序的运行结果会以崩溃结束：

ArrayList可以存放任意类型，例子中添加了一个String类型，添加了一个Integer类型，再使用时都以String的方式使用，因此程序崩溃了。为了解决类似这样的问题（在编译阶段就可以解决），泛型应运而生。

我们将第一行声明初始化list的代码更改一下，编译器会在编译阶段就能够帮我们发现类似这样的问题。

public class Demo {
    public static void main(String[] args) {
        List<String> li = new ArrayList<>();// 定义的时候申明了泛型，进行了类型的限制
        // 限制list集合里，只能放入string的对象
        li.add("abc");// 往集合里存放一个字符串对象String

        // 加上泛型之后，下面一行就会报错，只能放入字符串100
        // li.add(100);//往集合里存放一个整数Integer

        for (int i = 0; i < li.size(); i++) {
            String str = (String) li.get(i);// 报错
            System.out.println(str);// 原因添加了一个String类型，添加了一个Integer类型，再使用时都以String的方式使用，因此程序崩溃了。
            // 为了解决类似这样的问题（在编译阶段就可以解决），泛型应运而生。
        }
    }
}

3. 特性

泛型只在编译阶段有效。看下面的代码：

public class Demo {
    public static void main(String[] args) {
        List<String> li = new ArrayList<>();// 定义的时候申明了泛型，进行了类型的限制
        List<Integer> li1 = new ArrayList<>();
        
    
        li.add("abc");// 往集合里存放一个字符串对象String
        li.add("100");
        
        li1.add(100);
        li1.add(200);

        System.out.println(li.getClass().getName());//java.util.ArrayList
        System.out.println(li1.getClass().getName());//java.util.ArrayList
        //两个类型相同
    }
}

输出结果：泛型测试: 类型相同。

分析：通过上面的例子可以证明，在编译之后程序会采取去泛型化的措施。也就是说Java中的泛型，只在编译阶段有效。在编译过程中，正确检验泛型结果后，会将泛型的相关信息擦除，并且在对象进入和离开方法的边界处添加类型检查和类型转换的方法。也就是说，泛型信息不会进入到运行时阶段。

对此总结成一句话：泛型类型在逻辑上可以看成是多个不同的类型，实际上都是相同的基本类型。

 

4. 泛型的使用

泛型有三种使用方式，分别为：泛型类、泛型接口、泛型方法

4.1 泛型类

泛型类型用于类的定义中，被称为泛型类。通过泛型可以限制类对外开放的接口类型。最典型的就是各种容器类，如：ArrayList、HashSet、HashMap。

泛型类的最基本写法：

class类名称 <泛型标识：可以随便写任意标识号，标识指定的泛型的类型>{ // T E private 泛型标识 /*（成员变量类型）*/ var; ..... } }

一个最普通的泛型类：

public class Generic <T>{//这就是一个泛型类，有点类似于方法里的形式参数，类型参数化

    private  T key; //泛型类型的属性
    
    public Generic(T key) { //构造方法初始化k，传入一个泛型类型的k
        this.key = key;
    }
    public T getKey() {    //get方法获取这个k
        return key;
    }
}

public class Demo {
    public static void main(String[] args) {
        //因为下面为string泛型  所以必须为abc 字符串
        Generic<String> generic = new Generic<>("abc");// string相当于类型实参
        System.out.println(generic.getKey());//abc
        
        //不一定必须传入泛型的类型的实参
        //如果不传入泛型类型实参，在泛型类中使用泛型的方法或成员变量定义的类型可以为任何的类型
        Generic generic2 = new Generic("abcd");
        System.out.println(generic2.getKey());//abcd
        
        Generic generic3 = new Generic(12345);
        System.out.println(generic3.getKey());//12345
        
        Generic generic4 = new Generic(1.3);
        System.out.println(generic4.getKey());//1.3
    }
}

//泛型的类型参数只能是类类型（包括自定义类），不能是基本数据类型 //传入的实参类型需与泛型的类型参数类型相同

定义的泛型类，就一定要传入泛型类型实参么？并不是这样，在使用泛型的时候如果传入泛型实参，则会根据传入的泛型实参做相应的限制，此时泛型才会起到本应起到的限制作用。如果不传入泛型类型实参的话，在泛型类中使用泛型的方法或成员变量定义的类型可以为任何的类型。

注意：

·        泛型的类型参数只能是类类型，不能是基本数据类型。

·        不能对确切的泛型类型使用instanceof操作。如下面的操作是非法的，编译时会出错。

　　if(ex_num instanceof Generic<Number>){ }

4.2 泛型接口

泛型接口与泛型类的定义及使用基本相同。可以看一个例子：

//定义一个泛型接口

public interface Generator<T> {
      T next();
}

当实现泛型接口的类，未传入泛型实参时：

/** * 未传入泛型实参时，与泛型类的定义相同，在声明类的时候，需将泛型的声明也一起加到类中 * 即：class FruitGenerator<T> implements Generator<T>{ * 如果不声明泛型，如：class FruitGenerator implements Generator<T>，编译器会报错："Unknown class" */ class FruitGenerator<T> implements Generator<T>{ @Override public T next() { return null; } }

public class FruitGenerator implements Generator<String>{

    @Override
    public String next() {
        
        return null;
    }
}

当实现泛型接口的类，传入泛型实参时：

/** * 传入泛型实参时： * 定义一个类实现这个接口,虽然我们只创建了一个泛型接口Generator<T> * 但是我们可以为T传入无数个实参，形成无数种类型的Generator接口的实现类。 * 在实现类实现泛型接口时，如已将泛型类型传入实参类型，则所有使用泛型的地方都要替换成传入的实参类型 * 即：Generator<T>，public T next();中的的T都要替换成传入的String类型。 */ public class FruitGenerator implements Generator<String> { private String[] fruits = new String[]{"Apple", "Banana", "Pear"}; @Override public String next() { Random rand = new Random(); return fruits[rand.nextInt(3)]; } }

public class Demo {
    public static void main(String[] args) {
     Generic<Number> g1 = new Generic<Number>(123);
     Generic<Integer> g2 = new Generic<Integer>(321);
    // show(g2); 报错
     show1(g2);
    }
    public static void show(Generic<Number> generic) {
        System.out.println("genric"+generic.getKey());
    }
    public static void show1(Generic<Integer> generic) {
        System.out.println("genric"+generic.getKey());
    }
} 

4.3 泛型通配符

我们知道Ingeter是Number的一个子类，我们也验证过Generic<Ingeter>与Generic<Number>实际上是相同的一种基本类型。那么问题来了，在使用Generic<Number>作为形参的方法中，能否使用Generic<Ingeter>的实例传入呢？在逻辑上类似于Generic<Number>和Generic<Ingeter>是否可以看成具有父子关系的泛型类型呢？

为了弄清楚这个问题，我们使用Generic<T>这个泛型类继续看下面的例子：

public void showKeyValue1(Generic<Number> obj){ Log.d("泛型测试","key value is " + obj.getKey()); }

Generic<Integer> gInteger = new Generic<Integer>(123); Generic<Number> gNumber = new Generic<Number>(456); showKeyValue(gInteger); // showKeyValue这个方法编译器会为我们报错：Generic<java.lang.Integer> // cannot be applied to Generic<java.lang.Number>

通过提示信息我们可以看到Generic<Integer>不能被看作为`Generic<Number>的子类。由此可以看出:同一种泛型可以对应多个版本（因为参数类型是不确定的），不同版本的泛型类实例是不兼容的。

回到上面的例子，如何解决上面的问题？总不能为了定义一个新的方法来处理Generic<Integer>类型的类，这显然与java中的多态理念相违背。因此我们需要一个在逻辑上可以表示同时是Generic<Integer>和Generic<Number>父类的引用类型。由此类型通配符应运而生。

我们可以将上面的方法改一下：

public class Demo {
    public static void main(String[] args) {
     Generic<Number> g1 = new Generic<Number>(123);
     Generic<Integer> g2 = new Generic<Integer>(321);
     show(g2);//注意第12行的 ？ 通配符 
    }
    public static void show(Generic<?> generic) {
        System.out.println("genric"+generic.getKey());
    }
}

类型通配符一般是使用？代替具体的类型实参，注意了，此处’？’是类型实参，而不是类型形参 。重要说三遍！此处’？’是类型实参，而不是类型形参 ！ 此处’？’是类型实参，而不是类型形参 ！再直白点的意思就是，此处的？和Number、String、Integer一样都是一种实际的类型，可以把？看成所有类型的父类。是一种真实的类型。

可以解决当具体类型不确定的时候，这个通配符就是 ?  ；当操作类型时，不需要使用类型的具体功能时，只使用Object类中的功能。那么可以用 ? 通配符来表未知类型。

4.4 泛型方法

在java中,泛型类的定义非常简单，但是泛型方法就比较复杂了。

尤其是我们见到的大多数泛型类中的成员方法也都使用了泛型，泛型方法和泛型类是没有必然的关系的，初学者非常容易将泛型方法和泛型类里的使用了泛型的成员方法混为一谈。

泛型类，是在实例化类的时候指明泛型的具体类型；泛型方法，是在调用方法的时候指明泛型的具体类型 。

 

 

/**
 * * 泛型方法的基本介绍 * 说明： 1）public 与 返回值中间<T>非常重要，可以理解为声明此方法为泛型方法。
 * 2）只有声明了<T>的方法才是泛型方法，泛型类中的使用了泛型的成员方法并不是泛型方法。
 * 3）<T>表明该方法将使用泛型类型T，此时才可以在方法中使用泛型类型T。
 * 4）与泛型类的定义一样，此处T可以随便写为任意标识，常见的如T、E、K、V等形式的参数常用于表示泛型。
 */
public class Demo {
    public static void main(String[] args) {

    }

    // 泛型方法
    public <T> T show(Generic<T> generic) {
        System.out.println(generic.getKey());
        T t = generic.getKey();
        return t;
    }
}

泛型方法可以出现杂任何地方和任何场景中使用。但是有一种情况是非常特殊的，当泛型方法出现在泛型类中时，我们再通过一个例子看一下

 

public class Apple extends Fruit{

    @Override
    public String toString() {
        return "Apple";
    }    
}

 

public class Person {

    @Override
    public String toString() {
        return "Person";
    }
}

 

public class Generic<T> {

    public void show_1(T t) {
        System.out.println(t.toString());
    }
    public <T> void show_2(T t) {
        System.out.println(t.toString());
    }
    public <E> void show_3(E t) {
        System.out.println(t.toString());
    }
}

public class Demo {
    public static void main(String[] args) {
        Apple apple = new Apple();
        Person person = new Person();
        Generic<Apple> generateTest = new Generic();
        // apple是Fruit的子类，所以这里可以 generateTest.show_1(apple);
        // 编译器会报错，因为泛型类型实参指定的是Fruit，而传入的实参类是Person
        // generateTest.show_1(person);
        // 使用这两个方法都可以成功
        generateTest.show_2(apple);
        generateTest.show_2(person);
        // 使用这两个方法也都可以成功
        generateTest.show_3(apple);
        generateTest.show_3(person);
    }
}

总结：1：区分清楚泛型方法和泛型类中使用了泛型的普通方法；2：在你能够做到的前提，能使用泛型方法解决问题的，就尽量用泛型方法，不必使用泛型类

泛型方法与可变参数

再看一个泛型方法和可变参数的例子：

public <T> void printMsg( T... args){

for(T t : args){

Log.d("泛型测试","t is " + t);

}

}

printMsg("111",222,"aaaa","2323.4",55.55);

静态方法与泛型

静态方法有一种情况需要注意一下，那就是在类中的静态方法使用泛型：静态方法无法访问类上定义的泛型；如果静态方法操作的引用数据类型不确定的时候，必须要将泛型定义在方法上。

即：如果静态方法要使用泛型的话，必须将静态方法也定义成泛型方法 。

public class StaticGenerator<T> {

/** * 如果在类中定义使用泛型的静态方法，需要添加额外的泛型声明（将这个方法定义成泛型方法） * 即使静态方法要使用泛型类中已经声明过的泛型也不可以。 * 如：public static void show(T t){..},此时编译器会提示错误信息： "StaticGenerator cannot be refrenced from static context" */

public static <T> void show(T t){ }

}

4.5 泛型上下边界

<? extends T>和<? super T>是Java泛型中的“通配符（Wildcards）”和“边界（Bounds）”的概念。

·        <? extends T>：是指 “上界通配符（Upper Bounds Wildcards）”

·        <? super T>：是指 “下界通配符（Lower Bounds Wildcards）”

为什么要用通配符和边界？

使用泛型的过程中，经常出现一种很别扭的情况。比如我们有Fruit类，和它的派生类Apple类

 

public class Fruit {
}

 

public class Apple extends Fruit{
}

然后有一个最简单的容器：Plate类。盘子里可以放一个泛型的“东西”。我们可以对这个东西做最简单的“放”和“取”的动作：set( )和get( )方法。

 

public class Plate<T> {
    private T item;

    public Plate(T t) {
        item = t;
    }

    public void set(T t) {
        item = t;
    }

    public T get() {
        return item;
    }
}

现在我定义一个“水果盘子”，逻辑上水果盘子当然可以装苹果。

 

public class Demo {
    public static void main(String[] args) {
    //报错  Plate<Fruit> p = new Plate<Apple>(new Apple());
    }
}

Java编译器不允许这个操作。会报错，“装苹果的盘子”无法转换成“装水果的盘子”。不同版本的泛型类实例是不兼容的

编译器脑袋里认定的逻辑是这样的：

·        苹果 IS-A 水果

·        装苹果的盘子 NOT-IS-A 装水果的盘子

为了让泛型用起来更舒服，Oracle的大脑袋们就想出了<? extends T>和<? super T>的办法，来让”水果盘子“和”苹果盘子“之间发生关系。

什么是上界？

Plate<？ extends Fruit>

翻译成人话就是：一个能放水果以及一切是水果派生类的盘子。再直白点就是：啥水果都能放的盘子。这和我们人类的逻辑就比较接近了。

 

public class Demo {
    public static void main(String[] args) {
      Plate<? extends Fruit> p = new Plate<Apple>(new Apple());
    }
}

把水果体系扩大一下：

下界通配符 Plate<？ extends Fruit> 覆盖下图中蓝色的区域。

什么是下界？

Plate<？ super Fruit> p = new Plate<Food>(new Food());

 

上下界通配符的副作用

边界让Java不同泛型之间的转换更容易了。但不要忘记，这样的转换也有一定的副作用。那就是容器的部分功能可能失效。

还是以刚才的Plate为例。我们可以对盘子做两件事，往盘子里set()新东西，以及从盘子里get()东西。

 

public class Plate<T> {
    private T item;

    public Plate(T t) {
        item = t;
    }

    public void set(T t) {
        item = t;
    }

    public T get() {
        return item;
    }
}

上界<? extends T>不能往里存，只能往外取

<? extends Fruit>会使往盘子里放东西的set( )方法失效。但取东西get( )方法还有效。

 

public class Demo {
    public static void main(String[] args) {
      Plate<? extends Fruit> p = new Plate<Apple>(new Apple());
    //不能存入任何元素，通配符上界，set失效
     // 报错p.set(new Fruit());
     // 报错p.set(new Apple());
      
      Fruit newFruit1 = p.get();
      Object newFruit2 = p.get();
    //报错  Apple newFruit3 = p.get();
      Apple newFruit3 = (Apple)p.get();
    }
}

 

原因是编译器只知道容器内是Fruit或者它的派生类，但具体是什么类型不知道。可能是Fruit？可能是Apple？也可能是Banana，RedApple，GreenApple？编译器在看到后面用Plate赋值以后，盘子里没有被标上有“苹果”。而是标上一个占位符：? ，来表示捕获一个Fruit或Fruit的子类，具体是什么类不知道，代号? 。然后无论是想往里插入Apple或者Meat或者Fruit编译器都不知道能不能和这个? 匹配，所以就都不允许。

下界<? super T>不影响往里存，但往外取只能放在Object对象里

使用下界<? super Fruit>会使从盘子里取东西的get( )方法部分失效，只能存放到Object对象里。set( )方法正常。

 

public class Demo {
    public static void main(String[] args) {
        Plate<? super Fruit> p = new Plate<Fruit>(new Fruit());

        p.set(new Fruit());//存入元素正常
        p.set(new Apple());

        //报错 Fruit newFruit1 = p.get();
        Object newFruit2 = p.get(); //读取出来的东西只能存放在Object类里。

    }
}

因为下界规定了元素的最小粒度的下限，实际上是放松了容器元素的类型控制。既然元素是Fruit的基类，那往里存粒度比Fruit小的都可以。但往外读取元素就费劲了，只有所有类的基类Object对象才能装下。但这样的话，元素的类型信息就全部丢失。

结论性的原则：

·        频繁往外读取内容的，适合用上界Extends。

·        经常往里插入的，适合用下界Super。

 

 

4.6 关于泛型数组要提一下

在java中是”不能创建一个确切的泛型类型的数组”的。

也就是说下面的这个例子是不可以的：

List<String>[] ls = new 65.正则表达式.note<String>[10];

 

而使用通配符创建泛型数组是可以的，如下面这个例子：

List<?>[] ls = new ArrayList<?>[10];

 

这样也是可以的：

List<String>[] ls = new ArrayList[10];

 

下面使用一个例子来说明这个问题：

List<String>[] lsa = new List<String>[10]; // Not really allowed. Object o = lsa; Object[] oa = (Object[]) o; List<Integer> li = new ArrayList<Integer>(); li.add(new Integer(3)); oa[1] = li; // Unsound, but passes run time store check String s = lsa[1].get(0); // Run-time error: ClassCastException.

 

这种情况下，由于JVM泛型的擦除机制，在运行时JVM是不知道泛型信息的，所以可以给oa[1]赋上一个ArrayList而不会出现异常，

但是在取出数据的时候却要做一次类型转换，所以就会出现ClassCastException，如果可以进行泛型数组的声明，

上面说的这种情况在编译期将不会出现任何的警告和错误，只有在运行时才会出错。 而对泛型数组的声明进行限制，对于这样的情况，可以在编译期提示代码有类型安全问题，比没有任何提示要强很多。

 

 

下面采用通配符的方式是被允许的:数组的类型不可以是类型变量，除非是采用通配符的方式，因为对于通配符的方式，最后取出数据是要做显式的类型转换的。

List<?>[] lsa = new List<?>[10]; // OK, array of unbounded wildcard type. Object o = lsa; Object[] oa = (Object[]) o; List<Integer> li = new ArrayList<Integer>(); li.add(new Integer(3)); oa[1] = li; // Correct. Integer i = (Integer) lsa[1].get(0); // OK

 

最后

这部分讲的例子主要是为了阐述泛型中的一些思想而简单举出的，并不一定有着实际的可用性，在实际的编程过程中，自己可以使用泛型去简化开发，且能很好的保证代码质量。

 

 

 

 

 

 

 

 

 

 

1. 概述

泛型在java中有很重要的地位，在面向对象编程及各种设计模式中有非常广泛的应用。

什么是泛型？为什么要使用泛型？

泛型，即“参数化类型”。一提到参数，最熟悉的就是定义方法时有形参，然后调用此方法时传递实参。那么参数化类型怎么理解呢？

顾名思义，就是将原来的具体的类型参数化，类似于方法中的变量参数，此时类型也定义成参数形式（可以称之为类型形参），

然后在使用/调用时传入具体的类型（类型实参）。 泛型的本质是为了参数化类型（在不创建新的类型的情况下，通过泛型指定的不同类型来控制形参的类型，从而限制类型）。也就是说在泛型使用过程中，操作的数据类型被指定为一个参数，这种参数类型可以用在类、接口和方法中，分别被称为泛型类、泛型接口、泛型方法。

 

2. 例子说明

List arrayList = new ArrayList(); arrayList.add("aaaa"); arrayList.add(100); for(int i = 0; i< arrayList.size();i++){ String item = (String)arrayList.get(i); Log.d("泛型测试","item = " + item); }

 

毫无疑问，程序的运行结果会以崩溃结束：

java.lang.ClassCastException: java.lang.Integer cannot be cast to java.lang.String

 

ArrayList可以存放任意类型，例子中添加了一个String类型，添加了一个Integer类型，再使用时都以String的方式使用，因此程序崩溃了。为了解决类似这样的问题（在编译阶段就可以解决），泛型应运而生。

我们将第一行声明初始化list的代码更改一下，编译器会在编译阶段就能够帮我们发现类似这样的问题。

List<String> arrayList = new ArrayList<String>(); ... //arrayList.add(100); 在编译阶段，编译器就会报错

 

3. 特性

泛型只在编译阶段有效。看下面的代码：

List<String> stringArrayList = new ArrayList<String>(); List<Integer> integerArrayList = new ArrayList<Integer>(); Class classStringArrayList = stringArrayList.getClass(); Class classIntegerArrayList = integerArrayList.getClass(); if(classStringArrayList.equals(classIntegerArrayList)){ Log.d("泛型测试","类型相同"); }

 

输出结果：泛型测试: 类型相同。

分析：通过上面的例子可以证明，在编译之后程序会采取去泛型化的措施。也就是说Java中的泛型，只在编译阶段有效。在编译过程中，正确检验泛型结果后，会将泛型的相关信息擦除，并且在对象进入和离开方法的边界处添加类型检查和类型转换的方法。也就是说，泛型信息不会进入到运行时阶段。

对此总结成一句话：泛型类型在逻辑上可以看成是多个不同的类型，实际上都是相同的基本类型。

 

4. 泛型的使用

泛型有三种使用方式，分别为：泛型类、泛型接口、泛型方法

4.1 泛型类

泛型类型用于类的定义中，被称为泛型类。通过泛型可以限制类对外开放的接口类型。最典型的就是各种容器类，如：ArrayList、HashSet、HashMap。

泛型类的最基本写法：

class类名称 <泛型标识：可以随便写任意标识号，标识指定的泛型的类型>{ // T E private 泛型标识 /*（成员变量类型）*/ var; ..... } }

一个最普通的泛型类：

//此处T可以随便写为任意标识，常见的如T、E、K、V等形式的参数常用于表示泛型 //在实例化泛型类时，必须指定T的具体类型 public class Generic<T>{ //key这个成员变量的类型为T,T的类型由外部指定 private T key; public Generic(T key) { //泛型构造方法形参key的类型也为T，T的类型由外部指定 this.key = key; } public T getKey(){ //泛型方法getKey的返回值类型为T，T的类型由外部指定 return key; } }

 

//泛型的类型参数只能是类类型（包括自定义类），不能是基本数据类型 //传入的实参类型需与泛型的类型参数类型相同，即为Integer. Generic<Integer> genericInteger = new Generic<Integer>(123456); //传入的实参类型需与泛型的类型参数类型相同，即为String. Generic<String> genericString = new Generic<String>("key_vlaue"); Log.d("泛型测试","key is " + genericInteger.getKey()); Log.d("泛型测试","key is " + genericString.getKey());

 

定义的泛型类，就一定要传入泛型类型实参么？并不是这样，在使用泛型的时候如果传入泛型实参，则会根据传入的泛型实参做相应的限制，此时泛型才会起到本应起到的限制作用。如果不传入泛型类型实参的话，在泛型类中使用泛型的方法或成员变量定义的类型可以为任何的类型。

看一个例子：

Generic generic = new Generic("111111"); Generic generic1 = new Generic(4444); Generic generic2 = new Generic(55.55); Generic generic3 = new Generic(false); Log.d("泛型测试","key is " + generic.getKey()); Log.d("泛型测试","key is " + generic1.getKey()); Log.d("泛型测试","key is " + generic2.getKey()); Log.d("泛型测试","key is " + generic3.getKey());

 

D/泛型测试: key is 111111 D/泛型测试: key is 4444 D/泛型测试: key is 55.55 D/泛型测试: key is false

 

注意：

·        泛型的类型参数只能是类类型，不能是基本数据类型。

·        不能对确切的泛型类型使用instanceof操作。如下面的操作是非法的，编译时会出错。

　　if(ex_num instanceof Generic<Number>){ }

 

4.2 泛型接口

泛型接口与泛型类的定义及使用基本相同。可以看一个例子：

//定义一个泛型接口 public interface Generator<T> { public T next(); }

当实现泛型接口的类，未传入泛型实参时：

/** * 未传入泛型实参时，与泛型类的定义相同，在声明类的时候，需将泛型的声明也一起加到类中 * 即：class FruitGenerator<T> implements Generator<T>{ * 如果不声明泛型，如：class FruitGenerator implements Generator<T>，编译器会报错："Unknown class" */ class FruitGenerator<T> implements Generator<T>{ @Override public T next() { return null; } }

 

当实现泛型接口的类，传入泛型实参时：

/** * 传入泛型实参时： * 定义一个类实现这个接口,虽然我们只创建了一个泛型接口Generator<T> * 但是我们可以为T传入无数个实参，形成无数种类型的Generator接口的实现类。 * 在实现类实现泛型接口时，如已将泛型类型传入实参类型，则所有使用泛型的地方都要替换成传入的实参类型 * 即：Generator<T>，public T next();中的的T都要替换成传入的String类型。 */ public class FruitGenerator implements Generator<String> { private String[] fruits = new String[]{"Apple", "Banana", "Pear"}; @Override public String next() { Random rand = new Random(); return fruits[rand.nextInt(3)]; } }

 

 

4.3 泛型通配符

我们知道Ingeter是Number的一个子类，我们也验证过Generic<Ingeter>与Generic<Number>实际上是相同的一种基本类型。那么问题来了，在使用Generic<Number>作为形参的方法中，能否使用Generic<Ingeter>的实例传入呢？在逻辑上类似于Generic<Number>和Generic<Ingeter>是否可以看成具有父子关系的泛型类型呢？

为了弄清楚这个问题，我们使用Generic<T>这个泛型类继续看下面的例子：

public void showKeyValue1(Generic<Number> obj){ Log.d("泛型测试","key value is " + obj.getKey()); }

Generic<Integer> gInteger = new Generic<Integer>(123); Generic<Number> gNumber = new Generic<Number>(456); showKeyValue(gInteger); // showKeyValue这个方法编译器会为我们报错：Generic<java.lang.Integer> // cannot be applied to Generic<java.lang.Number>

通过提示信息我们可以看到Generic<Integer>不能被看作为`Generic<Number>的子类。由此可以看出:同一种泛型可以对应多个版本（因为参数类型是不确定的），不同版本的泛型类实例是不兼容的。

回到上面的例子，如何解决上面的问题？总不能为了定义一个新的方法来处理Generic<Integer>类型的类，这显然与java中的多态理念相违背。因此我们需要一个在逻辑上可以表示同时是Generic<Integer>和Generic<Number>父类的引用类型。由此类型通配符应运而生。

我们可以将上面的方法改一下：

public void showKeyValue1(Generic<?> obj){ Log.d("泛型测试","key value is " + obj.getKey()); }

类型通配符一般是使用？代替具体的类型实参，注意了，此处’？’是类型实参，而不是类型形参 。重要说三遍！此处’？’是类型实参，而不是类型形参 ！ 此处’？’是类型实参，而不是类型形参 ！再直白点的意思就是，此处的？和Number、String、Integer一样都是一种实际的类型，可以把？看成所有类型的父类。是一种真实的类型。

可以解决当具体类型不确定的时候，这个通配符就是 ?  ；当操作类型时，不需要使用类型的具体功能时，只使用Object类中的功能。那么可以用 ? 通配符来表未知类型。

 

4.4 泛型方法

在java中,泛型类的定义非常简单，但是泛型方法就比较复杂了。

尤其是我们见到的大多数泛型类中的成员方法也都使用了泛型，泛型方法和泛型类是没有必然的关系的，初学者非常容易将泛型方法和泛型类里的使用了泛型的成员方法混为一谈。

泛型类，是在实例化类的时候指明泛型的具体类型；泛型方法，是在调用方法的时候指明泛型的具体类型 。

/** * 泛型方法的基本介绍 * 说明： * 1）public 与 返回值中间<T>非常重要，可以理解为声明此方法为泛型方法。 * 2）只有声明了<T>的方法才是泛型方法，泛型类中的使用了泛型的成员方法并不是泛型方法。 * 3）<T>表明该方法将使用泛型类型T，此时才可以在方法中使用泛型类型T。 * 4）与泛型类的定义一样，此处T可以随便写为任意标识，常见的如T、E、K、V等形式的参数常用于表示泛型。 */ public <T> T showKeyName(Generic<T> container){

System.out.println("container key :" + container.getKey());

T test = container.getKey(); return test; }

 

 

泛型方法可以出现杂任何地方和任何场景中使用。但是有一种情况是非常特殊的，当泛型方法出现在泛型类中时，我们再通过一个例子看一下

public class GenericFruit { class Apple{ public String toString() { return "apple"; } } class Person{ public String toString() { return "Person"; } } class GenerateTest<T>{ public void show_1(T t){ System.out.println(t.toString()); } //在泛型类中声明了一个泛型方法，使用泛型E，这种泛型E可以为任意类型。可以类型与T相同，也可以不同。 //由于泛型方法在声明的时候会声明泛型<E>，因此即使在泛型类中并未声明泛型，编译器也能够正确识别泛型方法中识别的泛型。 public <E> void show_3(E t){ System.out.println(t.toString()); } //在泛型类中声明了一个泛型方法，使用泛型T，注意这个T是一种全新的类型，可以与泛型类中声明的T不是同一种类型。 public <T> void show_2(T t){ System.out.println(t.toString()); } } public static void main(String[] args) { Apple apple = new Apple(); Person person = new Person(); GenerateTest<Fruit> generateTest = new GenerateTest<Fruit>(); //apple是Fruit的子类，所以这里可以 generateTest.show_1(apple); //编译器会报错，因为泛型类型实参指定的是Fruit，而传入的实参类是Person //generateTest.show_1(person); //使用这两个方法都可以成功 generateTest.show_2(apple); generateTest.show_2(person); //使用这两个方法也都可以成功 generateTest.show_3(apple); generateTest.show_3(person); } }

 

总结：1：区分清楚泛型方法和泛型类中使用了泛型的普通方法；2：在你能够做到的前提，能使用泛型方法解决问题的，就尽量用泛型方法，不必使用泛型类

 

泛型方法与可变参数

再看一个泛型方法和可变参数的例子：

public <T> void printMsg( T... args){ for(T t : args){ Log.d("泛型测试","t is " + t); } }

printMsg("111",222,"aaaa","2323.4",55.55);

 

静态方法与泛型

静态方法有一种情况需要注意一下，那就是在类中的静态方法使用泛型：静态方法无法访问类上定义的泛型；如果静态方法操作的引用数据类型不确定的时候，必须要将泛型定义在方法上。

即：如果静态方法要使用泛型的话，必须将静态方法也定义成泛型方法 。

public class StaticGenerator<T> { .... .... /** * 如果在类中定义使用泛型的静态方法，需要添加额外的泛型声明（将这个方法定义成泛型方法） * 即使静态方法要使用泛型类中已经声明过的泛型也不可以。 * 如：public static void show(T t){..},此时编译器会提示错误信息： "StaticGenerator cannot be refrenced from static context" */ public static <T> void show(T t){ } }

 

 

4.5 泛型上下边界

<? extends T>和<? super T>是Java泛型中的“通配符（Wildcards）”和“边界（Bounds）”的概念。

·        <? extends T>：是指 “上界通配符（Upper Bounds Wildcards）”

·        <? super T>：是指 “下界通配符（Lower Bounds Wildcards）”

为什么要用通配符和边界？

使用泛型的过程中，经常出现一种很别扭的情况。比如我们有Fruit类，和它的派生类Apple类

class Fruit {} class Apple extends Fruit {}

然后有一个最简单的容器：Plate类。盘子里可以放一个泛型的“东西”。我们可以对这个东西做最简单的“放”和“取”的动作：set( )和get( )方法。

class Plate<T>{ private T item; public Plate(T t){item=t;} public void set(T t){item=t;} public T get(){return item;} }

现在我定义一个“水果盘子”，逻辑上水果盘子当然可以装苹果。

Plate<Fruit> p = new Plate<Apple>(new Apple());

Java编译器不允许这个操作。会报错，“装苹果的盘子”无法转换成“装水果的盘子”。不同版本的泛型类实例是不兼容的

编译器脑袋里认定的逻辑是这样的：

·        苹果 IS-A 水果

·        装苹果的盘子 NOT-IS-A 装水果的盘子

为了让泛型用起来更舒服，Oracle的大脑袋们就想出了<? extends T>和<? super T>的办法，来让”水果盘子“和”苹果盘子“之间发生关系。

什么是上界？

Plate<？ extends Fruit>

翻译成人话就是：一个能放水果以及一切是水果派生类的盘子。再直白点就是：啥水果都能放的盘子。这和我们人类的逻辑就比较接近了。

Plate<? extends Fruit> p = new Plate<Apple>(new Apple());

把水果体系扩大一下：

下界通配符 Plate<？ extends Fruit> 覆盖下图中蓝色的区域。

什么是下界？

Plate<？ super Fruit> p = new Plate<Food>(new Food());

 

上下界通配符的副作用

边界让Java不同泛型之间的转换更容易了。但不要忘记，这样的转换也有一定的副作用。那就是容器的部分功能可能失效。

还是以刚才的Plate为例。我们可以对盘子做两件事，往盘子里set()新东西，以及从盘子里get()东西。

class Plate<T>{ private T item; public Plate(T t){item=t;} public void set(T t){item=t;} public T get(){return item;} }

上界<? extends T>不能往里存，只能往外取

<? extends Fruit>会使往盘子里放东西的set( )方法失效。但取东西get( )方法还有效。

Plate<? extends Fruit> p=new Plate<Apple>(new Apple()); //不能存入任何元素 p.set(new Fruit()); //Error p.set(new Apple()); //Error //读取出来的东西只能存放在Fruit或它的基类里。 Fruit newFruit1=p.get(); Object newFruit2=p.get(); Apple newFruit3=p.get(); //Error

原因是编译器只知道容器内是Fruit或者它的派生类，但具体是什么类型不知道。可能是Fruit？可能是Apple？也可能是Banana，RedApple，GreenApple？编译器在看到后面用Plate赋值以后，盘子里没有被标上有“苹果”。而是标上一个占位符：? ，来表示捕获一个Fruit或Fruit的子类，具体是什么类不知道，代号? 。然后无论是想往里插入Apple或者Meat或者Fruit编译器都不知道能不能和这个? 匹配，所以就都不允许。

 

 

下界<? super T>不影响往里存，但往外取只能放在Object对象里

使用下界<? super Fruit>会使从盘子里取东西的get( )方法部分失效，只能存放到Object对象里。set( )方法正常。

Plate<? super Fruit> p=new Plate<Fruit>(new Fruit()); //存入元素正常 p.set(new Fruit()); p.set(new Apple()); //读取出来的东西只能存放在Object类里。 Apple newFruit3=p.get(); //Error Fruit newFruit1=p.get(); //Error Object newFruit2=p.get();

因为下界规定了元素的最小粒度的下限，实际上是放松了容器元素的类型控制。既然元素是Fruit的基类，那往里存粒度比Fruit小的都可以。但往外读取元素就费劲了，只有所有类的基类Object对象才能装下。但这样的话，元素的类型信息就全部丢失。

结论性的原则：

·        频繁往外读取内容的，适合用上界Extends。

·        经常往里插入的，适合用下界Super。

 

4.6 关于泛型数组要提一下

在java中是”不能创建一个确切的泛型类型的数组”的。

也就是说下面的这个例子是不可以的：

 

public class Demo {
    public static void main(String[] args) {
  //报错 List<String>[] lia = new ArrayList<String>[10];
    }
}

而使用通配符创建泛型数组是可以的，如下面这个例子：

 

public class Demo {
    public static void main(String[] args) {
      List<?>[] lia = new ArrayList<?>[10];
    }
}

这样也是可以的：

 

public class Demo {
    public static void main(String[] args) {
      List<?>[] lia = new ArrayList[10];
    }
}

下面使用一个例子来说明这个问题

 

 

List<String>[] lsa = new List<String>[10]; // Not really allowed.

Object o = lsa;

Object[] oa = (Object[]) o;

List<Integer> li = new ArrayList<Integer>();

li.add(new Integer(3));

oa[1] = li; // Unsound, but passes run time store check

String s = lsa[1].get(0); // Run-time error: ClassCastException.

这种情况下，由于JVM泛型的擦除机制，在运行时JVM是不知道泛型信息的，所以可以给oa[1]赋上一个ArrayList而不会出现异常，

但是在取出数据的时候却要做一次类型转换，所以就会出现ClassCastException，如果可以进行泛型数组的声明，

上面说的这种情况在编译期将不会出现任何的警告和错误，只有在运行时才会出错。 而对泛型数组的声明进行限制，对于这样的情况，可以在编译期提示代码有类型安全问题，比没有任何提示要强很多。

下面采用通配符的方式是被允许的:数组的类型不可以是类型变量，除非是采用通配符的方式，因为对于通配符的方式，最后取出数据是要做显式的类型转换的。

List<?>[] lsa = new List<?>[10]; // OK, array of unbounded wildcard type.

Object o = lsa; Object[] oa = (Object[]) o;

List<Integer> li = new ArrayList<Integer>();

li.add(new Integer(3));

oa[1] = li; // Correct.

Integer i = (Integer) lsa[1].get(0); // OK

最后

这部分讲的例子主要是为了阐述泛型中的一些思想而简单举出的，并不一定有着实际的可用性，在实际的编程过程中，自己可以使用泛型去简化开发，且能很好的保证代码质量。