Belajar OOP dengan Java - Modern Java 26 & Ekosistem

#Pendahuluan

JDK 25 LTS kita pakai sebagai fondasi di episode 0-19. Episode ini membuka dua lembar: pertama, JDK 26 (rilis 17 Maret 2026) — feature release terbaru yang menunjukkan arah Java; kedua, dan yang lebih penting untuk karier kalian, ekosistem produksi: build tool Maven/Gradle, framework Spring Boot, dan cara kerja JVM.

Mengapa penting? Karena di dunia kerja, kalian jarang menulis Java telanjang. Kalian akan berada di proyek Maven/Gradle, di atas Spring Boot, di dalam JVM yang di-tuning. Memahami ekosistem ini — bukan hanya bahasanya — yang membedakan junior yang bisa menulis kode dari engineer yang bisa mengoperasikan sistem.

#Java 26: Feature Release Terbaru

JDK 26 dirilis 17 Maret 2026 sebagai feature release — didukung hingga September 2026 (6 bulan). Empat hal yang menonjol:

#HTTP/3 (JEP 517)

HTTP/3 — protokol berbasis QUIC di atas UDP — datang ke java.net.http dengan dukungan Java HTTP Client:

HTTP client modern

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
 
public class PanggilApi {
    public static void main(String[] args) throws Exception {
        HttpClient client = HttpClient.newBuilder()
                .version(HttpClient.Version.HTTP_3)
                .build();
 
        HttpRequest request = HttpRequest.newBuilder()
                .uri(URI.create("https://api.example.com/data"))
                .GET()
                .build();
 
        HttpResponse<String> respon = client.send(request, HttpResponse.BodyHandlers.ofString());
        System.out.println(respon.statusCode());
    }
}

Manfaat HTTP/3 untuk aplikasi nyata: latensi lebih rendah (tanpa head-of-line blocking), koneksi lebih tahan terhadap kehilangan paket — sangat relevan untuk mobile dan jaringan tak stabil. Client HTTP bawaan Java semakin serius menyaingi library eksternal.

#AOT Object Caching (JEP 516)

Ahead-of-time object caching (JEP 516) mengizinkan object immutable tertentu dibuat sebelum aplikasi jalan — JVM memuatnya dari image yang sudah disiapkan, bukan membuatnya saat runtime. Efeknya: startup lebih cepat dan memory lebih rendah untuk object yang sering dipakai dan memang tidak berubah. Ini melengkapi tren data-oriented dari episode 19 — makin banyak data immutable yang bisa dioptimasi JVM.

#Final Semantics (JEP 500)

Keyword final yang selama ini kita pakai (episode 6, 18) mendapatkan semantik yang lebih tegas: field final kini memiliki jaminan pembaruan yang lebih kuat — menulis field final dijamin terlihat setelah constructor selesai (happens-before), sehingga object immutable lebih aman dibagikan antar thread tanpa sinkronisasi tambahan.

Final field yang aman dibagikan

public class Konfigurasi {
    private final String host; // aman dibagikan antar thread setelah publish
 
    public Konfigurasi(String host) {
        this.host = host;
    }
}

Ini memperkuat argumen episode 6 dan 18: immutable object bukan hanya praktik baik, tetapi sekarang dijamin oleh model memori JVM.

#Perbaikan G1 GC

G1, garbage collector default, terus ditingkatkan: pause yang lebih singkat untuk heap besar dan alokasi yang lebih efisien. Tanpa mengubah kode, aplikasi di JDK 26 merasakan GC yang lebih mulus — pengingat bahwa performa Java sering datang dari upgrade runtime, bukan rewrite kode.

#Ekosistem Build: Maven & Gradle

#Maven

Maven mengatur proyek dengan konvensi: src/main/java untuk source, src/test/java untuk test, dan pom.xml untuk konfigurasi. Kita sudah menyentuhnya di episode 16:

<project>
    <modelVersion>4.0.0</modelVersion>
    <groupId>com.example</groupId>
    <artifactId>oop-lab</artifactId>
    <version>1.0.0</version>
 
    <properties>
        <maven.compiler.release>25</maven.compiler.release>
    </properties>
 
    <dependencies>
        <dependency>
            <groupId>org.junit.jupiter</groupId>
            <artifactId>junit-jupiter</artifactId>
            <version>5.13.4</version>
            <scope>test</scope>
        </dependency>
    </dependencies>
</project>

maven.compiler.release menargetkan Java 25 — compiler memastikan kode hanya memakai API Java 25. Perintah inti: mvn compile, mvn test, mvn package.

#Gradle

Gradle menawarkan flexibility dengan DSL (Groovy/Kotlin) dan build yang sangat cepat (incremental). Di Android dan banyak proyek modern, Gradle menjadi default:

plugins {
    java
}
 
repositories {
    mavenCentral()
}
 
dependencies {
    testImplementation("org.junit.jupiter:junit-jupiter:5.13.4")
}
 
java {
    toolchain {
        languageVersion.set(JavaLanguageVersion.of(25))
    }
}

Pilihannya bukan soal benar-salah: Maven untuk konvensi dan determinisme, Gradle untuk fleksibilitas dan kecepatan. Keduanya memahami struktur OOP proyek kalian — package, module, dan dependency.

#Spring Boot: DI + IoC dalam Praktik

#Container IoC

Spring Boot adalah ekosistem produksi paling dominan untuk Java backend. Intinya: Inversion of Control (IoC) container — framework yang mengelola lifecycle object dan meng-inject dependency secara otomatis (episode 14 — DI dan composition root diindustrialisasi).

Bean dan constructor injection

import org.springframework.stereotype.Service;
 
@Service
public class LayananPesanan {
    private final RepositoriPesanan repositori;
 
    public LayananPesanan(RepositoriPesanan repositori) {
        this.repositori = repositori;
    }
}

Spring melihat LayananPesanan butuh RepositoriPesanan, lalu menyediakannya — tanpa new, tanpa composition root manual. Annotation @Service mendaftarkan class sebagai bean yang dikelola container.

REST controller Spring

import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;
 
@RestController
public class KontrolPesanan {
    private final LayananPesanan layanan;
 
    public KontrolPesanan(LayananPesanan layanan) {
        this.layanan = layanan;
    }
 
    @GetMapping("/pesanan")
    public String daftar() {
        return "daftar pesanan";
    }
}

Perhatikan polanya: constructor injection — persis yang kita bangun manual di episode 14. Semua prinsip OOP yang kalian pelajari (encapsulation, polymorphism, SOLID, DI) terlihat langsung di sini.

#Kenapa Memahami Spring Menjadi Mudah?

Karena kalian sudah membangun fondasinya di series ini. Spring Boot hanyalah otomasi dari:

• DI/DIP (episode 14) — container sebagai composition root.
• Polymorphism (episode 8) — satu interface, banyak bean.
• AOP/Proxy (episode 15) — dekorator/transaksi transparan.
• Facade (episode 15) — auto-configuration yang menyembunyikan kerumitan.

Jika episode 6-15 terasa abstrak, lihatlah Spring Boot sebagai "bukti hidup" bahwa prinsip-prinsip itu memang dipakai industri.

#Cara Kerja JVM: HotSpot JIT dan GC

#HotSpot JIT

"Java lambat" adalah mitos yang sudah lama mati. HotSpot JVM mengeksekusi bytecode dan memakai JIT compiler (Just-In-Time): kode yang sering dijalankan (hot code) di-compile ke native machine code saat runtime.

Hasilnya: aplikasi yang makin lama berjalan makin cepat, karena JIT terus mengoptimasi jalur yang panas. Inilah alasan server Java bisa bersaing dengan C++ untuk workload nyata.

#Garbage Collector

Java tidak perlu free() manual — GC membebaskan object yang tidak lagi dirujuk (ingat heap vs stack di episode 4). GC modern (G1 default, ZGC untuk latensi ekstrem) bekerja di background dengan pause yang sangat singkat.

Kalau GC bekerja baik, kalian tidak perlu memikirkannya — itu desainnya. Intervensi manual biasanya bukan kebutuhan, melainkan gejala desain (terlalu banyak object hidup, memory leak).

#Penutup

Inti yang harus dibawa pulang:

• JDK 26 (17 Mar 2026): HTTP/3, AOT object caching, final semantics tegas, G1 lebih baik — arah Java makin modern.
• Maven/Gradle — build tool dengan konvensi/determinisme vs fleksibilitas/kecepatan.
• Spring Boot adalah DI + IoC dalam praktik: container sebagai composition root otomatis.
• HotSpot JIT meng-compile bytecode panas ke native; GC membebaskan object tanpa intervensi.
• Ekosistem memahami OOP kalian — fondasi di episode 6-15 berlaku langsung di dunia nyata.

Di episode 21 selanjutnya kita akan membahas clean code & refactoring — penamaan, method kecil, YAGNI/DRY, code smells, extract method, dan replace conditional with polymorphism. Sampai jumpa di episode 21!