Constructeurs en Kotlin
je suis en train d'apprendre Kotlin officielle des docs, j'ai créé un class comme ci-dessous où j'ai créé un constructor qui en a deux parameters. Corps de l' constructorinit bloc.
class Person(name: String, surname: String) {
init {
Log.d("App", "Hello");
}
}
Eh bien, je veux en créer un de plus constructor qui va en prendre un parameter dans un constructor. Quelle est la façon de le faire dans Kotlin
5 réponses
init n'est pas un corps de constructeur. Il est appelé d'après le constructeur primaire avec le contexte du constructeur primaire.
comme indiqué dans la documentation officielle:
le constructeur primaire ne peut contenir aucun code. Le code d'initialisation peut être placé dans les blocs initializer, qui sont préfixés par le mot-clé init:
class Customer(name: String) {
init {
logger.info("Customer initialized with value ${name}")
}
}
notez que les paramètres du constructeur primaire peuvent être utilisés dans les blocs initialiseur. Ils peuvent également être utilisés dans les initialisateurs de propriétés déclarés dans le corps de classe:
class Customer(name: String) {
val customerKey = name.toUpperCase()
}
en fait, pour déclarer des propriétés et les initialiser à partir du constructeur principal, Kotlin a une syntaxe concise:
class Person(val firstName: String, val lastName: String, var age: Int) {
// ...
}
selon votre question, vous pouvez ajouter un constructeur pour accepter un paramètre comme suit:
class Person(name: String, surname: String) {
constructor(name: String) : this(name, "") {
// constructor body
}
init {
Log.d("App", "Hello");
}
}
mais il n'a pas l'air bon car nous sommes inutile passer deuxième argument chaîne vide. Si nous pouvons commander constructeur comme suit:
class Person(name: String) {
constructor(name: String, surname: String) : this(name) {
// constructor body
}
init {
Log.d("App", "Hello");
}
}
j'Espère que ça aide.
Première façon de le faire avec des valeurs vides
// (name: String, surname: String) default constructor signature
class Person(name: String, surname: String) {
// init block , represents the body of default constructor
init {
Log.d("primary", "Hello");
}
// secondary constructor
// this(name,"") call to default constructor
constructor(name : String):this(name,""){
Log.d("secondary", "Hello");
}
}
pourquoi this(name,"")
Si la classe possède un constructeur, chaque deuxième constructeur besoin de déléguer au constructeur principal, soit directement, soit indirectement par l'intermédiaire d'un autre secondaire constructeur(s). Délégation à un autre constructeur de la même classe est fait en utilisant le mot-clé suivant:
ou
kotlin, ne permettra pas d'utiliser nullthis(name,null) donc utiliser ? pour représenter null valeurs avec type,surname: String?
class Person(name: String, surname: String?) {
init {
Log.d("primary", "Hello");
}
constructor(name : String):this(name,null){
Log.d("secondary", "Hello");
}
}
dans la classe utiliser constructor mot clé pour créer secondaire constructeur. Comme:
class Person(name: String, surname: String) {
init {
Log.d("App", "Hello");
}
constructor(id: Int) {
}
}
Pour plus d'informations, consultez Constructeurs Secondaires
EDIT:
la Règle : si la classe a un constructeur primaire, chaque constructeur secondaire doit déléguer au constructeur primaire, soit directement, soit indirectement par l'intermédiaire d'un autre constructeur secondaire. La délégation à un autre constructeur de la même classe est fait en utilisant le mot-clé this.
class Person(val name: String) {
constructor(name: String, parent: Person) : this(name) {
parent.children.add(this)
}
}
donc quand vous appelez le constructeur secondaire, il appelle le constructeur primaire pour initialiser le nom et ensuite vous faites votre truc dans le constructeur secondaire. Dans l'exemple ci-dessus le nom est initialisé par l'appel principal constructeur.
Constructeurs Secondaires
la classe peut aussi déclarer les constructeurs secondaires, qui sont préfixés avec le constructeur:
class Person {
constructor(parent: Person) {
parent.children.add(this)
} }
si la classe a un constructeur primaire, chaque constructeur secondaire doit déléguer au constructeur primaire, soit directement, soit indirectement par l'intermédiaire d'un autre constructeur secondaire. La délégation à un autre constructeur de la même classe est faite en utilisant le mot-clé suivant:
class Person(val name: String) {
constructor(name: String, parent: Person) : this(name) {
parent.children.add(this)
} }
voir https://kotlinlang.org/docs/reference/classes.html Secondaire Constructeurs partie
c'est ainsi que vous créez un autre constructeur.
class Person(name: String, surname: String) {
init {
Log.d("App", "Hello");
}
constructor(id: Int) : this("example name", "example surname") {
}
}
rappelez-vous toujours que le constructeur secondaire devra référencer le constructeur primaire et ses paramètres en utilisant ce mot-clé.