Scala constructor overload?

Bagaimana Anda menyediakan konstruktor kelebihan beban di Scala?

Perlu disebutkan secara eksplisit bahwa Konstruktor Tambahan di Scala harus memanggil jawaban konstruktor utama (seperti pada landon9720), atau konstruktor bantu lain dari kelas yang sama, sebagai tindakan pertama mereka. Mereka tidak bisa begitu saja memanggil konstruktor superclass secara eksplisit atau implisit seperti yang mereka dapat di Jawa. Ini memastikan bahwa konstruktor utama adalah satu-satunya titik masuk ke kelas.

class Foo(x: Int, y: Int, z: String) {  
  // default y parameter to 0  
  def this(x: Int, z: String) = this(x, 0, z)   
  // default x & y parameters to 0
  // calls previous auxiliary constructor which calls the primary constructor  
  def this(z: String) = this(0, z);   
}

 class Foo(x: Int, y: Int) {
     def this(x: Int) = this(x, 0) // default y parameter to 0
 }

Pada Scala 2.8.0 Anda juga dapat memiliki nilai default untuk parameter konstruktor dan metode. Seperti ini

scala> class Foo(x:Int, y:Int = 0, z:Int=0) {                           
     | override def toString() = { "Foo(" + x + ", " + y + ", " + z + ")" }
     | }
defined class Foo

scala> new Foo(1, 2, 3)                                                    
res0: Foo = Foo(1, 2, 3)

scala> new Foo(4)                                                          
res1: Foo = Foo(4, 0, 0)

Parameter dengan nilai default harus datang setelah yang tanpa nilai default dalam daftar parameter.

Sambil melihat kode saya, saya tiba-tiba menyadari bahwa saya melakukan overload pada konstruktor. Saya kemudian ingat pertanyaan itu dan kembali untuk memberikan jawaban lain:

Di Scala, Anda tidak bisa membebani konstruktor, tetapi Anda bisa melakukan ini dengan fungsi.

Juga, banyak yang memilih untuk menjadikan applyfungsi objek pendamping sebagai pabrik untuk kelas masing-masing.

Membuat kelas ini abstrak dan membebani applyfungsi untuk mengimplementasikan-instantiate kelas ini, Anda memiliki "konstruktor" kelebihan beban Anda:

abstract class Expectation[T] extends BooleanStatement {
    val expected: Seq[T]
    …
}

object Expectation {
    def apply[T](expd:     T ): Expectation[T] = new Expectation[T] {val expected = List(expd)}
    def apply[T](expd: Seq[T]): Expectation[T] = new Expectation[T] {val expected =      expd }

    def main(args: Array[String]): Unit = {
        val expectTrueness = Expectation(true)
        …
    }
}

Perhatikan bahwa saya secara eksplisit menentukan masing apply- masing untuk kembali Expectation[T], jika tidak maka akan mengembalikan bebek yang diketik Expectation[T]{val expected: List[T]}.

Coba ini

class A(x: Int, y: Int) {
  def this(x: Int) = this(x, x)
  def this() = this(1)
  override def toString() = "x=" + x + " y=" + y
  class B(a: Int, b: Int, c: String) {
    def this(str: String) = this(x, y, str)
    override def toString() =
      "x=" + x + " y=" + y + " a=" + a + " b=" + b + " c=" + c
  }
}