Menjalankan Program Java

Kita sudah bisa mengompilasi, tetapi tahukah Anda bahwa perintah java sesungguhnya mengenal lebih dari satu cara menjalankan program? Cara klasik lewat bytecode hasil javac hanyalah salah satunya; ada mode satu berkas yang melompati kompilasi manual, dan ada format .jar untuk menyerahkan program utuh ke orang lain. Mengenal ketiganya membuat kita memilih jalur yang tepat untuk tiap situasi: latihan cepat, pengembangan harian, hingga distribusi aplikasi. Pada Chapter ini kita akan mencoba ketiga cara tersebut satu per satu dengan contoh yang benar-benar dieksekusi.

Cara Klasik: Kompilasi dengan javac lalu Eksekusi #

Inilah siklus yang kita jalankan pada Chapter Menggunakan Java Compiler: compiler javac menerjemahkan berkas sumber menjadi berkas .class, kemudian launcher java memuat bytecode tersebut ke JVM dan memanggil method main.

javac SapaanCli.java
java SapaanCli Budi Siti

Cara klasik cocok saat program terdiri dari banyak berkas. Seluruh sumber dikompilasi sekali, lalu berkas .class dapat dieksekusi berulang kali tanpa beban kompilasi ulang — penting saat program besar dijalankan berkali-kali. Kata-kata setelah nama class pada contoh di atas (Budi Siti) menjadi argumen program yang diterima array args di method main. Bila berkas .class berada di direktori lain, opsi -cp atau -classpath memberi tahu JVM lokasi yang harus diperiksa, misalnya java -cp bin SapaanCli.

Cara Cepat: Source-File Launcher #

Sejak Java 11, perintah java dapat menerima berkas sumber .java secara langsung: launcher mengompilasi berkas itu di memori, lalu langsung mengeksekusinya. Satu perintah, tanpa javac manual, tanpa berkas .class yang berserakan di direktori kerja.

java SapaanCli.java Budi Siti

Argumen setelah nama berkas tetap diteruskan ke program — perhatikan bahwa nama berkas memakai akhiran .java, sedangkan pada cara klasik kita cukup menulis nama class. Mari kita buktikan dengan program yang menyapa setiap nama yang diberikan:

public class SapaanCli {
    public static void main(String[] args) {
        if (args.length == 0) {
            System.out.println("Pemakaian: java SapaanCli.java <nama> <nama> ...");
            return;
        }
        for (String nama : args) {
            System.out.println("Halo, " + nama + "!");
        }
        System.out.println("Total disapa: " + args.length);
    }
}

Output yang Dihasilkan:

Halo, Budi!
Halo, Siti!
Total disapa: 2

Mari kita telaah baris-baris kode di atas:

1. Baris 3 (if (args.length == 0)): memeriksa apakah pengguna memberikan argumen. Tanpa argumen, program mencetak petunjuk pemakaian, lalu statement return mengakhiri main lebih awal — saat dijalankan tanpa argumen, keluarannya hanya baris petunjuk tersebut.
2. Baris 7-9 (for (String nama : args)): perulangan for-each mengambil setiap elemen array args satu per satu ke variabel nama, lalu mencetak sapaan untuk tiap nama.
3. Baris 11 (args.length): banyaknya elemen array — cara cepat menghitung berapa nama yang disapa.

Sejak Java 22, mode ini bahkan mampu menjalankan program multi-berkas: bila SapaanCli.java merujuk class yang berada di berkas .java lain di direktori yang sama, launcher ikut mengompilasi berkas-berkas itu secara otomatis. Untuk skrip latihan dan program kecil, source-file launcher adalah jalur tercepat.

Cara Distribusi: Berkas jar #

Ketika program harus diserahkan ke pengguna lain, mengirim deretan berkas .class terasa merepotkan. Format JAR (Java Archive) mengemas seluruh berkas .class — beserta sumber daya pendukung seperti berkas teks dan gambar — ke dalam satu berkas berekstensi .jar. Struktur dalamnya mengikuti arsip ZIP dengan satu berkas metadata khusus bernama manifest (META-INF/MANIFEST.MF) yang mencatat, antara lain, class titik masuk program.

Program kecil berikut menjadi bahan pakai kita:

public class AplikasiSapaan {
    public static void main(String[] args) {
        System.out.println("Halo dari berkas jar!");
    }
}

Output yang Dihasilkan:

Halo dari berkas jar!

Pengemasannya memakai alat jar dari direktori bin/ JDK:

javac AplikasiSapaan.java
jar --create --file aplikasi.jar --main-class AplikasiSapaan AplikasiSapaan.class
java -jar aplikasi.jar

Perintah pertama mengompilasi sumber menjadi AplikasiSapaan.class. Perintah kedua membuat arsip aplikasi.jar; opsi --main-class menuliskan nama class utama ke manifest sehingga JVM tahu titik masuknya tanpa perlu disebut lagi. Perintah ketiga menjalankan arsip tersebut. Ketiga perintah itu sudah diverifikasi di lingkungan penulisan Course ini: java -jar aplikasi.jar mencetak Halo dari berkas jar! — persis keluaran blok “Output yang Dihasilkan” di atas. Pengguna yang menerima aplikasi.jar cukup memasang JRE; tidak perlu javac dan tidak perlu berkas sumber.

Memilih Cara yang Tepat #

Ketiganya bertumpu pada fondasi yang sama: bytecode yang dieksekusi JVM. Yang berbeda hanya siapa yang mengompilasi dan dari mana bytecode dimuat. Dengan tiga jalur eksekusi ini di tangan, peralatan baris perintah kita lengkap — dan pada Chapter Memilih IDE dan Editor kita akan melihat editor mana yang paling nyaman mengawasi seluruh siklus tersebut sekaligus.

Referensi #

• java Launcher Reference — Oracle
• Oracle: Learning Java

public class AplikasiSapaan {
    public static void main(String[] args) {
        System.out.println("Halo dari berkas jar!");
    }
}

public class SapaanCli {
    public static void main(String[] args) {
        if (args.length == 0) {
            System.out.println("Pemakaian: java SapaanCli.java <nama> <nama> ...");
            return;
        }
        for (String nama : args) {
            System.out.println("Halo, " + nama + "!");
        }
        System.out.println("Total disapa: " + args.length);
    }
}