Java——泛型

最新推荐文章于 2025-06-19 15:48:05 发布
原创 最新推荐文章于 2025-06-19 15:48:05 发布 · 214 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

本文深入探讨Java中的高级特性，包括可变参数的使用，foreach循环的便利性，静态导入的注意事项，以及泛型的全面解析，涵盖泛型的引入、基本使用、泛型方法、通配符、泛型接口和泛型擦除等关键概念。

目录

1.可变参数

2.foreach循环

3.静态导入

4.泛型

4.1 引入

4.2 基本使用

4.3 泛型方法

4.4 通配符

4.5 泛型接口

4.6 泛型擦除（语法糖）

1.可变参数

可变参数的本质是数组

public [static] [final] 返回值 方法名称([参数类型 参数名称][参数类型 ... 参数名称]){}

代码示例：

/**
 * 可变参数
 * Author: qqy
 */

public class Test {
    public static void main(String[] args) {
        System.out.println(add1());
        System.out.println(add1(1));
        System.out.println(add1(1,2));
        System.out.println(add1(1,2,3,4,5));//随意传递内容、个数
        System.out.println(add1(null));
        System.out.println(add1(new int[]{1,2,3}));//可变参数可以接收数组
    }

        //int...data => int[]
    public static int add1(int...data) {
        if(data==null){
            return 0;
        }
        int sum=0;
        for(int i=0;i<data.length;i++){
            sum+=data[i];
        }
        return sum;
    }
}
  • 如果要传递多个参数，一个方法有且只能有一个可变参数，且可变参数一定放在最后（可变参数的个数不确定，因此需要将确定的参数置于前面）
/**
 * 传递多类参数（包含可变参数）
 * Author: qqy
 */
public class Test1 {
    public static void main(String[] args) {
        print("hello");
        print("hello", " world ");
        String str1 = "C'est";
        String str2 = "la";
        String str3 = "vie!";
        System.out.println(str1 + " " + str2 + " " + str3);
        print(str1, " ", str2, " ", str3);
    }

    //传递多类参数，可变参数一定放在最后，并且只能设置一个可变参数
    public static void print(String message, String... args) {
        StringBuilder stringBuilder = new StringBuilder();
        stringBuilder.append(message);
        for (int i = 0; i < args.length; i++) {
            stringBuilder.append(args[i]);
        }
        System.out.println(stringBuilder.toString());
    }
}

注意：

    //两个方法一样，不是方法重载
    public static void hello(String[] args){
    
    }
    
    public static void hello(String...args){
    
    }

2.foreach循环

用于数组 / 类集的简单输出；如需对类集 / 数组进行修改，仍用for循环。

for(数据类型 临时变量 : 数组(集合)) {
    // 循环次数为数组长度，而每一次循环都会顺序取出数组中的一个元素赋值给临时变量
}
  • 缺点：无法通过下标获取元素
/**
 * foreach循环
 * Author: qqy
 */
public class Test2 {
    public static void main(String[] args) {
        int[] intArray = new int[]{1, 2, 3, 4, 5};
        for (int anIntArray : intArray) {
            //每次循环（intArray）的时候会将数组中的元素赋值给变量（anIntArray）
            System.out.println(anIntArray);
        }
    }
}

3.静态导入

  • Java 支持静态导入 , 但是不建议使用——如果方法重名可能存在二义性；建议通过类名调用

  • 当本类中出现与静态导入方法名相同的方法，则执行本类中的方法

  • 如果代码中同时使用的两个类名相同，包名不同 => 全限定名不同，建议使用类的全限定名调用方法

    eg：java.lang.String      com.qqy.String

package com.qqy.java.util;

public class MyMath {
    public static int add(int x, int y) {
        return x + y;
    }

    public static int sub(int x, int y) {
        return x - y;
    }
}
package com.qqy.java.test;

import static com.qqy.java.util.MyMath.*; // 静态导入

public class TestDemo {
    public static void main(String[] args) {
        System.out.println(add(10, 20));  //静态导入后，使用方法时不用通过类名调用，直接通过方法名使用
        System.out.println(sub(30, 10));
    }
}

4.泛型

泛型指的就是在类定义的时候并不会设置类中的属性或方法中的参数的具体类型，而是在类使用时再进行定义。

  • 4.1 引入

为了在运行时，明确数据类型，引入泛型。

/**
 * 引入泛型
 * Author: qqy
 */
public class Test {
    public static void main(String[] args) {
        //将10装箱为Integer，再向上转型为Object
        Point intPoint=new Point(10,20);
        System.out.println(intPoint);
        //强制类型装换——向下转型 Object->int
        int intX = (int) intPoint.getX();
        int intY = (int) intPoint.getY();
        System.out.println("(" + intX + ", " + intY + ")");

        Point doublePoint = new Point(10.2D, 20.2D);
        double doubleX = (double) doublePoint.getX();
        double doubleY = (double) doublePoint.getY();
        System.out.println("(" + doubleX + ", " + doubleY + ")");

        Point stringPoint = new Point("东经80度", "北纬30度");
        String stringX = (String) stringPoint.getX();
        String stringY = (String) stringPoint.getY();
        System.out.println("(" + stringX + ", " + stringY + ")");
    }
}

class Point {

    private Object x;

    private Object y;

    public Point(Object x, Object y) {
        this.x = x;
        this.y = y;
    }

    public Object getX() {
        return x;
    }

    public Object getY() {
        return y;
    }

    @Override
    public String toString() {
        return "Point{" +
                "x=" + x +
                ", y=" + y +
                '}';
    }
}

  • 4.2 基本使用

  • 基本语法
//T 被称作是类型参数，用于指代任何类型
class MyClass<T> {
     T value1;
}

T 代表一般的任何类

E 代表 Element 的意思，或者 Exception 异常的意思

K 代表 Key 的意思  V 代表 Value 的意思，通常与 K 一起配合使用 —— 键值对，见Map集合

S 代表 Subtype 的意思

  • 泛型只能接受类，所有的基本数据类型必须使用包装类
/**
 * 泛型  x、y数据类型相同
 * Author: qqy
 */
public class Test2 <T>{
    private T x;
    private T y;

    public Test2(T x, T y) {
        this.x = x;
        this.y = y;
    }

    public T getX() {
        return x;
    }

    public T getY() {
        return y;
    }

    public static void main(String[] args) {
        //JDK1.7之后（包含1.7）第二个<>中的内容可以省略

        //Test2 Integer
        Test2<Integer> point=new Test2<>(10,20);
        Integer x=point.getX();
        Integer y=point.getY();
        System.out.println("("+x+","+y+")");

        //Test2 String
        Test2<String> point1=new Test2<>("东经20度","北纬50度");
        String strX=point1.getX();
        String strY=point1.getY();
        System.out.println("("+strX+","+strY+")");
    }
}
/**
 * 泛型  x、y数据类型不同
 * Author: qqy
 */
public class Test1<T,S> {
    private T x;
    private S y;

    public Test1(T x, S y) {
        this.x = x;
        this.y = y;
    }

    public T getX() {
        return x;
    }

    public S getY() {
        return y;
    }

    public String toString(){
        return "Test1{\""+
                "x="+x+
                " y="+y+
                "\"}";
    }

    public static void main(String[] args) {
        Test1<Integer,String> point=new Test1<>(20,"你好");
        Integer x=point.getX();
        String y=point.getY();
        System.out.println("("+x+","+y+")");
    }
}

  • 4.3 泛型方法

  • 泛型方法定义
//<T>中的 T 被称为 类型参数，而方法中的 T 被称为参数化类型，它不是运行时真正的参数。
class MyClass {
    public <T> void testMethod(T t) {
        System.out.println(t);
    }
}
  • 当泛型类与泛型方法共存时，泛型类中的类型参数与泛型方法中的类型参数没有关系，泛型方法始终以自己定义的类型参数为准。
  • 规范：泛型方法类型参数与泛型类的类型参数不同名
/**
 * 泛型方法
 * Author: qqy
 */

//只有方法中有<*>，才是泛型方法
public class Test3 <T>{
    private T msg;

    //构造方法
    public Test3(T msg) {
        this.msg=msg;
    }

    public T getMsg() {
        return msg;
    }

    //普通方法,括号中的T只与类有关
    public void method(T t){
        System.out.println(t);
    }

    //泛型方法
    //泛型方法与泛型类相互独立
    //此时的<T>与泛型类中的<T>无关
    public static <T> void print(T data){
        System.out.println(data);
    }

    public static <T,S> void print(T data,S value){
        System.out.println(data+" "+value);
    }

    //带返回值的泛型方法
    //<T> 声明是泛型方法，T 返回值，括号中的T是泛型参数
    public static <T> T convert(T data){
        return data;
    }

    //成员方法
    public <E> void msgprint(E value){
        System.out.println(value);
    }

    public static void main(String[] args) {
        print("hello");
        print(21);
        print(new Test1<>(22,"你好"));
        print("bonjour",18);

        Test3<String> msg=new Test3<>("c'est la vie");
        System.out.println(msg.getMsg());

        msg.msgprint("Amour");

        System.out.println(convert(33));
        System.out.println(convert("bonjour"));
    }
}

  • 4.4 通配符

解决参数统一问题

  • 方法中的参数应用了通配符，则参数不能修改
  • 通过泛型上限、下限对泛型进行限制
  • 泛型下限可以修改下限类型的内容
  • 4.4.1  ？

用于方法中，表示参数可以接收任意类型的泛型类

  • 在方法中，只能取得类中数据，不能修改数据——类型不确定，无法设置确定类型
/**
 * 通配符——用于方法中
 * Author: qqy
 */
public class Test4 {
    public static void main(String[] args) {
        MyClass<Double> my=new MyClass<>();
        my.setValue(10.2);
        print(my);
    }

    public static void print(MyClass<?> my){
        //通配符不可修改
        //my.setValue(200);
        System.out.println(my.getValue());
    }
}

class MyClass<T>{
    private T value;

    public T getValue() {
        return value;
    }

    public void setValue(T value) {
        this.value = value;
    }
}
  • 4.4.2  ？ extends 类

设置 / 取得泛型的上限，可用在方法 / 类中

//泛型必须是Number及其子类
？ extends Number
  • 用在类上 T  extends 类：T必须为类或者类的子类
  • 用在方法上  ？ extends 类：只能接收类或者其子类的泛型类；只能取得类中属性值，不能修改值（发生父类到子类的向下转型，需要强转，由于具体子类不确定，因此无法转型）
/**
 * 泛型上限
 * Author: qqy
 */
public class Test5 {
    public static void main(String[] args) {
        MyClass1<Integer> my1 = new MyClass1<>();
        my1.setValue(123);
        print(my1);
    }

    public static void print(MyClass1<? extends Number> my) {
        System.out.println(my.getValue());
    }
}

//类中设定泛型上限不能用？
class MyClass1<T extends Number> {
    private T value;

    public T getValue() {
        return value;
    }

    public void setValue(T value) {
        this.value = value;
    }
}
  • 4.4.3  ？ super 类

设置 / 取得泛型的下限，只能用于方法中

//此方法只能取String及其父类Object
？ super String
  • 可以修改属性值（子类到父类时自动的向上转型）
/**
 * 泛型下限
 * Author: qqy
 */
public class Test6 {
    public static void main(String[] args) {
        MyClass<String> my1 = new MyClass<>();
        my1.setValue("bonjour");
        print(my1);
    }

    public static void print(MyClass<? super String> my) {
        System.out.println(my.getValue());
    }
}

class MyClass<T>{
    private T value;

    public T getValue() {
        return value;
    }

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

  • 4.5 泛型接口

interface IGeneric<T>{
    T test(T t);
}
  • 两种实现：

子类继续保留泛型  /  子类定义时给出具体类型

/**
 * 泛型接口
 * Author: qqy
 */
public class Test7 {
    public static void main(String[] args) {
        IGeneric<Integer> iGeneric=new GenericImpl<Integer>();
        System.out.println(iGeneric.test(25));
        IGeneric iGeneric1=new GenericImpl1();
        System.out.println(iGeneric1.test("bonjour"));
    }
}

interface IGeneric<T>{
    T test(T t);
}

//1.子类继续保留泛型
class GenericImpl<T> implements IGeneric<T>{

    @Override
    public T test(T t) {
        return t;
    }
}

//2.子类定义时给出具体类型
class GenericImpl1 implements IGeneric<String>{

    @Override
    public String test(String s) {
        return s;
    }
}

  • 4.6 泛型擦除（语法糖）

泛型信息只存在于代码编译阶段，在进入 JVM 之前，与泛型相关的信息会被擦除掉——类型擦除。即：泛型类在JVM中与普通类无异。

  • 验证方式：instanceof、getClass

  • 泛型类进入JVM之前会进行类型擦除，之前泛型类的类型参数若没有指定上限，会被擦除成为Object类型。如果指定上限，则类型参数被替换为相应上限。

/**
 * 泛型擦除
 * Author: qqy
 */
public class Test8 {
    public static void main(String[] args) {
        Message<String> message1 = new Message<>();
        message1.setMessage("hello");

        Message<Integer> message2 = new Message<>();
        message2.setMessage(100);

        System.out.println(message1.getMessage());
        System.out.println(message2.getMessage());

        //利用instanceof验证
        System.out.println(message1 instanceof Message);
        System.out.println(message2 instanceof Message);

        //利用getClass()返回的类型验证
        System.out.println(message1.getClass().getName());
        System.out.println(message2.getClass().getName());
    }
}

class Message<T> {

    private T message;

    public T getMessage() {
        return message;
    }

    public void setMessage(T message) {
        this.message = message;
    }
}

 

Java——泛型设计
qq_40543015的博客
09-09 269
为集合提供编译时（静态）类型安全，并消除了大多数类型转换的需要（由于泛型是在编译时起作用，所以在运行时动态生成的反射可以绕过泛型限制）泛型类就是一个具有多种类型变量的类，泛型类可以拥有一个类型，也可以拥有多个类型[访问修饰符] class 类名<T,U,...> {T 泛型成员1;U 泛型成员2;...类型参数使用大写形式，且比较短，这是最常使用的​​/*** 查询全部* @return*//*** 根据id查询* @param k* @return*//**
Java—— 泛型详解
zjy_ccccc的博客
05-10 1269
泛型概述。泛型的好处。泛型的细节。泛型的分类。泛型类。泛型方法。泛型接口。泛型的通配符
JAVA——泛型的使用
章鱼丸子吖的博客
07-31 4514
泛型的定义使用，泛型的好处，泛型的通配符
java——泛型
mainjay
06-30 575
泛型 1.泛型的定义 泛型的上限： 格式： 类型名称 <? extends 类 > 对象名称 意义： 只能接收该类型及其子类 泛型的下限： 格式： 类型名称 <? super 类 > 对象名称 意义： 只能接收该类型及其父类型 public static void main(String[] args) { Collection<Integer> list1 = new ArrayList<Integer>(); Collection&
JAVA——泛型
最新发布
2401_88591507的博客
06-19 989
   泛型（Generics）是Java语言在JDK 5.0版本中引入的一种强大特性，用于在编译时提供更强的类型检查和类型安全。它允许程序员在定义类、接口和方法时使用类型参数（Type Parameters），从而实现类型参数化。通过泛型，可以编写出更加通用、灵活且类型安全的代码。
java —— 泛型
firstgrass的博客
06-02 445
泛型实质上就是将参数类型泛化，在具体使用的时候再进行确定。不论泛型类、泛型接口还是泛型方法，泛型都指的是参数的泛化，不是指类、接口和方法的类型。
Java基础——泛型
2301_78566776的博客
11-25 1611
泛型（Generics）是一种在编程时定义函数、类或接口时不具体指定将要操作的数据类型的方法。通过使用泛型，可以编写出更加通用、灵活且类型安全的代码。泛型允许在编译时进行类型检查，从而减少运行时错误，并提高了代码的可重用性和可读性。泛型就好比是给一个标签，就拿数组的泛型举例来说，我们把数组比作一个药瓶子，我们药瓶子贴上了什么标签，就放什么药，如果不管什么药都放在一个药瓶子里，那不得出大事吗？同样容器写上什么泛型，就存放什么数据；
Java——泛型方法
2301_80215285的博客
03-03 1244
泛型方法通过在方法返回值前添加类型参数（用尖括号。
Java——泛型调用
Gamble6
06-12 1125
Java 泛型（generics）是 JDK 5 中引入的一个新特性, 泛型提供了编译时类型安全检测机制，该机制允许开发者在编译时检测到非法的类型。 泛型的本质是参数化类型，也就是说所操作的数据类型被指定为一个参数。 一、泛型带来的好处 在没有泛型的情况的下，通过对类型 Object 的引用来实现参数的“任意化”，“任意化”带来的缺点是要做显式的强制类型转换，而这种转换是要求开发者对实际参数类型可以预知的情况下进行的。对于强制类型转换错误的情况，编译器可能不提示错误，在运行的时候才出现异常，这是本身就
Java——泛型接口
2301_80215285的博客
03-03 845
泛型接口通过在接口名后添加类型参数（用尖括号。
java——泛型总结
Hydra的博客
08-21 1412
对泛型一直半知半解，做下总结，顺便学习一下，本博文仅供参考。先来点概念压压惊。 泛型，即“参数化类型”。一提到参数，最熟悉的就是定义方法时有形参，然后调用此方法时传递实参。那么参数化类型怎么理解呢？ 顾名思义，就是将类型由原来的具体的类型参数化，类似于方法中的变量参数，此时类型也定义成参数形式（可以称之为类型形参）， 然后在使用/调用时传入具体的类型（类型实参）。 泛型的本质是为了参数化...
Java基础——泛型简要介绍
weixin_64451672的博客
01-08 429
Java基础——泛型简要介绍
Java——数组的定义与使用
热门推荐
cerf-volant的博客
11-07 2万+
目录 1.数组 2.数组初始化 2.1 动态初始化（声明并开辟数组） 2.2 引用传递的内存分析 2.3 静态初始化（开辟同时赋值） 3.二维数组 4.数组与方法互操作 5.Java对数组的支持 5.1 排序： 5.2 拷贝 6.对象数组 6.1动态初始化 1.数组 一组相关类型的变量集合 缺点：长度固定，存在越界问题 2.数组初始化 2.1 动态初始化...
Java小项目——聊天室（多线程版本）
cerf-volant的博客
03-21 3045
目录 1. 前言 2. 功能实现 3. 模块划分 4.功能分析 4.1 前期分析 4.2 具体实现 5. 使用技术 6. 代码 1. 前言 之前写过单线程版本的聊天室，这次对之前的版本进行扩展与优化，将其升级为一个多线程版本的聊天室，更好的贴近一个真实的聊天工具。 在这个版本中，聊天室具有注册、私聊、群聊以及退出的功能。 2. 功能实现 服务器需要实现 用户注册 ...
Java——I/O（File类和Path接口）
cerf-volant的博客
12-09 2938
目录 1. File文件操作类 1.1File类的基本使用 1.2 目录操作 1.3 文件信息 1.4 综合案例 2.Path类   1. File文件操作类 在Java.io包之中，File类是唯一一个与文件本身操作(创建、删除、取得信息...)有关，与文件内容无关的程序类。 1.1File类的基本使用 File类既可描述真实文件，也可以是个文件夹 File类...
Java——集合类（栈、队列、Collections和Stream流）
cerf-volant的博客
03-03 2050
目录 1. 栈 2. 队列 3. Properties属性文件操作 4. Collections工具类 5. Stream流 5.1 Collection改进 5.2 Stream操作 5.3 MapReduce基础模型 1. 栈 一种先进后出的数据结构，若栈已空，继续出栈会抛出空栈异常 几种常用方法 入栈 : public E push(E item) 出栈 : pub...
Java 小项目——字符界面收银台（优化版）
cerf-volant的博客
03-15 1743
目录 1. 前言 2. 功能实现 3. 功能分析 4. 模块划分 5. UML图 6. 使用技术 7. 代码 1. 前言 三个月前，我就写过这个项目的低级版。之前是利用数组进行商品的存储，所以存在商品数量固定的缺陷。经过三个月的学习，想要对这个项目进行优化，回头看了看当时的代码... 妈耶，写的都是些啥，暂且不说所用的技术比较low，那个框架、思路，简直是一团浆糊。反正我自己是看...
Java基础知识点深入解析——泛型与枚举等技巧
根据提供的文件信息，本篇笔记将详细探讨Java编程语言中的关键概念，包括泛型、枚举、静态导入、自动装箱拆箱、foreach循环、可变参数以及反射机制。这些知识点在Java开发中占据重要地位，理解和掌握它们对于编写...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值