Java: anong wika ito, mga tampok nito at pag-develop ng Android

Ano ang Java?

Java — isang general-purpose programming language, na nilikha ng Sun Microsystems noong 1995. Ang pangunahing prinsipyo — «Write Once, Run Anywhere»: ang naka-compile na Java bytecode ay tumatakbo sa anumang platform kung saan naka-install ang JVM virtual machine. Sa konteksto ng mobile development, naging unang opisyal na wika ng Android SDK ang Java, na inilabas ng Google noong 2008.

Ang arkitektura ng Java ay batay sa tatlong bahagi: JDK (Java Development Kit) — set ng mga tool ng developer, JRE (Java Runtime Environment) — runtime environment, at JVM (Java Virtual Machine) — virtual machine. Gumagamit ang Android ng sarili nitong implementasyon ng JVM — Android Runtime (ART), na pumalit sa Dalvik sa bersyon 5.0 (Lollipop). Ipinapatupad ng ART ang DEX bytecode, na na-compile mula sa Java bytecode sa pamamagitan ng dx/d8 utility.

Ang pangunahing tampok ng Java — awtomatikong pamamahala ng memorya sa pamamagitan ng Garbage Collector (GC). Hindi kailangang malinaw na maglabas ng memorya ang developer — sinusubaybayan at tinatanggal ng GC ang mga hindi ginagamit na bagay. Sa Android ART, ginagamit ang Concurrent Mark Sweep (CMS) at Generational GC, na na-optimize para sa limitadong resources ng mobile devices. Binabawasan nito ang karga ng developer, ngunit maaaring magdulot ng «lag» sa panahon ng pagtitipon ng basura sa UI thread.

Mga bersyon ng Java at Android API

Sinusuportahan ng Android ang isang subset ng Java API, na lumalawak sa bawat bagong bersyon ng OS. Nagdagdag ang Android 12 (API 31) ng suporta para sa Java 11, kabilang ang mga lambda na may variable capture, modular JPMS system, at HTTP client java.net.http. Ipinakilala ng Android 14 (API 34) ang experimental na suporta para sa Java 17 sa pamamagitan ng D8/R8 desugaring — ang ilang mga feature (records, sealed classes) ay isinasalin sa compatible na code para sa mas lumang bersyon.

Java SDK at pag-develop ng Android

Android SDK ay may kasamang Java compiler, dex (d8) utility, aapt (Asset Packaging Tool), emulator, at mga library na android.* at java.*. Sumulat ang developer ng code sa Java, ini-compile ito sa .class files (JVM bytecode), pagkatapos ay ginagawang .dex files (Dalvik Executable) ng d8 ang mga ito, na naka-package sa APK kasama ng mga resource at AndroidManifest.xml.

Gradle — build system ng Android project. Ang file na build.gradle (Groovy) o build.gradle.kts (Kotlin DSL) ay naglalarawan ng mga dependency, SDK bersyon, product flavors, at mga pirma. Ang Android Gradle Plugin (AGP) bersyon 8.x ay nag-automate ng desugaring — pagsasalin ng mga modernong Java feature sa backward-compatible code. Halimbawa, ang java.time.LocalDate ay nagiging code na compatible sa API 21+ nang walang pagbabago sa source code ng developer.

// Simpleng Android Activity sa 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("Kumusta mula sa Java!");
    }

    // Metodo para sa pag-handle ng click ng button
    public void onButtonClick(View view) {
        TextView tv = findViewById(R.id.textView);
        tv.setText("Button na-click");
    }
}

Ang klase na MainActivity ay nagmamana ng AppCompatActivity — base class mula sa AndroidX para sa backward compatibility. Ang metodo na onCreate ay tinatawag kapag gumawa ng Activity, kung saan naka-set ang layout sa pamamagitan ng setContentView. Ang findViewById ay nag-uugnay ng Java variable sa isang elemento mula sa XML layout. Ang metodo na onButtonClick ay naka-link sa button sa pamamagitan ng attribute na android:onClick sa XML.

Pagtatrabaho sa Activity at lifecycle

Lifecycle ng Activity sa Java — pagkakasunod-sunod ng mga callback: onCreate → onStart → onResume (aktibo), onPause → onStop → onDestroy (pagtatapos). Ang developer ay nag-o-override ng mga metodong ito para pamahalaan ang mga resource. onCreate — inisyalisasyon, onPause — pag-save ng data, onDestroy — pagpapalaya ng mga resource. Tinatawag ng Android ang mga metodong ito sa pag-ikot ng screen, pagpunta sa background, at pagtanggap ng tawag.

// Lifecycle ng Activity na may pamamahala ng estado
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) {
        // Pag-load ng data ayon sa ID
    }
}

Ang metodo na onSaveInstanceState ay nagse-save ng estado ng Activity sa pag-ikot ng screen o paglipat ng mga gawain. Ang Bundle ay naglalaman ng mga key-value pair — mga simpleng uri, Parcelable o Serializable na bagay. Ang onRestoreInstanceState ay nagre-restore ng na-save na estado. Ang pattern na ito ay kritikal para sa Android, dahil maaaring sirain ng system ang Activity kapag kulang ang memorya at ibalik ito kapag bumalik ang user.

Syntax ng Java: mga klase, metodo at uri

Syntax ng Java — parang C, mahigpit na naka-type, object-oriented. Ang bawat .java file ay naglalaman ng isang public class, na ang pangalan ay tumutugma sa pangalan ng file. Hindi sinusuportahan ng Java ang mga function sa labas ng mga klase — lahat ay metodo. Ang entry point — static na metodo na public static void main(String[] args) para sa console applications o mga lifecycle method ng Android Activity para sa mobile.

Mga uri ng data sa Java

Java ay naghahati ng mga uri sa primitives (int, double, boolean, char, byte, short, long, float) at reference types (mga klase, interfaces, array, enum). Ang mga primitive ay naka-store sa stack at ipinapasa ayon sa halaga. Ang mga bagay — sa heap, ipinapasa ayon sa reference. Ang autoboxing ay awtomatikong nagko-convert ng primitive sa wrapper object (Integer, Double, Boolean), ngunit lumilikha ng mga karagdagang bagay — sa Android ito ay kritikal para sa performance ng UI.

// Mga halimbawa ng Java data types at structures
public class DataTypes {
    // Primitives
    int count = 42;
    double price = 19.99;
    boolean isActive = true;
    char grade = 'A';

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

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

    // Enum para sa fixed set ng values
    public enum Status {
        PENDING, LOADING, SUCCESS, ERROR
    }
}

Ang generics List<T> ay nagsisiguro ng type safety ng mga collection. Ang metodo na getFirst ay nagbabalik ng elemento ng anumang uri — ang konkretong uri ay tinutukoy sa punto ng tawag. Ang Enum Status ay nagko-compile sa isang klase na may fixed set ng constants, bawat instance ay singleton. Sa Android, ang enum ay mas madalas gamitin dahil sa pagkonsumo ng memorya: Ino-optimize ng ProGuard/R8 ang enum sa int constants kung posible.

Java vs Kotlin: paghahambing sa Android

Paghahambing ng Java at Kotlin para sa Android development — isa sa mga pangunahing paksa mula noong 2019, nang ideklara ng Google ang Kotlin bilang priority language. Ang Kotlin ay ganap na compatible sa Java — parehong nagko-compile sa JVM bytecode, maaaring tumawag sa isa't isa, at gumamit ng parehong mga library. Gayunpaman, ang mga diskarte sa pagsulat ng code ay lubhang naiiba.

Template code

Inaalis ng Kotlin ang verbosity ng Java: ang data class ay pumapalit sa 50+ linya ng Java class na may getter, setter, equals, hashCode, toString at copy. Ang null safety ay naka-embed sa type system ng Kotlin — ang NullPointerException ay halos imposible. Ang Extension functions ay nagpapahintulot ng pagdagdag ng mga metodo sa mga umiiral na klase nang walang inheritance. Ang Smart Casts ay awtomatikong nagko-convert ng mga uri pagkatapos ng pagsusuri.

Performance

Sa mga tuntunin ng performance, ang Java at Kotlin ay magkapareho — parehong nagko-compile sa JVM bytecode, na parehong pinapatupad ng Android ART. Ang pagkakaiba sa laki ng APK: Nagdadagdag ang Kotlin ng ~200-400 KB para sa kotlin-stdlib library. Ang mga Java project ay may mas maliit na laki ng APK dahil sa kawalan ng karagdagang runtime, ngunit kapag gumagamit ng Java Stream API at Optional, ang laki ng APK ay maaaring tumaas dahil sa desugaring.

Mga tool ng Java developer para sa Android

Mga tool ng Java developer para sa Android ay may kasamang Android Studio, Gradle, profiler at emulator. Android Studio — ang opisyal na IDE, batay sa IntelliJ IDEA Community, may kasamang editor na may autocompletion ng Java, code analyzer (lint), refactoring, at visual na layout editor (Layout Editor).

Mga pangunahing tool

Android Gradle Plugin (AGP) bersyon 8.x ay namamahala ng build: compilation ng Java sa mga klase, desugaring, minification ProGuard/R8, packaging sa APK/AAB. R8 — pinahusay na desugaring at obfuscator, na pumapalit sa ProGuard. Ang build variants (debug/release + product flavors) ay na-configure sa pamamagitan ng build.gradle. Pinapabilis ng Gradle Daemon ang mga susunod na build sa pamamagitan ng caching.

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

Ang block na compileOptions ay tumutukoy ng Java version para sa compilation — ang Java 17 ay available mula sa AGP 8.x. Ang minimum na SDK (minSdk) ay tumutukoy ng pinakamababang bersyon ng Android kung saan gumagana ang app. Target SDK — ang bersyon kung saan na-test ang app. Ang pagkakaiba sa pagitan ng compileSdk at targetSdk: compileSdk — API para sa compilation, targetSdk — behavior ng runtime.

Mga limitasyon ng Java sa mobile development

Mga limitasyon ng Java sa Android ay naging dahilan ng paglipat ng Google sa Kotlin. NullPointerException — ang pinakakaraniwang exception sa Java-Android apps, dahil hindi nakikilala ng type system ang nullable at non-null references. Inirerekomenda ng Google ang @Nullable at @NonNull na anotasyon mula sa androidx.annotation package, ngunit hindi ito sinusuri ng compiler — tanging lint ang gumagawa nito.

Ang kawalan ng coroutines — isa pang limitasyon: ang mga asynchronous na operasyon sa Java ay nangangailangan ng mga callback, AsyncTask (hindi na ginagamit mula noong API 30), ExecutorService o RxJava. Ito ay humahantong sa callback hell at memory leaks sa pag-ikot ng screen. Ang Kotlin coroutines na may Structured Concurrency ay nilulutas ang problemang ito sa antas ng wika: ang coroutine ay kinakansela sa pagkasira ng Activity nang walang manual na pamamahala.

Ang template code sa Java — pinagmumulan ng mga error sa manual na pagsulat ng equals/hashCode, Parcelable implementations, at ViewHolder para sa RecyclerView. Ang Android KTX library at Jetpack Compose ay naka-orient sa Kotlin. Ang mga bagong Android API (Room, Navigation, Compose) ay naglalathala ng mga halimbawa sa Kotlin bilang default, kahit na may mga Java version.