Java泛型的概念和使用

下面是Java泛型的概念和使用攻略。

概念

Java泛型是一种参数化类型的概念，它可以让我们在定义类、方法或接口时使用参数来表示类型参数，并在使用时用实际类型参数代替类型参数。泛型的设计初衷是为了在编译时期发现类型错误，从而让程序更加健壮和可维护。

泛型的语法主要涉及以下几个部分：

1. 类型参数：用尖括号包裹，例如<T>。

2. 泛型类：使用类型参数定义类。

public class GenericClass<T> {
    private T value;

    public GenericClass(T value) {
        this.value = value;
    }

    public void printValue() {
        System.out.println("Value: " + value);
    }
}

1. 泛型方法：使用类型参数定义方法。

public class GenericMethod {
    public static <T> void printValue(T value) {
        System.out.println("Value: " + value);
    }
}

1. 通配符：用于指定泛型类型的上限或下限。

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

使用攻略

下面介绍一些Java泛型的使用攻略。

泛型类的使用

定义泛型类时，需要在类名后面添加尖括号并定义一个类型参数，用来代替实际类型。

public class GenericClass<T> {
    private T value;

    public GenericClass(T value) {
        this.value = value;
    }

    public void printValue() {
        System.out.println("Value: " + value);
    }
}

使用泛型类时，可以使用实际类型替代类型参数。

GenericClass<String> gc1 = new GenericClass<>("Hello");
gc1.printValue(); // Value: Hello

GenericClass<Integer> gc2 = new GenericClass<>(123);
gc2.printValue(); // Value: 123

泛型方法的使用

定义泛型方法时，需要在方法返回值前添加类型参数，并使用该类型参数作为方法中参数的类型或返回值的类型。

public class GenericMethod {
    public static <T> void printValue(T value) {
        System.out.println("Value: " + value);
    }
}

使用泛型方法时，需要在方法调用时指定实际类型。

GenericMethod.printValue("Hello"); // Value: Hello
GenericMethod.printValue(123); // Value: 123

通配符的使用

通配符可以用于指定泛型类型的上限或下限。

<? extends Number>表示泛型类型必须是Number或Number的子类。

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

使用通配符时，需要传入符合要求的泛型类型。

List<Integer> intList = Arrays.asList(1, 2, 3);
List<Double> doubleList = Arrays.asList(1.0, 2.0, 3.0);

Wildcard.printValue(intList); // 1 2 3
Wildcard.printValue(doubleList); // 1.0 2.0 3.0

类型擦除和桥方法

Java泛型是使用类型擦除来实现的，即在编译时，泛型类型会被擦除为Object类型，并使用类型转换来实现泛型的功能。

因为使用类型擦除实现泛型，所以Java中是不存在泛型类的子类关系的。在继承泛型类时，编译器会自动生成桥方法来保证类型安全。

下面是一个例子：

public class SuperClass<T> {
    public T getValue() {
        return null;
    }
}

public class SubClass<T> extends SuperClass<T> {
    @Override
    public T getValue() {
        return null;
    }
}

// 编译后的代码
public class SuperClass {
    public Object getValue() {
        return null;
    }
}

public class SubClass extends SuperClass {
    @Override
    public Object getValue() {
        return getValue();
    }
}

在继承时，子类重写了父类的方法，但是泛型类型被擦除了，所以子类的方法中返回的是Object类型。为了保证类型安全，编译器会自动生成桥方法，在桥方法中保留子类中的类型。

上面的例子中，SubClass类中生成的桥方法如下所示：

public class SubClass extends SuperClass {
    @Override
    public Object getValue() {
        return getValue();
    }

    @Override
    public Object getValue() {
        return super.getValue();
    }
}

桥方法起到了保证类型安全的作用。

至此，Java泛型的概念和使用攻略就介绍完毕了。