Android Studio installieren — IDE, SDK und Tools richtig einrichten

Bevor du deine erste Activity schreibst oder Compose-Previews bewunderst, brauchst du eine Werkbank, auf der alles zusammenpasst. Genau das liefert dir Android Studio: eine integrierte Entwicklungsumgebung, in der Editor, Build-System, Geräte-Emulator und das Android SDK aufeinander abgestimmt sind. Wenn du diesen Schritt sauber machst, sparst du dir später viele Stunden Fehlersuche, die nichts mit deinem eigentlichen Code zu tun haben. In diesem Artikel klären wir, was du eigentlich installierst, wie die Teile zusammenspielen und worauf du beim Setup achten solltest.

Was ist das?

Android Studio ist die offizielle Entwicklungsumgebung für Android, die Google auf Basis von JetBrains IntelliJ IDEA pflegt. Du bekommst damit nicht nur einen Editor mit Kotlin-Unterstützung, sondern ein komplettes Ökosystem: Projekt-Templates, ein konfiguriertes Gradle-Build, einen Layout- und Compose-Preview, Profiler, Logcat-Anzeige und einen Emulator für virtuelle Geräte. Wer auf Android entwickelt, arbeitet praktisch immer in dieser IDE, weil sie viele Tools verbindet, die einzeln eingerichtet sehr aufwändig wären.

Wichtig ist die Trennung zwischen IDE und SDK. Das Android SDK ist die Sammlung aus Plattform-APIs (also den Klassen wie Activity, View oder ViewModel), Build-Tools, Plattform-Tools wie adb und Geräte-Images für den Emulator. Android Studio bringt diese Teile mit oder lädt sie nach, aber sie sind eigenständige Komponenten. Du kannst dieselben SDK-Bestandteile theoretisch auch ohne IDE über die Kommandozeile nutzen — in der Praxis führt aber kein vernünftiger Weg an Android Studio vorbei, gerade wenn du mit Jetpack Compose, Compose Previews oder dem Layout-Inspector arbeiten willst.

Eingeordnet in die Roadmap heißt das: Diese Etappe ist die Grundlage für alles Weitere. Ohne lauffähige IDE kannst du weder ein Projekt bauen noch das offizielle Tutorial „Android Basics with Compose” durcharbeiten. Sobald du das Setup einmal sauber stehen hast, taucht das Thema kaum noch auf — bis irgendwann die nächste große Version erscheint und du gezielt aktualisierst.

Wie funktioniert es?

Bei der Installation laufen mehrere Schritte parallel ab, die du verstehen solltest, damit du Probleme später einordnen kannst. Du lädst zuerst das Android-Studio-Installationspaket von der offiziellen Seite developer.android.com. Beim ersten Start prüft die IDE, ob Java bereits vorhanden ist. Du musst dich darum nicht kümmern, weil Android Studio ein eigenes JetBrains-JDK mitbringt, das für Builds verwendet wird. Eine separate Java-Installation ist heute nicht mehr nötig und kann sogar verwirrend sein, wenn JAVA_HOME auf eine andere Version zeigt.

Im nächsten Schritt fragt dich der Setup-Wizard, ob du eine Standard-Installation möchtest. Wähle in der Regel den Standard-Pfad: Damit landen die SDK-Plattform, die Build-Tools, ein Emulator-Image und die Plattform-Tools in einem klar definierten Verzeichnis. Auf macOS liegt es typischerweise unter ~/Library/Android/sdk, auf Windows unter %LOCALAPPDATA%\Android\Sdk, unter Linux unter ~/Android/Sdk. Diesen Pfad solltest du dir merken, weil viele Werkzeuge — etwa adb aus dem Terminal — ihn brauchen.

Nach der Installation öffnest du den SDK-Manager (Menü: Tools → SDK Manager). Dort siehst du drei wichtige Reiter:

• SDK Platforms: hier wählst du, für welche API-Levels du entwickeln willst. Für moderne Apps ziehst du die jeweils aktuelle stabile Plattform mit, etwa Android 15 (API 35).
• SDK Tools: hier sind Build-Tools, der Emulator, Plattform-Tools und das Android Gradle Plugin gelistet. Lasse die Standardauswahl aktiv und ergänze sie nur bewusst, etwa um die NDK-Komponenten, wenn du sie wirklich brauchst.
• SDK Update Sites: hier hinterlegst du nichts manuell, solange du keine Drittanbieter-Add-ons nutzt.

Parallel dazu lebt der AVD Manager (Android Virtual Device). Damit erstellst du virtuelle Geräte, auf denen deine Apps laufen, ohne dass du echtes Hardware-Zubehör brauchst. Ein virtuelles Pixel-Gerät mit der aktuellen Plattform-Image-Variante (Google Play) ist ein guter Default für den Einstieg.

Im Hintergrund verzahnt sich das Ganze über Gradle. Wenn du ein Projekt öffnest, liest Android Studio die Datei settings.gradle.kts und die Modul-Dateien build.gradle.kts. Dort steht, welches Android Gradle Plugin (AGP), welche Kotlin-Version und welche compileSdk/minSdk/targetSdk du benutzt. Die IDE prüft, ob die passenden SDK-Komponenten lokal installiert sind, und bietet sonst an, sie nachzuladen. Genau dieser Mechanismus erklärt, warum „bei mir geht’s nicht” oft eine fehlende Build-Tools-Version ist.

In der Praxis

Im Alltag richtest du Android Studio genau einmal pro Rechner ein und pflegst es danach behutsam. Als praktischer Workflow für deinen ersten Tag bietet sich diese Reihenfolge an:

1. Lade Android Studio von developer.android.com/studio herunter. Achte darauf, dass du die Version für dein Betriebssystem und die richtige CPU-Architektur ziehst — auf einem Apple-Silicon-Mac brauchst du das arm64-Paket, nicht das Intel-Paket.
2. Folge dem Setup-Wizard und akzeptiere die Lizenzen für die SDK-Komponenten. Das Akzeptieren ist Pflicht; ohne diesen Schritt kann Gradle die Komponenten nicht herunterladen.
3. Öffne den SDK-Manager und prüfe, ob die aktuelle stabile Plattform installiert ist. Aktiviere im Reiter „SDK Tools” die Optionen „Android SDK Build-Tools”, „Android Emulator” und „Android SDK Platform-Tools”.
4. Lege im AVD-Manager ein virtuelles Pixel-Gerät an und starte es einmal kurz, um zu prüfen, ob die Hardware-Beschleunigung funktioniert.
5. Erstelle ein neues Projekt mit der Vorlage „Empty Activity” auf Compose-Basis und lasse es bauen. Wenn die Vorschau und der Run-Button funktionieren, ist die Werkbank einsatzbereit.

Damit du siehst, was Android Studio für dich erzeugt, hier ein typischer Auszug aus der build.gradle.kts eines neuen Compose-Projekts:

android {
    namespace = "de.androidcoden.hello"
    compileSdk = 35

    defaultConfig {
        applicationId = "de.androidcoden.hello"
        minSdk = 24
        targetSdk = 35
        versionCode = 1
        versionName = "1.0"
    }

    buildFeatures {
        compose = true
    }
}

dependencies {
    implementation(platform("androidx.compose:compose-bom:2025.01.00"))
    implementation("androidx.activity:activity-compose:1.9.3")
    implementation("androidx.compose.material3:material3")
}

Drei Dinge sind hier wichtig. compileSdk bestimmt, gegen welche API-Klassen du baust — diese Plattform muss im SDK-Manager installiert sein. minSdk legt fest, ab welcher Android-Version deine App läuft, und targetSdk signalisiert dem System, für welche Version du sie geprüft hast. Wenn der Build mit einer Meldung wie „SDK Platform 35 not found” abbricht, liegt es fast immer daran, dass diese Plattform im SDK-Manager noch nicht ausgewählt ist.

Die typische Stolperfalle für Einsteigerinnen und Einsteiger ist die Pfad-Verwirrung. Du installierst Android Studio in den Programme-Ordner, das SDK landet aber im Benutzerverzeichnis. Wenn du Anleitungen aus dem Netz kopierst, die JAVA_HOME setzen oder ein eigenes SDK-Verzeichnis vermuten, kannst du dir damit funktionierende Setups kaputtkonfigurieren. Halte dich am Anfang an die Standards: Studio installiert, SDK an Standardpfad, keine globalen Java-Variablen. Erst wenn du verstanden hast, was Gradle dort macht, lohnt sich Feintuning.

Eine zweite Stolperfalle sind Updates. Es ist verlockend, jede Canary- oder Beta-Version auszuprobieren, weil sie hübsche neue Features hat. Für Lernprojekte ist das in Ordnung, sobald du aber an einem Repository arbeitest, das mehrere Leute teilen, solltest du bei der stabilen Version bleiben und Updates des Android Gradle Plugins bewusst über Tools → AGP Upgrade Assistant einspielen. Sonst zwingst du Mitlernende zu Updates, die sie noch nicht durchführen können.

Validieren kannst du dein Setup auf vier konkrete Arten:

• Build: Ein leeres Compose-Projekt baut ohne Fehler. „Build Successful” reicht als erste Bestätigung.
• Emulator: Das virtuelle Gerät startet, zeigt den Launcher und du kannst deine App per Run-Button installieren.
• Logcat: In der Logcat-Ansicht siehst du Ausgaben deiner App, etwa von Log.d(...). Das zeigt, dass adb mit dem Emulator spricht.
• Tests: Ein generierter Unit-Test (ExampleUnitTest) und ein Instrumentation-Test (ExampleInstrumentedTest) laufen grün durch. Das bestätigt, dass nicht nur der App-Build, sondern auch das Test-Setup funktioniert.

Fazit

Die Installation von Android Studio ist mehr als ein Doppelklick auf einen Installer: Du baust dir damit eine integrierte Werkbank aus IDE, Android SDK und Tooling, auf die du in jedem späteren Roadmap-Schritt zurückgreifst. Wenn du einmal verstanden hast, dass die IDE nur die Hülle ist und die eigentlichen APIs, Build-Tools und Geräte-Images im SDK liegen, kannst du Fehlermeldungen viel ruhiger lesen und gezielt im SDK-Manager beheben. Nimm dir nach dem Setup eine halbe Stunde Zeit, klick dich bewusst durch SDK-Manager, AVD-Manager und Logcat, baue ein leeres Compose-Projekt und führe den generierten Test aus. Wenn dieser Mini-Workflow bei dir grün durchläuft, hast du dir die Grundlage geschaffen, auf der die nächsten Roadmap-Themen — Projektstruktur, Activity-Lebenszyklus und erste Compose-UIs — sauber aufsetzen können.