Kotlin Fundamentals en Android UI Interactie - Week 2 Studiekaarten 📘 THEORIE: Kotlin Fundamentals

Wat is een if statement in Kotlin?

Een if statement voert code uit als een conditie waar is.

if (conditie) {
    // code die uitgevoerd wordt als conditie waar is
}

Hoe werkt een if-else statement?

Een if-else statement voert één codeblok uit als de conditie waar is, en een ander codeblok als de conditie onwaar is.

if (conditie) {
    // code als conditie waar is
} else {
    // code als conditie onwaar is
}

Hoe gebruik je meerdere condities met if-elseif-else?

if (conditie1) {
    // code als conditie1 waar is
} else if (conditie2) {
    // code als conditie2 waar is
} else {
    // code als geen enkele conditie waar is
}

Wat is een when statement en hoe verschilt het van switch-case?

Een when statement is Kotlin's equivalent van switch-case, maar krachtiger:

• Geen break nodig (stopt automatisch na match)

• Meerdere condities mogelijk per case (gescheiden door komma)

• Kan gebruikt worden met 'in' en 'is' keywords

• Kan zonder parameter gebruikt worden voor complexe condities

when (x) {
    1 -> print("x is 1")
    2, 3 -> print("x is 2 of 3")
    in 4..10 -> print("x is tussen 4 en 10")
    is String -> print("x is een String")
    else -> print("x is iets anders")
}

Hoe gebruik je selecties als expressie in Kotlin?

In Kotlin kunnen if en when statements als expressies gebruikt worden om waarden toe te wijzen:

// if als expressie
val max = if (a > b) a else b

// when als expressie
val description = when (color) {
    Color.RED -> "warm"
    Color.BLUE -> "koud"
    else -> "neutraal"
}

Hoe werkt nullability in Kotlin?

• Standaard zijn variabelen in Kotlin niet-nullable

• Om een variabele nullable te maken, gebruik je het ? symbool

var nonNullable: String = "hello" // kan geen null zijn
var nullable: String? = "hello"   // kan null zijn
nullable = null                   // dit is toegestaan

Wat is de safe-call operator in Kotlin?

De safe-call operator ?. voert een operatie alleen uit als de variabele niet null is:

val name: String? = "Kotlin"
val length: Int? = name?.length // length is 6

val nullName: String? = null
val nullLength: Int? = nullName?.length // nullLength is null

Wat is de Elvis operator in Kotlin?

De Elvis operator ?: biedt een standaardwaarde wanneer een expressie null is:

val name: String? = null
val displayName = name ?: "Unknown" // displayName is "Unknown"

Wat is de not-null assertion operator in Kotlin?

De not-null assertion operator !! converteert een nullable type naar een niet-nullable type en gooit een NullPointerException als de waarde null is:

val name: String? = "Kotlin"
val length: Int = name!!.length // Werkt omdat name niet null is

val nullName: String? = null
val nullLength: Int = nullName!!.length // Gooit NullPointerException

Wat zijn smart casts in Kotlin?

Kotlin's compiler kan automatisch types casten na een null-check:

val name: String? = "Kotlin"
if (name != null) {
    // Compiler weet dat name hier niet null is
    println(name.length) // Geen safe call nodig
}

Wat zijn de drie hoofdonderdelen van een Kotlin class?

Properties (eigenschappen/variabelen)

Functions/Methods (functies/methodes)

Constructors (constructors)

class Person {
    // Properties
    var name: String = ""
    var age: Int = 0
    
    // Constructor
    constructor(name: String, age: Int) {
        this.name = name
        this.age = age
    }
    
    // Method
    fun introduce() {
        println("Hi, I'm $name and I'm $age years old")
    }
}

Hoe instantieer je een object in Kotlin?

In Kotlin gebruik je geen new keyword:

val person = Person("John", 25)

Hoe werken properties in Kotlin?

Properties worden gedefinieerd als variabelen binnen een klasse

Kotlin genereert automatisch getters en setters

Je kunt custom getters en setters definiëren:

class Battery {
    var percentage: Int = 100
        get() = field
        set(value) {
            field = if (value in 0..100) value else field
        }
}

Hoe werken constructors in Kotlin?

Kotlin heeft primaire en secundaire constructors:

Primaire constructor (in de class header):

class Person(val name: String, var age: Int)

Met init block (voor extra logica):

class Person(val name: String, var age: Int) {
    init {
        println("Person created with name $name")
    }
}

Secundaire constructor:

class Person(val name: String) {
    var age: Int = 0
    
    constructor(name: String, age: Int) : this(name) {
        this.age = age
    }
}

Hoe werkt overerving in Kotlin?

Klassen zijn standaard final (niet overerfbaar)

Gebruik open om overerving toe te staan

Gebruik override om methodes/properties te overschrijven

open class Animal {
    open fun makeSound() {
        println("Some generic sound")
    }
}

class Dog : Animal() {
    override fun makeSound() {
        println("Woof!")
    }
}

Welke visibility modifiers zijn er in Kotlin?

public (standaard): overal zichtbaar

private: alleen zichtbaar binnen dezelfde klasse of bestand

protected: zichtbaar in de klasse en subklassen

internal: zichtbaar binnen dezelfde module

class Example {
    public val a = 1       // overal zichtbaar
    private val b = 2      // alleen in deze klasse
    protected val c = 3    // in deze klasse en subklassen
    internal val d = 4     // binnen dezelfde module
}

Wat is compositie in Kotlin?

Compositie is een "heeft een" relatie tussen klassen, waarbij een klasse een instantie van een andere klasse bevat:

class Engine {
    fun start() {
        println("Engine started")
    }
}

class Car {
    private val engine = Engine() // Car heeft een Engine
    
    fun start() {
        engine.start()
        println("Car started")
    }
}

Wat zijn lambda expressions in Kotlin?

Lambda expressions zijn anonieme functies die als expressies kunnen worden gebruikt:

// Lambda syntax: { parameters -> body }
val sum = { a: Int, b: Int -> a + b }

// Lambda aanroepen
val result = sum(5, 3) // result = 8

// Lambda als parameter
val numbers = listOf(1, 2, 3, 4)
numbers.forEach { number -> println(number) }

// Verkorte notatie met 'it' voor één parameter
numbers.filter { it > 2 }

Wat is het it keyword in Kotlin lambdas?

it is een impliciet gegenereerde naam voor de enige parameter van een lambda:

// Met expliciete parameter
val numbers = listOf(1, 2, 3, 4)
numbers.filter { number -> number > 2 }

// Met 'it' keyword
numbers.filter { it > 2 }

Wat zijn higher-order functions in Kotlin?

Functies die andere functies als parameters accepteren of als resultaat teruggeven:

// Functie die een functie als parameter accepteert
fun calculate(a: Int, b: Int, operation: (Int, Int) -> Int): Int {
    return operation(a, b)
}

// Gebruik
val result = calculate(5, 3) { a, b -> a + b }

// Ingebouwde higher-order function: repeat
repeat(3) {
    println("Hello")
}

Hoe definieer je function types in Kotlin?

Function types worden gedefinieerd met de pijl-notatie:

// Functie type die twee Int parameters accepteert en een Int teruggeeft
val operation: (Int, Int) -> Int = { a, b -> a + b }

// Functie type zonder parameters die Unit teruggeeft
val action: () -> Unit = { println("Hello") }

// Functie type met één parameter die Boolean teruggeeft
val predicate: (Int) -> Boolean = { it > 0 }

Wat is trailing lambda syntax in Kotlin?

Als het laatste argument van een functie een functie is, kan deze buiten de haakjes worden geplaatst:

// Normale syntax
numbers.filter({ it > 2 })

// Trailing lambda syntax
numbers.filter { it > 2 }

// Met meerdere parameters
fun performOperation(a: Int, b: Int, operation: (Int, Int) -> Int): Int {
    return operation(a, b)
}

// Aanroepen met trailing lambda
performOperation(5, 3) { a, b -> a + b }

Welke veelgebruikte higher-order functions zijn er in Kotlin?

forEach: Voert een actie uit voor elk element

map: Transformeert elk element en geeft een nieuwe lijst terug

filter: Filtert elementen op basis van een conditie

reduce: Combineert alle elementen tot één resultaat

fold: Zoals reduce, maar met een startwaarde

any: Controleert of minstens één element voldoet aan een conditie

all: Controleert of alle elementen voldoen aan een conditie

val numbers = listOf(1, 2, 3, 4, 5)
numbers.forEach { println(it) }
val doubled = numbers.map { it * 2 }
val evens = numbers.filter { it % 2 == 0 }
val sum = numbers.reduce { acc, num -> acc + num }
val sumPlusTen = numbers.fold(10) { acc, num -> acc + num }

Hoe gebruik je function references in Kotlin?

Met de :: operator kun je verwijzen naar functies als waarden:

fun isEven(n: Int): Boolean = n % 2 == 0

// Functie referentie gebruiken
val numbers = listOf(1, 2, 3, 4, 5)
val evenNumbers = numbers.filter(::isEven)

// Methode referentie
class Person(val name: String) {
    fun isAdult(age: Int): Boolean = age >= 18
}
val person = Person("John")
val checkAdult = person::isAdult

Wat is property delegation in Kotlin?

Property delegation is een techniek waarbij je de getter en setter van een property delegeert aan een ander object:

class Example {
    var p: String by Delegate()
}

class Delegate {
    operator fun getValue(thisRef: Any?, property: KProperty<*>): String {
        return "$thisRef, thank you for delegating '${property.name}' to me!"
    }
    
    operator fun setValue(thisRef: Any?, property: KProperty<*>, value: String) {
        println("$value has been assigned to '${property.name}' in $thisRef.")
    }
}