Inisialisasi dan Deklarasi dalam Java
Ketika perintah deklarasi variabel dilaksanakan, komputer akan
menyiapkan memori untuk digunakan oleh variabel ini. Memori ini harus
diinisialisasi,yaitu diberi suatu nilai awal sebelum bisa digunakan
dalam perintah berikutnya. Pada variabel lokal, pernyataan deklarasi
sering diikuti oleh perintah pemberi nilai awal. Misalnya,
int i; // Deklarasi variabel yang bernama i
i = 0; // Beri nilai awal
Kita bisa juga melakukan deklarasi sekaligus inisialisasi variabel tersebut. Kedua pernyataan di atas bisa kita gabung menjadi
int i = 0; // Deklarasi variabel i sekaligus memberi nilai awal 0
Komputer akan tetap melakukan perintah di atas dalam dua langkah:
deklarasi variabel, kemudian mengisi nilai awal 0. Nilai awal tidak
harus berupa suatu bilangan, tetapi bisa juga berupa ekspresi yang
menghasilkan suatu nilai. Dan juga kita boleh melakukan inisialisasi
beberapa variabel sekaligus dalam 1 baris. Misalnya:
int x = 0, y = 1;
int awal, akhir = ‘A’ // Ok, tapi hanya akhir yang akan diinisialisasi
int N = 3, M = N+2; // Ok, karena N sudah diberi nilai awal sebelum digunakan oleh
Fitur ini biasa ditemui pada perulangan for, karena pernyataan 1 baris
ini bisa dimasukkan sebagai variabel kontrol di awal pernyataan for.
Karena variabel kontrol biasanya tidak berhubungan dengan bagian program
di luar perulangan, maka akan lebih praktis jika deklarasi variabel
kontrol itu dilakukan di awal perulangan.Contoh:
for ( int i = 0; i < 10; i++ ) {
System.out.println(i);
}
Tanda kurung { dan } di awal dan akhir untuk mempertegas bahwa i
hanya bersifat lokal di dalam perulangan yang tidak bisa diakses lagi
setelah perulangan selesai.
{
int i;
for ( i = 0; i < 10; i++ ) {
System.out.println(i);
}
}
Variabel anggota juga bisa diinisialisasi di mana dia dideklarasikan.Contoh:
public class Bank {
static double sukuBunga = 0.1; // sama dengan 10%
static long maxPenarikan = 3000000;
.
. // Perintah dan variabel lain
.
}
Variabel anggota statik akan dibuat pada saat kelas mulai dimasukkan
memori oleh interpreter Java, inisialisinya pun dilaksanakan pada saat
itu. Pada variabel anggota, deklarasi dan inisialisasi ini bukan hanya
sekedar singkatan dari 2 perintah seperti pada variabel lokal.
Pernyataan deklarasi adalah pernyataan yang bisa dibuat di luar
subrutin, sedangkan inisialisasi tidak bisa dilakukan di luar subrutin.
Contoh di bawah tidak diperbolehkan dalam Java.
public class Bank {
static double sukuBunga;
sukuBunga = 0.1; // ILEGAL, perintah ini harus ada di dalam subrutin
}
Karenanya, deklarasi variabel anggota biasanya juga dirangkai dengan
inisialisasi nilai awalnya. Jika tidak ada nilai awal yang diberikan,
maka nilai awal bawaan akan digunakan.
Misalnya “static int i;” setara dengan “static int i = 0;”.
Konstanta dan Sifat “final”
Kadang-kadang dalam kondisi tertentu, kita ingin nilai suatu variabel
tidak boleh berubah setelah diberi nilai awal. Misalnya, D
diinisialisasi dengan nilai 3.14159, maka nilai ini akan bisa diubah
oleh bagian lain dalam program. Di sini mungkin sang programmer ingin
mendefinisikan suatu konstanta yang diberi nama “D” sebagai pengganti
dari bilangan 3.14159.
Dengan cara ini, program akan lebih mudah dimengerti apabila program
tersebut ditulis dalam “keliling = D*diamater;” daripada “pokok =
3.14159*diameter;”.
Dalam java, sifat “final” bisa digunakan pada deklarasi variabel untuk
membuat nilai suatu variabel tidak bisa diubah setelah diinisialisasi.
Misalnya
final static double D = 3.14159;
Apabila kita mencoba mengganti isi variabel tersebut, misalnya di tengah
program dengan perintah “D = 20;” komputer akan menampilkan pesan
kesalahan sintaks pada saat kompilasi.
Sifat “final” boleh diberikan pada variabel lokal dan bahkan pada
parameter formal, akan tetapi paling berguna apabila diberikan pada
variabel anggota. Variabel anggota statik yang dideklarasikan dengan
sifat “final” juga disebut sebagai konstanta yang diberi nama.
Program akan jauh lebih mudah dibaca dengan menggunakan konstanta
bernama ini jika diberikan pada sesuatu angka penting yang digunakan
dalam program. Gaya penulisan yang dianjurkan untuk konstanta bernama
ini adalah dengan menggunakan huruf besar dengan baris bawah (jika
diperlukan).Contohnya:
final static double PI = 3.14159;
Gaya penulisan seperti ini juga digunakan oleh kelas standar Java,
yang di dalamnya terdapat banyak sekali konstanta bernama. Misalnya,
konstanta D sudah didefinisikan Java dalam kelas Math, yaitu Math.D,
sehingga kita tidak perlu mendefinisikannya sendiri.
Contoh lain adalah memberikan nama untuk gaya huruf, seperti Font.PLAIN,
Font.BOLD dan Font.ITALIC. Konstanta ini digunakan untuk menandai gaya
huruf untuk digunakan oleh subrutin lain dalam kelas Font.
Salah satu alasan untuk menggunakan konstanta bernama adalah supaya kita
bisa mengubah isinya dengan cepat apabila di kemudian hari kita ingin
memiliki nilai konstanta yang berbeda. Apabila nilai ini diubah, maka
kita harus mengkompilasi ulang program kita, karena nilai ini tidak bisa
diubah ketika program dieksekusi.
Misalnya kita definisikan suku Bunga pada contoh di atas sebagai konstanta bernama, yaitu
static final double SUKU_BUNGA = 0.1;
Suatu saat misalnya 2 tahun kemudian, bank tersebut ingin mengubah
suku bunganya menjadi 5% atau 0.05. Kita bisa mengubah nilainya hanya di
satu tempat yaitu di mana deklarasi SUKU_BUNGA berada. Kita tidak perlu
mencari semua nilai 0.1 di dalam program untuk menggantinya satu per
satu. Selain repot, mungkin membingungkan karena 0.1 bisa digunakan
untuk nilai lainnya, bukan hanya nilai suku bunga.
Aturan Penamaan dan Jangkauan (scope)
Ketika deklarasi variabel dieksekusi, komputer akan menyediakan tempat
di memori untuk variabel tersebut. Nama variabel dapat digunakan oleh
kode program untuk mengacu pada alamat di mana data tersebut disimpan di
dalam memori. Bagian di dalam kode sumber (yaitu program Java yang kita
tulis, masih dalam bentuk yang dimengerti manusia sebelum dikompilasi
menjadi bahasa mesin) di mana variabel tersebut valid dan bisa digunakan
disebut jangkauan variabel. Bukan hanya variabel yang memiliki
jangkauan, tetapi juga nama subrutin dan nama parameter formal.
Untuk subrutin statik, jangkauannya lebih mudah dipahami. Jangkauan
subrutin statik adalah kelas di mana ia didefinisikan. 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.
Untuk variabel anggota suatu kelas, aturannya sama, tetapi dengan
sedikit pengecualian. Kita boleh memiliki variabel lokal atau parameter
formal yang namanya sama dengan variabel anggota static. Jika ini
terjadi, maka variabel anggota akan disembunyikan oleh Java. Dalam
contoh berikut :
public class Game {
static int hitung; // variabel anggota
static void mainGame() {
int hitung; // variabel lokal
.
. // Perintah untuk main game
.
}
.
. // Variabel dan subrutin lain
.
} // akhir kelas Game
Kita lihat bahwa dalam subrutin mainGame(), “hitung” mengacu pada dua
hal yaitu variabel lokal dan variabel anggota statik. Di luar kelas
Game, “hitung” hanya mengacu pada variabel anggota statik. Dalam situasi
seperti ini, di dalam subrutin mainGame() maka “hitung” sebagai
variabel anggota akan disembunyikan oleh Java. Untuk menggunakan
variabel anggota ini, kita bisa menggunakan nama lengkapnya
yaituGame.hitung. Akan tetapi trik ini tidak bisa digunakan untuk
variabel anggota yang tidak statik.
Jangkauan parameter formal di dalam suatu subrutin berada di dalam blok
di mana ia dideklarasikan. Sehingga pada “for (int i=0; i<10; i++)”
variabel i hanya bisa di lihat di dalam blok perulangan for, tetapi
tidak valid di luar perulangan ini meskipun pada subrutin yang sama.
Akan tetapi kita tidak boleh mendeklarasikan parameter formal dengan
nama yang sama dengan variabel lokal yang berlaku di sana.Contohnya:
void subrutinJelek(int y) { int x; while (y > 0) {
int x; // ERROR: x sudah didefinisikan sebelumnya
.
.
.
}
}
Dalam bahasa pemrograman lain, pernyataan di atas masih dibolehkan,
yaitu dengan menyembunyikan x pada deklarasi sebelumnya. Akan tetapi
pada Java, segera setelah blok yang memuat suatu variabel selesai,
namanya bisa dipergunakan kembali.Contohnya:
void subrutinBagus(int y) {
while (y > 10) {
int x;
.
.
.
// Jangkauan x berakhir di sini
}
while (y > 0) {
int x; // OK: Deklarasi x sebelumnya sudah kadaluarsa
.
.
.
}
}
Ada beberapa hal lain yang menarik di Java. Nama subrutin dan
variabel boleh sama, karena komputer akan selalu dapat membedakan mana
subrutin atau variabel dengan melihat tanda buka kurung ‘(‘ setelah
namanya. Variabel tidak pernah menggunakan tanda kurung setelah namanya.
Sehingga suatu kelas boleh memiliki variabel anggota yang bernama
“hitung” dan subrutin yang bernama “hitung()”.
Lebih jauh lagi, nama suatu kelas boleh menggunakan nama subrutin atau
variabel yang sudah ada. Komputer bisa melihat apakah suatu nama berupa
kelas, variabel atau subrutin. Kelas adalah juga tipe data, sehingga
suatu kelas bisa digunakan untuk mendeklarasikan variabel dengan tipe
kelas tersebut, atau membuat subrutin yang keluarannya bertipe kelas
tersebut.
Atau sebagai contoh, perintah berikut bisa diterima oleh program Java :
static Test Test(Test Test) {
.
.
.
}
Test pertama adalah tipe keluaran suatu fungsi. Test kedua adalah
nama subrutin. Yang ketiga adalah tipe data parameter, dan keempat
adalah nama parameter normal.
