隐藏“本地” Java中的类型参数

Question

假设我使用带有泛型类型参数的接口，

interface Foo<T> {
  T getOne();
  void useOne(T t);
}

目的是类型 T 是抽象的：它对 Foo 的实现强制执行类型约束，但客户端代码并不关心 T 到底是什么。

这在通用方法的上下文中没有问题：

public <T> void doStuff(Foo<T> foo) {
  T t = foo.getOne();
  /* do stuff */
  foo.useOne(t);
}

但是假设我想分解 doStuff 的工作，在类 Bar 中保存一些状态。 在这种情况下，我似乎需要将 Foo 的类型参数添加到 Bar 中。

public class Bar<T> {
  private Foo<T> foo;
  private T t;

  /* ... */

  public void startStuff() {
    t = foo.getOne();
  }

  public void finishStuff() {
    foo.useOne(t);
  }
}

这有点奇怪，因为类型参数 T 没有出现在 Bar 的公共接口中（即，它不包含在任何方法参数或返回类型中）。 有没有办法“量化T”？ 即我是否可以将参数T设置为隐藏在Bar的界面中，如下所示？

public class Bar {
  <T> { // foo and t have to use the same T
    private Foo<T> foo;
    private T t;
  } // T is out of scope
  ... 
}

Answer 1

为了发挥作用，您有时需要设置 foo 字段。 那时您应该知道（或能够捕获）T。 我建议在构造函数中执行此操作，然后 Bar 拥有通用参数就有意义了。 您甚至可以使用接口，这样客户端代码就不必查看类型。 不过，我假设您不会采纳我的建议，并且确实想要一个 setFoo。 所以只需在可切换实现中添加一点即可：

/* pp */ class final BarImpl<T> {
    private final Foo<T> foo;
    private T t;

    BarImpl(Foo<T> foo) {
        this.foo = foo;
    }

    public void startStuff() {
        t = foo.getOne();
    }

    public void finishStuff() {
        foo.useOne(t);
    }
}

public final class Bar {
    private BarImpl<?> impl;

    /* ... */

    // Need to capture this wildcard, because constructors suck (pre-JDK7?).
    public void setFoo(Foo<?> foo) {
        setFooImpl(foo);
    }
    private <T> void setFooImpl(Foo<T> foo) {
        impl = new BarImpl<T>(foo);
    }

    public void startStuff() {
        impl.startStuff();
    }

    public void finishStuff() {
        impl.finishStuff();
    }
}

Answer 2

您的问题类似于 "capture helper" 解决的问题， 但我不确定它是否可以应用于使用两种单独方法的第二个示例。 您的第一个 doStuff 方法绝对可以更好地编写为 public void doStuff(Foo foo)，因为无论 Foo 类型如何，它都可以工作范围。 那么，“捕获助手”模式就会很有用。

---

更新：经过一番修改，扩展了 Goetz 捕获助手的想法，我想出了这个。 里面看起来有点乱； 从外面看，你不会怀疑任何事情。

public class Bar {
  private final Helper<?> helper;
  public Bar(Foo<?> foo) {
    this.helper = Helper.create(foo);
  }
  public void startStuff() {
    helper.startStuff();
  }
  public void finishStuff() {
    helper.finishStuff();
  }
  private static class Helper<T> {
    private final Foo<T> foo;
    private T t;
    private Helper(Foo<T> foo) {
      this.foo = foo;
    }
    static <T> Helper<T> create(Foo<T> foo) {
      return new Helper<T>(foo);
    }
    void startStuff() {
      t = foo.getOne();
    }
    void finishStuff() {
      foo.useOne(t);
    }
  }
}

Answer 3

为什么不采用三层层次结构：

abstract class Foo

abstract class FooImplBase<T> extends Foo

class Bar extends FooImplBase<String>

客户端只知道 Foo，其中不包含任何通用方法。 在 FooImplBase 中引入您需要的任何泛型方法，然后从中派生具体类。

因此，在您的示例中， startStuff() 和 endStuff() 在 Foo 中是抽象的，并在 FooImplBase 中实现>。 这听起来对你的实际情况有用吗？ 我同意这有点麻烦。

Answer 4

您正在定义 Bar 类。 有两件事是正确的...

1) Bar 中不涉及参数类型。 也就是说， foo 和 t 成员具有单一类型，例如 U，该类型对于定义来说是固定的。 如果您传递了一个 Foo 并希望分配给 foo，那么它必须是 Foo。 如果这一切都是真的，那么是的，它不是公共接口的一部分 - 一切都有特定的类型。 然后，我不确定“量化”是什么意思，因为没有自由类型变量。 如果您的意思是普遍量化，那么您如何协调 Bar 没有参数类型这一事实，因此必须为其每个成员指定一个具体类型？

2）Bar中涉及到参数类型。 它在公共接口中可能并不明显，但也许您传入了 Foo，因此您希望使用多个类型来实例化 Bar 类。 然后，如前所述，这是在公共接口中，您需要使用泛型在 T 中使 Bar 参数化。 这为您提供了某种形式的定义的通用量化，“对于所有类型 T，此定义都是正确的”。

Answer 5

必须在某个地方决定 Bar 类中的“T”使用什么类型。 因此，要么必须在 Bar 的定义中选择它（在类定义中用 Foo 替换 Foo），要么将其留给 Bar 类的客户端：在这种情况下，Bar 必须是通用的。

如果您希望有一个不依赖于 T 的 Bar 接口并且能够为 T 选择不同类型，则应该使用非泛型接口或抽象基类，如下所示：

interface Bar {
  void startStuff();
  // ...
}

class BarImplement<T> {
  private Foo<T> foo;
  // ...
}

Answer 6

如果你真的想引起一些愤怒，你可以将 Bar 类放在 Foo 接口中，并以这种方式吸掉 T。 有关接口内类的更多信息，请参阅本文 。 也许这是唯一有意义的情况？

interface Foo<T> {
  T getOne();
  void useOne(T t);

  public class Bar<T> {
    private Foo<T> foo;
    private T t;
    public void startStuff() {
      t = foo.getOne();
    }
    public void finishStuff() {
      foo.useOne(t);
    }
  }
}

Answer 7

对于 Bar 而言，这种情况下的参数 T 变得毫无用处，因为它将在编译时被擦除为 Object。 所以你也可以“省去麻烦”，尽早进行擦除：

public class Bar {

    private Foo<Object> foo;
    private Object t;

  ... 
}