5 Grundlagen der Kotlin-Programmierung

5.1 Datentypen und Variablen in Kotlin

In Kotlin, wie in jeder anderen Programmiersprache, spielen Datentypen und Variablen eine zentrale Rolle. Sie ermöglichen es, Daten zu speichern und während der Laufzeit eines Programms darauf zuzugreifen. Kotlin hat sich darauf konzentriert, ein robustes Typensystem zu bieten, das sowohl leistungsfähig als auch benutzerfreundlich ist. Der folgende Artikel gibt einen Überblick über die verschiedenen Datentypen und die Handhabung von Variablen in Kotlin.

5.1.1 Grundlegende Datentypen

5.1.2 Unveränderliche und veränderliche Variablen

5.1.3 Typinferenz

5.1.4 Spezielle Datentypen

5.1.5 Null-Sicherheit

5.1.6 Smart Casts

Kotlin bietet ein umfangreiches und ausdrucksstarkes Typensystem, das sowohl die Sicherheit als auch die Benutzerfreundlichkeit erhöht. Durch die Kombination von Typinferenz, Null-Sicherheit und Smart Casts erleichtert Kotlin das Schreiben von sauberem und wartbarem Code.

5.2 Übungsaufgaben

5.2.1 Grundlegende Datentypen

  1. Deklariere jeweils eine Variable für jeden numerischen Typ (Int, Double, Float, Long, Short, Byte) und weise ihr einen geeigneten Wert zu.
  2. Deklariere eine Boolean-Variable isKotlinFun und weise ihr den Wert true zu.
  3. Deklariere eine Char-Variable firstLetter und weise ihr den Buchstaben ‘K’ zu.
  4. Deklariere eine String-Variable greeting und weise ihr den Wert “Hello, Kotlin!” zu.

5.2.2 Unveränderliche und veränderliche Variablen

  1. Deklariere eine unveränderliche Variable e vom Typ Double und weise ihr den Wert 2.71828 zu.
  2. Deklariere eine veränderliche Variable userCount vom Typ Int und initialisiere sie mit 1. Erhöhe dann ihren Wert um 1.

5.2.3 Typinferenz

  1. Deklariere eine Variable language ohne expliziten Typ und weise ihr den Wert “Kotlin” zu. Der Compiler soll den Typ inferieren.
  2. Deklariere eine Variable year ohne expliziten Typ und weise ihr den Wert 2021 zu. Der Compiler soll den Typ inferieren.

5.2.4 Spezielle Datentypen

  1. Erstelle ein Array colors mit den Werten “Rot”, “Grün”, “Blau”.
  2. Erstelle eine Liste primeNumbers mit den Werten 2, 3, 5, 7.

5.2.5 Null-Sicherheit

  1. Deklariere eine null-fähige Variable optionalText vom Typ String? und weise ihr zunächst null zu. Überprüfe dann, ob sie null ist, und weise ihr, falls ja, den Wert “Nicht null” zu.

5.2.6 Smart Casts

  1. Schreibe eine Funktion printLength, die einen Parameter obj vom Typ Any akzeptiert. Verwende is um zu überprüfen, ob obj ein String ist, und gib in diesem Fall die Länge des Strings aus.

5.3 Musterlösungen

5.3.1 Grundlegende Datentypen

val myInt: Int = 42
val myDouble: Double = 3.14
val myFloat: Float = 2.718F
val myLong: Long = 10000000000L
val myShort: Short = 5000
val myByte: Byte = 127
val isKotlinFun: Boolean = true
val firstLetter: Char = 'K'
val greeting: String = "Hello, Kotlin!"

5.3.2 Unveränderliche und veränderliche Variablen

val e: Double = 2.71828
var userCount: Int = 1
userCount += 1

5.3.3 Typinferenz

val language = "Kotlin"
val year = 2021

5.3.4 Spezielle Datentypen

val colors: Array<String> = arrayOf("Rot", "Grün", "Blau")
val primeNumbers: List<Int> = listOf(2, 3, 5, 7)

5.3.5 Null-Sicherheit

var optionalText: String? = null
if (optionalText == null) optionalText = "Nicht null"
println(optionalText)

5.3.6 Smart Casts

fun printLength(obj: Any) {
    if (obj is String) {
        println(obj.length)
    }
}

5.4 Kontrollstrukturen in Kotlin: if, when, for, while

Kontrollstrukturen sind grundlegende Bausteine jeder Programmiersprache, die den Fluss der Ausführung steuern. Kotlin bietet eine Vielzahl von Kontrollstrukturen, die die Erstellung flexibler und effizienter Programme ermöglichen. In diesem Artikel werden die Kontrollstrukturen if, when, for und while in Kotlin detailliert besprochen.

5.4.1 if-Anweisung

5.4.2 when-Anweisung

5.4.3 for-Schleife

5.4.4 while- und do-while-Schleifen

Kontrollstrukturen in Kotlin sind flexibel und leistungsfähig. Sie bieten Entwicklern eine breite Palette an Möglichkeiten, den Programmfluss zu steuern. Die intuitive Syntax und Vielseitigkeit von Strukturen wie when und Bereichsoperatoren in for-Schleifen machen Kotlin zu einer effizienten und angenehmen Sprache für die Programmierung.

5.5 Übungsaufgaben

5.5.1 if-Anweisung

  1. Schreibe eine if-else-Anweisung, die überprüft, ob eine Variable age größer oder gleich 18 ist. Gib “Volljährig” aus, wenn dies zutrifft, andernfalls “Minderjährig”.
  2. Verwende if als Ausdruck, um den größeren Wert zweier Variablen a und b zu bestimmen und in einer Variable max zu speichern.

5.5.2 when-Anweisung

  1. Verwende eine when-Anweisung, um zu überprüfen, ob eine Variable number positiv, negativ oder null ist. Gib entsprechend “Positiv”, “Negativ” oder “Null” aus.
  2. Schreibe eine when-Anweisung, die basierend auf dem Wert einer Variable month den Namen der Jahreszeit ausgibt. Berücksichtige dabei mindestens vier verschiedene Fälle.

5.5.3 for-Schleife

  1. Verwende eine for-Schleife, um die Zahlen von 1 bis 5 auszugeben.
  2. Schreibe eine for-Schleife, die über ein Array von Strings iteriert und jeden String in Großbuchstaben ausgibt.

5.5.4 while- und do-while-Schleifen

  1. Verwende eine while-Schleife, um die Zahlen von 10 herunterzuzählen bis 1 und dann “Start!” auszugeben.
  2. Schreibe eine do-while-Schleife, die eine Variable n von 1 beginnend solange um 1 erhöht, bis n größer als 5 ist. Gib den Wert von n nach jeder Erhöhung aus.

5.6 Musterlösungen

5.6.1 if-Anweisung

val age = 17
if (age >= 18) {
    println("Volljährig")
} else {
    println("Minderjährig")
}

val a = 10
val b = 20
val max = if (a > b) a else b
println(max)

5.6.2 when-Anweisung

val number = -5
when {
    number > 0 -> println("Positiv")
    number < 0 -> println("Negativ")
    else -> println("Null")
}

val month = 4
when (month) {
    12, 1, 2 -> println("Winter")
    3, 4, 5 -> println("Frühling")
    6, 7, 8 -> println("Sommer")
    9, 10, 11 -> println("Herbst")
    else -> println("Ungültiger Monat")
}

5.6.3 for-Schleife

for (i in 1..5) {
    println(i)
}

val fruits = arrayOf("Apfel", "Banane", "Kirsche")
for (fruit in fruits) {
    println(fruit.toUpperCase())
}

5.6.4 while- und do-while-Schleifen

var countdown = 10
while (countdown > 0) {
    println(countdown)
    countdown--
}
println("Start!")

var n = 1
do {
    println(n)
    n++
} while (n <= 5)

5.7 Funktionen in Kotlin: Definition, Parameter, Rückgabewerte und Named-Parameter

Funktionen sind ein zentraler Bestandteil der Kotlin-Programmierung. Sie ermöglichen die Strukturierung des Codes in wiederverwendbare Einheiten. Dieser Artikel behandelt die Definition von Funktionen, die Handhabung von Parametern, Rückgabewerten und die Verwendung von Named-Parametern in Kotlin.

5.7.1 Funktionen definieren

5.7.2 Parameter in Funktionen

5.7.3 Rückgabewerte

5.7.4 Named-Parameter

5.7.5 Überladen von Funktionen

Funktionen in Kotlin bieten eine flexible Syntax und eine Reihe nützlicher Features wie Standard- und Named-Parameter. Durch diese Eigenschaften unterstützt Kotlin eine klare und präzise Codierung, die die Lesbarkeit und Wartbarkeit des Codes fördert. Mit der Möglichkeit, Funktionen zu überladen und Ausdrucks-Körper-Funktionen zu verwenden, bietet Kotlin Entwicklern die Werkzeuge, um effizient und effektiv zu programmieren.

5.8 Übungsaufgaben

5.8.1 Funktionen definieren

  1. Definiere eine Funktion square, die einen Int-Parameter number nimmt und sein Quadrat zurückgibt.
  2. Erstelle eine Funktion isEven, die prüft, ob eine gegebene Zahl n gerade ist, und einen Boolean-Wert zurückgibt.

5.8.2 Parameter in Funktionen

  1. Definiere eine Funktion printDetails, die drei Parameter hat: name (String), age (Int) und city (String), wobei city einen Standardwert “Unbekannt” hat.
  2. Schreibe eine Funktion calculateArea, die die Fläche eines Rechtecks berechnet. Sie soll zwei Int-Parameter haben: width und height, und die Fläche zurückgeben.

5.8.3 Rückgabewerte

  1. Definiere eine Funktion greetUser, die einen String-Parameter name nimmt und einen Gruß in Form eines Strings zurückgibt. Verwende dabei einen Ausdrucks-Körper.
  2. Schreibe eine Funktion maxValue, die zwei Int-Werte a und b nimmt und den größeren Wert zurückgibt. Verwende eine if-Anweisung im Ausdruckskörper.

5.8.4 Named-Parameter

  1. Rufe die Funktion printDetails mit Named-Parametern auf, und gib dabei für name “John”, für age 30 und für city “New York” an.
  2. Verwende Named-Parameter, um die Funktion calculateArea aufzurufen, wobei width 5 und height 10 sein sollen.

5.8.5 Überladen von Funktionen

  1. Überlade die Funktion greetUser, sodass sie einen zusätzlichen Parameter timeOfDay (String) mit den möglichen Werten “morning”, “afternoon”, “evening” nimmt. Basierend auf timeOfDay soll der Gruß angepasst werden.

5.9 Musterlösungen

5.9.1 Funktionen definieren

fun square(number: Int): Int = number * number

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

5.9.2 Parameter in Funktionen

fun printDetails(name: String, age: Int, city: String = "Unbekannt") {
    println("Name: $name, Alter: $age, Stadt: $city")
}

fun calculateArea(width: Int, height: Int): Int = width * height

5.9.3 Rückgabewerte

fun greetUser(name: String): String = "Hallo, $name!"

fun maxValue(a: Int, b: Int): Int = if (a > b) a else b

5.9.4 Named-Parameter

printDetails(name = "John", age = 30, city = "New York")

calculateArea(width = 5, height = 10)

5.9.5 Überladen von Funktionen

fun greetUser(name: String, timeOfDay: String): String {
    val greeting = when (timeOfDay) {
        "morning" -> "Guten Morgen"
        "afternoon" -> "Guten Tag"
        "evening" -> "Guten Abend"
        else -> "Hallo"
    }
    return "$greeting, $name!"
}

5.10 Klassen und Objekte: Grundkonzepte der Objektorientierung in Kotlin

Kotlin, eine moderne und leistungsfähige Programmiersprache, bietet umfassende Unterstützung für die objektorientierte Programmierung (OOP). Die Konzepte von Klassen und Objekten sind zentral in Kotlin, ähnlich wie in anderen OOP-Sprachen. Dieser Artikel befasst sich mit den Grundlagen von Klassen und Objekten in Kotlin, einschließlich Klassendefinitionen, Objekterzeugung und wichtigen OOP-Prinzipien.

5.10.1 Klassendefinition

5.10.2 Konstruktoren

5.10.3 Erzeugung von Objekten

5.10.4 Vererbung

5.10.5 Schnittstellen

5.10.6 Datenklassen

5.10.7 Objekte und Begleiterobjekte

Die objektorientierten Konzepte in Kotlin bieten eine umfassende und flexible Grundlage für die Entwicklung von Software. Durch das Verständnis von Klassen, Objekten, Vererbung, Schnittstellen und Datenklassen können Entwickler effiziente und gut strukturierte Programme erstellen. Kotlin vereinfacht dabei einige der komplexeren Aspekte der OOP und macht sie zugänglicher und leichter verständlich.

5.11 Übungsaufgaben

5.11.1 Klassendefinition

  1. Definiere eine Klasse Book mit zwei Eigenschaften: title (String) und author (String).

5.11.2 Konstruktoren

  1. Erstelle eine Klasse Rectangle mit zwei Eigenschaften: width und height (beide vom Typ Int). Definiere einen Primärkonstruktor, der beide Eigenschaften initialisiert.

5.11.3 Erzeugung von Objekten

  1. Instanziiere ein Objekt der Klasse Book mit dem Titel “Kotlin for Beginners” und dem Autor “Jane Doe”.

5.11.4 Vererbung

  1. Definiere eine Basisklasse Vehicle mit einer Methode drive(), die “Driving” ausgibt. Erstelle eine abgeleitete Klasse Car und überschreibe die drive-Methode mit der Ausgabe “Car driving”.

5.11.5 Schnittstellen

  1. Definiere eine Schnittstelle Clickable mit einer Methode click(). Implementiere diese Schnittstelle in einer Klasse Button, die bei Aufruf von click() “Button clicked” ausgibt.

5.11.6 Datenklassen

  1. Definiere eine Datenklasse Contact mit zwei Eigenschaften: name (String) und phoneNumber (String).

5.11.7 Objekte und Begleiterobjekte

  1. Erstelle ein Singleton-Objekt Database mit einer Methode connect(), die “Connected to database” ausgibt.
  2. Füge der Klasse Book ein Begleiterobjekt hinzu, das eine Methode createTestBook() hat, welche ein Book-Objekt mit vordefinierten Werten zurückgibt.

5.12 Musterlösungen

5.12.1 Klassendefinition

class Book(val title: String, val author: String)

5.12.2 Konstruktoren

class Rectangle(val width: Int, val height: Int)

5.12.3 Erzeugung von Objekten

val book = Book("Kotlin for Beginners", "Jane Doe")

5.12.4 Vererbung

open class Vehicle {
    open fun drive() {
        println("Driving")
    }
}

class Car : Vehicle() {
    override fun drive() {
        println("Car driving")
    }
}

5.12.5 Schnittstellen

interface Clickable {
    fun click()
}

class Button : Clickable {
    override fun click() {
        println("Button clicked")
    }
}

5.12.6 Datenklassen

data class Contact(val name: String, val phoneNumber: String)

5.12.7 Objekte und Begleiterobjekte

object Database {
    fun connect() {
        println("Connected to database")
    }
}

class Book(val title: String, val author: String) {
    companion object {
        fun createTestBook(): Book = Book("Default Title", "Default Author")
    }
}