浅析~Java泛型

1、Java中的泛型

思维导图

Java泛型.jpg

1.1、为什么要使用泛型

例如下面这个例子，如果list不加泛型，先向其添加两个String的值，再向其中添加一个Integer的值，这是完全可以的，因为这是list默认的类型是Object的；但是平时开发当中，可能忘了还传入了一个Integer的类型，就会导致如下的错误：

public static void main(String[] args) {
        List list = new ArrayList();
        list.add("111");
        list.add("222");
        list.add(333);

        for (int i = 0; i < list.size(); i++) {
            String value = (String) list.get(i);
            System.out.println("value : " + value);
        }
    }
OUTPUTS
value : 111
value : 222
Exception in thread "main" java.lang.ClassCastException: java.lang.Integer cannot be cast to java.lang.String
    at com.hzf.javatest.fanxing.TypeMain.main(TypeMain.java:15)

泛型的好处：
（1）适用于多种数据类型执行相同的代码
（2）泛型中的类型在使用时指定，不需要强制类型转换

1.2、泛型类和泛型接口

泛型，即“参数化类型”，只不过由具体类型的参数变为了变量参数。可以通过<T>来表示（其他大写字母都可以，不过常用的是T、E、K、V）；这种参数类型可以用在类、接口和方法中，分别称为泛型类、泛型接口、泛型方法。

public class TypeClass<T> {

    private T data;

    public T getData() {
        return data;
    }

    public void setData(T data) {
        this.data = data;
    }

}

//泛型接口
public interface TypeInterface<T> {
    T next();
}

public class TypeMain implements TypeInterface<String>{

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

1.3、泛型方法

在泛型类中的方法不一定为泛型方法，他可以用在任何地方和任何场景，包括普通类和泛型类。
泛型方法一定要在权限限定符和返回值中间加上<T>，表明这是一个泛型方法。

public class TypeMain {

    public <T> T typeMethod(T... a) {
        return a[a.length / 2];
    }

    public static void main(String[] args) {
        TypeMain typeMain = new TypeMain();
        System.out.println(typeMain.typeMethod("111", "222", "333"));
        System.out.println(typeMain.typeMethod(1, 2, 3));
    }

}
OUTPUTS
222
2

1.4、限定类型变量

在开发过程中，我们有时候需要对变量类型加以约束，比如比较最大值、最小值

public <T> T min(T a, T b) {
        if (a.compareTo(b) > 0) {
            return a;
        }
        return b;
    }

上面的例子程序compare再调用时，编译会出错；那么有没有一种方式可以对变量加以约束呢？我们可以使用T extends Comparable，T表示应该绑定类型的子类型，Comparable表示绑定类型，子类型和绑定类型可以是类也可以是接口。

public <T extends Comparable> T min(T a, T b) {
        if (a.compareTo(b) > 0) {
            return a;
        }
        return b;
    }

加以约束之后，如果在min中传入非Comparable的子类型就会报错。
extends左右都可以有多个（如 T,V extends Comparable & Serializable），但是限定类型中，只允许有一个类，并且这个类必须是限定列表的第一个（extends 后面如果有多个，必须将类放在第一个）,这种类的限定既可以用在泛型方法上也可以用在泛型类中。

2、泛型中的约束和局限性

（1）不能实例化泛型变量，例如new T()
（2）不能用基本类型实例化类型参数，例如TypeClass<double>，只能TypeClass<Double>
（3）运行时类型查询只适用于原始类型

        TypeMain<String> typeMainString = new TypeMain<>();
        TypeMain<Double> typeMainDouble = new TypeMain<>();
        System.out.println(typeMainString instanceof TypeMain);
        //以下两种方式都不被允许
//        System.out.println(typeMainString instanceof TypeMain<String>);
//        System.out.println(typeMainString instanceof TypeMain<T>);
        System.out.println(typeMainString.getClass() == typeMainDouble.getClass());
        System.out.println(typeMainDouble.getClass().getName());
OUTPUTS
true
true
com.hzf.javatest.fanxing.TypeMain

（4）不能用于静态域或者静态方法中

public class TypeMain<T> {
    private static T value;//编译报错
    private T value2;//OK 

    public static void main(String[] args) {
        T data;//编译报错
    }
    public void test(){
        T data; //OK
    }
}

之所以不能用于静态域或者静态方法中，是由于泛型是要在对象创建的时候才知道是什么类型的，而static的域早于类的构造函数，因此在这时虚拟机不知道T指的是什么
但是静态的泛型方法是可以的，因为在静态泛型方法创建的时候，不需要知道T具体指什么，当我们通过类名调用时，自然虚拟机就知道T具体的含义了。
（5）不能创建参数化类型的数组

        TypeMain<String>[] typeArrays = new TypeMain<String>[10];//这里是编译不过的；但是如果假如这里可以
        Object[] objArrays = typeArrays;//经过泛型擦除后会变成Object

Object是所有类的顶层父类，也就是typeArrays理论上就可以存放Double、Integer等其他非String的对象，那么就破坏了泛型引入的原则（规范参数）
（6）泛型类不能extends Exception或者Throwable
由于类型擦除的原因，加入泛型类可以继承自Exception的话，那么我们抛出someError<Integer>和somError<String>会统一被擦除成为somError，显然是不合适的

但是这种是可以的
public <T extends Throwable> void doWork(T t) throws T {
        try {

        } catch (Throwable e) {
            throw t;
        }
    }

3、泛型类型的继承规则

 public static void main(String[] args) {
        TypeMain<Fruit> typeMain = new TypeMain<Apple>();
    }

Apple是Fruit的子类，但是上面这行代码在编译期间就会报错，因为TypeMain<Fruit>和TypeMain<Apple>之间没有继承关系，没有什么关系。
但是泛型类可以继承或者扩展其他的泛型类，例如List和ArrayList

public class ArrayList<E> extends AbstractList<E>
        implements List<E>, RandomAccess, Cloneable, java.io.Serializable

4、通配符类型

泛型的继承规则可能会导致一个问题，比如下面代码

public class TypeClass<T> {

    private T data;

    public T getData() {
        return data;
    }

    public void setData(T data) {
        this.data = data;
    }

}

public class TypeMain {

    private static void print(TypeClass<Fruit> t){
        System.out.println(t.getData());
    }


    public static void main(String[] args) {
        TypeClass<Fruit> typeFruit = new TypeClass<>();
        print(typeFruit);

        TypeClass<Apple> typeApple = new TypeClass<>();
        print(typeApple);//这里不允许
    }

}

由于print函数限定的参数只能是Fruit类型的TypeClass对象，所以即使Apple是Fruit的子类，print(typeApple也是不被允许的)，于是引入了通配符类型 ？
? extends X 表示类型的上界，类型参数是X的子类
？super X 表示类型的下界，类型参数是X的超类

4.1、？extends X

表示传递给方法的参数只能是X的子类，包括X本身
还是上面那个例子，如果把print()函数修改成

private static void print(TypeClass<? extends Fruit> t){
        System.out.println(t.getData());
    }

在使用Fruit子类类型的TypeClass传入就不会报错了。
但是当创建了TypeClass<? extends Fruit>对象后，我们使用这个对象的setData方法传入new Apple和new Fruit会发现编译报错

public static void main(String[] args) {
        TypeClass<? extends Fruit> typeClass = new TypeClass<>();
        typeClass.setData(new Apple());//编译报错
        typeClass.setData(new Fruit());//编译报错
        
        Fruit fruit = typeClass.getData();//OK 
        Apple apple = (Apple) typeClass.getData(); //OK 
    }

这是由于？extends X规定了上界，也就是当我们从TypeClass<? extends Fruit>中取元素时，编译器是可以知道取出的元素一定是Fruit或者Fruit的子类，因此getData不会报错；但是编译器不会知道setData中传入的类型具体是谁的子类，说明? extends X 可以用来安全的访问数据

4.2、？super X

表示传入的参数必须是X的超类，包括X本身

public class TypeMain {

    private static void print(TypeClass<? super Apple> t){
        System.out.println(t.getData());
    }
    public static void main(String[] args) {
        TypeClass<Fruit> fruitTypeClass = new TypeClass<>();
        TypeClass<Apple> appleTypeClass = new TypeClass<>();
        //littleApple是Apple的子类
        TypeClass<LittleApple> littleAppleTypeClass = new TypeClass<>();
        
        print(fruitTypeClass);
        print(appleTypeClass);
        print(littleAppleTypeClass);//编译报错
    }

}

public static void main(String[] args) {
        TypeClass<Fruit> fruitTypeClass = new TypeClass<>();
        TypeClass<Apple> appleTypeClass = new TypeClass<>();
        //littleApple是Apple的子类
        TypeClass<LittleApple> littleAppleTypeClass = new TypeClass<>();

        TypeClass<? super Apple> typeClass = new TypeClass<>();
        typeClass.setData(new LittleApple());
        typeClass.setData(new Apple());
        typeClass.setData(new Fruit());//编译报错

        //getData得到的类型肯定是Apple的超类，但是具体是哪一个类不知道
        //因此getData默认类是Object
        Object data = typeClass.getData();
    }

这里是懵逼的~ ？super Apple，规定了下界是Apple，但是为什么setData却可以传入Apple的子类型
先以getData为例，？ super Apple规定了下界，因此getData得到的类型一定是高于等于Apple的，但是具体是哪一个类型，不知道...所以编译器这里默认使用的是Object来接收getData的值；
对于setData来说，之所以设置的值只能是Apple的子类，是因为Apple的子类，比如LittleApple或者Apple自身，是可以安全的转型为Apple的，而Fruit不能够转型为Apple，通过代码来说就是

Fruit f = new Apple();
Apple apple = (Apple) new Fruit();//这行会报ClassCastException异常

因此？super X 可以安全的写入数据，可以写入X及其子类型
有哪位大神这里有更好的解释，可以随时给我留言~

5、虚拟机如何实现泛型

虚拟机实现泛型的主要原理就是类型擦除

//这段方法编译报错
    private static String method(List<String> list) {
        return "";
    }

    private static Integer method(List<Integer> list) {
        return 0;
    }

上述代码是不能被编译的，因为List<String>和List<Integer>编译之后都被擦除了，变成了一样的原生类型List<E>,擦除动作导致这两种方法的特征签名变得一模一样。
由于Java泛型的引入，各种场景（虚拟机解析、反射等）下的方法调用都可能对原有的基础产生影响和新的需求，如在泛型类中如何获取传入的参数化类型等。因此，JCP组织对虚拟机规范做出了相应的修改，引入了诸如Signature、LocalVariableTypeTable等新的属性用于解决伴随泛型而来的参数类型的识别问题，Signature是其中最重要的一项属性，它的作用就是存储一个方法在字节码层面的特征签名[3]，这个属性中保存的参数类型并不是原生类型，而是包括了参数化类型的信息。修改后的虚拟机规范要求所有能识别49.0以上版本的Class文件的虚拟机都要能正确地识别Signature参数。

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