Java中常见错误-泛型擦除及桥接方法问题及解决方案

泛型擦除

​ 泛型擦除是Java泛型机制的一个特性，它意味着**在编译期间，所有的泛型信息都会被移除，而在运行时，所有泛型类型都转换为其边界类型（通常是Object，或者对于参数化的类型参数，是其指定的边界）。这是因为Java的泛型是类型安全的，但不是类型保留的**。换句话说，泛型只在编译时提供类型检查，而运行时并不保留这些类型信息。泛型擦除可以分为以下三类：

无界擦除

​ 无界擦除是指没有指定泛型类型的边界，通常使用 ? 作为通配符。这意味着方法或变量可以接受任何类型的对象。例如，想象你有一个动物观察站，它记录任何动物的信息，但不关心它们的类型。

public class ObservationStation {
    public void recordAnyAnimal(Animal<?> animal) {
        // 不关心动物的类型，只是记录
        System.out.println(animal);
    }
}

@Data
@NoArgsConstructor
public class Animal<T> {

    private T attribute; // 使用泛型T来表示动物的一个属性，比如名字、年龄等

    public Animal(T attribute) {
        this.attribute = attribute;
    }
}

public class unBoundMain {
    public static void main(String[] args) {
        ObservationStation station = new ObservationStation();
        Animal<String> animal1 = new Animal<>("Dog");
        Animal<Integer> animal2 = new Animal<>(1);

        station.recordAnyAnimal(animal1); // 无界擦除，因为可以接受任何Animal类型
        station.recordAnyAnimal(animal2); // 同理
    }
}

​ 在运行时，recordAnyAnimal 方法的参数类型被擦除为 Animal，这意味着它接受任何 Animal 类型的对象，而不管具体的 T 是什么类型。编译器在调用方法时会确保传入的参数是 Animal 的实例。

运行结果：

上界擦除

​ 上界擦除指的是在使用泛型时，将泛型参数限制为某种类型的子类型或该类型本身。

@Data
@NoArgsConstructor
public class Animal<T extends LivingBeing> { // 设置上界，T必须是LivingBeing或其子类

    private T attribute; // 使用泛型T来表示动物的一个属性，比如名字、年龄等

    public Animal(T attribute) {
        this.attribute = attribute;
    }
}

public class LivingBeing {
    private Age age; // 假设Age是一个枚举，表示生物的年龄阶段

    public enum Age {
        PUPPY,
        ADULT,
        SENIOR
    }

    // 其他属性和方法
}

@Data
public class Dog extends LivingBeing{
    private Age age;
}

public class ObservationStation {
    public void recordAnyAnimal(Animal<? extends LivingBeing> animal) { // 上界擦除，接受任何LivingBeing或其子类的Animal
        // 不关心动物的类型，只是记录
        System.out.println(animal);
    }
}

public class upBoundMain {
    public static void main(String[] args) {
        ObservationStation station = new ObservationStation();

        Dog dog = new Dog(); // 创建Dog对象
        dog.setAge(LivingBeing.Age.ADULT); // 设置Dog的年龄
        Animal<Dog> animal1 = new Animal<>(dog); // 将Dog放入Animal<Dog>

        station.recordAnyAnimal(animal1); // 正确，Dog是LivingBeing的子类
    }
}

​ 在这个案例中，我引入了一个假设的LivingBeing基类，并修改了Animal类的泛型声明Animal<T extends LivingBeing>以及ObservationStation类的recordAnyAnimal方法签名private T attribute;Animal(T attribute) ，以确保只有LivingBeing或其子类的Animal实例可以被记录。这样就实现了上界擦除效果

运行结果：

下界擦除

​ 下界通配符允许你指定一个类型参数的下界，意味着可以接受该类型及其父类型。类型擦除的确会让泛型参数具体类型信息消失，但不影响使用下界或上界通配符来表达类型约束

​ 尽管类型擦除导致泛型类型参数的具体类型信息在运行时不可用，但Java依然支持通过下界通配符（如? super T）来限定泛型参数，确保能够接受类型T及其父类型。这并不意味着下界概念在擦除过程中失效，而是指定了类型使用的灵活性在编译时得到保障，即使实际类型信息在运行时不可获取。

public class LivingBeing {
}

public class Dog extends LivingBeing {
    // Dog类的其他属性和方法
}

@Data
@NoArgsConstructor
public class Animal<T> {
    private T attribute;
    public Animal(T attribute) {
        this.attribute = attribute;
    }
}

public class ObservationStation {
    public <T extends LivingBeing> void recordSpecificAnimal(Animal<? super T> animal, T specificType) {
        // 这里可以使用specificType来访问animal的attribute，因为animal能接收specificType或其父类型
        System.out.println("Recording " + specificType + " with attribute: " + animal.getAttribute());
    }
    
public class lowBoundMain {
    public static void main(String[] args) {
        ObservationStation station = new ObservationStation();
        Dog dog = new Dog();
        Animal<Dog> animal1 = new Animal<>(dog);

        station.recordSpecificAnimal(animal1, dog); // 正确，Dog是Anima
    }
}

​ Dog类扩展了LivingBeing，这样它就可以用于Animal实例。在ObservationStation类的recordSpecificAnimal方法中，Dog实例可以作为T传入，因为Dog是LivingBeing的子类。Animal可以作为Animal<? super T>类型的参数传入，其中T是LivingBeing或其子类，因为Dog是LivingBeing的子类，所以Animal满足Animal<? super T>的约束。

运行结果：

public <T extends LivingBeing> void recordSpecificAnimal(Animal<? super T> animal, T specificType)

对 此处 <T extends LivingBeing> 的理解

​ 是Java泛型中的一个类型参数声明，它定义了一个名为 T 的类型变量，这个变量必须是 LivingBeing 类或其子类的类型。这里的 extends 关键字用来指定类型参数的边界，表明 T 只能是 LivingBeing 或者 LivingBeing 的任何子类

对 此处 ? super T 的理解

​ ? super T 是下界通配符，super 关键字在这里表示下界，T 是一个类型参数，代表一个未知的具体类型。
当你看到 ? super T，你可以理解为“任何类型，只要它是 T 或 T 的超类型”。这意味着 animal 变量可以接收任何 Animal 实例，只要这个实例的类型是 T 或者是 T 的父类。例如，如果 T 被实例化为 Dog，那么 animal 可以是 Animal，Animal，或者其他任何 Dog 的父类的 Animal 实例。

桥接方法

​ 桥接方法（Bridge Method）是Java编译器在泛型类型擦除过程中自动生成的一种特殊方法，旨在解决泛型类型擦除后可能导致的多态性问题。具体来说，当一个类继承了泛型类或者实现了泛型接口，并且重写了其中的方法时，如果子类或实现类的方法签名中的类型参数不同于父类或接口中的类型参数，编译器就会自动插入一个桥接方法来确保类型兼容性和多态性的正确实现。
桥接方法的特点如下：

• 透明性：对于开发者来说，桥接方法是不可见的，它在源代码中不会显示，仅存在于编译后的字节码中。
• 自动生成：桥接方法由Java编译器自动生成，无需程序员手动编写。
• 方法签名：桥接方法的签名与原始方法相同，但其返回类型或参数类型是原泛型类型擦除后的类型（通常是Object或其父类），而实际执行逻辑则委托给擦除类型参数后的具体实现方法。

访问标志：桥接方法在字节码层面会被标记为 ACC_BRIDGE 和 ACC_SYNTHETIC，表示这是一个桥接方法和编译器生成的方法。

用途：主要目的是为了确保在泛型类型擦除后，能够正确地调用到子类中重写的泛型方法，维持多态行为。

演示案例

公共部分

public class Pig1 extends Animal {
    public void setValue(String value) {
        System.out.println("Pig1.setValue called");
        super.setValue(value);
    }
}

public class Pig2 extends Animal<String> {
    @Override
    public void setValue(String value) {
        System.out.println("Pig2.setValue called");
        super.setValue(value);
    }
}

public class Animal<T> {

    AtomicInteger updateCount = new AtomicInteger();

    private T value;
    @Override
    public String toString() {
        return String.format("value: %s updateCount: %d", value, updateCount.get());
    }

    public void setValue(T value) {
        System.out.println("Animal.setValue called");
        this.value = value;
        updateCount.incrementAndGet();
    }
}

wrong1

    public static void main(String[] args) {
        wrong1();
    }

    public static void wrong1() {
        Pig1 pig1 = new Pig1();
        Arrays.stream(pig1.getClass().getMethods())
                .filter(method -> method.getName().equals("setValue"))
                .forEach(method -> {
                    try {
                        System.out.println(method);
                        method.invoke(pig1, "test");
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                });
        System.out.println(pig1.toString());
    }

运行结果：

执行过程：

​ wrong1方法中，对于Pig1对象，通过反射获取所有公共方法（包括继承的方法）中名为setValue的方法。由于Pig1重写了父类Animal的setValue方法，但没有改变参数类型，所以这里会看到两个方法：一个是直接从Pig1类中声明的方法，另一个是从父类继承而来的方法（因为泛型擦除后，父类的setValue(T value)变为setValue(Object value)，与子类重写的方法签名相同）。这里Pig1重写并不是我们规范化的重写

输出解释：

​ 首先调用了子类Pig1的setValue(String value)，打印出"Pig1.setValue called"，然后由于继承关系和方法重写规则，继续调用了父类的Animal.setValue(Object value)，这一步实际上也是对Pig1中重写方法的调用，因此再次打印"Animal.setValue called"。最后，updateCount被增加了2次，输出为"value: test updateCount: 2"。

wrong2

    public static void main(String[] args) {
        wrong2();
    }
    public static void wrong2() {
        Pig1 pig1 = new Pig1();
        Arrays.stream(pig1.getClass().getDeclaredMethods())
                .filter(method -> method.getName().equals("setValue"))
                .forEach(method -> {
                    try {
                        System.out.println(method);
                        method.invoke(pig1, "test");
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                });
        System.out.println(pig1.toString());
    }

运行结果：

wrong2的结果及解释
执行过程：

​ 与wrong1不同的是，这里仅获取Pig1声明的自身方法（不包括继承的），因此只找到了一个setValue(String value)方法。
输出解释：

​ 仅调用了一次Pig1.setValue，内部虽然调用了super.setValue(value)，但因为是在同一个方法体内，updateCount只增加了一次，所以输出为"value: test updateCount: 1"。

wrong3

    public static void main(String[] args) {
        wrong3();
    }
    public static void wrong3() {
        Pig2 pig2 = new Pig2();
        Arrays.stream(pig2.getClass().getDeclaredMethods())
                .filter(method -> method.getName().equals("setValue"))
                .forEach(method -> {
                    try {
                        System.out.println(method);
                        method.invoke(pig2, "test");
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                });
        System.out.println(pig2.toString());
    }

运行结果：

执行过程：

​ 对于Pig2，它继承自具有泛型参数的Animal，且重写了setValue方法。在反射调用时，因为泛型擦除，父类会产生一个桥接方法setValue(Object)。wrong3试图调用所有声明的方法（包括桥接方法），所以setValue(String)和桥接方法setValue(Object)都被调用了。

输出解释：

​ 首先调用子类Pig2的setValue(String value)，打印"Pig2.setValue called"，然后因为泛型擦除和桥接方法，又调用了父类的Animal.setValue(Object)（这里也是调用的子类重写的版本），再次打印"Animal.setValue called"。最终updateCount被增加了2次，输出为"value: test updateCount: 2"。

right

    public static void main(String[] args) {
        right();
    }
    public static void right() {
        Pig2 pig2 = new Pig2();
        Arrays.stream(pig2.getClass().getDeclaredMethods())
                .filter(method -> method.getName().equals("setValue") && !method.isBridge())
                .findFirst().ifPresent(method -> {
            try {
                System.out.println(method);
                method.invoke(pig2, "test");
            } catch (Exception e) {
                e.printStackTrace();
            }
        });
        System.out.println(pig2.toString());
    }

运行结果：

执行过程：

​ 此方法正确地处理了泛型导致的桥接方法问题。它通过检查方法是否为桥接方法（!method.isBridge()），只调用了实际需要的setValue(String)方法，忽略了桥接方法。
输出解释：

​ 只调用了Pig2.setValue(String value)一次，内部调用super.setValue(value)也是针对同一个具体类型的方法，因此updateCount只增加了一次，输出为"value: test updateCount: 1"。

原理总结

类型擦除：Java泛型在编译后会被擦除，这意味着像Animal< String >在字节码层面等同于Animal< Object >，导致方法签名可能变得不明确。
桥接方法：为了保证泛型擦除后的多态性，编译器会为某些泛型方法生成桥接方法，这些方法通常指向具体的实现。
反射调用：直接通过反射调用可能遇到桥接方法，导致意外的行为，如多次调用或不期望的类型转换。正确处理泛型和桥接方法对于避免这些问题至关重要。

本次 Java中常见错误-泛型擦除及桥接方法问题及解决方案 文章到此结束，创作不易，望我佬们三连支持一下