Java笔记---泛型

总结了泛型的基本语法、上下级通配符、泛型反射以及使用泛型的一些实践，看完还不会用泛型你顺着网线来打我（狗头）。

我们写的一些代码是可以被不同的类型复用的，但一般的代码要求类型必须是确定的，这对代码的复用产生了极大的限制。

将类型声明为超类或接口可以在一定范围内实现代码的复用，但这也只是将限制范围扩到了超类及其子类或实现了接口的类。在一些情况下这个范围还是不能满足到我们，尤其java是单根继承的。我们希望的是“非特定类型”的编码，而不是一个具体的类或接口。

Java 5开始引入的泛型可以支持我们编写出“非特定类型”的代码。泛型实现了参数化类型，将类型做一个参数，在定义类、接口或方法的同时声明类型参数，到使用时再决定其具体的类型。

泛型是编译时的特性，在编译时编译器对会对泛型进行类型检查并在类的‘边界（入参和返回）’处添加一些额外的转型代码，以此来保证运泛型行时的类型安全。

我们在使用时看上去像是用具体的类型替换了我们申明的类型参数。但实现上在编译后参化类型信息就丢失了，我们指定的具体的类型在运行时已经被擦除了。

Java采用类型擦除，而不像c++一样的类型替换也是无奈之举，因为java 5之前没有泛型，为了兼容java5之前的代码而选择类型擦除。

名词解释：

  • 类型参数：声明泛型类、接口或方法时在尖括号中申明的类型参数，如List<E>的E
  • 泛型类：声明了类型参数的类、接口或方法称为泛型类、泛型接口和泛型方法。
  • 参数化类型：使用泛型类时指定了具体的类型后称为参数化类型，如List<String>
  • 原始类型：参数化类型的泛型类的Class，如List<String>的原始类型为List，List<String>[]的原始类型也为List

一、泛型类：

1、声明和使用泛型类

在类名之后使用尖括号声明类型参数，声明的类型参数可以像普通类一样用在类型声明处使用，到使用时再决定其具体类型，然后编译器会帮我们处理一些类型类型转换的细节。

public class Holder<T> {
    T val;

    public Holder(T val) {
        this.val = val;
    }

    public T getVal() {
        return val;
    }
    
    public void setVal(T val) {
        return this.val = val;
    }
    
    public static void main(String[] args) {
        Holder<String> strHolder = new Holder<String>("abc");
        String s = h.getVal();
    }
}

在使用时指定了的Holder的类型参数为String。可以将getVal()的返回值直接赋给一个String变量，而不用显示的转型。在使用setVal时也必须传入String类获其子类，若入参不是String或其子类那么编译时会报错。

在Java7之前new参数化类型时需要指定类型，但在Java7之后new操作可以不用显示指定类型，编译器会自动推导出来：

 Holder<String> h = new Holder<>("abc");
2、多个类型参数使用逗号分隔：
public class Holder<A, B, C> {

    public A v1;
    public B v2;
    public C v3;

    public Holder(A v1, B v2, C v3) {
        this.v1 = v1;
        this.v2 = v2;
        this.v3 = v3;
    }

    public static void main(String[] args) {
        Holder<String, Integer, Float> h = new Holder<>("abc", 1, 2.5);
    }
}
3、泛型接口

接口也可以声明为泛型，声明和使用方式同泛型方法一样：

public interface Generator<T> {
    T next();
}
4、内部类可以使用外部类的类型参数：
class A<T> {
    class B {
        T a;
    }
}
5. 匿名内部类也可以是参数化类型的
interface A<T> {
    T next();
}
new A<String>() {
    @Override
    public String next() {
        return null;
    }
};
6. 静态的无法访问类型参数

静态的属性、静态方法、和静态内部类是无法使用类的泛型参数的。如果要使static方法具有泛型能力，可以使用泛型方法。

二、 继承泛型类/实现泛型接口

1、继承时指定类型

在继承一个泛型类或实现一个泛型接口时需要指定具体类型，指定了具体的类型后对子类而言它的父类或实现的接口就是参数化类型的，通过Class的getGenericSuperclass获取父类的类型时返回的类型为ParameterizedType的。

class Apple {
    public void  show() {
        System.out.println(getClass().getSimpleName());
    }
}

public class AppleHolder extends Holder<Apple> {

    public AppleHolder(Apple apple) {
        super(apple);
    }

    public static void main(String[] args) {
        AppleHolder appleHolder = new AppleHolder(new Apple());
        Apple apple = appleHolder.getVal();
        apple.show();

        System.out.println(appleHolder.getClass().getGenericSuperclass() instanceof ParameterizedType);
    }
}

Apple
true

2、继承时不指定类型

若继承类或实现接口时未指定类型，则对子类而言父类或接口的就是一个普通的类或接口，而其类型参数被擦除为Object，通过Class的getGenericSuperclass返回的类型是Class的。

public class CommonHolder extends Holder {

    public CommonHolder(Object val) {
        super(val);
    }

    public static void main(String[] args) {
        System.out.println(CommonHolder.class.getGenericSuperclass() instanceof Class);
    }
}

true

3、指定为子类中的类型参数

也可以将子类中声明的类型参数给到父类，后面为子类指定类型时父类也获得同样的类型。对子类而言它的父类仍是参数化类型的，通过Class的getGenericSuperclass的返回类型仍是ParameterizedType的。

public class CommonHolder<T> extends Holder<T> {

    public CommonHolder(T val) {
        super(val);
    }

    public static void main(String[] args) {
        System.out.println(CommonHolder.class.getGenericSuperclass() instanceof ParameterizedType);
    }
}

true

三、泛型方法

可以单独为方法声明泛型，而这个类不必是泛型类。定义泛型方法，只需要将泛型参数列表置于返回值之前。声明的类型参数在方法中定义类型的地方像普通类一样使用。

public class Test {
    public static <T> void t(T x) {
        System.out.println(x.getClass().getName());
    }
    
    public static <K,V> Map<K, V> newMap() {
        return new HashMap<K, V>();
    }

    public static void main(String[] args) {
        t(11);  // java.lang.Integer
        t("abc"); // java.lang.String

        Map<String, Date> m = newMap();
        m.put("now", new Date());
    }
}

使用泛型方法时不用显示的指定出具体的类型，编译器会根据方法类型参数的入参或返回赋值的类型推断出具体的类型，但若将调用结果直接作为一个参数传递给另外一个方法，这时编译器并不会进行类型推断。如果是基本类型则会自动装箱为包装类型。

public static <T> String className(T v) {
    return v.getClass().getSimpleName();
}

public static void main(String[] args) {
    // 输出Integer，自动推断出是Integer
    System.out.println(Test.className(11));
}

在调用泛型方法时也可以显示的指明类型，在点操作符与方法名之间插入尖括号，然后把类型置于其中：

Test.<String, Date>newMap();

变长参数列表也可以使用泛型参数:

public static <T> List<T> toList(T... args) {
    List<T> l = new ArrayList<T>(args.length);
    for (T e : args) {
        l.add(e);
    }
    return l;
}

当调用一个可变参数方法时，会创建一个数组来存放可变参数，若参数的类型是类型参数的，那么将创建泛型的数组，但Java不是允许创建泛型数组吗？
这里java做了一些妥协允许为可变参数创建一个泛型数组。

但可变参数列表的入参是可以为不同类型的，所以有时编译也无法决定泛型可变参数的具体类型，只能选择一个最通用的类型。

public class Test {

    public static void main(String[] args) {
        System.out.println(toArray(Integer.valueOf(11),  Double.valueOf(13)).getClass());
        
    }
    public static <T> T[] toArray(T... args) {
        return args;
    }
}

class [Ljava.lang.Number;

四、通配符：

// Drink -> Juice -> AppleJuice
public class Drink {}
public class Juice extends Drink {}
public class AppleJuice extends Juice {}

public class Bottle<T> {
    private T drink;

    public Bottle(T drink) {
        drink = drink;
    }

    public T getDrink() {
        return drink;
    }

    public void setDrink(T drink) {
        drink = drink;
    }
}

对于普通的类，同一个类的对象之间是可以互相赋值的，也可以将子类对象赋值给父类对象。

Juice juice1 = new Juice();
Juice juice2 = new Juice();
juice1 = juice2;
juice2 = new AppleJuice();

但对于泛型类只要指定的类型不同，那么就是不同的参数化类型，即使他们是同一个泛型类，即使类型参数之间有继承关系，也是不能互相赋值的：

// Error
Bottle<Juice> b1 = new Bottle<AppleJuice>(new AppleJuice());

虽然在类型擦除后他们都是Bottle<Object>，但在编译时编译器在泛型类的边界插入的类型处理代码是不同的，显然不能用处理AppleJuice的代码去处理其他类型，所以在编译器角度它们是不同的类型，编译时会报错。

为了解决的类型参数有继承关系的泛型实例之间的赋值问题，java提供了通配符。

1、上界通配符

在定义泛型变量是可以使用extends关键指定类型的上界，从而使声明的变量可以被赋值为类型参数为上界类及其子类的泛参数化类型，当然前提是泛型类是相同的或父子类。

Bottle<? extends Juice> b = new Bottle<AppleJuice>(new AppleJuice());

声明上界为Juice的b可以被赋值为Bottle<AppleJuice>。但使用上界通配符后泛型实例的使用也受到了一定限制。

虽然使用了extends通配符，但编译器任然不知道具体的类型是Juice或是Juice的子类，所以编译器无法保参数类型有类型参数的方法的入参的安全性，所以使用上界通配符声明的实例是不允许调用参数有类型参带的方法的。但入参为null时可以的，因为null并没有具体的类型。但返回是安全的，将子类赋给父类是安全的，所以返回类型类型参数的方法不受影响。

Bottle<? extends Juice> b = new Bottle<AppleJuice>(new AppleJuice());
Juice juice = b.getDrink();
// Error
b .setDrink(new AppleJuice());
2、下界通配符

使用super关键字指定下界的泛型变量，指定了下界的变量只能赋值为类型参数为指定的下界或下界的父类的参数化类型。

Bottle<? super Juice> b = new Bottle<Drink>(new AppleJuice());

在编译时入参会被转换为实际的类型Drink，用父类型来操作子类型是安全的，所以下界通配符声明的实例使用入参带类型参数的方法是安全的。但由于不能将父类赋值给子类，所以下界通配符声明的实例不能将返回类型为类型按时的方法的返回值赋给其他变量。

Bottle<? super Juice> b = new Bottle<Drink>(new AppleJuice());
// Error
Drink drink = b.getDrink();
3、无界通配符

参数类型指定为?号，表示任意类型都可以。

Bottle<?> b = new Bottle<>(new AppleJuice());
Drink drink = (Drink) b.getDrink();

// ERROR
b.setDrink(new AppleJuice());

使用无界通配符看起来和原始生类型没有什么区别，但无界通配符的意义在于在我们明确知道这里使用任意类型，并且无界通配符会进行类型检查，因为无界通配符不知道确切的类型所以无法保证安全性，所无界通配符的变量不能调用入参类型为类型参数的方法。

五、泛型的边界

由于类型擦除，对于类型参数我们是无法直接使用具体的属性或方法的。如下面的调用会编译失败：

import java.sql.DriverManager;
import java.util.*;;

public class Test<T> {
    public T val;

    public void show() {
        // 编译时失败
        val.show();
    }

    public static class Show {
        public void show() {
        }
    }

    public static void main(String[] args) throws ClassNotFoundException {
        Test<Show> t = new Test<>();
        t.show();
    }
}

即使我们知道val的类型后面会是Show，但因为类型擦除无法保证这样做的安全性所以会编译失败。不过可以通过extends显示的声明类型参数的上界，若没有声明那么上界就是Object。声明类上界后，在使用该泛型类时指定的类型只能为上界或其子类。

public class Show {
    public void show() {}
}
    
public class Test<T extends Show> {
    public T val;

    public void show() {
        // 可以调用
        val.show();
    }
    
    public static void main(String[] args)  {
        Test<Show> t = new Test<>();
        t.show();
    }
}

声明上界后可以显示的调用上界的属性或方法。在没有声明上界时默认上界为Object，所有我们可以在没有声明上界的情况下调用Object的方法。

public class Test<T> {
    public T val;
    public void show() {
        val.getClass();
        val.toString();
        val.hashCode();
    }
}

六、 类型擦除

使用泛型时指定的类型只在编译时期生效，在编译后会将所有的类型参数擦除到它的第一个边界，未指定边界的情况下擦除为Object。所以在运行时我们是无法获取到类型参数的具体类型的。

因为类型擦除，泛型参数在运行时已经不存在，所以不能在运行时显式的使用泛型的类型操作，如instanceof、new、T.class等，但前置类型转换时可以的:

public class Test<T> {
    Class<?> type;

    public Test(Class<?> type) {
        this.type = type;
    }

    public T[] newArray(int size) {
        return (T[]) Array.newInstance(type, size);
    }

    public static void main(String[] args) {
       Test<String> t = new Test<>(String.class);
       String[] strArr = t.newArray(10);
    }
}

虽然我们可以指定不同类型参数然，但在擦除后这些都指向同一个类型。如List<String>和List<Integer>的Class都是同一个即List.Class。

因为在编译时擦除了具体的类型信息，为类保证运行时正确的类型行为，编译器在编译时对泛型‘边界’，即对类中有泛型入参和放回的方法， 做了类型检查或插入转型代码。调用方法时对入参进行类型转换，返回时对返回值进行转换。

六、 建议

1、指定类型信息

因为类型擦除，我们无法在运行时获取具体的参数类型信息，若需要具体的类型信息可以显示的传递类型的Class对象。

public class Test<T> {
    private Class<T> kind;
    public T val;
    public Test(Class<T> kind) {
        this.kind = kind;
    }
    public boolean isType(Object o) {
        return kind.isInstance(o);
    }
}
2、能使用泛型方法就不使用泛型类

如果使用泛型方法可以取代泛型类，那么应该尽量使用泛型方法替换类的泛型类。

3、尽量使用参数化泛型：

如果一个类或接口是泛型的那么应该尽量使用其参数化的类型，这样编译器在编译时会为我们做一些类型的检查，避免在运行时报错。

若确是没有具体的类型也建议使用通配符，如List<?>。使用通配符可以在编译时进行检查，并阻止我们调用有类型参数的方法。

直接使用泛型的原始类型时有风险的，原始类型在编译时并不会进行类型检查，且类型参数被擦除为Object，Object可以接受任意类型的实例，如给到类的是不同类型的实例，在类中使用操作这些实例是有一定安全隐患且这些隐患可能在运时才暴露出来。而java之所以支直接使用泛型的原始类型只是为类兼容性。

4、不要将参数化类型赋给原始类型使用

为了兼容性，java没有禁止将参数化类型的变量转为原始类型，这类只是在编译时产生告警。但将参数化类型赋给原始类型后，编译器不会再对原始类型实例的操作进行类型检查，这可能会造成运行时的错误。

class Calculator<T> {
    public int intAdd(T v1, T v2) {
        return ((Number) v1).intValue() + ((Number) v1).intValue();
    }
}
public class Test {
    public static void main(String[] args) {
        Calculator<Integer> intCal= new Calculator<>();
        Calculator cal = intCal;
        cal.intAdd("a", "b");
    }
}

Exception in thread "main" java.lang.ClassCastException: java.lang.String cannot be cast to java.lang.Number
at com.test.java.Calculator.intAdd(Test.java:10)
at com.test.java.Test.main(Test.java:20)

将参数化类型Calculator<Integer>的intCal赋给Calculator的cal，后面对cal的的操作编译器不会进行类型检查，这个错误在运行时才会抛出。

public static void main(String[] args) {
    List<String> strList = new ArrayList<>();
    List list = strList;
    list.add(Integer.valueOf(11));
    String s = strList.get(0);
}

Exception in thread "main" java.lang.ClassCastException: java.lang.Integer cannot be cast to java.lang.String
at com.test.java.Test.main(Test.java:27)

上面代码在编译时只会产生一个警告，但在运行时会报出一个致命错误。因为将strList赋给了List类型的list，锁编译时不会对list变量的操作进行类型检查。而因为类型擦除，在运行时String被擦除为Object，所以list.add(Integer.valueOf(11))可以正常运行。但因为strList是List<String>类型的，编译时为其插入了String类型转换的代码，而将一个Integer转化为String时非法的。

5、尽量不要使用泛型的可变参数列表

泛型的可变参数有时应为无法确定具体的类型，只能将可变参数的数组类型定位一个通用的类型。对于可变参数列表的数组，我们不仅仅是用来传递值，可能会对其进行操作，这就带来了类型安全的风险。 应该尽量避免使用泛型的可变参数或使用List的参数化类型代替可变参数。

effective java有一个经典的例子，传入三个对象随机选取两个最为预估数组返回：

public class Test {

    public static void main(String[] args) {
        String[] strArr = pickTwo("a", "b", "c");
    }

    public static <T> T[] toArray(T... args) {
        return args;
    }

    public static <T> T[] pickTwo(T a, T b, T c) {
        switch (ThreadLocalRandom.current().nextInt(3)) {
            case 0: return toArray(a, b);
            case 1: return toArray(a, c);
            case 2: return toArray(b, c);
        }
        throw new AssertionError();
    }
}

Exception in thread "main" java.lang.ClassCastException: [Ljava.lang.Object; cannot be cast to [Ljava.lang.String;
at cn.ly.test.java.Test.main(Test.java:21)

这个类在编译时并不会报错，但运行时会抛出ClassCastException异常。pickTwo的参数是类型参数的的在将这一类型的参数传递给toArray方法时编译器无法判断类型参数的，只能创建一个Object[]数组来持有可变参数。对pickTwo的返回编译为我们插入了一个String[]的类型转换，但此时实际类型是Object[]是不能转换为String[]的。

6、强制类型转化泛型时应该转为通配符类型

在强制类型转化时，若目的类型是一个泛型那么应该将其转化为该类型的通配符参数化类型，而非原始类型。这样转型或的变量收到编译器的检查。

if (o instanceof List) {
    List<?> l = (List<?>) o;
}
最后编辑于 ：
©著作权归作者所有,转载或内容合作请联系作者
  • 人面猴
    序言：七十年代末，一起剥皮案震惊了整个滨河市，随后出现的几起案子，更是在滨河造成了极大的恐慌，老刑警刘岩，带你破解...
    沈念sama阅读 196,264评论 5赞 462
  • 死咒
    序言：滨河连续发生了三起死亡事件，死亡现场离奇诡异，居然都是意外死亡，警方通过查阅死者的电脑和手机，发现死者居然都...
    沈念sama阅读 82,549评论 2赞 373
  • 救了他两次的神仙让他今天三更去死
    文/潘晓璐 我一进店门，熙熙楼的掌柜王于贵愁眉苦脸地迎上来，“玉大人，你说我怎么就摊上这事。” “怎么了？”我有些...
    开封第一讲书人阅读 143,389评论 0赞 325
  • 道士缉凶录：失踪的卖姜人
    文/不坏的土叔 我叫张陵，是天一观的道长。 经常有香客问我，道长，这世上最难降的妖魔是什么？ 我笑而不...
    开封第一讲书人阅读 52,616评论 1赞 267
  • 港岛之恋（遗憾婚礼）
    正文 为了忘掉前任，我火速办了婚礼，结果婚礼上，老公的妹妹穿的比我还像新娘。我一直安慰自己，他们只是感情好，可当我...
    茶点故事阅读 61,461评论 5赞 358
  • 恶毒庶女顶嫁案：这布局不是一般人想出来的
    文/花漫 我一把揭开白布。 她就那样静静地躺着，像睡着了一般。 火红的嫁衣衬着肌肤如雪。 梳的纹丝不乱的头发上，一...
    开封第一讲书人阅读 46,351评论 1赞 273
  • 城市分裂传说
    那天，我揣着相机与录音，去河边找鬼。 笑死，一个胖子当着我的面吹牛，可吹牛的内容都是我干的。 我是一名探鬼主播，决...
    沈念sama阅读 36,776评论 3赞 387
  • 双鸳鸯连环套：你想象不到人心有多黑
    文/苍兰香墨 我猛地睁开眼，长吁一口气：“原来是场噩梦啊……” “哼！你这毒妇竟也来了？” 一声冷哼从身侧响起，我...
    开封第一讲书人阅读 35,414评论 0赞 255
  • 万荣杀人案实录
    序言：老挝万荣一对情侣失踪，失踪者是张志新（化名）和其女友刘颖，没想到半个月后，有当地人在树林里发现了一具尸体，经...
    沈念sama阅读 39,722评论 1赞 294
  • 护林员之死
    正文 独居荒郊野岭守林人离奇死亡，尸身上长有42处带血的脓包…… 初始之章·张勋 以下内容为张勋视角 年9月15日...
    茶点故事阅读 34,760评论 2赞 314
  • 白月光启示录
    正文 我和宋清朗相恋三年，在试婚纱的时候发现自己被绿了。 大学时的朋友给我发了我未婚夫和他白月光在一起吃饭的照片。...
    茶点故事阅读 36,537评论 1赞 326
  • 活死人
    序言：一个原本活蹦乱跳的男人离奇死亡，死状恐怖，灵堂内的尸体忽然破棺而出，到底是诈尸还是另有隐情，我是刑警宁泽，带...
    沈念sama阅读 32,381评论 3赞 315
  • 日本核电站爆炸内幕
    正文 年R本政府宣布，位于F岛的核电站，受9级特大地震影响，放射性物质发生泄漏。R本人自食恶果不足惜，却给世界环境...
    茶点故事阅读 37,787评论 3赞 300
  • 男人毒药：我在死后第九天来索命
    文/蒙蒙 一、第九天 我趴在偏房一处隐蔽的房顶上张望。 院中可真热闹，春花似锦、人声如沸。这庄子的主人今日做“春日...
    开封第一讲书人阅读 29,030评论 0赞 19
  • 一桩弑父案，背后竟有这般阴谋
    文/苍兰香墨 我抬头看了看天上的太阳。三九已至，却和暖如春，着一层夹袄步出监牢的瞬间，已是汗流浃背。 一阵脚步声响...
    开封第一讲书人阅读 30,304评论 1赞 252
  • 情欲美人皮
    我被黑心中介骗来泰国打工， 没想到刚下飞机就差点儿被人妖公主榨干…… 1. 我叫王不留，地道东北人。 一个月前我还...
    沈念sama阅读 41,734评论 2赞 342
  • 代替公主和亲
    正文 我出身青楼，却偏偏与公主长得像，于是被迫代替她去往敌国和亲。 传闻我的和亲对象是个残疾皇子，可洞房花烛夜当晚...
    茶点故事阅读 40,943评论 2赞 336