使用一组固定类型之一参数化一个类

Question

假设我有一个泛型类Foo，它可以容纳T 类型的对象。此外，假设我仅希望能够使用属于两种类型之一的对象来实例化该类。最后，假设这两种类型的最低公共上界是一个比我想要允许的这两种类型有更多子类的类型，所以我不能简单地为类型参数指定一个上限（如@ 987654324@)，因为这样我就可以用我期望的两种类型之外的其他类型来实例化该类。

为了说明，假设我希望Foo 仅保存String 或Integer。最低的公共上限是Object，因此指定一个上限并不能解决问题。

当然，我可以做一些类似的事情

class Foo<T> {

    private T obj;

    public Foo(T obj) throws IllegalArgumentException {
        if (!(obj instanceof String || obj instanceof Integer)) {
            throw new IllegalArgumentException("...");
        }
        this.obj = obj;
    }
}

但是，在这种情况下，我仍然可以使用 any 对象调用构造函数；如果我尝试使用既不是 String 也不是 Integer 的东西来实例化它，我将在 runtime 时遇到异常。

我想做得更好。我希望编译器静态推断（即在编译时）我只能使用String 或Integer 的对象来实例化这个类。

我在想一些类似的东西可能会奏效：

class Foo<T> {

    private T obj;

    public Foo(String s) {
        this((T) s);
    }

    public Foo(Integer i) {
        this((T) i);
    }

    private Foo(T obj) {
        this.obj = obj;
    }
}

这行得通，但它看起来非常非常奇怪。编译器警告（可以理解）未经检查的强制转换。当然我可以压制这些警告，但我觉得这不是要走的路。此外，看起来编译器实际上无法推断类型T。我惊讶地发现，使用 Foo 类的后一个定义，我可以这样做，例如：

Foo<Character> foo = new Foo<>("hello");

当然，这里的类型参数应该是String，而不是Character。但是编译器让我摆脱了上述任务。

1. 有没有办法实现我想要的，如果有，如何实现？
2. 附带问题：为什么编译器允许我在没有 警告 的情况下对上述 Foo<Character> 类型的对象进行赋值（当使用类 @987654341 的后一个定义时） @)? :)

Answer 1

尝试使用static工厂方法来防止编译器警告。

class Foo<T> {

    private T obj;

    public static Foo<String> of(String s) {
        return new Foo<>(s);
    }

    public static Foo<Integer> of(Integer i) {
        return new Foo<>(i);
    }

    private Foo(T obj) {
        this.obj = obj;
    }
}

现在您使用以下方法创建实例：

Foo<String> foos = Foo.of("hello");

Foo<Integer> fooi = Foo.of(42);

Foo<Character> fooc = Foo.of('a'); // Compile error

但是以下内容仍然有效，因为您可以声明任何类型 T 的 Foo，但不能实例化它：

Foo<Character> fooc2;

Foo<Character> fooc3 = null;

Foo<Object> fooob1;

Foo<Object> fooob2 = null;

Answer 2

1. 一个字：界面。您希望您的 Z 包装 A 或 B。创建一个实现 A 和 B 的最小公分母的接口。让您的 A 和 B 实现该接口。 AFAIK，没有其他可靠的方法可以做到这一点。您已经对构造函数等进行的操作是唯一的另一种可能性，但它伴随着您已经注意到的警告（必须使用未经检查的强制转换、静态工厂包装器或其他代码气味）。

_{注意：如果不能直接修改A和/或B，请事先为它们创建包装类WA和WB。}

示例：

interface Wrapper {
    /* either a marker interface, or a real one - define common methods here */
}

class WInt implements Wrapper {
    private int value;
    public WInt( int value ) { this.value = value; }
}

class WString implements Wrapper {
    private String value;
    public WString( String value ) { this.value = value; }
}

class Foo<T> {   
    private Wrapper w;   
    public Foo(Wrapper w) { this.w = w; }
}

1. 因为你打电话给你的private Foo(T obj) 由于钻石类型推断。因此，它等于调用Foo<Character> foo = new Foo<Character>("hello");

Answer 3

1. 长话短说：您试图在 java 泛型中创建两个类的联合，这是不可能的，但有一些解决方法。 See this post

2. 编译器在 T 参数中使用 Character 类。然后使用 String 构造函数，其中 String 被强制转换为 T（在本例中为字符）。 尝试将私有字段 obj 用作 Character 很可能会导致错误，因为保存的值是最终类 String 的实例。

Answer 4

泛型在这里不适合。

当 any 类可以用作类型时，使用

泛型。如果您仅允许Integer 和String，则不应使用泛型。改为创建两个类FooInteger 和FooString。

无论如何，实现应该是完全不同的。因为Integers 和Strings 是非常不同的东西，你可能会以不同的方式处理它们。 “但我正在以同样的方式处理它们！”你说。那么Foo<Double> 或Foo<Bar> 有什么问题。如果您可以使用相同的实现处理Integer 和String，那么您可能也可以使用相同的方式处理Bar 和Double 以及其他任何东西。

关于你的第二个问题，编译器会看到你想创建一个Foo<Character>，所以它会尝试找到一个合适的重载。并且它找到了要调用的 Foo(T) 重载，因此就编译器而言，该语句非常好。