Java 创建泛型类（具有通配符类型）和多个构造函数

我是Scala（2.8）的新手，下面是我在Scala中努力表达的东西：

我需要定义一个类，该类（由于与Java库的互操作性）实现了可比性；它的泛型类型必须与自身或超类相当

我还需要一个no-args构造函数以及另一个使用泛型参数的构造函数

我编写了一个简单的Java版本：

public class MyComparable<T extends Comparable<? super T>>{
    public MyComparable() {}

    public MyComparable(T a){
        System.out.println(a);
    }
}

---

public class MyComparable不完全确定您想做什么，但您可以这样做：

import java.lang.Comparable

class MyComparable[T <: Comparable[_>:Tb],Tb]()(implicit ev: T=:=Tb) {
  def this(a: T)(implicit ev: T=:=Tb) = {
    this()
    println(a)
  }
}

import java.lang.com
类MyComparable[T:Tb]，Tb]（）（隐式ev:T=：=Tb）{
定义此（a:T）（隐式ev:T=：=Tb）={
这（）
println（a）
}
}
您将问题复杂化了——尽管如果Java有声明站点差异会更好，这将使所有这些都变得毫无意义。无论如何，下面是等效代码：

class MyComparable[T <: Comparable[T2], T2 >: T]() {
    def this(a: T) = {
        this()
        println(a)
    }
}

这仍然与我发布的Java代码不同，但它似乎比其他解决方案更接近、更清晰：

import java.lang.Comparable
class MyComparable[T <: Comparable[T]]() {
    def this(a: Comparable[_ >: T]) = {
        this()
        println(a)
    }
}

import java.lang.com
类MyComparable[T:T]）={
这（）
println（a）
}
}

以下是我在遇到这个问题时读到的一些杂项链接，它们可能会帮助其他人解决类似的问题：








您最初的问题是什么？
类MyComparable[T:T]
被拒绝了？您的Scala代码在概念上与上面显示的示例Java代码没有太大关系。我最初的问题涉及两个类似的泛型类，带有访问器/变异器，是泛型参数的2倍。。。总的来说，这个问题要复杂得多，我可以把它粘贴到其他地方，但我已经把我的问题减少到了这几行，我不认为使用我的原始代码会给这个问题增加任何东西。我不知道你说的“拒绝”是什么意思，但显然你不能这样写签名，否则你会得到一个循环引用。我不明白你为什么说Scala代码在概念上与Java代码不同。。。你想详细说明区别吗？（由于5分钟的限制，添加而不是编辑）@soc我的意思是：两者都有一个泛型参数，必须与其相同的类型或超类型相比较，都有一个空构造函数，都有一个带有泛型参数T的构造函数，我实际上留下了一个System.out.println（a）在Scala代码中缺少的Java代码中，这是唯一的区别，现在我已经修复了它，谢谢！我仍然不太习惯Scala的构造函数和多参数列表，所以我以前没有想过将隐式参数复制到另一个构造函数上（你知道，
implicit
欺骗了我，使我认为不需要它）不过：Java等价物更方便：我可以像这样实例化Scala MyComparable:
新建MyComparable[String，String]（）
新建MyComparable[String，String]（“dummy”）
而Java MyComparable可以这样使用：
新建MyComparable（）
新建MyComparable（“dummy”）

new MyComparable[String]（）

new MyComparable[String]（“dummy”）

因此，现在我将对答案进行投票，并等待是否有更好的解决方案（这是我在这里提出的第一个问题，因此，说明这一点可能是多余的）编辑：显然，在我拥有15个声誉之前，我无法投票：/I我接受了你的答案，原因如下：-我不喜欢接受我自己的答案-你的答案最接近我的原始方法-我真的需要+2代表为我的答案添加额外链接（呃：我讨厌这个网站）谢谢，你的第一个建议非常简单，尽管它迫使我们明确指定T2类型，我们的T是其子类型。第二个建议很有意思，但我尝试了我的情况，确实没有帮助。。。我仔细考虑了一下，我认为在这里使用反变异是没有帮助的：问题在于传递给构造函数的类型；只有当从类中获取该类型，或者将对象重新分配给其他子类/超类时，使用逆变参数可能才有帮助。实际上，在发布这个问题之前，我甚至不知道scala中协变和逆变的含义，但由于我有使用普通java不变量的负担，我的选择已经很有限了。您的第三个示例非常简洁，并且（连同代码片段#2）促使我了解了方差在scala中是如何工作的，但在这种情况下它仍然不可用：我的类必须能够接受无法实现Cp scala特性的现有java类型（再想一想，我可以将所有需要的类划分为子类，并为每个类混合这个特性，但这种方式看起来很脏）非常好！我也会选择这个。

import scala.annotation.unchecked.uncheckedVariance
class MyComparable[-T <: Comparable[T @uncheckedVariance]]() {
    def this(a: T) = {
        this()
        println(a)
    }
}

scala> trait Cp[-T] {
     |   def compareTo(other: T): Int
     | }
defined trait Cp

scala> class MyComparable[-T <: Cp[T]] {
     | }
defined class MyComparable

import java.lang.Comparable
class MyComparable[T <: Comparable[T]]() {
    def this(a: Comparable[_ >: T]) = {
        this()
        println(a)
    }
}