java - 从 scala 代码使用 java 中定义的递归泛型类型

Question

我在 java 代码中有以下定义:

一个抽象端口定义(由具体端口类类型化):

package test;

public class Port<
     PortOptions extends Port.Options, 
     ConcretePort extends Port<PortOptions, ConcretePort>> {

    public interface Options {
    }

}

端口服务定义(可以通过一些回调机制对端口做一些事情)

package test;

import java.util.Set;

public class PortService {
    public interface Callback<T> {
        void processData(T data);
    }

    public void methodWithCallback(Callback<Set<Port>> callback) {

    }
}

我想从 scala 注册一个回调到端口服务。我试过的是这样的:

package test

import test.PortService.Callback
import java.util

class PortServiceCaller {

    def callingMethod() {
        val portService: PortService = new PortService

        portService.methodWithCallback(new Callback[java.util.Set[Port[_, _]]] {
            def processData(data: util.Set[Port[_, _]]) {

            }
        })
    }
}

它悲惨地失败了:

error: type mismatch;
found   : java.lang.Object with test.PortService.Callback[java.util.Set[test.Port[_, _]]]
required: test.PortService.Callback[java.util.Set[test.Port[_ <: test.Port.Options, _ <: test.Port[?0,?1]]]]
portService.methodWithCallback(new Callback[java.util.Set[Port[_, _]]] {

问题是:如何编写scala代码才能让我正确调用java服务？

我查看了 Scala 打字系统，但似乎无法弄明白。

稍后编辑:

解决方案其实很简单:

将回调方法声明为:

    public void methodWithCallback(Callback<Set<Port<?, ?>>> callback) {

    }

然后像这样从 scala 中调用它:

    portService.methodWithCallback(new Callback[java.util.Set[Port[_, _]]] {
        def processData(data: java.util.Set[Port[_, _]]) {
        }
    })

考虑到两种语言的类型系统，这也是有意义的。

Answer 1

你在 Java 中所做的事情是危险的，你的代码编译成功只是因为 Java 编译器是惰性的，不会检查它。当你写的时候:

   public void methodWithCallback(Callback<Set<Port>> callback) {

    }

您基本上丢弃了有关端口的所有类型信息:

Port<PortOptions extends Port.Options, ConcretePort extends Port<PortOptions, ConcretePort>>

整个信息将不可用，Java 编译器允许您省略类型参数。在 Scala 中，这是不可能的，不仅你必须正确表达类型参数，还必须正确表达类型约束。这里的第一个问题是为什么您在编写 Port 时甚至不说那里有一些未知类型。

public void methodWithCallback(Callback<Set<Port<?,?>>> callback) {

}

将是编写它的正确方法。

如果现在你想表达多个未知类型之间的边界关系，你不能使用适合简单边界的紧凑型_ for existential types，而必须使用forSome

  class Port[A,B<:A]

  def myMethod(a:Port[A,B]forSome {type B; type B<:A})

但是，正如我倾向于说的那样，最终使用这些模式会使您的设计变得薄弱，而您可能有一种更简洁、更优雅的方式来解决您的问题。如果您随后需要丢弃有关类型安全的信息，那么使用泛型有什么意义？