本篇文章为你整理了泛型（泛型是什么意思）的详细内容，包含有泛型编程 泛型是什么意思 泛型 java 泛型擦除 泛型，希望能帮助你了解 泛型。
泛型，即 “参数化类型”。一提到参数，最熟悉的就是定义方法时有形参，然后调用此方法时传递实参。那么参数化类型怎么理解呢？
顾名思义，就是通过泛型指定的不同类型来控制形参限制。在泛型使用过程中，操作的数据类型被指定为一个参数，这种参数类型可以用在类、接口和方法中，分别被称为泛型类、泛型接口、泛型方法。
常见的泛型变量
E：元素（Element），多用于 java 集合框架
K：关键字（Key）
N：数字（Number）
T：类型（Type）
V：值（Value）
为什么用泛型
提高可读性
使 ClassCastException 这种错误在编译期就检测出来
适用于多种数据类型执行相同的代码（代码复用）
举个例子：
public class Add {
//普通方法实现
private static int add(int a, int b) {
System.out.println(a + "+" + b + "=" + (a + b));
return a + b;
private static float add(float a, float b) {
System.out.println(a + "+" + b + "=" + (a + b));
return a + b;
private static double add(double a, double b) {
System.out.println(a + "+" + b + "=" + (a + b));
return a + b;
// 泛型方法实现
private static T extends Number double add(T a, T b) {
System.out.println(a + "+" + b + "=" + (a.doubleValue() + b.doubleValue()));
return a.doubleValue() + b.doubleValue();
public static void main(String[] args) {
Add.add(1, 2);
Add.add(1f, 2f);
Add.add(1d, 2d);
System.out.println("--------------------------");
// 以下三个都是调用泛型方法
// 此时其实是用一个泛型方法就实现了上面三个重载方法的功能。
Add.add(Integer.valueOf(1), Integer.valueOf(2));
Add.add(Float.valueOf(1), Float.valueOf(2));
Add.add(Double.valueOf(1), Double.valueOf(2));
泛型的使用方法
由我们指定想要传入泛型类中的类型，把泛型定义在类上，用户使用该类的时候，才把类型明确下来，比如：定义一个万能的实体数据暂存工具类。
泛型类在初始化时就把类型确定了
package com.nasus.generic.how;
public class EntityTool T {
private T entity;
public T getEntity() {
return entity;
public void setEntity(T entity) {
this.entity = entity;
public static void main(String[] args) {
// 创建对象并指定元素类型
EntityTool String stringTool = new EntityTool ();
stringTool.setEntity("一个优秀的废人");
String s = stringTool.getEntity();
System.out.println(s);
// 创建对象并指定元素类型
EntityTool Integer integerTool = new EntityTool ();
// 此时，如果这里传入的还是 String 类型，那就会在编译期报错
integerTool.setEntity(10);
int i = integerTool.getEntity();
System.out.println(i);
泛型方法在调用时才确定最终类型
若有返回值，返回值不需要强转
package com.nasus.generic.how;
public class Show {
public static T T show(T t) {
System.out.println(t);
return t;
public static void main(String[] args) {
// 返回值不用强转，传进去是什么，返回就是什么
String s = show("一个优秀的废人");
int num1 = show(666);
double num2 = show(666.666);
System.out.println("------------------------");
System.out.println(s);
System.out.println(num1);
System.out.println(num2);
当实现类不明确泛型接口的类型参数变量时，实现类也必须定义类型参数变量
public interface Show T {
void show(T t);
public class ShowImpl T implements Show T {
@Override
public void show(T t) {
System.out.println(t);
public static void main(String[] args) {
ShowImpl String stringShow = new ShowImpl ();
stringShow.show("一个优秀的废人");
明确泛型接口的类型参数变量
public class ShowImpl2 implements Show String {
@Override
public void show(String s) {
System.out.println("一个优秀的废人");
限定泛型类型变量
限定泛型类型上限
指定了泛型类的父类声明类
在类中使用：
类名 泛型标识 extends 类 {}
// 用在类上
public class Show T extends Number {
private T show(T t){
System.out.println(t);
return t;
public static void main(String[] args) {
// 初始化时指定类型
Show Integer show = new Show ();
show.show(6666666);
// 报错，该类只接受继承于 Number 的泛型参数
// Show String stringShow = new Show ();
在方法中使用
定义对象：类名 泛型标识 extends 类 对象名称
public class Info T {
// 定义泛型变量
private T var;
public void setVar(T var) {
this.var = var;
public T getVar() {
return this.var;
public String toString() {
return this.var.toString();
// 用在方法上，只能接收 Number 及其子类
public static void showInfo(Info ? extends Number t) {
System.out.print(t);
public static void main(String args[]) {
Info Integer i1 = new Info ();
Info Float i2 = new Info ();
i1.setVar(666666666);
i2.setVar(666666.66f);
showInfo(i1);
showInfo(i2);
限定泛型类型下限
定义对象：类名 泛型标识 extends 类 对象名称
与指定上限相反，指定下限定很简单，就是相当于指定了泛型类的子类。
public class ShowInfo {
// 只接受 String 的父类
public static void showInfo(Info ? super String t) {
System.out.println(t);
public static void main(String args[]) {
Info String stringInfo = new Info ();
Info Object objectInfo = new Info ();
stringInfo.setVar("一个优秀的废人");
objectInfo.setVar(new Object());
showInfo(stringInfo);
showInfo(objectInfo);
通配符类型
? extends Parent 指定了泛型类型的上限
? super Child 指定了泛型类型的下届
? 指定了没有限制的泛型类型
泛型的使用规范
1、不能实例化泛型类
2、静态变量或方法不能引用泛型类型变量，但是静态泛型方法是可以的
3、基本类型无法作为泛型类型
4、无法使用 instanceof 关键字或 == 判断泛型类的类型
5、泛型类的原生类型与所传递的泛型无关，无论传递什么类型，原生类是一样的
6、泛型数组可以声明但无法实例化
7、泛型类不能继承 Exception 或者 Throwable
8、不能捕获泛型类型限定的异常但可以将泛型限定的异常抛出
以上就是泛型（泛型是什么意思）的详细内容，想要了解更多 泛型的内容，请持续关注盛行IT软件开发工作室。
郑重声明：本文由网友发布，不代表盛行IT的观点，版权归原作者所有，仅为传播更多信息之目的，如有侵权请联系，我们将第一时间修改或删除，多谢。