Belajar OOP dengan Java - Instalasi & Hello World

#Pendahuluan

Di episode 2 kita membangun kerangka pikir OOP — class, object, dan empat pilar. Sekarang saatnya tangan mulai menulis kode. Episode ini menyelesaikan instalasi yang belum selesai di episode 0, lalu memandu kalian menulis, meng-compile, dan menjalankan program Java pertama: Hello World.

Kenapa Hello World penting dalam konteks OOP? Karena program sekecil ini sudah mengajarkan dua pelajaran fundamental: semua kode Java hidup di dalam class, dan main method adalah pintu masuk eksekusi. Memahami keduanya sejak awal akan mencegah kebingungan di episode 4 dan 5.

#Menyelesaikan Instalasi JDK

Jika kalian belum sempat menginstall di episode 0, sekarang waktunya. Dua jalur utama:

#Jalur A: SDKMAN (Linux/macOS)

curl -s "https://get.sdkman.io" | bash
source "$HOME/.sdkman/bin/sdkman-init.sh"
sdk list java | grep -i temurin
sdk install java 25-tem

Perintah sdk list java menampilkan semua versi yang tersedia; kalian mencari baris dengan label 25-tem (Temurin 25). SDKMAN juga bisa mengaktifkan versi tertentu sebagai default dengan sdk default java 25-tem.

#Jalur B: Installer Resmi (Windows/macOS/Linux)

Unduh installer Temurin dari situs Adoptium dan pilih paket JDK 25 (bukan JRE). Setelah install, pastikan JAVA_HOME menunjuk ke direktori JDK:

java -version
javac -version
echo "$JAVA_HOME"

Di Windows, jalankan perintah yang sama di Command Prompt. Jika javac tidak dikenali padahal JDK sudah terinstall, tambahkan bin direktori JDK ke PATH — di Windows, installernya biasanya sudah melakukannya otomatis.

#Menyiapkan Editor

#IntelliJ IDEA Community

Buka IntelliJ IDEA → New Project → pilih bahasa Java, build system IntelliJ, dan SDK 25. IntelliJ otomatis mengenali JDK dari JAVA_HOME. Untuk series ini, kita tidak memakai Maven/Gradle dulu — cukup SDK murni.

#VS Code

Install extension "Extension Pack for Java" dari Microsoft. Extension ini membawa language server, debugger, dan test runner sekaligus. Setelah terpasang, VS Code akan memakai JDK 25 yang sudah terinstall untuk kompilasi.

Keduanya akan memberi kalian auto-completion, error highlighting, dan kemampuan menjalankan program dengan satu klik. Untuk episode ini, kita tetap berlatih lewat terminal dulu agar memahami proses compile yang sesungguhnya.

#Hello World: Struktur Program Pertama

Buat file Main.java di ~/oop-lab/src:

Main.java

public class Main {
    public static void main(String[] args) {
        System.out.println("Hello, OOP!");
    }
}

Empat bagian penting yang perlu kalian pahami:

1. public class Main — deklarasi class. Nama class wajib sama persis dengan nama file (Main.java).
2. public static void main — signature main method yang wajib tetap seperti ini. public berarti bisa dipanggil dari mana saja, static berarti milik class (bukan object), void berarti tidak mengembalikan nilai.
3. String[] args — argumen baris perintah, dibahas nanti di episode 5.
4. System.out.println(...) — mencetak ke konsol.

#Mengapa main Harus static?

Ini pertanyaan OOP yang bagus. main dipanggil oleh JVM sebelum object apa pun dibuat — JVM belum tahu class apa yang akan di-instantiate. Karena itu main harus static (milik class), sehingga bisa dipanggil tanpa new. Pelajaran ini akan terasa penting lagi di episode 4.

#Compile dan Run

Proses Java dua langkah: javac meng-compile source menjadi bytecode (file .class), lalu java menjalankan bytecode di JVM.

cd ~/oop-lab
javac -d out src/Main.java
java -cp out Main

Hasilnya:

Hello, OOP!

Dua hal yang terjadi:

• javac -d out src/Main.java membaca Main.java, lalu menulis Main.class (bytecode) ke direktori out. Flag -d menentukan direktori output.
• java -cp out Main memuat class Main dari classpath out dan menjalankan main-nya.

Perhatikan: perintah java memakai nama class (Main), bukan nama file (Main.class). Ini khas Java dan menjadi penting saat kita punya banyak class di episode-episode berikutnya.

#Melihat Bytecode

Salah satu hal yang membedakan Java dari bahasa lain: source dikompilasi ke bytecode yang berjalan di JVM, bukan langsung ke mesin. Kalian bisa memeriksa hasil compile:

ls -la out/
javap -c out/Main.class

javap -c menampilkan bytecode dalam bentuk mnemonik. Kalian tidak perlu memahaminya sekarang — yang penting kalian tahu bahwa Java memisahkan "compile" dan "run". Kompabilitas write once, run anywhere lahir dari pemisahan ini: bytecode yang sama bisa dijalankan di Linux, Windows, atau macOS selama JVM-nya ada.

#Workflow Cepat: Menjalankan dari IntelliJ/VS Code

Editor mengotomatiskan langkah javac + java. Di IntelliJ, cukup tekan tombol ▶ (Run) di samping main. Di VS Code, klik "Run" pada dekorator di atas main. Editor juga menampilkan error compile secara langsung saat mengetik — ini mempercepat debugging secara drastis.

#Latihan Kecil

Sebelum lanjut, coba dua modifikasi:

1. Ubah teks dalam println menjadi nama kalian, compile, dan jalankan ulang.
2. Panggil main dua kali dari class yang sama — buat method kedua yang dipanggil dari main, misal public static void sapa(). Ini latihan membiasakan diri bahwa main hanya titik masuk; logika seharusnya dipisah ke method lain.

Main.java versi latihan

public class Main {
    public static void main(String[] args) {
        sapa();
        sapa();
    }
 
    static void sapa() {
        System.out.println("Halo dari method!");
    }
}

#Penutup

Inti yang harus dibawa pulang:

• Install JDK 25 LTS via SDKMAN atau installer resmi; pastikan javac -version berhasil.
• Semua program Java hidup di dalam class; nama class sama dengan nama file.
• public static void main(String[] args) adalah pintu masuk eksekusi yang dipanggil JVM tanpa object.
• Alur compile-run: javac -d out src/Main.java lalu java -cp out Main.
• Editor mempercepat workflow, tetapi memahami perintah terminal lebih penting.

Di episode 4 selanjutnya kita akan membedah class & object secara mendalam — deklarasi class dengan field instance/static, keyword new, reference, serta bagaimana Java menyimpan object di heap dan reference di stack. Pastikan Hello World kalian sudah berjalan, karena pelajaran inti OOP dimulai sekarang!