深入理解Java编写泛型的方法！

开篇语

哈喽，各位小伙伴们，你们好呀，我是喵手。运营社区：C站/掘金/腾讯云/阿里云/华为云/51CTO；欢迎大家常来逛逛

  今天我要给大家分享一些自己日常学习到的一些知识点，并以文字的形式跟大家一起交流，互相学习，一个人虽可以走的更快，但一群人可以走的更远。

  我是一名后端开发爱好者，工作日常接触到最多的就是Java语言啦，所以我都尽量抽业余时间把自己所学到所会的，通过文章的形式进行输出，希望以这种方式帮助到更多的初学者或者想入门的小伙伴们，同时也能对自己的技术进行沉淀，加以复盘，查缺补漏。

小伙伴们在批阅的过程中，如果觉得文章不错，欢迎点赞、收藏、关注哦。三连即是对作者我写作道路上最好的鼓励与支持！

前言

  在Java中，泛型是一个非常强大且灵活的特性，它允许你编写可以处理多种类型数据的代码，而无需失去类型安全性。随着Java的泛型机制的引入，我们能够让代码更加通用、简洁，并且在编译时就能捕获类型错误。今天，我们将深入探讨如何在Java中编写泛型，并理解泛型的工作原理。

一、泛型的基础概念

首先，理解泛型的基本概念是非常重要的。泛型允许你定义能够操作不同类型数据的类、接口和方法，同时仍保持类型安全。换句话说，泛型为类、接口和方法提供了一个占位符，可以在实际使用时替换为具体的类型。

1. 泛型类

泛型类是定义带有类型参数的类。类型参数允许我们在创建对象时指定数据类型，从而避免了使用Object类型时出现的强制类型转换问题。

语法结构：

class ClassName<T> {
    private T data;

    public void setData(T data) {
        this.data = data;
    }

    public T getData() {
        return data;
    }
}

示例代码：

// 泛型类示例
public class Box<T> {
    private T value;

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

    public T getValue() {
        return value;
    }

    public static void main(String[] args) {
        Box<Integer> intBox = new Box<>();
        intBox.setValue(100);
        System.out.println("Value in intBox: " + intBox.getValue());

        Box<String> strBox = new Box<>();
        strBox.setValue("Hello, Generics!");
        System.out.println("Value in strBox: " + strBox.getValue());
    }
}

在这个例子中，我们定义了一个Box类，它是一个泛型类，能够容纳任何类型的数据。通过传入不同的类型参数，我们在运行时创建了Box<Integer>和Box<String>两个不同的实例，分别存储了整数和字符串。

2. 泛型接口

接口也可以是泛型的，这意味着你可以定义带有类型参数的接口，并在实现该接口时指定具体的类型。

语法结构：

interface InterfaceName<T> {
    void performAction(T data);
}

示例代码：

// 泛型接口示例
interface Printer<T> {
    void print(T value);
}

class StringPrinter implements Printer<String> {
    public void print(String value) {
        System.out.println("Printing: " + value);
    }
}

class IntegerPrinter implements Printer<Integer> {
    public void print(Integer value) {
        System.out.println("Printing number: " + value);
    }
}

public class GenericInterfaceExample {
    public static void main(String[] args) {
        Printer<String> stringPrinter = new StringPrinter();
        stringPrinter.print("Hello, world!");

        Printer<Integer> integerPrinter = new IntegerPrinter();
        integerPrinter.print(123);
    }
}

在这个例子中，Printer接口是一个泛型接口，StringPrinter和IntegerPrinter分别实现了该接口并定义了具体的打印行为。

3. 泛型方法

泛型方法是指在方法内部使用泛型，它允许你在方法签名中定义类型参数，而这个类型参数的作用只限于该方法。

语法结构：

public <T> void method(T arg) {
    // 方法实现
}

示例代码：

// 泛型方法示例
public class GenericMethodExample {
    // 泛型方法
    public static <T> void printArray(T[] array) {
        for (T element : array) {
            System.out.println(element);
        }
    }

    public static void main(String[] args) {
        Integer[] intArray = {1, 2, 3};
        String[] strArray = {"Hello", "World"};

        // 调用泛型方法
        printArray(intArray);
        printArray(strArray);
    }
}

在这个例子中，printArray是一个泛型方法，它能够接受任何类型的数组并打印其中的元素。我们通过<T>来声明一个类型参数T，并在方法内部使用它。

二、通配符（Wildcard）与泛型

通配符是泛型中的一个重要概念，它允许你在某些情况下使用“任意类型”的泛型。

1. 上界通配符（? extends T）

上界通配符限制了泛型类型必须是T类型或T类型的子类。

示例代码：

public class UpperBoundWildcard {
    // 使用上界通配符
    public static void printNumbers(List<? extends Number> list) {
        for (Number number : list) {
            System.out.println(number);
        }
    }

    public static void main(String[] args) {
        List<Integer> integers = List.of(1, 2, 3);
        List<Double> doubles = List.of(1.1, 2.2, 3.3);

        printNumbers(integers);  // 可以传递 List<Integer>
        printNumbers(doubles);   // 可以传递 List<Double>
    }
}

在这个例子中，printNumbers方法接受一个List<? extends Number>类型的参数，这意味着它可以接受任何Number类型及其子类的列表，如Integer、Double等。

2. 下界通配符（? super T）

下界通配符限制了泛型类型必须是T类型或T类型的父类。

示例代码：

public class LowerBoundWildcard {
    // 使用下界通配符
    public static void addNumbers(List<? super Integer> list) {
        list.add(10);  // 只能添加Integer类型或其子类
    }

    public static void main(String[] args) {
        List<Number> numberList = new ArrayList<>();
        List<Object> objectList = new ArrayList<>();

        addNumbers(numberList);  // 可以传递 List<Number>
        addNumbers(objectList);   // 可以传递 List<Object>
    }
}

在这个例子中，addNumbers方法接受一个List<? super Integer>类型的参数，这意味着它可以接受Integer类型或Integer的父类类型（如Number或Object）的列表。

3. 无界通配符（?）

无界通配符表示可以接受任何类型的泛型。

示例代码：

public class WildcardExample {
    public static void printList(List<?> list) {
        for (Object obj : list) {
            System.out.println(obj);
        }
    }

    public static void main(String[] args) {
        List<String> strList = List.of("Java", "Generics", "Wildcards");
        List<Integer> intList = List.of(1, 2, 3);

        printList(strList);  // 可以传递 List<String>
        printList(intList);  // 可以传递 List<Integer>
    }
}

无界通配符?表示可以传递任何类型的列表，因此printList方法可以接受任何类型的列表。

三、泛型的限制与注意事项

1. 不能使用基本数据类型作为泛型参数

在Java中，泛型不支持基本数据类型（如int、char等）。你只能使用其对应的包装类（如Integer、Character等）。

示例代码：

// 错误示例
// Box<int> box = new Box<>();  // 编译错误

// 正确示例
Box<Integer> box = new Box<>();

2. 泛型类型不能使用instanceof

在Java中，你不能使用instanceof来检查泛型类型的类型参数。由于类型擦除（type erasure）机制，泛型在运行时是不可知的。

错误示例：

// 错误示例
List<String> list = new ArrayList<>();
if (list instanceof List<String>) {  // 编译错误
    System.out.println("This is a List<String>");
}

四、总结

泛型是Java编程语言中一个强大的特性，它能够让你编写更加通用和灵活的代码，同时确保类型安全。通过泛型类、接口和方法，你可以大大简化代码的结构，并避免强制类型转换带来的潜在错误。同时，通配符和泛型的上下界限制为你的代码提供了更大的灵活性和可扩展性。

希望通过这篇文章的讲解，你能更好地理解Java泛型的工作原理，并在实际编程中合理应用泛型，提高代码的复用性和可维护性。

… …

文末

好啦，以上就是我这期的全部内容，如果有任何疑问，欢迎下方留言哦，咱们下期见。

… …

学习不分先后，知识不分多少；事无巨细，当以虚心求教；三人行，必有我师焉！！！

wished for you successed ！！！

⭐️若喜欢我，就请关注我叭。

⭐️若对您有用，就请点赞叭。
⭐️若有疑问，就请评论留言告诉我叭。

版权声明：本文由作者原创，转载请注明出处，谢谢支持！