Java泛型T,E,K,V,N,?与Object区别和含义

 更新时间:2022年03月09日 15:30:58   作者:不想起床的小张  
Java 泛型(generics)是 JDK 5 中引入的一个新特性, 泛型提供了编译时类型安全检测机制,该机制允许程序员在编译时检测到非法的类型。本文将详细讲讲Java泛型T、E、K、V、N、?和Object区别和含义,需要发可以参考一下

通常我们在看一些源码时,发现全是T、?,晕乎乎的:sob:。于是,把泛型掌握好十分重要!

什么是泛型

Java 泛型(generics)是 JDK 5 中引入的一个新特性, 泛型提供了编译时类型安全检测机制,该机制允许程序员在编译时检测到非法的类型。

泛型的本质是参数化类型,也就是说所操作的数据类型被指定为一个参数。

泛型有什么好处?写个例子一目了然:

我们要封装一个消息响应类:

public class Result implements Serializable {

    // 响应码
    Integer code;

    // 是否成功
    Boolean success;

    // 返回体数据
    User user;

    public Result(Integer code, Boolean success, User user) {
        this.code = code;
        this.success = success;
        this.user = user;
    }

    @Override
    public String toString() {
        return "Result{" +
                "code=" + code +
                ", success=" + success +
                ", user=" + user +
                '}';
    }

    public static void main(String[] args) {

        User user = new User(1, "Tony");
        Result result = new Result(200, true, user);
        System.out.println(result);

    }

}

class User implements Serializable {

    Integer id;

    String name;

    public User(Integer id, String name) {
        this.id = id;
        this.name = name;

    }

    @Override
    public String toString() {
        return "User{" +
                "id=" + id +
                ", name='" + name + '\'' +
                '}';
    }
}
Result{code=200, success=true, user=User{id=1, name='Tony'}}

进程已结束,退出代码0

呼~这样这个反应体就可以返回请求状态和用户信息了。可现在需求又需要返回关于手机的信息,那我们又得封装一个能返回手机信息的响应类了...到后面还有衣服、鞋子...那不得累死?这时候泛型登场了:

public class Result<T> implements Serializable {

    // 响应码
    Integer code;

    // 是否成功
    Boolean success;

    // 返回体数据
    T data;

    public Result(Integer code, Boolean success, T data) {
        this.code = code;
        this.success = success;
        this.data = data;
    }

    @Override
    public String toString() {
        return "Result{" +
                "code=" + code +
                ", success=" + success +
                ", data=" + data +
                '}';
    }

    public static void main(String[] args) {

        User user = new User(1, "Tony");
        Result<User> resultUser = new Result<>(200, true, user);
        System.out.println(resultUser);
        Phone phone = new Phone(999.99, "Yellow");
        Result<Phone> resultPhone = new Result<>(200, true, phone);
        System.out.println(resultPhone);

    }

}

class User implements Serializable {

    Integer id;

    String name;

    public User(Integer id, String name) {
        this.id = id;
        this.name = name;

    }

    @Override
    public String toString() {
        return "User{" +
                "id=" + id +
                ", name='" + name + '\'' +
                '}';
    }
}

class Phone implements Serializable {

    Double price;

    String color;

    @Override
    public String toString() {
        return "Phone{" +
                "price=" + price +
                ", color='" + color + '\'' +
                '}';
    }

    public Phone(Double price, String color) {
        this.price = price;
        this.color = color;
    }
}
Result{code=200, success=true, data=User{id=1, name='Tony'}}
Result{code=200, success=true, data=Phone{price=999.99, color='Yellow'}}

进程已结束,退出代码0

可见,利用泛型,可以统一标识需要返回的实体类。不管你来什么类,我都可以给你塞进去!

第一次接触可能看不太明白,下面就详细讲解

泛型方法

你可以写一个泛型方法,该方法在调用时可以接收不同类型的参数。根据传递给泛型方法的参数类型,编译器适当地处理每一个方法调用。

语法规则

所有泛型方法声明都有一个类型参数声明部分(由尖括号分隔),该类型参数声明部分在方法返回类型之前

比如说这是一个用来打印数组的泛型方法:

private static <E> void printArray(E[] inputArray)

每一个类型参数声明部分包含一个或多个类型参数,参数间用逗号隔开。一个泛型参数,也被称为一个类型变量,是用于指定一个泛型类型名称的标识符。

比如这个方法

private static <E,T> void printArray(E[] inputArray, T data)

类型参数能被用来声明返回值类型,并且能作为泛型方法得到的实际参数类型的占位符。

泛型方法体的声明和其他方法一样。注意类型参数只能代表引用型类型,不能是原始类型(int double char等)

泛型标记符

  • E Element 集合元素
  • T Type Java类
  • K Key 键
  • V Value 值
  • N Number 数值类型
  • ? 表示不确定的Java类型

这些标记并不是限定只有对应的类型才能使用,即使你统一使用A-Z英文字母的其中一个,编译器也不会报错。之所以又不同的标记符,这是一种**约定。**在开发中很多规则都是一种约定,它能提高我们代码的可读性,方便团队见的合作开发

写个完整的例子:

public class TFunction {

    public static void main(String[] args) {

        // 创建各种类型的数组
        Integer[] intArray = {1, 2, 3, 4, 5};
        Double[] doubleArray = {1.1, 2.2, 3.3, 4.4};
        Character[] charArray = {'H', 'E', 'L', 'L', 'O'};

        System.out.println("整型数组元素为:");
        printArray(intArray); // 传递一个整型数组

        System.out.println("\n双精度型数组元素为:");
        printArray(doubleArray); // 传递一个双精度型数组

        System.out.println("\n字符型数组元素为:");
        printArray(charArray); // 传递一个字符型数组

    }

    // 泛型方法
    private static <E> void printArray(E[] inputArray) {

        // 遍历打印数组
        Arrays.stream(inputArray).forEach(e -> {
            System.out.printf("%s ", e);
        });
        System.out.println();

    }
    
}

泛型类

泛型类的声明与非泛型类几乎相同,唯一的不同在于类名的后面添加了参数声明部分

这边就不举例子了,因为开篇的例子就是封装了一个泛型类,当时不太理解的可以再回去看一下

类型通配符

我们一般可以使用?来承接所有的引用类型,搬运一个菜鸟上的例子:

public class GenericTest {
     
    public static void main(String[] args) {
        List<String> name = new ArrayList<String>();
        List<Integer> age = new ArrayList<Integer>();
        List<Number> number = new ArrayList<Number>();
        
        name.add("icon");
        age.add(18);
        number.add(314);
 
        getData(name);
        getData(age);
        getData(number);
       
   }
 
   public static void getData(List<?> data) {
      System.out.println("data :" + data.get(0));
   }
}
data :icon
data :18
data :314

?extends T

这是**泛型上边界:**只有T对象的子类可以被传入

如果是? extends C,那么只有D和E允许被传入,否则会编译报错

? super T

这是**泛型下边界:**只有T对象的父类可以被传入

如果是? super D,那么只有C和A允许被传入,否则会编译报错

T 和 ?

不知道看到这里,有没有疑惑。T和?好像作用差不多啊,有什么区别?

这里解释一下,T一般作为泛型参数,而?是更多是用来一个不确定的引用类型,意会一下吧~~~

T 和 Object

重头戏!!

知道的Object的同志都了解其是Java的超类(所有对象的父类),不了解的可以去看看我的博客,有做详细的解释。

那么问题就来了,Object好像可以代替泛型的功能啊!所有能用到泛型的地方Object都可以!

其实,在JDK5之前,都是用的Object,但其存在很多的问题,JDK5之后便引入了泛型

Object是所有类的父类,在编码过程中就难免出现类型转化问题,且在编译阶段不会报错,到了运行阶段才暴露问题,大大降低了程序的安全性和健壮性!

举例之前说一些转型的分类:

向上转型 用父类声明一个子类对象 例如:Animal是Cat的父类,在声明时我们这么写:

  Animal cat = new Cat();

向下转型

将父类对象强转为其子类实例:

Animal cat = new Cat();
Cat anotherCat = (Cat) cat;

所以当我们使用Object作为泛型来使用时,不仅写起来麻烦,还要不停的进行类型转化,还很容易出现问题,很逊的诶~

举个例子看看:

利用Object定义了一个数字变量,我们常识将其向下转型为Integer和String。将一个数字转型为字符串是一件荒唐的事情,可编译器并不能察觉这件事,直到程序运行了起来...

类型转换异常!!!

总结

泛型的出现,当类型转化出现问题的时候,在编译阶段就会暴露出来。解决了Object存在的诸多问题,让代码更加优雅,程序更加安全,更加健壮。

以上就是Java泛型T,E,K,V,N,?与Object区别和含义的详细内容,更多关于Java 泛型的资料请关注脚本之家其它相关文章!

相关文章

  • Java并发编程创建并运行线程的方法对比

    Java并发编程创建并运行线程的方法对比

    这篇文章主要为大家详细介绍了Java并发编程创建并运行线程的方法,文中示例代码介绍的非常详细,具有一定的参考价值,感兴趣的小伙伴们可以参考一下,希望能够给你带来帮助
    2022-03-03
  • Java实现常见的排序算法的示例代码

    Java实现常见的排序算法的示例代码

    这篇文章主要为大家详细介绍了Java实现常见的排序算法(选择排序、插入排序、希尔排序等)的相关资料,文中的示例代码讲解详细,感兴趣的可以了解一下
    2022-10-10
  • springboot项目如何设置时区

    springboot项目如何设置时区

    这篇文章主要介绍了springboot项目如何设置时区问题,具有很好的参考价值,希望对大家有所帮助。如有错误或未考虑完全的地方,望不吝赐教
    2023-07-07
  • Java利用Easyexcel导出excel表格的示例代码

    Java利用Easyexcel导出excel表格的示例代码

    这篇文章主要为大家详细介绍了Java利用Easyexcel导出excel表格的示例代码,文中的代码讲解详细,感兴趣的小伙伴可以跟随小编一起了解一下
    2022-07-07
  • 详细分析JVM类加载机制

    详细分析JVM类加载机制

    JVM将class文件字节码文件加载到内存中, 并将这些静态数据转换成方法区中的运行时数据结构,在堆(并不一定在堆中,HotSpot在方法区中)中生成一个代表这个类的java.lang.Class 对象,作为方法区类数据的访问入口,接下来将详细讲解JVM类加载机制
    2022-04-04
  • java 如何判断是否是26个英文字母

    java 如何判断是否是26个英文字母

    这篇文章主要介绍了java 如何判断是否是26个英文字母的操作,具有很好的参考价值,希望对大家有所帮助。一起跟随小编过来看看吧
    2021-01-01
  • Java事务的个人理解小结

    Java事务的个人理解小结

    数据库操作的事务习惯上就称为Java事务
    2013-03-03
  • Java中StringBuilder与StringBuffer使用及源码解读

    Java中StringBuilder与StringBuffer使用及源码解读

    我们前面学习的String就属于不可变字符串,因为理论上一个String字符串一旦定义好,其内容就不可再被改变,但实际上,还有另一种可变字符串,包括StringBuilder和StringBuffer两个类,那可变字符串有什么特点,又怎么使用呢,接下来就请大家跟我一起来学习吧
    2023-05-05
  • 详解Gradle安装并配置到IDEA的方法

    详解Gradle安装并配置到IDEA的方法

    这篇文章主要介绍了Gradle安装并配置到IDEA的方法,本文给大家介绍的非常详细,对大家的学习或工作具有一定的参考借鉴价值,需要的朋友可以参考下
    2020-09-09
  • 解决springboot读取application.properties中文乱码问题

    解决springboot读取application.properties中文乱码问题

    初用properties,读取java properties文件的时候如果value是中文,会出现乱码的问题,所以本文小编将给大家介绍如何解决springboot读取application.properties中文乱码问题,需要的朋友可以参考下
    2023-11-11

最新评论