Java泛型-多种类型的参数

Java泛型是Java语言中的一项非常强大的特性，它允许我们在编写程序时定义一种数据类型，可以用来代替真实的数据类型。而且，Java泛型不仅可以用于类、接口定义中，还可以用于方法的参数、返回值、变量等多种类型的参数。

泛型类

泛型类指的是被参数化的类，也就是说，它的数据类型是由类的使用者来指定的。我们可以通过在类名后面添加<T>这样的语句来定义泛型类。例如：

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

上述的GenericClass就是一个泛型类，它的类型由<T>所指定。使用时，我们可以为T指定任何类型，例如：

GenericClass<String> str = new GenericClass<>();
str.setValue("Hello, World!");
System.out.println(str.getValue()); // Hello, World!

GenericClass<Integer> num = new GenericClass<>();
num.setValue(123);
System.out.println(num.getValue()); // 123

上述的代码展示了如何创建GenericClass泛型类的实例，并传递不同类型的参数。

泛型方法

泛型方法指的是被参数化的方法，它可以对参数、返回值或者本地变量使用泛型类型。我们可以在方法的返回值、参数列表或者方法名前面添加<T>这样的语句来定义泛型方法。例如：

public class GenericMethod {
    public static <T> void print(T value) {
        System.out.println(value);
    }
}

上述的GenericMethod就是一个包含泛型方法的类，它的print方法可以接收任何类型的参数，比如：

GenericMethod.print("Hello, World!"); // Hello, World!
GenericMethod.print(123); // 123
GenericMethod.print(3.14); // 3.14

泛型接口

泛型接口指的是被参数化的接口，它的类型也是由实现类来指定的。我们可以在接口名后面添加<T>这样的语句来定义泛型接口。例如：

public interface GenericInterface<T> {
    T getValue();
    void setValue(T value);
}

上述的GenericInterface就是一个包含泛型类型参数的接口，它的实现类必须指定T的具体类型。例如：

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

上述的代码展示了如何实现一个泛型接口。

通配符

通配符是Java泛型中用来表示未知类型的符号，可以用在泛型方法、泛型类、泛型接口的定义中。通配符一般用?来表示，例如：

public class GenericClass<T> {
    // 可以接收任何类型的参数
    public void print(GenericClass<?> obj) {
        System.out.println(obj.value);
    }
}

上述的print方法中定义了一个通配符来表示传递的参数类型未知。它可以接收任何类型的参数，例如：

GenericClass<String> str = new GenericClass<>();
GenericClass<Integer> num = new GenericClass<>();

str.print(str); // Hello, World!
num.print(num); // 123

上述的代码展示了如何使用通配符来定义泛型方法中的参数类型。

上下界限定

Java泛型中的上下界限定可以让我们对类型参数进行限制，从而提高程序的可读性和鲁棒性。其中，上界限定使用extends关键字来指定，下界限定使用super关键字来指定。例如：

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

上述的GenericClass限定了它的类型参数必须是Number类或者其子类。这样可以有效避免一些类型转换的问题。

另外，下界限定可以用来限定某个类型必须是某个类的父类或者本身，例如：

public void printList(List<? super Integer> list) {
    // 可以往列表中添加Integer及其子类对象
    list.add(new Integer(3));
    list.add(new Long(123L));
    list.add(new Double(3.14));
    // 不能往列表中添加其他类型的对象
    list.add(new String("abc")); // compile error
}

上述的printList方法中定义了一个下界限定来限制传递的参数必须是Integer类的父类或者本身。这样，我们可以往列表中添加Integer及其子类对象，而不能添加其他类型的对象。

总结

Java泛型可以为程序提供很多好处，例如类型安全、减少类型转换等等。不过，如果滥用泛型，会导致程序变得复杂而难以理解。因此，合理地使用Java泛型可以提高程序的可维护性和可扩展性。