Scala：重写通用 Java 方法 II

Question

在 Scala 中，我需要重写以下给定的 Java 类和方法：

public abstract class AbstractJava<T> {
    protected abstract T test(Class<? extends T> clazz);
}

public class ConcreteJava extends AbstractJava<Object> {
    @Override
    protected Object test(Class<?> clazz) {
        return null;
    }
}

// Scala
class ConcreteScala extends ConcreteJava {
    protected override def test(clazz: Class[_ <: AnyRef]): AnyRef =
        super.test(clazz)
}

我收到编译错误：

error: ambiguous reference to overloaded definition,

both method test in class ConcreteJava of type 
(clazz: java.lang.Class[_])java.lang.Object

and method test in class AbstractJava of type 
(clazz: java.lang.Class[_ <: java.lang.Object])java.lang.Object

match argument types (Class[_$1]) and expected result type AnyRef

super.test(clazz)

我不希望 Scala 编译器引用 abstract 方法>超级调用。另外，我希望它首先引用direct超类。

如何让 Scala 类编译？

谢谢！

编辑：

当离开super.test(clazz)调用时，会出现错误消息：

error: name clash between defined and inherited member:

method test:(clazz: Class[_ <: AnyRef])AnyRef and
method test:(clazz: java.lang.Class[_])java.lang.Object in class ConcreteJava

have same type after erasure: (clazz: java.lang.Class)java.lang.Object

protected override def test(clazz: Class[_ <: AnyRef]): AnyRef = null

嗯，当然这些是相同类型（或变体）...！ - 所以 Scala/Java 继承有问题......

感谢 michid，有一个初步的解决方案：

class ConcreteScala3 {
  this: ConcreteJava =>
  protected override def test(clazz: Class[_ <: AnyRef]): AnyRef = {
    this.foo() // method of ConcreteJava
    null
  }
}

尽管我们无法从这里进行 super 调用。

仍然非常欢迎回复。

Answer 1

使用原始类型覆盖 Java 方法时存在一些限制。请参阅相应的 Scala 票证。具体来说，Martin Odersky 的 comment: "[...] 在这些情况下唯一能做的就是实现一个子类实现该方法的 Java [...]”

但是，我在 博客文章 之前提到，对于某些情况似乎有解决方案。技巧是使用 Java 端原始类型的存在类型显式声明重写 Scala 类的 self 类型。

通过这种技术，我得到了以下工作：

public abstract class AbstractJava<T> {
    protected abstract T test(Class<T> clazz);
}

public class ConcreteJava extends AbstractJava<Object> {
    @Override
    protected Object test(Class<Object> clazz) {
        return null;
    }
}

class ConcreteScala extends ConcreteJava {
    this: AbstractJava[AnyRef] =>

    protected override def test(clazz: Class[AnyRef]): AnyRef = {
        super.test(clazz)
    }
}

Answer 2

关于同一问题的问题在2017年再次提出。

我认为这肯定是一个错误，我创建了一个问题< a href="https://issues.scala-lang.org/browse/SI-10155" rel="nofollow noreferrer">SI-10155。

您可以应用以下解决方法。

创建额外的 Java 类，通过重写 test() 将其“重命名”为 renameTest()，并且还提供调用超级 ConcreteJava.test() 的能力> 通过 concreteTest() 方法。

public abstract class RenameJava extends ConcreteJava {
    public Object concreteTest(Class<?> c) {
        return super.test(c);
    }

    abstract protected Object renameTest(Class<?> c);

    @Override
    protected Object test(Class<?> c) {
        return renameTest(c);
    }
}

现在，在 ConcreteScala 类中，您可以重写 renameTest() 并且仍然可以使用 调用超级 ConcreteJava.test() 方法具体测试（）方法。

class ConcreteScala extends RenameJava {
  override protected def renameTest(c: Class[_]) = {
    // custom logic
    concreteTest(c)
  }
}