Java笔记十——泛型

大家好，我是讯享网，很高兴认识大家。

泛型概述

向上转型

ArrayList<T>实现了List<T>接口，即即类型ArrayList可以向上转型为List。
List<String> list = new ArrayList<String>();

使用泛型

泛型类

最典型的就是各种容器类，如：List、Set、Map

编写泛型类

//在实例化泛型类时，必须指定T的具体类型 public class Generic<T> { //成员变量key的类型为T，T的类型由外部指定 private T key; public Generic(T key) {//构造方法形参key，具体类型由传入参数的类型决定 this.key = key; } public T getKey() { return key; } }

讯享网

讯享网//泛型的类型参数只能是类类型（包括自定义类），不能是简单类型 //传入的实参类型需与泛型的类型参数类型相同，即为Integer. Generic<Integer> genericInteger = new Generic<Integer>(); //传入的实参类型需与泛型的类型参数类型相同，即为String. Generic<String> genericString = new Generic<String>("key_vlaue");

泛型的类型参数只能是类类型，不能是简单类型，不能对确切的泛型类型使用instanceof操作，编译会报错

泛型接口

泛型接口定义也很简单，泛型接口通常用于各种类的生产器中，例如

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

实现泛型接口的类，例如FruitGenerator，实现时可以传入具体类型的泛型实参，未传入时声明类的时候要将泛型的声明加入到类声明中：

讯享网/ * 未传入泛型实参时，与泛型类的定义相同，在声明类的时候，需将泛型的声明也一起加到类中 * 即：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)]; } }

泛型通配符

常用的通配符为： T，E，K，V，？

？表示不确定的 java 类型
T (type) 表示具体的一个java类型
K V (key value) 分别代表java键值中的Key Value
E (element) 代表Element

类型通配符一般是使用？代替具体的类型实参

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

泛型可以同时定义多种类型，例如Map<K, V>。

使用类似<? extends Number>通配符作为方法参数时表示：

方法内部可以调用获取Number引用的方法，例如：Number n = obj.getFirst();；

方法内部无法调用传入Number引用的方法（null除外），例如：obj.setFirst(Number n);。

即一句话总结：使用extends通配符表示可以读，不能写。

使用类似<T extends Number>定义泛型类时表示：

泛型类型限定为Number以及Number的子类。

使用<? super Integer>通配符表示：

允许调用set(? super Integer)方法传入Integer的引用；

不允许调用get()方法获得Integer的引用。

讯享网

唯一例外是可以获取Object的引用：Object o = p.getFirst()。

换句话说，使用<? super Integer>通配符作为方法参数，表示方法内部代码对于参数只能写，不能读。

<? extends T>允许调用读方法T get()获取T的引用，但不允许调用写方法set(T)传入T的引用（传入null除外）；

<? super T>允许调用写方法set(T)传入T的引用，但不允许调用读方法T get()获取T的引用（获取Object除外）。

一个是允许读不允许写，另一个是允许写不允许读。

泛型方法

泛型类中的静态方法

编写泛型类时，要特别注意，泛型类型不能用于静态方法，对于静态方法，要单独改写成为“泛型”方法。例如：

public class Pair<T> { private T first; private T last; public Pair(T first, T last) { this.first = first; this.last = last; } public T getFirst() { ... } public T getLast() { ... } // 静态泛型方法应该使用其他类型区分: public static <K> Pair<K> create(K first, K last) { return new Pair<K>(first, last); } }

泛型方法的声明定义

讯享网/ * 泛型方法的基本介绍 * @param tClass 传入的泛型实参 * @return T 返回值为T类型 * 说明： * 1）public 与 返回值中间<T>非常重要，可以理解为声明此方法为泛型方法。 * 2）只有声明了<T>的方法才是泛型方法，泛型类中的使用了泛型的成员方法并不是泛型方法。 * 3）<T>表明该方法将使用泛型类型T，此时才可以在方法中使用泛型类型T。 * 4）与泛型类的定义一样，此处T可以随便写为任意标识，常见的如T、E、K、V等形式的参数常用于表示泛型。 */ public <T> T genericMethod(Class<T> tClass)throws InstantiationException , IllegalAccessException{ T instance = tClass.newInstance(); return instance; }

Object obj = genericMethod(Class.forName("com.test.test"));

泛型方法的基本用法

讯享网public class GenericTest { 
    //这个类是个泛型类，在上面已经介绍过 public class Generic<T>{ 
    private T key; public Generic(T key) { 
    this.key = key; } //我想说的其实是这个，虽然在方法中使用了泛型，但是这并不是一个泛型方法。 //这只是类中一个普通的成员方法，只不过他的返回值是在声明泛型类已经声明过的泛型。 //所以在这个方法中才可以继续使用 T 这个泛型。 public T getKey(){ 
    return key; } / * 这个方法显然是有问题的，在编译器会给我们提示这样的错误信息"cannot reslove symbol E" * 因为在类的声明中并未声明泛型E，所以在使用E做形参和返回值类型时，编译器会无法识别。 public E setKey(E key){ this.key = keu } */ } / * 这才是一个真正的泛型方法。 * 首先在public与返回值之间的<T>必不可少，这表明这是一个泛型方法，并且声明了一个泛型T * 这个T可以出现在这个泛型方法的任意位置. * 泛型的数量也可以为任意多个 * 如：public <T,K> K showKeyName(Generic<T> container){ * ... * } */ public <T> T showKeyName(Generic<T> container){ 
    System.out.println("container key :" + container.getKey()); //当然这个例子举的不太合适，只是为了说明泛型方法的特性。 T test = container.getKey(); return test; } //这也不是一个泛型方法，这就是一个普通的方法，只是使用了Generic<Number>这个泛型类做形参而已。 public void showKeyValue1(Generic<Number> obj){ 
    Log.d("泛型测试","key value is " + obj.getKey()); } //这也不是一个泛型方法，这也是一个普通的方法，只不过使用了泛型通配符? //同时这也印证了泛型通配符章节所描述的，?是一种类型实参，可以看做为Number等所有类的父类 public void showKeyValue2(Generic<?> obj){ 
    Log.d("泛型测试","key value is " + obj.getKey()); } / * 这个方法是有问题的，编译器会为我们提示错误信息："UnKnown class 'E' " * 虽然我们声明了<T>,也表明了这是一个可以处理泛型的类型的泛型方法。 * 但是只声明了泛型类型T，并未声明泛型类型E，因此编译器并不知道该如何处理E这个类型。 public <T> T showKeyName(Generic<E> container){ ... } */ / * 这个方法也是有问题的，编译器会为我们提示错误信息："UnKnown class 'T' " * 对于编译器来说T这个类型并未项目中声明过，因此编译也不知道该如何编译这个类。 * 所以这也不是一个正确的泛型方法声明。 public void showkey(T genericObj){ } */ public static void main(String[] args) { 
    } }

类中的泛型方法

泛型方法可以在任何地方和场景中使用，当泛型方法出现在泛型类中是，比较特殊。

public class GenericFruit { 
    class Fruit{ 
    @Override public String toString() { 
    return "fruit"; } } class Apple extends Fruit{ 
    @Override public String toString() { 
    return "apple"; } } class Person{ 
    @Override 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); } }

泛型方法与可变参数

参数是数组，元素可以是不同类型

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

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

泛型上下边界

类型通配符？所有java类都可以匹配，注意不能调用与对象有关的方法
设定通配符上限  List<? extends Number>
————下限 //传递进来的只能是Type或Type的父类
<? super Type>

为泛型添加上边界
即传入的实参必须是指定类型的子类型

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

Generic<String> generic1 = new Generic<String>("11111"); Generic<Integer> generic2 = new Generic<Integer>(2222); Generic<Float> generic3 = new Generic<Float>(2.4f); Generic<Double> generic4 = new Generic<Double>(2.56); //这一行代码编译器会提示错误，因为String类型并不是Number类型的子类 //showKeyValue1(generic1); showKeyValue1(generic2); showKeyValue1(generic3); showKeyValue1(generic4);

如果我们把泛型类的定义也改一下:

讯享网public class Generic<T extends Number>{ 
    private T key; public Generic(T key) { 
    this.key = key; } public T getKey(){ 
    return key; } }

//这一行代码也会报错，因为String不是Number的子类 Generic<String> generic1 = new Generic<String>("11111");

泛型的上下边界添加，必须与泛型的声明在一起。

擦拭法

Java的泛型是由编译器在编译时实行的，编译器内部永远把所有类型T视为Object处理，但是，在需要转型的时候，编译器会根据T的类型自动为我们实行安全地强制转型。

Java泛型的局限

局限一：不能是基本类型，例如int，因为实际类型是Object，Object类型无法持有基本类型：
局限二：无法取得带泛型的Class。（联系反射的知识）
因为T是Object，我们对Pair<String>和Pair<Integer>类型获取Class时，获取到的是同一个Class，也就是Pair类的Class。
换句话说，所有泛型实例，无论T的类型是什么，getClass()返回同一个Class实例，因为编译后它们全部都是Pair<Object>
局限三：无法判断带泛型的类型：
instanceof不管用
局限四：不能实例化T类型：
new T()这种会报错

不恰当的覆写方法

下面的equals(）不能通过编译

讯享网public class Pair<T> { 
    public boolean equals(T t) { 
    return this == t; } }

equals(T t)实际上会被擦拭成equals(Object t)，equals方法是继承自Object的，阻止这种实际上会变成覆写的泛型方法定义。换个名字就可以了，把equals换成same

泛型和反射

部分反射API是泛型，例如：Class，Constructor；

可以声明带泛型的数组，但不能直接创建带泛型的数组，必须强制转型；

可以通过Array.newInstance(Class, int)创建T[]数组，需要强制转型；

同时使用泛型和可变参数时需要特别小心。