Kotlin secondaire constructeur
Comment déclarer un constructeur secondaire à Kotlin?
y a-t-il une documentation à ce sujet?
ci-dessous ne compile pas...
class C(a : Int) {
// Secondary constructor
this(s : String) : this(s.length) { ... }
}
8 réponses
Mise À Jour : Depuis M11 (De 0,11.*) Kotlin prend en charge "1519100920 secondaire" constructeurs .
pour L'instant Kotlin ne prend en charge que les constructeurs primaires (les constructeurs secondaires peuvent être pris en charge plus tard).
la plupart des cas d'utilisation pour les constructeurs secondaires sont résolus par l'une des techniques ci-dessous:
Technique 1. (résout votre cas) définir une méthode d'usine à côté de votre classe
fun C(s: String) = C(s.length)
class C(a: Int) { ... }
utilisation:
val c1 = C(1) // constructor
val c2 = C("str") // factory method
Technique 2. (peut également être utile) définir les valeurs par défaut pour les paramètres
class C(name: String? = null) {...}
utilisation:
val c1 = C("foo") // parameter passed explicitly
val c2 = C() // default value used
noter que les valeurs par défaut travailler pour toute fonction , non seulement pour les constructeurs
"151970920 la Technique de" l' 3. (quand vous avez besoin d'encapsulation) utilisez une méthode d'usine définie dans un objet compagnon
parfois, vous voulez votre constructeur privé et seulement une méthode d'usine disponible pour les clients. Pour l'instant cela n'est possible qu'avec une méthode d'usine 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")
comme le 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/")
}
rappelez-vous que vous devez étendre le premier comportement du constructeur.
pour déclarer un constructeur secondaire Kotlin il suffit d'utiliser le constructeur mot-clé: like
c'est un constructeur primaire:
class Person constructor(firstName: String) {
}
ou
class Person(firstName: String) {
}
pour le code du 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 la suivante erreur
Primary constructor call expected
je viens de voir cette question et je pense qu'il peut y avoir une autre technique qui sonne encore mieux que celles proposées par Andrey.
class C(a: Int) {
class object {
fun invoke(name: String) = C(name.length)
}
}
que vous pouvez soit écrire quelque chose comme val c:C = C(3) ou val c:C = C("abc") , parce que le invoke méthodes de travail sorte de la même façon que le apply méthodes de travail à Scala.
mise à Jour
à partir de Maintenant, les constructeurs secondaires font déjà partie la spécification de la langue donc cette solution ne devrait pas être utilisée.
vous pouvez définir plusieurs constructeurs dans Kotlin avec constructor mais vous devez sauter 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)
}
class Person(val name: String) {
constructor(name: String, parent: Person) : this(name) {
parent.children.add(this)
}
}
vous pouvez essayer cette.
L'extrait de code ci-dessous doit fonctionner
class C(a:Int){
constructor(s:String):this(s.length){..}
}
kotlin Secondaire constructeur exemple
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()
}