Kotlin const, var en val Trefwoorden

1. Inleiding

In deze tutorial zullen we dat zijn waarin de belangrijkste verschillen tussen de const, var, en val trefwoorden in de Kotlin-taal.

Om deze zoekwoorden in context te plaatsen, zullen we dat zijn door ze te vergelijken met hun Java-equivalenten.

2. Inzicht in typen

Om deze sleutelwoorden te begrijpen, moeten we twee van de belangrijkste categorieën typesystemen begrijpen die een taal kan volgen: manifest typen en afgeleid typen.

2.1. Manifest typen

Alle talen bieden een reeks primitieve gegevenstypen om gegevens in een programma op te slaan en te manipuleren. Programmeertalen die de discipline voor het typen van manifesten volgen, moeten hun gegevenstypen expliciet binnen het programma hebben gedefinieerd.

Java volgt tot en met versie 10 strikt deze discipline. Als we bijvoorbeeld een nummer binnen een programma willen opslaan, moeten we een gegevenstype definiëren, zoals int:

int myVariable = 3;

2.2. Afgeleide typen

In tegenstelling tot Java, Kotlin volgt de afgeleide typediscipline. Talen die type-inferentie ondersteunen detecteert automatisch gegevenstypen binnen het programma tijdens het compileren.

Deze detectie betekent dat wij, als ontwikkelaars, geen zorgen hoeven te maken over de gegevenstypen die we gebruiken.

3. var

Ten eerste beginnen we met var, Het sleutelwoord van Kotlin dat veranderlijke, niet-definitieve variabelen vertegenwoordigt. Eenmaal geïnitialiseerd, zijn we vrij om de gegevens van de variabele te muteren.

Laten we eens kijken hoe dit werkt:

var myVariable = 1

Achter de schermen, myVariable initialiseert met de Int data type.

Hoewel Kotlin type-inferentie gebruikt, zijn we hebben ook de mogelijkheid om het datatype te specificeren wanneer we de variabele initialiseren:

var myVariable: Int = 1

Variabelen die zijn gedeclareerd als één gegevenstype en vervolgens worden geïnitialiseerd met een waarde van het verkeerde type, zullen resulteren in een fout:

var myVariable: Int = b // FOUT!

4. val

Kotlin's val trefwoord werkt veel in de hetzelfde als de var trefwoord, maar met één belangrijk verschil: de variabele is alleen-lezen. Het gebruik van val is net zoals het declareren van een nieuwe variabele in Java met de laatste trefwoord.

In Kotlin zouden we bijvoorbeeld schrijven:

val name: String = "Baeldung"

Terwijl we in Java zouden schrijven:

final String name = "Baeldung";

Net als een laatste variabele in Java, een val variabele in Kotlin moet een waarde krijgen zoals deze is gedeclareerd, of in een Klasse constructeur:

class Address (val street: String) {val name: String = "Baeldung"}

5. const

Leuk vinden val, variabelen gedefinieerd met de const trefwoord zijn onveranderlijk. Het verschil hier is datconst wordt gebruikt voor variabelen die tijdens het compileren bekend zijn.

Een variabele declareren const lijkt veel op het gebruik van de statisch trefwoord in Java.

Laten we eens kijken hoe we een const variabele in Kotlin:

const val WEBSITE_NAME = "Baeldung"

En de analoge code die in Java is geschreven, zou zijn:

final static String WEBSITE_NAME = "Baeldung";

5.1. Constante voering

Vanaf Kotlin 1.1 integreert de Kotlin-compiler het const val waarden naar de locaties waar ze worden gebruikt. Laten we bijvoorbeeld een eenvoudig voorbeeld bekijken:

const val VALUE: String = "constant" fun main () {println ("$ VALUE is inline")}

Op het eerste gezicht zouden we kunnen denken dat de Kotlin-compiler een statische veldwaarde van een klasse krijgt en deze vervolgens samenvoegt met de "Is inline" tekst. Echter, sinds const vals zijn inline, zal de compiler de "constante" letterlijk waar de WAARDE constant wordt gebruikt. Deze constante inlining is veel efficiënter dan het verkrijgen van een statische waarde uit een klasse.

Om te controleren of de inlining daadwerkelijk onder de motorkap gebeurt, kunnen we de bytecode bekijken. Ten eerste moeten we het Kotlin-bestand compileren met kotlinc:

$ kotlinc Main.kt

Gebruik vervolgens javapkunnen we een kijkje nemen in de gegenereerde bytecode:

$ javap -c -p -v MainKt // afgekapt 0: ldc # 16 // Stringconstante is inline 2: astore_0 3: iconst_0 4: istore_1 5: getstatic # 22 // Field java / lang / System.out: Ljava / io / PrintStream; 8: aload_0 9: invokevirtual # 28 // Method java / io / PrintStream.println: (Ljava / lang / Object;) V 12: return

Zoals hierboven getoond, bij index 0, de "constante" letterlijk wordt gekopieerd voor aaneenschakeling. Dus er is geen getstatisch om een ​​waarde op te halen uit een statisch veld in een klasse.

Waar het op neerkomt is dat hoewel de const vals kunnen eruit zien als statische velden, ze zijn niet geïmplementeerd als openbare statische finale velden. Simpel gezegd, de const val is slechts een illusie van een compiler.

6. Conclusie

In dit artikel hebben we kort gekeken naar het verschil tussen manifest en afgeleid typen.

Vervolgens keken we naar het verschil tussen Kotlin's var,val, en const trefwoorden.