Bab V - Subrutin

Pemrograman kompleks
Salah satu cara yang digunakan untuk memecah permasalahan kompleks menjadi permasalahan yang
lebih kecil adalah dengan subrutin. Subrutin terdiri dari sekelompok perintah yang melakukan suatu
tugas tertentu. Subrutin memiliki nama, sehingga bisa dipanggil suatu saat di bagian lain program.
Ketika komputer mengeksekusi program, setiap kali nama subrutin tersebut dipanggil, program akan
melaksanakan semua perintah di dalam subrutin tersebut.
Subrutin boleh digunakan berulang-ulang, dari mana pun di dalam program, bahkan dari dalam
subrutin lain. Dengan cara ini kita bisa membuat subrutin sederhana yang digunakan berulang-ulang di
seluruh program. Dengan cara ini, program besar dapat dipecah menjadi bagian-bagian kecil. yang
masing-masing melakukan perintah sederhana.
Seperti dijelaskan sebelumnya, subrutin bisa berbentuk statik atau non-statik. Dalam bagian ini hanya
subrutin statik yang akan dijelaskan lebih lanjut. Subrutin non-statik adalah inti dari pemrograman
berorientasi objek, dan akan dijelaskan lebih lanjut pada bab berikutnya.
Kotak Hitam
Subrutin terdiri dari beberapa instruksi yang melakukan suatu tugas tertentu, dikumpulkan
dalam satu himpunan, dan diberi nama. Kumpulan instruksi ini bisa berupa suatu "tugas" yang
cukup kompleks yang disatukan sebagai konsep. Dengan cara ini, kita tidak perlu lagi
memikirkan bagaimana komputer melakukan tugas hingga sedetail mungkin. Kita hanya perlu
memanggil nama subrutin tersebut untuk menjalankan suatu "tugas".
Subrutin sering juga disebut dengan kotak hitam (atau black box) karena kita tidak perlu (atau
tidak mau tahu) secara detail apa yang subrutin tersebut lakukan. Kita hanya ingin tahu
hubungan kotak hitam tersebut dengan dunia luar. ubungan ini disebut antar muka (inter!ace).
Di kotak itu mungkin ada tombol yang bisa kita tekan, ada keyboard yang bisa kita ketik, atau
mungkin ada jendela untuk memberi dan mengambil in!ormasi dari dalamnya.
Karena kita bermaksud untuk menyembunyikan kompleksitas (dalam hal ini program yang akan
kita buat), ada beberapa prinsip penting dari suatu kotak hitam "
Antar muka harus sederhana, jelas, tak berbelit-belit, dan mudah dimengerti.
#pa contoh kotak hitam di sekitar kita$ Sebetulnya banyak, misalnya %&, handphone, D&D
player, '() player, kulkas, #*, dan sebagainya. Kita bisa menyalakan %&, mengganti channel,
menaikkan dan menurunkan +olume dengan mudah tanpa harus mengetahui bagaimana %&
bekerja. Sama halnya dengan #*, #nda cukup menekan tombol, menaikkan dan menurunkan
temperatur tanpa harus mengerti bagaimana #* bekerja.
Sekarang mari kita lihat bagian dalam dari kotak hitam. ,agaimana #* atau %& bekerja disebut
dengan implementasi. #turan kedua dari suatu kotak hitam adalah "
Untuk menggunakan kotak hitam, kita tidak perlu mengetahui tentang
implementasi. Yang kita butuh adalah antar muka.
Sebetulnya kita bisa mengganti implementasi selama apa yang dihasilkan dan apa yang diminta
tetap sama. #tau dengan kata lain, perilakunya tidak berubah. 'isalnya dulu %& menggunakan
tabung hampa, tetapi sekarang menggunakan transistor. %etapi perubahan implementasi (dari
tabung hampa ke transistor) tidak mengubah bagaimana %& dioperasikan dan apa yang kita
lihat di %&. Seperti halnya dengan program, kita bisa mengubah implementasi suatu subrutin,
misalnya mengoptimasi subrutin tersebut agar lebih cepat, tanpa mengubah perilaku program
secara keseluruhan, dan tanpa mengubah perilaku !ungsi lain yang memanggil subrutin tersebut.
%entunya untuk membuat kotak hitam, kita perlu mengetahui detail tentang implementasinya.
Kotak hitam digunakan untuk membantu baik si pembuat kotak hitam maupun penggunanya.
(ada akhirnya, kotak hitam tersebut akan digunakan dalam bermacam-macam situasi. -rang
yang membuat kotak hitam ini tidak perlu mengerti bagaimana kotaknya akan digunakan.
(embuatnya hanya menjamin bah.a kotak yang dibuat harus bekerja sesuai dengan yang
diharapkan. #turan ketiga dari kotak hitam "
Pembuat implementor! kotak hitam tidak perlu tahu bagaimana kotak hitam itu
akan digunakan.
Dengan kata lain, kotak hitam membagi dunia menjadi / bagian, yaitu bagian luar, untuk apa ia
digunakan, dan bagian dalam, yaitu detail bagaimana ia bekerja.
#ntar muka kotak hitam tidak melulu harus berupa koneksi !isik antara kotak hitam dengan
dunia luar. #ntar muka bisa juga berupa spesi!ikasi yang menjelaskan apa yang dilakukan kotak
hitam tersebut, dan perilakunya terhadap input yang diterimanya. %idak cukup untuk
menyebutkan bah.a %& membutuhkan colokan kabel, tetapi harus disebutkan bah.a colokan
kabel digunakan untuk menyambung aliran listrik ke %& supaya %& bisa dinyalakan.
Dalam bahasa pemrograman, antar muka dari suatu subrutin harus terdiri dari komponen sintaks
dan semantik. ,agian sintaks dari subrutin mengandung penjelasan tentang apa yang harus
diketik untuk memanggil subrutin tersebut. Dan bagian semantik menjelaskan bagaimana secara
khusus apa yang akan dikerjakan oleh subrutin tersebut. 0ntuk menulis program yang benar,
kita harus mengetahui spesi!ikasi sintaks dari subrutin tersebut. 0ntuk mengerti dan bisa
menggunakan subrutin tersebut see!ekti! mungkin, kita harus mengetahui spesi!ikasi
semantiknya. Kedua bagian dari subrutin tersebut bisa disebut sebagai kontrak subrutin.
Kontrak subrutin bisa dijelaskan seperti "1ni yang harus #nda lakukan untuk menggunakan
saya, dan ini yang akan saya lakukan untuk #nda". Ketika kita menulis subrutin, komentar yang
kita tulis untuk menjelaskan subrutin itu harus memuat kontrak subrutin tersebut. Kadang kala
kontrak ini seringkali tidak dituliskan dengan benar, sehingga programmer yang
menggunakannya harus menerka apa yang akan dilakukan. %entu saja ini tidak e!isien dan
menghabiskan banyak .aktu apabila kita harus menerka semua subrutin yang terdapat dalam
bahasa pemrograman.
Subrutin Statik dan Variabel Statik
Setiap subrutin yang dideklarasikan dalam 2a+a harus dideklarasikan di dalam suatu Kelas (*lass). al
ini mungkin membuat 2a+a sedikit tidak normal, karena dalam bahasa pemrograman lain, subrutin bisa
diletakkan di mana saja termasuk di luar kelas. Salah satu dari !ungsi kelas adalah menggabungkan
subrutin dan +ariabel bersama. Dan ini tidak mudah apabila subrutin dan +ariabel berada di luar kelas,
terutama apabila beberapa paket harus digabungkan menjadi satu seperti dalam program kompleks.
#kan terdapat banyak kebingungan yang mungkin diakibatkan dari nama subrutin atau nama +ariabel
yang sama.
Subrutin yang dideklarasikan di dalam kelas disebut dengan metode (method). Di bab kemudian kita
akan menggunakan istilah metode, tetapi bab ini kita akan menggunakan subrutin dalam artiannya
sebagai subrutin statik. 'etode akan digunakan untuk subrutin non-statik yang lebih merupakan si!at
dari objek, dan bukan bagian dari kelas itu sendiri.
De!inisi subrutin dalam bahasa pemrograman 2a+a dapat dituliskan dalam bentuk
sifat tipe_keluaran nama_subrutin ( daftar parameter ) {
perintah
}
Kita sudah pernah mende!inisikan suatu subrutin, yaitu subrutin main(). (aling tidak kita sudah kenal
bagaimana subrutin dide!inisikan.
perintah yang terdapat di antara 3 dan 4 disebut juga badan subrutin. (erintah ini merupakan badan
atau implementasi suatu subrutin, seperti yang dibahas sebelum pada penjelasan tentang kotak hitam.
(erintah ini merupakan instruksi yang akan dieksekusi oleh komputer pada saat subrutin ini dipanggil.
sifat adalah si!at dari subrutin itu sendiri. ,eberapa si!at yang pernah kita lihat adalah static dan
public. #da lebih dari selusin si!at yang bisa diberikan kepada subrutin.
2ika kita akan membuat !ungsi, yaitu subrutin yang menghitung suatu nilai kemudian mengembalikan
hasilnya, maka tipe_keluaran adalah tipe data dari keluaran yang dihasilkan oleh !ungsi tersebut.
Kita akan membahas lebih lanjut tentang keluaran pada bagian berikutnya. 2ika subrutin kita bukan
!ungsi dan tidak menghasilkan nilai apa-apa, kita gunakan tipe data spesial yang dinamakan void untuk
menunjukkan bah.a tidak ada nilai keluaran yang akan dikembalikan oleh subrutin tersebut.
#khirnya kita sampai pada da!tar parameter. (arameter adalah bagian dari antar muka suatu subrutin.
(arameter adalah in!ormasi yang diberikan kepada suatu subrutin dari dunia luar, untuk digunakan
dalam eksekusi subrutin tersebut. Kasus sederhana misalnya tele+isi memiliki subrutin ganti*hannel().
(ertanyaan yang akan muncul adalah ganti channel ke mana$ Dalam hal ini parameter dapat
digunakan, misalnya channel berbentuk bilangan bulat (int) dan deklarasi subrutin ganti*hannel dapat
berbentuk seperti
public void gantiChannel(int channel) {
...
}
(ernyataan tersebut berarti subrutin ganti*hannel() memiliki parameter channel yang bertipe int. #kan
tetapi channel belum memiliki nilai. 5ilainya akan diberikan pada saat subrutin ini dipanggil, misalnya
dengan
gantiChannel(17);
Da!tar parameter dari suatu subrutin bisa juga kosong, atau bisa berisi lebih dari satu parameter dalam
bentuk
tipe_data nama_parameter
2ika ada lebih dari satu parameter, maka parameter-perameter tersebut dihubungkan dengan koma.
*atatan bah.a masing-masing parameter harus terdiri dari satu tipe data dan satu nama, misalnya
double x, double dan bukan double x, .
(arameter akan dijelaskan lebih lanjut pada bagian berikutnya.
,erikut ini adalah beberapa contoh deklarasi subrutin yang umum dilakukan "
public static void main!ame() {
// "public" dan "static" ada sifat; "void" adalah tipe_keluaran
// "mainGame" adalah nama subrutin
// daftar parameternya kosong
... // perintah untuk memainkan game ditulis di bagian ini
}

int ambil"data(int ") {
// tidak ada sifat, "int" adalah tipe_keluaran
// "ambilNdata" adalah nama subrutin
// dan parameternya adalah N yang memiliki tipe data int
... // perintah untuk mengambil N data ditulis di bagian ini
}

static boolean kurang#ari(double x, double ) {
// "static" adalah sifat, "boolean" adalah tipe_keluaran
// "kurangDari" adalah nama subrutin
// parameternya ada 2, yaitu yang bertipe data double
// dan y yang !uga bertipe data double
.... // perintah untuk mengu!i apakah lebih kecil dari y ditulis di sini
}
Dalam contoh kedua perhatikan bah.a si!atnya tidak "static", dan subrutin ini tidak dibahas dalam
bagian ini. Subrutin pertama memiliki si!at "public" yang artinya subrutin ini dapat dipanggil dari
bagian manapun, termasuk dari luar kelas yang dimaksud.
#da lagi si!at subrutin yaitu "pri+ate" yang berarti hanya bisa dipanggil dari dalam kelas di mana
subrutin tersebut dide!inisikan. Si!at "public" dan "pri+ate" dinamakan penentu akses (access speci!ier).
2ika tidak disebutkan jenis aksesnya dalam suatu de!inisi subrutin, maka otomatis subrutin itu memiliki
si!at "package" yang artinya hanya bisa dipanggil dari paket yang sama dari kelas di mana ia
dide!inisikan. Si!at lain yang berkaitan dengan penentu akses adalah "protected" dan ini akan dibahas
lebih lanjut pada bagian tentang pemrograman berorientasi objek.
1ngatkah bah.a subrutin main() yang biasa kita gunakan dalam contoh-contoh program memiliki
bentuk seperti berikut $
public static main($tring%& args) { ... }
Si!atnya adalah "public" dan "static", namanya adalah "main" dan parameternya adalah args yang
bertipe data array dari String. Kita akan bahas tentang array pada bagian struktur data di bab
berikutnya.
"enjalankan subrutin
Ketika kita mende!inisikan subrutin, pada dasarnya kita memberitahu 2a+a bah.a suatu subrutin
tersedia dalam suatu kelas. Subrutin tersebut tidak dijalankan sampai ia dipanggil. (al ini juga berlaku
untuk kelas main(), meskipun kita tinggal memanggilnya secara spesi!ik, tetapi sistem operasi kita
akan memanggil subrutin main() pada saat program tersebut dijalankan.) 'isalnya subrutin
main!ame() di atas dapat dipanggil seperti
main!ame();
(ernyataan ini dapat dipanggil di mana pun dalam kelas yang sama, meskipun dari dalam subrutin yang
berbeda, misalnya dari dalam subrutin main(). Karena main!ame() bersi!at "public", maka subrutin ini
dapat juga dipanggil dari luar kelas di mana ia dideklarasikan. 'isalnya, main!ame() dideklarasikan
dalam kelas 6undu, maka main6ame dapat dipanggil dari kelas lain seperti
!undu.main!ame();
(enggunaan nama kelas di sini berarti memberitahu 2a+a di mana subrutin main!ame() harus dicari
(dalam hal ini di dalam kelas 6undu). Dan ini juga membedakan bah.a yang dimainkan adalah 6undu,
bukan Catur.main!ame() atau 'lar(angga.main!ame().
7ebih umum, untuk memanggil suatu subrutin dapat dilakukan dengan bentuk
nama_subrutin(parameter);
Dan untuk memanggil subrutin dari luar kelas, bisa dilakukan dalam bentuk
nama_kelas.nama_subrutin(parameter);
apabila subrutin tersebut memiliki si!at "static". #pabila subrutin tersebut tidak bersi!at "statik" maka
nama8kelas harus diganti dengan nama objek jelmaan kelas tersebut. (#kan dijelaskan lebih jauh nanti
pada bab tentang pemrograman berorientasi objek).
2uga, apabila tidak ada parameter yang dide!inisikan, maka parameter bisa dihilangkan, tetapi tanda
kurungnya () harus tetap ada meskipun kosong.
Variabel Statik
Suatu kelas juga bisa berisi lain hal selain subrutin, misalnya +ariabel. &ariabel juga bisa dide!inisikan
di dalam subrutin, yang disebut +ariabel lokal. 0ntuk membedakannya +ariabel yang dide!inisikan di
dalam kelas disebut +ariabel anggota, karena +ariabel tersebut adalah anggota kelas.
Seperti subrutin, +ariabel juga bisa bersi!at statik atau non-statik. Di bagian ini kita hanya akan
membahas +ariabel statik. &ariabel anggota statik dimiliki oleh kelas, dan akan selalu ada selama kelas
tersebut ada. Komputer akan menyiapkan memori tempat penyimpanan +ariabel statik pada saat 2a+a
interpreter dijalankan.
(erubahan +ariabel statik ini akan mengubah isi memori tersebut, tidak peduli dari bagian program
mana perubahan +ariabel ini dilakukan. Kapanpun +ariabel ini dipanggil, ia akan mengambil data dari
memori di mana dia disimpan, tidak peduli bagian program mana yang memanggilnya. 1ni berarti
+ariabel statik bisa diisi dari subrutin satu dan dimodi!ikasi dari subrutin lainnya. #tau dengan kata
lain, +ariabel statik digunakan bersama oleh seluruh bagian kelas. &ariabel lokal hanya bisa dipanggil
dari dalam subrutin di mana ia dideklarasikan.
Deklarasi +ariabel anggota dapat dilakukan dengan cara yang sama seperti deklarasi +ariabel dalam
subrutin. Kecuali, mereka juga bisa diberi attribut yang berisi si!atnya, misalnya "static", "public", atau
"pri+ate". 'isalnya,
static int umur;
static private double x;
Seperti halnya penentu akses pada subrutin, +ariabel yang bersi!at "pri+ate" hanya bisa diakses dari
dalam kelas yang bersangkutan, sedangkan +ariabel "public" dapat diakses dari manapun. 'isalnya,
kelas System, memiliki +ariabel out, sehingga bisa kita panggil dari luar dengan $stem.)ut.
Ketika kita mendeklarasikan suatu +ariabel di dalam subrutin, kita harus memberi nilai a.al untuk
+ariabel tersebut. #kan tetapi untuk +ariabel anggota, 2a+a otomatis memberi nilai a.al, sehingga tidak
perlu diinisialisasi terlebih dahulu. 'isalnya int akan diberi nilai a.al 9, karakter diberi nilai yang
berupa karakter dengan nilai 0nicode 9, dan String diberi nilai a.al null, sementara boolean diberi
nilai a.al !alse.
Kita tentu saja bisa memberi nilai a.al apabila nilai a.al yang diberi 2a+a tidak cocok dengan aplikasi
kita. *aranya misalnya dengan memberi nilai di a.al subrutin main().
#ontoh Subrutin - "engubah Program $ata$ata
Kita mulai dengan program :ata:ata yang kita bahasa pada bagian tentang .hile dan do ...
.hile.
(erhatikan bah.a di dalam program tersebut kita harus menulis berulang-ulang untuk
mendapatkan input data dari user. Sekarang kita akan pisahkan kode untuk mengambil input
dari user dalam kelas yang dinamakan Konsol1nput.
(ertama-tama buat project baru di ;clipse yang dinamakan :ata:ata/. *aranya "<ile -= 5e. -=
2a+a (roject" kemudian masukkan :ata:ata/.
Kemudian buat kelas baru yang dinamakan Konsol1nput. "<ile -= 5e. -= *lass", masukkan
package ratarata/ dan 5ame Konsol1nput seperti gambar berikut "
Kita akan membuat subrutin statik yang dinamakan ambilDouble() yang tugasnya memberi
pertanyaan kepada user, mengambil input dari user dan mengubah input dari user menjadi
bilangan real (tipe data double).
Kita bisa de!inisikan subrutin ini dengan
public static double ambil#)uble($tring pertanaan) { ... }
"public" dan "static" adalah si!at subrutin ini, "double" merupakan tipe data keluarannya karena
kita ingin subrutin ini mengembalikan input bertipe double sehingga siap untuk digunakan.
"ambilDouble" adalah nama subrutin ini, dan "String pertanyaan" adalah parameternya yaitu
berupa pertanyaan yang diberikan kepada user pada saat data akan diambil.
#pa yang harus dilakukan sekarang$ Kita ambil perintah untuk mengambil data dari :ata:ata
yaitu "
double bilangan * +;
,uffered-eader br * new ,uffered-eader(new
.nput$tream-eader($stem.in));
$tring strbilangan * null;

$stem.)ut.print(/0asukkan bilangan pertama 1 /);
try {
strbilangan * br.read2ine();
} catch (.34xcepti)n i)e) {
$stem.)ut.println(/5esalahan .3, pr)gram berhenti/);
$stem.exit(1);
}

// mengubah input men!adi double agar bisa diproses lebih lan!ut
bilangan * #)uble.parse#)uble(strbilangan);
1ngat bah.a parameter "String pertanyaan" adalah pertanyaan yang akan kita ajukan kepada
user, sehingga baris
$stem.)ut.print(/0asukkan bilangan pertama 1 /);
kita ganti dengan
$stem.)ut.print(pertanaan);
Kita akan kembalikan "bilangan" kepada si pemanggil, sehingga di akhir subrutin kita beri
perintah
return bilangan;
yang berarti kembalikan bilangan kepada si pemanggil !ungsi ini.
2angan lupa juga untuk menambahkan import 6a7a.i).8; di a.al kelas karena
,u!!ered:eader adalah anggota dari paket ini. Sekarang subrutin ambilDouble() menjadi seperti
ini
package ratarata9;

import 6a7a.i).8;

public class 5)ns)l.nput {

public static double ambil#)uble($tring pertanaan) {
$tring strbilangan * null;
,uffered-eader br * new ,uffered-eader(new
.nput$tream-eader($stem.in));
double bilangan;

$stem.)ut.print(pertanaan);
try {
strbilangan * br.read2ine();
} catch (.34xcepti)n i)e) {
$stem.)ut.println(/5esalahan .3, pr)gram berhenti/);
$stem.exit(1);
}

bilangan * #)uble.parse#)uble(strbilangan);
return bilangan;
}

}
Kemudian kita buat kelas baru yang dinamakan :ata:ata/, seperti pada gambar berikut "
Dengan menggunakan subrutin yang baru kita buat, kita modi!ikasi program :ata:ata menjadi
:ata:ata/ sebagai berikut "
package ratarata9;

public class -ata-ata9 {

/**
* @param args
*/
public static void main($tring%& args) {
// "#D# $uto%generated method stub
double 6umlah * +;
double bilangan * +;
int n * +;

bilangan * 5)ns)l.nput.ambil#)uble(/0asukkan bilangan pertama 1 /);

while (bilangan :* +) {
6umlah ;* bilangan; // sama dengan & !umlah ' !umlah (
bilangan
n;;; // sama dengan & n ' n()

bilangan * 5)ns)l.nput.ambil#)uble(/0asukkan bilangan berikutna
(atau + untuk mengakhiri) 1 /);
}

// hitung rata%rata
double ratarata * 6umlah<n;

// cetak hasilnya ke layar
if (n ** +) {
$stem.)ut.println(/#ata k)s)ng, rata=rata tidak bisa dihitung/);
} else {
$stem.)ut.println(/>nda memasukkan / ; n ; / data/);
$stem.)ut.println(/-ata=rata bilangan ang dimasukkan adalah / ;
ratarata);
}
}
}
(erhatikan beberapa perubahan di dalam program ini. (ertama, kita hapus perintah-perintah
untuk mengambil input dari user karena sudah kita implementasikan pada subrutin
ambilDouble() di kelas Konsol1nput.
Di kelas :ata:ata/, kita panggil subrutin ambilDouble() dengan perintah
bilangan * 5)ns)l.nput.ambil#)uble(/0asukkan bilangan pertama 1 /);
dan
bilangan * 5)ns)l.nput.ambil#)uble(/0asukkan bilangan berikutna
(atau + untuk mengakhiri) 1 /);
di mana parameternya adalah pertanyaan yang diberikan kepada user sebelum memasukkan
data.
asil keluarannya sama dengan pada kelas :ata:ata
(rogram di atas dapat diunduh dalam bentuk >ip !ile atau melalui gudang S&5 di alamat "
http%&&belajarja'a.google(ode.(om&s'n&trunk&$ata$ata)
#ontoh Program Subrutin dan Variabel Statik
'ari kita lihat kembali dan kita akan ubah program 'ainSuit pada halaman ini.
(ertama-tama kita akan ubah algoritma untuk menentukan siapa yang menang. Dalam program
sebelumnya, kita gunakan pernyataan s.itch case, yaitu kita tuliskan semua kemungkinan
dalam permainan.
2ika #nda ingat, 2empol dilambangkan dengan 9, %elunjuk dilambangkan dengan ?, dan
Kelingking dilambangkan dengan /. *ara lain untuk menentukan pemenangnya adalah dengan
mengurangi suitKomputer dan suit0ser
delta * suit5)mputer = suit'ser;
#pabila delta @ 9, maka permainan berakhir seri. Sekarang coba masukkan apabila komputer 9
(2empol) dan user ? (%elunjuk). Dalam hal ini delta bernilai -?, dan ini berarti komputer
menang. Dengan kata lain, apabila delta bernilai -? maka komputer menang, dan apabila delta
bernilai ?, maka user menang.
*oba lagi juga komputer 9 (2empol) dan user / (Kelingking). Dalam hal ini delta -/, dan ini
berarti user menang sesuai dengan aturan bah.a Kelingking menang mela.an 2empol.
Dengan si!at seperti di atas, kita bisa ubah pernyataan s.itch case pada program sebelumnya
dengan
// menghitung siapa yang menang
int delta * suit5)mputer = suit'ser;

switch (delta) {
case +1
seri;;;
$stem.)ut.println(/?asilna 1 $eri/);
break;
case 11
case =91
user0enang;;;
$stem.)ut.println(/?asilna 1 >nda menang/);
break;
case =11
case 91
k)mputer0enang;;;
$stem.)ut.println(/?asilna 1 >nda kalah/);
break;
}
Kemudian, kita tambahkan lagi +ariabel statik yang !ungsinya digunakan untuk mendata berapa
kali komputer menang, berapa kali #nda menang dan berapa kali seri.
public static int user0enang * +;
public static int k)mputer0enang * +;
public static int seri * +;
Kemudian kita akan pindahkan sebagian kode pada subrutin main sehingga dapat dipanggil
berkali-kali tanpa harus menulis seluruh kode lagi. Kita namakan subrutin ini main6ame().
Kodenya sebagai berikut "
public static int user0enang * +;
public static int k)mputer0enang * +;
public static int seri * +;

public static void main!ame() {
,uffered-eader br * new ,uffered-eader(new
.nput$tream-eader($stem.in));
// variabel untuk mengambil input dari user
$tring input * null;

// *ita gunakan pernyataan +hile hingga user betul
// memasukkan salah satu dari ,, ", atau *
boolean input7alid * false;

int suit5)mputer * +;
int suit'ser * +;

// selama input tidak valid, !alankan perulangan ini
while (:input7alid) {
$stem.)ut.print(/0asukkan suit >nda /);
try {
input * br.read2ine();
} catch (.34xcepti)n i)e) {
$stem.)ut.println(/5esalahan .3, pr)gram berhenti/);
$stem.exit(1);
}

// pastikan bah+a user memasukkan sesuatu dengan mengecek
// apakah pan!ang input - .
// !ika tidak, maka perulangan akan dilan!utkan
if (input.length() @ +) {
switch (input.char>t(+)) {
case A6A 1
case ABA 1
suit'ser * +;
input7alid * true; // kita ganti inputvalid agar
perulangan selesai
break;
case AtA 1
case A(A 1
suit'ser * 1;
input7alid * true; // kita ganti inputvalid agar
perulangan selesai
break;
case AkA 1
case A5A 1
suit'ser * 9;
input7alid * true; // kita ganti inputvalid agar
perulangan selesai
break;
}
}
}

// sekarang menghitung suit komputer
// /ath0random12 menghasilkan nilai acak antara . dan )
// !ika kita kali 3, berarti menghasilkan nilai acak antara . dan 3
// perintah 1int2 untuk mengubah bilangan real men!adi bilangan
bulat
// dengan cara menghilangkan semua digit di belakang koma
// misalnya )0.232323 men!adi )
suit5)mputer * (int)(0ath.rand)m()8C);

// suatu saat "mungkin" nilai random bernilai 3
// karena 3 tidak ada dalam suit kita, maka kita harus ubah men!adi
// salah satu suit yang valid, yaitu ., ), atau 2
// dalam hal ini kita ganti !adi 2
if (suit5)mputer ** C) {
suit5)mputer * 9;
}

// menghitung siapa yang menang
int delta * suit5)mputer = suit'ser;

switch (delta) {
case +1
seri;;;
$stem.)ut.println(/?asilna 1 $eri/);
break;
case 11
case =91
user0enang;;;
$stem.)ut.println(/?asilna 1 >nda menang/);
break;
case =11
case 91
k)mputer0enang;;;
$stem.)ut.println(/?asilna 1 >nda kalah/);
break;
}
}
Sekarang kita ubah subrutin main()-nya, sehingga komputer akan menanyakan #nda untuk
main lagi atau tidak. 2ika ja.abannya ya, maka permainan akan diteruskan, dan statistik
menang-kalah-seri akan ditampilkan. 2ika tidak, hanya tampilkan statistiknya saja, kemudian
program akan keluar.
public static void main($tring%& args) {
// "#D# $uto%generated method stub

// cetak aturan main dan input dari user
$stem.)ut.println(/Dermainan suit/);
$stem.)ut.println(/**************/);
$stem.)ut.println(/0asukkan salah satu dari C kemungkinan 1/);
$stem.)ut.println(/B untuk Bemp)l/);
$stem.)ut.println(/( untuk (elun6uk/);
$stem.)ut.println(/5 untuk 5elingking/);
$stem.)ut.println(//); // baris kosong

while (true) {
main!ame();

// tampilkan statistik
$stem.)ut.println(/$tatistik 1/);
$stem.)ut.println(/5)mputer * / ; k)mputer0enang ; / >nda * /
; user0enang ; / $eri * / ; seri);
$stem.)ut.println(//); // baris kosong

// variabel untuk mengambil input dari user
,uffered-eader br * new ,uffered-eader(new
.nput$tream-eader($stem.in));
$tring input * null;

$stem.)ut.print(/0ain lagi (E<() F /);
try {
input * br.read2ine();
} catch (.34xcepti)n i)e) {
$stem.)ut.println(/5esalahan .3, pr)gram berhenti/);
$stem.exit(1);
}

// keluar !ika !a+abannya tidak
if ((input.char>t(+) ** AtA) GG (input.char>t(+) ** A(A))
break;
}
}
,erikut ini hasil keluarannya
Dan program tersebut dapat #nda unduh dalam bentuk >ip !ile atau melalui gudang S&5 di
alamat " http%&&belajarja'a.google(ode.(om&s'n&trunk&"ainSuitSubrutin*
Parameter
2ika subrutin adalah kotak hitam, maka parameter merupakan alat atau mekanisme untuk
memberikan in!ormasi dari dunia luar ke dalam kotak. (arameter merupakan bagian dari antar
muka dengan suatu subrutin. Dengan menggunakan parameter, kita dapat mengatur perilaku
suatu subrutin sesuai dengan input yang diberikan.
Sebagai analogi, kita ambil contoh #* -- yaitu alat yang mengatur suhu ruangan pada
temperatur konstan. #* memiliki parameter, yaitu tombol remote yang digunakan untuk
memasukkan suhu yang diinginkan. #* akan selalu melakukan tugas yang sama, yaitu
mengatur suhu ruangan. #kan tetapi, tugas persis yang dilakukan tergantung suhu yang diterima
dari remote control.
Kita ambil contoh pada kelas Konsol1nput pada bagian terdahulu.
public static double ambil#)uble($tring pertanaan) {
$tring strbilangan * null;
,uffered-eader br * new ,uffered-eader(new
.nput$tream-eader($stem.in));
double bilangan;

$stem.)ut.print(pertanaan);
try {
strbilangan * br.read2ine();
} catch (.34xcepti)n i)e) {
$stem.)ut.println(/5esalahan .3, pr)gram berhenti/);
$stem.exit(1);
}

bilangan * #)uble.parse#)uble(strbilangan);
return bilangan;
}
Di sini subrutin ambilDouble memiliki parameter tunggal yang bertipe String dan bernama
pertanyaan. Ketika subrutin ini dipanggil, suatu nilai harus ikut disertakan, dan nilai ini
dimasukkan dalam parameter "pertanyaan". 'isalnya, subrutin dapat dipanggil dengan a *
ambil#)uble(/hall)/);. Ketika komputer menjalankan perintah ini, komputer akan
memasukkan "hallo" ke dalam parameter "pertanyaan", kemudian subrutin ambilDouble
menjalankan semua perintah di dalamnya.
2ika parameter yang diberikan berupa +ariabel, misalnya +ariabel str berisi "kabar", kemudian
subrutin ambilDouble panggil dengan perintah ambil#)uble(str), maka isi dari str akan
dikopi ke dalam parameter "pertanyaan" terlebih dahulu sebelum seluruh perintah dalam
subrutin ambilDouble dilaksanakan.
(erlu dicatat bah.a istilah "parameter" digunakan dalam dua konsep berbeda tetapi berkaitan.
Aang pertama adalah "parameter" digunakan untuk mende!inisikan suatu subrutin. (arameter
yang digunakan pada de!inisi suatu subrutin disebut parameter +ormal. "(arameter" yang
digunakan untuk memanggil suatu subrutin disebut parameter aktual. Ketika suatu subrutin
dipanggil, parameter aktual akan die+aluasi, dan hasilnya akan dimasukkan ke dalam parameter
!ormal.
(arameter !ormal berbentuk seperti pengenal atau nama, dan bersi!at seperti halnya +ariabel dan
memiliki tipe -- misalnya int, double, atau String. (arameter aktual bersi!at seperti nilai atau
angka, jadi bisa berbentuk ekspresi atau perintah apapun yang menghasilkan nilai atau angka.
Se.aktu kita memanggil subrutin, kita harus memberi parameter aktual untuk setiap parameter
!ormal yang dide!inisikan.
'isalnya, lihat contoh berikut.
static void lakukan$esuatu(int ", double d, boolean b) {
... // perintah lainnya di sini
}
Subrutin ini bisa saja dipanggil dengan instruksi berikut.
lakukan$esuatu(1, 0ath.rand)m() 8 C, x ** C);
Ketika komputer menge+aluasi subrutin ini, pada dasarnya sama dengan menglakukan perintah-
perintah berikut.
{
int ";
double d;
boolean b;

" * 1;
d * 0ath.rand)m() 8 C;
b * (x ** C);
... // perintah lainnya di sini
}
0ntuk memanggil subrutin, yang kita perlukan adalah nama, berapa banyak parameter !ormal
yang dimilikinya, dan tipe dari parameter !ormal tersebut. 1n!omasi ini disebut juga tanda
subrutin. %anda subrutin lakukanSesuatu dapat ditulis sebagai
lakukanSesuatu(int,double,boolean). (erhatikan bah.a tanda subrutin tidak memiliki nama
parameterB sebetulnya jika kita hanya ingin menggunakan subrutin tersebut, nama parameter
tidaklah penting, karena nama bukan merupakan bagian dari antar muka subrutin.
2a+a agak sedikit berbeda karena memungkinkan dua atau lebih subrutin yang berbeda dalam
kelas yang sama memiliki tanda subrutin yang berbeda. ('irip seperti bahasa *CC) Subrutin
yang seperti ini disebut subrutin yang dibebanlebihkan (o'erloaded). 'isalnya,
void taruh($tring s) { ... }
void taruh(int i) { ... }
void taruh(double d) { ... }
void taruh(boolean b) { ... }
Kita sudah menggunakan subrutin yang dibebanlebihkan ini misalnya pada
System.out.println(). 2ika kita coba ketik System.out.println pada ;clipse, ;clipse akan
membantu kita untuk melihat parameter apa saja yang dibutuhkan, termasuk juga dapat
menunjukkan apakah suatu subrutin dibebanlebihkan.
#atatan % -+erload tidak berlaku pada tipe keluaran subrutin. Dua atau lebih subrutin dengan
nama sama dalam suatu kelas tetapi memiliki tipe keluaran yang berbeda tidak diperbolehkan
dalam 2a+a. 'isalnya, kalau kita coba de!inisikan / !ungsi seperti berikut, maka 2a+a akan
memberi pernyataan kesalahan sintaks.
int ambil($tring s) { ... }
boolean ambil($tring s) { ... }
double ambil($tring s) { ... }
%erakhir, hingga saat ini kita sudah mengenal ) jenis +ariabel" +ariabel lokal, yang dide!inisikan
di dalam suatu blok, +ariabel statik, yang dide!inisikan di dalam suatu kelas, dan parameter
!ormal, yang dide!inisikan pada de!inisi subrutin di dalam suatu kelas.
&ariabel lokal tidak memiliki hubungan dengan dunia luar sama sekali. (arameter digunakan
untuk berhubungan dengan dunia luar sebagai alat untuk menerima nilai atau angka dari dunia
luar. (erubahan nilai pada +ariabel lokal dan parameter tidak mempengaruhi +ariabel itu sendiri
karena si!atnya terisolasi.
al yang sama sekali berbeda akan terjadi apabila suatu subrutin menggunakan +ariabel yang
dide!inisikan di luar subrutin itu. &ariabel tersebut hidup secara terpisah dari subrutin, dan bisa
diakses oleh apapun di luar subrutin itu. &ariabel ini disebut +ariabel global. &ariabel ini terlihat
oleh semua subrutin dalam kelas tersebut. (erubahan yang terjadi di sini dapat mempengaruhi
cara kerja subrutin lain yang menggunakan +ariabel tersebut.
al ini kita lihat pada contoh sebelumnya tentang subrutin dan +ariabel statik untuk menghitung
statistik komputer'enang, user'enang, dan seri.
%idak ada yang salah dalam menggunakan +ariabel global, akan tetapi kita harus terus ingat
bah.a +ariabel global itu harus sebagai bagian dari antar muka subrutin kita dengan
keseluruhan dunia luar. *ara ini sebetulnya jalan belakang yang tidak terdokumentasi seperti
pada de!inisi subrutin, yang apabila aturan-aturannya tidak dipenuhi secara disiplin mungkin
akan menyebabkan bug atau kesalahan lain di luar kontrol kita.
(aling tidak ada satu alasan untuk menggunakan +ariabel global, yaitu apabila kelas secara
keseluruhan dianggap sebagai kotak hitam, akan lebih masuk akal apabila subrutin bisa
mengintip sedikit keluar dan saling menukar in!ormasi jika cara ini jauh lebih mudah
diimplementasikan dan dilihat dari dunia luar.
,ipe Keluaran
Suatu subrutin yang mengembalikan nilai disebut !ungsi. Suatu !ungsi hanya dapat
mengembalikan nilai dengan tipe tertentu, yang disebut tipe keluaran. <ungsi biasanya
dipanggil di tempat suatu nilai atau angka ditempatkan, misalnya disebelah kanan tanda @, pada
parameter se.aktu subrutin dipanggil, atau di tengah-tengah ekspresi yang panjang. <ungsi
dengan tipe keluaran boolean juga bisa ditempatkan sebagai kondisi pada pernyataan i! atau
.hile.
Sebetulnya boleh-boleh saja memanggil suatu !ungsi sendirian tanpa diletakkan di sebelah
kanan tanda @, misalnya ambil#)uble(/hall)/);. Dalam hal ini keluarannya akan diabaikan
oleh komputer. %ergantung program yang akan kita buat, kadang-kadang program kita memang
sengaja membuang nilai yang dikembalikan oleh !ungsi karena satu dan lain hal.
0ntuk membuat !ungsi yang mengeluarkan suatu nilai kembali kepada pemanggilnya, kita
harus memberikan pernyataan return, dengan bentuk
return ekspresi;
(ernyataan return ini hanya boleh ditulis di dalam sebuah subrutin (termasuk subrutin main()),
dan ekspresi harus menghasilkan nilai yang memiliki tipe yang sama dengan tipe keluaran yang
dide!inisikan pada deklarasi subrutin tersebut.
Ketika komputer menjalankan pernyataan return, komputer akan menghitung "ekspresi",
menghentikan eksekusi subrutin tersebut saat itu juga, dan kembali pada si pemanggil dengan
memba.a nilai hasil perhitungan "ekspresi".
'isalnya, kita akan menghitung luas suatu lingkaran. Kita buat !ungsi luas7ingkaran dengan
parameter jarijari dan keluarannya bertipe double, sebagai berikut "
static double luas2ingkaran(double 6ari6ari) {
return C.1H 8 6ari6ari 8 6ari6ari;
}
#nggap komputer sedang melakukan perintah "ruangk)s)ng * 9+89+ =
luas2ingkaran(1+);". Ketika sampai pada bagian luas7ingkaran, !ungsi tersebut akan
memasukkan ?9 ke dalam parameter !ormal jarijari. Di dalam badan !ungsi, ia akan menghitung
C.1H 8 1+.+ 8 1+.+ yang hasilnya )?D.9. 5ilai ini akan dikembalikan kepada !ungsi a.alnya
untuk menghitung "ruangk)s)ng * 9+89+ = luas2ingkaran(1+);", sehingga !ungsi ini juga
bisa diganti dengan "ruangk)s)ng * H++ = C1H.+;" asilnya yaitu EF dimasukkan ke dalam
+ariabel ruangk)s)ng
Dalam subrutin biasa -- yaitu subrutin yang tipe keluarannya void -- kita juga bisa
menggunakan perintah return untuk langsung keluar dari subrutin tersebut, yaitu dengan
perintah return; tanpa ekspresi. Di subrutin ini perintah return boleh diberikan jika diperlukan,
akan tetapi pada !ungsi perintah return .ajib diberikan.
,erikut ini adalah !ungsi untuk menentukan nilai akhir (#, ,, *, D atau ;) dari nilai ujian.
static char nilai>lfa(double nilai'6ian) {
if (nilai'6ian @* I+)
return A>A;
else if (nilai'6ian @* J+)
return A,A;
else if (nilai'6ian @* 7+)
return ACA;
else if (nilai'6ian @* K+)
return A#A;
else
return A4A;
}
(erhatikan bah.a pada setiap cabang, perintah return diberikan. #da juga beberapa programmer
yang lebih suka dengan menggunakan +ariabel sementara kemudian perintah return diberi satu
kali saja di akhir !ungsi, seperti contoh berikut.
static char nilai>lfa(double nilai'6ian) {
char keluaran;
if (nilai'6ian @* I+)
keluaran * A>A;
else if (nilai'6ian @* J+)
keluaran * A,A;
else if (nilai'6ian @* 7+)
keluaran * ACA;
else if (nilai'6ian @* K+)
keluaran * A#A;
else
keluaran * A4A;
return keluaran;
}
*ontoh di atas memiliki tipe keluaran char. Dan sebenarnya, tipe keluaran bisa bertipe apa saja,
termasuk kelas, seperti String pada contoh berikut.
static $tring ulang5arakter(char c, int n) {
$tring keluaran * //;

// tambah karakter c ke dalam 4tring keluaran sebanyak n kali
for (int i * 1; i L* n; i;;)
keluaran * keluaran ; c;

return keluaran;
}
<ungsi di atas ber!ungsi untuk mengulang karakter c sebanyak n kali dan mengembalikan
hasilnya. 'isalnya jika !ungsi di atas kita panggil dengan "ulang * ulang5arakter(A>A,
1+);" maka ulang akan bernilai "##########" setelah !ungsi ulangKarakter dijalankan.
,oolbo-, AP., dan Paket
Dengan semakin mudah digunakannya komputer, akan semakin sulit dan kompleks tugas yang
harus dilakukan oleh programmer. Kita dengan mudah menulis program berbasis konsol dengan
menggunakan beberapa subrutin untuk menampilkan pesan dan mengambil input dari user. 601
(graphical user inter!ace @ antarmuka pengguna berbasis gra!ik), seperti jendela, tombol, scroll
bar, menu, kotak input teks, dan lain-lain mungkin lebih menarik bagi user. #kan tetapi
programmer harus berhadapan dengan kemungkinan yang sangat amat banyak, dan lebih
banyak subrutin yang harus dibuat untuk bisa mengontrol setiap komponen 601.
Seseorang yang ingin membuat program untuk Gindo.s misalnya, harus menggunakan
%oolbox Gindo.s, yaitu koleksi dari ribuan subrutin, misalnya untuk membuka dan menutup
jendela, untuk menggambar dan menulis teks, menambah tombol dan menerima respon dari
user. Selain 601 ada juga subrutin yang berurusan dengan membuka, membaca, dan menulis
!ile, berkomunikasi dengan net.ork, dan lain-lain. 1ntinya di dalam toolbox terdapat segala
sesuatu yang menurut kita standar. #pple dan 7inux memiliki toolbox sendiri yang berbeda
dengan yang disediakan oleh Gindo.s.
Setiap proyek pembuatan program akan terdiri dari ino+asi (sesuatu yang sangat baru) dan
menggunakan kembali sesuatu yang sudah pernah dibuat sebelumnya. Seorang programmer
diberi peralatan untuk berhasil dalam proyeknya tersebut, yang paling dasar adalah apa yang
diberikan oleh bahasa pemrograman itu sendiri, misalnya +ariabel, perulangan, dan lain-lain. Di
atasnya, programmer bisa menambahkan toolbox yang berisi subrutin yang sudah ditulis untuk
melakukan tugas tertentu. #lat ini, jika didesain dengan sangat baik, bisa dijadikan kotak hitam
yang sesungguhnya, yaitu kotak hitam yang kita betul-betul tidak perlu tahu bagaimana dia
bekerja.
,agian yang ino+ati! adalah bagaimana merangkai alat tadi menjadi sesuatu yang berguna
untuk suatu proyek atau suatu masalah yang ingin dipecahkan (pengolah kata, bro.ser, game,
dll). 1ni disebut pemrograman aplikasi.
%oolbox suatu so!t.are adalah juga kotak hitam. 1a memiliki antar muka dengan
programmernya. #ntar muka ini berisi spesi!ikasi tentang rutin-rutin apa saja yang ada di sana,
apa parameter yang dibutuhkan, dan tugas apa yang mereka lakukan. 1n!ormasi ini disebut #(1
(#pplications (rogramming 1nter!ace @ #ntarmuka (emrograman untuk #plikasi). Gindo.s
#(1 adalah spesi!ikasi semua subrutin yang tersedia dalam toolbox #pple.
(erusahaan yang membuat hard.are, misalnya sound card atau blue tooth mungkin juga akan
membuat #(1 untuk perangkat tersebut yang berisi subrutin yang diperlukan programmer untuk
bisa menggunakan perangkat itu. (eneliti yang membuat program untuk menyelesaikan suatu
perhitungan matematis kompleks -- misalnya persamaan di!erensial -- juga akan membuat #(1
sehingga orang lain bisa menggunakan subrutinnya tanpa harus mengerti dengan detail
bagaimana perhitungan itu dilakukan.
,ahasa pemrograman 2a+a juga didukung oleh #(1 yang cukup besar dan standar. *ontoh #(1
yang pernah kita lihat misalnya 'ath.random(), tipe data String, dan subrutin yang terkait. 2a+a
#(1 standar terdiri dari subrutin untuk membuat dan mengendalikan 601, untuk komunikasi
net.ork, baca tulis !ile, dan lain-lain. 'ungkin lebih mudah jika #(1 ini dianggap sebagai
bagian dari bahasa 2a+a, akan tetapi sebetulnya #(1 terdiri dari subrutin yang bisa digunakan
dalam program 2a+a.
2a+a merupakan bahasa yang tidak tergantung pada mesin atau sistem operasi di mana ia
dijalankan. 2a+a #(1 yang sama harus bisa bekerja dengan semua sistem. #kan tetapi ingat
bah.a yang sama adalah antar mukanya. 1mplementasinya bisa sangat berbeda antara satu
sistem operasi dengan lainnya.
Sistem 2a+a pada suatu komputer terdiri dari implementasi pada komputer tersebut. (rogram
2a+a yang kita buat memanggil subrutin pada komputer tersebut. Ketika komputer menjalankan
program dan sampai pada perintah untuk memanggil subrutin pada #(1, komputer akan
menjalankan implementasi subrutin yang sesuai dengan sistem komputer di mana program
tersebut dijalankan. #rtinya, kita hanya perlu belajar satu #(1 saja untuk melakukan
pemrograman pada berbagai macam komputer dan sistem operasi.
Seperti subrutin pada 2a+a, subrutin pada #(1 standar dikelompokkan ke dalam kelas. 0ntuk
membuat organisasi lebih baik, kelas 2a+a dapat digabungkan menjadi paket. Kita juga bisa
membuat hirarki paket yang lebih tinggi, karena paket juga bisa berisi paket lain. Kenyataannya
seluruh #(1 standar 2a+a diimplementasikan dalam beberapa paket. Salah satu paketnya
bernama "6a7a", yang berisi paket-paket non-601 dan juga 601 berbasis #G%. (aket lain,
yaitu "6a7ax", yang ditambahkan pada +ersi ?./, berisi kelas yang digunakan untuk 601 S.ing.
Suatu paket dapat terdiri dari kelas ataupun pake lain. (aket yang terdapat di dalam paket lain
disebut "sub paket". (aket 6a7a dan 6a7ax juga memiliki beberapa sub paket. Salah satu sub
paket 6a7a, misalnya disebut aMt. Karena aMt berada di dalam paket 6a7a, nama lengkapnya
adalah 6a7a.aMt. (aket inilah yang sebenarnya memiliki kelas-kelas 601 #G%, seperti kelas
,utt)n yang melambangkan tombol, atau !raphics yang merupakan kumpulan rutin untuk
menggambar di monitor. Karena kelas ini tergabung dalam paket 6a7a.aMt, maka nama
lengkapnya adalah 6a7a.aMt.,utt)n dan 6a7a.aMt.!raphics. Demikian juga dengan ja+ax
yang memiliki sub paket yang bernama 6a7ax.sMing, yang terdiri dari kelas yang bernama
6a7ax.sMing.B,utt)n dan 6a7ax.sMing.B>pplet.
(aket ja+a sendiri terdiri dari beberapa sub paket lain, seperti 6a7a.i) yang sudah kita pakai
dalam bab-bab sebelumnya, berguna untuk memberikan !asilitas inputHoutput, 6a7a.net untuk
mengendalikan komunikasi jaringan, dan 6a7a.applet mengimplementasikan !ungsi dasar
untuk applet. (aket yang paling dasar disebut 6a7a.lang. Di dalam paket ini terdapat kelas-
kelas !undamental misalnya $tring dan 0ath.
'ungkin akan lebih jelas jika kita lihat ilustrasi berikut tentang tingkatan paket ja+a, sub paket,
kelas di dalam sub paket, dan subrutin di dalam kelas.

'isalkan kita akan menggunakan kelas 6a7a.aMt.C)l)r dalam program. Salah satu caranya
adalah dengan menggunakan nama lengkap dari kelas tersebut, misalnya
6a7a.aMt.C)l)r Marna5)tak;
untuk mendekalarasi +ariabel bernama .arnaKotak yang tipenya adalah 6a7a.aMt.C)l)r.
%entu saja akan terlalu cape jika kita harus menulis nama kelas dengan lengkap setiap kali akan
digunakan. 2a+a mengijinkan kita untuk menggunakan langsung nama kelasnya jika kita
berikan perintah import, seperti
import 6a7a.aMt.C)l)r;
di a.al program, dan kemudian di bagian lain, kita bisa menyingkat 6a7a.aMt.C)l)r hanya
dengan nama kelasnya saja, sehingga menjadi
C)l)r Marna5)tak;
(Satu-satunya keuntungan yang diberikan perintah import adalah untuk menyingkat penulisan
nama kelas, bukan untuk mengimport keseluruhan kelas ke dalam program kita. Seandainya
perintah import tidak kita berikan, dan kita panggil dengan nama lengkapnya, 2a+a akan tetap
bisa mengakses kelas tersebut.)
#da lagi jalan pendek untuk mengimport seluruh kelas pada suatu paket. Kita bisa import
seluruh kelas di dalam paket 6a7a.aMt dengan
import 6a7a.aMt.8;
1ngat pada kode kita sebelumnya yang berbentuk seperti ini$
import 6a7a.i).8;
Ketika program yang akan kita buat semakin besar, maka ada kemungkinan kita harus
mengimport banyak paket. Satu hal penting yang perlu diingat adalah ada kemungkinan
beberapa paket memiliki nama kelas yang sama. 'isalnya 6a7a.aMt dan 6a7a.util memiliki
kelas yang bernama 2ist. 2ika kita import kedua kelas dengan perintah 6a7a.aMt.8 dan
6a7a.util.8, maka nama 2ist menjadi rancu.
2ika kita mencoba membuat +ariabel dengan tipe data 7ist, ja+a akan menampilkan pesan
kesalahan tentang adanya nama kelas yang membingungkan. Solusinya$ 6unakan nama
lengkap kelasnya, yaitu 6a7a.aMt.2ist atau 6a7a.util.2ist.
Karena paket 6a7a.lang.8 adalah paket yang sangat penting, setiap kelas dalam 6a7a.lang
akan diimport otomatis ke dalam semua program. Seakan-akan semua program dimulai dengan
perintah "import 6a7a.lang.8;". #rtinya, kita bisa memanggil kelas seperti String saja,
bukan 6a7a.lang.$tring, atau 0ath.sNrt() bukan 6a7a.lang.0ath.sNrt().
(rogrammer juga bisa membuat paket baru. 'isalnya kita akan membuat kelas yang akan
diletakkan di paket yang bernama alatbantu. 'aka pada a.al program kita harus dide!inisikan
dengan perintah "package alatbantu;" (rogram lain yang menggunakan paket ini bisa
menambah "import alatbantu.8;" untuk mengabmbil semua kelas dalam paket alatbantu.
'asalahnya hal ini agak sedikit lebih rumit. 1ngat bah.a ketika suatu program menggunakan
kelas, maka kelas tersebut harus "tersedia" ketika program tersebut dikompilasi dan ketika
program terus dieksekusi. %entunya lebih pas tergantung dari lingkungan 2a+a yang kita
lakukan. biasanya paket yang bernama alatbantu harus berada di dalam direktori alatbantu, dan
direktori tersebut harus diletakkan pada direktori yang sama dengan program yang akan
menggunakan kelas itu.
(ada program yang menggunakan banyak kelas, maka sangat masuk akal apabila kita membagi
dan mengorganisir kelas tersebut dalam satu atau beberapa paket. Dan juga masuk akal untuk
membuat paket baru sebagai toolbox atau dengan kata lain membuat #(1 baru yang belum
diko+er oleh #(1 2a+a. (Seringkali orang yang membuat #(1 lebih disanjung akan
kehebatannya dibandingkan dengan orang yang hanya menggunakan #(1).
Dalam program ;clipse kita, kita sudah menggunakan paket dari a.al. ,ab ini menjelaskan
lebih detail tentang paket. Sebetulnya tidak ada salahnya kita mengorganisir setiap program
yang kita buat sejak a.al. (ada saat program kita besar, maka perubahan yang diperlukan untuk
mengorganisir akan lebih signi!ikan.
,entang /eklarasi
5ama adalah hal yang paling dasar dalam pemrograman. ,anyak sekali tetek bengek detail di
dalam deklarasi dan menggunakan nama. Dalam bagian ini akan kita singgung beberapa hal
penting tentang deklarasi dan penggunaan +ariabel pada 2a+a.
"enggabungkan .nisialisasi dan /eklarasi
Ketika perintah deklarasi +ariabel dilaksanakan, komputer akan menyiapkan memori untuk
digunakan oleh +ariabel ini. 'emori ini harus diinisialisasi, yaitu diberi suatu nilai a.al
sebelum bisa digunakan dalam perintah berikutnya. (ada +ariabel lokal, pernyataan deklarasi
sering diikuti oleh perintah pemberi nilai a.al. 'isalnya,
int i; // Deklarasi variabel yang bernama i
i * +; // 5eri nilai a+al
Kita bisa juga melakukan deklarasi sekaligus inisialisasi +ariabel tersebut. Kedua pernyataan di
atas bisa kita gabung menjadi
int i * +; // Deklarasi variabel i sekaligus memberi nilai a+al .
Komputer akan tetap melakukan perintah di atas dalam dua langkah" deklarasi +ariabel,
kemudian mengisi nilai a.al 9. 5ilai a.al tidak harus berupa suatu bilangan, tetapi bisa juga
berupa ekspresi yang menghasilkan suatu nilai. Dan juga kita boleh melakukan inisialisasi
beberapa +ariabel sekaligus dalam ? baris. 'isalnya,
int x * +, * 1;
int aMal, akhir * A>A; // #k, tapi hanya akhir yang akan diinisialisasi
int " * C, 0 * ";9; // #k, karena N sudah diberi nilai a+al sebelum
digunakan oleh /
<itur ini biasa ditemui pada perulangan !or, karena pernyataan ? baris ini bisa dimasukkan
sebagai +ariabel kontrol di a.al pernyataan !or. Karena +ariabel kontrol biasanya tidak
berhubungan dengan bagian program di luar perulangan, maka akan lebih praktis jika deklarasi
+ariabel kontrol itu dilakukan di a.al perulangan. 'isalnya
for ( int i * +; i L 1+; i;; ) {
$stem.)ut.println(i);
}
(erlu diingat bah.a ekspresi di atas merupakan singkatan dari blok berikut. Saya sengaja
tambahkan 3 dan 4 di a.al dan akhir untuk mempertegas bah.a i hanya bersi!at lokal di dalam
perulangan yang tidak bisa diakses lagi setelah perulangan selesai.
{
int i;
for ( i * +; i L 1+; i;; ) {
$stem.)ut.println(i);
}
}
&ariabel anggota juga bisa diinisialisasi di mana dia dideklarasikan. 'isalnya,
public class ,ank {
static double suku,unga * +.1; // sama dengan ).6
static long maxDenarikan * 9++++++;
.
. // 7erintah dan variabel lain
.
}
&ariabel anggota statik akan dibuat pada saat kelas mulai dimasukkan memori oleh interpreter
2a+a, inisialisinya pun dilaksanakan pada saat itu. (ada +ariabel anggota, deklarasi dan
inisialisasi ini bukan hanya sekedar singkatan dari / perintah seperti pada +ariabel lokal.
(ernyataan deklarasi adalah pernyataan yang bisa dibuat di luar subrutin, sedangkan inisialisasi
tidak bisa dilakukan di luar subrutin. *ontoh di ba.ah tidak diperbolehkan dalam 2a+a.
public class ,ank {
static double suku,unga;
suku,unga * +.1; // 89:G$9, perintah ini harus ada di dalam
subrutin
}
Karenanya, deklarasi +ariabel anggota biasanya juga dirangkai dengan inisialisasi nilai a.alnya.
2ika tidak ada nilai a.al yang diberikan, maka nilai a.al ba.aan akan digunakan. 'isalnya
"static int i;" setara dengan "static int i * +;".
Konstanta dan Si+at 0+inal0
Kadang-kadang dalam kondisi tertentu, kita ingin nilai suatu +ariabel tidak boleh berubah
setelah diberi nilai a.al. 'isalnya, pi diinisialisasi dengan nilai ).?D?IJ, maka nilai ini akan
bisa diubah oleh bagian lain dalam program. Di sini mungkin sang programmer ingin
mende!inisikan suatu konstanta yang diberi nama "pi" sebagai pengganti dari bilangan ).?D?IJ.
Dengan cara ini, program akan lebih mudah dimengerti apabila program tersebut ditulis dalam
"keliling * pi8diamater;" daripada "p)k)k * C.1H1OI8diameter;".
Dalam ja+a, si!at "!inal" bisa digunakan pada deklarasi +ariabel untuk membuat nilai suatu
+ariabel tidak bisa diubah setelah diinisialisasi. 'isalnya
final static double pi * C.1H1OI;
#pabila kita mencoba mengganti isi +ariabel tersebut, misalnya di tengah program dengan
perintah "pi * 9+;" komputer akan menampilkan pesan kesalahan sintaks pada saat kompilasi.
Si!at "!inal" boleh diberikan pada +ariabel lokal dan bahkan pada parameter !ormal, akan tetapi
paling berguna apabila diberikan pada +ariabel anggota. &ariabel anggota statik yang
dideklarasikan dengan si!at "!inal" juga disebut sebagai konstanta yang diberi nama.
(rogram akan jauh lebih mudah dibaca dengan menggunakan konstanta bernama ini jika
diberikan pada sesuatu angka penting yang digunakan dalam program. 6aya penulisan yang
dianjurkan untuk konstanta bernama ini adalah dengan menggunakan huru! besar dengan baris
ba.ah (jika diperlukan). 'isalnya
final static double D. * C.1H1OI;
6aya penulisan seperti ini juga digunakan oleh kelas standar 2a+a, yang di dalamnya terdapat
banyak sekali konstanta bernama. 'isalnya, konstanta (1 sudah dide!inisikan 2a+a dalam kelas
'ath, yaitu 'ath.(1, sehingga kita tidak perlu mende!inisikannya sendiri.
*ontoh lain adalah memberikan nama untuk gaya huru!, seperti <ont.(7#15, <ont.,-7D dan
<ont.1%#71*. Konstanta ini digunakan untuk menandai gaya huru! untuk digunakan oleh
subrutin lain dalam kelas <ont.
Salah satu alasan utama untuk menggunakan konstanta bernama adalah supaya kita bisa
mengubah isinya dengan cepat apabila di kemudian hari kita ingin memiliki nilai konstanta
yang berbeda. #pabila nilai ini diubah, maka kita harus mengkompilasi ulang program kita,
karena nilai ini tidak bisa diubah ketika program dieksekusi.
'isalnya kita de!inisikan suku,unga pada contoh di atas sebagai konstanta bernama, yaitu
static final double $'5'_,'"!> * +.1;
Suatu saat misalnya / tahun kemudian, bank tersebut ingin mengubah suku bunganya menjadi
IK atau 9.9I. Kita bisa mengubah nilainya hanya di satu tempat yaitu di mana deklarasi
S0K08,056# berada. Kita tidak perlu mencari semua nilai 9.? di dalam program untuk
menggantinya satu per satu. Selain repot, mungkin membingungkan karena 9.? bisa digunakan
untuk nilai lainnya, bukan hanya nilai suku bunga.
Aturan Penamaan dan 1angkauan s(ope!
Ketika deklarasi +ariabel dieksekusi, komputer akan menyediakan tempat di memori untuk
+ariabel tersebut. 5ama +ariabel dapat digunakan oleh kode program untuk mengacu pada
alamat di mana data tersebut disimpan di dalam memori. ,agian di dalam kode sumber (yaitu
program 2a+a yang kita tulis, masih dalam bentuk yang dimengerti manusia sebelum
dikompilasi menjadi bahasa mesin) di mana +ariabel tersebut +alid dan bisa digunakan disebut
jangkauan +ariabel. ,ukan hanya +ariabel yang memiliki jangkauan, tetapi juga nama subrutin
dan nama parameter !ormal.
0ntuk subrutin statik, jangkauannya lebih mudah dipahami. 2angkauan subrutin statik adalah
kelas di mana ia dide!inisikan. Kita bisa juga memanggil subrutin itu dari dalam kelas dirinya
sendiri. Dalam pemrograman tingkat lanjut, teknik ini disebut rekursi (recursion), yaitu subrutin
yang memanggil dirinya sendiri. %eknik ini digunakan dalam bab yang akan datang yang
berbicara detail tentang struktur data dan algoritma.
0ntuk +ariabel anggota suatu kelas, aturannya sama, tetapi dengan sedikit pengecualian. Kita
boleh memiliki +ariabel lokal atau parameter !ormal yang namanya sama dengan +ariabel
anggota static. 2ika ini terjadi, maka +ariabel anggota akan disembunyikan oleh 2a+a. Dalam
contoh berikut "
public class !ame {
static int hitung; // variabel anggota
static void main!ame() {
int hitung; // variabel lokal
.
. // 7erintah untuk main game
.
}
.
. // ;ariabel dan subrutin lain
.

} // akhir kelas Game
Kita lihat bah.a dalam subrutin main6ame(), "hitung" mengacu pada dua hal yaitu +ariabel
lokal dan +ariabel anggota statik. Di luar kelas 6ame, "hitung" hanya mengacu pada +ariabel
anggota statik. Dalam situasi seperti ini, di dalam subrutin main6ame() maka "hitung" sebagai
+ariabel anggota akan disembunyikan oleh 2a+a. 0ntuk menggunakan +ariabel anggota ini, kita
bisa menggunakan nama lengkapnya yaitu 6ame.hitung. #kan tetapi trik ini tidak bisa
digunakan untuk +ariabel anggota yang tidak statik.
2angkauan parameter !ormal di dalam suatu subrutin berada di dalam blok di mana ia
dideklarasikan. Sehingga pada "for (int i*+; iL1+; i;;)" +ariabel i hanya bisa di lihat di
dalam blok perulangan !or, tetapi tidak +alid di luar perulangan ini meskipun pada subrutin
yang sama.
#kan tetapi kita tidak boleh mendeklarasikan parameter !ormal dengan nama yang sama dengan
+ariabel lokal yang berlaku di sana. 'isalnya,
void subrutinBelek(int ) {
int x;
while ( @ +) {
int x; // :<<#<& sudah didefinisikan sebelumnya
.
.
.
}
}
Dalam bahasa pemrograman lain, pernyataan di atas masih dibolehkan, yaitu dengan
menyembunyikan x pada deklarasi sebelumnya. #kan tetapi pada 2a+a, segera setelah blok yang
memuat suatu +ariabel selesai, namanya bisa dipergunakan kembali. 'isalnya.
void subrutin,agus(int ) {
while ( @ 1+) {
int x;
.
.
.
// ,angkauan berakhir di sini
}
while ( @ +) {
int x; // #*& Deklarasi sebelumnya sudah kadaluarsa 
.
.
.
}
}
#da beberapa hal lain yang menarik di 2a+a. 5ama subrutin dan +ariabel boleh sama, karena
komputer akan selalu dapat membedakan mana subrutin atau +ariabel dengan melihat tanda
buka kurung L(L setelah namanya. &ariabel tidak pernah menggunakan tanda kurung setelah
namanya. Sehingga suatu kelas boleh memiliki +ariabel anggota yang bernama "hitung" dan
subrutin yang bernama "hitung()".
7ebih jauh lagi, nama suatu kelas boleh menggunakan nama subrutin atau +ariabel yang sudah
ada. Komputer bisa melihat apakah suatu nama berupa kelas, +ariabel atau subrutin. Kelas
adalah juga tipe data, sehingga suatu kelas bisa digunakan untuk mendeklarasikan +ariabel
dengan tipe kelas tersebut, atau membuat subrutin yang keluarannya bertipe kelas tersebut.
#tau sebagai contoh, perintah berikut bisa diterima oleh program 2a+a "
static !ila !ila(!ila !ila) {
.
.
.
}
6ila pertama adalah tipe keluaran suatu !ungsi. 6ila kedua adalah nama subrutin. Aang ketiga
adalah tipe data parameter, dan keempat adalah nama parameter !ormal.
%etapi, ingat tidak semua yang mungkin dan boleh dilakukan berarti harus dilakukan.
7ihat lebih jelas di sini " Mne.sletter8url