web-dev-qa-db-fra.com

Kotlin constructeur secondaire

Comment déclarer un constructeur secondaire dans Kotlin?

Y at-il de la documentation à ce sujet?

Ce qui suit ne compile pas ...

class C(a : Int) {
  // Secondary constructor
  this(s : String) : this(s.length) { ... }
}
syntaxconstructorkotlin
85
ironic

Mise à jour : Depuis M11 (0.11. *), Kotlin prend en charge constructeurs secondaires .

Pour le moment, Kotlin ne prend en charge que les constructeurs primaires (les constructeurs secondaires peuvent être pris en charge ultérieurement).

La plupart des cas d'utilisation de constructeurs secondaires sont résolus par l'une des techniques suivantes:

Technique 1. (résout votre cas) Définissez une méthode fabrique à côté de votre classe

fun C(s: String) = C(s.length)
class C(a: Int) { ... }

usage:

val c1 = C(1) // constructor
val c2 = C("str") // factory method

Technique 2. (peut également être utile) Définir les valeurs par défaut des paramètres

class C(name: String? = null) {...}

usage:

val c1 = C("foo") // parameter passed explicitly
val c2 = C() // default value used

Notez que les valeurs par défaut fonctionnent pour toutes les fonctions, pas seulement pour les constructeurs

Technique 3. (lorsque vous avez besoin d'encapsulation) Utilisez une méthode de fabrique définie dans un objet compagnon

Parfois, vous voulez que votre constructeur soit privé et que seule une méthode d'usine soit disponible pour les clients. Pour l'instant, cela n'est possible qu'avec une méthode de fabrique définie dans un objet compagnon :

class C private (s: Int) {
    companion object {
        fun new(s: String) = C(s.length)
    }
}

usage:

val c = C.new("foo")
79
Andrey Breslav

En tant que points de documentation , vous pouvez utiliser un constructeur secondaire de cette façon

class GoogleMapsRestApiClient constructor(val baseUrl: String) {

    constructor() : this("https://api.whatever.com/")

}

N'oubliez pas que vous devez étendre le comportement du premier constructeur.

24
cesards

pour déclarer un constructeur secondaire Kotlin utilisez simplement le constructeur mot-clé: like

c'est un constructeur primaire:

class Person constructor(firstName: String) {

}

ou

class Person(firstName: String) {

}

pour le code constructeur secondaire comme ceci:

class Person(val name: String) {
    constructor(name: String, parent: Person) : this(name) {
        parent.children.add(this)
    }
}

il est obligatoire d'appeler le principal constructeur sinon, le compilateur lancera ce qui suit erreur

Primary constructor call expected
15
Rashid Iqbal

Constructeurs avec init:

class PhoneWatcher : TextWatcher {

    private val editText: EditText
    private val mask: String

    private var variable1: Boolean = false
    private var variable2: Boolean = false

    init {
        variable1 = false
        variable2 = false
    }

    constructor(editText: EditText) : this(editText, "##-###-###-####")

    constructor(editText: EditText, mask: String) {
        this.editText = editText
        this.mask = mask
    }
    ...
}
7
CoolMind

Vous pouvez définir plusieurs constructeurs dans Kotlin avec constructor mais vous devez ignorer le constructeur par défaut class AuthLog(_data: String)

class AuthLog {

    constructor(_data: String): this(_data, -1)

    constructor(_numberOfData: Int): this("From count ", _numberOfData)

    private constructor(_data: String, _numberOfData: Int)

}

Pour plus de détails voir ici

Mettre à jour

Maintenant, vous pouvez définir le constructeur par défaut

class AuthLog(_data: String, _numberOfData: Int) {

    constructor(_data: String): this(_data, -1) {
        //TODO: Add some code here if you want
    }

    constructor(_numberOfData: Int): this("From count", _numberOfData)

}
5
Osvel Alvarez Jacomino

Je viens de voir cette question et je pense qu’il existe peut-être une autre technique qui sonne même mieux que celles proposées par Andrey.

class C(a: Int) {
    class object {
        fun invoke(name: String) = C(name.length)
    }        
}

Que vous puissiez écrire quelque chose comme val c:C = C(3) ou val c:C = C("abc"), parce que les méthodes invoke fonctionnent de la même manière que les méthodes apply dans Scala.

Mise à jour

À partir de maintenant, les constructeurs secondaires font déjà partie de la spécification de langage. Cette solution de contournement ne devrait donc pas être utilisée.

4
caeus

L'extrait de code ci-dessous devrait fonctionner

class  C(a:Int){
  constructor(s:String):this(s.length){..}
}
1
Sachini Samarasinghe
class Person(val name: String) {
    constructor(name: String, parent: Person) : this(name) {
        parent.children.add(this)
    }
}

vous pouvez essayer ça.

1
Ruhul

J'étais un peu confus avec la plupart des réponses. Pour faciliter la compréhension, j’ajoute un exemple avec plus d’éléments:

   @JsonInclude(JsonInclude.Include.NON_NULL)
   data class Response(val code: String) {
      var description: String? = null
      var value: String? = null

      constructor(code: String, description: String?) : this(code) {
          this.description = description
      }

      constructor(code: String, description: String?, value: String) : this(code, description) {
          this.value = value
      }
   }
0
Abbin Varghese

exemple de constructeur secondaire kotlin

class Person(name: String){
    var name=""
    var age=0

    constructor(age :Int,name : String)  : this(name){
        this.age=age
        this.name=name
    }
    fun display(){
        print("Kotlin Secondary constructor $name  , $age")
    }
}

fonction principale

fun main(args : Array<String>){

    var objd=Person(25,"Deven")
    objd.display()
}
0
Deven Mer