十三、泛型

已于 2024-09-02 19:50:03 修改
阅读量885 收藏 14
点赞数 30
分类专栏： Java 文章标签： java android 开发语言
于 2024-09-01 08:30:00 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44063529/article/details/141760374
版权

文章目录

一、泛型的理解和好处

在这里插入图片描述

在这里插入图片描述

package com;


import java.util.ArrayList;

/**
 * @author Gao YongHao
 * @version 1.0
 */
public class Generic01 {
    public static void main(String[] args) {
        // 使用传统方法来解决 ===> 使用泛型
        // 解读
        // 1. 当我们 ArrayList<Dog> 表示存放到 ArrayList 集合中的元素是Dog类型（细节后面说）
        // 2. 如果编译器发现添加的类型，不满足要求，就会报错
        ArrayList<Dog> dogs = new ArrayList<Dog>();
        dogs.add(new Dog("旺财", 10));
        dogs.add(new Dog("发财", 1));
        dogs.add(new Dog("小黄", 5));
        // 假如不小心添加了一只猫,编译器会报错
//        dogs.add(new Cat("招财猫", 8));
        for (Dog o : dogs) {
            System.out.println(o.getName() + "-" + o.getAge());
        }

    }
}

class Cat {
    private String name;
    private int age;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public Cat(String name, int age) {
        this.name = name;
        this.age = age;
    }
}

class Dog {
    private String name;
    private int age;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public Dog(String name, int age) {
        this.name = name;
        this.age = age;
    }
}

在这里插入图片描述

二、泛型的基本介绍

  • 泛型是一种表示数据类型的数据类型。是数据的多态表现。在类声明时使用，可以把数据类型作为参数传入类中（即：参数化类型）
  • 泛型的具体数据类型是在编译期间就确定下来的
    在这里插入图片描述
public class Genric03{
    public static void main(String[] args){
        Person<String> person = new Person<String>("韩顺平教育");
        /*
            可以这要理解，上面的Person类
            
class Person{
    String s; // E 表示 s 的数据类型，该数据类型在定义Person对象的时候指定，即在编译期间，就确定E是什么类型
    public Person(String s){ // E 也可以是参数类型
        this.s = s;
    }
    public String f(){ // 返回类型使用E
        return s;
    }
}
        */
    }

}

class Person<E>{
    E s; // E 表示 s 的数据类型，该数据类型在定义Person对象的时候指定，即在编译期间，就确定E是什么类型
    public Person(E s){ // E 也可以是参数类型
        this.s = s;
    }
    public E f(){ // 返回类型使用E
        return s;
    }
}

三、泛型基本语法

3.1 语法介绍

在这里插入图片描述

3.2 泛型使用的注意事项和细节

在这里插入图片描述

四、自定义泛型

4.1 自定义泛型类

在这里插入图片描述

package com.generic;

/**
 * @author Gao YongHao
 * @version 1.0
 */
public class Generic02 {
    public static void main(String[] args) {

    }
}

// 解读
// 1. Tiger 后面有泛型，索引我们把 Tiger 成为自定义泛型类
// 2. T,R,M 泛型的标识符,一般是单个大写字母
// 3. 泛型标识符可以有多个
// 4. 普通成员可以使用泛型（属性，方法）

class Tiger<T,R,M>{
    String name;
    T t; // 属性使用泛型
    R r;
    M m;

    // 因为数组在new的使用不能确定T的类型，就无法在内存开空间
//    T[] ts = new T[8];

    // 因为静态是和类相关的，在类加载时，对象还没有创建
    // 所以，如果静态方法和静态属性使用了泛型，JVM就无法完成初始化
//    static R r2;
//    public static void m1(M m){
//
//    }

    public Tiger(String name, T t, R r, M m) { // 构造器使用泛型
        this.name = name;
        this.t = t;
        this.r = r;
        this.m = m;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public T getT() { // 返回类型可以使用泛型
        return t;
    }

    public void setT(T t) { // 方法使用到泛型
        this.t = t;
    }

    public R getR() {
        return r;
    }

    public void setR(R r) {
        this.r = r;
    }

    public M getM() {
        return m;
    }

    public void setM(M m) {
        this.m = m;
    }
}

4.2 自定义泛型接口

在这里插入图片描述

package com.generic;

/**
 * @author Gao YongHao
 * @version 1.0
 */
public class Generic03 {
    public static void main(String[] args) {

    }
}

/**
 * 泛型接口使用说明
 * 1. 接口中，静态成员也不能使用泛型
 * 2. 泛型接口的类型，在继承接口或者实现接口时确定
 * @param <U>
 * @param <R>
 */
interface IUsb<U, R> {

    // 普通方法中，可以使用接口泛型
    R get(U u);

    void hi(R r);

    void run(R r1, R r2, U u1, U u2);

    // 在 jdk8 中,可以在接口中，使用默认方法,也是可以使用泛型
    default R method(U u) {
        return null;
    }


}

// 实现接口时，直接指定泛型接口的类型
// 给 U 指定 Integer，给 R 指定了 Float
// 所以，当我们实现了IUsb,会使用Integer替换U，使用Float替换 R
class BB implements IUsb<Integer,Float>{
    @Override
    public Float get(Integer integer) {
        return null;
    }

    @Override
    public void hi(Float aFloat) {

    }

    @Override
    public void run(Float r1, Float r2, Integer u1, Integer u2) {

    }

    @Override
    public Float method(Integer integer) {
        return null;
    }
}


// 在继承接口  指定泛型接口的类型
interface IA extends IUsb<String,Double>{
}

// 当我们去实现IA接口时，因为IA在继承IUsu接口时，
// 指定了 U 为 String，R 为Double
class AA implements IA{
    @Override
    public Double get(String s) {
        return null;
    }

    @Override
    public void hi(Double aDouble) {

    }

    @Override
    public void run(Double r1, Double r2, String u1, String u2) {

    }

    @Override
    public Double method(String s) {
        return null;
    }
}

4.3 自定义泛型方法(成员方法 or 静态方法)

  • 注意：泛型方法与使用泛型的区别
    在这里插入图片描述
package com.generic;

import java.util.ArrayList;

/**
 * @author Gao YongHao
 * @version 1.0
 */
public class Generic04 {
    public static void main(String[] args) {
        Car car = new Car();
        // 当调用方法时，编译器会根据传入参数，确定泛型的具体类型
        car.fly("宝马", 100);

        // 测试
        // T -> String, R -> Array
        Fish<String, ArrayList> fish = new Fish<>();
        fish.hello(new ArrayList(),11.3f);
    }
}

// 泛型方法，可以定义在普通类中，也可以定义在泛型类中
class Car {// 普通类

    public void run() {
    } // 普通方法

    // 说明
    // 1. <T,R> 就是泛型
    // 2. 是提供给 fly 使用的
    public <T, R> void fly(T t, R r) { // 泛型方法

    }
}

class Fish<T, R> { // 泛型类
    public void run() {

    }

    public <U, M> void eat(U u, M m) { // 泛型方法

    }

    // 说明
    // 1. 下面hi方法不是泛型方法
    // 2. 是 hi 方法使用了类声明的 泛型
    public void hi(T t) {

    }

    // 泛型方法，可以使用类声明的泛型，也可以使用自己声明的泛型
    public <K> void hello(R r, K k) {

    }

}

五、泛型的继承和通配符

在这里插入图片描述

package com.generic;

import java.util.List;

/**
 * @author Gao YongHao
 * @version 1.0
 */
public class Generic05 {
    public static void main(String[] args) {

    }

    public static void printCollection1(List<?> c) {
        for (Object o : c) { // 通配符，取出时，就是Object
            System.out.println(o);
        }

    }

    // ? extends AA 表示 上限；可以接受 AA 或者 AA 子类
    public static void printCollection2(List<? extends AA> c) {
        for (Object o : c) { // 通配符，取出时，就是Object
            System.out.println(o);
        }
    }

    // ? super 子类类名AA:支持AA类以及AA类的父类，不限于直接父类
    public static void printCollection3(List<? super AA> c) {
        for (Object o : c) { // 通配符，取出时，就是Object
            System.out.println(o);
        }
    }

}

六、类型擦除

6.1 类型擦除机制介绍

https://blog.csdn.net/briblue/article/details/76736356 Java 泛型，你了解类型擦除吗？

  • 泛型是 Java 1.5 版本才引进的概念，在这之前是没有泛型的概念的，但显然，泛型代码能够很好地和之前版本的代码很好地兼容(之前版本借助Object类型与强制转换作为泛型解决方法)
  • 这是因为，泛型信息只存在于代码编译阶段，在进入 JVM 之前，与泛型相关的信息会被擦除掉，专业术语叫做类型擦除。
  • 通俗地讲，泛型类和普通类在 java 虚拟机内是没有什么特别的地方。回顾文章开始时的那段代码
List<String> l1 = new ArrayList<String>();
List<Integer> l2 = new ArrayList<Integer>();
        
System.out.println(l1.getClass() == l2.getClass());

打印的结果为 true 是因为 List<String> 和 List<Integer> 在 jvm 中的 Class 都是 List.class。
泛型信息被擦除了。
可能同学会问，那么类型 String 和 Integer 怎么办？
答案是 泛型转译

public class Erasure <T>{
    T object;

    public Erasure(T object) {
        this.object = object;
    }
    
}

Erasure 是一个泛型类，我们查看它在运行时的状态信息可以通过反射。

Erasure<String> erasure = new Erasure<String>("hello");
Class eclz = erasure.getClass();
System.out.println("erasure class is:"+eclz.getName());

打印结果是

erasure class is:com.frank.test.Erasure

Class 的类型仍然是 Erasure 并不是 Erasure<T> 这种形式，那我们再看看泛型类中 T 的类型在 jvm 中是什么具体类型

Field[] fs = eclz.getDeclaredFields();
for ( Field f:fs) {
    System.out.println("Field name "+f.getName()+" type:"+f.getType().getName());
}

打印结果是

Field name object type:java.lang.Object

那我们可不可以说，泛型类被类型擦除后，相应的类型就被替换成 Object 类型呢？
这种说法，不完全正确。
我们更改一下代码

public class Erasure <T extends String>{
//    public class Erasure <T>{
    T object;

    public Erasure(T object) {
        this.object = object;
    }
    
}

现在再看测试结果

Field name object type:java.lang.String

我们现在可以下结论了，在泛型类被类型擦除的时候，之前泛型类中的类型参数部分如果没有指定上限，如 <T> 则会被转译成普通的 Object 类型，如果指定了上限如 <T extends String> 则类型参数就被替换成类型上限。
所以，在反射中。

public class Erasure <T>{
    T object;

    public Erasure(T object) {
        this.object = object;
    }
    
    public void add(T object){
        
    }
    
}

add() 这个方法对应的 Method 的签名应该是 Object.class。

Erasure<String> erasure = new Erasure<String>("hello");
Class eclz = erasure.getClass();
System.out.println("erasure class is:"+eclz.getName());

Method[] methods = eclz.getDeclaredMethods();
for ( Method m:methods ){
    System.out.println(" method:"+m.toString());
}

打印结果是

method:public void com.frank.test.Erasure.add(java.lang.Object)

也就是说，如果你要在反射中找到 add 对应的 Method，你应该调用 getDeclaredMethod("add",Object.class) 否则程序会报错，提示没有这么一个方法，原因就是类型擦除的时候，T 被替换成 Object 类型了。

6.2 类型擦除带来的局限性

  • 类型擦除，是泛型能够与之前的 java 版本代码兼容共存的原因。但也因为类型擦除，它会抹掉很多继承相关的特性，这是它带来的局限性
  • 理解类型擦除有利于我们绕过开发当中可能遇到的雷区，同样理解类型擦除也能让我们绕过泛型本身的一些限制。比如
    在这里插入图片描述

正常情况下，因为泛型的限制，编译器不让最后一行代码编译通过，因为类似不匹配，但是，基于对类型擦除的了解，利用反射，我们可以绕过这个限制。

public interface List<E> extends Collection<E>{
    
     boolean add(E e);
}

上面是 List 和其中的 add() 方法的源码定义。
因为 E 代表任意的类型，所以类型擦除时，add 方法其实等同于

boolean add(Object obj);

那么，利用反射，我们绕过编译器去调用 add 方法。

public class ToolTest {


    public static void main(String[] args) {
        List<Integer> ls = new ArrayList<>();
        ls.add(23);
//        ls.add("text");
        try {
            Method method = ls.getClass().getDeclaredMethod("add",Object.class);
            
            
            method.invoke(ls,"test");
            method.invoke(ls,42.9f);
        } catch (NoSuchMethodException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (SecurityException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IllegalArgumentException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (InvocationTargetException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        
        for ( Object o: ls){
            System.out.println(o);
        }
    
    }

}

打印结果是：

23
test
42.9

可以看到，利用类型擦除的原理，用反射的手段就绕过了正常开发中编译器不允许的操作限制。

七、JUnit

在这里插入图片描述

在这里插入图片描述

八、泛型细节

8.1 泛型类或者泛型方法中，不接受 8 种基本数据类型

所以，你没有办法进行这样的编码。

List<int> li = new ArrayList<>();
List<boolean> li = new ArrayList<>();

需要使用它们对应的包装类。

List<Integer> li = new ArrayList<>();
List<Boolean> li1 = new ArrayList<>();

8.2 对泛型方法的困惑

public <T> T test(T t){
    return null;
}

有的同学可能对于连续的两个 T 感到困惑，其实 <T> 是为了说明类型参数，是声明,而后面的不带尖括号的 T 是方法的返回值类型。 你可以相像一下，如果 test() 这样被调用

test("123");

那么实际上相当于

public String test(String t);

8.3 Java 不能创建具体类型的泛型数组

这句话可能难以理解，代码说明。

List<Integer>[] li2 = new ArrayList<Integer>[];
List<Boolean> li3 = new ArrayList<Boolean>[];

这两行代码是无法在编译器中编译通过的。原因还是类型擦除带来的影响。
List<Integer> 和 List<Boolean> 在 jvm 中等同于 List<Object>，所有的类型信息都被擦除，程序也无法分辨一个数组中的元素类型具体是 List<Integer> 类型还是 List<Boolean> 类型。
但是

List<?>[] li3 = new ArrayList<?>[10];
li3[1] = new ArrayList<String>();
List<?> v = li3[1];

借助于无限定通配符却可以，前面讲过 ? 代表未知类型，所以它涉及的操作都基本上与类型无关，因此 jvm 不需要针对它对类型作判断，因此它能编译通过，但是，只提供了数组中的元素因为通配符原因，它只能读，不能写。比如，上面的 v 这个局部变量，它只能进行 get() 操作，不能进行 add() 操作，这个在前面通配符的内容小节中已经讲过。

ModelBulider
关注
  • 30
    点赞
  • 踩
  • 14
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
JavaSE十三（泛型）
qq_46002941的博客
10-20 194
文章目录泛型1.1 泛型概述1.2 泛型类1.3 泛型方法1.4泛型接口1.5 类型通配符1.6 可变参数1.7 可变参数的使用 泛型 1.1 泛型概述 泛型：是JDK5之后引入的新特性，它提供了编译时类型安全检测机制，该机制允许编译时检测到非法的类型，它的本质是参数化类型， 也就是说所操作的数据类型被指定为一个参数 一提到参数，最熟悉的就是定义方法时有形参，然后调用此方法时传递实参。那么参数化类型怎么理解呢？ 顾名思义，就是将类型由原来的具体的类型参数化，然后在使用/调用时传入具体的类型 这种参数类型可以
十三：泛型
weixin_44330782的博客
03-25 126
十三：泛型 1、泛型的概念 泛型的设计背景 集合容器类在设计阶段/声明阶段不能确定这个容器到底实际存的是什么类型的 对象，所以在JDK1.5之前只能把元素类型设计为Object，JDK1.5之后使用泛型来解决。因为这个时候除了元素的类型不确定，其他的部分是确定的，例如关于这个元素如何保存，如何管理等是确定的，因此此时把元素的类型设计成一个参数，这个类型参数叫做泛型。Collection，List，ArrayList 这个就 是类型参数，即泛型。 泛型的概念 所谓泛型，就是允许在定义类、接口时通过一
十、泛型
lsssssssssssy的博客
04-26 99
目录一、概述二、在集合中使用泛型三、自定义泛型结构3.1 自定义泛型类、泛型接口3.2 自定义泛型方法3.3 DAO四、泛型在继承上的体现五、通配符的使用5.1 <?>5.2 有限制的通配符 一、概述 泛型：允许在定义类、接口时通过一个标识表示类中某个属性的类型或者是某个方法的返回值及参数类型。这个类型参数将在使用时（例如， 继承或实现这个接口，用这个类型声明变量、创建对象时）确...
第十三章 泛型
目小温的博客
07-12 104
0712 学习记录
十九 C# 泛型
Mwyldnje2003的博客
03-14 998
1、泛型概述 泛型（Generics）是将类型作为参数传递给类、结构、接口和方法，这些参数通常被称作站位符，是类、就结构、接口和方法所存储或使用的一个或多个类型的占位符。 泛型集合是可以将类型参数用作它所存储的对象的类型的占位符：类型参数作为其字段的类型和其方法的参数类型出现。 泛型方法可以将其类型参数用作其返回值的类型或者其参数的类型之一。 泛型为开发者提供了一种高性能的编程方式，能够提高代码的重用性，并允许开发者别写非常有效的解决防范。 使用泛型可以提高性能，其中显著的一个改进是.NET框架组件不会在
第十三章、 泛型
qq_64226679的博客
08-29 675
基本语法class 类名{成员注意细节（1）. 普通成员可以使用泛型（方法、属性）（2）. 使用泛型的数组，不能初始化（3）. 静态方法中不能使用类的泛型（4）. 泛型类的类型，是在创建对象时确定的（因为创建对象时，需要指定确定类型）（5）. 如果在创建对象时，没有指定类型，默认为Object/*** @aim java基础学习* @note java笔记*///1.Tiger 后面加有泛型，所以就可以称 为自定义泛型类。
Java六十三： 泛型
开发者
11-29 267
泛型 引用 标签 设计背景 集合容器类在设计阶段/声明阶段不能确定这个容器到底实际存的是什么类型的对象，所以在jdk5之前只能把元素类型设计为Object； jdk5之后使用泛型来解决：因为这个时候除了元素的类型不确定，其他部分是确定的，例如关于这个元素如何保存，如何管理等，因此此时把元素的类型设计成一个参数，这个类型参数叫做泛型。 Collection ，List，ArrayList 这个就是类型参数，就是泛型 一、集合中的泛型 在集合中使用泛型 ① 集合接口或集合类在jd
第十三章 泛型程序设计
03-20
**第十三章 泛型程序设计** 泛型是Java编程语言中的一个重要特性，引入于Java 5.0，它允许在定义类、接口和方法时使用类型参数，从而提高了代码的类型安全性和重用性。泛型的主要目标是提供一种方式来限制容器对象...
十三、集合进阶 泛型的继承和通配符
02-18
主要有三种类型的通配符： - `?` 无界通配符：代表任何类型，如`List<?>`表示可以包含任何类型的列表。 - `? extends T` 上界通配符：表示类型为T或T的任何子类型，如`List<? extends Number>`可以接受Number或其...
三十分钟掌握STL(泛型编程)
12-27
### STL(Standard Template Library)概览与核心概念 #### STL的重要性及特点 STL，即标准模板库（Standard Template Library），是C++标准库的重要组成部分，它为开发者提供了丰富的工具集，涵盖了数据结构、算法...
Spring(十三)--Spring泛型处理
Xjzzon的博客
10-11 513
Java5类型接口-java.lang.reflect.Type Java泛型反射API Spring泛型类型辅助类 核心API-org.springframework.core.GenericTypeResolver 1.处理类型相关(Type)相关方法 resolveReturnType: 获取方法返回值的Type resolveType: 2.处理泛型参数类型(ParameterizedType)相关方法 resolveReturnTypeArgument: 获取方法返回值的泛型参数.
Java基础（6）- Java代码笔记3
weixin_47062560的博客
08-30 1508
数据类型[][] 数组名 = new 数据类型[m][n]数据类型 数组名[][] = new 数据类型[m][n]数据类型[] 数组名[] = new 数据类型[m][n]m：代表二维数组长度n：代表二维数组中每个一维数组的长度。
浅析synchronized锁升级的原理与实现 1
最新发布
水w的博客
09-01 940
浅析synchronized锁升级的原理与实现
[C++规范] 访问类成员变量的方式：直接访问还是通过成员函数访问？
热门推荐
Loewen丶的小窝
08-26 1万+
在面向对象编程（OOP）中，通过成员函数（如`ME_HardwareTypeEnum Type() const;` 和 `int Id() const;`）来访问类的私有或受保护成员（如`m_hardwareType` 和 `m_id`），而不是直接通过公共成员访问，是一种更好的做法。
《深入理解 Java 中的适配器模式》
面团到油条的成长日记
08-29 7037
在软件开发的广阔领域中，不同接口之间不匹配的问题时常像个棘手的难题困扰着开发者。而适配器模式就像是一位得力的助手，专门用来解决这类问题。它的关键作用在于把一个类的接口有效地转化为客户端所期望的另一种接口，让原本因接口不相符而不能一起工作的两个类可以共同协作，学习本文希望你能有所收获
Java设计模式之建造者模式详细讲解和案例示范
weixin_39996520的博客
08-28 5483
建造者模式是一种创建型设计模式，允许用户通过一步步地构造复杂对象的方式来避免直接使用大量的构造函数或复杂的初始化过程。它通过将对象的创建过程分解为多个步骤，并允许这些步骤以链式调用的方式来执行，最终生成一个完全构建的对象。首先，我们定义一个Order类，该类包括了多个字段，如订单ID、客户信息、商品列表、配送地址等。// Getter方法省略...在这个例子中，类提供了构建Order对象所需的各个方法，每个方法返回实例，以便进行链式调用。
C++的内存模型
qhu1600417010的博客
08-28 1127
C++ 的内存模型包含了程序运行时如何分配、访问、管理内存的规则，涵盖了多线程环境下的数据一致性、内存对齐、以及虚拟内存管理等内容。掌握这些概念对于编写高效、安全的 C++ 程序至关重要。
输入三个正整数，找出不大不小的值
laocooon的博客
08-30 944
/ 找出最大值，找出最小值，然后不是最大值也不是最小值的。// 2、输入三个正整数，找出不大不小的值。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

ModelBulider

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值