【技术积累】Java中的泛型【一】

泛型是什么

Java中的泛型是一种能够让用户在编写代码时避免使用明确的类型而进行类型参数化的机制。Java中的泛型可以让编程者在代码编写时不必关心具体类型，只用关心类型之间的关系和相互转换，从而在编写代码的过程中实现类型的复用。这使得代码更加简洁、可读性更高，并且可以提高代码的可维护性和可扩展性。

Java泛型可以在类、方法、接口、以及数组等多个地方使用，并且可以结合约束条件来限制类型参数的类型。例如，在定义一个泛型类时，可以使用<T>定义一个泛型类型参数，T可以代表任何具体类型，例如Integer、String、Map等。在使用泛型时，可以将具体类型传递给类型参数，然后在方法或者类中使用该类型参数，从而实现代码的类型自动化。

Java中的泛型还具有类型检查和类型擦除的特性。类型检查可以检查在编译时期是否使用了正确的类型，避免了在运行时期由于类型转换错误而产生的异常。而类型擦除则是Java泛型在实现时使用的一种技术，它会去掉泛型中的类型参数信息，并将其变为原始类型，在运行时也不会保留泛型的信息，从而实现Java泛型的运行时兼容性。

什么是类型参数？

Java中的类型参数是用于泛型编程的占位符，可以用来表示任何类型。它们用尖括号 "<>" 括起来，放置在类名或方法名后面，用来指定通用类型。

 

例如，以下代码中的 T 就是一个类型参数：

 

public class MyClass<T> {
    private T value;

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

    public T getValue() {
        return value;
    }
}

 

在上面的代码中，T 代表一个通用类型。可以在创建 MyClass 对象时指定 T 的具体类型，如：

 

MyClass<Integer> intObj = new MyClass<>();
MyClass<String> strObj = new MyClass<>();

这样，intObj 对象中的 value 的类型就是 Integer，strObj 对象中的 value 的类型就是 String。

 

类型参数可以用在类、方法、接口等地方，用来实现通用的算法。使用类型参数可以允许我们编写一次通用的代码，可以用于不同类型的数据，是 Java 泛型编程的核心特性。

什么是类型擦除？

类型擦除（type erasure）是指在Java编译期间，对泛型类型参数信息的擦除，将所有泛型类型参数都用它们的上界（或Object类型）替换，从而在运行时不会保留泛型类型信息。

具体来说，编译器会将泛型类、泛型接口中的类型参数用对应的类型上限（即extends关键字后面的类型）替换，泛型方法中的类型参数也会被替换。例如，对于以下泛型类：

public class Pair<T, S> {
    private T first;
    private S second;

    public Pair(T first, S second) {
        this.first = first;
        this.second = second;
    }

    public T getFirst() {
        return first;
    }

    public S getSecond() {
        return second;
    }
}

它在编译后会被转换为：

public class Pair {
    private Object first;
    private Object second;

    public Pair(Object first, Object second) {
        this.first = first;
        this.second = second;
    }

    public Object getFirst() {
        return first;
    }

    public Object getSecond() {
        return second;
    }
}

这就是类型擦除的过程，所有泛型类型信息都被擦除并替换为Object类型。

虽然泛型类型信息被擦除，但在运行时可以通过反射机制获取到泛型类型信息，这使得泛型在运行时仍然可以使用。但是，由于类型擦除，泛型类型参数在运行时无法进行类型检查，因此可能会导致类型安全问题。

什么是通配符类型？

Java中的通配符类型是一种泛型类型，用于表示未知类型的泛型参数。 通配符类型由问号（？）表示，其可以用作方法的参数类型、字段类型、局部变量类型等任何地方需要使用泛型类型的地方。

通配符类型有两种形式：无界通配符类型和有界通配符类型。

无界通配符类型是指使用符号 ? 表示未知类型，例如 List<?>。在使用无界通配符类型时，不能添加任何元素到集合中，因为这个集合的元素类型是未知的。但是，可以从集合中获取元素，并将其转换为 Object 类型。

有界通配符类型是指使用符号 ? extends 或 ? super，限制泛型参数的类型范围。例如，List<? extends Number> 表示泛型参数必须是 Number 类型或其子类型。而 List<? super Integer> 表示泛型参数必须是 Integer 类型或其父类型。在使用有界通配符类型时，可以添加元素到集合中，并能获取它们。

注意，通配符类型不能用于泛型类或泛型接口的定义，只能作为方法参数或返回类型的通用形式使用。

什么是泛型方法和泛型类

泛型方法和泛型类是Java中重要的概念，它们的作用是为了提高代码的可重用性和安全性。

泛型方法是在方法的声明中使用泛型类型，使得方法可以接受不同类型的参数，同时还可以指定返回值或方法体中使用的泛型类型。泛型方法通常有以下特点：

1. 泛型方法可以在方法中定义自己的类型参数，也可以使用类定义的类型参数。
2. 泛型方法可以接受任意类型的参数，即可以接受参数化类型，也可以接受普通类型。
3. 泛型方法可以有多个类型参数，也可以没有类型参数。
4. 泛型方法可以有泛型类型的返回值。

下面是一个使用泛型方法的例子：

public static <T> void printArray(T[] array) {
    for (int i = 0; i < array.length; i++) {
        System.out.print(array[i] + " ");
    }
    System.out.println();
}

在这个例子中，我们定义了一个名为 printArray 的泛型方法，它接受一个泛型数组作为参数，并且使用 for 循环遍历数组的每个元素，最后输出所有元素到控制台。

泛型类是在类的声明中使用泛型类型，使得类可以接受不同类型的参数，同时还可以指定类中使用的泛型类型。泛型类通常有以下特点：

1. 泛型类可以在类名后面添加泛型类型参数。
2. 泛型类可以在类中定义泛型类型的实例变量。
3. 泛型类可以有泛型类型的构造方法。
4. 泛型类可以有泛型类型的方法。

下面是一个使用泛型类的例子：

public class Box<T> {
    private T value;

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

    public T getValue() {
        return value;
    }

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

    public static void main(String[] args) {
        Box<Integer> box = new Box<>(10);
        System.out.println(box.getValue());
    }
}

在这个例子中，我们定义了一个名为 Box 的泛型类，它有一个泛型类型参数 T，同时定义了一个名为 value 的实例变量，以及相应的 get 和 set 方法。在 main 方法中，我们创建了一个 Box 对象，并且使用泛型类型为 Integer 的参数，然后输出了这个对象的值到控制台。

总的来说，泛型方法和泛型类是Java中非常重要的概念，它们可以为我们提供更加灵活和安全的编程方式，同时也是提高代码可读性和可维护性的有效手段。

泛型类中是否可以继承泛型类

Java中泛型类可以继承泛型类，这一特性被称为泛型的继承或泛型的子类化。

在泛型类继承中，子类继承的父类可以是泛型类也可以是非泛型类。当子类继承的父类是泛型类时，子类可以继承父类的泛型类型；也可以在继承时指定自己的泛型类型。

下面是一个范例来展示Java中泛型类继承泛型类的用法：

public class Parent<T> {
    // 泛型类型 T
    private T data;

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

    public T getData() {
        return data;
    }
}

public class Child<T> extends Parent<T> {
    // 继承泛型类 Parent<T>
}

public class Test {
    public static void main(String[] args) {
        Child<String> child = new Child<String>(); // 子类指定了泛型类型为 String
        child.setData("Hello World");
        System.out.println(child.getData()); // 输出结果为 "Hello World"
    }
}

在上面的例子中，Child类继承了Parent类，由于Parent类是一个泛型类，所以Child类又继承了Parent类的泛型类型T。而在定义Child类时，也可以在继承Parent类时指定T的具体类型，如Child<String>，从而使Child类也成为具有泛型特性的类。

总结一下，Java中允许泛型类继承泛型类，子类也可以使用父类的泛型类型或为自己指定泛型类型。这个特性可以帮助开发者更好地管理和组织泛型类，能够提升代码的可重用性和可读性。

泛型方法中是否可以声明泛型类

Java中泛型方法可以声明泛型类，这样可以在方法中使用泛型类型参数，从而在方法中实现通用的操作。

除了声明泛型类，泛型方法还可以声明泛型方法参数、返回类型，以及利用泛型通配符进行类型转换等常用操作。

以下是一个简单的示例，展示了在泛型方法中声明泛型类的用法：

public class MyClass<T> {
    public <E> void printElements(E[] elements) {
        for (E element : elements) {
            System.out.println(element.toString());
        }
        T obj = new T();  // 泛型类类型参数T在泛型方法中使用
    }
}

public class Test {
    public static void main(String[] args) {
        Integer[] integers = {1, 2, 3, 4, 5};
        String[] strings = {"Hello", "World"};

        MyClass<Integer> myClass = new MyClass<>();
        myClass.printElements(integers);

        MyClass<String> myClass1 = new MyClass<>();
        myClass1.printElements(strings);
    }
}

在上述代码中，我们定义了一个泛型类 MyClass<T>，其中，又定义了一个名为 printElements 的泛型方法，该方法中使用了泛型类型参数 E[]，并在方法中对数组元素进行遍历输出；同时，方法中也使用了泛型类型参数 T，在方法中初始化一个泛型类类型参数T的对象。

在Test类中，我们实例化了两个 MyClass 类，分别强制指定泛型类型参数为 Integer 类型和 String 类型，并通过执行各自的 printElements 方法来打印数组元素。

通过这种方式，Java中的泛型方法不仅支持泛型类型参数，也支持对泛型类（包括实例化泛型类对象）的操作，从而让我们可以实现更加通用的方法封装，提升代码的可读性和复用性。

为什么类型参数不能是原始类型

1. 泛型的类型擦除机制

Java中的泛型是通过类型擦除机制实现的。泛型类和方法会在编译时通过擦除类型信息来去除泛型的影响，转换成原始类型。例如，List<String>和List<Integer>在编译后都会变成List<Object>。

原始类型与泛型类无法一起使用，这样会破坏Java 的类型安全。如果类型参数允许原始类型，那么在擦除类型信息之后，无法在运行时获得类型信息，这就导致了无法编写通用的泛型代码。

1. 原始类型的限制

原始类型不能继承任何类，也无法实现任何接口。如果类型参数可以是原始类型，那么泛型类就无法利用Java强大的面向对象特性来实现更加复杂、灵活的结构。

1. 自动类型转换问题

Java中自动类型转换和类型擦除机制可能会导致类型参数变为原始类型。例如，我们在泛型方法中将一个原始类型转换为一个泛型类型参数，当运行时擦除类型时，这个泛型类型变成了Object类型，而不是我们想要的类型参数。

综上所述，Java中为什么类型参数不能是原始类型，是因为这种做法会破坏Java的类型安全和面向对象特性，无法实现通用的泛型代码。

什么是限定通配符和无限定通配符？

限定通配符是Java中泛型的一个重要特性，用于指定泛型参数的上界或下界。

在Java中，泛型参数不仅可以指定具体的类型，还可以指定一个范围，即可以定义类型的上界或下界。限定通配符就是用来指定这个范围的符号。

限定通配符分为extends和super两种类型：

1. extends限定通配符：用于指定泛型参数的上界。表示类型必须是指定类型或其子类。

示例：List<? extends Number> 表示泛型参数必须是Number或其子类，如Integer、Double等。

1. super限定通配符：用于指定泛型参数的下界。表示类型必须是指定类型或其父类。

示例：List<? super Integer> 表示泛型参数必须是Integer或其父类，如Number、Object等。

限定通配符的作用是确保泛型参数的类型符合特定的条件，同时增加代码的可用性和可读性。

Java中的无限定通配符（Unbounded Wildcard）是指泛型参数没有任何限制，使用符号"?"来表示。

示例：List<?> 表示List中可以存放任何类型的对象，相当于是List<Object>的简化写法。

无限定通配符可以用于以下情况：

1. 当泛型参数类型并不重要时，比如在方法中只需要对泛型参数进行处理而不需要知道具体类型。

2. 当泛型类型的上界或下界无法确定时，比如在方法中需要接受不同类型的List对象，但是这些List对象的元素类型并不确定。

无限定通配符并不能直接调用参数的方法或者添加新的元素，因为其具体的类型是未知的，需要通过强制类型转换才能进行操作。

什么是类型边界

Java泛型中的类型边界（Type Bound）是指限制泛型类型参数的范围，使得参数只能是特定类或其子类，或者实现了特定接口的类或其实现类。

类型边界有两种形式：extends和super。extends用于限制类型参数的上界（Upper Bound），即指定参数只能是某一类或其子类的类型；super用于限制类型参数的下界（Lower Bound），即指定参数只能是某一类或其父类的类型。

//类型边界为Number及其子类

public class GenericClass<T extends Number> {

private T number;

public GenericClass(T number) {

this.number = number;

}

public T getNumber() {

return number;

}

}

GenericClass<Integer> intClass = new GenericClass<>(10);

GenericClass<Double> doubleClass = new GenericClass<>(3.14);

//类型边界为String及其父类

public class GenericClass<T super String> {

private T str;

public GenericClass(T str) {

	this.str = str;

}

public T getString() {

	return str;

}

}

GenericClass<Object> objClass = new GenericClass<>("Hello World");

GenericClass<CharSequence> charSeqClass = new GenericClass<>("Hello World");

什么是协变

Java泛型中的协变（Covariant）是指泛型类型参数的子类型关系能够被继承到泛型类的实例化类型中。也就是说，子类型的泛型类实例可以替代父类型的泛型类实例。

在Java中，协变类型只有在泛型参数是用作方法返回值类型时才可以生效。在这种情况下，如果泛型实例可以返回子类型对象，则该类型为协变类型。

public class Animal {}

public class Dog extends Animal {}

//泛型协变

public class GenericClass<T> {

public T getAnimal() {

return null;

}

}

GenericClass<Dog> dogClass = new GenericClass<>();

GenericClass<? extends Animal> animalClass = dogClass;

Animal animal = animalClass.getAnimal(); //协变成Animal类型

Dog dog = dogClass.getAnimal(); //无需转换，返回类型为Dog

什么是类型变量的继承

Java泛型中，类型变量的继承是指当一个泛型类型参数被声明在一个类中，并被另一个类继承时，继承后的子类可以直接使用该泛型类型参数。

具体来说，当一个类声明了泛型类型参数T，在另一个类中继承该类时，可以通过在子类中指定T的具体类型来使用其父类中声明的泛型类型。子类可以继承和使用其父类中的泛型类型，或者在实现接口时使用泛型类型。

public class ParentClass<T> {

T t;

public T getT() {

return t;

}

}

public class ChildClass<T> extends ParentClass<T> {

}

ChildClass<String> child = new ChildClass<>();

child.setT("Hello"); //继承父类中的泛型类型T

String s = child.getT(); //继承父类中的泛型类型T

//类实现接口时使用泛型类型

public interface MyInterface<T> {

public T getT();

}

public class MyClass<T> implements MyInterface<T> {

}

MyClass<String> myClass = new MyClass<>();

String s = myClass.getT(); //使用泛型类型T