Java 方法前面加 ＜T＞ 是做什么？泛型方法 原理、样例

已于 2024-10-02 22:42:41 修改
阅读量595 收藏 7
点赞数 7
分类专栏： 日常开发 Java 文章标签： java java-ee
于 2024-10-02 17:48:05 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/matrixlzp/article/details/142674916
版权

在 Java 中，方法前面加上 <T> 表示该方法是一个泛型方法。泛型方法允许你在方法签名中指定一个或多个类型参数，从而使得该方法可以处理多种类型的对象。这增加了代码的灵活性和复用性。

一、基本语法

<T1, T2, ..., Tn> 返回类型 方法名(形参列表) {
    // 方法体
}
  • <T1, T2, ..., Tn>：类型参数列表，可以有一个或多个类型参数。
  • 返回类型：方法的返回类型，可以是具体的类型，也可以是类型参数。
  • 方法名：方法的名称。
  • 形参列表：方法的参数列表，可以使用类型参数作为参数类型。

 二、代码示例

1. 单个类型参数的泛型方法

 假设现在富士康（Foxconn）要生产一批手机，它给手机厂商定下了一个规范：

package com.study.genericity.entity;

/**
 * 富士康的手机生产规范
 */
public abstract class MobilePhone {
    abstract void produce();
}

 OPPO、Huawei 都按照 富士康 的规范（extends MobilePhone）生产手机：

package com.study.genericity.entity;
import lombok.AllArgsConstructor;

@AllArgsConstructor
public class OPPO extends MobilePhone {
    /** 型号 */
    private String model;
    /** 颜色 */
    private String color;
    /** 运行内存 */
    private String ram;
    /** 存储 */
    private String rom;

    @Override
    public void produce() {
        System.out.println("正在生产 OPPO手机 ：型号-"+model+" 颜色-"+color+" 运行内存-"+ram+" 存储容量-"+rom);
    }
}
----------------------------------------
package com.study.genericity.entity;
import lombok.AllArgsConstructor;

@AllArgsConstructor
public class Huawei extends MobilePhone {
    /** 型号 */
    private String model;
    /** 颜色 */
    private String color;
    /** 是否折叠 */
    private boolean foldOrNot;
    /** 运行内存 */
    private String ram;
    /** 存储 */
    private String rom;

    @Override
    public void produce() {
        String description = "正在生产 华为手机 ："+(foldOrNot?"折叠屏 ":"")+model+" "+color+" "+ram+" "+rom;
        System.out.println(description);
    }
}

 富士康 为他们开了一条通用生产线生产手机：

package com.study.genericity.entity;

public class Foxconn {
    /** 富士康通用生产线 */
    public static void produce(MobilePhone mobilePhone) {
        mobilePhone.produce();
    }

    public static void main(String[] args) {
        OPPO oppo = new OPPO("Find X7", "白日梦想家", "12GB", "256GB");
        produce(oppo);
        Huawei huawei = new Huawei("Pocket 2", "洛可可白", true, "12GB", "256GB");
        produce(huawei);
    }
}
输出：
正在生产 OPPO手机 ：型号-Find X7 颜色-白日梦想家 运行内存-12GB 存储容量-256GB
正在生产 华为手机 ：折叠屏 Pocket 2 洛可可白 12GB 256GB

 这个时候来了苹果，他们委托 富士康 生产新版 iPhone。

不过苹果 它财大气粗，它有自己的手机生产规范：

package com.study.genericity.entity;

/**
 * 苹果自己的移动产品生产规范
 */
public abstract class AppleMobile {

    abstract void producePhone();
}
----------------------------------------
package com.study.genericity.entity;

import lombok.AllArgsConstructor;

@AllArgsConstructor
public class Apple extends AppleMobile {
    /** 型号 */
    private String model;
    /** 颜色 */
    private String color;
    /** 运行内存 */
    private String ram;
    /** 存储 */
    private String rom;

    @Override
    public void producePhone() {
        System.out.println("正在生产 尊贵的iPhone :"+model+" "+color+" "+ram+" "+rom);
    }
}

 富士康 本来想拒绝，因为苹果的生产流程已经继承了 AppleMobile 规范, 无法再继承 MobilePhone 规范，两个规范并不兼容（Java 单继承）。但如果为苹果单开一条生产线，成本又特别高昂。

package com.study.genericity.entity;

public class Foxconn {
    /** 富士康通用生产线 */
    public static void produce(MobilePhone mobilePhone) {
        mobilePhone.produce();
    }

    /** 为苹果单开一条流水线 */
    public static void produce(AppleMobile appleMobile) {
        appleMobile.producePhone();
    }

    public static void main(String[] args) {
        OPPO oppo = new OPPO("Find X7", "白日梦想家", "12GB", "256GB");
        produce(oppo);
        Huawei huawei = new Huawei("Pocket 2", "洛可可白", true, "12GB", "256GB");
        produce(huawei);
        Apple apple = new Apple("iPhone 16 Pro", "白", "16GB", "128GB");
        produce(apple);
    }
}
输出：
正在生产 OPPO手机 ：型号-Find X7 颜色-白日梦想家 运行内存-12GB 存储容量-256GB
正在生产 华为手机 ：折叠屏 Pocket 2 洛可可白 12GB 256GB
正在生产 尊贵的iPhone :iPhone 16 Pro 白 16GB 128GB

 这可愁坏了 富士康 的老总，这个时候，聪明的工程师 小林 为老板想了一个办法，他用 泛型方法 的方式，定义了一条通用的流水线，可以忽略类型规范：

package com.study.genericity.entity;

import java.util.function.Consumer;

public class Foxconn {

    /** 用 泛型方法 定义通用生产流水线 */
    public static <T> void produce(Consumer<T> consumer, T phone) {
        consumer.accept(phone);
    }

    public static void main(String[] args) {
        OPPO oppo = new OPPO("Find X7", "白日梦想家", "12GB", "256GB");
        produce(OPPO::produce, oppo);
        Huawei huawei = new Huawei("Pocket 2", "洛可可白", true, "12GB", "256GB");
        produce(Huawei::produce, huawei);
        Apple apple = new Apple("iPhone 16 Pro", "白", "16GB", "128GB");
        // 苹果 定制化生产
        produce(Apple::producePhone, apple);
    }
}
输出：
正在生产 OPPO手机 ：型号-Find X7 颜色-白日梦想家 运行内存-12GB 存储容量-256GB
正在生产 华为手机 ：折叠屏 Pocket 2 洛可可白 12GB 256GB
正在生产 尊贵的iPhone :iPhone 16 Pro 白 16GB 128GB

富士康 老板高兴坏了，因为这条流水线太好用，老板甚至放弃了自定义的手机生产规范 MobilePhone，给手机厂商更高的自由度（不用再继承 MobilePhone），去生产定制化的手机产品：

package com.study.genericity.entity;
import lombok.AllArgsConstructor;

@AllArgsConstructor
public class Huawei {
    /** 型号 */
    private String model;
    /** 颜色 */
    private String color;
    /** 是否折叠 */
    private boolean foldOrNot;
    /** 运行内存 */
    private String ram;
    /** 存储 */
    private String rom;
    /** 定制化生产 */
    public void produceHuawei() {
        String description = "正在生产 华为手机 ："+(foldOrNot?"折叠屏 ":"")+model+" "+color+" "+ram+" "+rom;
        System.out.println(description);
    }
}
---------------------------------------------
package com.study.genericity.entity;
import lombok.AllArgsConstructor;

@AllArgsConstructor
public class OPPO {
    /** 型号 */
    private String model;
    /** 颜色 */
    private String color;
    /** 运行内存 */
    private String ram;
    /** 存储 */
    private String rom;
    /** 定制化生产 */
    public void produceOPPO() {
        System.out.println("正在生产 OPPO手机 ：型号-"+model+" 颜色-"+color+" 运行内存-"+ram+" 存储容量-"+rom);
    }
}
---------------------------------------------
package com.study.genericity.entity;

import java.util.function.Consumer;

public class Foxconn {

    /** 用 泛型方法 定义通用生产流水线 */
    public static <T> void produce(Consumer<T> consumer, T phone) {
        consumer.accept(phone);
    }

    public static void main(String[] args) {
        OPPO oppo = new OPPO("Find X7", "白日梦想家", "12GB", "256GB");
        // OPPO 定制化生产
        produce(OPPO::produceOPPO, oppo);
        Huawei huawei = new Huawei("Pocket 2", "洛可可白", true, "12GB", "256GB");
        // 华为 定制化生产
        produce(Huawei::produceHuawei, huawei);
        Apple apple = new Apple("iPhone 16 Pro", "白", "16GB", "128GB");
        // 苹果 定制化生产
        produce(Apple::producePhone, apple);
    }
}
输出：
正在生产 OPPO手机 ：型号-Find X7 颜色-白日梦想家 运行内存-12GB 存储容量-256GB
正在生产 华为手机 ：折叠屏 Pocket 2 洛可可白 12GB 256GB
正在生产 尊贵的iPhone :iPhone 16 Pro 白 16GB 128GB

2、返回类型也是泛型的泛型方法

 输入：

一个列表，和 几个数据。

输出：

数据包含在 列表 中的一个新的列表。

示例：

输入 [2，5，7，9，10] 和 5，27 输出 [5]

输入 ["福建", "江西", "浙江"] 和 "江苏","福建" 输出 ["福建"]

 一种 泛型方法 的实现：

package com.study.genericity.entity;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

public class Test {

    @SafeVarargs
    public static <T> List<T> filter(List<T> list, T... args) {
        List<T> result = new ArrayList<T>();
        for (T t : args) {
            if (list.contains(t)) {
                result.add(t);
            }
        }
        return result;
    }

    public static void main(String[] args) {
        List<Integer> list1 = Arrays.asList(2,5,7,9,10);
        System.out.println( filter(list1, 5, 27) );
        List<String> list2 = Arrays.asList("福建", "江西", "浙江");
        System.out.println( filter(list2, "江苏", "福建") );
    }
}
输出：
[5]
[福建]

 在这个例子中，filter 方法是一个泛型方法，它的入参是类型参数<T>的 泛型列表 List<T> 和 类型参数<T>的可变参数；它的返回类型还是 类型参数<T>的 泛型列表 List<T>。

这种返回类型也是泛型的泛型方法，在很多框架中都有大量的使用。

比如 cn.hutool.json.JSONUtil :

// 根据 JSON 字符串和 bean Class 类型，解析 JSON 数据 为 指定类型
public static <T> T toBean(String jsonString, Class<T> beanClass) {
        return toBean(parseObj(jsonString), beanClass);
}

matrixlzp
关注
专栏目录
Java中的泛型<T>类与方法
Mistra的博客
04-12 1444
————–&gt; 原文链接 泛型就是变量类型的参数化。在使用泛型前，存入集合中的元素可以是任何类型的，当从集合中取出时，所有的元素都是Object类型，需要进行向下的强制类型转换，转换到特定的类型。而强制类型转换容易引起运行时错误。 泛型类型参数只能被类或接口类型赋值，不能被原生数据类型赋值，原生数据类型需要使用对应的包装类。 一、介绍 例子一：使用了泛型 class Tes...
Java基础 -- 04泛型＜T＞
mmlz00的博客
12-20 1万+
目录 泛型概念： 泛型种类： 泛型接口 泛型类 泛型方法 普通泛型方法 静态泛型方法 泛型构造函数 泛型进阶： 泛型通配符 泛型上界 泛型下界 泛型擦除 泛型注意事项 泛型的用法: 泛型的示例: 高阶篇 泛型概念： 没有JDK5问世以前的老代码： 先看第1个小示例：Integer类型...
Java泛型＜T＞
weixin_41405489的博客
12-12 9316
泛型的本质是参数化类型，也就是说所操作的数据类型被指定为一个参数。Collection,List 这个就是类型参数，即泛型。这种参数类型可以用在类、接口和方法的创建中，分别称为泛型类、泛型接口、泛型方法。Java语言引入泛型的好处是安全简单。在Java SE 1.5之前，没有泛型的情况的下，通过对类型Object的引用来实现参数的“任意化”，“任意化”带来的缺点是要做显式的强制类型转换，而这种转换是要求开发者对实际参数类型可以预知的情况下进行的。
JAVA方法
code_newPig的博客
04-16 147
JAVA方法 1、什么是方法? Java方法是语句的集合，它们在一起执行一个功能 方法是解决一类问题的步骤的有序组合 方法包含于类或对象中 方法在程序中被创建，在其他地方被引用 设计方法的原则:方法的本意是功能块，就是实现某个功能的语句块的集合，我们设计方法的时候，最好保持方法的原子性，就是一个方法只完成一功能，这样有利于我们后期的扩展 public class Demo01 { //main方法 public static void main(String[] args)
Jdk5.0新特性Generic Types(泛型)
xie_wansong的专栏
02-03 236
. 介绍 2.定义简单Java泛型 其实Java的泛型就是创建一个用类型作为参数的类。就象我们写类的方法一样，方法是这样的method(String str1,String str2 ),方法中参数str1、str2的值是可变的。而泛型也是一样的，这样写class Java_Generics，这里边的K和V就象方法中的参数str1和str2,也是可变。下面看看例子： import j...
Java的方法前面有一个＜T＞是什么？
soralink的博客
09-30 2452
在方法前面放范型 我们在看java源码的时候会发现有的方法前面会用。我管这个方法叫做范型方法，英文是Generic Methods。 代码样例： <R> Stream<R> map(Function<? super T, ? extends R> mapper); 这个抽象方法在返回类型的前面有一个。 作用阈 其实这个声明类似于范型声明，但是这个方法前面的声名只能作用在方法中。 如何书写 这个范型可以用于静态和非静态方法但是用<>包裹的范型必须放在返回类型的
Java学习笔记
cj1064789374的博客
08-29 836
Java学习笔记
廖雪峰java教程学习笔记——集合
zhang35的博客
05-30 669
定义 Java的java.util包主要提供了三种类型的集合：List、Set、Map Java集合的设计特点： 接口和实现类相分离，例如有序表的接口是List，具体的实现类有ArrayList、LinkedList等 支持泛型 访问集合总是通过迭代器 避免使用历史遗留类和接口 有一小部分集合类是遗留类，不应该继续使用： Hashtable：一种线程安全的Map实现； Vector：一种线程安全的List实现； Stack：基于Vector实现的LIFO的栈。 还有一小部分接口是遗留接口，也不应该继
【java面试经(架构师&设计师)-第5课】JAVA基础之多线程(一)
金和弦的博客
11-04 446
技术清单 申明：本文属于整理加工原创，部分举证材料来自于网络，仅用于学习参考。 本文主要介绍java数据结构相关知识，通过本文讲解，你可以明白： 1、JDK、JRE、JVM的概念和区别是什么？ 2、Java程序编译和运行的过程，JVM如何加载字节码文件的，类加载器如何卸载字节码？ 3、JVM内存模型是怎样的？Java运行时数据区情况？一个对象（两个属性，四个方法）实例化100次，现在内存中的存储状态，几个对象，几个属性，几个方法？ 4、堆和栈的区别是什么？在java内存分配中，什么时候会存到堆，
Java并发常见面试题
m0_66689823的博客
05-27 695
Java并发常见面试题
Java泛型<T> T与T的使用方法详解
08-18
主要介绍了Java泛型 T与T的使用方法详解,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
＜Zhuuu_ZZ＞实时流之Apache Flink
热门推荐
Zhuuu_ZZ的博客
01-06 1万+
Apache Flink
Java泛型详解
chuanjiaoye5017的博客
11-10 569
Java泛型详解 Java泛型（generics）是JDK 5中引入的一个新特性，允许在定义类和接口的时候使用类型参数（type parameter）。声明的类型参数在使用时用具体的类型来替换。泛型最主要的应用是在JDK 5中的新集合类框架中。对于泛型概念的引入，开发社区的观点...
java t的使用_java中的t怎么用
weixin_36073697的博客
02-15 1253
T表示返回值是一个泛型，传递啥，就返回啥类型的数据，而单独的T就是表示限制你传递的参数类型，这个案例中，通过一个泛型的返回方式，获取每一个集合中的第一个数据， 通过返回值 T 和T的两种方法实现。T 用法返回值，直接写T表示限制参数的类型，这种方法一般多用于共同操作一个类对象，然后获取里面的集合信息啥的。public class Demo2 {public static void main(St...
Java 泛型<T> T与T的用法
行者-崛起之路
02-14 9092
&lt;T&gt; T表示返回值是一个泛型，传递啥，就返回啥类型的数据，而单独的T就是表示限制你传递的参数类型，这个案例中，通过一个泛型的返回方式，获取每一个集合中的第一个数据， 通过返回值&lt;T&gt; T 和T的两种方法实现 &lt;T&gt; T 用法 这个&lt;T&gt; T 表示的是返回值T是泛型，T是一个占位符，用来告诉编译器，这个东西先给我留着，等我编译的时候，告诉你。...
关于java中<T>问题
Well~
01-22 565
#新浪博客搬家# (2017-04-04 22:09:55) 指泛型，这里T是指类型，作为参数表示类型可变。 其实Java的泛型就是创建一个用类型作为参数的类。就象我们写类的方法一样，方法是这样的method(String str1,String str2 ),方法中参数str1、str2的值是可变的。而泛型也是一样的，这样写class Java_Gener
java T方法_JAVA 泛型方法<T>
weixin_39546661的博客
02-15 1565
public static void main(String[] args) throwsException {String[] arr= new String[]{"1", "2", "3"};changeAddr(arr,0, 2);System.out.println(Arrays.toString(arr));Person person= newPerson();//T 作为对象传入，返回...
泛型方法<T>
四问四不知的博客
07-04 665
先写点无关的东西， io.swagger.annotations包下的几个常用注解： @Api：用在请求的类上，表示类的说明 eg:@Api(value="无意义的注解，UI界面可以看到",tags="说明类的作用，可以在UI界面看到的注解") @ApiImplicitParams:用在请求的方法上，表示一组参数说明 eg:@ApiImplicitParams({ @ApiI...
泛型方法前为什么要加<T>和不加<T>有什么区别
最新发布
06-03
在Java中，泛型方法前加<T>和不加<T>的区别如下： 1. 加<T>表示这是一个泛型方法，可以接受任意类型的参数，并且在方法内部可以使用T来代表实际类型。不加<T>则表示这是一个普通方法，只能接受特定类型的参数。 2. 加<T>可以增强方法的通用性，可以使方法适应不同类型的参数。不加<T>则只能接受特定类型的参数，不够通用。 3. 加<T>可以避免类型转换的问题，可以在编译时检查类型是否匹配。不加<T>则需要手动进行类型转换，容易出错。 4. 加<T>可以提高代码的可读性和简洁性，可以减少重复代码的编写。不加<T>则需要编写多个方法来适应不同类型的参数，代码冗余。 例如，下面是一个定义了泛型类型参数T的泛型方法： ``` public <T> T getMax(T[] array) { T max = array[0]; for (int i = 1; i < array.length; i++) { if (array[i].compareTo(max) > 0) { max = array[i]; } } return max; } ``` 在这个方法中，<T>表示这是一个泛型方法，并且T是一个类型参数。在方法体内部，可以使用T来代表实际的类型。这个方法可以接受任意类型的数组参数，并返回数组中的最大值。 而如果不加<T>，则需要编写多个方法来适应不同类型的参数，例如： ``` public int getMax(int[] array) { int max = array[0]; for (int i = 1; i < array.length; i++) { if (array[i] > max) { max = array[i]; } } return max; } public double getMax(double[] array) { double max = array[0]; for (int i = 1; i < array.length; i++) { if (array[i] > max) { max = array[i]; } } return max; } ``` 这些方法都是重复的代码，可以通过使用泛型方法来避免这种情况。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值