Scala surcharge du constructeur?

Comment voulez-vous fournir des constructeurs surchargés en Scala?

InformationsquelleAutor Landon Kuhn | 2009-07-07
  1. 178

    Il vaut la peine de mentionner explicitement que les Auxiliaires des Constructeurs en Scala doit appeler le principal constructeur (comme dans landon9720 s) réponse, ou un autre auxiliaire constructeur de la même classe, comme première action. Ils ne peuvent pas simplement appeler le constructeur de la superclasse, explicitement ou implicitement, comme ils peuvent en Java. Cela garantit que le principal constructeur est le seul point d'entrée de la 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);   
}
    • McAuliffe: le Mauvais exemple? Sans deuxième et troisième constructeurs, l'utilisateur peut appeler new Foo(x=2,z=4) et new Foo(z=5) si vous modifiez votre première ligne de class Foo(x: Int = 0, y: Int = 0, z: String) {
    • Nommé/arguments par Défaut n'est pas arrivé jusqu'à la Scala 2.8.
    • Il serait intéressant de mentionner comment utiliser une surcharge de constructeur. Il n'est pas trivial que le new mot-clé est nécessaire, même pour des classes de cas.
    InformationsquelleAutor Jon McAuliffe
  2. 32
     class Foo(x: Int, y: Int) {
     def this(x: Int) = this(x, 0) //default y parameter to 0
 }
    InformationsquelleAutor Landon Kuhn
  3. 15

    Comme de la Scala de 2.8.0 vous pouvez également avoir des valeurs par défaut pour le constructeur et les paramètres de la méthode. Comme ce

    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)

    Paramètres avec des valeurs par défaut doivent venir après celles qui ont pas de valeurs par défaut dans la liste des paramètres.

    • Cela ne fonctionne pas pour les non-trivial de défaut de bien. donc class Foo(val x:Int, y:Int=2*x) ne fonctionne pas.
    • Lundberg: vous avez écrit des Paramètres avec des valeurs par défaut doivent venir après celles qui ont pas de valeurs par défaut dans la liste des paramètres. C'est faux, new Foo(x=2,z=4) imprime Foo(2,0,4).
    • ce que je voulais dire, c'est que vous ne pouvez pas écrire de nouveau Foo(12, x=2) vous devez écrire le nouveau Foo(x=2, 12). Vous pouvez écrire de nouvelles Foo(12, y=2), alors vous aurez Foo(12, 2, 0)
    • Qui ne fonctionne pas bien avec Java.
    InformationsquelleAutor Jörgen Lundberg
  4. 8

    En regardant mon code, j'ai soudain réalisé que je ne sorte de surcharge de constructeur. Je me suis alors souvenu de cette question et revient à donner une autre réponse:

    En Scala, vous ne pouvez pas surcharger les constructeurs, mais vous pouvez le faire avec des fonctions.

    Aussi, beaucoup choisissent de faire de la apply la fonction d'un compagnon objet d'une usine pour la catégorie concernée.

    Faire de cette classe abstraite et une surcharge du apply fonction à mettre en œuvre-instancier cette classe, vous avez votre surchargé “constructeur”:

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

    Remarque que j'définir explicitement chaque apply de retour Expectation[T], sinon, il serait de retour à un canard tapé Expectation[T]{val expected: List[T]}.

    InformationsquelleAutor flying sheep
  5. 1

    J'ai pensé que peut-être Scala Constructeurs (2008-11-11) pourrait ajouter plus d'informations.

    InformationsquelleAutor asyncwait
  6. 0

    Essayer cette

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