本文主要是介绍Java之泛型、通配符、类型擦除，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！
重点梳理：
为什么要有泛型？
泛型类
泛型方法
类型擦除
一、为什么要有泛型？
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>{@Overridepublic void print(T t) {System.out.println(t);}
}
class Message2 implements IMessage<Integer>{@Overridepublic 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());//获取属性类型}}
}
结果：
实际上，在泛型类被类型擦除时，之前泛型类的类型参数部分如果没有指定上限，则会被转译为普通的Object类型；如果指定上限，则类型参数就会被替换为类型上限。
A instaceof B//判断A是否由B实例化来的
A.getClass();//获取对象A的类对象
这篇关于Java之泛型、通配符、类型擦除的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！
