深入理解java泛型Generic

深入理解Java泛型

Java泛型是Java语言中的重要特性之一，在编写Java程序时经常被使用。本文将介绍Java泛型的相关知识点，包括泛型类、泛型方法、通配符、类型擦除等内容。本文将帮助读者更深入地理解Java泛型。

泛型类

泛型类是指在定义其时使用了类型参数的类，通过类型参数来实现对不同类型的支持。泛型类定义的语法如下：

public class GenericClass<T> {
    private T value;
    public void setValue(T value) {
        this.value = value;
    }
    public T getValue() {
        return this.value;
    }
}

在上述代码中，GenericClass 是一个泛型类，使用了类型参数 T。在实例化泛型类时，可以指定 T 的具体类型，例如：

GenericClass<String> gc = new GenericClass<String>();
gc.setValue("hello");
String value = gc.getValue();

在上述代码中，实例化了一个 GenericClass 对象，其中的类型参数 T 被指定为 String 类型。通过 setValue 方法设置了一个字符串值，通过 getValue 方法获取了该字符串值。

泛型方法

与泛型类类似，Java中还可以定义泛型方法，通过泛型方法可以在不同的方法中使用类型参数实现对不同类型的支持。

public class GenericMethod {
    public <T> void print(T value) {
        System.out.println(value.getClass().getSimpleName() + ": " + value);
    }
}

在上述代码中，定义了一个 print 方法，使用了类型参数 T，通过 value.getClass().getSimpleName() 可以获得该参数的类型的类名，然后通过 System.out.println 输出。

GenericMethod gm = new GenericMethod();
gm.print("hello");
gm.print(123);

上述代码中，创建了一个 GenericMethod 对象，分别调用了 print 方法，传递了一个字符串和一个整数类型参数。

通配符

通配符是在泛型中使用的一种特殊符号，它可以表示任意类型的参数。

上限通配符

上限通配符使用 extends 关键字来限制泛型类型参数的类型上限。例如：

public void print(List<? extends Number> list) {
    for (Number n : list) {
        System.out.println(n);
    }
}

上述代码中，使用 List<? extends Number> 来声明方法参数 list 的类型，该声明表示参数类型为 Number 或其子类型的 List 对象。

下限通配符

下限通配符使用 super 关键字来限制泛型类型参数的类型下限。例如：

public void add(List<? super Integer> list) {
    list.add(new Integer(10));
}

上述代码中，使用 List<? super Integer> 来声明方法参数 list 的类型，该声明表示参数类型为 Integer 或其超类型的 List 对象。

类型擦除

Java泛型实现的机制是类型擦除，编译器通过泛型类和泛型方法的特殊写法，来将类型参数在编译时期擦除，并在运行时期中使用 Object 类型来代替泛型类型参数。这种机制的本质上是为了保证兼容性和适应旧版本的Java代码。

上述介绍了Java泛型中的一些关键知识点，通过学习本文可以更深入地理解Java泛型，体验Java泛型的强大之处，开发出更加高效和功能强大的Java应用程序。

示例一：

public class Point<T> {
    private T x;
    private T y;

    public Point(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) {
        Point<Integer> point = new Point<>(10, 20);
        int x = point.getX();
        int y = point.getY();
        System.out.println("Point(" + x + ", " + y + ")");
    }
}

以上代码中定义了一个泛型类Point，它的参数T可以将x和y同时定义成整型、浮点型等类型。在main函数中通过将类带参数Integer实例化并使用getX和getY属性可把Point类中的x和y的值转换为整型，便于进行相关的计算操作。

示例二：

public class Utils {
    public static <T> T find(T[] array, T value) {
        for (T item : array) {
            if (item.equals(value)) {
                return item;
            }
        }
        return null;
    }

    public static void main(String[] args) {
        String[] array = {"hello", "world", "java"};
        String res = find(array, "world");
        System.out.println(res);
    }
}

以上代码中定义了一个工具类Utils，它的泛型方法find可以查找数组中是否包含指定的元素，并返回该元素本身，返回值类型也是泛型类型T。在main函数中实例化字符串数组array和一个字符串value，将array和value作为参数传入find方法中进行查找，查找到“world”字符串后返回该元素本身。