web-dev-qa-db-fra.com

Constructeurs à Kotlin

J'apprends Kotlin à partir de documents officiels, j'ai créé un class comme ci-dessous, où j'ai créé un constructor qui a deux parameters. Le corps de constructor est dans le bloc init.

class Person(name: String, surname: String) {
    init {
        Log.d("App", "Hello");
    }
}

Eh bien, je veux créer un autre constructor qui prendra un parameter dans un constructor. Quel est le moyen de faire dans Kotlin

androidconstructorkotlin
34
N Sharma

Eh bien, init n'est pas un corps de constructeur. Il est appelé d'après constructeur primaire avec le contexte de constructeur principal.

Comme indiqué dans la documentation officielle:

Le constructeur principal ne peut contenir aucun code. Le code d’initialisation peut être placé dans des blocs d’initialisation, précédés du mot-clé init:

class Customer(name: String) {
    init {
        logger.info("Customer initialized with value ${name}")
    }
}

Notez que les paramètres du constructeur principal peuvent être utilisés dans les blocs d'initialisation. Ils peuvent également être utilisés dans les initialiseurs de propriétés déclarés dans le corps de la 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 cela ne semble pas correct car nous ne sommes pas obligés de passer la chaîne vide au deuxième argument. Nous pouvons donc commander le 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.

42
chandil03

Premier chemin 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 a un constructeur principal, chaque constructeur secondaire doit déléguer au constructeur principal, directement ou indirectement par le biais d'un autre constructeur secondaire. La délégation à un autre constructeur de la même classe est effectuée à l'aide du mot-clé this:

ou

kotlin n'autorisant pas l'utilisation de null comme this(name,null), utilisez donc ? pour représenter null les valeurs de type, surname: String?

class Person(name: String, surname: String?) {

    init {
        Log.d("primary", "Hello");
    }

    constructor(name : String):this(name,null){
        Log.d("secondary", "Hello");
    }
}
3
Pavneet_Singh

Dans la classe, utilisez le mot clé constructor pour créer un constructeur secondaire. Comme :

class Person(name: String, surname: String) {
    init {
        Log.d("App", "Hello");
    }
    constructor(id: Int) {

    }
}

Pour plus d'informations, consultez Constructeurs Secondaires

EDIT:
Rule: Si la classe a un constructeur primaire, chaque constructeur secondaire doit déléguer au constructeur primaire, directement ou indirectement via un ou plusieurs constructeurs secondaires. La délégation à un autre constructeur de la même classe est effectuée à l'aide du mot-clé this.

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

Ainsi, lorsque vous appelez le constructeur secondaire, il appelle le constructeur principal pour initialiser le nom, après quoi vous faites votre travail dans le constructeur secondaire. Dans l'exemple ci-dessus, le nom est initialisé en appelant le constructeur principal.

2
Akshay Bhat 'AB'

Voici comment créer 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 principal et ses paramètres à l'aide du mot-clé this.

1
Alf Moh

Constructeurs Secondaires

La classe peut également déclarer des constructeurs secondaires, préfixés par constructeur:

class Person {
    constructor(parent: Person) {
        parent.children.add(this)
    } }

Si la classe a un constructeur principal, chaque constructeur secondaire doit déléguer au constructeur principal, directement ou indirectement par le biais d'un autre constructeur secondaire. La délégation à un autre constructeur de la même classe est effectuée à l'aide du mot-clé this:

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

voir https://kotlinlang.org/docs/reference/classes.html partie Constructeurs secondaires

1
Solo