让我们从周期依赖开始。

trait A {
  selfA: B =>
  def fa: Int }

trait B {
  selfB: A =>
  def fb: String }

然而，这个解决方案的模块化并不像它看起来那么好，因为你可以像这样重写自我类型:

trait A1 extends A {
  selfA1: B =>
  override def fb = "B's String" }
trait B1 extends B {
  selfB1: A =>
  override def fa = "A's String" }
val myObj = new A1 with B1

但是，如果重写了self类型的成员，就失去了对原始成员的访问权，仍然可以通过super using继承访问原始成员。因此，通过使用继承真正获得的是:

trait AB {
  def fa: String
  def fb: String }
trait A1 extends AB
{ override def fa = "A's String" }        
trait B1 extends AB
{ override def fb = "B's String" }    
val myObj = new A1 with B1

现在我不能说我已经理解了饼模式的所有微妙之处，但是我突然意识到，加强模块化的主要方法是通过组合而不是继承或自我类型。

继承版本更短，但我更喜欢继承而不是自我类型的主要原因是，我发现对自我类型进行正确的初始化顺序要棘手得多。然而，有些事情你可以用自我类型做，而不能用继承做。自我类型可以使用类型，而继承需要一个trait或类，如下所示:

trait Outer
{ type T1 }     
trait S1
{ selfS1: Outer#T1 => } //Not possible with inheritance.

你甚至可以这样做:

trait TypeBuster
{ this: Int with String => }

尽管您永远无法实例化它。我没有看到任何绝对的理由不能够从一个类型继承，但我肯定认为它将有用的路径构造函数类和特征，因为我们有类型构造函数特征/类。是不幸的

trait InnerA extends Outer#Inner //Doesn't compile

我们有这个:

trait Outer
{ trait Inner }
trait OuterA extends Outer
{ trait InnerA extends Inner }
trait OuterB extends Outer
{ trait InnerB extends Inner }
trait OuterFinal extends OuterA with OuterB
{ val myV = new InnerA with InnerB }

或:

  trait Outer
  { trait Inner }     
  trait InnerA
  {this: Outer#Inner =>}
  trait InnerB
  {this: Outer#Inner =>}
  trait OuterFinal extends Outer
  { val myVal = new InnerA with InnerB with Inner }

我们应该更多地理解的一点是，特征可以扩展阶级。感谢David Maclver指出这一点。下面是我自己代码中的一个例子:

class ScnBase extends Frame
abstract class ScnVista[GT <: GeomBase[_ <: TypesD]](geomRI: GT) extends ScnBase with DescripHolder[GT] )
{ val geomR = geomRI }    
trait EditScn[GT <: GeomBase[_ <: ScenTypes]] extends ScnVista[GT]
trait ScnVistaCyl[GT <: GeomBase[_ <: ScenTypes]] extends ScnVista[GT]

ScnBase继承自Swing Frame类，因此它可以用作self类型，然后在最后(实例化时)混合使用。然而，val geomR在被继承trait使用之前需要初始化。所以我们需要一个类来强制先行初始化geomR。ScnVista类可以被多个正交特征继承，这些特征本身也可以被继承。使用多个类型参数(泛型)提供了另一种模块化形式。

Martin Odersky最初的Scala论文《可伸缩组件抽象》中的2.3节“自类型注释”实际上很好地解释了自类型在mixin组合之外的用途:提供了一种将类与抽象类型关联起来的替代方法。

文中给出的例子如下所示，它似乎没有一个优雅的子类对应:

abstract class Graph {
  type Node <: BaseNode;
  class BaseNode {
    self: Node =>
    def connectWith(n: Node): Edge =
      new Edge(self, n);
  }
  class Edge(from: Node, to: Node) {
    def source() = from;
    def target() = to;
  }
}

class LabeledGraph extends Graph {
  class Node(label: String) extends BaseNode {
    def getLabel: String = label;
    def self: Node = this;
  }
}

trait A { def x = 1 }
trait B extends A { override def x = super.x * 5 }
trait C1 extends B { override def x = 2 }
trait C2 extends A { this: B => override def x = 2}

// 1.
println((new C1 with B).x) // 2
println((new C2 with B).x) // 10

// 2.
trait X {
  type SomeA <: A
  trait Inner1 { this: SomeA => } // compiles ok
  trait Inner2 extends SomeA {} // doesn't compile
}

另一件没有提到的事情是:因为自类型不是所需类的层次结构的一部分，它们可以从模式匹配中排除，特别是当您根据密封的层次结构进行穷尽匹配时。当你想要建模正交行为时，这很方便，比如:

sealed trait Person
trait Student extends Person
trait Teacher extends Person
trait Adult { this : Person => } // orthogonal to its condition

val p : Person = new Student {}
p match {
  case s : Student => println("a student")
  case t : Teacher => println("a teacher")
} // that's it we're exhaustive

另一个区别是自类型可以指定非类类型。例如

trait Foo{
   this: { def close:Unit} => 
   ...
}

这里的self类型是一个结构类型。其效果是说，任何在Foo中混合的东西都必须实现一个无参数的“close”方法返回单元。这为duck类型提供了安全的mixin。

其他答案总结:

扩展的类型公开给继承的类型，但自类型不是 class Cow {this: FourStomachs}允许你使用只适用于反刍动物的方法，如digestGrass。扩展牛的特性将没有这样的特权。另一方面，类Cow扩展four胃部会将digestGrass暴露给任何扩展Cow的人。 自类型允许循环依赖，而扩展其他类型则不允许