对 Java 中泛型理解

泛型的概念

  1. 泛型是一种末知的数据类型，当我们不知道使用什么数据类型的时候，可以使用泛型
  2. 泛型也可以看成是一个变量用来接收数据类型
  3. E e：Element元素
  4. T t：Type类型

有无使用泛型的对比

不使用泛型

创建集合对象，不使用泛型

  1. 好处：集合不使用泛型，默认的类型就是Object类型，可以存储任意类型的数据。

    举例：

    复制
    		public class Demo01Generic {
    		    public static void main(String[] args) {
    		        // 集合不使用泛型
    		        ArrayList arrayList = new ArrayList();
    		 
    		        // 向集合中添加数据，用于测试，这里添加了String类型的数据，和int类型的数据
    		        arrayList.add("ABC");
    		        arrayList.add(123);
    		 
    		        // 使用迭代器遍历集合
    		        // 第一步：获取送代器的实现类对象，并使用Iterator接口接收
    		        Iterator ite = arrayList.iterator();
    		        // 第二步：使用hasNext方法和next方法遍历集合，取出的元素的类型默认是Object类型
    		        while (ite.hasNext()) {
    		            System.out.println(
    		                    ite.next()
    		            );
    		        }
    		    }
    		}
    复制
    		输出结果：
    		ABC
    		123

  2. 弊端：不安全，会引发异常

    复制
    		public class Demo02Generic {
    		    public static void main(String[] args) {
    		 
    		        ArrayList arrayList = new ArrayList();
    		 
    		        arrayList.add("ABC");
    		        arrayList.add(123);
    		 
    		        Iterator ite = arrayList.iterator();
    		        while (ite.hasNext()) {
    		            // 取出的数据，默认是Object类型
    		            Object object = ite.next();
    		 
    		            // 假如想使用String特有的length方法来获取字符串的长度，是不可以的
    		            // 需要将Object类型向下转型为String类型才能使用它的特有方法
    		            // 但是集合里面还有数据类型是Integer的数据，所以不能进行向下转型为String类型，
    		            // 如果强行转换，那么在运行是会抛出ClassCastException异常
    		            String string = (String)object;
    		            System.out.println(string.length());
    		        }
    		    }
    		}
    复制
    		抛出错误：
    		Exception in thread "main" java.lang.ClassCastException: java.lang.Integer cannot be cast to java.lang.String
    		    at XXXXXX.main(Demo02Generic.java:36)

使用泛型

创建集合对象，使用泛型

  1. 好处：
    1. 避免了类型转换的麻烦，存储的是什么类型，取出的就是什么类型
    2. 把运行期昇常，提升到了编译期
  2. 弊端：泛型是什么类型，只能存储什么类型的数据

举例：

复制
import java.util.ArrayList;
import java.util.Iterator;
 
public class Demo03Generic {
    public static void main(String[] args) {
 
        ArrayList<String> arrayList = new ArrayList<>();
 
        arrayList.add("ABC");
        // 假如添加的数据的类型不是String类型，
        // 那么会抛出错误：方法 java,util.Collection.add(java.lang.String)不适用
        // arrayList.add(123);
 
        Iterator<String> ite = arrayList.iterator();
        while (ite.hasNext()) {
 
            String string = ite.next();
 
            System.out.println(
                    string.length()
            );
        }
    }
}
复制
输出结果：
3

定义和使用含有泛型的类

说明

  1. 泛型，用来灵活地将数据类型应用到不同的类、方法、接口当中。将数据类型作为参数进行传递。

  2. 定义和使用含有泛型的类：

    定义格式：

    复制
    		修饰符 class 类名称<代表泛型的变量> { . . . }

举例

  1. 创建一个含有泛型的类

    复制
    		public class GenericClass<E> {
    		    private E name;
    		 
    		    public E getName() {
    		        return name;
    		    }
    		 
    		    public void setName(E name) {
    		        this.name = name;
    		    }
    		}

  2. 使用这个类

    复制
    		public class DemoGenericClass {
    		    public static void main(String[] args) {
    		        // 使用泛型
    		        GenericClass<String> name1 = new GenericClass<>();
    		        name1.setName("使用泛型：这里只能添加指定类型的数据");
    		        String string = name1.getName();
    		        System.out.println(string);
    		 
    		        // 不使用泛型，默认是Object类型
    		        GenericClass name2 = new GenericClass();
    		        name2.setName("不使用泛型：这里能添加不同类型的数据");
    		        Object object = name2.getName();
    		        System.out.println(object);
    		    }
    		}

  3. 输出结果

    复制
    		使用泛型：这里只能添加指定类型的数据
    		不使用泛型：这里能添加不同类型的数据

定义和使用含有泛型的方法

说明

  1. 定义含有泛型的方法:泛型定义在方法的修饰符和返回值类型之间。

  2. 格式：

    复制
    		修饰符 <泛型> 返回值类型 方法名(参数列表(使用泛型)) {
    		    方法体
    		}

  3. 含有泛型的方法，在调用方法的时候确定泛型的数据类型。传递什么类型的参数，泛型就是什么类型。

举例

  1. 定义含有泛型的方法

    复制
    		public class GenericMethod {
    		    /**
    		     * 定义一个含有泛型的方法
    		     */
    		    public <W> String method1(W w) {
    		        return  "一个含有泛型的方法：" + w;
    		    }
    		 
    		    /**
    		     * 定义一个含有泛型的静态方法
    		     */
    		    public static <Z> String method2(Z z) {
    		        return  "一个含有泛型的静态方法：" + z;
    		    }
    		}

  2. 使用这两个方法

    复制
    		public class DemoGenericMethod {
    		    public static void main(String[] args) {
    		        // 创建类对象
    		        GenericMethod gm = new GenericMethod();
    		 
    		        // 调用含有泛型的普通方法
    		        System.out.println(
    		                gm.method1(666)
    		        );
    		        System.out.println(
    		                gm.method1("ABC")
    		        );
    		        System.out.println(
    		                gm.method1(0.999)
    		        );
    		 
    		        // 调用含有泛型的静态方法
    		        // 可以使用gm.method2()来调用静态方法
    		        // 不推荐使用创建对象来调用静态方法，推荐直接用类名称来调用
    		        System.out.println(
    		                GenericMethod.method2(666)
    		        );
    		        System.out.println(
    		                GenericMethod.method2("ABC")
    		        );
    		        System.out.println(
    		                GenericMethod.method2(0.999)
    		        );
    		    }
    		}

  3. 输出结果

    复制
    		一个含有泛型的普通方法：666
    		一个含有泛型的普通方法：ABC
    		一个含有泛型的普通方法：0.999
    		一个含有泛型的静态方法：666
    		一个含有泛型的静态方法：ABC
    		一个含有泛型的静态方法：0.999

定义和使用含有泛型的接口

说明

  1. 含有泛型的接口，第一种使用方式是：通过定义接口的实现类，实现接口，指定接口的泛型。
  2. 含有泛型的接口第二种使用方式:接口使用什么泛型,实现类就使用什么泛型,类跟着接口走就相当于定义了一个含有泛型的类,创建对象的时候确定泛型的类型。

举例

例子1

  1. 定义一个含有泛型的接口

    复制
    		public interface GenericInterface<I> {
    		    /**
    		     * 接口的抽象方法
    		     * @param i 泛型参数
    		     */
    		    public abstract void method(I i);
    		 
    		}

  2. 创建接口实现类

    复制
    		public class GenericInterfaceImplement implements GenericInterface<String>{
    		    @Override
    		    public void method(String s) {
    		        System.out.println(
    		                "含有泛型的接口，第一种使用方式是：通过定义接口的实现类，实现接口，指定接口的泛型\n" 
    		                        + "这个方法传入指定类型参数是：" + s
    		        );
    		    }
    		}

  3. 测试含有泛型的接口

    复制
    		public class DemoGenericInterfaceImplement {
    		    public static void main(String[] args) {
    		        GenericInterfaceImplement gii = new GenericInterfaceImplement();
    		 
    		        gii.method("666999");
    		    }
    		}

  4. 输出结果：

    复制
    		含有泛型的接口，第一种使用方式是：通过定义接口的实现类，实现接口，指定接口的泛型
    		这个方法传入指定类型参数是：666999

例子2

  1. 创建一个含有泛型的接口

    复制
    		public interface GenericInterface<I> {
    		    /**
    		     * 接口的抽象方法
    		     * @param i 泛型参数
    		     */
    		    public abstract void method(I i);
    		 
    		}

  2. 创建接口的实现类

    复制
    		public class GenericInterfaceImplement<I> implements GenericInterface<I>{
    		 
    		    @Override
    		    public void method(I i) {
    		        System.out.println(
    		                "含有泛型的接口第二种使用方式:接口使用什么泛型,实现类就使用什么泛型,类跟着接口走\n"
    		                        + "创建对象的时候传入指定类型参数是：" + i
    		        );
    		    }
    		}

  3. 测试含有泛型的接口

    复制
    		public class DemoGenericInterfaceImplement {
    		    public static void main(String[] args) {
    		        GenericInterfaceImplement01<Integer> gii = new GenericInterfaceImplement01<>();
    		 
    		        gii.method(2020);
    		    }
    		}

泛型通配符

  1. 通配符基本使用泛型的通配：不知道使用什么类型来接收的时候，此时可以使用?，?表示未知通配符，即：表示任意的数据类型。
  2. 使用方式：不能创建对象使用，只能作为方法的参数使用。
  3. 注意：一但使用泛型的通配符，那么，只能使用Object类中的共性方法，集合中元素的自身方法无法使用。

举例

  1. 创建一个遍历集合的方法

    复制
    		public class IteratorArrayList {
    		    // 由于不知道接收的ArrayList的数据是什么类型，所以使用泛型通配符?
    		    public static void printArrayList(ArrayList<?> arrayList) {
    		        // 使用迭代器遍历集合
    		        Iterator<?> ite = arrayList.iterator();
    		        while (ite.hasNext()) {
    		            // next()方法取出的元素是Object，可以接收任意的数据类型
    		            Object object = ite.next();
    		            System.out.println(object);
    		        }
    		    }
    		}

  2. 测试这个方法

    复制
    		public class DemoIteratorArrayList {
    		    public static void main(String[] args) {
    		        // Integer类型数据
    		        ArrayList<Integer> arrayList1 =  new ArrayList<>();
    		        arrayList1.add(1);
    		        arrayList1.add(2);
    		        arrayList1.add(3);
    		        arrayList1.add(4);
    		        arrayList1.add(5);
    		        // 遍历Integer数据类型的集合
    		        IteratorArrayList.printArrayList(arrayList1);
    		 
    		        System.out.println("==========================================");
    		 
    		        // String数据类型
    		        ArrayList<String> arrayList2 =  new ArrayList<>();
    		        arrayList2.add("一号元素");
    		        arrayList2.add("二号元素");
    		        arrayList2.add("三号元素");
    		        arrayList2.add("四号元素");
    		        arrayList2.add("五号元素");
    		        // 遍历String数据类型的集合
    		        IteratorArrayList.printArrayList(arrayList2);
    		    }
    		}

  3. 输出结果：

    复制
    		1
    		2
    		3
    		4
    		5
    		==========================================
    		一号元素
    		二号元素
    		三号元素
    		四号元素
    		五号元素
posted @   LeeHua  阅读(407)  评论(0)  编辑  收藏  举报
编辑推荐：
· AI与.NET技术实操系列：向量存储与相似性搜索在 .NET 中的实现
· 基于Microsoft.Extensions.AI核心库实现RAG应用
· Linux系列：如何用heaptrack跟踪.NET程序的非托管内存泄露
· 开发者必知的日志记录最佳实践
· SQL Server 2025 AI相关能力初探
阅读排行：
· 震惊！C++程序真的从main开始吗？99%的程序员都答错了
· winform 绘制太阳，地球，月球 运作规律
· 【硬核科普】Trae如何「偷看」你的代码？零基础破解AI编程运行原理
· 超详细：普通电脑也行Windows部署deepseek R1训练数据并当服务器共享给他人
· 上周热点回顾（3.3-3.9）
点击右上角即可分享
微信分享提示
AI IDE Trae

目录导航