Kotlin Basic Types: Int, String, Boolean und Double

Basic Types sind die kleinen, aber sehr wichtigen Bausteine deines Kotlin-Codes. Wenn du in Android eine Anzahl speicherst, Text anzeigst, eine Entscheidung triffst oder einen Messwert berechnest, arbeitest du fast immer mit Int, String, Boolean oder Double. Wer diese Typen sauber versteht, schreibt Code, der leichter zu lesen, besser zu testen und weniger anfällig für versteckte Fehler ist.

Was ist das?

Basic Types beschreiben, welche Art von Wert eine Variable oder ein Ausdruck enthält. Ein Int steht für ganze Zahlen, etwa eine Anzahl von Artikeln im Warenkorb. Ein String steht für Text, zum Beispiel den Namen eines Screens oder eine Fehlermeldung. Ein Boolean speichert genau zwei Zustände: true oder false. Ein Double steht für Gleitkommazahlen, also Werte mit Nachkommastellen, etwa eine Temperatur oder eine Kartenposition.

In Kotlin sehen diese Typen auf den ersten Blick ähnlich aus wie primitive Typen aus Java. Das mentale Modell ist aber etwas anders: Du behandelst sie wie normale Kotlin-Typen mit Eigenschaften und Funktionen. Du kannst zum Beispiel auf einem String .length aufrufen oder einen Int mit .coerceAtLeast(0) begrenzen. Gleichzeitig kann Kotlin auf der JVM intern effiziente primitive Repräsentationen verwenden, wenn das möglich ist. Für dich zählt zuerst die klare Typinformation im Code.

Für Android ist das wichtig, weil fast jede Schicht deiner App solche Werte weitergibt. In Compose steuerst du UI mit Texten, Zahlen und Booleans. In einem ViewModel beschreibst du Ladezustände, Zähler, Eingaben und berechnete Werte. In Datenklassen für API-Antworten oder lokale Speicherung landen IDs, Namen, Flags und Messwerte. Basic Types sind also kein isoliertes Kotlin-Thema, sondern die Sprache, in der deine App ihren Zustand beschreibt.

Du solltest früh verstehen: Ein Typ ist nicht nur Syntax. Er ist eine Vereinbarung. Wenn eine Funktion Int erwartet, sagst du damit, dass nur ganze Zahlen sinnvoll sind. Wenn ein Parameter Boolean heißt, sollte sein Name sofort erklären, welche Entscheidung er steuert. Wenn du Double verwendest, akzeptierst du bewusst die Eigenschaften von Gleitkommazahlen, einschließlich Rundungsfragen.

Wie funktioniert es?

Kotlin kann Typen oft automatisch ableiten. Schreibst du val count = 3, ist count ein Int. Schreibst du val title = "Profil", ist title ein String. Bei val enabled = true entsteht ein Boolean, und bei val progress = 0.75 ein Double. Diese Typinferenz macht Code kürzer, ersetzt aber nicht dein Verständnis. Gerade bei öffentlichen Funktionen, Datenklassen und UI-State ist ein expliziter Typ oft hilfreicher, weil er die Absicht lesbar macht.

Int nutzt du für ganze Zahlen. Typische Beispiele sind Listenpositionen, Badge-Zähler, Retry-Versuche, Seitenzahlen oder Ressource-IDs. Beachte, dass Division mit zwei Int-Werten wieder eine ganze Zahl ergibt. 5 / 2 ist also 2, nicht 2.5. Wenn du eine genaue Nachkommaberechnung brauchst, muss mindestens ein Wert ein Double sein, zum Beispiel 5.0 / 2.

String ist der Standardtyp für Text. In Android solltest du sichtbare UI-Texte in echten Apps meistens aus String-Ressourcen beziehen, damit Übersetzung und Pflege funktionieren. Trotzdem arbeitest du im Kotlin-Code ständig mit String: für Eingaben, Log-Ausgaben, IDs, Suchbegriffe oder zusammengesetzte Texte. Kotlin unterstützt String-Templates, etwa "Hallo, $name". Das ist lesbar, solange du keine komplexe Logik direkt im Text versteckst.

Boolean ist für Entscheidungen da. Ein guter Boolean-Name liest sich wie eine Frage oder Aussage: isLoading, hasError, canSubmit, isPremiumUser. Schlechte Namen wie status oder flag zwingen dich später zum Rätseln. Besonders in Compose ist das relevant, weil Booleans oft direkt steuern, ob ein Ladeindikator, ein Button oder eine Fehlermeldung sichtbar ist.

Double verwendest du für Zahlen mit Nachkommastellen. Das passt für Koordinaten, Animationen, Fortschrittswerte, physikalische Messwerte oder statistische Berechnungen. Für Geldbeträge ist Double dagegen oft die falsche Wahl, weil binäre Gleitkommazahlen Dezimalbeträge nicht immer exakt darstellen. In vielen Apps speicherst du Geld besser als kleinste Einheit mit Int oder Long, zum Beispiel Cent, und formatierst erst bei der Anzeige.

Ein weiterer zentraler Punkt ist Nullbarkeit. String und String? sind in Kotlin unterschiedliche Typen. Ein String muss einen Text enthalten. Ein String? darf auch null sein. Dasselbe Prinzip gilt für Int?, Boolean? und Double?. Diese Unterscheidung ist in Android sehr wertvoll, weil Eingaben, gespeicherte Werte und Netzwerkdaten fehlen können. Du solltest nicht überall nullable Typen verwenden, sondern nur dort, wo fehlende Werte fachlich wirklich möglich sind.

In der Praxis

Stell dir einen Compose-Screen vor, auf dem ein Nutzer einen Rabatt eingibt. Du brauchst Text aus einem Eingabefeld, eine ganze Anzahl, eine Entscheidung für die Button-Aktivierung und eine Nachkommaberechnung für die Anzeige. Schon in diesem kleinen Beispiel kommen alle vier Basic Types vor.

data class CheckoutUiState(
    val itemCount: Int = 0,
    val couponCode: String = "",
    val isApplyingCoupon: Boolean = false,
    val discountPercent: Double = 0.0
)

fun CheckoutUiState.canApplyCoupon(): Boolean {
    return couponCode.isNotBlank() && itemCount > 0 && !isApplyingCoupon
}

fun CheckoutUiState.discountLabel(): String {
    val percent = discountPercent.coerceIn(0.0, 100.0)
    return "Rabatt: %.1f %%".format(percent)
}

Hier zeigt itemCount: Int, dass nur ganze Stückzahlen erlaubt sind. couponCode: String startet mit einem leeren Text, nicht mit null, weil ein nicht ausgefülltes Feld fachlich als leerer Text ausreicht. isApplyingCoupon: Boolean beschreibt einen laufenden Vorgang klar und kann direkt in der UI für einen Ladezustand genutzt werden. discountPercent: Double erlaubt Nachkommastellen, wird aber mit coerceIn(0.0, 100.0) begrenzt, damit keine unsinnigen Prozentwerte angezeigt werden.

Eine gute Entscheidungsregel lautet: Wähle den Typ nach der fachlichen Bedeutung, nicht nach Bequemlichkeit. Eine Anzahl ist ein Int, ein sichtbarer oder eingegebener Text ist ein String, eine Ja-Nein-Entscheidung ist ein klar benannter Boolean, und ein Mess- oder Verhältniswert mit Nachkommastellen ist ein Double. Wenn du später merkst, dass ein Wert fehlen kann, mach ihn gezielt nullable und behandle diesen Fall sichtbar im Code.

Eine typische Stolperfalle ist das ungeprüfte Umwandeln von Strings. Nutzereingaben kommen in Android oft als String, auch wenn du eine Zahl erwartest. Wenn du text.toInt() aufrufst und der Text "abc" enthält, bekommst du eine Exception. Für Eingaben ist toIntOrNull() meistens besser, weil du den Fehlerzustand kontrolliert behandeln kannst.

fun parseItemCount(input: String): Int {
    return input.trim().toIntOrNull()?.coerceAtLeast(0) ?: 0
}

Dieser Code entfernt Leerzeichen, versucht die Umwandlung, verhindert negative Werte und nutzt 0 als Fallback. Ob 0 fachlich passt, hängt von deiner App ab. Manchmal ist ein eigener Fehlerzustand besser. Wichtig ist: Die Typumwandlung verschwindet nicht irgendwo im UI-Code, sondern wird bewusst behandelt.

Auch bei Booleans entstehen häufig Fehler, wenn Namen unklar sind oder mehrere Zustände in einen einzelnen Boolean gepresst werden. isLoading und hasError sind für einfache Fälle gut. Wenn ein Screen aber mehrere Zustände kennt, etwa Idle, Loading, Success und Error, reicht ein einzelner Boolean nicht mehr sauber aus. Dann bist du zwar schon bei einem späteren Modellierungsthema, aber der Auslöser ist derselbe: Der Typ soll ausdrücken, was fachlich möglich ist.

Beim Testen kannst du Basic Types sehr direkt prüfen. Schreibe kleine Unit-Tests für Umwandlungen und Berechnungen. Prüfe Randwerte wie leere Strings, negative Zahlen, sehr große Zahlen, 0.0, 100.0 und ungültige Eingaben. Im Debugger lohnt es sich, bei einem Breakpoint nicht nur den Wert, sondern auch den Typ und die Nullbarkeit im Kopf mitzulesen. Im Code-Review solltest du besonders auf drei Fragen achten: Passt der Typ zur Fachbedeutung? Ist der Name klar? Sind Umwandlungen und Grenzwerte kontrolliert?

Fazit

Basic Types wirken unscheinbar, aber sie tragen einen großen Teil der Verständlichkeit deiner Android-App. Wenn du Int, String, Boolean und Double bewusst einsetzt, machst du Zustände, Eingaben und Berechnungen klarer. Übe das an einem kleinen Compose- oder ViewModel-Beispiel: Benenne jeden Wert präzise, prüfe Eingaben mit sicheren Umwandlungen, setze Breakpoints an Berechnungen und schreibe Tests für Randfälle. So erkennst du früh, ob dein Code nur kompiliert oder ob seine Typen wirklich die Fachlogik deiner App ausdrücken.