Constructeur secondaire Kotlin

Question

Comment déclarer un constructeur secondaire en Kotlin ?

Y a-t-il de la documentation à ce sujet ?

Le code suivant ne compile pas...

class C(a : Int) {
  // Constructeur secondaire
  this(s : String) : this(s.length) { ... }
}

Answer 1

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

---

Pour l'instant, Kotlin ne prend en charge que les constructeurs primaires (les constructeurs secondaires pourraient être pris en charge ultérieurement).

La plupart des cas d'utilisation des constructeurs secondaires peuvent être résolus par l'une des techniques ci-dessous :

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

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

utilisation :

val c1 = C(1) // constructeur
val c2 = C("str") // méthode de fabrique

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

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

utilisation :

val c1 = C("foo") // paramètre passé explicitement
val c2 = C() // valeur par défaut utilisée

Notez que les valeurs par défaut fonctionnent pour n'importe quelle fonction, 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 qu'une seule méthode de fabrique soit disponible pour les clients. Pour l'instant, ceci est uniquement possible 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)
    }
}

utilisation :

val c = C.new("foo")

Answer 2

Comme le document indique, vous pouvez utiliser un constructeur secondaire de cette manière

class GoogleMapsRestApiClient constructor(val baseUrl: String) {

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

}

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

Answer 3

Pour déclarer un constructeur secondaire Kotlin il suffit d'utiliser le mot-clé constructor : comme

il s'agit d'un constructeur primaire :

class Person constructor(firstName: String) {

}

ou

class Person(firstName: String) {

}

pour le constructeur secondaire, le code ressemble à ceci :

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

il est obligatoire d'appeler le constructeur primaire sinon, le compilateur affichera l'erreur suivante

Appel de constructeur primaire attendu

Answer 4

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

Answer 5

Trop tard pour répondre, mais voici ma modeste contribution :)

Puisque Kotlin prend en charge la valeur par défaut des paramètres, (note : je veux utiliser la puissance de null) comme ceci :

data class MyClass(val a: Int? = null, val b: String? = null, val c: Double? = null)

nous n'avons pas besoin d'avoir plusieurs constructeurs. mais même si nous le voulons, nous pouvons le faire de cette manière aussi :

data class MyClass(val a: Int?, val b: String?, val c: Double?){
    constructor() : this(null,null,null)
    constructor(a : Int) : this(a,null,null)
    constructor(a : Int, b: String) : this(a,b,null)
}

nous pouvons instancier cette classe de différentes manières :

println(MyClass().toString())
println(MyClass(1).toString())
println(MyClass(1,"String").toString())
println(MyClass(1,"String",0.5).toString())

et voyons aussi le résultat :