Java: ce fel de limbaj este, caracteristicile sale și dezvoltarea Android

Ce este Java?

Java — un limbaj de programare de uz general, creat de compania Sun Microsystems în 1995. Principiul principal — «Write Once, Run Anywhere»: bytecodul compilat Java rulează pe orice platformă unde este instalată mașina virtuală JVM. În contextul dezvoltării mobile, Java a devenit primul limbaj oficial al Android SDK, lansat de Google în 2008.

Arhitectura Java se bazează pe trei componente: JDK (Java Development Kit) — setul de instrumente pentru dezvoltator, JRE (Java Runtime Environment) — mediul de execuție și JVM (Java Virtual Machine) — mașina virtuală. Android folosește propria implementare a JVM — Android Runtime (ART), care a înlocuit Dalvik în versiunea 5.0 (Lollipop). ART execută bytecodul DEX, care este compilat din bytecodul Java prin utilitarul dx/d8.

Caracteristica cheie a Java — gestionarea automată a memoriei prin Garbage Collector (GC). Dezvoltatorul nu trebuie să elibereze explicit memoria — GC monitorizează obiectele neutilizate și le elimină. În Android ART se utilizează Concurrent Mark Sweep (CMS) și Generational GC, optimizate pentru resursele limitate ale dispozitivelor mobile. Aceasta reduce sarcina asupra dezvoltatorului, dar poate cauza «lag-uri» în timpul colectării gunoiului în firul UI.

Versiunile Java și Android API

Android suportă un subset al Java API, care se extinde cu fiecare nouă versiune a sistemului de operare. Android 12 (API 31) a adăugat suportul pentru Java 11, inclusiv lambdas cu capturarea variabilelor, sistemul modular JPMS și clientul HTTP java.net.http. Android 14 (API 34) a introdus suportul experimental pentru Java 17 prin desugaring D8/R8 — unele funcții (records, sealed classes) se traduc în cod compatibil pentru versiunile mai vechi.

Java SDK și dezvoltarea Android

Android SDK include compilatorul Java, utilitarul dex (d8), aapt (Asset Packaging Tool), emulatorul și bibliotecile android.* și java.*. Dezvoltatorul scrie cod în Java, îl compilează în fișiere .class (bytecod JVM), apoi d8 le transformă în fișiere .dex (Dalvik Executable), care sunt ambalate în APK împreună cu resursele și AndroidManifest.xml.

Gradle — sistemul de build al proiectului Android. Fișierul build.gradle (Groovy) sau build.gradle.kts (Kotlin DSL) descrie dependențele, versiunile SDK, flavor-urile (product flavors) și semnăturile. Android Gradle Plugin (AGP) versiunea 8.x automatizează desugar — traducerea funcțiilor moderne Java în cod compatibil retroactiv. De exemplu, java.time.LocalDate se transformă în cod compatibil cu API 21+ fără modificări în codul sursă al dezvoltatorului.

// Un Activity Android simplu în 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("Salut din Java!");
    }

    // Metodă pentru gestionarea clic pe buton
    public void onButtonClick(View view) {
        TextView tv = findViewById(R.id.textView);
        tv.setText("Buton apăsat");
    }
}

Clasa MainActivity moștenește AppCompatActivity — clasa de bază din AndroidX pentru compatibilitate retroactivă. Metoda onCreate este apelată la crearea Activity, în ea se setează layout-ul prin setContentView. findViewById leagă variabila Java de un element din layout-ul XML. Metoda onButtonClick este legată de buton prin atributul android:onClick în XML.

Lucrul cu Activity și ciclul de viață

Ciclul de viață al Activity în Java — o secvență de callback-uri: onCreate → onStart → onResume (activ), onPause → onStop → onDestroy (finalizare). Dezvoltatorul suprascrie aceste metode pentru gestionarea resurselor. onCreate — inițializare, onPause — salvare date, onDestroy — eliberare resurse. Android apelează aceste metode la rotirea ecranului, trecerea în fundal și primirea unui apel.

// Ciclul de viață al Activity cu gestionarea stării
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) {
        // Încărcarea datelor după identificator
    }
}

Metoda onSaveInstanceState salvează starea Activity la rotirea ecranului sau comutarea sarcinilor. Bundle conține perechi cheie-valoare — tipuri simple, obiecte Parcelable sau Serializable. onRestoreInstanceState restaurează starea salvată. Acest model este critic pentru Android, deoarece sistemul poate distruge Activity la insuficiența de memorie și o poate restaura la revenirea utilizatorului.

Sintaxa Java: clase, metode și tipuri

Sintaxa Java — asemănătoare cu C, strict tipizată, orientată pe obiecte. Fiecare fișier .java conține o clasă publică, al cărei nume coincide cu numele fișierului. Java nu suportă funcții în afara claselor — totul este o metodă. Punctul de intrare — metoda statică public static void main(String[] args) pentru aplicații consolă sau metodele ciclului de viață Android Activity pentru mobile.

Tipuri de date în Java

Java împarte tipurile în primitive (int, double, boolean, char, byte, short, long, float) și tipuri de referință (clase, interfețe, array-uri, enum). Primitivile sunt stocate pe stivă și transmise prin valoare. Obiectele — în heap, transmise prin referință. Autoboxing convertește automat primitiva într-un obiect wrapper (Integer, Double, Boolean), dar creează obiecte suplimentare — în Android acest lucru este critic pentru performanța UI.

// Exemple de tipuri de date și structuri Java
public class DataTypes {
    // Primitive
    int count = 42;
    double price = 19.99;
    boolean isActive = true;
    char grade = 'A';

    // Tipuri de referință
    String name = "Android";
    Integer boxed = 100; // autoboxing
    List<String> items = new ArrayList<>();

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

    // Enum pentru un set fix de valori
    public enum Status {
        PENDING, LOADING, SUCCESS, ERROR
    }
}

Genericile List<T> asigură siguranța tipurilor colecțiilor. Metoda getFirst returnează un element de orice tip — tipul concret este determinat la punctul de apel. Enum Status se compilează într-o clasă cu un set fix de constante, fiecare instanță este un singleton. În Android enum este folosit mai rar din cauza consumului de memorie: ProGuard/R8 optimizează enum în constante int acolo unde este posibil.

Java vs Kotlin: comparație în Android

Comparația Java și Kotlin pentru dezvoltarea Android — unul dintre subiectele principale din 2019, când Google a declarat Kotlin limbaj prioritar. Kotlin este complet compatibil cu Java — ambele se compilează în bytecod JVM, se pot apela reciproc și pot folosi aceleași biblioteci. Cu toate acestea, abordările de scriere a codului diferă radical.

Cod șablon

Kotlin elimină prolixitatea Java: data class înlocuiește 50+ de linii ale unei clase Java cu getteri, setteri, equals, hashCode, toString și copy. Null safety este încorporat în sistemul de tipuri Kotlin — NullPointerException este practic imposibilă. Funcțiile de extensie (Extension functions) permit adăugarea de metode la clasele existente fără moștenire. Smart Casts convertesc automat tipurile după verificare.

Performanță

Din punct de vedere al performanței Java și Kotlin sunt identice — ambele se compilează în bytecod JVM, pe care Android ART îl execută la fel. Diferența în dimensiunea APK: Kotlin adaugă ~200-400 KB pentru biblioteca kotlin-stdlib. Proiectele Java au o dimensiune APK mai mică datorită absenței unui runtime suplimentar, dar la utilizarea Java Stream API și Optional dimensiunea APK poate crește din cauza desugaring-ului.

Instrumente pentru dezvoltatorul Java în Android

Instrumentele dezvoltatorului Java pentru Android includ Android Studio, Gradle, profilerul și emulatorul. Android Studio — IDE-ul oficial, bazat pe IntelliJ IDEA Community, include editor cu autocompletare Java, analizor de cod (lint), refactorizare și editor vizual de layout-uri (Layout Editor).

Instrumente principale

Android Gradle Plugin (AGP) versiunea 8.x gestionează build-ul: compilarea Java în clase, desugaring, minificarea ProGuard/R8, ambalarea în APK/AAB. R8 — desugaring și ofuscare îmbunătățită, înlocuind ProGuard. Build variants (debug/release + product flavors) se configurează prin build.gradle. Gradle Daemon accelerează build-urile ulterioare prin memorare în cache.

// build.gradle (app) — configurația modulului 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'
}

Blocul compileOptions specifică versiunea Java pentru compilare — Java 17 este disponibil de la AGP 8.x. SDK-ul minim (minSdk) determină versiunea minimă de Android pe care funcționează aplicația. Target SDK — versiunea pentru care aplicația a fost testată. Diferența între compileSdk și targetSdk: compileSdk — API pentru compilare, targetSdk — comportamentul runtime-ului.

Limitările Java în dezvoltarea mobilă

Limitările Java în Android au devenit motivul tranziției Google la Kotlin. NullPointerException — cea mai frecventă excepție în aplicațiile Java-Android, deoarece sistemul de tipuri nu distinge între referințe nullable și non-null. Google recomandă adnotările @Nullable și @NonNull din pachetul androidx.annotation, dar compilatorul nu le verifică — doar lint face acest lucru.

Lipsa corutinelor — o altă limitare: operațiile asincrone în Java necesită callback-uri, AsyncTask (depreciat de la API 30), ExecutorService sau RxJava. Aceasta duce la callback hell și scurgeri de memorie la rotirea ecranului. Corutinele Kotlin cu Structured Concurrency rezolvă această problemă la nivel de limbaj: corutina este anulată la distrugerea Activity fără gestionare manuală.

Codul șablon în Java — sursă de erori la scrierea manuală a equals/hashCode, implementărilor Parcelable și ViewHolder pentru RecyclerView. Bibliotecile Android KTX și Jetpack Compose sunt orientate către Kotlin. Noile API-uri Android (Room, Navigation, Compose) publică exemple în Kotlin implicit, deși versiunile Java există.