Java #

Java adalah salah satu bahasa pemrograman paling berpengaruh yang pernah ada. Lahir di pertengahan 1990-an dengan janji “write once, run anywhere”, Java berhasil membuktikan klaimnya selama hampir tiga dekade — bertahan melewati gelombang demi gelombang bahasa baru, tetap relevan di era cloud, mobile, dan microservices. Ini bukan kebetulan. Ada keputusan desain yang disengaja, ekosistem yang matang, dan komunitas yang besar di balik ketahanan itu. Dokumentasi ini membahas Java dari akar — bukan sekadar sintaks, tapi bagaimana Java berpikir, bagaimana runtime-nya bekerja, dan mengapa pilihan-pilihan yang tampak aneh di permukaan ternyata punya alasan yang solid.

Apa Itu Java? #

Java adalah bahasa pemrograman berorientasi objek yang berjalan di atas platform virtual bernama Java Virtual Machine (JVM). Yang membuat Java unik dibanding bahasa lain di zamannya adalah pemisahan yang jelas antara kode sumber, kode yang dikompilasi, dan lingkungan tempat kode itu berjalan. Kamu menulis kode Java, lalu kompiler mengubahnya menjadi bytecode — format biner yang bukan kode mesin asli, tapi juga bukan teks yang bisa dibaca manusia. Bytecode inilah yang dijalankan oleh JVM, dan JVM tersedia untuk hampir semua sistem operasi dan arsitektur prosesor yang relevan saat ini.

Hasilnya: program Java yang sama bisa berjalan di Linux, Windows, macOS, bahkan di chip ARM tanpa kompilasi ulang. Di era 1990-an ketika fragmentasi platform adalah mimpi buruk nyata para pengembang, ini adalah revolusi.

Java dipengaruhi oleh banyak bahasa sebelumnya. Sintaks dan sistem tipenya mengambil banyak dari C++, tapi membuang kompleksitas yang dianggap berbahaya — tidak ada pointer aritmetik, tidak ada multiple inheritance yang ambigu, tidak ada manual memory management. Konsep object yang murni datang dari Smalltalk. Ide tentang portabilitas dan platform virtual terinspirasi dari Pascal dan UCSD p-System. Hasilnya adalah bahasa yang terasa familiar bagi programmer C++ tapi jauh lebih aman dan konsisten.

flowchart LR
    A["Kode Sumber\n(.java)"] -->|javac| B["Bytecode\n(.class)"]
    B -->|JVM Linux| C["Program berjalan\ndi Linux"]
    B -->|JVM Windows| D["Program berjalan\ndi Windows"]
    B -->|JVM macOS| E["Program berjalan\ndi macOS"]
    B -->|JVM ARM| F["Program berjalan\ndi ARM / Android"]

Filosofi “write once, run anywhere” ini bukan hanya slogan pemasaran. Ia mencerminkan keputusan arsitektur yang konsisten: Java sengaja memilih abstraksi yang lebih tebal di atas hardware untuk membeli portabilitas. Tradeoff ini membuat Java kadang lebih lambat dari C++ untuk komputasi intensif, tapi jauh lebih produktif untuk aplikasi bisnis, server, dan enterprise yang kebutuhan utamanya bukan raw performance melainkan keandalan dan maintainability.

Sejarah dan Asal-Usul #

Java lahir di Sun Microsystems pada awal 1990-an, diprakarsai oleh James Gosling — seorang ilmuwan komputer asal Kanada yang kemudian dikenal sebagai “Father of Java”. Proyek ini awalnya bernama Green Project, dan tujuan awalnya bukan membuat bahasa server atau web — melainkan membuat software untuk perangkat consumer elektronik: set-top box, remote control, televisi interaktif.

Bahasa yang dikembangkan pertama kali diberi nama Oak (nama pohon ek yang tumbuh di depan kantor Gosling). Tapi nama Oak sudah digunakan perusahaan lain dan tidak bisa dipatenkan. Nama Java dipilih sebagai pengganti — terinspirasi dari kopi Java, jenis kopi yang populer di kalangan programmer. Versi pertama yang dirilis ke publik adalah JDK 1.0 pada 23 Januari 1996.

Timing peluncurannya bertepatan sempurna dengan ledakan popularitas World Wide Web. Java menawarkan sesuatu yang belum ada: applet — program kecil yang bisa disematkan di halaman web dan berjalan di browser pengunjung tanpa instalasi. Netscape Navigator 2.0, browser paling populer saat itu, mengumumkan dukungan Java applet. Dalam semalam, Java menjadi sensasi.

flowchart TD
    A["1991 — Green Project dimulai\nJames Gosling & tim di Sun Microsystems"] --> B["1992 — Prototipe pertama\nBahasa bernama Oak"]
    B --> C["1994 — Pivot ke Web\nTarget: browser dan internet"]
    C --> D["1995 — Java 1.0 diumumkan\nNetscape adopsi Java Applet"]
    D --> E["1996 — JDK 1.0 dirilis\n23 Januari 1996"]
    E --> F["1998 — Java 2 (J2SE 1.2)\nSwing, Collections Framework"]
    F --> G["2004 — Java 5\nGenerics, Annotations, Enums, Autoboxing"]
    G --> H["2014 — Java 8\nLambda, Stream API, Optional"]
    H --> I["2017 — Java 9\nModule System (Project Jigsaw)"]
    I --> J["2018 — Rilis 6 bulan sekali\nJava 11 LTS, 17 LTS, 21 LTS, ..."]

Tapi perjalanan Java tidak selalu mulus. Applet perlahan ditinggalkan karena masalah keamanan dan performa. Sun Microsystems diakuisisi oleh Oracle Corporation pada 2010 dalam transaksi senilai $7,4 miliar. Akuisisi ini membawa kontroversi — Oracle menggugat Google soal penggunaan Java API di Android, kasus hukum yang berlangsung bertahun-tahun sebelum akhirnya diputuskan oleh Mahkamah Agung AS. Tapi di sisi teknis, Oracle justru mempercepat evolusi Java dengan mengadopsi siklus rilis enam bulanan sejak Java 9 (2017) — sebuah perubahan yang dibutuhkan untuk menjaga Java tetap relevan di ekosistem yang bergerak cepat.

Di Mana Java Digunakan? #

Java bukan bahasa akademik. Ia ada di mana-mana di industri, seringkali di bagian yang tidak terlihat tapi paling kritis.

Aplikasi Enterprise dan Backend Server #

Ini adalah habitat utama Java. Sebagian besar aplikasi enterprise berskala besar — perbankan, asuransi, logistik, telekomunikasi — dibangun di atas Java. Framework seperti Spring Boot, Quarkus, dan Micronaut menjadikan Java pilihan utama untuk REST API, microservices, dan sistem yang butuh reliability tinggi. Bank-bank besar di seluruh dunia menjalankan core banking system mereka di Java, bukan karena tren, tapi karena Java sudah terbukti stabil selama puluhan tahun.

Android #

Secara historis, Android development menggunakan Java sebagai bahasa utamanya. Meskipun Google kini merekomendasikan Kotlin, seluruh Android SDK dan framework dibangun di atas platform Java (JVM). Memahami Java berarti memahami fondasi di bawah setiap aplikasi Android — bagaimana lifecycle bekerja, bagaimana memori dikelola, bagaimana threading dan concurrency diimplementasikan.

Big Data dan Data Engineering #

Ekosistem big data modern sangat bergantung pada JVM. Apache Hadoop, Apache Spark, Apache Kafka, Apache Flink, Elasticsearch — semua dibangun di Java atau Scala (yang juga berjalan di JVM). Kalau kamu bekerja di bidang data engineering, pemahaman Java atau Scala adalah kebutuhan praktis, bukan pilihan.

Developer Tools dan IDE #

Hampir semua IDE populer ditulis di Java: IntelliJ IDEA, Eclipse, NetBeans, Android Studio. Build tool seperti Maven dan Gradle juga berbasis JVM. Ini bukan kebetulan — JVM memberikan portabilitas yang dibutuhkan tool yang harus berjalan di berbagai sistem operasi.

flowchart TD
    Java["Java & JVM Ecosystem"] --> Enterprise["Enterprise Backend\nSpring Boot, Quarkus\nCore Banking, ERP"]
    Java --> Android["Mobile - Android\nAndroid SDK\nAndroid Studio"]
    Java --> BigData["Big Data & Streaming\nKafka, Spark, Hadoop\nFlink, Elasticsearch"]
    Java --> Tools["Developer Tools\nIntelliJ, Eclipse\nMaven, Gradle"]
    Java --> Embedded["Embedded & IoT\nJava ME\nSmart Card"]
    Java --> Cloud["Cloud Native\nGCP, AWS Lambda\nKubernetes Operators"]

Java Virtual Machine (JVM) #

JVM adalah inti dari seluruh ekosistem Java. Memahami JVM bukan hanya pengetahuan akademik — ia langsung mempengaruhi bagaimana kamu menulis kode yang efisien, memahami masalah performa, dan men-debug masalah memori.

Cara Kerja JVM #

Ketika kamu menjalankan program Java, urutan kejadiannya seperti ini:

1. Kompiler javac mengubah kode sumber .java menjadi bytecode .class
2. JVM memuat file .class melalui Class Loader
3. Bytecode Verifier memeriksa bahwa bytecode valid dan tidak melanggar aturan keamanan
4. Interpreter menjalankan bytecode baris per baris
5. JIT Compiler (Just-In-Time) mengidentifikasi hot path — bagian kode yang sering dieksekusi — dan mengkompilasinya menjadi kode mesin native untuk performa lebih tinggi

sequenceDiagram
    participant Dev as Developer
    participant javac as Java Compiler
    participant CL as Class Loader
    participant BV as Bytecode Verifier
    participant JIT as JIT Compiler
    participant CPU as CPU / Hardware

    Dev->>javac: javac Main.java
    javac-->>Dev: Main.class (bytecode)
    Dev->>CL: java Main
    CL->>BV: Verifikasi bytecode
    BV-->>CL: Bytecode valid
    CL->>JIT: Eksekusi
    JIT->>CPU: Kompilasi hot path → native code
    CPU-->>Dev: Output program

Garbage Collection #

Salah satu fitur paling penting JVM adalah Garbage Collector (GC) — sistem manajemen memori otomatis. Kamu tidak perlu memanggil free() atau delete seperti di C/C++. JVM secara otomatis mendeteksi objek yang tidak lagi direferensikan dan membebaskan memorinya.

Ada beberapa algoritma GC di JVM modern, masing-masing dengan tradeoff berbeda:

GC yang “otomatis” bukan berarti kamu bisa mengabaikan manajemen memori. Memory leak di Java tetap mungkin terjadi — misalnya menyimpan referensi ke objek di static collection yang tidak pernah dibersihkan. Otomatis di sini artinya JVM yang mengeksekusi pembebasan memori, bukan kamu tidak perlu memikirkan lifetime objek sama sekali.

JVM Bukan Hanya Untuk Java #

Salah satu keputusan desain terbaik dalam sejarah JVM adalah memisahkan platform dari bahasa. JVM hanya peduli pada bytecode — tidak peduli bahasa apa yang menghasilkan bytecode itu. Ini membuka pintu bagi banyak bahasa untuk memanfaatkan ekosistem JVM yang matang:

Java Development Kit (JDK) #

JDK adalah paket yang harus kamu install untuk mengembangkan program Java. JDK bukan hanya runtime — ia menyertakan semua tool yang dibutuhkan selama development.

Komponen JDK #

JDK (Java Development Kit)
  ├── JRE (Java Runtime Environment)
  │   ├── JVM (Java Virtual Machine)
  │   └── Java Class Library (rt.jar / modules)
  ├── javac          ← compiler
  ├── java           ← launcher
  ├── javadoc        ← documentation generator
  ├── jar            ← archive tool
  ├── jdb            ← debugger
  ├── jshell         ← REPL (sejak Java 9)
  ├── jlink          ← custom runtime image builder
  ├── jmap           ← heap dump tool
  └── jstack         ← thread dump tool

Versi LTS dan Siklus Rilis #

Sejak Java 9 (2017), Java dirilis setiap enam bulan. Tidak semua versi mendapat dukungan jangka panjang — hanya versi LTS (Long-Term Support) yang mendapat patch keamanan dan bug fix selama bertahun-tahun.

Untuk proyek baru di 2024–2025, Java 21 adalah pilihan yang tepat. Ia adalah LTS terbaru dengan fitur paling modern termasuk virtual threads — yang mengubah cara penulisan kode concurrent secara fundamental. Untuk proyek yang sudah ada, Java 17 adalah target upgrade yang aman sebelum melangkah ke 21.

Varian JDK #

Karena Java adalah platform open source (OpenJDK), berbagai vendor menyediakan distribusi JDK mereka sendiri. Semua mengikuti spesifikasi yang sama (JSR, JEP), tapi masing-masing punya optimasi dan kebijakan support yang berbeda:

Untuk kebanyakan proyek, Eclipse Temurin (dari Adoptium) atau Amazon Corretto adalah pilihan yang aman — gratis, tanpa batasan lisensi produksi, dan mendapat dukungan jangka panjang.

Karakteristik Bahasa Java #

Memahami mengapa Java dibuat dengan cara tertentu lebih penting dari sekadar hafal sintaksnya. Berikut karakteristik inti yang membentuk cara Java berpikir.

Strongly Typed dan Statically Typed #

Java adalah bahasa yang strongly typed — setiap variabel punya tipe yang jelas, dan tipe tidak bisa diubah secara implisit. Ini berbeda dari JavaScript atau Python yang lebih permissif. Di Java, kamu harus eksplisit:

// Java: tipe harus dideklarasikan
int jumlah = 42;
String nama = "Budi";
double harga = 15_000_000.0;

// Sejak Java 10: var untuk local variable type inference
var items = new ArrayList<String>(); // compiler tahu ini ArrayList<String>

// ANTI-PATTERN yang tidak mungkin di Java:
// jumlah = "empat puluh dua"; // kompilasi error

Static typing berarti tipe dicek saat kompilasi, bukan saat runtime. Bug tipe tertangkap sebelum program dijalankan — ini keunggulan besar untuk codebase besar di mana runtime errors jauh lebih mahal.

Berorientasi Objek #

Java adalah bahasa OOP yang konsisten — hampir segalanya adalah objek. Ada sedikit pengecualian untuk primitive types (int, long, double, boolean, dll.) demi performa, tapi setiap primitive punya wrapper class-nya (Integer, Long, Double, Boolean).

// Primitive: disimpan langsung di stack, bukan sebagai objek
int angka = 42;
double pi = 3.14159;

// Wrapper class: diperlukan saat butuh objek (generics, collections)
Integer angkaObj = Integer.valueOf(42);
List<Integer> daftar = new ArrayList<>(); // tidak bisa List<int>

// Autoboxing: Java otomatis mengkonversi antara primitive dan wrapper
daftar.add(100);         // int → Integer secara otomatis
int nilai = daftar.get(0); // Integer → int secara otomatis

Platform Independence #

Prinsip “write once, run anywhere” diimplementasikan melalui bytecode dan JVM. Bytecode Java bersifat platform-neutral — ia bukan instruksi untuk x86, bukan untuk ARM, melainkan instruksi untuk mesin virtual abstrak yang kemudian diterjemahkan oleh JVM ke kode mesin asli di platform yang bersangkutan.

Memory Safety #

Java menghilangkan kategori bug yang paling berbahaya di C/C++:

• Tidak ada pointer aritmetik — kamu tidak bisa menulis ke sembarang alamat memori
• Array bounds checking — akses indeks di luar batas selalu memunculkan exception, bukan undefined behavior
• Garbage collection — memori dibebaskan otomatis, menghilangkan use-after-free dan double-free
• Null safety (parsial) — meski NullPointerException masih ada, Java modern semakin baik mendeteksinya via annotation dan Optional

// ANTI-PATTERN: code yang bisa NPE
String nama = getNama(); // bisa return null
System.out.println(nama.toUpperCase()); // NullPointerException jika null!

// BENAR: gunakan Optional untuk nilai yang mungkin null
Optional<String> nama = getNamaOptional();
nama.ifPresent(n -> System.out.println(n.toUpperCase()));

// Atau dengan map
String hasil = nama.map(String::toUpperCase).orElse("(tidak ada)");

Ekosistem dan Komunitas #

Java bukan hanya bahasa — ia adalah ekosistem. Kematangan ekosistem ini adalah salah satu alasan utama Java masih sangat relevan setelah hampir tiga dekade.

Maven Central Repository #

Maven Central adalah repositori library Java terbesar di dunia, dengan ratusan ribu artifact yang tersedia secara gratis. Butuh library untuk parsing JSON? Ada Jackson dan Gson. Butuh HTTP client? Ada OkHttp dan Apache HttpClient. Butuh dependency injection? Ada Spring dan Guice. Hampir selalu ada library yang matang dan teruji untuk kebutuhan apapun.

Build Tools #

Framework Utama #

Apa yang Akan Dipelajari di Dokumentasi Ini #

Dokumentasi ini disusun dari fondasi ke topik lanjutan, mengikuti alur yang membangun pemahaman secara bertahap — bukan kumpulan referensi yang dilempar begitu saja.

flowchart TD
    A["Dasar\nSintaks, Tipe Data, Variabel\nKontrol Alur, Fungsi, Kelas"] --> B["Lanjutan\nConcurrency, I/O, Stream\nUnit Test, Networking"]
    B --> C["Topik Lainnya\nDatabase SQL & NoSQL\nMessage Broker, Cache\nFramework & Library"]
    C --> D["Standard Library\nStrings, IO, Math\ndan modul lainnya"]

Section Dasar membahas fondasi: sintaks Java, sistem tipe, variabel, operator, kontrol alur (if-else, switch, loop), fungsi (method), kelas dan OOP, interface, exception handling, hingga collection framework (List, Map) dan build tools.

Section Lanjutan masuk ke topik yang membedakan programmer Java biasa dari yang mahir: multi-threading dan concurrency, I/O blocking vs non-blocking, socket programming, web server, unit testing dengan JUnit, mocking dengan Mockito, dan Stream API yang mengubah cara menulis kode iteratif.

Section Topik Lainnya bersifat praktis: integrasi Java dengan berbagai teknologi yang sering ditemui di dunia nyata — database relasional (MySQL, PostgreSQL, Oracle, MSSQL), database NoSQL (MongoDB, Elasticsearch), message broker (Kafka, RabbitMQ, Amazon SQS), cache (Redis, Memcached), dan framework populer (Spring Boot, Quarkus).

Section Standard Library membahas modul-modul bawaan Java yang sering digunakan: manipulasi string, operasi I/O, fungsi matematika, dan lainnya.

Ringkasan #

• Java adalah platform, bukan hanya bahasa — kode Java dikompilasi ke bytecode yang berjalan di JVM, bukan langsung ke kode mesin. Ini adalah fondasi dari “write once, run anywhere”.
• JVM adalah mesin virtual yang canggih — ia bukan sekadar interpreter. JIT compiler, garbage collector, dan profiler terintegrasi membuat JVM performa tinggi untuk beban kerja produksi.
• Pilih JDK yang tepat — untuk proyek baru, gunakan Java 21 LTS. Untuk distribusi JDK, Eclipse Temurin atau Amazon Corretto adalah pilihan yang aman dan bebas lisensi.
• Static typing adalah aset, bukan beban — bug tipe tertangkap saat kompilasi, bukan saat runtime. Di codebase besar, ini menghemat banyak waktu debugging.
• Ekosistem adalah kekuatan terbesar Java — ratusan ribu library di Maven Central, framework yang matang, dan komunitas yang besar berarti solusi untuk hampir setiap masalah sudah ada dan teruji.
• Java modern bukan Java lama — Java 8 membawa lambda dan Stream API. Java 17 membawa sealed classes dan pattern matching. Java 21 membawa virtual threads. Java terus berkembang — jangan nilai berdasarkan kesan lama.
• GC otomatis bukan berarti bebas masalah memori — memory leak tetap bisa terjadi jika kamu menyimpan referensi yang tidak perlu. Pahami cara GC bekerja untuk menulis kode yang efisien.