Java泛型笔记

已于 2022-12-28 18:25:55 修改
阅读量257 收藏
点赞数
文章标签： java 开发语言 jvm
于 2022-12-03 16:58:11 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_68239185/article/details/128065306
版权

Java泛型

泛型的理解与应用

泛型的声明与使用

  • 主要原理是在类声明时通过一个标识表示类中某个属性的类型或者是某个方法的返回值及参数类型。

  • 泛型的声明：

//泛型类的声明:
[访问权限] class 类名称<泛型类型标识1，泛型类型标识2...泛型类型标识3>{
	[访问权限] 泛型类型标识 变量名称;
	[访问权限] 泛型类型标识 方法名称() {};
	[访问权限] 返回值类型声明 方法名称(泛型类型标识 变量名称) {};
}

//泛型对象的声明
类名称<具体类> 对象名称 = new 类名称<具体类>();
  • 例子：
public class GenericsState {

    public static void main(String[] args) {
        GenericsTest1<String> test1 = new GenericsTest1<String>();
        test1.setVar("张三");
        String name = test1.getVar();

        GenericsTest1<Integer> test2 = new GenericsTest1<Integer>();
        test2.setVar(20);
        int age = test2.getVar();

        GenericsTest1<Double> test3 = new GenericsTest1<Double>();
        test3.setVar(78.5);
        double y = test3.getVar();
        System.out.println("name:\t" + name);
        System.out.println("age:\t" + age);
        System.out.println("y:\t" + y);
    }
}


class GenericsTest1<T> {
    private T var;

    public T getVar() {
        return var;
    }

    public void setVar(T var) {
        this.var = var;
    }
}

泛型的最大好处实际就是避免了类转换异常。

泛型应用中的构造方法

[访问权限] 构造方法 ([泛型类型 参数名称]){
}
  • 例子：
public class GenericsState {

    public static void main(String[] args) {
        GenericsTest1<Integer> test = null;
        test = new GenericsTest1<Integer>(20);
        System.out.println("age = " + test.getVar());
    }
}


class GenericsTest1<T> {
    public GenericsTest1(T var) {
        this.var = var;
    }

    private T var;

    public T getVar() {
        return var;
    }

    public void setVar(T var) {
        this.var = var;
    }
}

通配符

  • 在泛型类的操作中，在进行引用传递时泛型类型必须匹配才可以传递，否则是无法传递的。
  • 通配符“？”，表示可以接收此类型的任意泛型对象。如果使用“？”泛型对象时，则不能设置被指定的内容。
    • 例子：
public class SendGenerics {

    public static void main(String[] args) {
        GenericsTest4<String> test1 = new GenericsTest4<String>();
        test1.setVar("张三");
        fun(test1);
        GenericsTest4<?> test2 = new GenericsTest4<String>();
        test.setVar("李四");//报错，违规
        test.setVar(null);//可以
    }

    public static void fun(GenericsTest4<?> temp){
        System.out.println("内容 = " + temp.getVar());
    }
}

class GenericsTest4<T> {
    private T var;

    public T getVar() {
        return var;
    }

    public void setVar(T var) {
        this.var = var;
    }
}

受限泛型

  • 设置上限
    • 现在假设一个方法中能接收的泛型对象只能是数字类型，此时定义方法参数接收对象时，就必须指定泛型的上限。因为所有包装类都是Number类的子类。
//声明对象
类名称<? extends 类> 对象名称
//定义类
[访问权限] 类名称<泛型标识 extends 类>{}

例子：

public class GenericsDemo {
    public static void main(String[] args) {
        Info<Integer> i1 = new Info<Integer>();
        Info<Float> i2 = new Info<Float>();
        i1.setVar(30);
        i2.setVar(30.2f);
        System.out.println("内容：" + i1.getVar());
        fun(i1);
        fun(i2);
    }
	//接受Info对象，设置上限为Number，所以只能接收数字类型。（在Info没有被设置上限的情况。）
    public static void fun(Info<? extends Number> temp){
        System.out.println(temp.getVar() + "、");
    }
}

//此处的泛型只能是数字类型
class Info<T extends Number> {
    private T var;

    public Info() {
    }

    public Info(T var) {
        this.var = var;
    }

    public T getVar() {
        return var;
    }

    public void setVar(T var) {
        this.var = var;
    }
}
  • 设置下限
    • 当使用的泛型只能在本类及其父类类型上应用时，就必须使用泛型的范围下限进行配置。
//声明对象
类名称<? super 类> 对象名称
//定义类
[访问权限] 类名称 <泛型标识 extends 类>{}

例子

package Generics;

public class GenericsLower {
    public static void main(String[] args) {
        Info1<String> i1 = new Info1<String>();
        Info1<Object> i2 = new Info1<Object>();
        i1.setVar("张三");
        i2.setVar(new Object());
        fun(i1);
        fun(i2);
    }

    //只能接收String或Object类的泛型。
    public static void fun(Info1<? super String> temp) {
        System.out.println("内容：" + temp);
    }
}

class Info1<T> {
    private T var;

    public T getVar() {
        return var;
    }

    public void setVar(T var) {
        this.var = var;
    }

    @Override
    public String toString() {
        return this.var.toString();
    }
}

泛型与子类继承的限制

  • 一个子类可以通过对象多态性为其父类实例化，但是在泛型操作中，子类的泛型类型时无法使用父类的泛型类型接收的。
/**
 * 以下代码中错误提示是不匹配类型，Info<String>无法转换
 * 为Info<Object>。虽然String是Object的子类，但是在
 * 泛型的使用中此概念无效，此时只能应用"?"接收。
 */

public class GenericsInterface {
    public static void main(String[] args) {
        Info<String> i1 = new Info<String>();
        Info<Object> i2 = null;
        i2 = i1;
    }
}

泛型接口

泛型接口的定义

[访问权限] interface 接口名称<泛型标识> {
}

//例如：
public interface Info<T> {
	public T getVar();
}

泛型接口的两种实现方式

  • 接口定义后就要定义此接口的子类，定义泛型接口的子类有两种方式

    • 一种是直接在子类后声明泛型。
    • 另一种是直接在子类实现的接口中明确的给出泛型的类型。

  • 在子类的定义上声明泛型类型

public class GenericsInterface {
    public static void main(String[] args) {
        Infolmpl<String> i = null;
        i = new Infolmpl<String>("张三");
        System.out.println("内容：" + i.getVar());
    }
}

interface Info2<T> {
    public T getVar();
}

class Infolmpl<T> implements Info2<T> {
    private T var;

    public Infolmpl(T var) {
        this.var = var;
    }

    @Override
    public T getVar() {
        return var;
    }

    public void setVar(T var) {
        this.var = var;
    }
}
  • 直接在接口中定义指定具体类型
public class GenericsInterface {
    public static void main(String[] args) {
        Infolmpl1<String> i1 = new Infolmpl1<String>("李四");
        System.out.println("内容：" + i1.getVar());
    }
}

interface Info2<T> {
    public T getVar();
}

class Infolmpl1<T> implements Info2<String> {
    private String var;

    public Infolmpl1(String var) {
        this.var = var;
    }

    @Override
    public String getVar() {
        return var;
    }

    public void setVar(String var) {
        this.var = var;
    }
}

泛型方法

定义与使用

  • 在泛型方法中可以定义泛型参数，此时，参数的类型就是传入数据的类型。
[访问权限] <泛型标识> 泛型标识 方法名称([泛型标识 泛型名称])

//例子：
public <T> T fun(T t){
	return t;
}
  • 如果可以通过泛型方法返回一个泛型类型的实例化对象，则必须在方法的返回类型声明处明确地指定泛型标识。
package Generics;

public class GenericFun {
    public static void main(String[] args) {
        Info3<Integer> i = fun(30);
        System.out.println("内容：" + i.getVar());
    }

	//<T extends Number>表示给方法中传入或返回的泛型类型由调用方法时所设置的参数类型决定。
	//Info3 <T>表示返回为Info类的对象。
    public static <T extends Number> Info3 <T> fun(T t) {
        Info3<T> info = new Info3<T>();
        info.setVar(t);
        return info;
    }
}

class Info3<T extends Number> {
    private T var;

    public T getVar() {
        return var;
    }

    public void setVar(T var) {
        this.var = var;
    }
}

使用泛型统一传入的参数类型

  • 如果现在一个方法要求传入的泛型类型一致，也可以通过泛型方法指定。
public class GenericFun {
    public static void main(String[] args) {
      Info3<String> i1 = new Info3<String>();
      Info3<String> i2 = new Info3<String>();
      i1.setVar("hello");
      i2.setVar("world");
      add(i1, i2);
    }
	
	//<T>表示泛型方法
	//此处的i1和i2对象的泛型类型必须一致，不一致编译时会报错。
    public static <T> void add(Info3 i1,Info3 i2) {
        System.out.println(i1.getVar() + " " +  i2.getVar());
    }
}

class Info3<T> {
    private T var;

    public T getVar() {
        return var;
    }

    public void setVar(T var) {
        this.var = var;
    }
}

泛型数组

  • 使用泛型方法时，也可以传递或返回一个泛型数组。
public class GenericArray {
    public static void main(String[] args) {
        Integer i[] = fun1(1,2,3,4,5,6);
        fun2(i);
    }

    //接收可变参数，返回泛型数组。
    public static <T> T[] fun1(T... arg) {
        return arg;
    }

    //接收泛型数组。
    public static <T> void fun2(T a[]) {
        System.out.println("接收泛型数组：");
        for (T t : a){
            System.out.print(t + "、");
        }
        System.out.println();
    }
}

泛型的嵌套设置

  • 泛型也可以在一个类的泛型中指定另外一个类的泛型。
package Generics;

public class GenericNested {
    public static void main(String[] args) {
        Demo<Info4<String,Integer>> d = null;
        Info4<String,Integer> i = null;
        i = new Info4<String,Integer>("张三",25);
        d = new Demo<Info4<String,Integer>>(i);
        System.out.println("内容一：" + d.getInfo().getVar());
        System.out.println("内容二：" + d.getInfo().getValue());
    }
}

class Info4<T,V> {
    private T var;
    private V value;

    public Info4(T var, V value) {
        this.var = var;
        this.value = value;
    }

    public T getVar() {
        return var;
    }

    public void setVar(T var) {
        this.var = var;
    }

    public V getValue() {
        return value;
    }

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

class Demo<S> {
    private S info;

    public Demo(S info) {
        this.info = info;
    }

    public S getInfo() {
        return info;
    }

    public void setInfo(S info) {
        this.info = info;
    }
}
云树和雨
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
使用hutool工具判断字符串是否全部是字母(包括大小写)，java判断字符串是否全部是字母(包括大小写)
qq_43700885的博客
07-29 259
1.导入hutool的maven依赖。2.复制一下代码执行。
golang 接口
m0_70982551的博客
07-24 1038
接口定义了一组方法，这些方法没有具体的实现。接口类型的变量可以存储任何实现了这些方法的类型的值。// 更多方法...在Go语言中，接口值是指存储了实现某个接口的具体类型值的变量。接口值由两部分组成：1.动态类型：这是接口值当前存储的实际类型。2.动态值：这是实际存储的值，该值必须实现了接口中定义的所有方法。
java判断邮箱地址是否正确，使用hutool工具判断邮箱地址是否正确
qq_43700885的博客
07-29 110
1.导入hutool的maven依赖。2.直接复制一下代码运行。
Swagger使用Map接受参数时，页面如何显示具体参数及说
a1058926697的博客
07-26 565
后端使用Map接受参数，要求在swagger页面上显示具体的参数名称、类型及说明。当Map接受参数数量少时，可以使用Swagger自带的注解。自定义注解 @ApiGlobalModel。编写处理注解对应的插件。
26.jdk源码阅读之ConcurrentLinkedQueue
最新发布
前端、移动端、后端源码级底层原理分享
07-29 744
ConcurrentLinkedQueue 是 Java 中提供的一个基于无界非阻塞算法的线程安全队列。它是一个适用于高并发环境的队列实现，基于链表结构。
Java的@DateTimeFormat注解与@JsonFormat注解的使用对比
訾博（ZiBo）的博客
07-27 690
在Spring和Jackson框架中，日期和时间格式化是一个常见需求。注解主要用于Spring的表单绑定，而注解则用于Jackson的JSON序列化和反序列化。了解这两个注解的使用场景和方法，可以帮助开发者更高效地处理日期和时间。和是处理日期和时间格式化的两个重要注解。主要用于Spring MVC的请求参数绑定，而主要用于Jackson的JSON序列化和反序列化。了解它们的使用场景和功能，可以帮助开发者更高效地处理日期和时间格式化需求。通过本文的介绍，希望读者能够更清晰地理解和。
Java修炼 2024.7.26 0:24
2301_80011650的博客
07-26 441
问题：编写一个方法，找出一个数组中的众数（出现次数超过数组长度一半的元素）。例如，输入 [2, 2, 1, 1, 2]，输出 2。编写一个方法，找出一个整数数组中的第二大元素。例如，输入 [3, 5, 1, 8, 7]，输出 7。例如，输入 5，输出 5。问题：编写一个方法，将给定的字符串逆转。问题：使用数组实现栈，并提供基本操作（push、pop、peek、isEmpty）。问题：实现一个单向链表，并提供基本的操作（添加、删除、查找元素）。问题：编写一个方法来查找一个给定字符串的所有子串。
Java代码基础算法练习-数的特性-2024.07.25
Sakurapaid的博客
07-25 389
小A喜欢两种性质都成立的数字，小B喜欢至少符合一种性质的数字，小C喜欢不符合这两种性质的 数字。给出一个数字，请输出三个人是否喜欢这个数字。如果喜欢输出1，否则输出0，用空格分隔。输入数字 num，先定义三个整型代表三个人的喜欢与否，先默认设为 0。之后判断num对于性质1、2的条件，分别用 boolen 类型标识。对于每个整型进行判断，是否改为 1 代表喜欢。性质2：大于4且不大于12;
新建springboot项目找不到java版本8?
weixin_74009895的博客
07-28 139
新建springboot项目找不到java版本8?
SSM框架整合——常用方式整合SSM框架（三）Spring和MyBatis整合
PAP
07-26 202
SSM框架整合——常用方式整合SSM框架（三）Spring和MyBatis整合
高级java每日一道面试题-2024年7月29日-并发篇-什么时候用乐观锁,什么时候用悲观锁?
qq_43071699的博客
07-29 339
悲观锁适用于数据竞争激烈的场景，能够提供强一致性，但可能导致较多的线程等待。乐观锁适用于读多写少的场景，能够提供更高的并发性能，但可能需要多次尝试才能成功更新数据。
19.jdk源码阅读之FutureTask
前端、移动端、后端源码级底层原理分享
07-25 877
FutureTask 是 Java 并发包中的一个重要类，它实现了 RunnableFuture 接口，结合了 Future 和 Runnable 的特性。FutureTask 通常用于异步任务的执行和结果的获取。
c++ 智能指针shared_ptr与make_shared
Txwtech笛克特科
07-25 289
shared_ptr是C++11引入的一种智能指针，‌它允许多个shared_ptr实例共享同一个对象，‌通过引用计数来管理对象的生命周期。‌当最后一个持有对象的shared_ptr被销毁时，‌它会自动删除所指向的对象。‌这种智能指针主要用于解决资源管理问题，‌避免内存泄漏。make_shared是C++标准库中的一个函数，‌用于创建一个shared_ptr智能指针，‌它接受一个或多个参数来构造一个对象，‌并返回一个指向该对象的shared_ptr。类SerialModbus的成员指针。
Java —— 线程
JL_L666的博客
07-26 669
程序(program)：为完成特定的任务，选用某一种语言编写的，即指，静态对象。进程(process)：程序的一次执行过程，或是。程序是静态的、进程是。进程是调度和分配资源的最小单位。注意：不同的进程之间是不共享内存的、进程之间的数据交换和通信的成本很高。线程(thread)：进程可以进一步细化为线程，是运行中进程的一条或多条执行路径。线程调度策略单核CPU与多核CPU并行与并发上。
Jvm基础（一）
G81948577的博客
07-19 1184
本地方法就是不使用java编写的，比如C++编写的程序，只是需要传递参数。
教务管理平台/高校教务管理系统的设计与实现/教务网站/学生成绩管理系统/学生课程管理系统
weixin_47958760的博客
07-27 788
本毕业设计的内容是设计并且实现一个基于JSP技术的教务管理平台。采用MYSQL为数据库开发平台，SSM框架，Tomcat网络信息服务作为应用服务器。教务管理平台的功能已基本实现，主要有学生、教师、课程信息、课程选择、教师课表、学生成绩、图书信息、考试等管理功能。 论文主要从系统的分析与设计 、数据库设计和系统的详细设计等几个方面来进行论述，系统分析与设计部分主要论述了系统的功能分析、系统的设计思路，数据库设计主要论述了数据库的设计，系统的详细设计部分主要论述了几个主要模块的详细设计过程。
PHP中static的使用
likeshopgood的博客
07-24 891
本文详细介绍了PHP中static关键字的使用，并通过实例展示了其强大功能。利用静态属性和方法，我们可以在类实例间共享数据和行为，从而提高代码的效率和可维护性。然而，使用静态成员时，需注意内存管理和访问权限的特殊性，以确保代码的健売性和可管理性。关于我们本文由ChatMoney团队出品，ChatMoney专注于AI应用落地与变现，我们提供全套、持续更新的AI源码系统与可执行的变现方案，致力于帮助更多人利用AI来变现，欢迎进入ChatMoney获取更多AI变现方案！
Java 使用 POI 导出Excel，设置同一个单元格的内容显示不同的文字颜色
viman3344的专栏
07-27 381
在使用Apache POI的库生成Excel的时候，如何在一个Cell中的文字中显示不同的颜色？下面是一个示例代码，演示如何在单元格中设置不同颜色的文本。more。
关于Jenkins自动化部署Maven项目:
gzx233的博客
07-27 921
测试工程:Jenkins自动化部署maven项目全流程
Java泛型深入理解与应用
"java李兴华学习笔记之泛型" 在Java编程中，泛型是自JDK 1.5版本引入的一个重要特性，它极大地提高了代码的类型安全性和重用性。李兴华老师的课程主要关注如何利用泛型来优化程序设计。下面将详细讲解泛型的基本...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值