Java泛型详解

最新推荐文章于 2024-05-29 23:10:16 发布
最新推荐文章于 2024-05-29 23:10:16 发布
阅读量898 收藏 2
点赞数 1
分类专栏： 笔记 Java学习 文章标签： java 开发语言 java-ee
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_51553982/article/details/125157551
版权
笔记 同时被 2 个专栏收录
334 篇文章 42 订阅
订阅专栏
Java学习
181 篇文章 3 订阅
订阅专栏

Java泛型详解

泛型

使用Object类常出现类型转换异常

泛型由此而生

简单来说，泛型就是泛泛而谈（空洞，不确定）的类型

Java泛型(generics）是JDK5中引入的一个新特性，泛型提供了编译时类型安全监测机制，该机制允许我们在编译时检测到非法的类型数据结构

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

优点

  1. 类型安全
  2. 无需进行类型转换（无类型转换异常）

如何声明泛型

使用 类名称+< 泛型标识 > 进行声明
若是变量则直接使用 泛型标识+变量名
如下：

public class Obj <T>{
	private T ele;
}

我们常见有五种泛型标识：

  1. T：用于指定类的类型
  2. E：用于指定集合中的元素
  3. K：用于指明键值对中的键
  4. V：用于指明键值对中的值
  5. ？：用于指定任意类型

泛型的类型只有在使用的时候才会知道是什么类型

如何使用泛型

正常用！
意思是平时你怎么使用的就怎么使用
泛型不要看的那么重，他只是不确定的类型，也是一种类型，和String，Boolean，Integer那些都一样

你只要记住在使用时指明泛型具体的类型即可

泛型类

Demo1 < T >

package type;

public class Demo1 <T>{
    private T ele1;
    private T ele2;

    public Demo1(T ele1, T ele2) {
        this.ele1 = ele1;
        this.ele2 = ele2;
    }

    public Demo1() {
    }

    public T getEle1() {
        return ele1;
    }

    public void setEle1(T ele1) {
        this.ele1 = ele1;
    }

    public T getEle2() {
        return ele2;
    }

    public void setEle2(T ele2) {
        this.ele2 = ele2;
    }

    @Override
    public String toString() {
        return "Demo1{" +
                "ele1=" + ele1 +
                ", ele2=" + ele2 +
                '}';
    }
}

test1

package test;

import type.Demo1;

public class test1 {

    public static void main(String[] args) {
        Demo1<String> stringDemo1 = new Demo1<>();
        stringDemo1.setEle1("element1");
        stringDemo1.setEle2("element2");
        stringDemo1.toString();
        System.out.println(stringDemo1.toString());
        System.out.println("---------------");
        Demo1<Boolean> booleanDemo1 = new Demo1<>();
        booleanDemo1.setEle1(true);
        booleanDemo1.setEle2(false);
        System.out.println(booleanDemo1.toString());
    }
}

在这里插入图片描述

泛型类及其子类

1. 子类也是泛型类

若子类也是泛型类，子类和父类的泛型标识需要一致
即父类使用标识T子类也是T

父类
package type;

public class Parent <T>{
}
子类
package type;

public class Child1<T> extends Parent{
}

2.子类非泛型类

若子类非泛型类则父类需要在继承时指明类型

父类
package type;

public class Parent <T>{
}
子类
package type;

public class Child2 extends Parent<String>{
}

泛型接口

同泛型类一样有两种，写法相同

package type;

public interface Demo2 <T>{
    void doMethod();
}

实现一个带有2个泛型的类

package type;

public class Child2<K,V>{
    private K key;
    private V value;

    public Child2() {
    }

    public Child2(K key, V value) {
        this.key = key;
        this.value = value;
    }

    public K getKey() {
        return key;
    }

    public void setKey(K key) {
        this.key = key;
    }

    public V getValue() {
        return value;
    }

    public void setValue(V value) {
        this.value = value;
    }
}

泛型方法

  • public与返回值中间< T >非常重要，可以理解为声明此方法为泛型方法。
  • 只有声明了< T >的方法才是泛型方法，泛型类中的使用了泛型的成员方法并不是泛型方法。
  • < T >表明该方法将使用泛型类型T，此时才可以在方法中使用泛型类型T。
  • 与泛型类的定义一样，此处T可以随便写为任意标识，常见的如T、E、K、V等形式的参数常用于表示泛型。
修饰符 <标识> 返回值类型 方法名（）{}

类

public <E> E met(E value){
        return value;
    }

package type;

public class Demo1 <T>{
    private T ele1;
    private T ele2;

    /*省略*/

    public <E> E met(E value){
        return value;
    }
}

测试

package test;

import type.Demo1;

public class test1 {

    public static void main(String[] args) {

        Demo1<Boolean> booleanDemo1 = new Demo1<>();
        booleanDemo1.setEle1(true);
        booleanDemo1.setEle2(false);
        System.out.println(booleanDemo1.toString());

        String test_met = booleanDemo1.met("test_met");
        System.out.println(test_met);
    }
}

在这里插入图片描述

？（类型通配符）

想象以下场景
你现在要在泛型类中对一个方法进行重载

public void met(Child<Int> child){}

public void met(Child<String> child){}

你认为可以重载成功吗？

答案是不行！因为Child< String >和Child< Int >实际上就是一个Child< T >!

所以？由此而生

public void met(Child<?> child){}

我们就可以直接通过这样一个进行多个方法的重载

所以？就代表类型实参，而不是类型形参

类型通配符的上限

我们设置可以用？进行继承，标识该泛型只能是继承的类或其子类

public void met(Child<? extends Number> child){}

这就称为类型通配符的上限

上限表示该类型至多是XX类型

类型通配符的下限

将extends改为super这表明当前传入实参类型只能是某个类型的父类


public void met(Child<? super Int> child){}

下限表示该类型至少是XX类型

类型擦除

泛型的信息只存在于代码编译阶段，进入JVM前与之相关的信息会被抹除（去掉）

这被称为类型擦除

无限制类型擦除

从泛型 → Object

即所有的泛型标识都转为Object

//擦除前
public T ele
//擦除后
public Object ele
验证（通过反射）
泛型类
package type;

public class Demo1 <T>{
    private T ele1;
    private T ele2;

    public Demo1(T ele1, T ele2) {
        this.ele1 = ele1;
        this.ele2 = ele2;
    }

    public Demo1() {
    }

    public T getEle1() {
        return ele1;
    }

    public void setEle1(T ele1) {
        this.ele1 = ele1;
    }

    public T getEle2() {
        return ele2;
    }

    public void setEle2(T ele2) {
        this.ele2 = ele2;
    }

    @Override
    public String toString() {
        return "Demo1{" +
                "ele1=" + ele1 +
                ", ele2=" + ele2 +
                '}';
    }

    public <E> E met(E value){
        return value;
    }
}
测试类
package test;

import type.Demo1;

import java.lang.reflect.Field;

public class test3 {
    public static void main(String[] args) {
        Demo1<String> stringDemo1 = new Demo1<>();
        Class<? extends Demo1> aClass = stringDemo1.getClass();
        Field[] declaredFields = aClass.getDeclaredFields();
        for (Field declaredField : declaredFields) {
            System.out.println(declaredField.getType().getSimpleName());
        }
    }
}

在这里插入图片描述

类型上下限擦除

上限变父类，向下兼容
下限变Object，顶层兼容所有

只要记住上面两句话即可
即：

//上限
public <T extends Parent> T met(){...}
//擦除后
public Parent met(){...}

//下限
public <T super Parent> T met(){...}
//擦除后
public Object met(){...}

桥接方法

当我们的类以指定的某个类型实现某个泛型接口，编译后就会产生桥接方法

桥接方法是为了让实现类向上兼容

接口
package type;

public interface Demo2 <T>{
    T doMethod(T val);
}
实现类
package type;

public class Demo3 implements Demo2<String>{
    @Override
    public String doMethod(String val) {
        System.out.println("实现接口");
        return val;
    }
}
编译后
package type;

public class Demo3 implements Demo2{
    @Override
    public String doMethod(String val) {
        System.out.println("实现接口");
        return val;
    }
//编译后生成的桥接方法
@Override
    public Object doMethod(Object val) {
        System.out.println("实现接口");
        return doMethod((String) val)
    }
}

泛型数组

声明方式

package test;

import java.util.ArrayList;

public class test4 {
    public static void main(String[] args) {
        ArrayList<String>[] lists = new ArrayList[10];
        ArrayList<String> strings = new ArrayList<>();
        strings.add("new");
        lists[0] = strings;
        String s = lists[0].get(0);
        System.out.println(s);

    }
}

问题

这时候就有人问了，我不能写出如下的形式吗？

package test;

import java.util.ArrayList;

public class test4 {
    public static void main(String[] args) {
        ArrayList<String>[] lists = new ArrayList[10];
        lists[0].add("hello");
        System.out.println(lists[0].get(0));
    }
}

这样一看从逻辑上好像解释的通
既然lists[ ]是ArrayList< String >类型那么一定有其add方法可以添加元素

但是实际上是不对的！会出现空指针

在这里插入图片描述

原因

经过调试，你可以看到在执行这一行时lists[0]是空，也就是说lists[0]仅有对象引用没有内存空间！所以null.add()根本不可能有这个方法！

在这里插入图片描述

通过Array.newInstance创建

package type;

import java.lang.reflect.Array;

public class Demo4<T> {
    private T[] ele;

    public Demo4(Class<T> ele, int length) {
        this.ele = (T[]) Array.newInstance(ele, length);
    }
}
简明编程
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
java泛型详解
08-31
Java 泛型详解 Java 泛型是 Java 语言中的一种重要机制，它可以帮助开发者编写更加安全、灵活和可重用的代码。在本文中，我们将详细介绍 Java 泛型的相关知识，包括泛型的概念、类型擦除、泛型的应用场景等内容。 ...
Java泛型方法的声明方式
xharvard的专栏
08-15 1599
Java泛型方法的声明方式
Java泛型之类型通配声明
d0203的博客
05-17 78
【代码】Java泛型之类型通配声明。
Java 中的泛型详解
最新发布
XuChaofafa的博客
05-29 1104
泛型，即“参数化类型”。一提到参数，最熟悉的就是定义方法时有形参列表，普通方法的形参列表中，每个形参的数据类型是确定的，而变量是一个参数。在调用普通方法时需要传入对应形参数据类型的变量（实参），若传入的实参与形参定义的数据类型不匹配，则会报错。那参数化类型是什么？以方法的定义为例，在方法定义时，将方法签名中的形参的数据类型也设置为参数（也可称之为类型参数），在调用该方法时再从外部传入一个具体的数据类型和变量。
（46）Java基础 --泛型
kulr_w的博客
03-04 1167
一、泛型的概述 定义 广泛的类型，在定义一个类的时候，类型中有些方法参数、返回值类型不确定，就使用一个符号，来表示那些尚未确定的类型，这个符号，就称为泛型。 使用 对于有泛型的类型，在这些类型后面跟上尖括号，尖括号里面写上泛型的确定类型（在使用某个类创建对象时，已经可以确定这个具体的类型了，那么就直接写出具体类型）。 例如：List<Integer> al = new ArrayList<Integer>(); 泛型的好处 ...
Java中泛型 Class＜T＞、T与Class＜?＞、 Object类和Class类、 object.getClass() 和 Object.class
freeking101的博客
10-23 1万+
From：Java中泛型 Class<T>、T与Class<?>、 Object类和 Class类、 object.getClass() 和 Object.class ：https://www.cnblogs.com/zhaoyanhaoBlog/p/9362267.html Class<T>和 Class<?>类型 有什么区别：https://www.jianshu.com/p/fecafcc83fba Java...
夯实JAVA基本之一 —— 泛型详解(1):基本使用
热门推荐
启舰
11-16 2万+
前言：无论何时，相信自己。 相关文章： 1、《夯实JAVA基本之一 —— 泛型详解(1):基本使用》 2、《夯实JAVA基本之一——泛型详解(2)：高级进阶》 3、《夯实JAVA基本之二 —— 反射（1）：基本类周边信息获取》 4、《夯实JAVA基本之二 —— 反射（2）：泛型相关周边信息获取》 5、《夯实JAVA基本之二 —— 反射（3）：类内部信息获取》 一、引入 ...
Java 泛型详解
09-18
Java泛型详解，Java泛型详解，Java泛型详解，Java泛型详解
深入理解java泛型详解
08-30
让我们深入探讨一下Java泛型的各个方面。 首先，泛型（Generic type）是一种在定义类、接口或方法时，使用类型参数的方式。类型参数就像是方法的形参，但用于类型而非值。例如，当我们创建一个泛型列表`List<T>`，`...
java泛型详解.pdf
10-02
java泛型详解.pdf
011Java泛型
传说中国的博客
03-29 316
泛型的设计背景： 集合容器类在设计阶段/声明阶段不能确定这个容器到底实际存的是什么类型的对象，所以在JDK1.5之前只能把元素类型设计为Object，JDK1.5之后使用泛型来解决。因为这个时候除了元素的类型不确定，其他的部分是确定的，例如关于这个元素如何保存，如何管理等是确定的，因此此时把元素的类型设计成一个参数，这个类型参数叫做泛型。例如：Collection，List，ArrayList这个就是类型参数，即泛型。 泛型的概念： 所谓泛型，就是允许在定义类、接口时通过一个标识表示类中某个属性的类型
Java泛型
qq_52830421的博客
02-25 205
泛型的声明:Interface接口{},class 类{},注意事项:T,E只能是引用类型,不能是基本数据类型,在给泛型指定好具体类型后可以传入该类型或者其子类类型,不传默认是Object。一.泛型又称为参数化类型,解决数据类型的安全性问题,在类声明或实例化的时候只要制定好需要的类型即可,即泛型是程序员可以表示一种数据类型的数据类型 ArrayList里面的"E"就称为泛型。自定义泛型接口:接口中,静态成员不能使用泛型,接口中,所有成员都是静态的(方法是默认抽象的);
JAVA中的泛型方法的声明形式的介绍
roddger1的博客
07-09 1805
在java中，泛型分为称为泛型类、泛型接口、泛型方法。 其中泛型类、泛型接口理解较为容易，但是泛型方法，容易让人产生困惑。 那么我们在这片文章中来学习一下泛型方法。 泛型方法，是在调用方法的时候指明泛型的具体类型 。 /** 泛型方法的基本介绍 @param tClass 传入的泛型实参 @return T 返回值为T类型 说明： 1）”修饰符“ 与 “返回值类型” 之间的 为声明此方法为泛型方法。只有声明了的方法才是泛型方法，泛型类中的使用了泛型的成员方法并不是泛型方法。 2）表明该方法将使用泛型类型
泛型方法的声明
weixin_47284895的博客
07-21 1318
File类和Directory类就好比一个工厂，文件和文件夹就好比工厂所制作的产品，而工厂和产品的关系主要表现在以下几个方面工厂可以自行开发产品（文件和文件夹的创建）；泛型方法可以在类、结构或接口声明中声明，这些类、结构或接口本身可以是泛型或非泛型的。如果在泛型类型声明中声明泛型方法，则方法体可以同时引用该方法的类型参数T和包含该方法的声明的类型参数T。泛型的应用比较复杂，既有泛型类，也有泛型接口、泛型方法等。虽然合理地使用泛型类可以减少重复的代码，但这往往需要高级的技巧和合理的设计。...
Java8之泛型
CRUD工程师
01-03 2790
泛型是JDK1.5版本引入的，以泛型类为例，申明泛型类时需带上参数类型T，成员变量就可以被限制为T的类型。不过需要注意的是，申明为泛型类，不代表新建对象时必须增加泛型限制。当类定义中的类型参数没有任何限制时，在类型擦除中直接被替换为Object，即形如和的类型参数都被替换为Object。​当类定义中的类型参数存在限制（上下界）时，在类型擦除中替换为类型参数的上界或者下界，比如形如和
Java获取泛型的class类型
tfdev的博客
11-05 1万+
项目中使用一个工具类，需要传入类的class来确定返回的结果类型，比如： public <T> convert(Object obj,Class<T> t){ ....... } 类似这种格式 然后我想传入一个类型比如：List<String>的class，但是不能直接写List<String>.class,于是需要使用TypeReference来解决。 简单看了下里边的思路跟网上说的获取泛型类型需要通过继承一个父类是一样的解决方法。 Typ.
JAVA一种获得泛型类泛型参数Class对象的方法
什么乱七八糟的
03-15 6366
java通过泛型类特化子类获得泛型参数class对象的方法
java基础(十二 )-----Java泛型详解
05-16
Java泛型是Java 5引入的新特性，可以提高代码的可读性和安全性，降低代码的耦合度。泛型是将类型参数化，实现代码的通用性。 一、泛型的基本语法 在声明类、接口、方法时可以使用泛型，泛型的声明方式为在类名、接口名、方法名后面加上尖括号<>，括号中可以声明一个或多个类型参数，多个类型参数之间用逗号隔开。例如： ```java public class GenericClass<T> { private T data; public T getData() { return data; } public void setData(T data) { this.data = data; } } public interface GenericInterface<T> { T getData(); void setData(T data); } public <T> void genericMethod(T data) { System.out.println(data); } ``` 其中，`GenericClass`是一个泛型类，`GenericInterface`是一个泛型接口，`genericMethod`是一个泛型方法。在这些声明中，`<T>`就是类型参数，可以用任何字母代替。 二、泛型的使用 1. 泛型类的使用 在使用泛型类时，需要在类名后面加上尖括号<>，并在括号中指定具体的类型参数。例如： ```java GenericClass<String> gc = new GenericClass<>(); gc.setData("Hello World"); String data = gc.getData(); ``` 在这个例子中，`GenericClass`被声明为一个泛型类，`<String>`指定了具体的类型参数，即`data`字段的类型为`String`，`gc`对象被创建时没有指定类型参数，因为编译器可以根据上下文自动推断出类型参数为`String`。 2. 泛型接口的使用 在使用泛型接口时，也需要在接口名后面加上尖括号<>，并在括号中指定具体的类型参数。例如： ```java GenericInterface<String> gi = new GenericInterface<String>() { private String data; @Override public String getData() { return data; } @Override public void setData(String data) { this.data = data; } }; gi.setData("Hello World"); String data = gi.getData(); ``` 在这个例子中，`GenericInterface`被声明为一个泛型接口，`<String>`指定了具体的类型参数，匿名内部类实现了该接口，并使用`String`作为类型参数。 3. 泛型方法的使用 在使用泛型方法时，需要在方法名前面加上尖括号<>，并在括号中指定具体的类型参数。例如： ```java genericMethod("Hello World"); ``` 在这个例子中，`genericMethod`被声明为一个泛型方法，`<T>`指定了类型参数，`T data`表示一个类型为`T`的参数，调用时可以传入任何类型的参数。 三、泛型的通配符 有时候，我们不知道泛型的具体类型，可以使用通配符`?`。通配符可以作为类型参数出现在方法的参数类型或返回类型中，但不能用于声明泛型类或泛型接口。例如： ```java public void printList(List<?> list) { for (Object obj : list) { System.out.print(obj + " "); } } ``` 在这个例子中，`printList`方法的参数类型为`List<?>`，表示可以接受任何类型的`List`，无论是`List<String>`还是`List<Integer>`都可以。在方法内部，使用`Object`类型来遍历`List`中的元素。 四、泛型的继承 泛型类和泛型接口可以继承或实现其他泛型类或泛型接口，可以使用子类或实现类的类型参数来替换父类或接口的类型参数。例如： ```java public class SubGenericClass<T> extends GenericClass<T> {} public class SubGenericInterface<T> implements GenericInterface<T> { private T data; @Override public T getData() { return data; } @Override public void setData(T data) { this.data = data; } } ``` 在这个例子中，`SubGenericClass`继承了`GenericClass`，并使用了相同的类型参数`T`，`SubGenericInterface`实现了`GenericInterface`，也使用了相同的类型参数`T`。 五、泛型的限定 有时候，我们需要对泛型的类型参数进行限定，使其只能是某个类或接口的子类或实现类。可以使用`extends`关键字来限定类型参数的上限，或使用`super`关键字来限定类型参数的下限。例如： ```java public class GenericClass<T extends Number> { private T data; public T getData() { return data; } public void setData(T data) { this.data = data; } } public interface GenericInterface<T extends Comparable<T>> { T getData(); void setData(T data); } ``` 在这个例子中，`GenericClass`的类型参数`T`被限定为`Number`的子类，`GenericInterface`的类型参数`T`被限定为实现了`Comparable`接口的类。 六、泛型的擦除 在Java中，泛型信息只存在于代码编译阶段，在编译后的字节码中会被擦除。在运行时，无法获取泛型的具体类型。例如： ```java public void genericMethod(List<String> list) { System.out.println(list.getClass()); } ``` 在这个例子中，`list`的类型为`List<String>`，但是在运行时，`getClass`返回的类型为`java.util.ArrayList`，因为泛型信息已经被擦除了。 七、泛型的类型推断 在Java 7中，引入了钻石操作符<>，可以使用它来省略类型参数的声明。例如： ```java List<String> list = new ArrayList<>(); ``` 在这个例子中，`ArrayList`的类型参数可以被编译器自动推断为`String`。 八、总结 Java泛型是一个强大的特性，可以提高代码的可读性和安全性，降低代码的耦合度。在使用泛型时，需要注意它的基本语法、使用方法、通配符、继承、限定、擦除和类型推断等问题。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值