Sự khác biệt giữa các lớp con tự và đặc điểm là gì?

Một kiểu tự cho một đặc điểm A:

trait B
trait A { this: B => }

nói rằng " Akhông thể trộn lẫn vào một lớp cụ thể mà cũng không mở rộng B" .

Mặt khác, như sau:

trait B
trait A extends B

nói rằng "bất kỳ lớp (cụ thể hoặc trừu tượng) nào Acũng sẽ được trộn trong B" .

Không phải hai câu này có nghĩa giống nhau sao? Kiểu tự dường như chỉ phục vụ để tạo khả năng xảy ra lỗi thời gian biên dịch đơn giản.

Tôi đang thiếu gì?

Nó chủ yếu được sử dụng cho Dependency Injection , chẳng hạn như trong Mẫu Bánh. Có tồn tại một bài viết tuyệt vời bao gồm nhiều hình thức tiêm phụ thuộc khác nhau trong Scala, bao gồm cả Mô hình Bánh. Nếu bạn Google "Mẫu bánh và Scala", bạn sẽ nhận được nhiều liên kết, bao gồm cả bản trình bày và video. Bây giờ, đây là một liên kết đến một câu hỏi khác .

Bây giờ, như sự khác biệt giữa một loại bản thân và mở rộng một đặc điểm, đó là đơn giản. Nếu bạn nói B extends A, thì B là một A. Khi bạn sử dụng tự loại, B yêu cầu một A. Có hai yêu cầu cụ thể được tạo với kiểu tự:

1. Nếu Bđược mở rộng, thì bạn bắt buộc phải kết hợp A.
2. Khi một lớp cụ thể cuối cùng mở rộng / trộn lẫn - trong những đặc điểm này, một số lớp / tính trạng phải thực hiện A.

Hãy xem xét các ví dụ sau:

scala> trait User { def name: String }
defined trait User

scala> trait Tweeter {
     |   user: User =>
     |   def tweet(msg: String) = println(s"$name: $msg")
     | }
defined trait Tweeter

scala> trait Wrong extends Tweeter {
     |   def noCanDo = name
     | }
<console>:9: error: illegal inheritance;
 self-type Wrong does not conform to Tweeter's selftype Tweeter with User
       trait Wrong extends Tweeter {
                           ^
<console>:10: error: not found: value name
         def noCanDo = name
                       ^

Nếu Tweeterlà một lớp con của User, sẽ không có lỗi. Trong đoạn mã trên, chúng ta cần một Userbất cứ khi nào Tweeterđược sử dụng, tuy nhiên một Userkhông được cung cấp để Wrong, vì vậy chúng tôi đã nhận lỗi. Bây giờ, với mã ở trên vẫn còn trong phạm vi, hãy xem xét:

scala> trait DummyUser extends User {
     |   override def name: String = "foo"
     | }
defined trait DummyUser

scala> trait Right extends Tweeter with User {
     |   val canDo = name
     | }
defined trait Right 

scala> trait RightAgain extends Tweeter with DummyUser {
     |   val canDo = name
     | }
defined trait RightAgain

Với Right, yêu cầu để trộn vào một Userđược thỏa mãn. Tuy nhiên, yêu cầu thứ hai được đề cập ở trên không được thỏa mãn: gánh nặng của việc thực hiện Uservẫn còn đối với các lớp / đặc điểm mở rộng Right.

Với RightAgaincả hai yêu cầu đều được thỏa mãn. A Uservà việc thực hiện Userđược cung cấp.

Đối với các trường hợp sử dụng thực tế hơn, xin vui lòng xem các liên kết ở đầu câu trả lời này! Nhưng, hy vọng bây giờ bạn có được nó.

Tự loại cho phép bạn xác định phụ thuộc theo chu kỳ. Ví dụ: bạn có thể đạt được điều này:

trait A { self: B => }
trait B { self: A => }

Kế thừa sử dụng extendskhông cho phép điều đó. Thử:

trait A extends B
trait B extends A
error:  illegal cyclic reference involving trait A

Trong sách Oderky, hãy xem phần 33.5 (Tạo chương UI bảng tính) trong đó đề cập đến:

Trong ví dụ về bảng tính, Mô hình lớp kế thừa từ Trình đánh giá và do đó có được quyền truy cập vào phương thức đánh giá của nó. Theo cách khác, Trình đánh giá lớp định nghĩa kiểu tự của nó là Kiểu, như sau:

package org.stairwaybook.scells
trait Evaluator { this: Model => ...

Hi vọng điêu nay co ich.

Một sự khác biệt nữa là các kiểu tự có thể chỉ định các kiểu không phải là lớp. Ví dụ

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

Loại tự ở đây là một loại cấu trúc. Hiệu quả là để nói rằng bất cứ điều gì trộn lẫn trong Foo đều phải thực hiện một đơn vị trả về phương thức "đóng" không có đối số. Điều này cho phép mixins an toàn để gõ vịt.

Phần 2.3 "Chú thích Selftype" của bản tóm tắt thành phần Scala gốc của Martin Oderky thực sự giải thích rõ ràng mục đích của selftype ngoài thành phần mixin: cung cấp một cách khác để liên kết một lớp với một loại trừu tượng.

Ví dụ được đưa ra trong bài báo giống như sau, và nó dường như không có một phóng viên lớp con thanh lịch:

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;
  }
}

Một điều khác chưa được đề cập: bởi vì kiểu tự không phải là một phần của hệ thống phân cấp của lớp bắt buộc, chúng có thể được loại trừ khỏi khớp mẫu, đặc biệt là khi bạn khớp hoàn toàn với hệ thống phân cấp kín. Điều này thuận tiện khi bạn muốn mô hình hóa các hành vi trực giao như:

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

TL; DR tóm tắt các câu trả lời khác:

• Các loại bạn mở rộng được tiếp xúc với các kiểu được kế thừa, nhưng các kiểu tự thì không

  ví dụ: class Cow { this: FourStomachs }cho phép bạn sử dụng các phương pháp chỉ có sẵn cho động vật nhai lại, chẳng hạn như digestGrass. Tuy nhiên, những đặc điểm mở rộng Bò sẽ không có những đặc quyền như vậy. Mặt khác, class Cow extends FourStomachssẽ tiếp xúc digestGrassvới bất cứ ai extends Cow .

• tự loại cho phép phụ thuộc theo chu kỳ, mở rộng các loại khác không

Hãy bắt đầu với sự phụ thuộc theo chu kỳ.

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

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

Tuy nhiên, tính mô-đun của giải pháp này không tuyệt vời như lần đầu tiên xuất hiện, bởi vì bạn có thể ghi đè các kiểu tự như vậy:

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

Mặc dù, nếu bạn ghi đè một thành viên của loại tự, bạn sẽ mất quyền truy cập vào thành viên ban đầu, vẫn có thể được truy cập thông qua siêu sử dụng kế thừa. Vì vậy, những gì thực sự đạt được khi sử dụng thừa kế là:

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

Bây giờ tôi không thể yêu cầu hiểu tất cả sự tinh tế của mẫu bánh, nhưng điều gây ấn tượng với tôi là phương pháp chính để thực thi mô đun là thông qua thành phần chứ không phải kiểu thừa kế hoặc kiểu tự.

Phiên bản thừa kế ngắn hơn, nhưng lý do chính tôi thích kế thừa hơn các kiểu tự là tôi thấy khó khăn hơn nhiều để có được thứ tự khởi tạo chính xác với các kiểu tự. Tuy nhiên, có một số điều bạn có thể làm với kiểu tự mà bạn không thể làm với thừa kế. Các kiểu tự có thể sử dụng một kiểu trong khi thừa kế yêu cầu một đặc điểm hoặc một lớp như trong:

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

Bạn thậm chí có thể làm:

trait TypeBuster
{ this: Int with String => }

Mặc dù bạn sẽ không bao giờ có thể khởi tạo nó. Tôi không thấy bất kỳ lý do tuyệt đối nào cho việc không thể kế thừa từ một loại, nhưng tôi chắc chắn cảm thấy sẽ hữu ích khi có các lớp và đặc điểm của hàm tạo đường dẫn khi chúng ta có các đặc điểm / lớp của hàm tạo. Thật không may

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

Chúng tôi có thứ này:

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 }

Hoặc này:

  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 }

Một điểm cần được đồng cảm nhiều hơn là các đặc điểm có thể mở rộng các lớp. Cảm ơn David Maclver đã chỉ ra điều này. Đây là một ví dụ từ mã của riêng tôi:

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]

ScnBasekế thừa từ lớp Swing Frame, do đó, nó có thể được sử dụng như một kiểu tự và sau đó trộn vào cuối (tại thời điểm khởi tạo). Tuy nhiên, val geomRcần phải được khởi tạo trước khi nó được sử dụng bằng cách kế thừa các đặc điểm. Vì vậy, chúng ta cần một lớp để thực thi khởi tạo trước geomR. Lớp ScnVistasau đó có thể được kế thừa từ nhiều đặc điểm trực giao mà bản thân chúng có thể được thừa hưởng từ đó. Sử dụng nhiều tham số loại (generic) cung cấp một hình thức mô đun thay thế.

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
}

Kiểu tự cho phép bạn chỉ định loại nào được phép trộn lẫn một đặc điểm. Ví dụ, nếu bạn có một đặc điểm với kiểu tự Closeable, thì đặc điểm đó biết rằng những điều duy nhất được phép trộn nó vào, phải thực hiện Closeablegiao diện.

Cập nhật: Một điểm khác biệt chính là các kiểu tự có thể phụ thuộc vào nhiều lớp (tôi thừa nhận đó là trường hợp góc một chút). Ví dụ, bạn có thể có

class Person {
  //...
  def name: String = "...";
}

class Expense {
  def cost: Int = 123;
}

trait Employee {
  this: Person with Expense =>
  // ...

  def roomNo: Int;

  def officeLabel: String = name + "/" + roomNo;
}

Điều này cho phép thêm Employeemixin vào bất cứ thứ gì thuộc lớp con Personvà Expense. Tất nhiên, điều này chỉ có ý nghĩa nếu Expensekéo dài Personhoặc ngược lại. Vấn đề là việc sử dụng các kiểu tự Employeecó thể độc lập với hệ thống phân cấp của các lớp mà nó phụ thuộc vào. Nó không quan tâm đến những gì mở rộng những gì - Nếu bạn chuyển đổi thứ bậc của Expensevs Person, bạn không phải sửa đổi Employee.

trong trường hợp đầu tiên, một tính trạng phụ hoặc lớp con của B có thể được trộn lẫn vào bất cứ điều gì sử dụng A. Vì vậy, B có thể là một tính trạng trừu tượng.