Sovraccarico costruttore Scala?

Come fornite costruttori sovraccarichi in Scala?

Vale la pena menzionare esplicitamente che i Costruttori ausiliari in Scala devono chiamare la risposta del costruttore principale (come in landon9720), o un altro costruttore ausiliario della stessa classe, come la loro prima azione. Non possono semplicemente chiamare il costruttore della superclasse in modo esplicito o implicito come in Java. Ciò garantisce che il costruttore principale sia l'unico punto di accesso alla classe.

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
 }

A partire da Scala 2.8.0 è inoltre possibile avere valori predefiniti per i parametri dei metodi e dei contrettori. Come questo

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)

I parametri con valori predefiniti devono venire dopo quelli senza valori predefiniti nell'elenco dei parametri.

Mentre guardavo il mio codice, improvvisamente mi sono reso conto di aver sovraccaricato un costruttore. Poi ho ricordato quella domanda e sono tornato per dare un'altra risposta:

In Scala, non puoi sovraccaricare i costruttori, ma puoi farlo con le funzioni.

Inoltre, molti scelgono di trasformare la applyfunzione di un oggetto compagno in una fabbrica per la rispettiva classe.

Rendendo astratta questa classe e sovraccaricando la applyfunzione per implementare l'istanza di questa classe, hai il tuo "costruttore" sovraccarico:

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)
        …
    }
}

Si noti che io definisco esplicitamente ciascuno applyda restituire Expectation[T], altrimenti restituirebbe un'anatra digitata Expectation[T]{val expected: List[T]}.

Prova questo

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