In dit artikel leer je over constructors in Kotlin (zowel primaire als secundaire constructors) en over initialisatieblokken met behulp van voorbeelden.
Een constructor is een beknopte manier om klasse-eigenschappen te initialiseren.
Het is een speciale lidfunctie die wordt aangeroepen wanneer een object wordt geïnstantieerd (gemaakt). Hoe ze in Kotlin werken, is echter iets anders.
In Kotlin zijn er twee constructeurs:
- Primaire constructor - beknopte manier om een klasse te initialiseren
- Secundaire constructor - hiermee kunt u aanvullende initialisatielogica plaatsen
Primaire constructor
De primaire constructor maakt deel uit van de klassenheader. Hier is een voorbeeld:
class Person (val firstName: String, var age: Int) (// class body)
Het blok van de code, omgeven door haakjes is de belangrijkste constructeur: (val firstName: String, var age: Int).
De constructor heeft twee eigenschappen gedeclareerd: firstName(alleen-lezen eigenschap zoals gedeclareerd met trefwoord val) en age(lezen-schrijven eigenschap zoals gedeclareerd met trefwoord var).
Voorbeeld: primaire constructor
fun main(args: Array) ( val person1 = Person("Joe", 25) println("First Name = $(person1.firstName)") println("Age = $(person1.age)") ) class Person(val firstName: String, var age: Int) ( )
Wanneer u het programma uitvoert, is de uitvoer:
Voornaam = Joe Age = 25
Wanneer het object van Personklasse is gemaakt, "Joe"en 25waarden worden doorgegeven alsof het Personeen functie is.
Dit initialiseert firstNameen ageeigenschappen van person1 object naar "Joe"en 25respectievelijk.
Er zijn andere manieren om primaire constructors te gebruiken.
Primaire constructor- en initialisatieblokken
De primaire constructor heeft een beperkte syntaxis en kan geen code bevatten.
Om de initiatiecode te plaatsen (niet alleen code om eigenschappen te initialiseren), wordt het initialisatieblok gebruikt. Het wordt voorafgegaan door een inittrefwoord. Laten we het bovenstaande voorbeeld aanpassen met het initialisatieblok:
fun main(args: Array) ( val person1 = Person("joe", 25) ) class Person(fName: String, personAge: Int) ( val firstName: String var age: Int // initializer block init ( firstName = fName.capitalize() age = personAge println("First Name = $firstName") println("Age = $age") ) )
Wanneer u het programma uitvoert, is de uitvoer:
First Name = Joe Age = 25
Hier accepteren parameters fName en personAge tussen haakjes waarden "Joe"en 25respectievelijk wanneer person1-object wordt gemaakt. FName en personAge worden echter gebruikt zonder varof val, en zijn geen eigenschappen van de Personklasse.
De Personklasse heeft twee eigenschappen firstName en leeftijd worden gedeclareerd.
Wanneer het person1object is gemaakt, wordt de code in het initialisatieblok uitgevoerd. Het initialisatieblok initialiseert niet alleen zijn eigenschappen, maar drukt ze ook af.
Hier is een andere manier om dezelfde taak uit te voeren:
fun main(args: Array) ( val person1 = Person("joe", 25) ) class Person(fName: String, personAge: Int) ( val firstName = fName.capitalize() var age = personAge // initializer block init ( println("First Name = $firstName") println("Age = $age") ) )
Om onderscheid te maken tussen de constructorparameter en de eigenschap, worden verschillende namen gebruikt (fName en firstName, en personAge en age). Het is gebruikelijker om _firstName en _age te gebruiken in plaats van een volledig verschillende naam voor constructorparameters. Bijvoorbeeld:
class Person (_firstName: String, _age: Int) (val firstName = _firstName.capitalize () var age = _age // initialisatieblok init (…))
Standaardwaarde in Primary Constructor
U kunt een standaardwaarde opgeven voor constructorparameters (vergelijkbaar met het opgeven van standaardargumenten voor functies). Bijvoorbeeld:
fun main(args: Array) ( println("person1 is instantiated") val person1 = Person("joe", 25) println("person2 is instantiated") val person2 = Person("Jack") println("person3 is instantiated") val person3 = Person() ) class Person(_firstName: String = "UNKNOWN", _age: Int = 0) ( val firstName = _firstName.capitalize() var age = _age // initializer block init ( println("First Name = $firstName") println("Age = $age") ) )
Wanneer u het programma uitvoert, is de uitvoer:
Voornaam = Joe Leeftijd = 25 person2 is geïnstantieerd Voornaam = Jack Leeftijd = 0 person3 is geïnstantieerd Voornaam = ONBEKEND Leeftijd = 0
Kotlin secundaire constructeur
In Kotlin kan een klasse ook een of meer secundaire constructors bevatten. Ze zijn gemaakt met behulp van een constructortrefwoord.
Secundaire constructeurs zijn niet zo gebruikelijk in Kotlin. Het meest voorkomende gebruik van secundaire constructor komt naar voren wanneer u een klasse moet uitbreiden die meerdere constructors biedt die de klasse op verschillende manieren initialiseren. Zorg ervoor dat u Kotlin Inheritance controleert voordat u het leert.
Hier leest u hoe u een secundaire constructor in Kotlin kunt maken:
class Log (constructor (data: String) (// een code) constructor (data: String, numberOfData: Int) (// een code))
Hier heeft de Logklasse twee secundaire constructors, maar geen primaire constructor.
Je kunt de les uitbreiden als:
class Log (constructor (data: String) (// code) constructor (data: String, numberOfData: Int) (// code)) class AuthLog: Log (constructor (data: String): super (data) (// code ) constructor (data: String, numberOfData: Int): super (data, numberOfData) (// code))
Hier AuthLogroepen constructeurs van de afgeleide klasse de overeenkomstige constructor van de basisklasse aan Log. Daarvoor super()wordt gebruikt.
In Kotlin kun je ook een constructor aanroepen vanuit een andere constructor van dezelfde klasse (zoals in Java) met this().
class AuthLog: Log (constructor (data: String): deze (data, 10) (// code) constructor (data: String, numberOfData: Int): super (data, numberOfData) (// code))
Voorbeeld: Kotlin Secondary Constructor
fun main(args: Array) ( val p1 = AuthLog("Bad Password") ) open class Log ( var data: String = "" var numberOfData = 0 constructor(_data: String) ( ) constructor(_data: String, _numberOfData: Int) ( data = _data numberOfData = _numberOfData println("$data: $numberOfData times") ) ) class AuthLog: Log ( constructor(_data: String): this("From AuthLog -> " + _data, 10) ( ) constructor(_data: String, _numberOfData: Int): super(_data, _numberOfData) ( ) )
Wanneer u het programma uitvoert, is de uitvoer:
Van AuthLog -> Slecht wachtwoord: 10 keer
Opmerking: de secundaire constructor moet de basisklasse initialiseren of delegeren naar een andere constructor (zoals in het bovenstaande voorbeeld) als de klasse geen primaire constructor heeft.
