Kotlin
Idioms

DTO's (POJO's / POCO's) maken

Dataklassen in Kotlin zijn klassen die zijn gemaakt om alleen maar gegevens te bewaren. Dergelijke klassen zijn gemarkeerd als data :

data class User(var firstname: String, var lastname: String, var age: Int)

De bovenstaande code maakt een User met de volgende automatisch gegenereerde:

• Getters en Setters voor alle eigenschappen (getters alleen voor val s)
• equals()
• hashcode()
• toString()
• copy()
• componentN() (waar N de overeenkomstige eigenschap is in volgorde van aangifte)

Net als bij een functie kunnen ook standaardwaarden worden opgegeven:

data class User(var firstname: String = "Joe", var lastname: String = "Bloggs", var age: Int = 20)

Meer details vindt u hier Gegevensklassen .

Een lijst filteren

val list = listOf(1,2,3,4,5,6)

//filter out even numbers

val even = list.filter { it % 2 == 0 }

println(even) //returns [2,4]

Gedelegeerd aan een klasse zonder deze in de openbare constructor op te geven

Stel dat u wilt delegeren naar een klasse, maar u wilt de gedelegeerde klasse niet opgeven in de constructorparameter. In plaats daarvan wilt u het privé construeren, waardoor de constructor-beller zich hiervan niet bewust is. In eerste instantie lijkt dit misschien onmogelijk omdat klassedelegatie het mogelijk maakt alleen te delegeren naar constructorparameters. Er is echter een manier om dit te doen, zoals in dit antwoord wordt gegeven :

class MyTable private constructor(table: Table<Int, Int, Int>) : Table<Int, Int, Int> by table {

    constructor() : this(TreeBasedTable.create()) // or a different type of table if desired

}

Hiermee kun je de constructor van MyTable gewoon zo aanroepen: MyTable() . De Table<Int, Int, Int> waaraan MyTable afgevaardigden privé worden gemaakt. Constructor beller weet er niets van.

Dit voorbeeld is gebaseerd op deze SO-vraag .

Serialiseerbaar en serialVersionUid in Kotlin

Om de serialVersionUID voor een klasse in Kotlin te maken, hebt u een paar opties die allemaal betrekking hebben op het toevoegen van een lid aan het bijbehorende object van de klasse.

De meest beknopte bytecode komt van een private const val die een private statische variabele van de betreffende klasse wordt, in dit geval MySpecialCase :

class MySpecialCase : Serializable {
    companion object {
        private const val serialVersionUID: Long = 123
    }
}

U kunt deze formulieren ook gebruiken, elk met een bijwerking van getter / setter-methoden die niet nodig zijn voor serialisatie ...

class MySpecialCase : Serializable {
    companion object {
        private val serialVersionUID: Long = 123
    }
}

Dit creëert het statische veld, maar creëert ook een getter en ook getSerialVersionUID op het getSerialVersionUID object dat onnodig is.

class MySpecialCase : Serializable {
    companion object {
        @JvmStatic private val serialVersionUID: Long = 123
    }
}  

Dit creëert het statische veld maar creëert ook een statische getter en ook getSerialVersionUID op de bevattende klasse MySpecialCase wat overbodig is.

Maar alle werken als een methode om de serialVersionUID te voegen aan een Serializable klasse.

Vloeiende methoden in Kotlin

Vloeiende methoden in Kotlin kunnen hetzelfde zijn als Java:

fun doSomething() {
   someOtherAction()
   return this
}

Maar u kunt ze ook functioneler maken door een uitbreidingsfunctie te maken zoals:

fun <T: Any> T.fluently(func: ()->Unit): T {
    func()
    return this
}

Wat dan duidelijker vloeiende functies mogelijk maakt:

fun doSomething() {
   return fluently { someOtherAction() }
}

Gebruik let of ook om het werken met nulbare objecten te vereenvoudigen

let in Kotlin creëert een lokale binding van het object waarop het werd opgeroepen. Voorbeeld:

val str = "foo"
str.let {
    println(it) // it
}  

Hiermee wordt "foo" afgedrukt en wordt Unit geretourneerd.

Het verschil tussen let en also is dat u elke waarde uit een let blok kunt retourneren. also in de andere hand zal altijd reutrn Unit .

Waarom vraagt u dit nu? Omdat als je een methode aanroept die null kan retourneren en je alleen code wilt uitvoeren wanneer die retourwaarde niet null je let of also zo kunt gebruiken:

val str: String? = someFun()
str?.let {
    println(it)
}

Dit stuk code voert het let blok alleen uit als str niet null . Let op de null ( ? ).

Gebruik toepassen om objecten te initialiseren of method chaining te bereiken

De documentatie van apply zegt het volgende:

roept het opgegeven functieblok op met this waarde als ontvanger en retourneert this waarde.

Hoewel de kdoc niet zo nuttig is, is apply inderdaad een nuttige functie. In lekentaal apply wordt een scope waarin this is gebonden aan het object dat u opgeroepen apply op. Dit stelt u in staat om wat code te sparen wanneer u meerdere methoden op een object moet aanroepen die u later terug zult keren. Voorbeeld:

File(dir).apply { mkdirs() }

Dit is hetzelfde als dit schrijven:

fun makeDir(String path): File {
    val result = new File(path)
    result.mkdirs()
    return result
}