Java之泛型、通配符、类型擦除

最新推荐文章于 2024-11-21 08:00:00 发布

原创最新推荐文章于 2024-11-21 08:00:00 发布 · 392 阅读

1 ·

CC 4.0 BY-SA版权

Java 专栏收录该内容

52 篇文章

订阅专栏

重点梳理：
为什么要有泛型？
泛型类
泛型方法
类型擦除

一、为什么要有泛型？

1.为了避免类型转换错误（ClassCastException),提高程序的健壮性。

在程序中进行Java类型转换时，可能会出现ClassCastException类型转换异常。如：

List list=new ArrayList();
list.add("hello");
Integer i=(Integer)list.get(0);//编译通过，运行时抛出ClassCastException异常

在JDK5之前的版本里，集合中的元素都是Object类型，从集合中获取元素时，往往需要进行强制类型转换。JDK5引入了泛型机制，所有集合都采用了泛型机制，避免了出现ClassCastException异常，提供程序的健壮性。

List<String> list=new ArrayList<String>();//链表中的元素必须均为String类型
list.add("hello");//合法
list.add(Integer(11));//编译出错，不允许把Integer对象加入到链表中

Integer i=list.get(0);//编译出错，链表中的元素为String类型，无法转换为Integer类型
String s=list.get(0);//合法
Object o=list.get(0);//合法，允许向上转型，无须进行强制类型转换

2.简化程序

当要输出不同类型的数据时，使用泛型方法就可以搞定，而不用写大量代码。

二、泛型类

1.泛型类的定义

定义类
class 类名<T>{
	//类的属性和方法
}

使用类
类名<具体参数类型的包装类>  对象名=new 类名<具体参数类型的包装类>();//JDK1.5后new后的包装类型可以省略

泛型指的是在类定义的时候并不会设置类中的属性或方法中的参数的具体类型，而是在类使用时才定义。

2.泛型的参数

尖括号中的T被称作是类型参数，用于指代任何数据类型。实际上这个T可以任意写，但出于规范，Java还是建议我们用单个大写字母代表类型参数。

T  代表一般的任何类
E  Element或者Exception异常的意思
K  Key的意思
V  Value的意思，通常与K一起搭配使用
S  Subtype的意思

注意：在使用泛型类/方法时，参数的类型如果是基本数据类型，必须使用对应的包装类型。包装类型有直接继承Object类的两个类型：Character、Boolean。有继承Object类的Number类的子类：Byte、Short、Integer、Long、Float、Double

3.泛型类的使用

package com.xunpu.generic_type;

class Bag<T>{
    private T content;

    public Bag(T content) {
        this.content = content;
    }

    public T getContent() {
        return content;
    }

    public void setContent(T content) {
        this.content = content;
    }
}
public class TestGeneric {
    public static void main(String[] args) {
        Bag<String> bag=new Bag<String>("mybook");
      //Integer content1=bag.getContent();//编译出错，编译器能判断出类型不兼容。
        String content=bag.getContent();
        System.out.println(content);
    }

}

一个泛型类可以有多个类型参数，语法为类名<T1,T2,T3,......>

4.通配符

在程序类中追加了泛型后，避免了类型转换异常，但又会产生新的问题，参数类型不统一。如：

public class TestGeneric {
    public static void main(String[] args) {
        Bag<String> bag=new Bag<String>("mybook");
        String content=bag.getContent();
        fun(bag);//编译出错，只能接收Integer 
    }
public static void fun(Bag<Integer> bag){
      System.out.println(bag.getContent());
}

因此，现在要解决：既可以接收所有的泛型类型，但是又不能让用户随意更改。这种情况就需要使用通配符“？”来处理。

public class TestGeneric {
    public static void main(String[] args) {
        Bag<String> bag=new Bag<String>("mybook");
        String content=bag.getContent();
        fun(bag);
    }
    //此时使用通配符“？”表示fun()可以接收所有的泛型类型。
public static void fun(Bag<?> bag){
      System.out.println(bag.getContent());
}

结果：

在通配符“？”的基础上又产生了两个子通配符：

? extends 类名：设置泛型上限
? super 类名：设置泛型下限

如：

? extends Number,表示只能设置Number及其子类，例如Integer,Float,Byte
? super String，表示只能设置String及其父类Object

三、泛型方法

1.泛型方法的定义格式与使用格式

 格式：public <T> returnValue  函数名(T t）{
	//方法体
	return returnValue;
	}
 使用格式：returnValue  临时变量=函数名(T类型的参数);
如果是类中的方法，则在函数内部先定义对象，然后再调用方法。T 临时变量=对象名.方法名(参数列表);

注意：如果泛型类中有泛型方法，那么这两个参数类型没有一点关系，二者是相互独立的。

2.泛型方法中的参数和泛型类一样，如果是基本数据类型，必须使用相应的包装类型。

3.泛型方法的使用

package com.xunpu.generic_type;

class Bag<T>{
    private T content;

    public T getContent() {
        return content;
    }

    public void setContent(T content) {
        this.content = content;
    }

    public Bag(T t){
        this.content=t;
    }
    //泛型方法  与泛型类中的泛型无关
    public <T> T testMethod(T t){
        return t;
    }

}
public class TestGeneric {
    public static void main(String[] args) {
        //定义泛型类中的数据为String类型
       Bag<String> bag=new Bag<String>("hello");
       System.out.println(bag.getContent());
       //定义泛型方法中的数据为Integer类型
       Integer t=bag.testMethod(2);
       System.out.println(t);
    }
}

结果：

四、泛型接口

泛型除了可以定义在类中和方法中，还可以定义在接口中。

1.格式

实现接口的类可以继续使用泛型，也可以明确给泛型的类型。

定义格式：
interface IMessage<T>{
     void print(T t);
}
类实现接口一：继续使用泛型
class 实现接口的类名 implements IMessage<T>{
            public void print(T t){
                //方法体
            }
}
使用：
IMessage<包装类型> 对象名=new 实现接口的类名<包装类型>();
对象名.print(对应的数据);

类实现接口二：明确给出具体类型
class 实现接口的类名 implements IMessage<String>{
            public void print(String str){
                //方法体
            }
}
使用：
IMessage<String> msg=new 实现接口的类名();

2.泛型接口的使用

package com.xunpu.generic_type;

interface IMessage<T>{
    void print(T t);
}
class Messge<T> implements IMessage<T>{

    @Override
    public void print(T t) {
        System.out.println(t);
    }
}
class Message2 implements IMessage<Integer>{

    @Override
    public void print(Integer i) {
        System.out.println(i);
    }
}
public class TestGeneric {
    public static void main(String[] args) {
        IMessage<String> msg=new Messge<>();
        msg.print("hello java");
        IMessage msg2=new Message2();
        msg2.print(666);
    }
}

结果：

五、类型擦除

泛型是JDK1.5版本才引进的，但显然，泛型代码能很好地和之前版本地代码很好地兼容。这是因为，

泛型信息只存在于代码编译阶段，在进入JVM之前，运行时与泛型相关的信息会被擦除掉，专业术语叫做“类型擦除”。

观察类型擦除：

package com.xunpu.generic_type;

import java.lang.reflect.Field;

class Message<T,E>{
    private T message;
    private E text;

    public E getText() {
        return text;
    }

    public void setText(E text) {
        this.text = text;
    }

    public T getMessage() {
        return message;

    }

    public void setMessage(T message) {
        this.message = message;
    }
}
public class TestGeneric {
    public static void main(String[] args) {
        Message<String,Integer> message=new Message<>();
        Class cls=message.getClass();
        Field[] fields=cls.getDeclaredFields();//获取本类中的属性
        for(Field field:fields){
            System.out.println(field.getType());//获取属性类型
        }
    }
}

结果：