I den här artikeln lär du dig om konstruktörer i Kotlin (både primära och sekundära konstruktörer) samt initialiseringsblock med hjälp av exempel.
En konstruktör är ett koncist sätt att initiera klassegenskaper.
Det är en speciell medlemsfunktion som anropas när ett objekt instantieras (skapas). Hur de fungerar i Kotlin är dock lite annorlunda.
I Kotlin finns det två konstruktörer:
- Primär konstruktör - kortfattat sätt att initiera en klass
- Sekundär konstruktör - låter dig sätta ytterligare initialiseringslogik
Primär konstruktör
Den primära konstruktören är en del av klassrubriken. Här är ett exempel:
klass Person (val firstName: String, var age: Int) (// class body)
Kodblocket omgiven av parenteser är den primära bygga: (val firstName: String, var age: Int).
Konstruktören förklarade två egenskaper: firstName(skrivskyddad egenskap som deklareras med hjälp av nyckelord val) och age(läs-skriv-egenskap som deklareras med nyckelord var).
Exempel: Primär konstruktör
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) ( )
När du kör programmet blir resultatet:
Förnamn = Joe Ålder = 25
När klassobjektet Personskapas "Joe"och 25värden skickas som om det Personär en funktion.
Detta initierar firstNameoch ageegenskaper hos person1 invända mot "Joe"och 25respektive.
Det finns andra sätt att använda primära konstruktörer.
Primära konstruktions- och initialiseringsblock
Den primära konstruktören har en begränsad syntax och kan inte innehålla någon kod.
För att sätta initieringskoden (inte bara kod för att initiera egenskaper) används initialiseringsblock. Det är prefix med initnyckelord. Låt oss ändra exemplet ovan med initialiseringsblock:
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") ) )
När du kör programmet blir resultatet:
First Name = Joe Age = 25
Här parametrar FNAME och personlighet inuti parentes accepterar värden "Joe"och 25respektive när person1 objekt skapas. Emellertid används fName och personAge utan att använda vareller valär inte Personklassens egenskaper .
Den Personklassen har två fastigheter firstname och ålder deklareras.
När person1objekt skapas körs kod inuti initialiseringsblocket. Initieringsblocket initialiserar inte bara dess egenskaper utan skriver också ut dem.
Här är ett annat sätt att utföra samma uppgift:
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") ) )
För att skilja konstruktörsparametern och egenskapen används olika namn (fName och firstName, och personAge and age). Det är vanligare att använda _firstName och _age istället för ett helt annat namn för konstruktörsparametrar. Till exempel:
klass Person (_firstName: String, _age: Int) (val firstName = _firstName.capitalize () var age = _age // initializer block init (…))
Standardvärde i primär konstruktör
Du kan tillhandahålla standardvärde för konstruktörsparametrar (liknande att tillhandahålla standardargument till funktioner). Till exempel:
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") ) )
När du kör programmet blir resultatet:
Förnamn = Joe Ålder = 25 person2 är instantierad Förnamn = Jack Ålder = 0 person3 är instantierad Förnamn = Okänd Ålder = 0
Kotlin Secondary Constructor
I Kotlin kan en klass också innehålla en eller flera sekundära konstruktörer. De skapas med hjälp av constructornyckelord.
Sekundära konstruktörer är inte så vanliga i Kotlin. Den vanligaste användningen av sekundär konstruktör uppstår när du behöver utöka en klass som tillhandahåller flera konstruktörer som initierar klassen på olika sätt. Var noga med att kontrollera Kotlin Inheritance innan du lär dig det.
Så här kan du skapa en sekundär konstruktör i Kotlin:
class Log (constructor (data: String) (// some code) constructor (data: String, numberOfData: Int) (// some code))
Här har Logklassen två sekundära konstruktörer, men ingen primär konstruktör.
Du kan utöka klassen som:
klass Logg (constructor (data: String) (// code) constructor (data: String, numberOfData: Int) (// code)) class AuthLog: Log (constructor (data: String): super (data) (// code ) konstruktör (data: String, numberOfData: Int): super (data, numberOfData) (// code))
Här AuthLogkallar konstruktörer av den härledda klassen motsvarande konstruktör för basklassen Log. För det super()används.
I Kotlin kan du också ringa en konstruktör från en annan konstruktör i samma klass (som i Java) med this().
class AuthLog: Log (constructor (data: String): this (data, 10) (// code) constructor (data: String, numberOfData: Int): super (data, numberOfData) (// code))
Exempel: 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) ( ) )
När du kör programmet blir resultatet:
Från AuthLog -> Dåligt lösenord: 10 gånger
Obs! Den sekundära konstruktören måste initiera basklassen eller delegera till en annan konstruktör (som i exemplet ovan) om klassen inte har någon primär konstruktör.
