11.Java 基础 - 泛型

最新推荐文章于 2018-02-08 17:35:01 发布
最新推荐文章于 2018-02-08 17:35:01 发布
阅读量947 收藏
点赞数
分类专栏： Java SE Java SE 文章标签： Java 泛型
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u012420654/article/details/51910196
版权

基本概念

泛型的本质是参数化类型（Parameterized Type）的应用，也就是说所操作的数据类型被指定为一个参数，在用到的时候在指定具体的类型。

这种参数类型可以用在类、接口和方法的创建中，分别称为泛型类、泛型接口和泛型方法。

1.发展

在 JDK 1.5 之前，只能通过 Object 是所有类型的父类和类型强制转换两个特点的配合来实现类型泛化。

因此在编译期间，编译器无法检查这个 Object 的强制转型是否成功，这样容导致发生 ClassCastException （强制转换异常） 。

下面我们来看一个实例，就能知道泛型的作用：

  • 不使用泛型的情况（1.5 之前）
ArrayList arrayList = new ArrayList();
arrayList.add(100);
arrayList.add("abc");

//因为不知道取出来的值的类型，类型转换的时候容易出错  
String str = (String) arrayList.get(0);
  • 使用泛型的情况（1.5 之后）
ArrayList<String> arrayList = new ArrayList<String>();
arrayList.add("abc");

//因为限定了类型，所以不能添加整形,编译器会提示出错
arrayList.add(100);

2.术语

// 以 ArrayList<E>,ArrayList<Integer> 为例：

ArrayList<E>：泛型类型

E：类型变量（或者类型参数）

ArrayList<Integer> ：参数化的类型

Integer：类型参数的实例（或实际类型参数）

ArrayList ：原始类型

3.探究

泛型类

class Demo<T> {
    private T value;

    Demo(T value) {
        this.value = value;
    }

    public T getValue() {
        return value;
    }

    public void setValue(T value) {
        this.value = value;
    }
}

public class Test {
    public static void main(String[] args) {
        Demo<String> demo = new Demo("abc");
        demo.setValue("cba");
        System.out.println(demo.getValue()); // cba
    }
}

泛型接口

interface Demo<K, V> {
    void print(K k, V v);
}

class DemoImpl implements Demo<String, Integer> {

    @Override
    public void print(String k, Integer v) {
        System.out.println(k + "-" + v);
    }
}

public class Test {
    public static void main(String[] args) {
        Demo<String, Integer> demo = new DemoImpl();
        demo.print("abc", 100);
    }
}

泛型方法

public class Test {
    public static void main(String[] args) {
        int num = get("abc", 100);
        System.out.println(num);
    }

    // 关键 --> 多了 <K, V> ，可以理解为声明此方法为泛型方法
    public static <K, V> V get(K k, V v) {

        if (k != null) {
            return v;
        }
        return null;
    }
}

类型限定

类型限定在泛型类、泛型接口和泛型方法中都可以使用，不过要注意下面几点：

  • 不管该限定是类还是接口，统一都使用关键字 extends

  • 可以使用 & 符号给出多个限定

  • 如果限定既有接口也有类，那么类必须只有一个，并且放在首位置。例如：

public static <T extends Comparable&Serializable> T get(T t1,T t2)

下面再来分析下类型限定的作用…

1.不对类型参数设置界限

观察下面的代码，在没有对类型参数进行类型限定时会出现编译错误。原因如下：

  • 因为在编译之前，编译器并不能确认泛型类型（T）是什么类型

  • 因此它默认 T 为原始类型（Object）。

  • 所以只能调用 Object 的方法，而不能调用 compareTo 方法。

public static <T> T get(T t1,T t2) {
    //编译错误
    if(t1.compareTo(t2)>=0);
    return t1;
}

2.对类型参数设置界限

当对类型参数 T 设置界限（bound）后，编译错误不再发生。因为此时编译器默认 T 的原始类型为 Comparable。

public static <T extends Comparable> T get(T t1,T t2) {
    if(t1.compareTo(t2)>=0);
    return t1;
}

类型擦除

  • Java 中的泛型基本上都是在编译器这个层次来实现的。

  • 在生成的 Java 字节码中是不包含泛型中的类型信息的。

  • 使用泛型时加上的类型参数，会在编译器在编译的时候去掉，这个过程就称为类型擦除。

来看下面的这个例子：

public class Test {
    public static void main(String[] args) {
        ArrayList<String> arrayList1 =new ArrayList<String>();
        ArrayList<Integer> arrayList2 = new ArrayList<Integer>();
        // true
        System.out.println(arrayList1.getClass() == arrayList2.getClass());
    }
}

观察代码，这里定义了两个ArrayList数组：

  • 一个是ArrayList泛型类型，只能存储字符串，一个是ArrayList泛型类型，只能存储整形。

  • 通过比较它们的类对象，发现结果为 true。

  • 说明泛型类型 String 和 Integer 在编译过程中都被擦除掉了，只剩下了原始类型（即 Object）。

再来看一个例子：

public class Test {
    public static void main(String[] args) throws Exception{
        ArrayList<String> arrayList =new ArrayList<String>();
        arrayList.add("abc");
        arrayList.getClass().getMethod("add", Object.class).invoke(arrayList, 100);
         for (int i=0;i<arrayList.size();i++) {  
                System.out.println(arrayList.get(i));  
            }  
    }
}

观察代码，这里定义了一个ArrayList 泛型类型实例化为 Integer 的对象

  • 如果直接调用 add 方法，那么只能存储整形的数据。

  • 利用反射调用 add 方法，却可以存储字符串。

  • 说明 Integer 泛型实例在编译之后被擦除了，只保留了原始类型。

1.原始类型

  • 原始类型（raw type）就是擦除去了泛型信息，最后在字节码中的类型变量的真正类型。

  • 任意一个泛型的类型参数，都存在对应的原始变量。

  • 一旦类型变量被擦除（crased），就会使用其限定类型（无限定的变量用 Object）替换。

// 此时 T 是一个无限定类型，所以原始类型就是 Object
class Pair<T> { } 

// 类型变量有限定，原始类型就用第一个边界的类型变量来替换,即Comparable
class Pair<T extends Comparable& Serializable> { }  

// 此时原始类型为 Serializable，编译器在必要的时要向 Comparable 插入强制类型转换
// 为了提高效率，应该将标签（tagging）接口（即没有方法的接口）放在边界限定列表的末尾
class Pair<T extends Serializable&Comparable>

2.类型参数的类型

在下面的例子中，类型参数指 T，T 的类型就是所谓的【类型参数】的类型。

观察代码，可以得出如下结论：

  • 不指定【类型参数 T 】的类型，当参数的类型不一致时，原始类型取同一父类的最小级

  • 指定【类型参数 T 】的类型时，原始类型只能为其指定的类型或类型的子类

public class Test {

    // 定义泛型方法
    public static <T> T add(T x, T y) {
        return y;
    }

    public static void main(String[] args) {

        // 1.不指定泛型

        // 两个参数都是 Integer，所以 T 为 Integer 类型
        int i = Test.add(1, 2); 

        // 两个参数分别是 Integer，Float，取同一父类的最小级，T 为 Number 类型
        Number f = Test.add(1, 1.2);

        // T 为 Object
        Object o = Test.add(1, "asd");

        // 2.指定泛型

        // 指定了Integer，所以只能为 Integer 类型或者其子类
        int a = Test.<Integer> add(1, 2);

        //编译错误，指定了 Integer，不能为Float
        int b=Test.<Integer>add(1, 2.2); 

         // 指定为Number，所以可以为 Integer，Float
        Number c = Test.<Number> add(1, 2.2);
    }

}

3.类型检查

泛型的类型检查是针对引用的，而不针对被引用的对象本身。

在下面的例子中，list 是引用对象，因此类型检查是针对它的。

// 没有进行类型检查，等价于 ArrayList list = new ArrayLis()
ArrayList list = new ArrayList<String>();
list.add(100);
list.add("hello");

// 进行编译检查，等价于 ArrayList<String> list = new ArrayList<String>();
ArrayList<String> list = new ArrayList();
list.add("hello");
list.add(100);  // 编译错误

4.类型擦除与多态的冲突

来看下面的例子，这里定义了一个泛型类 Parent，一个实现它的子类 Son，并在子类中重写了父类的方法。

class Parent<T> {
    private T value;

    public T getValue() {
        return value;
    }

    public void setValue(T value) {
        this.value = value;
    }
}

class Son extends Parent<String>{
    @Override
    public void setValue(String value) {
         super.setValue(value);
    }
    @Override
    public String getValue(){
        return super.getValue();}
    }

在上面提到过泛型的类型参数在编译时会被类型擦除，因此编译后的 Parent 类如下：

class Parent {
    private Object value;

    public Object getValue() {
        return value;
    }

    public void setValue(Object value) {
        this.value = value;
    }
}

此时对比 Parent 与 Son 的 getValue/setValue 方法，发现方法的参数类型已经改变，从 Object -> String，这也意味着不是重写（overrride） 而是重载（overload）。

然而调用 Son 的 setValue 方法， 发现添加 Object 对象时编译错误。说明也不是重载。

public class Test {
    public static void main(String[] args) {
        Son son = new Son();
        son.setValue("hello");
        // 关键 -->编译错误
        son.setValue(new Object());
    }
}

那么问题来了，通过上面的分析？Son 中定义的方法到底是重写还是重载？答案是：重写。这里 JVM 采用了桥方法（Brige）来解决类型擦除和多态引起的冲突。

我们对 Son 进行反编译（”Javap -c 类名.class”），得到如下内容：

Compiled from "Test.java"
class Son extends Parent<java.lang.String> {
  Son();
    Code:
       0: aload_0       
       1: invokespecial #8                  // Method Parent."<init>":()V
       4: return        

  public void setValue(java.lang.String);
    Code:
       0: aload_0       
       1: aload_1       
       2: invokespecial #16                 // Method Parent.setValue:(Ljava/lang/Object;)V
       5: return        

  public java.lang.String getValue();
    Code:
       0: aload_0       
       1: invokespecial #23                 // Method Parent.getValue:()Ljava/lang/Object;
       4: checkcast     #26                 // class java/lang/String
       7: areturn       

  public java.lang.Object getValue();
    Code:
       0: aload_0       
       1: invokevirtual #28                 // Method getValue:()Ljava/lang/String;
       4: areturn       

  public void setValue(java.lang.Object);
    Code:
       0: aload_0       
       1: aload_1       
       2: checkcast     #26                 // class java/lang/String
       5: invokevirtual #30                 // Method setValue:(Ljava/lang/String;)V
       8: return        
}

发现这里共有 4 个 setValue/getValue 方法，除了 Son 表面上重写的 String 类型，编译器又自己生成了 Object 类型的方法，也称为桥方法。结果就是，编译器通过桥方法真正实现了重写，只是在访问时又去调用表面的定义的方法。

注意事项

  • 不能用基本类型实例化类型参数，可以用对应的包装类来实例化类型参数
// 编译错误
ArrayList<int> list = new ArrayList<int>();

// 正确写法
ArrayList<Integer> list = new ArrayList<Integer>();
  • 参数化类型的数组不合法
Demo<T >{
}

public class Test {
    public static void main(String[] args) {
        // 编译错误 --> 类型擦除导致数组变成 Object []，因此没有意义
        Demo<String>[ ]  demo =new Demo[10];
    }
}
  • 不能实例化类型变量
// 编译错误，需要类型参数需要确定类型
Demo<T> demo = new Demo<T>
  • 泛型类的静态上下文中不能使用类型变量
public class Demo<T> {
    public static T name;
    public static T getName() {
        ...
    }
}
  • 不能抛出也不能捕获泛型类的对象
//异常都是在运行时捕获和抛出的，而在编译的时候，泛型信息全都会被擦除掉。会导致这里捕获的类型一致

try{  
}catch(Problem<Integer> e1){  
    //do Something... 
}catch(Problem<Number> e2){  
    // do Something ...
}

参考

oxf
关注
专栏目录
（46）Java基础 --泛型
kulr_w的博客
03-04 1329
一、泛型的概述 定义 广泛的类型，在定义一个类的时候，类型中有些方法参数、返回值类型不确定，就使用一个符号，来表示那些尚未确定的类型，这个符号，就称为泛型。 使用 对于有泛型的类型，在这些类型后面跟上尖括号，尖括号里面写上泛型的确定类型（在使用某个类创建对象时，已经可以确定这个具体的类型了，那么就直接写出具体类型）。 例如：List<Integer> al = new ArrayList<Integer>(); 泛型的好处 ...
解放双手——Android自动化测试
eclipse_xu
05-11 6万+
人们懒的走路，才创造了汽车； 人们懒的爬楼，才创造了电梯； 人们懒的扫地，才创造了自动扫地机器人。 人类的进步，离不开这些喜欢偷懒的人，现在，程序猿将偷懒上升到了一个新的高度——利用程序来进行自动化软件测试，将测试工程师从繁琐的测试用例中解脱出来，从此可以一边喝着咖啡，一边看着程序自动测试，不必看着测试用例重复无数次的测试步骤，也不必担心操作失误而导致不必要的错误，更不用担心压力测试而导致的身心俱疲。想了解程序猿是如
深入浅出RxJava三--响应式的好处
大头鬼Bruce
04-05 8万+
原文链接在第一篇中，我介绍了RxJava的基础知识。第二篇中，我向你展示了操作符的强大。但是你可能仍然没被说服。这篇里面，我讲向你展示RxJava的其他的一些好处，相信这篇足够让你去使用Rxjava.错误处理到目前为止，我们都没怎么介绍onComplete()和onError()函数。这两个函数用来通知订阅者，被观察的对象将停止发送数据以及为什么停止（成功的完成或者出错了）。下面的代码展示了怎么使用
Java面试题全集（上）
热门推荐
骆昊的技术专栏
04-08 166万+
2013年年底的时候，我看到了网上流传的一个叫做《Java面试题大全》的东西，认真的阅读了以后发现里面的很多题目是重复且没有价值的题目，还有不少的参考答案也是错误的，于是我花了半个月时间对这个所谓的《Java面试大全》进行了全面的修订并重新发布在我的CSDN博客。
学习、探究Java设计模式——观察者模式
蓝天白云梦的csdn博客
09-06 1874
前言观察者模式是面向对象编程中较为常用的一种设计模式，观察者模式又称为订阅-发布模式，特别是适用于GUI图形界面中，比如Android的View中就大量使用了此模式。那么观察者模式到底是什么以及我们应该怎么使用它呢？相信通过本文的学习，你们会有一个更为清晰的答案。定义 观察者模式：定义了对象之间的一对多依赖，当一个对象改变状态时，它的所有依赖者都会收到通知并自动更新。 由以上的定义，我们可以知道
Java设计模式——桥模式
weixin_30914981的博客
03-31 228
概述 桥模式（Bridge）是为了解决将抽象部分与实现部分分离，好让他们都在自己的维度上有多维度地变化。这句话是好理解的，只是我在学习完桥模式之后，存在一些疑问，还好现在想通了。现在我就桥模式的设计思想和我的疑问一并发出，希望于你有益。 版权说明 著作权归作者所有。 商业转载请联系作者获得授权，非商业转载请注明出处。 本文作者：Coding-Naga 发表日...
大学课程讲义-Java基础-泛型.docx
最新发布
08-14
Java泛型是Java编程语言中的一种特性，它允许在数据结构（如集合）中存储特定类型的元素，从而提供了编译时的类型安全性和更清晰的代码。泛型引入的主要目标是...理解并熟练使用泛型是每个Java开发者的基础技能之一。
java基础-泛型学习总结
03-12
思维导图
java基础-泛型通配符
03-12
java基础-泛型通配符
Java 基础(4-8) - 泛型机制详解.pdf
06-28
11. **异常中使用泛型**：可以创建泛型异常，如`throw new MyException(value)`，但需要确保异常处理时能够正确捕获。 12. **获取泛型的参数类型**：在运行时无法直接获取泛型参数类型，但可以通过反射API间接获取...
［Android Studio 权威教程］断点调试和高级调试
ZeroFlutter
06-15 4万+
有人说Android 的调试是最坑的，那我只能说是你不会用而已，我可以说Android Studio的调试是我见过最棒的。 好了开始写一个简单的调试程序，我们先来一个for循环 for (int i = 0; i < 10; i++) { //获取当前i的值 int selector = i; //打log查看当前i的值（此步多余，实际开发请忽略） Logger.e("fo
android高仿微信表情输入与键盘输入(详细实现分析)
zejian的博客
08-05 4万+
转载请注明出处： http://blog.csdn.net/javazejian/article/details/52126391  最近公司在项目上要使用到表情与键盘的切换输入，自己实现了一个，还是存在些缺陷，比如说键盘与表情切换时出现跳闪问题，这个相当困扰我，不过所幸在Github（其中一个不错的开源项目，其代码整体结构很不错）并且在论坛上找些解决方案，再加上我也是研究了好多个开源项目的代码，
仿斗鱼直播的弹幕效果实现
郭霖
10-18 3425
有朋友在公众号里问过我，像直播的那种弹幕效果该如何实现？这篇文章给你答案。
Spring中原型prototype的准确使用
只作为个人备忘录
11-07 1315
实际问题 项目中，报表导出涉及到了在同一个类的两个不同方法中，都有相同的查询数据库的操作，一个方法是用于获取内容，一个是用于获取条数的，大概类似于这样： @Service public class MyReportExporter extends AbstractReportExporter{ @Override protected DataResp getData(Param
JAVA常用数据结构及原理分析
lj745280746的专栏
06-26 5257
前不久面试官让我说一下怎么理解java数据结构框架，之前也看过部分源码，balabala讲了一堆，现在总结一下。java.util包中三个重要的接口及特点：List（列表）、Set（保证集合中元素唯一）、Map（维护多个key-value键值对，保证key唯一）。其不同子类的实现各有差异，如是否同步（线程安全）、是否有序。 常用类继承树： 以下结合源码讲解常用类实现原理及相互之间的差异。 Col
java调用matlab程序
It_BeeCoder的博客
09-17 2744
在实际Java编程中，我们可能想要使用matlab编写一些复杂的数值计算算法，然后导入我们的java项目中调用。这首先需要我们matlab的jdk版本和java项目的jdk版本对应一致。想查看matlabjdk版本，可以在matlab命令行中输入version -java来查看，会看到类似下面的内容: Java 1.7.0_60-b19 with Oracle Corporation Jav
java 面试题
yanlove_jing的专栏
05-19 1320
JAVA面试题 我看到了网上流传的一个叫做《Java面试题大全》的东西，认真的阅读了以后发现里面的很多题目是重复且没有价值的题目，还有不少的参考答案也是错误的，于是我花了半个月时间对这个所谓的《Java面试大全》进行了全面的修订并重新发布在我的CSDN博客。在修订的过程中，参照了当时JDK最新版本（Java 7）给出了题目的答案和相关代码，去掉了EJB 2.x、JSF等无用内容或过时
Java中字符串和整型的相互转换
Gone_with_the_wind91的博客
09-27 590
大多数情况下，用户通过文本框或者文本域提交自己的输入。用户通过文本框或文本域输入的内容通常是string格式的。而你常常需要的是这些内容的整数形式。例如，年龄，电话号码等等。为了使字符串转为整型或者整型转为字符串变得方便，Java提供了很多有用的并且简单的方法。在这篇文章中，我们将讨论字符串转整型和整型转字符串的不同方法。 Java中如何将字符串转化为整型 Java中有两个可选的方法用
Java集合---HashTable源码剖析
留下你的观点
02-08 218
Hashtable 概要与HashMap主要区别是Hashtable的put，get方法都是同步的，线程安全，但是性能较差 key和value都不能为null，HashMap中key与value都可以为 null 与HashMap类似，key必须实现hashCode()和equals方法，由于equals判断前都会先判断hashCode方法是否相等，两个equals的对象的hashCode()必须...
Java基础-泛型详解
"这份大学课程讲义主要介绍了Java编程中的泛型概念，旨在提高代码的类型安全性、可读性和稳定性。泛型允许程序员在编写代码时指定容器（如List）所容纳的对象类型，从而在编译阶段就能检测出类型错误，避免了运行时...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

oxf

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值