实例化泛型类型类的子类

Question

I have simple generic class as shown below:

public class Test<T extends Number> {

    public void doSomething() {
        Test t = new Test();
        t.getNumber();

    }

    public T getNumber() {
        T d = new Double("1.5"); // I get an compiler error here!
        return d;
    }
}

The getNumber method returns T (which extends Number) and in its implementation it instantiates a Double. The compiler is throwing up an error on the line:

    T d = new Double("1.5"); // I get an compiler error here!

The error is:

Incompatible types:
[ERROR] found   : java.lang.Double
[ERROR] required: T

Since T extends Number, I would have expected this to work. Am I missing something?

Answer 1

T extends Number, but that does not mean that it extends Double. Double is only one of the known subclasses of Number.

Answer 2

在左侧使用通用参数，在右侧使用特定的实现是不正确的。

Answer 3

1. You should get a compiler warning when you instantiate test.

2. Imagine that you instantiate Test<Integer> . Then the line in the getNumber method becomes:

   Integer d = new Double("1.5");

Obviously, it should throw a compiler error.

I think that you should not use a generic type argument - replace your class with:

public class Test {
    public Number getNumber() {
        Number d = Double.valueOf("1.5"); // No compiler error
        return d;
    }
}

Another solution would be to express the condition that you can use any superclass of Double as a type argument, ie:

public class Test<T super Double> {
    public T getNumber() {
        T d = Double.valueOf("1.5"); // No compiler error
        return d;
    }
}

A few general tips:

• Do not box primitive types without a good reason.
• Do not use new to instantiate boxed primitive types, use the static factory methods in the boxing classes instead.
• Do not use generic types without a good reason. And when you go to the hassle of defining a generic type, do not instantiate it without a type parameter.

Answer 4

T d = (T)new Double("1.5");

您必须将强制类型转换为T。即使它解决了您的问题，我也对您的工作感到怀疑。

Answer 5

The generic type definition class Test<T extends Number> means that whoever chooses to create an object of your Test class can choose which type parameter to use. The user chooses, not you as the class implementor.

This means you can't be sure which type it will be, and thus your getNumber() method can only safely

• return an object which somehow came in as a T object
• return null
• return an object which some other method returning T gave back.
  • return an object created from a Class<T> (or Class<? extends T> )
  • return an object from a Collection<T> (or Collection<? extends T> )
  • something similar