streamalism.org

1. Overzicht

In deze tutorial zullen we constructeurs in Kotlin grondig bekijken.

Laten we beginnen met een korte samenvatting van het concept: we gebruiken constructors om objecten te maken. Deze zien eruit als methode-declaraties, maar hebben altijd dezelfde naam als de klasse en geven niets terug.

Bekijk onze inleidende tutorial voor het opzetten van een Kotlin-project.

In Kotlin kan een klasse een primaire constructor en een of meer aanvullende secundaire constructors hebben.

In de volgende secties zullen we elk type en de bijbehorende concepten bespreken.

2. Primaire constructor

De eerste manier om een ​​object in Kotlin te maken, is door een primaire constructor te gebruiken.

Dit is een onderdeel van de koptekst van de klas. Parameters kunnen ook klassevelden zijn, die we achter de klassendeclaratie plaatsen.

Laten we eens kijken naar een basisklasse-declaratie, met twee eigenschappen en een primaire constructor:

class Person constructor (val naam: String, val leeftijd: Int? = null)

In dit voorbeeld hebben we eigenschappen gedeclareerd via de val trefwoord. Dit gedraagt ​​zich op dezelfde manier als gewone variabelen, met de vermelding dat val eigenschappen zijn alleen-lezen (Java laatste trefwoord tegenhanger).

Als we de referentie later willen wijzigen, moeten we de var trefwoord in plaats daarvan. We kunnen het type veld echter niet weglaten in de primaire constructor, aangezien dit expliciet moet zijn.

In sommige gevallen kunnen we de constructeur trefwoord. Dit is slechts in twee gevallen verplicht: wanneer we annotaties gebruiken, zoals @Autowired of toegang tot modificatoren, zoals privaat of beschermd.

We kunnen ook de standaardparameters van Kotlin in de constructors gebruiken.

Laten we vervolgens kijken hoe we onze primaire constructor kunnen gebruiken:

val person = Persoon ("Jan") val personWithAge = Persoon ("Mark", 22)

Dat kunnen we zien een klassenaam is een constructoraanroep. Het is niet nodig om de nieuw trefwoord.

Laten we ter referentie ook eens kijken naar het Java-equivalent van een constructor-declaratie:

class PersonJava {laatste String naam; uiteindelijke Integer-leeftijd; openbare PersonJava (String naam) {this.name = naam; this.age = null; } public PersonJava (String naam, Integer leeftijd) {this.name = naam; this.age = leeftijd; }}

Zoals u kunt zien, heeft Java veel meer code nodig om hetzelfde resultaat te bereiken.

2.1. Primaire constructeurs op de JVM

Houd er rekening mee dat de compiler een extra constructor zonder parameters op de JVM zal genereren. Voor dit doel zal het een object instantiëren met standaardwaarden.

Op deze manier kan Kotlin goed werken met bibliotheken als Jackson of JPA, die de constructor no-args gebruiken om klasse-instanties te maken:

class Person (val name: String = "")

3. Initialiseren van eigenschappen van constructorparameters

Initializers voor eigenschappen van de hoofdtekst van de klasse kunnen de primaire constructorparameters gebruiken.

Laten we transformeren naam naar de upperCaseName eigendom:

class Person (val name: String, val age: Int? = null) {val upperCaseName: String = name.toUpperCase ()}

We kunnen de uitvoer in de console zien door de tweede toe te voegen in het blok:

init {println ("Naam in hoofdletters is $ upperCaseName")}

4. Initialisatieblokken

We kunnen geen code in de primaire constructor plaatsen.

Soms moeten we echter een initialisatiecode uitvoeren. Een goede plaats hiervoor is een initialisatieblok, dat wordt voorafgegaan door de in het trefwoord.

Het initialisatieblok wordt genoemd naar de primaire constructor. We hebben op deze plek ook toegang tot klassevelden.

Een klas kan er een of meer hebben in het blokken.

Laten we het initialisatieblok toevoegen aan ons Persoon klasse:

init {println ("Hallo, ik ben $ naam") if (achternaam.isEmpty ()) {throw IllegalArgumentException ("Achternaam mag niet leeg zijn!")}}

Vervolgens, wanneer we een Persoon class-object, we zullen zien in de console:

Hallo, ik ben John

We zouden gooien IllegalArgumentException voor de lege achternaam.

Als we er veel hebben in het blokken, worden ze uitgevoerd in dezelfde volgorde als ze verschijnen in de hoofdtekst van de klas.

5. Secundaire constructor

In een Kotlin-klasse kunnen we ook een of meer secundaire constructors declareren.Secundaire constructors worden voorafgegaan door de constructeur trefwoord:

class Car {val id: String val type: String constructor (id: String, type: String) {this.id = id this.type = type}}

En het basisgebruik:

fun main (args: Array) {val car = Car ("1", "sport") val suvCar = Car ("2", "suvCar")} 

Elke secundaire constructor moet delegeren naar de primaire constructor. We doen dit door dit trefwoord.

Laten we onze eigendommen verplaatsen naar het primaire constructor en wijzigen secundaire constructor:

class Car (val id: String, val type: String) {constructor (id: String): this (id, "unknown")}

6. Constructeurs en erfenis

We kunnen een primaire constructor van de superklasse gebruiken.

Merk op dat alle klassen in Kotlin laatste standaard. Dit betekent dat we de Open trefwoord zodat we kunnen erven van onze Persoon klasse.

Laten we een Werknemer klasse die erft van de Persoon klasse. Ze gebruiken allebei primaire constructors:

klasse Medewerker (naam: String, val salaris: Int): Persoon (naam) 

Door dit te doen, passeren we een naam naar de primaire constructor van Persoon klasse. Bovendien voegen we een nieuw veld toe met de naam salaris in de Werknemer klasse.

7. Conclusie

In dit korte artikel hebben we verschillende manieren besproken om constructeurs in de Kotlin-taal te maken. We kunnen onze velden op veel verschillende manieren concretiseren, volgens onze wensen.

De implementatie van al onze voorbeelden is te vinden in het Github-project.

Voor meer informatie over de functies van Kotlin zelf, bekijk dan onze inleiding tot Kotlin.