关于Java泛型深入理解小总结

1、何为泛型

首先泛型的本质便是类型参数化,通俗的说就是用一个变量来表示类型,这个类型可以是String,Integer等等不确定,表明可接受的类型,原理类似如下代码

int pattern; //声明一个变量未赋值,pattern可以看作是泛型
pattern = 4;
pattern = 5;//4和5就可以看作是String和Integer

泛型的具体形式见泛型类、泛型方法

  *泛型类形式如下

class Test<T>
{
    private T t;
    Test(T t)
    {
        this.t = t;
    }
    public  T getT()
    {
        return t;
    }

    public void setT(T t)
    {
        this.t = t;
    }
}

  *泛型方法举例代码如下

public <T> void show()
{
    operation about T...
}

泛型参数类型声明必须在返回类型之前

2、为何要引入泛型,即泛型与Object的优势

由于泛型可以接受多个参数,而Object经过强制类型转换可以转换为任何类型,既然二者都具有相同的作用,为何还要引进泛型呢?

解答:泛型可以把使用Object的错误提前到编译后,而不是运行后,提升安全性。以下用带泛型的ArrayList和不带泛型的Arraylist举例说明

代码1:

ArrayList al = new ArrayList();
al.add("hello");
al.add(4);//自动装箱
String s1 = (String)al.get(0);
String s2 = (String)al.get(1);//在编译时没问题,但在运行时出现问题

首先声明无泛型的ArrayList时,其默认的原始类型是Object数组,既然为Object类型,就可以接受任意数据的赋值,因此编译时没有问题,但是在运行时,Integer强转成String,肯定会出现ClassCastException.因此泛型的引入增强了安全性,把类转换异常提前到了编译时期。

3、类型擦除和原始类型

  *类型擦除的由来

在JAVA的虚拟机中并不存在泛型,泛型只是为了完善java体系,增加程序员编程的便捷性以及安全性而创建的一种机制,在JAVA虚拟机中对应泛型的都是确定的类型,在编写泛型代码后,java虚拟中会把这些泛型参数类型都擦除,用相应的确定类型来代替,代替的这一动作叫做类型擦除,而用于替代的类型称为原始类型,在类型擦除过程中,一般使用第一个限定的类型来替换,若无限定则使用Object.

  *对泛型类的翻译

泛型类(不带泛型限定)代码:

class Test<T>
{
    private T t;
    public void show(T t)
    {

    }
}

虚拟机进行翻译后的原始类型:

class Test
{
    private Object t;
    public void show(Object t)
    {

    }
}

泛型类(带泛型限定)代码: 

class Test<? extends Comparable>
{
    private T t;
    public void show(T t)
    {

    }
}

虚拟机进行翻译后的原始类型:

class Test
{
    private Comparable t;
    public void show(Comparable t)
    {

    }
}

 *泛型方法的翻译

class Test<T>
{
    private T t;
    public void show(T t)
    {

    }
}

class TestDemo extends Test<String>
{
    private String t;
    public void show(String t)
    {

    }
}

由于TestDemo继承Test<String>,但是Test在类型擦除后还有一个public void Show(Object t),这和那个show(String t)出现重载,但是本意却是没有show(Object t)的,

因此在虚拟机翻译泛型方法中,引入了桥方法,及在类型擦除后的show(Object t)中调用另一个方法,代码如下:

public void show(Object t)
{
    show((String) t);
}

4、泛型限定

  *泛型限定是通过?(通配符)来实现的,表示可以接受任意类型,那一定有人有疑问,那?和T(二者单独使用时)有啥区别了,其实区别也不是很大,仅仅在对参数类型的使用上。

例如:

public void print(ArrayList<?> al)
{
    Iterator<?> it = al.iterator();
    while(it.hasNext())
    {
        System.out.println(in.next());
    }
}

public <T> void print(ArrayList<T> al)
{
    Iterator<T> it = al.iterator();
    while(it.hasNext())
    {
        T t = it.next();  //区别就在此处,T可以作为类型来使用,而?仅能作为接收任意类型
        System.out.println(t);
    }
}

  *? extends SomeClass  这种限定,说明的是只能接收SomeClass及其子类类型,所谓的“上限”

  *? super SomeClass 这种限定,说明只能接收SomeClass及其父类类型,所谓的“下限”

一下举例? extends SomeClass说明一下这类限定的一种应用方式

由于泛型参数类型可以表示任意类型的类类型,若T要引用compareTo方法,如何保证在T类中定义了compareTo方法呢?利用如下代码:

public <T extends Comparable> shwo(T a, T b)
{
    int num = a.compareTo(b);
}

此处用于限定T类型继承自Comparable,因为T类型可以调用compareTo方法。

  *可以有多个类型限定,例如:

<T extends Comparable & Serializable>

这种书写方式为何把comparable写在前边?因为由于类型擦除的问题,原始类型是由Comparable替换的,因此写在前边的是类中存在此类型的泛型方法放在前边,避免调用方法时类型的强制转换,提高效率。

class Test<T extends Comparable & Serializable>
{
    private T lower;
    private T upper;

    public Test(T first, T second) //此处是利用Comparable的方法,因此把Comparable写在前边,类型擦除后为Comparable,若为Serializable,还得用强制类型转换,否则不能使用compareTo方法。
    {
        int a = first.compareTo(second);
        ...
    }
}

  *关于泛型类型限定的“继承”误区

总有些人误把类型的限定当作继承,比如:

//类型是这样的
<Student extends Person>
//然后出现此类错误
ArrayList<Person> al = new ArrayList<Student>();

此处的<Person>, <Student>作为泛型的意思是ArrayList容器的接收类型,用一个简单的例子来说明

ArrayList是一个大型养殖场,<Person>表明的是他能够接收动物,而上边的new语句生成的是一个只能够接收猪的养殖场(ArrayList<Student>),即把一个大型养殖场建造成了一个养猪场,若是继承的大型养殖场肯定是还能接受狗、羊....的,但是现在建造成了养猪场,那还能接受别的动物么?所以这肯定是错误的用法!简而言之,泛型new时两边的类型参数必须一致。

5、泛型的一些基本规则约束

  *泛型的类型参数必须为类的引用,不能用基本类型(int, short, long, byte, float, double, char, boolean)

  *泛型是类型的参数化,在使用时可以用作不同类型(此处在说泛型类时会详细说明)

  *泛型的类型参数可以有多个,代码举例如下:

public <T, E> void show()
{
    coding operation.....
}                

  *泛型可以使用extends, super, ?(通配符)来对类型参数进行限定

  *由于类型擦除,运行时类型查询只适用于原始类型,比如instanceof、getClass()、强制类型转换,a instanceof (Pair<Employe>),在类型擦除后便是 a instanceof Pair,因此以上运行的一些操作在虚拟机中操作都是对原始类型进行操作,无论写的多么虚幻,都逃不出类型擦除,因为在虚拟机种并不存在泛型。

  *不能创建参数化类型的数组

例如写如下代码:

Pair<String>[] table = new Pair<String>[10]; //ERROR
//让Object[] t指向table
Object[] t = table;
//向t中添加对象
t[0] = new Pair<Employe>();
//关键错误之处
String s = table[0];

由于Object可以接收任何类型,在里边存入 new Pari<Employe>时,没有任何问题,但是当取出的时候会出现ClassCastException,因此不能创建参数化类型数组。

  *不能实例化类型变量,及不能出现以下的类似代码

T t = new T();
//或
T.Class

因为在类型擦除后,便是Object t = new Object();与用意不符合,即本意肯定不是要调用Object.

  *不能再静态域或方法中出现参数类型

例如如下错误代码

class Test<T>
{
    private static T example;  //error
    public static void showExample() //error
    {
        action about T...
    }
    public static T showExample() //error
    {
        action about T....
     }
}    

首先方法是一个返回类型为T的普通方法,而非泛型方法,这和在静态方法中使用非静态参数是一样的,静态方法是先于对象而存在内存中的,因此在编译的时候,T的类型无法确定,一定会出现“Cannot make a static reference to a non_static reference”这样类似的错误。

但是这样的代码就是正确的

class Test<T>
{public static <T> T show()
    {
        action
    }
}

因为此处的静态方法是泛型方法,可以使用.

  *不能抛出或捕获泛型类的实例

    +不能抛出不能捕获泛型类对象

    +泛型类不能扩展Throwable,注意是类不能继承Throwable,类型参数的限定还是可以的。

    +catch子句不能使用类型变量,如下代码

try
{
    ....
}
catch(T e) //error
{
    ...
}

  *类型擦除后的冲突注意

例如:

class Pair<T>
{
    public boolean equals(T value) //error
    {
        ....
    }
}

此处的错误的原因不能存在同一个方法,在类型擦除后,Pair的方法为,public boolean equals(Object value),这与从Object.class中继承下来的equals(Object obj)冲突。

  *一个类不能成为两个接口类型的子类,而这两个接口是同一接口的不同参数化。

例如:

class Calendar implements coparable<Calendar>{}

class GregorianCalendar extends Calendar implements Comparable<GregorianCalendar>{} //error

当类型擦除后,Calendar实现的是Comparable,而GregorianCalendar继承了Calendar,又去实现Comparable,必然出错!

———————————————————————————————————————————————————————————————————————————————

先总结到此处。

时间: 2024-10-11 16:48:46

关于Java泛型深入理解小总结的相关文章

对java泛型的理解

自jdk1.6之后泛型就被广泛使用了,刚开始也是这么稀里糊涂的学了但是老是搞不懂其中的奥妙,后来随着项目经验的增多慢慢的才体会到了泛型的各种好处,看了不少项目封装的底层才发现原来泛型一般和接口混合使用来满足标准制定和参数多样化这样的代码需求.弄清楚之后我自己也动手实际体验了一下,觉得还是挺简单的.接下来就分享下我学泛型的心得,写的不好大家可以指出来. 1 标识接口 虽然叫标识接口但是这个java类不仅仅局限于interface,class也是OK的,选择接口还是类关键看自己的选择:下面是我定义的

Java:泛型的理解

本文源自参考<Think in Java>,多篇博文以及阅读源码的总结 前言 Java中的泛型每各人都在使用,但是它底层的实现方法是什么呢,为何要这样实现,这样实现的优缺点有哪些,怎么解决泛型带来的问题.带着好奇,我查阅资料进行了初步的学习,在此与诸位探讨. 一 类型参数 学过JAVA的人都知道泛型,明白大概怎么使用.在类上为:class 类名 {},在方法上为:public void 方法名 (T x){}.泛型的实现使得类型变成了参数可以传入,使得类功能多样化. 具体可分为5种情况: T是

Java泛型深入理解

Java泛型是Java1.5引入的新特性,泛型的本质是参数化类型,也就是说所操作的数据类型被指定为一个参数.这种参数类型可以用在类.接口和方法的创建中,分别称为泛型类.泛型接口.泛型方法.泛型的类型参数只能是类(引用)类型(包括自定义类),不能是基本数据类型.Java语言引入泛型的好处是安全简单. 转载自:http://www.cnblogs.com/lwbqqyumidi/p/3837629.html

java泛型的理解

最近在看视频,看到比较经典的比大小问题.输入两个数,返回大的数,类型可以为int,long,float等. 通常的教程中用这个例子引入了构造函数以及重载的概念,在学习完泛型后,我想到能不能写一个泛型的方法,用以实现比较. 为了完成这个任务,我们首先需要了解一下泛型. 什么的泛型 泛型是java语言系统的一种扩展,支持创建可以按照类型进行参数化的类. 泛型的好处 泛型的好处也是显而易见的, 首先可以扩充代码的通用性,通过泛型可以使方法支持更多的类型. 泛型有助于增强类型安全,编译器可以对类型进行比

java 泛型深入理解

学习java开始接触到泛型是在容器的时候,如没有使用泛型 List list = new ArrayList(); list.add(1); list.add("1"); list.forEach(x-> System.out.println(x));//编译器不会报错,但是在输出list的时候要注意类型检查. 使用泛型 List<String> list = new ArrayList<String>(); list.add(1); list.add(&

理解Java泛型 通配符 ? 以及其使用

什么是泛型: 泛型从字面上理解,是指一个类.接口或方法支持多种类型,使之广泛化.一般化和更加通用.Java中使用Object类来定义类型也 能实现泛型,但缺点是造成原类型信息的丢失,在使用中容易造成ClassCastException. Java泛型带到的好处: 使得一个类或方法中的类型参数化,最终达到代码复用的效果.( 不使用泛型,你可能需要每种情况的类或方法都要定义一遍 ) 实现类型检查的功能,避免ClassCastException.(这是相对于使用Object类型实现泛型而言.因为我可以

一个小栗子聊聊JAVA泛型基础

背景 周五本该是愉快的,可是今天花了一个早上查问题,为什么要花一个早上?我把原因总结为两点: 日志信息严重丢失,茫茫代码毫无头绪. 对泛型的认识不够,导致代码出现了BUG. 第一个原因可以通过以后编码谨慎的打日志来解决,我们今天主要来一起回顾下JAVA泛型基础. 一个小栗子 先看下面一个例子,test1实例化一个List容器的时候没有指定泛型参数,那么我们可以往这个容器里面放入任何类型的对象,这样是不是很爽?但是当我们从容器中取出容器中的对象的时候我们必须小心翼翼,因为容器中的对象具有运行时的类

Java反射的理解(六)-- 通过反射了解集合泛型的本质

Java反射的理解(六)-- 通过反射了解集合泛型的本质 上述写了那么多,我们可能会有个疑问,为什么要用反射,步骤比我们常规的加载类操作复杂多了,别急,这个问题我最后才解答,我们先来了解集合泛型的本质. 直接上代码: import java.lang.reflect.Method; import java.util.ArrayList; public class MethodDemo4 { public static void main(String[] args) { ArrayList li

Java泛型中extends和super的理解(转)

E – Element (在集合中使用,因为集合中存放的是元素) T – Type(Java 类) K – Key(键) V – Value(值) N – Number(数值类型) ? – 表示不确定的java类型(无限制通配符类型) S.U.V – 2nd.3rd.4th types Object – 是所有类的根类,任何类的对象都可以设置给该Object引用变量,使用的时候可能需要类型强制转换,但是用使用了泛型T.E等这些标识符后,在实际用之前类型就已经确定了,不需要再进行类型强制转换. ?