Java: Was ist das für eine Sprache, ihre Merkmale und Android-Entwicklung

Was ist Java?

Java ist eine allgemeine Programmiersprache, die von Sun Microsystems im Jahr 1995 entwickelt wurde. Das Hauptprinzip lautet "Write Once, Run Anywhere": kompilierter Java-Bytecode läuft auf jeder Plattform, auf der die virtuelle Maschine JVM installiert ist. Im Kontext der mobilen Entwicklung wurde Java die erste offizielle Sprache des Android SDK, das von Google im Jahr 2008 veröffentlicht wurde.

Die Java-Architektur basiert auf drei Komponenten: JDK (Java Development Kit) — eine Reihe von Entwicklerwerkzeugen, JRE (Java Runtime Environment) — die Laufzeitumgebung und JVM (Java Virtual Machine) — die virtuelle Maschine. Android verwendet seine eigene JVM-Implementierung — Android Runtime (ART), die Dalvik in Version 5.0 (Lollipop) ersetzte. ART führt DEX-Bytecode aus, der über das Dienstprogramm dx/d8 aus Java-Bytecode kompiliert wird.

Ein Hauptmerkmal von Java ist die automatische Speicherverwaltung durch den Garbage Collector (GC). Der Entwickler muss Speicher nicht explizit freigeben — der GC verfolgt ungenutzte Objekte und entfernt sie. In Android ART werden Concurrent Mark Sweep (CMS) und Generational GC verwendet, optimiert für die begrenzten Ressourcen mobiler Geräte. Dies entlastet den Entwickler, kann aber während der Garbage Collection im UI-Thread zu "Lags" führen.

Java-Versionen und Android API

Android unterstützt eine Teilmenge der Java API, die mit jeder neuen OS-Version erweitert wird. Android 12 (API 31) fügte Unterstützung für Java 11 hinzu, einschließlich Lambda-Variablen-Capture, JPMS-Modulsystem und HTTP-Client java.net.http. Android 14 (API 34) führte experimentelle Unterstützung für Java 17 durch D8/R8-Desugaring ein — einige Funktionen (Records, Sealed Classes) werden in kompatiblen Code für ältere Versionen übersetzt.

Java SDK und Android-Entwicklung

Das Android SDK enthält den Java-Compiler, das dex-Dienstprogramm (d8), aapt (Asset Packaging Tool), Emulator und Bibliotheken android.* und java.*. Der Entwickler schreibt Code in Java, kompiliert ihn in .class-Dateien (JVM-Bytecode), dann konvertiert d8 sie in .dex-Dateien (Dalvik Executable), die zusammen mit Ressourcen und AndroidManifest.xml in APK verpackt werden.

Gradle ist das Build-System für Android-Projekte. Die Datei build.gradle (Groovy) oder build.gradle.kts (Kotlin DSL) beschreibt Abhängigkeiten, SDK-Versionen, Flavors und Signaturen. Android Gradle Plugin (AGP) Version 8.x automatisiert Desugar — die Übersetzung moderner Java-Funktionen in abwärtskompatiblen Code. Beispielsweise wird java.time.LocalDate ohne Änderungen im Quellcode des Entwicklers in API 21+ kompatiblen Code umgewandelt.

// Einfache Android Activity in Java
package com.example.myapp;

import android.os.Bundle;
import android.widget.TextView;
import androidx.appcompat.app.AppCompatActivity;

public class MainActivity extends AppCompatActivity {
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        TextView tv = findViewById(R.id.textView);
        tv.setText("Hello from Java!");
    }

    // Methode zur Behandlung von Button-Klicks
    public void onButtonClick(View view) {
        TextView tv = findViewById(R.id.textView);
        tv.setText("Button clicked");
    }
}

Die Klasse MainActivity erweitert AppCompatActivity — eine Basisklasse aus AndroidX für Abwärtskompatibilität. Die Methode onCreate wird beim Erstellen der Activity aufgerufen; darin wird das Layout über setContentView festgelegt. findViewById verbindet eine Java-Variable mit einem Element aus dem XML-Layout. Die Methode onButtonClick ist über das Attribut android:onClick in XML an den Button gebunden.

Arbeiten mit Activity und Lebenszyklus

Der Activity-Lebenszyklus in Java ist eine Abfolge von Callbacks: onCreate → onStart → onResume (aktiv), onPause → onStop → onDestroy (Beendigung). Der Entwickler überschreibt diese Methoden zur Ressourcenverwaltung. onCreate — Initialisierung, onPause — Daten speichern, onDestroy — Ressourcen freigeben. Android ruft diese Methoden bei Bildschirmdrehung, Wechsel in den Hintergrund und bei Telefonanrufen auf.

// Activity-Lebenszyklus mit Zustandsverwaltung
public class DetailActivity extends AppCompatActivity {
    private String itemId;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_detail);

        itemId = getIntent().getStringExtra("ITEM_ID");
        loadData(itemId);
    }

    @Override
    protected void onSaveInstanceState(Bundle outState) {
        super.onSaveInstanceState(outState);
        outState.putString("item_id", itemId);
    }

    @Override
    protected void onRestoreInstanceState(Bundle savedInstanceState) {
        super.onRestoreInstanceState(savedInstanceState);
        itemId = savedInstanceState.getString("item_id");
        loadData(itemId);
    }

    private void loadData(String id) {
        // Daten nach Identifikator laden
    }
}

Die Methode onSaveInstanceState speichert den Zustand der Activity bei Bildschirmdrehung oder Aufgabenwechsel. Bundle enthält Schlüssel-Wert-Paare — einfache Typen, Parcelable- oder Serializable-Objekte. onRestoreInstanceState stellt den gespeicherten Zustand wieder her. Dieses Muster ist kritisch für Android, da das System die Activity bei Speichermangel zerstören und bei Rückkehr des Benutzers wiederherstellen kann.

Java-Syntax: Klassen, Methoden und Typen

Die Java-Syntax ist C-ähnlich, stark typisiert, objektorientiert. Jede .java-Datei enthält eine öffentliche Klasse, deren Name mit dem Dateinamen übereinstimmt. Java unterstützt keine Funktionen außerhalb von Klassen — alles ist eine Methode. Der Einstiegspunkt ist die statische Methode public static void main(String[] args) für Konsolenanwendungen oder die Android Activity-Lebenszyklusmethoden für Mobilgeräte.

Java-Datentypen

Java unterteilt Typen in primitive (int, double, boolean, char, byte, short, long, float) und Referenztypen (Klassen, Interfaces, Arrays, enum). Primitive werden auf dem Stack gespeichert und als Wert übergeben. Objekte befinden sich im Heap und werden als Referenz übergeben. Autoboxing konvertiert automatisch einen primitiven Typ in ein Wrapper-Objekt (Integer, Double, Boolean), erzeugt aber zusätzliche Objekte — in Android ist dies kritisch für die UI-Leistung.

// Beispiele für Java-Datentypen und -Strukturen
public class DataTypes {
    // Primitive
    int count = 42;
    double price = 19.99;
    boolean isActive = true;
    char grade = 'A';

    // Referenztypen
    String name = "Android";
    Integer boxed = 100; // autoboxing
    List<String> items = new ArrayList<>();

    // Methode mit Generics
    public <T> T getFirst(List<T> list) {
        return list.isEmpty() ? null : list.get(0);
    }

    // Enum für festen Wertesatz
    public enum Status {
        PENDING, LOADING, SUCCESS, ERROR
    }
}

Generics List<T> bieten Typsicherheit für Sammlungen. Die Methode getFirst gibt ein Element beliebigen Typs zurück — der spezifische Typ wird an der Aufrufstelle bestimmt. Enum Status wird in eine Klasse mit einem festen Satz von Konstanten kompiliert, jede Instanz ist ein Singleton. In Android wird Enum aufgrund des Speicherverbrauchs seltener verwendet: ProGuard/R8 optimiert Enum wo möglich in int-Konstanten.

Java vs Kotlin: Vergleich in Android

Der Vergleich von Java und Kotlin für die Android-Entwicklung ist seit 2019 eines der Hauptthemen, als Google Kotlin zur Prioritätssprache erklärte. Kotlin ist vollständig mit Java kompatibel — beide kompilieren zu JVM-Bytecode, können sich gegenseitig aufrufen und dieselben Bibliotheken verwenden. Die Ansätze zum Schreiben von Code unterscheiden sich jedoch drastisch.

Boilerplate-Code

Kotlin beseitigt die Ausführlichkeit von Java: data class ersetzt 50+ Zeilen einer Java-Klasse mit Gettern, Settern, equals, hashCode, toString und copy. Null-Sicherheit ist in Kotlins Typsystem eingebaut — NullPointerException ist praktisch unmöglich. Erweiterungsfunktionen ermöglichen das Hinzufügen von Methoden zu bestehenden Klassen ohne Vererbung. Smart Casts konvertieren Typen automatisch nach einer Prüfung.

Leistung

In Bezug auf die Leistung sind Java und Kotlin identisch — beide kompilieren zu JVM-Bytecode, den Android ART gleichermaßen ausführt. Der Unterschied liegt in der APK-Größe: Kotlin fügt ~200-400 KB für die kotlin-stdlib-Bibliothek hinzu. Java-Projekte haben aufgrund des fehlenden zusätzlichen Runtimes eine kleinere APK-Größe, aber bei Verwendung von Java Stream API und Optional kann die APK-Größe durch Desugaring zunehmen.

Java-Entwicklerwerkzeuge für Android

Die Java-Entwicklerwerkzeuge für Android umfassen Android Studio, Gradle, Profiler und Emulator. Android Studio ist die offizielle IDE, basierend auf IntelliJ IDEA Community, mit einem Java-Autovervollständigungs-Editor, Code-Analyzer (lint), Refactoring und einem visuellen Layout-Editor (Layout Editor).

Wichtigste Werkzeuge

Android Gradle Plugin (AGP) Version 8.x verwaltet den Build: Java-Kompilierung in Klassen, Desugaring, ProGuard/R8-Minifizierung, Verpackung in APK/AAB. R8 ist ein aktualisierter Desugarer und Obfuscator, der ProGuard ersetzt. Build-Varianten (debug/release + product flavors) werden über build.gradle konfiguriert. Gradle Daemon beschleunigt nachfolgende Builds durch Caching.

// build.gradle (app) — Konfiguration des Java-Moduls
android {
    compileSdk 34
    defaultConfig {
        applicationId "com.example.myapp"
        minSdk 21
        targetSdk 34
        versionCode 1
        versionName "1.0"
    }
    compileOptions {
        sourceCompatibility JavaVersion.VERSION_17
        targetCompatibility JavaVersion.VERSION_17
    }
}

dependencies {
    implementation 'androidx.core:core-ktx:1.12.0'
    implementation 'androidx.appcompat:appcompat:1.6.1'
    implementation 'com.google.android.material:material:1.11.0'
    testImplementation 'junit:junit:4.13.2'
}

Der compileOptions-Block gibt die Java-Version für die Kompilierung an — Java 17 ist mit AGP 8.x verfügbar. Die minimale SDK (minSdk) bestimmt die minimale Android-Version, auf der die Anwendung läuft. Target SDK ist die Version, für die die Anwendung getestet wurde. Der Unterschied zwischen compileSdk und targetSdk: compileSdk ist die API für die Kompilierung, targetSdk ist das Laufzeitverhalten.

Einschränkungen von Java in der mobilen Entwicklung

Die Einschränkungen von Java in Android führten zur Umstellung von Google auf Kotlin. NullPointerException ist die häufigste Ausnahme in Java-Android-Anwendungen, da das Typsystem nicht zwischen nullable und non-null Referenzen unterscheidet. Google empfiehlt die Annotationen @Nullable und @NonNull aus dem Paket androidx.annotation, aber der Compiler prüft sie nicht — nur lint tut dies.

Das Fehlen von Coroutinen ist eine weitere Einschränkung: Asynchrone Operationen in Java erfordern Callbacks, AsyncTask (veraltet seit API 30), ExecutorService oder RxJava. Dies führt zu Callback-Hell und Speicherlecks bei Bildschirmdrehung. Kotlin-Coroutinen mit Structured Concurrency lösen dieses Problem auf Sprachebene: Eine Coroutine wird bei Zerstörung der Activity ohne manuelle Verwaltung abgebrochen.

Boilerplate-Code in Java ist eine Fehlerquelle beim manuellen Schreiben von equals/hashCode, Parcelable-Implementierungen und ViewHolder für RecyclerView. Die Android KTX-Bibliotheken und Jetpack Compose sind auf Kotlin ausgerichtet. Neue Android-APIs (Room, Navigation, Compose) veröffentlichen Beispiele standardmäßig in Kotlin, obwohl Java-Versionen existieren.