Java: milyen nyelv ez, jellemzői és Android fejlesztés

Mi az a Java?

Java — egy általános célú programozási nyelv, amelyet a Sun Microsystems hozott létre 1995-ben. A fő alapelv — «Write Once, Run Anywhere»: a lefordított Java bájtkód bármely platformon fut, ahol a JVM virtuális gép telepítve van. A mobilfejlesztés kontextusában a Java lett az Android SDK első hivatalos nyelve, amelyet a Google 2008-ban adott ki.

A Java architektúrája három összetevőn alapul: JDK (Java Development Kit) — fejlesztői eszközkészlet, JRE (Java Runtime Environment) — futásidejű környezet, és JVM (Java Virtual Machine) — virtuális gép. Az Android a JVM saját implementációját használja — Android Runtime (ART), amely az 5.0 (Lollipop) verzióban váltotta fel a Dalvikot. Az ART a DEX bájtkódot futtatja, amelyet a dx/d8 segédprogrammal Java bájtkódból fordítanak.

A Java egyik kulcsjellemzője — automatikus memóriakezelés a Garbage Collector (GC) segítségével. A fejlesztőnek nem kell explicit módon felszabadítania a memóriát — a GC nyomon követi a nem használt objektumokat és eltávolítja azokat. Az Android ART-ban Concurrent Mark Sweep (CMS) és Generational GC kerül használatra, amelyek optimalizálva vannak a mobileszközök korlátozott erőforrásaira. Ez csökkenti a fejlesztő terhelését, de «lagokat» okozhat a szemétgyűjtés során az UI szálban.

Java verziók és Android API

Az Android a Java API egy részhalmazát támogatja, amely minden új OS verzióval bővül. Az Android 12 (API 31) hozzáadta a Java 11 támogatását, beleértve a változókat befogó lambda kifejezéseket, a moduláris JPMS rendszert és a java.net.http HTTP klienst. Az Android 14 (API 34) bevezette a Java 17 kísérleti támogatását D8/R8 desugaring segítségével — egyes funkciók (records, sealed classes) kompatibilis kódra fordulnak régebbi verziókhoz.

Java SDK és Android fejlesztés

Android SDK tartalmazza a Java fordítót, a dex (d8) segédprogramot, az aapt-ot (Asset Packaging Tool), az emulátort és az android.* és java.* könyvtárakat. A fejlesztő Java-ban ír kódot, lefordítja .class fájlokká (JVM bájtkód), majd a d8 .dex fájlokká (Dalvik Executable) alakítja azokat, amelyek az erőforrásokkal és az AndroidManifest.xml-lel együtt APK-ba csomagolódnak.

A Gradle — az Android projekt build rendszere. A build.gradle (Groovy) vagy build.gradle.kts (Kotlin DSL) fájl leírja a függőségeket, SDK verziókat, termékváltozatokat (product flavors) és aláírásokat. Az Android Gradle Plugin (AGP) 8.x verziója automatizálja a desugaringot — a modern Java funkciók visszafelé kompatibilis kódra fordítását. Például a java.time.LocalDate API 21+ kompatibilis kóddá alakul a fejlesztő forráskódjának változtatása nélkül.

// Egyszerű Android Activity Java-ban
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("Helló Java-ból!");
    }

    // Metódus gombnyomás kezelésére
    public void onButtonClick(View view) {
        TextView tv = findViewById(R.id.textView);
        tv.setText("Gomb megnyomva");
    }
}

A MainActivity osztály az AppCompatActivity-t — az AndroidX alaposztályát örökli a visszafelé kompatibilitásért. Az onCreate metódus az Activity létrehozásakor hívódik meg, benne a layout a setContentView segítségével kerül beállításra. A findViewById összeköti a Java változót az XML elrendezés egy elemével. Az onButtonClick metódus az android:onClick XML attribútum segítségével kapcsolódik a gombhoz.

Munka az Activity-vel és életciklus

Az Activity életciklusa Java-ban — a callback-ek sorozata: onCreate → onStart → onResume (aktív), onPause → onStop → onDestroy (befejezés). A fejlesztő felülírja ezeket a metódusokat az erőforrások kezeléséhez. onCreate — inicializálás, onPause — adatok mentése, onDestroy — erőforrások felszabadítása. Az Android ezeket a metódusokat hívja meg képernyő forgatásakor, háttérbe kerüléskor és hívás fogadásakor.

// Activity életciklus állapotkezeléssel
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) {
        // Adatok betöltése azonosító alapján
    }
}

Az onSaveInstanceState metódus elmenti az Activity állapotát képernyő forgatásakor vagy feladatok váltásakor. A Bundle kulcs-érték párokat tartalmaz — egyszerű típusokat, Parcelable vagy Serializable objektumokat. Az onRestoreInstanceState visszaállítja a mentett állapotot. Ez a minta kritikus az Android számára, mert a rendszer megsemmisítheti az Activity-t memóriahiány esetén, és visszaállíthatja, amikor a felhasználó visszatér.

Java szintaxis: osztályok, metódusok és típusok

A Java szintaxisa — C-szerű, szigorúan típusos, objektumorientált. Minden .java fájl egy publikus osztályt tartalmaz, amelynek neve megegyezik a fájl nevével. A Java nem támogatja a függvényeket osztályokon kívül — minden metódus. A belépési pont — a statikus public static void main(String[] args) metódus konzolalkalmazásokhoz vagy az Android Activity életciklus metódusai mobilos alkalmazásokhoz.

Java adattípusok

Java a típusokat primitívekre (int, double, boolean, char, byte, short, long, float) és referenciatípusokra (osztályok, interfészek, tömbök, enum) osztja. A primitívek a veremben tárolódnak és érték szerint adódnak át. Az objektumok — a kupacban, referencia szerint adódnak át. Az autoboxing automatikusan konvertálja a primitívet egy burkoló objektummá (Integer, Double, Boolean), de extra objektumokat hoz létre — Androidban ez kritikus az UI teljesítménye szempontjából.

// Példák Java adattípusokra és struktúrákra
public class DataTypes {
    // Primitívek
    int count = 42;
    double price = 19.99;
    boolean isActive = true;
    char grade = 'A';

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

    // Metódus Generics-szel
    public <T> T getFirst(List<T> list) {
        return list.isEmpty() ? null : list.get(0);
    }

    // Enum rögzített értékkészlethez
    public enum Status {
        PENDING, LOADING, SUCCESS, ERROR
    }
}

A generikusok List<T> biztosítják a gyűjtemények típusbiztonságát. A getFirst metódus bármilyen típusú elemet visszaad — a konkrét típus a hívás helyén kerül meghatározásra. Az Enum Status egy osztállyá fordul, rögzített konstanskészlettel, minden példány singleton. Androidban az enum ritkábban használt a memóriafogyasztás miatt: a ProGuard/R8 optimalizálja az enum-ot int konstansokká ahol lehetséges.

Java vs Kotlin: összehasonlítás Androidban

A Java és Kotlin összehasonlítása Android fejlesztéshez — az egyik fő téma 2019 óta, amikor a Google a Kotlint prioritásos nyelvvé nyilvánította. A Kotlin teljes mértékben kompatibilis a Java-val — mindkettő JVM bájtkódra fordul, hívhatják egymást és használhatják ugyanazokat a könyvtárakat. Azonban a kódírási megközelítések gyökeresen különböznek.

Sablon kód

A Kotlin kiküszöböli a Java terjengősségét: a data class helyettesíti a Java osztály 50+ sorát getterekkel, setterekkel, equals, hashCode, toString és copy metódusokkal. A null safety be van építve a Kotlin típusrendszerébe — a NullPointerException gyakorlatilag lehetetlen. Az Extension functions lehetővé teszik metódusok hozzáadását meglévő osztályokhoz öröklődés nélkül. A Smart Casts automatikusan konvertálja a típusokat ellenőrzés után.

Teljesítmény

Teljesítmény szempontjából a Java és Kotlin azonos — mindkettő JVM bájtkódra fordul, amelyet az Android ART ugyanúgy hajt végre. A különbség az APK méretében: a Kotlin ~200-400 KB-ot ad hozzá a kotlin-stdlib könyvtárért. A Java projektek kisebb APK mérettel rendelkeznek a plusz futásidejű környezet hiánya miatt, de a Java Stream API és Optional használatakor az APK mérete nőhet a desugaring miatt.

Java fejlesztő eszközei Androidhoz

A Java fejlesztő eszközei Androidhoz magukban foglalják az Android Studio-t, a Gradle-t, a profilozót és az emulátort. Az Android Studio — a hivatalos IDE, amely az IntelliJ IDEA Community-n alapul, tartalmaz Java autokompletálással ellátott szerkesztőt, kódanalizátort (lint), refaktorálást és vizuális elrendezésszerkesztőt (Layout Editor).

Fő eszközök

Android Gradle Plugin (AGP) 8.x verzió kezeli a buildet: a Java osztályokká fordítását, desugaringot, ProGuard/R8 minifikációt, APK/AAB csomagolást. Az R8 — továbbfejlesztett desugaring és obfuszkátor, amely felváltja a ProGuard-ot. A build variants (debug/release + product flavors) a build.gradle segítségével konfigurálható. A Gradle Daemon a gyorsítótárazással felgyorsítja a későbbi buildeket.

// build.gradle (app) — Java modul konfigurációja
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'
}

A compileOptions blokk határozza meg a Java verziót a fordításhoz — a Java 17 elérhető az AGP 8.x-től. A minimális SDK (minSdk) meghatározza az Android minimális verzióját, amelyen az alkalmazás fut. A Target SDK — a verzió, amelyre az alkalmazást tesztelték. A különbség a compileSdk és targetSdk között: compileSdk — API a fordításhoz, targetSdk — futásidejű viselkedés.

Java korlátozásai mobilfejlesztésben

A Java korlátozásai Androidban vezettek a Google Kotlinra való áttéréséhez. A NullPointerException — a leggyakoribb kivétel Java-Android alkalmazásokban, mert a típusrendszer nem különbözteti meg a nullable és non-null referenciákat. A Google az @Nullable és @NonNull annotációkat ajánlja az androidx.annotation csomagból, de a fordító nem ellenőrzi őket — csak a lint teszi ezt.

A korutinok hiánya — egy másik korlátozás: az aszinkron műveletek Java-ban callback-eket, AsyncTask-ot (elavult API 30-tól), ExecutorService-t vagy RxJava-t igényelnek. Ez callback hell-hez és memóriaszivárgáshoz vezet képernyő forgatáskor. A Kotlin coroutines a Structured Concurrency-vel megoldja ezt a problémát nyelvi szinten: a korutin az Activity megsemmisítésekor kézi kezelés nélkül törlődik.

A sablon kód Java-ban — hibák forrása az equals/hashCode, Parcelable implementációk és ViewHolder kézi írásakor a RecyclerView-hoz. Az Android KTX könyvtárak és a Jetpack Compose a Kotlinra összpontosítanak. Az új Android API-k (Room, Navigation, Compose) alapértelmezésben Kotlin példákat tesznek közzé, bár Java verziók is léteznek.