Class 自类型注释妨碍内部类的实例化。为什么？

给定

外部

类及其

内部

类的抽象定义，我想实例化

Outer1

trait中定义的具体

Inner1

类

abstract class Outer {
  type Inner_Tp <: Inner;
  abstract class Inner {
    self: Inner_Tp =>
  }
}

trait Outer1 {
  self: Outer =>
  protected class Inner1 extends Inner {
    self: Inner_Tp =>
  }
  def Inner1() = new Inner1()
}

抽象类外部{
型内螺纹
}
}
性状外1{
self:Outer=>
受保护的类Inner1扩展了内部{
self:internal_Tp=>
}
def Inner1（）=新Inner1（）
}

Scala编译器提前终止编译，并给出以下错误消息：“错误：类Inner1无法实例化，因为它不符合自身类型Outer1.this.Inner1和Outer1.this.Inner\Tp”为什么？

---

毕竟，

Inner1

类是在作为其

Outer1

特征的抽象上下文中定义的。我想推迟定义

type Inner\u Tp

，直到特性被混合到某个具体类中。

对于

Inner1

，self类型表示它将始终与抽象类型

Inner\u Tp

一起实例化。这是一个在实例化点没有实现的承诺：类型仅为

Inner1

，而不是

Inner1 with Inner\u Tp

如果需要延迟定义

内部\u Tp

，则还需要延迟创建将其作为自类型的任何实例。这是绝对必要的，因为您无法生成您还不知道的类型的值。因此，最好让方法保持抽象。您还可以优化抽象类型：

trait Outer1 extends Outer {
   type Inner_Tp <: Inner1
   protected class Inner1 extends Inner

   def Inner1(): Inner_Tp
}

trait Outer1扩展了外部{
键入internal\u-Tp，因为
self:internal\u-Tp
告诉我们，除非
internal
的子类型也是
internal\u-Tp
的子类型，否则不允许实例化它

在
Inner1
中重写
self=>internal\u Tp
只是重申约束，它并不满足约束。为了得到类似的想法，当您有一个抽象类的后代时，如果它没有实现抽象方法，您必须再次编写它是抽象的。并且您不能实例化。同样，您在这里重申了
Inner_Tp
是必需的，您没有使
内部\u Tp
可用

只要
internal\u Tp
是一种抽象类型，你就无法将其混合在一起，因此你就无法编写
新的Inner1
。你可能应该引入一种创建Inners的抽象方法。
Thx伙计们，我已经接受了尤利安·德拉戈斯的回答，尽管你对它的解释同样好。+1作为你的回答好吧，尤连的名声显然不能反映他对斯卡拉的掌握程度，所以他必须得到很多分数：）