streamalism.org

1. Inleiding

Kotlin leende veel ideeën uit andere talen; een van dergelijke constructies is de voorwerp.

In dit korte artikel zullen we zien wat objecten zijn en hoe ze kunnen worden gebruikt.

2. Objecten in Kotlin

In Kotlin, zoals in bijna alle JVM-talen, is er het concept van een klasse als de kern van het Object-Oriented Programming-model. Kotlin introduceert het concept van een voorwerp Daarbovenop.

Terwijl a klasse beschrijft structuren die kunnen worden geïnstantieerd als en wanneer gewenst en die zoveel instanties mogelijk maakt als nodig is, een voorwerp vertegenwoordigt in plaats daarvan een enkele statische instantie, en kan nooit meer of minder hebben dan deze ene instantie.

Dit is handig voor verschillende technieken, waaronder singleton-objecten en het eenvoudig verpakken van functionaliteit voor inkapseling:

object SimpleSingleton {val answer = 42; fun greet (name: String) = "Hallo, $ naam!" } assertEquals (42, SimpleSingleton.answer) assertEquals ("Hallo, wereld!", SimpleSingleton.greet ("wereld"))

Objecten bieden ook volledige ondersteuning voor zichtbaarheidsmodificatoren, waardoor gegevens kunnen worden verborgen en ingekapseld zoals bij elke andere klasse:

object Counter {private var count: Int = 0 fun currentCount () = count fun increment () {++ count}} Counter.increment () println (Counter.currentCount ()) println (Counter.count) // dit zal mislukken compileren

Daarnaast, objecten kunnen klassen uitbreiden en interfaces implementeren. Daarbij zijn het in feite singleton-instanties van bovenliggende klassen, precies zoals verwacht.

Dit kan erg handig zijn in gevallen waarin we een stateless implementatie hebben en het niet nodig is om elke keer een nieuwe instantie te maken, bijv. Comparator:

object ReverseStringComparator: Comparator {override fun Compare (o1: String, o2: String) = o1.reversed (). CompareTo (o2.reversed ())} val strings = listOf ("Hallo", "Wereld") val gesorteerdStrings = strings .sortedWith (ReverseStringComparator)

3. Wat is een begeleidend object?

Begeleidende objecten zijn in wezen hetzelfde als een standaard voorwerp definitie, alleen met een paar extra functies om de ontwikkeling gemakkelijker te maken.

Een begeleidend object wordt altijd binnen een andere klasse gedeclareerd. Hoewel het een naam kan hebben, hoeft het er geen te hebben, in dat geval heeft het automatisch de naam Metgezel:

class OuterClass {begeleidend object {// gelijk aan "begeleidend object Companion"}}

Met begeleidende objecten kunnen hun leden worden benaderd vanuit de begeleidende klasse zonder de naam op te geven.

Tegelijkertijd zijn zichtbare leden toegankelijk van buiten de klas wanneer ze worden voorafgegaan door de klassenaam:

class OuterClass {begeleidend object {privé val secret = "Je kunt me niet zien" val public = "Je kunt me zien"} fun getSecretValue () = geheim} assertEquals ("Je kunt me zien", OuterClass.public) assertEquals ( "Je kunt me niet zien", OuterClass.secret) // Geen toegang tot 'geheim'

4. Statische velden

Het belangrijkste gebruik voor begeleidende objecten is het vervangen van statische velden / methoden die bekend zijn uit Java. Deze velden worden echter niet automatisch als zodanig gegenereerd in het resulterende klassenbestand.

Als we ze nodig hebben om te worden gegenereerd, moeten we de @JvmStatic annotatie op het veld, die dan de bytecode zal genereren zoals verwacht:

class StaticClass {begeleidend object {@JvmStatic val staticField = 42}}

Zonder dit te doen, het statische veld staticField is niet gemakkelijk toegankelijk via Java-code.

Door deze annotatie toe te voegen, wordt het veld precies zo gegenereerd als nodig is voor een standaard statisch veld, waardoor volledige interoperabiliteit vanuit Java mogelijk is, indien nodig.

Dit betekent dat het bovenstaande een statisch methode getStaticField () op de StaticClass klasse.

5. Conclusie

Objecten in Kotlin voegen een hele extra laag toe die we kunnen gebruiken, waardoor onze code verder wordt gestroomlijnd en het gemakkelijker wordt om deze te ontwikkelen.

Companion-objecten gaan dan nog verder, waardoor schonere code mogelijk is die gemakkelijker te onderhouden en te gebruiken is.

Zoals altijd zijn codefragmenten te vinden op GitHub.