Java : qu'est-ce que ce langage, ses caractéristiques et le développement Android

Qu'est-ce que Java ?

Java est un langage de programmation généraliste créé par Sun Microsystems en 1995. Le principe principal est « Write Once, Run Anywhere » : le bytecode Java compilé s'exécute sur n'importe quelle plateforme disposant de la machine virtuelle JVM. Dans le contexte du développement mobile, Java est devenu le premier langage officiel du SDK Android, publié par Google en 2008.

L'architecture Java repose sur trois composants : JDK (Java Development Kit) — ensemble d'outils de développement, JRE (Java Runtime Environment) — environnement d'exécution et JVM (Java Virtual Machine) — machine virtuelle. Android utilise sa propre implémentation de la JVM — Android Runtime (ART), qui a remplacé Dalvik dans la version 5.0 (Lollipop). ART exécute le bytecode DEX, compilé à partir du bytecode Java via l'utilitaire dx/d8.

Une caractéristique clé de Java est la gestion automatique de la mémoire via le Garbage Collector (GC). Le développeur n'a pas besoin de libérer la mémoire explicitement — le GC suit les objets inutilisés et les supprime. Dans Android ART, Concurrent Mark Sweep (CMS) et Generational GC sont utilisés, optimisés pour les ressources limitées des appareils mobiles. Cela réduit la charge du développeur, mais peut provoquer des « lags » lors du garbage collection sur le thread UI.

Versions Java et API Android

Android prend en charge un sous-ensemble de l'API Java qui s'étend avec chaque nouvelle version du système d'exploitation. Android 12 (API 31) a ajouté la prise en charge de Java 11, incluant les lambdas avec capture de variables, le système de modules JPMS et le client HTTP java.net.http. Android 14 (API 34) a introduit la prise en charge expérimentale de Java 17 via le desugaring D8/R8 — certaines fonctionnalités (records, sealed classes) sont traduites en code compatible pour les anciennes versions.

Java SDK et développement Android

Le SDK Android comprend le compilateur Java, l'utilitaire dex (d8), aapt (Asset Packaging Tool), l'émulateur et les bibliothèques android.* et java.*. Le développeur écrit du code en Java, le compile en fichiers .class (bytecode JVM), puis d8 les convertit en fichiers .dex (Dalvik Executable), qui sont empaquetés dans APK avec les ressources et AndroidManifest.xml.

Gradle est le système de build des projets Android. Le fichier build.gradle (Groovy) ou build.gradle.kts (Kotlin DSL) décrit les dépendances, les versions du SDK, les flavors et les signatures. Android Gradle Plugin (AGP) version 8.x automatise le desugar — traduction des fonctionnalités Java modernes en code rétrocompatible. Par exemple, java.time.LocalDate est converti en code compatible API 21+ sans modification du code source du développeur.

// Activity Android simple en 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!");
    }

    // Méthode pour gérer le clic du bouton
    public void onButtonClick(View view) {
        TextView tv = findViewById(R.id.textView);
        tv.setText("Button clicked");
    }
}

La classe MainActivity étend AppCompatActivity — une classe de base d'AndroidX pour la rétrocompatibilité. La méthode onCreate est appelée lors de la création de l'Activity ; elle définit le layout via setContentView. findViewById lie une variable Java à un élément du layout XML. La méthode onButtonClick est liée au bouton via l'attribut android:onClick dans le XML.

Travailler avec Activity et le cycle de vie

Le cycle de vie d'Activity en Java est une séquence de callbacks : onCreate → onStart → onResume (actif), onPause → onStop → onDestroy (fin). Le développeur surcharge ces méthodes pour gérer les ressources. onCreate — initialisation, onPause — sauvegarde des données, onDestroy — libération des ressources. Android appelle ces méthodes lors de la rotation de l'écran, du passage en arrière-plan et de la réception d'un appel.

// Cycle de vie d'Activity avec gestion d'état
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) {
        // Chargement des données par identifiant
    }
}

La méthode onSaveInstanceState sauvegarde l'état de l'Activity lors de la rotation de l'écran ou du changement de tâche. Bundle contient des paires clé-valeur — types simples, objets Parcelable ou Serializable. onRestoreInstanceState restaure l'état sauvegardé. Ce modèle est critique pour Android, car le système peut détruire l'Activity en cas de faible mémoire et la restaurer au retour de l'utilisateur.

Syntaxe Java : classes, méthodes et types

La syntaxe Java est de type C, fortement typée, orientée objet. Chaque fichier .java contient une classe publique dont le nom correspond au nom du fichier. Java ne prend pas en charge les fonctions en dehors des classes — tout est méthode. Le point d'entrée est la méthode statique public static void main(String[] args) pour les applications console ou les méthodes du cycle de vie d'Android Activity pour les mobiles.

Types de données Java

Java divise les types en primitifs (int, double, boolean, char, byte, short, long, float) et types de référence (classes, interfaces, tableaux, enum). Les primitifs sont stockés sur la pile et passés par valeur. Les objets sont dans le tas, passés par référence. L'autoboxing convertit automatiquement un primitif en objet wrapper (Integer, Double, Boolean), mais crée des objets supplémentaires — dans Android, c'est critique pour les performances de l'UI.

// Exemples de types de données et structures Java
public class DataTypes {
    // Primitifs
    int count = 42;
    double price = 19.99;
    boolean isActive = true;
    char grade = 'A';

    // Types de référence
    String name = "Android";
    Integer boxed = 100; // autoboxing
    List<String> items = new ArrayList<>();

    // Méthode avec Génériques
    public <T> T getFirst(List<T> list) {
        return list.isEmpty() ? null : list.get(0);
    }

    // Enum pour ensemble fixe de valeurs
    public enum Status {
        PENDING, LOADING, SUCCESS, ERROR
    }
}

Les génériques List<T> assurent la sécurité des types pour les collections. La méthode getFirst retourne un élément de n'importe quel type — le type spécifique est déterminé au point d'appel. Enum Status est compilé en une classe avec un ensemble fixe de constantes, chaque instance est un singleton. Dans Android, enum est moins utilisé en raison de la consommation mémoire : ProGuard/R8 optimise enum en constantes int lorsque c'est possible.

Java vs Kotlin : comparaison dans Android

La comparaison de Java et Kotlin pour le développement Android est l'un des sujets principaux depuis 2019, lorsque Google a déclaré Kotlin comme langage prioritaire. Kotlin est totalement compatible avec Java — les deux compilent vers le bytecode JVM, peuvent s'appeler mutuellement et utiliser les mêmes bibliothèques. Cependant, les approches d'écriture du code diffèrent radicalement.

Code boilerplate

Kotlin élimine la verbosité de Java : data class remplace 50+ lignes d'une classe Java avec getters, setters, equals, hashCode, toString et copy. La sécurité null est intégrée au système de types de Kotlin — NullPointerException est pratiquement impossible. Les fonctions d'extension permettent d'ajouter des méthodes aux classes existantes sans héritage. Smart Casts convertissent automatiquement les types après une vérification.

Performances

En termes de performances, Java et Kotlin sont identiques — les deux compilent vers le bytecode JVM, qu'Android ART exécute de la même manière. La différence réside dans la taille de l'APK : Kotlin ajoute ~200-400 Ko pour la bibliothèque kotlin-stdlib. Les projets Java ont une taille d'APK plus petite en raison de l'absence de runtime supplémentaire, mais avec Java Stream API et Optional, la taille de l'APK peut augmenter à cause du desugaring.

Outils du développeur Java pour Android

Les outils du développeur Java pour Android incluent Android Studio, Gradle, le profileur et l'émulateur. Android Studio est l'IDE officiel, basé sur IntelliJ IDEA Community, avec un éditeur à autocomplétion Java, un analyseur de code (lint), du refactoring et un éditeur visuel de layouts (Layout Editor).

Outils principaux

Android Gradle Plugin (AGP) version 8.x gère le build : compilation Java en classes, desugaring, minification ProGuard/R8, empaquetage en APK/AAB. R8 est un desugaring et obfuscateur mis à jour, remplaçant ProGuard. Les variantes de build (debug/release + product flavors) sont configurées via build.gradle. Gradle Daemon accélère les builds suivants grâce au caching.

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

Le bloc compileOptions spécifie la version Java pour la compilation — Java 17 est disponible avec AGP 8.x. Le SDK minimum (minSdk) détermine la version minimale d'Android sur laquelle l'application fonctionne. Target SDK est la version avec laquelle l'application a été testée. La différence entre compileSdk et targetSdk : compileSdk est l'API pour la compilation, targetSdk est le comportement à l'exécution.

Limitations de Java dans le développement mobile

Les limitations de Java dans Android ont conduit à la transition de Google vers Kotlin. NullPointerException est l'exception la plus courante dans les applications Java Android, car le système de types ne distingue pas les références nullable et non-null. Google recommande les annotations @Nullable et @NonNull du package androidx.annotation, mais le compilateur ne les vérifie pas — seul lint le fait.

L'absence de coroutines est une autre limitation : les opérations asynchrones en Java nécessitent des callbacks, AsyncTask (obsolète depuis API 30), ExecutorService ou RxJava. Cela mène au callback hell et aux fuites mémoire lors de la rotation de l'écran. Les coroutines de Kotlin avec Structured Concurrency résolvent ce problème au niveau du langage : une coroutine est annulée lors de la destruction de l'Activity sans gestion manuelle.

Le code boilerplate en Java est une source d'erreurs lors de l'écriture manuelle de equals/hashCode, des implémentations Parcelable et du ViewHolder pour RecyclerView. Les bibliothèques Android KTX et Jetpack Compose sont orientées vers Kotlin. Les nouvelles API Android (Room, Navigation, Compose) publient des exemples par défaut en Kotlin, bien que des versions Java existent.