Java: wat voor taal is het, zijn kenmerken en Android-ontwikkeling

Wat is Java?

Java — een algemene programmeertaal, gemaakt door Sun Microsystems in 1995. Het hoofdprincipe — «Write Once, Run Anywhere»: gecompileerde Java-bytecode werkt op elk platform waar de JVM virtuele machine is geïnstalleerd. In de context van mobiele ontwikkeling werd Java de eerste officiële taal van de Android SDK, uitgebracht door Google in 2008.

De architectuur van Java is gebaseerd op drie componenten: JDK (Java Development Kit) — de set ontwikkeltools, JRE (Java Runtime Environment) — de runtime-omgeving en JVM (Java Virtual Machine) — de virtuele machine. Android gebruikt zijn eigen implementatie van JVM — Android Runtime (ART), die Dalvik verving in versie 5.0 (Lollipop). ART voert DEX-bytecode uit, die wordt gecompileerd uit Java-bytecode via het dx/d8-hulpprogramma.

Een belangrijk kenmerk van Java — automatisch geheugenbeheer via Garbage Collector (GC). De ontwikkelaar hoeft geen geheugen expliciet vrij te geven — GC volgt ongebruikte objecten en verwijdert ze. In Android ART worden Concurrent Mark Sweep (CMS) en Generational GC gebruikt, geoptimaliseerd voor de beperkte bronnen van mobiele apparaten. Dit vermindert de belasting van de ontwikkelaar, maar kan «vertragingen» veroorzaken tijdens het ophalen van vuilnis in de UI-thread.

Java-versies en Android API

Android ondersteunt een subset van Java API, die wordt uitgebreid met elke nieuwe versie van het besturingssysteem. Android 12 (API 31) voegde ondersteuning voor Java 11 toe, inclusief lambda's met variabele capture, het modulaire JPMS-systeem en de HTTP-client java.net.http. Android 14 (API 34) introduceerde experimentele ondersteuning voor Java 17 via D8/R8-desugaring — sommige functies (records, sealed classes) worden vertaald naar compatibele code voor oudere versies.

Java SDK en Android-ontwikkeling

Android SDK bevat de Java-compiler, het dex-hulpprogramma (d8), aapt (Asset Packaging Tool), emulator en de bibliotheken android.* en java.*. De ontwikkelaar schrijft code in Java, compileert deze naar .class-bestanden (JVM-bytecode), waarna d8 ze omzet naar .dex-bestanden (Dalvik Executable), die samen met bronnen en AndroidManifest.xml in een APK worden verpakt.

Gradle — het buildsysteem van een Android-project. Het bestand build.gradle (Groovy) of build.gradle.kts (Kotlin DSL) beschrijft afhankelijkheden, SDK-versies, product flavors en handtekeningen. Android Gradle Plugin (AGP) versie 8.x automatiseert desugaring — de vertaling van moderne Java-functies naar achterwaarts compatibele code. Bijvoorbeeld, java.time.LocalDate wordt omgezet naar code die compatibel is met API 21+ zonder wijzigingen in de broncode van de ontwikkelaar.

// Een eenvoudige 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("Hallo vanuit Java!");
    }

    // Methode voor het afhandelen van knopklik
    public void onButtonClick(View view) {
        TextView tv = findViewById(R.id.textView);
        tv.setText("Knop geklikt");
    }
}

De klasse MainActivity erft van AppCompatActivity — de basisklasse uit AndroidX voor achterwaartse compatibiliteit. De methode onCreate wordt aangeroepen bij het maken van de Activity, waarin de layout wordt ingesteld via setContentView. findViewById verbindt een Java-variabele met een element uit de XML-layout. De methode onButtonClick is aan de knop gekoppeld via het kenmerk android:onClick in XML.

Werken met Activity en levenscyclus

De levenscyclus van Activity in Java — een reeks callbacks: onCreate → onStart → onResume (actief), onPause → onStop → onDestroy (beëindiging). De ontwikkelaar overschrijft deze methoden om bronnen te beheren. onCreate — initialisatie, onPause — gegevens opslaan, onDestroy — bronnen vrijgeven. Android roept deze methoden aan bij schermrotatie, naar de achtergrond gaan en het ontvangen van een oproep.

// Activity-levenscyclus met statusbeheer
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) {
        // Gegevens laden op ID
    }
}

De methode onSaveInstanceState slaat de status van de Activity op bij schermrotatie of het wisselen van taken. Bundle bevat sleutel-waardeparen — eenvoudige typen, Parcelable- of Serializable-objecten. onRestoreInstanceState herstelt de opgeslagen status. Dit patroon is cruciaal voor Android, omdat het systeem de Activity kan vernietigen bij geheugengebrek en herstellen wanneer de gebruiker terugkeert.

Java-syntaxis: klassen, methoden en typen

Java-syntaxis — C-achtig, sterk getypeerd, objectgeoriënteerd. Elk .java-bestand bevat één openbare klasse waarvan de naam overeenkomt met de bestandsnaam. Java ondersteunt geen functies buiten klassen — alles is een methode. Het toegangspunt is de statische methode public static void main(String[] args) voor consoletoepassingen of de levenscyclusmethoden van Android Activity voor mobiel.

Gegevenstypen in Java

Java verdeelt typen in primitieven (int, double, boolean, char, byte, short, long, float) en referentietypen (klassen, interfaces, arrays, enum). Primitieven worden op de stack opgeslagen en doorgegeven op waarde. Objecten — op de heap, doorgegeven via referentie. Autoboxing converteert automatisch een primitief naar een wrapper-object (Integer, Double, Boolean), maar creëert extra objecten — in Android is dit kritisch voor UI-prestaties.

// Voorbeelden van Java-gegevenstypen en -structuren
public class DataTypes {
    // Primitieven
    int count = 42;
    double price = 19.99;
    boolean isActive = true;
    char grade = 'A';

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

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

    // Enum voor vaste set waarden
    public enum Status {
        PENDING, LOADING, SUCCESS, ERROR
    }
}

Generieke typen List<T> zorgen voor typeveiligheid van collecties. De methode getFirst retourneert een element van elk type — het concrete type wordt bepaald op het aanroepspunt. Enum Status wordt gecompileerd naar een klasse met een vaste set constanten, elk exemplaar is een singleton. In Android wordt enum minder gebruikt vanwege geheugenverbruik: ProGuard/R8 optimaliseert enum waar mogelijk naar int-constanten.

Java vs Kotlin: vergelijking in Android

Vergelijking van Java en Kotlin voor Android-ontwikkeling — een van de belangrijkste onderwerpen sinds 2019, toen Google Kotlin tot prioriteitstaal verklaarde. Kotlin is volledig compatibel met Java — beide compileren naar JVM-bytecode, kunnen elkaar aanroepen en dezelfde bibliotheken gebruiken. De benaderingen van het schrijven van code verschillen echter fundamenteel.

Template-code

Kotlin elimineert de omslachtigheid van Java: data class vervangt 50+ regels Java-klasse met getters, setters, equals, hashCode, toString en copy. Null safety is ingebouwd in het typesysteem van Kotlin — NullPointerException is praktisch onmogelijk. Extension-functies maken het mogelijk methoden aan bestaande klassen toe te voegen zonder overerving. Smart Casts converteren automatisch typen na controle.

Prestaties

Qua prestaties zijn Java en Kotlin identiek — beide compileren naar JVM-bytecode, die Android ART op dezelfde manier uitvoert. Het verschil in APK-grootte: Kotlin voegt ~200-400 KB toe voor de kotlin-stdlib-bibliotheek. Java-projecten hebben een kleinere APK-grootte door het ontbreken van extra runtime, maar bij gebruik van Java Stream API en Optional kan de APK-grootte toenemen door desugaring.

Tools voor Java-ontwikkelaars voor Android

Tools voor Java-ontwikkelaars voor Android omvatten Android Studio, Gradle, profiler en emulator. Android Studio — de officiële IDE, gebaseerd op IntelliJ IDEA Community, bevat een editor met Java-autocompletion, code-analysator (lint), refactoring en een visuele layout-editor (Layout Editor).

Belangrijkste tools

Android Gradle Plugin (AGP) versie 8.x beheert de build: compilatie van Java naar klassen, desugaring, minificatie ProGuard/R8, verpakking naar APK/AAB. R8 — verbeterde desugaring en obfuscator, ter vervanging van ProGuard. Build variants (debug/release + product flavors) worden geconfigureerd via build.gradle. Gradle Daemon versnelt volgende builds door caching.

// build.gradle (app) — configuratie van de Java-module
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'
}

Het blok compileOptions specificeert de Java-versie voor compilatie — Java 17 is beschikbaar vanaf AGP 8.x. De minimale SDK (minSdk) bepaalt de minimale Android-versie waarop de app werkt. Target SDK — de versie waarvoor de app is getest. Het verschil tussen compileSdk en targetSdk: compileSdk — API voor compilatie, targetSdk — runtime-gedrag.

Beperkingen van Java in mobiele ontwikkeling

Beperkingen van Java in Android waren de reden voor Google's overstap naar Kotlin. NullPointerException — de meest voorkomende uitzondering in Java-Android-apps, omdat het typesysteem geen onderscheid maakt tussen nullable en non-null referenties. Google raadt @Nullable- en @NonNull-annotaties uit het androidx.annotation-pakket aan, maar de compiler controleert ze niet — alleen lint doet dit.

Het ontbreken van coroutines — nog een beperking: asynchrone bewerkingen in Java vereisen callbacks, AsyncTask (verouderd sinds API 30), ExecutorService of RxJava. Dit leidt tot callback hell en geheugenlekken bij schermrotatie. Kotlin-coroutines met Structured Concurrency lossen dit probleem op taalniveau op: de coroutine wordt geannuleerd bij vernietiging van de Activity zonder handmatig beheer.

Template-code in Java — een bron van fouten bij het handmatig schrijven van equals/hashCode, Parcelable-implementaties en ViewHolder voor RecyclerView. Android KTX-bibliotheken en Jetpack Compose zijn gericht op Kotlin. Nieuwe Android API's (Room, Navigation, Compose) publiceren standaard voorbeelden in Kotlin, hoewel Java-versies bestaan.