4

在 Java 1.6.0_21 中，下面的第一个示例编译得很好，我认为这是因为参数类型边界是裸露的。也就是说，在下面的“Z extends Zen”界限中，Java 允许 Zen 作为原始非泛型类型的名称（相当于运行时“已擦除”类型）滑动。这可能是错误的和不好的，但它也可能是有用的，或者至少是在回家的公共汽车上的古怪美好时光：

public class CorefTest {

    public static interface Tao<Z extends Zen> {
    }

    public static interface Zen<T extends Tao> {
    }
}

在 Scala 2.8.0.final 中，下面通过 CleanOceanWithFish 编译得很好，显示了一些基本的类型参数连接。但是当我们发现 Zen 和 Tao 是相互依赖的泛型类型时，Scala 编译器会拒绝我的编织构造。请参阅注释中的编译器错误。

package heaven.piece
class Lucky {
    trait Water {}
    trait CleanWater extends Water {}
    trait Sea [W <: Water] {}
    trait Fish[S <: Sea[CleanWater]] {}

    trait CleanOceanWithFish[F <: Fish[CleanOceanWithFish[F]]] 
                   extends Sea[CleanWater]{}

// Above code compiles fine, but the type constructor pair below doesn't compile 

    trait Tao[Z <: Zen[Tao[Z]]]{};

    trait Zen[T <: Tao[Zen[T]]]{};
}
// error: type arguments [Lucky.this.Tao[Z]] do not conform to trait Zen's 
//     type parameter bounds [T <: Lucky.this.Tao[Lucky.this.Zen[T]]]

// error: type arguments [Lucky.this.Zen[T]] do not conform to trait Tao's 
//     type parameter bounds [Z <: Lucky.this.Zen[Lucky.this.Tao[Z]]]

那么，我怎样才能在道和禅之间正确地打结 Scala (2.8.0) 结呢？

这当然是一个人为的例子，但我真正想要的是使用 Scala 来扩展我以上述形式工作的一些真正的 Java 类型（到目前为止，通过“forSome”和“[_]”的存在类型对我没有帮助）。我认为在 Scala 中编译 Zen 和 Tao 可能会为 Java 扩展指明方向。如果您可以在答案中考虑 Java 扩展问题，那就更好了。谢谢你的帮助！

在 Nikita S. 和 Kris N. 以下非常有用的前两个答案之后发布的更新。

我凭经验学到了更多关于各种 Java+Scala 共指场景的知识。结果是，当我们想要 Java 和 Scala 中的可互操作的共同引用类型时，那么这个 Java 构造：

public static interface JavaFunTao<JFZ extends JavaFunZen<? extends JavaFunTao<JFZ>>> {
    public JFZ consider(JFZ someZen, JavaFunTao<JFZ> otherTao);
}
public static interface JavaFunZen<JFT extends JavaFunTao<? extends JavaFunZen<JFT>>> { 
    public JFT meditate(JFT someTao, JavaFunZen<JFT> otherZen);
}

提供比我在顶部的第一个 Java 示例更具体的类型（避免原始类型），然后可以在 Scala 中正确扩展，如下所示：

class HiFunTao[HFZ <: HiFunZen[  _ <: HiFunTao [HFZ]]] extends JavaFunTao[ HFZ] {
    override def consider(someZen: HFZ, otherTao: JavaFunTao[HFZ]) : HFZ = {
        println (this.toString() + " is considering " + someZen + " and " + otherTao);
        someZen
    }
}
class HiFunZen[HFT <: HiFunTao[ _ <:  HiFunZen [HFT]]] extends JavaFunZen[ HFT] {
    override def meditate(someTao: HFT, otherZen: JavaFunZen[HFT]) : HFT = {
        println (this.toString() + " is meditating on " + someTao + " and " + otherZen);
        someTao
    }
}

我验证了我们可以基于这些创建简单的具体类型，实例化它们，并调用它们的方法。Java 和 Scala 中的关键步骤是将有界通配符放置在类型参数树循环回当前声明类型的位置，即 java 中的“? extends”和 Scala 中的“_ <:”。

4

2 回答 2

3

由于 Zen 和 Tao 都不是协变的，因此您的 zen 和 tao 存在可替代性问题。这对我来说在 2.8.1 下编译得很好：

trait Tao[+Z <: Zen[Tao[Z]]]

trait Zen[+T <: Tao[Zen[T]]]

当然，如果您想冥想 Z 或 T，那么这对您也不起作用，至少与所述不完全一样，因为协变类型参数处于逆变位置的问题。你可以像这样解决这个问题：

trait Tao[+Z <: Zen[Tao[Z]]] {
  def meditate[M >: Z](m: M) = ()
}

trait Zen[+T <: Tao[Zen[T]]] {
  def meditate[M >: T](m: M) = ()
}

但这可能仍会对您的实现产生您可能不想要的限制。至少，这很令人困惑。:)

更新：

顺便说一句，这也避免了更新 NSkvortsov 答案中提到的问题。这编译得很好：

class Zazen extends Zen[Tao[Zazen]]
于 2011-04-07T15:14:38.723 回答
2

我想，这就是你需要的：

class MyClass {

  trait Tao[Z <: Zen[_]]{};
  trait Zen[T <: Tao[_]]{};

}

此代码段由 Scala 2.8.1 成功编译

更新

不幸的是，扩展CorefTest.Zen和CorefTest.Tao在 scala 中是不可能的。这就是为什么。

在java中实现接口的唯一方法是使用原始类型：

public class TaoImpl<Z extends CorefTest.Zen> implements CorefTest.Tao<Z> { }

public class ZenImpl<T extends CorefTest.Tao> implements CorefTest.Zen<T> { }

比一个可以实例化这样的类：

TaoImpl<ZenImpl> tao = new TaoImpl<ZenImpl>();
ZenImpl<TaoImpl> zen = new ZenImpl<TaoImpl>();

但是scala 不支持原始类型。所以TaoImpl，ZenImpl只是不能定义。有关详细讨论，请参阅此电子邮件主题和问题#2091和#1737

于 2011-04-07T11:40:07.003 回答