androidkotlinapp-entwicklungandroid-studiojetpack-compose

Android-App-Entwicklung mit Kotlin: Einstieg und Grundlagen

10 Min. Lesezeit

Android ist mit über 70 % Marktanteil weltweit das meistgenutzte mobile Betriebssystem – und mit Kotlin hat Google seit 2017 eine moderne, ausdrucksstarke Programmiersprache zur ersten Wahl für Android-Entwicklung erklärt. In diesem Artikel bekommst du einen soliden Einstieg: von den Vorteilen von Kotlin über die Einrichtung von Android Studio bis hin zu den wichtigsten Konzepten wie Jetpack Compose, ViewModel und dem Gradle-Buildsystem.

Warum Kotlin statt Java für Android?

Lange Zeit war Java die einzige offizielle Sprache für Android-Entwicklung. Kotlin, entwickelt von JetBrains, läuft vollständig auf der JVM und ist 100 % interoperabel mit Java – du kannst Java- und Kotlin-Code in einem Projekt mischen. Warum wechseln?

// Java – POJO mit Boilerplate
public class Nutzer {
    private String name;
    private int alter;
    public Nutzer(String name, int alter) { this.name = name; this.alter = alter; }
    public String getName() { return name; }
    public int getAlter() { return alter; }
    // equals, hashCode, toString ...
}

// Kotlin – Data Class, eine Zeile
data class Nutzer(val name: String, val alter: Int)

Android Studio einrichten

Android Studio ist die offizielle IDE für Android-Entwicklung, basierend auf IntelliJ IDEA. Download unter developer.android.com/studio – verfügbar für Windows, macOS und Linux.

Nach der Installation:

  1. Android Studio starten und dem Setup-Assistenten folgen
  2. Das Android SDK herunterladen (aktuell Android 15, API Level 35)
  3. Optional: Ein virtuelles Gerät (AVD) über den AVD Manager erstellen – z.B. ein Pixel 9 mit Android 15

Für die beste Performance nutze einen physischen Android-Geräte via USB (USB-Debugging in den Entwickleroptionen aktivieren) oder den neueren Android Emulator mit Google Play Store-Unterstützung.

Projektstruktur verstehen

Wenn du ein neues Android-Projekt erstellst, wähle die Vorlage "Empty Activity" mit Kotlin und Jetpack Compose. Die wichtigsten Verzeichnisse und Dateien:

AndroidManifest.xml – das Herz der App-Konfiguration

<manifest xmlns:android="http://schemas.android.com/apk/res/android">
    <uses-permission android:name="android.permission.INTERNET" />

    <application
        android:icon="@mipmap/ic_launcher"
        android:label="@string/app_name"
        android:theme="@style/Theme.MeineApp">

        <activity
            android:name=".MainActivity"
            android:exported="true">
            <intent-filter>
                <action android:name="android.intent.action.MAIN" />
                <category android:name="android.intent.category.LAUNCHER" />
            </intent-filter>
        </activity>
    </application>
</manifest>

Activity und Fragment – die klassischen UI-Bausteine

Bevor Jetpack Compose existierte, war Androids UI in Activities und Fragments organisiert:

Mit Jetpack Compose und dem modernen Single-Activity-Pattern brauchst du meist nur eine Activity, und alle Bildschirme sind Composables. Fragments verlieren für neue Projekte an Bedeutung.

Jetpack Compose – modernes deklaratives UI für Android

Jetpack Compose ist Googles Antwort auf Apples SwiftUI: ein deklaratives UI-Toolkit, das XML-Layouts ersetzt. Statt Views in XML zu definieren, schreibst du Kotlin-Funktionen mit @Composable-Annotation:

import androidx.compose.material3.*
import androidx.compose.runtime.*
import androidx.compose.foundation.layout.*
import androidx.compose.ui.Modifier

@Composable
fun ZählerBildschirm() {
    var zähler by remember { mutableStateOf(0) }

    Column(
        modifier = Modifier.fillMaxSize(),
        verticalArrangement = Arrangement.Center,
        horizontalAlignment = androidx.compose.ui.Alignment.CenterHorizontally
    ) {
        Text(
            text = "Zähler: $zähler",
            style = MaterialTheme.typography.headlineMedium
        )

        Spacer(modifier = Modifier.height(16.dp))

        Button(onClick = { zähler++ }) {
            Text("Erhöhen")
        }
    }
}

Das Prinzip ist dasselbe wie in SwiftUI: Du beschreibst, was angezeigt werden soll, und Compose aktualisiert die UI automatisch, wenn sich der State ändert. remember hält den State über Recompositionen hinweg, mutableStateOf macht ihn reaktiv.

Navigation in Compose

// build.gradle.kts
implementation("androidx.navigation:navigation-compose:2.8.0")

// NavHost mit Compose
val navController = rememberNavController()

NavHost(navController = navController, startDestination = "home") {
    composable("home") { HomeScreen(navController) }
    composable("detail/{id}") { backStack ->
        val id = backStack.arguments?.getString("id") ?: ""
        DetailScreen(id = id)
    }
}

ViewModel und StateFlow – Architektur und Zustandsverwaltung

Für eine saubere Trennung von UI und Geschäftslogik verwendest du ViewModel (aus Jetpack Architecture Components). Das ViewModel überlebt Konfigurationsänderungen (z.B. Rotation) und enthält deinen App-State:

import androidx.lifecycle.ViewModel
import kotlinx.coroutines.flow.MutableStateFlow
import kotlinx.coroutines.flow.StateFlow
import kotlinx.coroutines.flow.asStateFlow

data class AufgabenState(
    val aufgaben: List<String> = emptyList(),
    val isLoading: Boolean = false
)

class AufgabenViewModel : ViewModel() {
    private val _state = MutableStateFlow(AufgabenState())
    val state: StateFlow<AufgabenState> = _state.asStateFlow()

    fun aufgabeHinzufügen(titel: String) {
        val aktuelleAufgaben = _state.value.aufgaben
        _state.value = _state.value.copy(
            aufgaben = aktuelleAufgaben + titel
        )
    }
}

// Im Composable
@Composable
fun AufgabenScreen(viewModel: AufgabenViewModel = viewModel()) {
    val state by viewModel.state.collectAsState()

    // UI basierend auf state rendern
}

StateFlow ist ein reaktiver Datenstrom, der immer einen aktuellen Wert hält – ideal für UI-State. Für einmalige Ereignisse (Navigation, Snackbar) nutze SharedFlow.

Das Gradle-Buildsystem

Gradle ist das Build-Tool für Android. Es verwaltet Abhängigkeiten, kompiliert deinen Code und erstellt das APK oder AAB (Android App Bundle). Die Build-Konfiguration liegt in build.gradle.kts (Kotlin DSL):

// app/build.gradle.kts
android {
    namespace = "tech.kotsch.meinapp"
    compileSdk = 35

    defaultConfig {
        applicationId = "tech.kotsch.meinapp"
        minSdk = 26
        targetSdk = 35
        versionCode = 1
        versionName = "1.0.0"
    }

    buildTypes {
        release {
            isMinifyEnabled = true
            proguardFiles(getDefaultProguardFile("proguard-android-optimize.txt"))
        }
    }
}

dependencies {
    implementation("androidx.compose.material3:material3:1.3.0")
    implementation("androidx.lifecycle:lifecycle-viewmodel-compose:2.8.0")
    implementation("androidx.navigation:navigation-compose:2.8.0")
}

Mit minSdk = 26 (Android 8.0) erreichst du rund 90 % aller aktiven Android-Geräte (Stand 2024). ProGuard / R8 (aktiviert durch isMinifyEnabled = true) verkleinert und verschleiert deinen Code im Release-Build.

Debugging-Tools in Android Studio

Android Studio bietet mächtige Debugging-Werkzeuge:

Play Store veröffentlichen – die Grundlagen

Für die Veröffentlichung im Google Play Store benötigst du ein Google Play Developer-Konto (einmalige Registrierungsgebühr von 25 USD). Der Prozess in Kurzform:

  1. In Android Studio: Build → Generate Signed Bundle / APK – wähle "Android App Bundle" (.aab)
  2. Erstelle einen neuen Keystore oder verwende einen bestehenden zum Signieren
  3. Lade das AAB in der Google Play Console unter play.google.com/console hoch
  4. Fülle Metadaten aus: Beschreibung, Screenshots (mindestens 2), Datenschutzrichtlinien-URL
  5. Starte einen geschlossenen Beta-Test (analog zu TestFlight) oder gehe direkt in die Produktion

Google prüft neue Apps ebenfalls (meist innerhalb von 1-3 Tagen). Im Gegensatz zu Apple ist der Review-Prozess weniger strikt, aber auch hier gibt es Ablehnungen bei Policy-Verstößen.

Mehr zur plattformübergreifenden Entwicklung findest du bei den Android-Apps von Arthur Kotsch. Wenn du auch iOS-Entwicklung lernen möchtest, lies die SwiftUI Grundlagen-Anleitung.

Häufige Fragen

Muss ich Java können, um mit Kotlin Android-Apps zu entwickeln?

Nein. Du kannst direkt mit Kotlin einsteigen, ohne Java zu kennen. Da Kotlin vollständig interoperabel mit Java ist, kannst du bei Bedarf Java-Bibliotheken nutzen und Java-Code einbinden – aber das ist keine Voraussetzung. Alle Google-Tutorials und offizielle Dokumentation sind seit Jahren primär auf Kotlin ausgerichtet.

Sollte ich Jetpack Compose oder klassische XML-Layouts lernen?

Für neue Projekte und Einsteiger eindeutig Jetpack Compose. XML-Layouts (mit View Binding oder Data Binding) sind Legacy und werden von Google nicht mehr aktiv weiterentwickelt. Compose ist der Standard für alle neuen Android-Apps. Kenntnisse in XML-Layouts sind jedoch nützlich, wenn du bestehende große Projekte wartest oder mit älterem Code arbeitest.

Wie viel RAM und CPU brauche ich für Android Studio?

Android Studio und der Emulator sind ressourcenhungrig. Empfohlen werden mindestens 16 GB RAM (8 GB Minimum), ein moderner Mehrkern-Prozessor (Intel Core i5/i7 oder AMD Ryzen 5/7) und 10-20 GB freier Festplattenspeicher (SSD empfohlen). Auf einem physischen Android-Gerät via USB zu testen ist deutlich schneller als der Emulator und spart Ressourcen.

Was ist der Unterschied zwischen APK und AAB?

Ein APK (Android Package) ist das klassische Installationspaket – eine einzelne Datei für alle Geräte. Ein AAB (Android App Bundle) ist das moderne Format: Google Play erzeugt daraus geräteoptimierte APKs, die nur die für das jeweilige Gerät nötigen Ressourcen enthalten. Das reduziert Download-Größen um bis zu 15-20 %. Für Play Store Uploads ist AAB seit 2021 Pflicht für neue Apps.

Kann ich mit Kotlin Apps für iOS entwickeln?

Mit Kotlin Multiplatform (KMP) kannst du Geschäftslogik (Netzwerk, Datenbank, Business Rules) zwischen Android und iOS teilen. Die UI bleibt plattformspezifisch – SwiftUI auf iOS, Compose auf Android. KMP ist eine beliebte Alternative zu Flutter und React Native, wenn du native Performance und Tooling beider Plattformen beibehalten möchtest. Google und JetBrains investieren stark in diesen Ansatz.