Der beste Weg, eine Sprache zu verstehen, ist, Code darin zu schreiben. Nicht darüber lesen, keine Webinare schauen, keine Artikel als „später lesen" speichern (wir wissen alle, wie das endet). Kotlin von Null: Tutorial für Einsteiger - 1IDE öffnen und etwas bauen, das tatsächlich funktioniert.

Genau dafür ist dieses Tutorial. Wir gehen von null bis zur ersten funktionierenden Mini-App. Wer Java kennt, kommt noch schneller voran — ich ziehe die ganze Zeit Parallelen.

Kotlin starten: zwei Wege, einer dauert null Minuten

Direkt im Browser. Geh auf play.kotlinlang.org und fang einfach an. Nichts installieren, nichts konfigurieren, keine Stack-Overflow-Kaninchenlöcher, warum das Setup nicht klappt. Perfekt für den ersten Eindruck.

In IntelliJ IDEA. Kotlin-Unterstützung ist eingebaut. Neues Kotlin-Projekt erstellen — und fertig. Keine Plugins, kein Aufwand.

Dein erstes Programm:

fun main() {
    println("Hello, Kotlin!")
}

In Java sieht dasselbe so aus:

public class Main {
    public static void main(String[] args) {
        System.out.println("Hello, Kotlin!");
    }
}

Beide machen exakt dasselbe. Kotlin hat nur kein public static void und keine Wrapper-Klasse — weil... warum brauchten wir die eigentlich? Gute Frage. Java hat sie nie wirklich beantwortet.

val und var: zwei Wörter, die du dir merken musst

In Kotlin werden Variablen mit val oder var deklariert.

val name = "Alice"   // Unveränderlich. Wie final in Java.
var age = 25         // Veränderlich.

age = 26             // Okay.
name = "Bob"         // Compilerfehler.
Kotlin

Einfache Regel: Nutze val überall, wo der Wert nicht geändert werden muss. var nur, wenn du wirklich eine Mutation brauchst. Es ist wie ein Versprechen an dich selbst: „Das werde ich nicht ändern." Und Kotlin sorgt dafür, dass du es einhältst.

Den Typ musst du nicht angeben — Kotlin leitet ihn ab:

val score = 100     // Kotlin erkennt: das ist ein Int
val name = "Alice"  // Das ist ein String

Oder explizit, wenn du es bevorzugst:

val score: Int = 100
val name: String = "Alice"

Null-Safety: wie Kotlin NullPointerException eliminiert

Tony Hoare erfand null im Jahr 1965 und nannte es später seinen „Milliarden-Dollar-Fehler". Klingt nach Selbstkritik — ist aber eigentlich untertrieben. NullPointerException hat die Industrie seither weit mehr gekostet.

In Java kann jede Variable null sein. Der Compiler schweigt. Man erfährt es zur Laufzeit. In Production. Manchmal während eines Live-Demos vor dem Kunden — ja, das passiert.

Kotlin löst das Problem auf Ebene des Typsystems:

var name: String = "Alice"
name = null  // Compilerfehler. Sofort. Vor dem Start.

Wenn eine Variable null sein kann, muss man das explizit mit ? angeben:

var name: String? = "Alice"
name = null  // Wir haben vereinbart: nullable — jetzt okay.

Was tut man, wenn man eine Methode auf etwas aufrufen will, das null sein könnte?

println(name?.length)        // Wenn null — gibt null zurück. Kein Absturz.
println(name?.length ?: 0)   // Wenn null — gibt 0 zurück. Elvis-Operator.

Er heißt Elvis-Operator — weil ?: wie Elvis Presleys Frisur aussieht. Das ist kein Witz. Das ist die offizielle Erklärung in der Dokumentation.

Funktionen

In Java:

public static int add(int a, int b) {
    return a + b;
}

In Kotlin:

fun add(a: Int, b: Int): Int {
    return a + b
}

Oder noch kürzer — für Einzeiler-Funktionen:

fun add(a: Int, b: Int) = a + b

Kotlin unterstützt Standardparameterwerte. In Java würde man mehrere überladene Methoden schreiben. In Kotlin — nur eine:

fun greet(name: String, greeting: String = "Hallo") {
    println("$greeting, $name!")
}

greet("Alice")           // Hallo, Alice!
greet("Bob", "Hey")      // Hey, Bob!

String-Templates — $name direkt im String. Kotlin setzt den Wert der Variable ein. Kein +, keine Konkatenation — wie es eine vernünftige Sprache tun sollte.

Data Class: Tschüss, Boilerplate

Klassische Aufgabe: Ein Modell wird gebraucht — ein Benutzer mit Name, Alter und E-Mail.

In Java bedeutet das: Konstruktor, drei Getter, drei Setter, equals(), hashCode(), toString(). Oder Lombok. Oder das Schicksal akzeptieren und alles von Hand schreiben wie anno 2005.

In Kotlin:

data class User(val name: String, val age: Int, val email: String)

Eine Zeile. Der Compiler generiert alles Weitere, inklusive copy():

val alice = User("Alice", 30, "alice@example.com")
val olderAlice = alice.copy(age = 31)

println(alice)
// User(name=Alice, age=30, email=alice@example.com)

Schau dir copy() an. Du erstellst ein neues Objekt und änderst nur die benötigten Felder. In Java würde man dafür normalerweise einen Builder schreiben. Oder einfach leiden.

Extension Functions: Methoden zu fremden Klassen hinzufügen

Stell dir vor, du möchtest der Klasse String eine Methode hinzufügen. In Java — eine Utility-Klasse mit statischen Methoden, und dann überall StringUtils.doSomething(myString). Funktioniert, fühlt sich aber wie ein Workaround an.

In Kotlin — Extension Functions:

fun String.isValidEmail(): Boolean {
    return this.contains("@") && this.contains(".")
}

println("user@example.com".isValidEmail())  // true
println("kein-email".isValidEmail())        // false

Liest sich wie eine native Methode der Klasse. Keine Vererbung, keine Wrapper. Einfach eine Methode hinzugefügt — und schon benutzt man sie.

Alles zusammen: ein User-Validator

Nehmen wir alles, was wir gelernt haben, und schreiben etwas Echtes.

data class User(val name: String, val email: String?)

fun String.isValidEmail() = contains("@") && contains(".")

fun validateUser(user: User): String {
    val emailStatus = user.email?.let {
        if (it.isValidEmail()) "gültig" else "ungültig"
    } ?: "nicht angegeben"

    return "${user.name}: E-Mail $emailStatus"
}

fun main() {
    val users = listOf(
        User("Alice", "alice@example.com"),
        User("Bob", "bob-kein-email"),
        User("Charlie", null)
    )
    users.forEach { println(validateUser(it)) }
}
C++

Ausgabe:

Alice: E-Mail gültig
Bob: E-Mail ungültig
Charlie: E-Mail nicht angegeben

Beachte: null wird ohne ein einziges if behandelt. Die Operatoren ?. und ?: erledigen das elegant. Charlie hat keine E-Mail angegeben — und kein NPE. Das Leben ist schön.

Das war nur der Anfang

Hier haben wir die Grundlagen behandelt: Variablen, Null-Safety, Funktionen, Data Classes, Extension Functions.

Es wird noch interessanter. Coroutines — asynchroner Code ohne Schmerzen. Sealed Classes — eine mächtige Alternative zu switch, die dich nicht vergessen lässt, einen Fall zu behandeln. Funktionale Collection-Operationen — map, filter, reduce in einer Zeile.

Wenn du Kotlin systematisch lernen möchtest und nicht in verstreuten Artikeln, die sich in Browser-Tabs verlieren — probier unseren Kurs. 62 Level, über 1.100 Aufgaben mit automatischer Überprüfung, 3 Projekte fürs Portfolio. Das erste Level ist kostenlos.

→ codegym.cc/de/courses/kotlin

Weiterlesen