java基础(十二 )-----Java泛型详解

Java泛型是Java 5引入的新特性，可以提高代码的可读性和安全性，降低代码的耦合度。泛型是将类型参数化，实现代码的通用性。

一、泛型的基本语法

在声明类、接口、方法时可以使用泛型，泛型的声明方式为在类名、接口名、方法名后面加上尖括号<>，括号中可以声明一个或多个类型参数，多个类型参数之间用逗号隔开。例如：

public class GenericClass<T> {
    private T data;

    public T getData() {
        return data;
    }

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

public interface GenericInterface<T> {
    T getData();
    void setData(T data);
}

public <T> void genericMethod(T data) {
    System.out.println(data);
}

其中，`GenericClass`是一个泛型类，`GenericInterface`是一个泛型接口，`genericMethod`是一个泛型方法。在这些声明中，`<T>`就是类型参数，可以用任何字母代替。

二、泛型的使用

1. 泛型类的使用

在使用泛型类时，需要在类名后面加上尖括号<>，并在括号中指定具体的类型参数。例如：

GenericClass<String> gc = new GenericClass<>();
gc.setData("Hello World");
String data = gc.getData();

在这个例子中，`GenericClass`被声明为一个泛型类，`<String>`指定了具体的类型参数，即`data`字段的类型为`String`，`gc`对象被创建时没有指定类型参数，因为编译器可以根据上下文自动推断出类型参数为`String`。

2. 泛型接口的使用

在使用泛型接口时，也需要在接口名后面加上尖括号<>，并在括号中指定具体的类型参数。例如：

GenericInterface<String> gi = new GenericInterface<String>() {
    private String data;

    @Override
    public String getData() {
        return data;
    }

    @Override
    public void setData(String data) {
        this.data = data;
    }
};

gi.setData("Hello World");
String data = gi.getData();

在这个例子中，`GenericInterface`被声明为一个泛型接口，`<String>`指定了具体的类型参数，匿名内部类实现了该接口，并使用`String`作为类型参数。

3. 泛型方法的使用

在使用泛型方法时，需要在方法名前面加上尖括号<>，并在括号中指定具体的类型参数。例如：

genericMethod("Hello World");

在这个例子中，`genericMethod`被声明为一个泛型方法，`<T>`指定了类型参数，`T data`表示一个类型为`T`的参数，调用时可以传入任何类型的参数。

三、泛型的通配符

有时候，我们不知道泛型的具体类型，可以使用通配符`?`。通配符可以作为类型参数出现在方法的参数类型或返回类型中，但不能用于声明泛型类或泛型接口。例如：

public void printList(List<?> list) {
    for (Object obj : list) {
        System.out.print(obj + " ");
    }
}

在这个例子中，`printList`方法的参数类型为`List<?>`，表示可以接受任何类型的`List`，无论是`List<String>`还是`List<Integer>`都可以。在方法内部，使用`Object`类型来遍历`List`中的元素。

四、泛型的继承

泛型类和泛型接口可以继承或实现其他泛型类或泛型接口，可以使用子类或实现类的类型参数来替换父类或接口的类型参数。例如：

public class SubGenericClass<T> extends GenericClass<T> {}

public class SubGenericInterface<T> implements GenericInterface<T> {
    private T data;

    @Override
    public T getData() {
        return data;
    }

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

在这个例子中，`SubGenericClass`继承了`GenericClass`，并使用了相同的类型参数`T`，`SubGenericInterface`实现了`GenericInterface`，也使用了相同的类型参数`T`。

五、泛型的限定

有时候，我们需要对泛型的类型参数进行限定，使其只能是某个类或接口的子类或实现类。可以使用`extends`关键字来限定类型参数的上限，或使用`super`关键字来限定类型参数的下限。例如：

public class GenericClass<T extends Number> {
    private T data;

    public T getData() {
        return data;
    }

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

public interface GenericInterface<T extends Comparable<T>> {
    T getData();
    void setData(T data);
}

在这个例子中，`GenericClass`的类型参数`T`被限定为`Number`的子类，`GenericInterface`的类型参数`T`被限定为实现了`Comparable`接口的类。

六、泛型的擦除

在Java中，泛型信息只存在于代码编译阶段，在编译后的字节码中会被擦除。在运行时，无法获取泛型的具体类型。例如：

public void genericMethod(List<String> list) {
    System.out.println(list.getClass());
}

在这个例子中，`list`的类型为`List<String>`，但是在运行时，`getClass`返回的类型为`java.util.ArrayList`，因为泛型信息已经被擦除了。

七、泛型的类型推断

在Java 7中，引入了钻石操作符<>，可以使用它来省略类型参数的声明。例如：

List<String> list = new ArrayList<>();

在这个例子中，`ArrayList`的类型参数可以被编译器自动推断为`String`。

八、总结

Java泛型是一个强大的特性，可以提高代码的可读性和安全性，降低代码的耦合度。在使用泛型时，需要注意它的基本语法、使用方法、通配符、继承、限定、擦除和类型推断等问题。