当前位置: 首页 > 知识库问答 >
问题:

为什么java需要强制转换将有界类型参数实例化为其上限类?

令狐烨烨
2023-03-14
<T extends Integer> void passVal (T t) {
    Integer number = 5;
    t = (T) number; // Without cast a compile error is issued
}

共有1个答案

张博涛
2023-03-14

T并不意味着Integer,它必须对Integer或从它扩展的任何类有效。假设StrangeInteger从Integer扩展而来,并用StrangeInteger替换T:

void passVal (StrangeInteger t) {
    Integer number = 5;
    t = (StrangeInteger) number;
}

它试图将一个整数变量分配给一个StrangeInteger变量,除非number首先是一个StrangeInteger或一个派生类,否则不能这样做。实际上,除非t是整数,否则代码应该在运行时抛出异常(概念上),但由于类型擦除,在这种情况下实际上不会抛出异常(请参见编辑2)。

情况类似于:

Object obj = "Hello"
String t = (String)obj; // this will not fail, but requires a cast

Object obj2 = getDBConnection();
String t2 = (String)obj2; // this will fail at runtime

Edit:Integer确实是final,所以T只能是Integer,但是编译器可能没有检查上限是否是final,毕竟上限是final没有什么意义,所以允许这种特殊情况会增加复杂性,但实际收益很小。

编辑2:TL;博士:你混淆了上下限,但类型擦除有警告。当您做任何值得使用泛型而不是仅仅使用基类型做的事情时,这种情况就会中断。

英语不是我的第一语言,所以我可能不太清楚。

我想您正在纠结于使用带有上限的泛型类型和只是将上限用作类型之间的区别。泛型(来自C++和其他语言)的思想是,如果将T替换为边界允许的任何类型T,代码必须是有效的,因此不能调用任何未在上限中定义的方法。

A是T的上界也意味着您可以始终将一个T对象赋给一个A变量。您不能安全地将A对象分配给T变量(除非A==T),只有当A是T的下界而不是上界时,您才能这样做。又见了解上下限?在Java泛型中。

Java使用类型擦除来实现泛型,有一些优点,但这导致了一些并不总是明显的限制。由于类型擦除,在这种情况下,强制转换本身不会失败,因此在类型检查之后,在类型擦除步骤中将T替换为上限,即(T)数替换为(整数)数。如果执行任何导致对子类进行强制转换的操作,例如,如果返回更改的t并将结果赋给子类的变量,则仍然会发生异常,因为编译器添加了隐式强制转换。

如果调用依赖于T的子类的方法,这也会失败,这是一种常见的模式,例如:

List<Person> persons = ...
Comparator<Person> nameComparator = (p1,p2) -> p1.getName().compareTo(p2.getName())
java.util.Collections.sort(persons,nameComparator);

下面的代码示例显示几种情况下的行为。我对所有内容都使用System.err,以避免输出中的顺序问题。

import java.util.function.Consumer;
import java.util.function.Function;

class A {
    @Override public String toString(){ return "A";}
    public String foo(){ return "foo";}
}

class B extends A {
    @Override public String toString(){ return "B";}
    public String bar(){ return "bar";}
}

class C extends B { }

public class Main {

    public static void main(String[] args) {
        Function<A,String> funA = a -> a.foo();
        Function<B,String> funB = b -> b.bar();
        Function<C,String> funC = c -> c.bar();
        Consumer<B> ignoreArgument = b -> {
            System.err.println("  Consumer called");
        };

        B b = new B();
        System.err.println("* voidTest *");
        voidTest(b);
        System.err.println("------------");
        System.err.println("* returnTest *"); 
        returnTest(b);
        System.err.println("returnTest without using result did not throw");
        System.err.println("------------");
        try {
            System.err.println("Returned " + returnTest(b).toString());
            System.err.println("returnTest: invoking method on result did not throw");
        }
        catch(Exception ex) {
            System.err.println("returnTest: invoking method on result threw");
            ex.printStackTrace();
        }
        System.err.println("------------");
        B b2 = null;
        try {
            b2 = returnTest(b);
            System.err.println("returnTest: assigning result to a B variable did not throw");
        }
        catch(Exception ex) {
            System.err.println("returnTest: assigning result to a B variable threw");
            ex.printStackTrace();
        }
        System.err.println("------------");
        System.err.println("* functionTest funA *");
        functionTest(b, funA);
        System.err.println("------------");
        System.err.println("* functionTest funB * ");
        functionTest(b, funB);
        System.err.println("------------");
        System.err.println("* consumerTest *");
        consumerTest(b, ignoreArgument);
        // The following won't work because C is not B or a superclass of B
        // Compiler error functionTest(T, Function<? super T,String>) is not applicable for the arguments (B, Function<C,String>)
        // functionTest(b, funC); 
    }

    private static <T extends A> void voidTest(T t){
        System.err.println("  Before: " + t.toString());
        t = (T)new A(); // warning Type safety: Unchecked cast from A to T
        System.err.println("  After: " + t.toString());
    }

    private static <T extends A> T returnTest(T t){
        System.err.println("  Before: " + t.toString());
        t = (T)new A();
        System.err.println("  After: " + t.toString());
        return t;
    }

    private static <T extends A> void functionTest(T t, Function<? super T,String> fun) {
        System.err.println("  fun Before: " + fun.apply(t));
        t = (T)new A();
        try {
            System.err.println("  fun After: " + fun.apply(t));
        }
        catch(Exception ex) {
            System.err.println("  fun After: threw");
            ex.printStackTrace();
        }
    }

    private static <T extends A> void consumerTest(T t, Consumer<? super T> c) {
        System.err.print("  Before: ");
        c.accept(t);
        t = (T)new A();
        try {
            System.err.println("  After: ");
            c.accept(t);
            System.err.println("    c.accept(t) After: worked");
        }
        catch(Exception ex) {
            System.err.println("    c.accept(t) After: threw");
            ex.printStackTrace();
        }
    }
}

OpenJDK 11下的输出是:

* voidTest *
  Before: B
  After: A
------------
* returnTest *
  Before: B
  After: A
returnTest without using result did not throw
------------
  Before: B
  After: A
returnTest: invoking method on result threw
java.lang.ClassCastException: class A cannot be cast to class B (A and B are in unnamed module of loader 'app')
    at Main.main(Main.java:35)
------------
  Before: B
  After: A
returnTest: assigning result to a B variable threw
java.lang.ClassCastException: class A cannot be cast to class B (A and B are in unnamed module of loader 'app')
    at Main.main(Main.java:45)
------------
* functionTest funA *
  fun Before: foo
  fun After: foo
------------
* functionTest funB * 
  fun Before: bar
  fun After: threw
java.lang.ClassCastException: class A cannot be cast to class B (A and B are in unnamed module of loader 'app')
    at Main.functionTest(Main.java:83)
    at Main.main(Main.java:57)
------------
* consumerTest *
  Before:   Consumer called
  After: 
    c.accept(t) After: threw
java.lang.ClassCastException: class A cannot be cast to class B (A and B are in unnamed module of loader 'app')
    at Main.consumerTest(Main.java:97)
    at Main.main(Main.java:60)
 类似资料:
  • 问题内容: 我有以下两节课: 和: 当我运行测试时,一切都是笨拙的。如果我将类型参数化更改为: 编译器抱怨,报告: 错误:类型不兼容的整数不能转换为T number = new Integer(11); 其中T是类型变量T扩展了在方法getSomeValue(boolean)中声明的Object 它同样对Double有所抱怨。为什么? 编辑:我犯了一个错误。这实际上是有效的代码。 现在我明白了@S

  • 我为JavaFX TableColumn创建了一个扩展函数,使得在没有重复样板的情况下实现cellFactory更加简洁。扩展函数定义如下: 为了格式化TableCell,我只需要定义TableCell中应该发生什么。当当前单元格有非空项可用时更新项。例如,要格式化LocalDateTime,我现在可以编写: 然后我继续定义另一个扩展来执行此操作,因此我可以编写: 此函数使用第一个函数,如下所示:

  • 问题内容: 我认为你不能将Java泛型类型参数绑定到下限(即使用关键字)。我正在阅读Angelika Langer泛型常见问题解答对此主题的看法。他们说,这基本上可以归结为无用的下限(“没有任何意义”)。 我不相信。我可以想象它们的用途是帮助你更灵活地调用产生类型化结果的库方法的调用者。想象一下一个方法,该方法创建了用户指定大小的数组列表,并用空字符串填充了该列表。一个简单的声明是 但这不必要地限

  • 我正在编写一个泛型方法,它处理泛型接口的请求类型,并返回一个泛型响应。 前面提到的是我的接口、方法和Pojos。 现在,我正在编写一个请求处理程序,其中有一个方法 上述代码的问题是,在调用私有方法 buildResponse 时,我必须强制转换我的响应,但我只是想知道在定义 T 时,我已经指定了 T 扩展响应,而我的私有方法返回实现响应的 MyResponse,那么为什么需要强制转换呢?

  • 我现在正在学习遗传和多态性,除此之外,我也理解它。为什么我需要投三个。setY()不应该已经可以访问它了,因为我正在创建一个从G类继承的H对象。 第8行是语法错误。

  • 问题内容: 我正在制作一个类,以便模拟C ++中的函数指针的功能。最初,我只用s 做所有事情,但后来我有了一个想法- 为什么不使其真正通用? 问题出在这个构造函数上,该构造函数试图使用签名调用另一个构造函数: 我以为这会很好,但是我收到了以下编译器错误: 因此,我很困惑,我这样做: 现在可以编译,但是我收到以下警告: 我想问题是我不明白这意味着什么。我认为,由于从参数推断出的类型,因此有 必要 调