스칼라에서 자기 유형과 형질 상속의 차이점은 무엇입니까?

Google 검색시이 주제에 대한 많은 답변이 나타납니다. 그러나 나는이 두 기능의 차이점을 잘 설명하는 사람이 있다고 생각하지 않습니다. 한 번 더 시도하고 싶습니다. 구체적으로 ...

자기 유형으로 할 수 있고 상속하지 않고 할 수있는 것은 무엇입니까?

나에게, 둘 사이에 정량화 할 수있는 물리적 차이가 있어야한다. 그렇지 않으면 명목상 다르다.

특성 A가 B 또는 자체 유형 B를 확장하는 경우 B의 존재가 요구 사항이라는 것을 모두 설명하지 않습니까? 차이점은 어디에 있습니까?

특성 A가 B를 확장하면 A를 혼합하면 A에 추가하거나 확장하는 모든 것을 정확하게 B에 더 해줍니다. 반대로, 특성 A에 명시 적으로 B로 유형이 지정된 자체 참조가있는 경우 최종 상위 클래스는 B 또는 하위 유형의 B 도 혼합해야합니다 ( 먼저 이를 혼합해야 합니다).

그것이 가장 중요한 차이점입니다. 첫 번째 경우, 정확한 유형의 B는 A 지점이 연장되는 지점에서 결정화됩니다. 두 번째로, 부모 클래스의 디자이너는 부모 클래스가 구성되는 시점에서 어떤 버전의 B가 사용되는지 결정합니다.

또 다른 차이점은 A와 B가 같은 이름의 메소드를 제공하는 것입니다. A가 B를 확장하는 경우 A의 방법은 B보다 우선합니다. A가 B 다음에 섞인 경우 A의 방법이 단순히 이깁니다.

입력 된 자체 참조는 훨씬 더 많은 자유를줍니다. A와 B의 커플 링이 느슨합니다.

최신 정보:

이러한 차이점의 이점에 대해 명확하지 않기 때문에 ...

직접 상속을 사용하는 경우 B + A 인 특성 A를 만듭니다. 당신은 돌로 관계를 설정했습니다.

유형이 지정된 자체 참조를 사용하는 경우 클래스 C에서 특성 A를 사용하려는 사람은 누구나

• B와 A를 C에 섞는다.
• B의 하위 유형을 혼합 한 다음 A를 C에 혼합하십시오.
• A를 C에 혼합하십시오. 여기서 C는 B의 서브 클래스입니다.

스칼라가 코드 블록을 생성자로 사용하여 특성을 직접 인스턴스화 할 수있는 방법을 고려할 때 이는 옵션의 한계가 아닙니다.

A의 방법 우승 의 차이점은 A가 B를 확장하는 A와 비교하여 마지막에 혼합되기 때문에 이것을 고려하십시오 ...

일련의 특성을 혼합하는 foo()경우, 메소드 가 호출 될 때마다 컴파일러는 혼합 된 마지막 특성으로 이동 foo()한 다음 (찾을 수없는 경우) 구현 foo()하고 사용 하는 특성을 찾을 때까지 순서를 왼쪽으로 탐색 합니다. 그. A에는 호출 옵션 super.foo()이 있으며 구현을 찾을 때까지 시퀀스를 왼쪽으로 이동합니다.

따라서 A가 B에 대한 자체 참조 유형을 가지고 있고 A의 작성자가 B가 구현 한다는 것을 알고 있다면 foo()A는 super.foo()아무것도 제공하지 않으면 foo()B가 할 것이라는 것을 알 수 있습니다 . 그러나 클래스 C의 작성자는를 구현하는 다른 특성을 제거하는 옵션이 있으며 foo()대신 A 가이를 얻습니다.

다시 말하지만 이것은 A 확장 B보다 훨씬 강력하고 제한이 적으며 B의 버전을 직접 호출 foo()합니다.

자체 유형을 설정하거나 설정할 때의 wrt 가시성 및 "기본"구현의 차이점을 보여주는 코드가 있습니다. 실제 이름 충돌이 해결되는 방법에 대해 이미 논의한 부분은 설명하지 않고 가능한 것과 불가능한 것에 중점을 둡니다.

trait A1 {
  self: B =>

  def doit {
    println(bar)
  }
}

trait A2 extends B {
  def doit {
    println(bar)
  }
}

trait B {
  def bar = "default bar"
}

trait BX extends B {
  override def bar = "bar bx"
}

trait BY extends B {
  override def bar = "bar by"
}

object Test extends App {
  // object Thing1 extends A1  // FAIL: does not conform to A1 self-type
  object Thing1 extends A1 with B
  object Thing2 extends A2

  object Thing1X extends A1 with BX
  object Thing1Y extends A1 with BY
  object Thing2X extends A2 with BX
  object Thing2Y extends A2 with BY

  Thing1.doit  // default bar
  Thing2.doit  // default bar
  Thing1X.doit // bar bx
  Thing1Y.doit // bar by
  Thing2X.doit // bar bx
  Thing2Y.doit // bar by

  // up-cast
  val a1: A1 = Thing1Y
  val a2: A2 = Thing2Y

  // println(a1.bar)    // FAIL: not visible
  println(a2.bar)       // bar bx
  // println(a2.bary)   // FAIL: not visible
  println(Thing2Y.bary) // 42
}

IMO의 중요한 차이점 중 하나는 (업 캐스트 된 부분에서 설명 된 것처럼) 단순히 보는 것에 만 A1필요하다는 것을 드러내지 않는다는 것입니다 . 실제로 특정 전문화 가 사용되는 것을 볼 수있는 유일한 코드 는 구성된 유형 (와 같은 ) 을 명시 적으로 알고있는 코드입니다 .BA1BThink*{X,Y}

또 다른 요점은 A2(확장자와 함께) 실제로 B다른 것을 지정하지 않으면 실제로 사용 A1한다는 것입니다 (자체 유형)은 B재정의하지 않는 한 사용할 것이라고 말하지 않으며 객체가 인스턴스화 될 때 콘크리트 B가 명시 적으로 주어져야합니다.