Senin, 12 Desember 2011

Subrutin Statik dan Variabel Statik (Java)


Setiap subrutin yang dideklarasikan dalam Java harus dideklarasikan di dalam suatu Kelas (Class). Hal ini mungkin membuat Java sedikit tidak normal, karena dalam bahasa pemrograman lain, subrutin bisa diletakkan di mana saja termasuk di luar kelas. Salah satu dari fungsi kelas adalah menggabungkan subrutin dan variabel bersama. Dan ini tidak mudah apabila subrutin dan variabel berada di luar kelas, terutama apabila beberapa paket harus digabungkan menjadi satu seperti dalam program kompleks. Akan terdapat banyak kebingungan yang mungkin diakibatkan dari nama subrutin atau nama variabel 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. Metode akan digunakan untuk subrutin non-statik yang lebih merupakan sifat dari objek, dan bukan bagian dari kelas itu sendiri.
Definisi subrutin dalam bahasa pemrograman Java dapat dituliskan dalam bentuk
sifat tipe_keluaran nama_subrutin ( daftar parameter ) {
    perintah
}
Kita sudah pernah mendefinisikan suatu subrutin, yaitu subrutin main(). Paling tidak kita sudah kenal bagaimana subrutin didefinisikan.
perintah yang terdapat di antara { dan } disebut juga badan subrutin. Perintah ini merupakan badan atau implementasi suatu subrutin, seperti yang dibahas sebelum pada penjelasan tentang kotak hitam. Perintah ini merupakan instruksi yang akan dieksekusi oleh komputer pada saat subrutin ini dipanggil.
sifat adalah sifat dari subrutin itu sendiri. Beberapa sifat yang pernah kita lihat adalah static dan public. Ada lebih dari selusin sifat yang bisa diberikan kepada subrutin.
Jika kita akan membuat fungsi, yaitu subrutin yang menghitung suatu nilai kemudian mengembalikan hasilnya, makatipe_keluaran adalah tipe data dari keluaran yang dihasilkan oleh fungsi tersebut. Kita akan membahas lebih lanjut tentang keluaran pada bagian berikutnya. Jika subrutin kita bukan fungsi dan tidak menghasilkan nilai apa-apa, kita gunakan tipe data spesial yang dinamakan void untuk menunjukkan bahwa tidak ada nilai keluaran yang akan dikembalikan oleh subrutin tersebut.
Akhirnya kita sampai pada daftar parameter. Parameter adalah bagian dari antar muka suatu subrutin. Parameter adalah informasi yang diberikan kepada suatu subrutin dari dunia luar, untuk digunakan dalam eksekusi subrutin tersebut. Kasus sederhana misalnya televisi memiliki subrutin gantiChannel(). Pertanyaan yang akan muncul adalah ganti channel ke mana? Dalam hal ini parameter dapat digunakan, misalnya channel berbentuk bilangan bulat (int) dan deklarasi subrutin gantiChannel dapat berbentuk seperti
public void gantiChannel(int channel) {
    ...
}
Pernyataan tersebut berarti subrutin gantiChannel() memiliki parameter channel yang bertipe int. Akan tetapi channel belum memiliki nilai. Nilainya akan diberikan pada saat subrutin ini dipanggil, misalnya dengan
gantiChannel(17);
Daftar parameter dari suatu subrutin bisa juga kosong, atau bisa berisi lebih dari satu parameter dalam bentuk
tipe_data nama_parameter
Jika ada lebih dari satu parameter, maka parameter-perameter tersebut dihubungkan dengan koma. Catatan bahwa masing-masing parameter harus terdiri dari satu tipe data dan satu nama, misalnya double x, double y dan bukan double x, y.
Parameter akan dijelaskan lebih lanjut pada bagian berikutnya.
Berikut ini adalah beberapa contoh deklarasi subrutin yang umum dilakukan :
public static void mainGame() {
    // "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 ambilNdata(int N) {
    // 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 kurangDari(double x, double y) {
    // "static" adalah sifat, "boolean" adalah tipe_keluaran
    // "kurangDari" adalah nama subrutin
    // parameternya ada 2, yaitu x yang bertipe data double
    // dan y yang juga bertipe data double
    .... // perintah untuk menguji apakah x lebih kecil dari y ditulis di sini
}
Dalam contoh kedua perhatikan bahwa sifatnya tidak "static", dan subrutin ini tidak dibahas dalam bagian ini. Subrutin pertama memiliki sifat "public" yang artinya subrutin ini dapat dipanggil dari bagian manapun, termasuk dari luar kelas yang dimaksud.
Ada lagi sifat subrutin yaitu "private" yang berarti hanya bisa dipanggil dari dalam kelas di mana subrutin tersebut didefinisikan. Sifat "public" dan "private" dinamakan penentu akses (access specifier). Jika tidak disebutkan jenis aksesnya dalam suatu definisi subrutin, maka otomatis subrutin itu memiliki sifat "package" yang artinya hanya bisa dipanggil dari paket yang sama dari kelas di mana ia didefinisikan. Sifat lain yang berkaitan dengan penentu akses adalah "protected" dan ini akan dibahas lebih lanjut pada bagian tentang pemrograman berorientasi objek.
Ingatkah bahwa subrutin main() yang biasa kita gunakan dalam contoh-contoh program memiliki bentuk seperti berikut ?
public static main(String[] args) { ... }
Sifatnya 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.
Menjalankan subrutin
Ketika kita mendefinisikan subrutin, pada dasarnya kita memberitahu Java bahwa suatu subrutin tersedia dalam suatu kelas. Subrutin tersebut tidak dijalankan sampai ia dipanggil. (Hal ini juga berlaku untuk kelas main(), meskipun kita tinggal memanggilnya secara spesifik, tetapi sistem operasi kita akan memanggil subrutin main() pada saat program tersebut dijalankan.) Misalnya subrutin mainGame() di atas dapat dipanggil seperti
mainGame();
Pernyataan ini dapat dipanggil di mana pun dalam kelas yang sama, meskipun dari dalam subrutin yang berbeda, misalnya dari dalam subrutin main(). Karena mainGame() bersifat "public", maka subrutin ini dapat juga dipanggil dari luar kelas di mana ia dideklarasikan. Misalnya, mainGame() dideklarasikan dalam kelas Gundu, maka mainGame dapat dipanggil dari kelas lain seperti
Gundu.mainGame();
Penggunaan nama kelas di sini berarti memberitahu Java di mana subrutin mainGame() harus dicari (dalam hal ini di dalam kelas Gundu). Dan ini juga membedakan bahwa yang dimainkan adalah Gundu, bukan Catur.mainGame() atauUlarTangga.mainGame().
Lebih 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 sifat "static". Apabila subrutin tersebut tidak bersifat "statik" maka nama_kelas harus diganti dengan nama objek jelmaan kelas tersebut. (Akan dijelaskan lebih jauh nanti pada bab tentang pemrograman berorientasi objek).
Juga, apabila tidak ada parameter yang didefinisikan, maka parameter bisa dihilangkan, tetapi tanda kurungnya () harus tetap ada meskipun kosong.
Variabel Statik
Suatu kelas juga bisa berisi lain hal selain subrutin, misalnya variabel. Variabel juga bisa didefinisikan di dalam subrutin, yang disebut variabel lokal. Untuk membedakannya variabel yang didefinisikan di dalam kelas disebut variabel anggota, karena variabel tersebut adalah anggota kelas.
Seperti subrutin, variabel juga bisa bersifat statik atau non-statik. Di bagian ini kita hanya akan membahas variabel statik. Variabel anggota statik dimiliki oleh kelas, dan akan selalu ada selama kelas tersebut ada. Komputer akan menyiapkan memori tempat penyimpanan variabel statik pada saat Java interpreter dijalankan.
Perubahan variabel statik ini akan mengubah isi memori tersebut, tidak peduli dari bagian program mana perubahan variabel ini dilakukan. Kapanpun variabel ini dipanggil, ia akan mengambil data dari memori di mana dia disimpan, tidak peduli bagian program mana yang memanggilnya. Ini berarti variabel statik bisa diisi dari subrutin satu dan dimodifikasi dari subrutin lainnya. Atau dengan kata lain, variabel statik digunakan bersama oleh seluruh bagian kelas. Variabel lokal hanya bisa dipanggil dari dalam subrutin di mana ia dideklarasikan.
Deklarasi variabel anggota dapat dilakukan dengan cara yang sama seperti deklarasi variabel dalam subrutin. Kecuali, mereka juga bisa diberi attribut yang berisi sifatnya, misalnya "static", "public", atau "private". Misalnya,
static int umur;
static private double x;
Seperti halnya penentu akses pada subrutin, variabel yang bersifat "private" hanya bisa diakses dari dalam kelas yang bersangkutan, sedangkan variabel "public" dapat diakses dari manapun. Misalnya, kelas System, memiliki variabel out, sehingga bisa kita panggil dari luar dengan System.out.
Ketika kita mendeklarasikan suatu variabel di dalam subrutin, kita harus memberi nilai awal untuk variabel tersebut. Akan tetapi untuk variabel anggota, Java otomatis memberi nilai awal, sehingga tidak perlu diinisialisasi terlebih dahulu. Misalnya int akan diberi nilai awal 0, karakter diberi nilai yang berupa karakter dengan nilai Unicode 0, dan String diberi nilai awal null, sementara boolean diberi nilai awal false.
Kita tentu saja bisa memberi nilai awal apabila nilai awal yang diberi Java tidak cocok dengan aplikasi kita. Caranya misalnya dengan memberi nilai di awal subrutin main().

Tidak ada komentar:

Posting Komentar