Pernyataan switch memiliki bentuk sebagai berikut :

switch (ekspresi) {
    case nilai1:
        perintah1
        break;
    case nilai2:
        perintah2
        break;
    case nilai3:
        perintah3
        break;
    default:
        perintah_lain
}

Di sini pernyataan switch akan mencari nilai ekspresi yang sesuai dengan nilai-nilai yang didaftarkan pada pernyataan case. Jika salah satu nilai ditemui, maka program akan melompat ke cabang case tersebut dan melakukan perintah yang terdapat di sana. Jika tidak ditemui, maka program akan melompat ke perintah yang terdapat pada pernyataan default.

Catatan ekspresi hanya bisa berbentuk nilai bilangan bulat (int, short, dan sejenisnya) atau karakter, sehingga kita tidak bisa menggunakan switch untuk mengevaluasi ekspresi yang berbentuk String.

Pernyataan break di atas sebetulnya tidak harus selalu ada. Tetapi, perintah break di sini memerintahkan komputer agar segera keluar dari blok switch apabila perintah tersebut telah selesai dilaksanakan.

Apabila perintah break tidak diberikan, maka program akan terus mengeksekusi perintah lain meskipun sudah berada di luar nilai yang tertera dalam pernyataan casenya.

Misalnya, lihat kode berikut ini :

switch (N)
    case 1:
        System.out.println("Angka tersebut bernilai 1");
        break;
    case 2:
    case 3:
    case 4:
    case 5:
        System.out.println("Angka tersebut bernilai 2, 3, 4, atau 5");
        break;
    case 6:
    case 7:
    case 8:
        System.out.println("Angka tersebut bernilai 6, 7, atau 8");
        break;
    default:
        System.out.println("Angka tersebut tidak bernilai 1 - 8");
}

Salah satu aplikasi di mana pernyataan switch berguna adalah untuk memproses menu. Menu memiliki beberapa pilihan dan user akan diminta untuk memilih suatu pilihan. Kita dapat menggunakan switch untuk menginstruksikan komputer untuk melakukan tugas tertentu sesuai dengan menu yang dipilih oleh user.

Jika Anda ingat pernyataan main() pada program Java, pernyataan main memiliki parameter String[] args, di mana args merupakan argumen yang diberikan pada saat program dijalankan melalui konsol. Biasanya argumen yang diberikan berupa opsi bagaimana program harus dilaksanakan. Di sini pernyataan switch juga berguna untuk memilih bagaimana program akan berjalan.

Jika Anda terbiasa atau pernah bergaul dengan Linux, maka tidak asing untuk menemukan perintah pada Linux seperti “ls -l” atau “tar xfz blabla”. Di sini ls atau tar adalah nama program dan “-l” atau “xfz blabla” adalah argumen yang diberikan pada saat program dijalankan.

Pernyataan kosong
Pernyataan kosong sebenarnya merupakan blok kosong, atau sama dengan {} tanpa perintah apa-apa di dalamnya. Dalam Java, pernyataan kosong juga berarti tanda ; sehingga apabila Anda menulis kode seperti

if (x > 0);
    perintah1

maka perintah1 akan tetap dilaksanakan walaupun x <= 0.

Perintah kosong sering merupakan sumber kesalahan dan salah satu fitur yang sulit untuk dicari kesalahannya pada saat debugging. Misalnya perintah berikut

for (i = 1; i <= 10; i++);
    System.out.println("hallo");

Anda berharap untuk mencetak kata hallo 10x di layar, pada kenyataannya hanya 1 hallo yang dicetak. Kenapa? Karena tanda “;” setelah for menyatakan bahwa program tidak melakukan apa-apa di dalam perulangan. Perintah System.out.println(“hallo”) tidak berada di dalam perulangan for, sehingga perintah ini hanya dijalankan 1x saja.

Pernyataan-pernyataan lain
Hingga saat ini kita sudah membahas hampir semua pernyataan yang Java sediakan. Ada beberapa yang akan kita bahas kemudian, tetapi pernyataan-pernyataan ini merupakan pernyataan lanjutan Java, seperti return yang digunakan untuk membuat subrutin sendiri, atau try…catch dan throw untuk mengontrol alur kesalahan apabila ditemui di tengah program (atau dengan kata lain eksepsi atau pengecualian), dan synchronized untuk mengatur kontrol untuk multi-threading.

if (suatu_kondisi)
     perintah1
else
    perintah2

Seperti biasa, perintah1 dan perintah2 bisa berbentuk blok yang terdiri dari beberapa perintah. Pernyataan if merupakan bentuk percabangan 2 arah. Bagian else yang terdiri dari kata “else” dan perintah2 tidak selalu harus ada.

Perhatikan bahwa baik perintah1 dan perintah2 bisa merupakan pernyataan if itu sendiri. Ada beberapa hal menarik yang mungkin berguna. Ambil contoh dalam pernyataan berikut

if (x > 0)
    if (y > 0)
        System.out.println("perintah1");
else
    System.out.println("perintah2");

Pertama-tama, komputer tidak peduli bagaimana Anda memformat paragraf dan indentasi dari pernyataan if tersebut. Java akan menganggap else terkait dengan if terdekat, sehingga kode di atas akan dianggap seperti

if (x > 0)
    if (y > 0)
        System.out.println("perintah1");
    else
        System.out.println("perintah2");

else di program di atas akan dianggap bagian dari pernyataan jika y > 0, padahal yang kita maksud adalah else jika x > 0. Untuk memperbaikinya, kita tambahkan tanda kurung {} sehingga menjadi

if (x > 0) {
    if (y > 0)
        System.out.println("perintah1");
}
else
    System.out.println("perintah2");

Kedua pernyataan tersebut memiliki arti yang berbeda. Jika x <= 0, pada kode pertama Java tidak mencetak apa-apa ke layar, sedangkan kode kedua java akan mencetak “perintah2″.

Lebih menarik lagi, perhatikan kode berikut

if (kondisi_pertama)
    perintah1
else
    if (kondisi_kedua)
        perintah2
    else
        perintah3

Lagi-lagi karena Java tidak membedakan indentasi penulisan, maka kode tersebut akan diterjemahkan Java seperti

if (kondisi_pertama)
    perintah1
else if (kondisi_kedua)
    perintah2
else
    perintah3

Dengan kata lain perintah tersebut lebih seperti percabangan 3 arah. Komputer akan mengeksekusi hanya salah satu dari perintah1, perintah2, atau perintah3. Komputer akan mengevaluasi kondisi_pertama, jika true, maka perintah1 dieksekusi sementara perintah2 dan perintah3 diabaikan. Jika false, maka kondisi_kedua akan dievaluasi. Jika true, maka perintah2 akan dieksekusi dan perintah3 diabaikan. Jika false, maka hanya perintah3 saja yang dieksekusi.

Berikut ini adalah contoh penggunaan percabangan 3 arah.

if (suhu < 20)
    System.out.println("Dingin");
else if (suhu < 30)
    System.out.println("Lumayan");
else
    System.out.println("Panas");

Kita bahkan dapat membentuk pernyataan if-else ini menjadi percabangan N arah, misalnya

if (kondisi_pertama)
    perintah1
else if (kondisi_kedua)
    perintah2
else if (kondisi_ketiga)
    perintah3
else if (kondisi_keempat)
    perintah4
.
.
.
else if (kondisi_keNminus1)
    perintahNmin1
else
    perintahN

Contoh berikut ini adalah mengurutkan 3 bilangan dari kecil ke besar. Misalnya kita mempunyai 3 variabel a,b dan c. Bilangan yang paling kecil adalah bilangan yang lebih kecil dari kedua bilangan yang lain. Sekarang mari kita rangkai logika untuk menentukan urutan bilangan dari kecil ke besar. Mula-mula kita cek apakah a lebih kecil dari b dan c, yaitu dengan pernyataan

if (a < b && a <c)

Jika a betul merupakan bilangan terkecil, maka kita uji apakah b lebih kecil dari c dengan perintah

if (b < c)

Jika a bukan bilangan terkecil, maka b atau c, salah satunya bisa merupakan bilangan terkecil. Kita hanya perlu membandingkan apakah b lebih kecil dari c dengan

if (b < c)

Jika b lebih kecil dari c, berarti kita tahu bahwa b adalah bilangan terkecil. Tetapi kita belum tahu apakah bilangan terkecil berikutnya adalah a atau c, sehingga kita harus menguji lagi dengan

if (a < c)

Jika a lebih kecil dari c, maka urutannya adalah b, a, c. Jika tidak, maka urutannya adalah b, c, a.

Demikian halnya apabila jika b > c, maka kita bisa tentukan urutan bilangannya.

Keseluruhan logika ini, bisa kita tuangkan dalam bentuk :

if (a < b && a < c) {
    if (b < c)
        System.out.println(a + " " + b + " " + c);
    else
        System.out.println(a + " " + c + " " + b);
} else if (b < c) {
    if (a < c)
        System.out.println(b + " " + a + " " + c);
    else
        System.out.println(b + " " + c + " " + a);
} else {
    if (a < b)
        System.out.println(c + " " + a + " " + c);
    else
        System.out.println(c + " " + b + " " + a);
}

Logika di atas bisa juga dituangkan dengan cara lain, yaitu melihat urutannya. Pertama kita cek apakah a < b. Jika ya, kita tahu bahwa urutannya pasti a terlebih dahulu baru b. Kemudian kita lihat apakah c berada di sebelah kiri a atau disebelah kanan b atau di tengah-tengah.

Demikian seterusnya jika urutannya b terlebih dahulu baru a. Sehingga kodenya bisa dituliskan dalam bentuk :

if (a < b) {
    if (c < a)
        System.out.println(c + " " + a + " " + b);
    else if (c > b)
        System.out.println(a + " " + b + " " + c);
    else
        System.out.println(a + " " + c + " " + b);
} else {
    if (c < b)
        System.out.println(c + " " + b + " " + a);
    else if (c > a)
        System.out.println(b + " " + a + " " + c);
    else
        System.out.println(b + " " + c + " " + a);
}

Misalnya, kita akan menghitung 1+2+3+4+5+…+100. Kita bisa ekspresikan program tersebut dalam bentuk

i = 1;
jumlah = 0;
while (i <= 100) {
    jumlah += i;
    i++;
}

Perulangan ini dapat ditulis juga dengan

jumlah = 0;
for (i = 1; i <= 100; i++)
    jumlah += i

Apa point-point penting yang kita lihat dari perubahan ini? Pertama mari kita lihat bentuk penggunaan while yang umum dilakukan

inisialisasi variabel
while (suatu_kondisi_variabel) {
    perintah
    update_variabel
}

Di sini perulangan while memiliki 3 komponen penting, yaitu inisialisasi, yaitu memberikan nilai awal suatu variabel, suatu_kondisi_variabel, yaitu pengujian bahwa perulangan akan terus dilakukan selama kondisi ini bernilai true, dan terakhir update_variabel, yaitu instruksi mengubah nilai kondisi variabel untuk membatasi perulangan sehingga akan selesai suatu saat, tidak berulang terus menerus.

Pada perulangan for, ketiga komponen ini dirangkai menjadi satu dalam bentuk

for (inisialisasi_variabel; kondisi_variabel; update_variabel)
   perintah

atau jika perintah merupakan blok yang terdiri dari banyak perintah, dapat dituliskan juga dalam bentuk

for (inisialisasi_variabel; kondisi_variabel; update_variabel) {
   banyak_perintah
}

Di sini inisialisasi variabel bisa berupa apa saja yang berbentuk perintah, misalnya memberikan variabel dengan nilai awal tertentu, dalam bentuk variabel = nilai_awal.

kondisi_variabel harus berbentuk pernyataan boolean seperti suatu_kondisi pada pernyataan while. Sedangkan update_variabel juga berbentuk perintah.

inisialisasi_variabel, kondisi_variabel, atau update_variabel dapat dikosongkan dan tidak harus selalu diisi. Bagian yang tidak diisi yang selalu digantikan dengan true, yang artinya perulangan akan terus dieksekusi tanpa henti. Untuk menghentikannya, perintah break harus diberikan ditengah-tengah badan perulangan.

Bentuk paling umum dari perulangan for adalah menghitung. Biasanya perulangan ini memiliki bentuk seperti

for (variabel = nilai_minimum; variabel <= nilai_maksimum; variabel++) {
    perintah
}

Perhatikan bagian terakhir adalah menaikkan nilai variabel dengan 1, yang artinya perulangan akan dimulai dengan nilai_minimum, diakhiri dengan nilai_maksimum dengan jeda 1.

Contoh, jika kita ingin berhitung 2,5,8,11,14,17, atau dengan kata lain, mulai dari 2 hingga 17 dengan jeda 3, kita bisa mengekspresikan for dengan

for (i = 2; i <= 17; i += 3) {
    System.out.println(i);
}

Untuk menghitung mundur, kita bisa menggunakan perintah seperti

for (i = 20; i >= 0; i--) {
    System.out.println(i);
}

Atau jika kita ingin menghitung maju dan mundur pada saat yang bersamaan, misalnya i dari 1 hingga 10 dan j dari 10 hingga 1, kita bisa ekspresikan dengan

for (i = 1, j = 10; i <= 10; i++, j--) {
    System.out.println(i + " " + j);
}

Catatan penting! Variabel yang akan digunakan, dalam contoh di atas i dan j, adalah variabel yang harus dideklarasikan sebelumnya. Java adalah bahasa pemrograman ketat, yang artinya semua harus didefinisikan dengan jelas sebelum digunakan. Untuk banyak kasus, deklarasi variabel dan perulangannya bisa dilakukan serentak pada bagian inisialisasi variabel. Misalnya :

for (int i = 1; i <= 10; i++) {
    System.out.println(i)
}

Perhatikan ada imbuhan int di depan inisialisasi variabel i, yang merupakan deklarasi variabel i dengan tipe data int sekaligus menginisialisasi nilainya dengan 1.

Perulangan for bertingkat

Seperti pada perulangan while, perulangan for pun dapat dilakukan bertingkat, artinya perulangan for di dalam perulangan for.

Kita ambil contoh sederhana misalnya membuat tabel perkalian seperti

 1   2   3   4   5   6   7   8   9  10  11  12
 2   4   6   8  10  12  14  16  18  20  22  24
 3   6   9  12  15  18  21  24  27  30  33  36
 4   8  12  16  20  24  28  32  36  40  44  48
 5  10  15  20  25  30  35  40  45  50  55  60
 6  12  18  24  30  36  42  48  54  60  66  72
 7  14  21  28  35  42  49  56  63  70  77  84
 8  16  24  32  40  48  56  64  72  80  88  96
 9  18  27  36  45  54  63  72  81  90  99 108
10  20  30  40  50  60  70  80  90 100 110 120
11  22  33  44  55  66  77  88  99 110 121 132
12  24  36  48  60  72  84  96 108 120 132 144

Program untuk membuat tabel perkalian tersebut bisa diekspresikan dengan algoritma pseudocode sebagai berikut

untuk setiap baris i = 1,2,3...,12
    cetak perkalian i dengan 1,2,3..12
    cetak baris baru

Kalau kita jabarkan lebih lanjut, perintah kedua juga merupakan perulangan dari 1 hingga 12, sehingga algoritma di atas bisa kita tulis sebagai

untuk setiap baris i = 1,2,3...,12
    untuk setiap kolom j = 1,2,3...,12
        cetak i*j
    cetak baris baru

Kita bisa terjemahkan ke dalam bahasa Java sebagai

for (int i = 1; i <= 12; i++) {
    for (int j = 1;  j <= 12; j++) {
        System.out.print(i*j + " ");
    }
    System.out.println("");
}

i = 1;
jumlah = 0;
while (i <= 100) {
    jumlah += i;
    i++;
}

jumlah = 0;
for (i = 1; i <= 100; i++)
    jumlah += i

inisialisasi variabel
while (suatu_kondisi_variabel) {
    perintah
    update_variabel
}

for (inisialisasi_variabel; kondisi_variabel; update_variabel)
   perintah

for (inisialisasi_variabel; kondisi_variabel; update_variabel) {
   banyak_perintah
}

for (variabel = nilai_minimum; variabel <= nilai_maksimum; variabel++) {
    perintah
}

for (i = 2; i <= 17; i += 3) {
    System.out.println(i);
}

for (i = 20; i >= 0; i--) {
    System.out.println(i);
}

for (i = 1, j = 10; i <= 10; i++, j--) {
    System.out.println(i + " " + j);
}

for (int i = 1; i <= 10; i++) {
    System.out.println(i)
}

 1   2   3   4   5   6   7   8   9  10  11  12
 2   4   6   8  10  12  14  16  18  20  22  24
 3   6   9  12  15  18  21  24  27  30  33  36
 4   8  12  16  20  24  28  32  36  40  44  48
 5  10  15  20  25  30  35  40  45  50  55  60
 6  12  18  24  30  36  42  48  54  60  66  72
 7  14  21  28  35  42  49  56  63  70  77  84
 8  16  24  32  40  48  56  64  72  80  88  96
 9  18  27  36  45  54  63  72  81  90  99 108
10  20  30  40  50  60  70  80  90 100 110 120
11  22  33  44  55  66  77  88  99 110 121 132
12  24  36  48  60  72  84  96 108 120 132 144

untuk setiap baris i = 1,2,3...,12
    cetak perkalian i dengan 1,2,3..12
    cetak baris baru

untuk setiap baris i = 1,2,3...,12
    untuk setiap kolom j = 1,2,3...,12
        cetak i*j
    cetak baris baru

for (int i = 1; i <= 12; i++) {
    for (int j = 1;  j <= 12; j++) {
        System.out.print(i*j + " ");
    }
    System.out.println("");
}

Pernyataan while telah diperkenalkan pada bagian sebelumnya. Perulangan while memiliki bentuk

while (suatu_kondisi)
    perintah

perintah bisa juga berupa blok yang berisi kumpulan perintah-perintah di antara { dan }. perintah ini disebut juga dengan inti perulangan. Inti perulangan akan terus dieksekusi selama suatu_kondisi bernilai true. suatu_kondisi ini disebut juga penguji perulangan.

Ada beberapa hal yang mungkin jadi pertanyaan. Apa yang terjadi jika suatu_kondisi sudah bernilai false sejak pertama kali komputer sampai pada pernyataan ini? Dalam hal ini blok perulangan tidak akan dieksekusi sama sekali. Program akan melompat ke perintah berikutnya di luar blok perulangan.

Lalu apa yang terjadi jika suatu_kondisi bernilai false di tengah-tengah perulangan, apakah program keluar dari perulangan saat itu juga? Dalam hal ini, tentunya tidak. Program akan mengeksekusi semua perintah hingga akhir blok selesai. Setelah itu program akan kembali ke pernyataan while, dan setelah mengevaluasi kembali suatu_kondisi, dan jika hasilnya salah, baru program akan melompat ke perintah berikutnya di luar blok.

Mari kita ubah sedikit algoritma yang kita buat di bagian sebelumnya. Kali ini kita akan membuat program yang menghitung rata-rata dengan cara menanyakan suatu bilangan kepada user, kemudian program akan berhenti jika masih ada data yang akan diproses.

Inisialisasi jumlah dengan 0
Inisialisasi n (berapa data yang dimasukkan user) dengan 0
while (masih ada data yang akan diproses):
    Minta input dari user
    Tambah jumlah dengan input dari user
    Tambah n dengan 1
Bagi jumlah dengan n untuk menghitung rata-rata
Cetak rata-rata ke layar

Pertanyaan berikutnya, bagaimana menentukan masih ada data yang akan diproses? Cara yang paling mudah adalah melihat apakah nilai yang dimasukkan user bernilai 0. Nol di sini bukan termasuk data yang akan dijumlahkan tetapi bertugas sebagai sinyal bahwa tidak ada lagi data yang harus dimasukkan.

Lalu bagaimana kita harus menguji bahwa data yang dimasukkan bernilai 0 atau bukan? (Ingat, kita baru menanyakan data di dalam blok perulangan. Pada saat komputer pertama kali menemui perulangan while, komputer tidak tahu apa-apa.) Dalam hal ini, kita akan sedikit ubah algoritma kita seperti berikut :

Inisialisasi jumlah dengan 0
Inisialisasi n (berapa data yang dimasukkan user) dengan 0
Minta input dari user
while (input tidak sama dengan 0):
    Tambah jumlah dengan input dari user
    Tambah n dengan 1
    Minta input dari user
Bagi jumlah dengan n untuk menghitung rata-rata
Cetak rata-rata ke layar

Pada dasarnya, kita tanyakan user terlebih dahulu sebelum perulangan while. Dengan cara ini, kita bisa mendapat nilai input untuk dievaluasi pada pernyataan while. Di dalam perulangan while, kita tempatkan pertanyaan untuk mendapat input dari user di akhir perulangan. Artinya, setelah kita memproses input dari user, kita akan tanyakan lagi kepada user untuk mendapatkan kondisi untuk mengevaluasi kondisi while berikutnya.

Perhatikan juga bahwa ketika 0 dimasukkan, program tidak akan menghitung nilai 0 lagi. Di algoritma sebelumnya, nilai 0 akan ikut dijumlahkan dan n akan bertambah 1, padahal 0 bukan data. Nol hanya berfungsi sebagai sinyal bahwa perulangan harus selesai. Masalah ini sangat amat umum ditemui oleh programmer, karena menghitung satu demi satu ternyata tidak mudah. Untuk itu debugger diperlukan untuk melihat lebih detail apa yang dilakukan oleh komputer.

Kita bisa ubah algoritma di atas menjadi program Java sebagai berikut.

import java.io.*;

public class RataRata {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		double jumlah = 0;
		double bilangan = 0;
		int n = 0;
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		String strbilangan = null;

		System.out.print("Masukkan bilangan pertama : ");
		try {
			strbilangan = br.readLine();
		} catch (IOException ioe) {
	        	System.out.println("Kesalahan IO, program berhenti");
	        	System.exit(1);
		}

		// mengubah input menjadi double agar bisa diproses lebih lanjut
		bilangan = Double.parseDouble(strbilangan);

		while (bilangan != 0) {
		    jumlah += bilangan; 	// sama dengan : jumlah = jumlah + bilangan
		    n++;			// sama dengan : n = n+1

		    // tanya user input
		    System.out.print("Masukkan bilangan berikutnya (atau 0 untuk mengakhiri) : ");
		    try {
		        strbilangan = br.readLine();
		    } catch (IOException ioe) {
		        System.out.println("Kesalahan IO, program berhenti");
		        System.exit(1);
		    }

		    // mengubah input menjadi double agar bisa diproses lebih lanjut
		    bilangan = Double.parseDouble(strbilangan);
		}

		// hitung rata-rata
		double ratarata = jumlah/n;

		// cetak hasilnya ke layar
		if (n == 0) {
			System.out.println("Data kosong, rata-rata tidak bisa dihitung");
		} else {
			System.out.println("Anda memasukkan " + n + " data");
			System.out.println("Rata-rata bilangan yang dimasukkan adalah " + ratarata);
		}
	}

Berikut hasil keluarannya :

Pernyataan do … while

Kadang-kadang akan lebih mudah menulis perulangan jika penguji perulangan dilakukan di akhir badan perulangan. Dalam hal ini badan perulangan akan dieksekusi terlebih dahulu tanpa memperdulikan apakah suatu kondisi bernilai true atau false. Pengujian dilakukan di akhir setelah suatu kondisi didapat dalam eksekusi perulangan pertama kali.

Pernyataan do … while pada dasarnya merupakan pernyataan while terbalik, dengan bentuk.

do
    perintah
while (suatu_kondisi);

Atau apabila perintah berbentuk blok kumpulan perintah-perintah, bisa juga ditulis dalam bentuk

do {
    perintah-perintah
} while (suatu_kondisi);

Perlu diingat bahwa pernyataan do … while diakhiri dengan tanda ; di akhir while.

Contoh sederhana adalah program bermain game, di mana game akan menanyakan apakah user ingin bermain lagi.

do {
    main game
    tanya user apakah ingin main lagi
} while (user menjawab ya);

Jika suatu saat Anda harus menulis kondisi pada pernyataan while seperti ini while (jawaban == true), Anda bisa mengganti pernyataan ini menjadi while (jawaban). Menguji apakah jawaban sama dengan true sama artinya dengan melihat apakah jawaban berisi “true”.

Demikian juga dengan while (jawaban == false), bisa diganti dengan while (!jawaban). Seperti dijelaskan pada bab tentang operator boolean, operator ! membalik isi dari boolean, misalnya dari true menjadi false atau sebaliknya. Dengan menuliskan while (!jawaban) berarti sama dengan menguji apakah jawaban berisi false.

Pernyataan do … while memberikan keleluasaan kepada Anda untuk berekspresi dengan lebih lugas. Sebenarnya, untuk memecahkan suatu masalah dengan perulangan do … while juga bisa diekspresikan dengan perintah while, demikian juga sebaliknya.

do
   perintah
while (suatu_kondisi);

bisa dituliskan dalam bentuk

perintah
while (suatu_kondisi)
   perintah

Demikian juga dengan

while (suatu_kondisi)
   perintah

bisa juga dituliskan dalam bentuk

if (suatu_kondisi) {
    do {
        perintah
    while (suatu_kondisi);
}

tanpa merubah aliran program sama sekali.

Pernyataan break dan continue

Pernyataan while dan do … while menguji kondisi di awal atau di akhir badan perulangan. Pengujian bisa juga dilakukan di tengah-tengah badan perulangan, kemudian memerintahkan program untuk keluar dari badan perulangan saat itu juga. Caranya dengan menggunakan perintah

break<code>, sehingga program seperti

<code>while (suatu_kondisi)
    perintah

bisa ditulis dalam bentuk

while (true)
    perintah
    if (!suatu_kondisi)
        break;
<code>

Apa makna dari program di atas? <code>while (true)

artinya memerintahkan program untuk melakukan perulangan selamanya, karena true tidak akan berubah. Di tengah-tengah program, kita uji apakah suatu_kondisi bernilai false. Jika ya, maka perintah break akan dieksekusi yang menyebabkan program keluar dari badan perulangan ke perintah berikutnya di luar badan perulangan.

Kadang-kadang gaya penulisan ini lebih masuk akal ketimbang gaya penulisan baku seperti while atau do … while, tapi tentu saja ini tergantung dari cara pikir masing-masing programmer dan juga masalah yang akan dipecahkan.

Pernyataan while atau do … while dapat dibuat bertingkat, misalnya membuat blok while dalam blok while.

while (suatu_kondisi) {
    perintah
    while (kondisi_lain) {
        perintah_lain
        while (kondisi_lain_lagi) {
            perintah_baru
        }
    }
}

Apabila perintah break diberikan, maka program akan keluar dari perulangan yang berada persis di atasnya. Misalnya, apabila perintah break diberikan setelah perintah_lain maka program akan keluar dari dalam perulangan while (kondisi_lain).

Perlu diingan juga apabila perintah break diberikan di dalam pernyataan if, maka program akan keluar dari perulangan yang persis di atasnya.

Selain perintah break yang secara langsung menghentikan perulangan, perintah continue digunakan untuk menghentikan operasi saat itu, mengabaikan perintah hingga perulangan berakhir, kemudian kembali kepada perintah while lagi. Misalnya,

while (suatu_kondisi) {
    perintah
    continue;
    perintah_lagi
    perintah_lain_lagi
}

Perulangan akan menjalankan perintah, mengabaikan perintah_lagi dan perintah_lain_lagi, kemudian kembali kepada pernyataan while untuk mengevaluasi apakah suatu_kondisi bernilai true. Jika ya perulangan akan diteruskan. Tetapi karena ada perintah continue, artinya selama perulangan tersebut berjalan, perintah_lagi dan perintah_lain_lagi tidak akan pernah dieksekusi.

}

Untuk itu programmer baru harus dilengkapi dengan cara berfikir dan peralatan yang memungkinkan mereka untuk sukses dalam menerjemahkan suatu tugas menjadi rangkaian perintah yang bisa dimengerti oleh komputer.

Program komputer itu seperti seni yang memuat suatu ide. Seorang programmer mulai dengan suatu tugas di kepalanya, misalnya menghitung sisi miring dari segitiga siku-siku. Kemudian dia akan berfikir tentang apa yang harus dilakukan untuk menyelesaikan tugas tersebut dalam bahasa manusia. Dalam hal ini misalnya, sisi miring dapat dihitung dengan mengambil akar kuadrat dari jumlah kuadrat sisi siku-sikunya. Pemecahan masalah ini kemudian diterjemahkan ke dalam bahasa pemrograman yang berupa perintah langkah demi langkah bagaimana komputer harus menyelesaikan tugas tersebut.

Perintah langkah demi langkah hingga detail ini disebut algoritma. (Secara teknis, algoritma adalah kumpulan langkah-langkah sederhana yang jelas, tidak membingungkan karena hanya ada satu cara untuk melakukan langkah sederhana tersebut, dilakukan selama kurun waktu tertentu. Kita tidak ingin program menghitung selamanya tanpa batas waktu.)

Program ditulis dalam bahasa pemgrograman tertentu. Tetapi algoritma ditulis secara umum atau generic, dalam bahasa manusia, sehingga bisa diimplementasikan menggunakan bahasa pemrograman apapun. Atau dengan kata lain, algoritma mirip seperti ide di belakang program yang akan kita tulis. Tetapi ide tersebut harus jelas, dan memuat langkah demi langkah yang sederhana.

Jadi darimana algoritma itu datang? Biasanya orang harus membuat algoritma itu. Dengan skill, latihan dan pengalaman, orang akan lebih mudah membuat suatu algoritma.

Di bagian ini akan dibahas tentang bagaimana membuat suatu algoritma. Jadi bahasa Java akan kita tinggalkan sementara. Kita akan beralih untuk berfikir secara abstrak.

Misalnya, kita memiliki suatu tugas di kepala. Salah satu cara untuk menyelesaikan tugas itu adalah menuliskan penyelesaiannya langkah demi langkah, dan dari sana kita membuat algoritma untuk menyelesaikan masalah itu. Kemudian dari setiap langkah tersebut, kita bisa membuat langkah-langkah lain yang lebih detail, sampai kita bisa menerjemahkan langkah-langkah itu ke dalam bahasa pemrograman. Metode ini disebut penghalusan bertahap (stepwise refinement), dan sifatnya top-down atau dari atas ke bawah. Sambil kita menambah detail pada setiap langkah, kita bisa mulai menuliskan algoritma dalam bentuk pseudocode (kode palsu) yang bentuknya tidak harus persis atau mengikuti suatu bahasa pemrograman.

Misalnya, kita ambil contoh untuk menghitung rata-rata dari 5 bilangan. Kita bisa menuliskan pseudocode dalam bentuk berikut :

ambil input user untuk bilangan pertama
masukkan ke variabel x
ambil input user untuk bilangan kedua
tambahkan variabel x dengan bilangan kedua
ambil input user untuk bilangan ketiga
tambahkan variabel x dengan bilangan ketiga
ambil input user untuk bilangan keempat
tambahkan variabel x dengan bilangan keempat
ambil input user untuk bilangan kelima
tambahkan variabel x dengan bilangan kelima
bagi variabel x dengan 5
tampilkan hasilnya di layar

Algoritma di atas betul, tetapi terlalu banyak perulangan. Bagaimana jika bilangan yang akan dirata-ratakan ada 100? Kita bisa udah algoritma di atas dengan pseudocode yang lebih mudah dimengerti, misalnya

while a kurang dari 5
    ambil input user untuk bilangan ke-a
    tambahkan nilai x dengan bilangan ke-a
    tambah a dengan 1
bagi variabel x dengan 5
tampilkan di layar

Sekarang, ambil input user bisa dideskripsikan lebih jauh. Kita harus memberikan pertanyaan kepada user. Dan seperti dipelajari pada bab sebelumnya, input dari user berupa String yang harus diterjemahkan ke dalam tipe data bilangan untuk bisa dikalkulasi. Pseudocode di atas dapat ditulis ulang sebagai berikut :

while a kurang dari 5
    beri pertanyaan kepada user untuk memasukkan bilangan ke-a
    ambil input user untuk bilangan ke-a
    ubah input menjadi bilangan
    tambahkan nilai x dengan bilangan ke-a
    tambah a dengan 1
bagi variabel x dengan 5
tampilkan di layar

Dan juga dari pelajaran sebelumnya, untuk mengambil input user, kita bisa dihadapkan pada permasalahan IO (input output). Selain itu kita juga harus menginisialisasi pembaca dan tempat meletakkan string sementara. Untuk itu, kita harus mengubah pseudocode nya menjadi seperti ini

inisialisasi pembaca
inisialisasi tempat string sementara
while a kurang dari 5
    beri pertanyaan kepada user untuk memasukkan bilangan ke-a
    "coba" ambil input user untuk bilangan ke-a
        jika ada masalah keluar dari program
    ubah input menjadi bilangan
    tambahkan nilai x dengan bilangan ke-a
    tambah a dengan 1
bagi variabel x dengan 5
tampilkan di layar

Kemudian, perlu diperhatikan bahwa variabel a dan x tidak diketahui nilai awalnya oleh komputer. Bayangkan jika nilai a dan x ditentukan oleh komputer secara acak, bukan saja hasil rata-ratanya menjadi tak tentu, tetapi juga perulangannya menjadi tak menentu. Untuk itu kita harus tambahkan perintah untuk menginisialisasi a dan x dengan 0, sehingga pseudocodenya menjadi

inisialisasi x dengan 0
inisialisasi a dengan 0
inisialisasi pembaca
inisialisasi tempat string sementara
while a kurang dari 5
    beri pertanyaan kepada user untuk memasukkan bilangan ke-a
    "coba" ambil input user untuk bilangan ke-a
        jika ada masalah keluar dari program
    ubah input menjadi bilangan
    tambahkan nilai x dengan bilangan ke-a
    tambah a dengan 1
bagi variabel x dengan 5
tampilkan di layar

Dari sini kita bisa menerjemahkan pseudocode tersebut menjadi program Java, yaitu :

double x = 0;
int a = 0;
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
String strbilangan = null;

while (a < 5) {
    System.out.print("Masukkan bilangan ke-" + a + " : ");
    try {
        strbilangan = br.readLine();
    } catch (IOException ioe) {
        System.out.println("Kesalahan IO, program berhenti");
        System.exit(1);
    }
    x = x + Double.parseDouble(strbilangan);
    a = a + 1;
}
x = x / 5;
System.out.println("Rata-rata bilangan yang dimasukkan adalah " + x);

Jangan lupa bahwa program tersebut membutuhkan paket java.io.*, sehingga kita harus menambah

import java.io.*

di awal kelas.

import java.io.*;

public class HitungRataRata5Bil {
	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		double x = 0;
		int a = 0;
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		String strbilangan = null;
		while (a < 5) {
		    System.out.print("Masukkan bilangan ke-" + a + " : ");
		    try {
		        strbilangan = br.readLine();
		    } catch (IOException ioe) {
		        System.out.println("Kesalahan IO, program berhenti");
		        System.exit(1);
		    }
		    x = x + Double.parseDouble(strbilangan);
		    a = a + 1;
		}
		x = x / 5;
		System.out.println("Rata-rata bilangan yang dimasukkan adalah " + x);
	}
}

Masing-masing struktur ini sebetulnya merupakan pernyataan tunggal yang berdiri dengan sendirinya, tetapi di dalamnya terdiri dari satu atau lebih perintah sehingga keseluruhannya menjadi suatu struktur perintah.

Blok

Blok adalah pernyataan sederhana yang dimulai dengan { dan diakhiri dengan }. Tujuannya untuk mengelompokkan beberapa perintah sehingga lebih dimengerti. Misalnya

{
     perintah
}

Pernyataan blok biasanya terdapat dalam struktur kontrol, tetapi sebetulnya tanpa struktur kontrol pun, blok tetap berlaku. Contoh sederhana penggunaan blok ini adalah dalam subrutin main() yang kita lakukan pada contoh-contoh sebelumnya.

Berikut ini adalah 2 contoh penggunaan blok.

{
    System.out.println("Hallo");
    System.out.println("Dunia");
}

{ // blok ini digunakan untuk menukar isi variable x dan y
    int temp;
    temp = x;
    x = y;
    y = temp;
}

Pada blok kedua, kita mendeklarasikan variable baru temp. Dalam blok kedua ini, variabel apapun yang dideklarasikan tidak akan dapat diakses dari luar blok ini. Variabel ini disebut variabel lokal, karena hanya bisa diakses dari dalam blok.

Ketika komputer menjalankan program ini, komputer akan mempersiapkan memori untuk menyimpan variabel yang dideklarasikan di dalam blok ini. Ketika blok ini selesai dijalankan, komputer akan melepas memori yang digunakan dalam blok ini untuk digunakan oleh bagian program lain.

Konsep “scope” atau jangkauan pada konsep pemrograman, mengacu pada bisa atau tidaknya suatu variabel dilihat oleh bagian program lain. Jangkauan suatu variabel menyatakan di bagian mana variabel ini valid atau dengan kata lain bisa diakses. Jangkauan variabel dalam suatu blok terbatas hanya pada blok tersebut.

Blok sendiri sebetulnya bukan merupakan struktur kontrol. Program akan berjalan seperti biasa dari atas kebawah seperti biasa. Secara umum struktur kontrol dibagi menjadi 2 bagian, yaitu : perulangan dan percabangan.

Perulangan

Sebagai contoh untuk membahas tentang perulangan, kita lihat pernyataan while, yang memiliki bentuk seperti

while (suatu_kondisi) {
   perintah
}

Semantik pada pernyataan while tersebut adalah sebagai berikut. Ketika komputer sampai pada pernyataan while, komputer akan melakukan perhitungan pada suatu_kondisi. Apabila suatu_kondisi bernilai true, blok yang berisi perintah akan dilakukan. Setelah komputer sampai pada bagian akhir blok, komputer akan menghitung kembali suatu_kondisi. Jika masih bernilai true, maka blok tersebut akan dieksekusi, dan jika tidak, program akan melompat ke bagian program berikutnya setelah blok berakhir. Atau dengan kata lain, jika suatu_kondisi bernilai false, blok perintah tidak akan dieksekusi.

Berikut ini adalah contoh untuk menulis bilangan 1 hingga 5.

int angka = 1; // inisialisasi variabel, kita mulai dengan mengisi variabel angka dengan 1

while (angka <= 5) {
     System.out.println(angka); // cetak isi angka di layar
     angka = angka + 1;         // tambah angka dengan 1
}

System.out.println("Selesai...");

Variabel angka kita inisialiasi (persiapkan) dan kita isi mula-mula dengan 1. Ketika program sampai pada pernyataan while, program akan mengevaluasi apakah angka <= 5. Pada saat program baru dimulai, angka masih bernilai 1, sehingga pernyataan angka <= 5 bernilai true. Dalam hal ini perintah di dalam blok akan dieksekusi, yaitu mencetak angka ke layar, kemudian menambah angka dengan 1. Sekarang angka bernilai 2.

Setelah sampai pada akhir blok, program akan kembali pada awal pernyataan while. Sekarang angka bernilai 2, dan karena 2 masih kurang dari atau sama dengan 5, program akan kembali mengeksekusi perintah dalam blok. Begitu seterusnya hingga angka bernilai 6. Pada saat ini program akan berhenti melakukan perulangan dan berhenti melakukan eksekusi perintah di dalam blok tersebut, kemudian melakukan perintah berikutnya, yaitu menampilkan kata “Selesai…”.

Percabangan

Pernyataan if memperintahkan komputer untuk memilih salah satu aksi yang akan dilakukan, tergantung pada suatu kondisi tertentu. Bentuknya dapat ditulis sebagai berikut

if (suatu_kondisi)
     perintah_1;
else
     perintah_2;

Perintah_1 dan perintah_2 juga bisa berbentuk blok, sehingga pernyataan di atas dapat ditulis juga sebagai berikut

if (suatu_kondisi) {
     perintah_1;
} else {
     perintah_2;
}

Ketika komputer sampai pada pernyataan if, komputer akan menghitung apakah suatu_kondisi bernilai true. Jika iya, maka blok perintah berikutnya akan dieksekusi, dalam hal ini perintah_1. Jika tidak, maka blok setelah pernyataan else akan dieksekusi, yaitu perintah_2.

Sebagai contoh, mari kita kembali pada contoh program untuk membalik nilai x dan y, dengan syarat x harus lebih besar dari y. Dalam hal ini, setelah program ini dieksekusi, nilai x akan selalu bernilai lebih kecil dari y, karena jika nilai x lebih besar, nilai x akan ditukar dengan nilai y.

if (x > y) { // jika x lebih besar dari y
    // blok ini digunakan untuk menukar isi variable x dan y
    int temp;
    temp = x;
    x = y;
    y = temp;
}

Contoh berikut adalah program untuk menentukan apakah suatu bilangan merupakan bilangan genap atau bilangan ganjil. Dengan menggunakan operator %, yaitu sisa pembagian, kita dapat menentukan apabila sisa pembagian suatu bilangan dengan 2 adalah 0, maka bilangan tersebut merupakan bilangan genap. Jika tidak, maka bilangan tersebut adalah bilangan ganjil.

if ((x % 2) == 0) {
    System.out.println(x + " adalah bilangan genap");
} else {
    System.out.println(x + " adalah bilangan ganjil");
}

Kita akan bahas tentang struktur kontrol di bagian berikutnya. Semoga bagian ini yang merupakan bagian pendahuluan tentang struktur kontrol dapat dimengerti sehingga kita bisa mempelajari konsep yang lebih kompleks lagi.

Sebagai contoh, kita akan membuat program untuk menghitung nilai investasi setelah n tahun. Input yang diminta dari user adalah :

• Nama
• Investasi awal (Rp)
• Bunga (%)
• Periode (tahun)

Dengan menggunakan teknik yang sama pada contoh sebelumnya, kita bisa mengambil input tersebut menggunakan kelas BufferedReader seperti berikut.

nama = br.readLine();
strawal = br.readLine();
strbunga = br.readLine();
strperiode = br.readLine();

Tetapi karena keluaran dari readLine() bertipe String, kita harus mengubahnya menjadi bentuk bilangan agar dapat diproses lebih lanjut.

Untuk mengubah String menjadi int, kita dapat menggunakan kelas Java Integer yang di dalamnya memiliki fungsi parseInt(str). Fungsi ini dapat dipanggil dengan:

periode = Integer.parseInt(strperiode);

Sedangkan untuk mengubah String menjadi double, kita menggunakan kelas Java Double yang di dalamnya memiliki fungsi parseDouble(str). Fungsi ini dapat dipanggil dengan:

awal= Double.parseDouble(strawal);
bunga = Double.parseDouble(strbunga);

Setelah semua variabel didapat dan diubah, kita baru bisa untuk memulai perhitungan. Untuk menghitung bunga bank setelah n tahun, kita bisa menggunakan rumus berikut :
akhir = awal * (1 + bunga)^periode

Dalam Java, rumus tersebut bisa dituliskan dengan ekspresi berikut

akhir = awal * Math.pow(1 + bunga,periode);

import java.io.*;

public class HitungInvestasiNPeriode {
	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		// buat objek baru untuk mengambil input
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		// tempat di mana input dari user akan diletakkan
		String nama = null;
		String strawal = null;
		String strbunga = null;
		String strperiode = null;
		try {
			System.out.print("Masukkan nama Anda : ");
			nama = br.readLine();
			System.out.print("Masukkan jumlah awal investasi (Rp) : ");
			strawal = br.readLine();
			System.out.print("Masukkan bunga (mis 0.1 = 10%) : ");
			strbunga = br.readLine();
			System.out.print("Masukkan periode (tahun) : ");
			strperiode = br.readLine();
		} catch(IOException ioe) {
			System.out.println("Kesalahan IO pada saat menanyakan nama Anda");
			System.exit(1);
		}
		// deklarasi variabel tipe bilangan
		double awal;
		double bunga;
		int periode;
		double akhir;
		// mengubah input dari Sting ke tipe data bilangan
		periode = Integer.parseInt(strperiode);
		awal = Double.parseDouble(strawal);
		bunga = Double.parseDouble(strbunga);
		// menghitung hasil investasi selama n periode
		akhir = awal * Math.pow(1+bunga, periode);
		// tampilkan hasil perhitungan di layar
		System.out.println();
		System.out.println("Terima kasih, " + nama);
		System.out.print("Hasil investasi Anda setelah " + periode + " tahun ");
		System.out.println("adalah Rp. " + akhir);
	}
}

Berikut ini adalah hasil keluarannya :

Kita membutuhkan kelas yang beberapa kelas, yaitu BufferedReader, InputStreamReader, dan System.in (lawan dari System.out yang kita gunakan untuk menampilkan pesan di layar).

Dua kelas pertama terdapat dalam package yang dinamakan java.io. Untuk itu, kita harus menambah satu baris perintah

import java.io.*

yang berarti mengimport semua kelas dalam paket java.io (tanda * berarti semua).

Kemudian kita harus juga membuat suatu objek dari kelas BufferedReader. Kelas BufferedReader adalah kelas abstrak yang menangani baca tulis ke suatu media.

Kelas ini membutuhkan kelas lain sebagai pekerjanya, yaitu InputStreamReader. Dan InputStreamReader membutuhkan media tempat baca tulis dilakukan, yaitu System.in.

Semua ini bisa dituliskan dalam satu perintah yaitu :

BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

Di sini variabel br merupakan objek yang merupakan jelmaan dari kelas BufferedReader.

Untuk memerintahkan Java mengambil input dari user, kita gunakan fungsi readline() yang terdapat pada kelas BufferedReader, dalam hal ini terealisasi pada objek br.

nama = br.readLine();

Karena kita berhubungan langsung dengan sistem IO (input-output) komputer yang harus diasumsikan tidak pasti (misalnya ada masalah pada sistem keyboard, atau komputer sedang bekerja berat sehingga input dari user tidak bisa diambil), kita harus menempatkan fungsi readLine() pada klausa

try {
...
} catch (IOException ioe) {
...
}

Perintah di dalam try { … } adalah perintah yang kita ingin jalankan pada situasi yang “mungkin” tidak berhasil.

Parameter pada catch, yaitu IOException ioe adalah jenis kesalahan yang ingin kita tangkap. Dalam hal ini kita ingin menangkap adanya kesalahan IO, yaitu kesalahan yang bertipe IOException.

Perintah di dalam catch { … } adalah perintah yang akan dilakukan apabila kesalahan ditangkap. Jika tidak ada kesalahan IO yang ditemukan, maka bagian ini akan dilewatkan (tidak dijalankan).

Mari kita lihat program akhir untuk mengambil input dari user.

import java.io.*; 

public class AmbilInputKonsol {
	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		System.out.print("Masukkan nama Anda : ");
		// buat objek baru untuk mengambil input
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		// tempat di mana input dari user akan diletakkan
		String nama = null;
		try {
			nama = br.readLine();
		} catch(IOException ioe) {
			System.out.println("Kesalahan IO pada saat menanyakan nama Anda");
			System.exit(1);
		}
		System.out.println("Terima kasih, " + nama);
	}
}

Catatan : Pada objek, seperti String, operasi pembanding akan membandingkan alamat memory tempat objek itu disimpan, bukan membandingkan isinya. Untuk membandingkan isi String, gunakan equals(), equalsIgnoreCase(), dan compareTo() seperti dibahas pada bagian sebelumnya.

Operator boolean AND

Operator kondisi AND menghasilkan “true” apabila kedua operandnya bernilai “true”. Jika salah satunya atau keduanya “false”, operator ini menghasilkan “false”. Berikut ini tabel kebenaran operasi AND.

Operator && akan mengevaluasi Op2 (di sebelah kanan) HANYA jika operand 1 bernilai “true”. Seperti terlihat dari tabel di atas, apabila Op1 (di sebelah kiri) bernilai “false”, hasilnya akan selalu “false” tidak tergantung pada isi dari Op2.

Operator kondisi OR

Operator kondisi OR menghasilkan “true” jika salah satu operandnya bernilai “true”. Jika keduanya “false”, operator ini menghasilkan “false”. Berikut ini table kebenaran oeprasi OR.

Operator || akan mengevaluasi Op2 (di sebelah kanan) HANYA jika operand 1 bernilai “false”. Seperti terlihat dari tabel di atas, apabila Op1 (di sebelah kiri) bernilai “true”, hasilnya akan selalu “true” tidak tergantung pada isi dari Op2.

Operator NOT

Operator NOT (”!”) melakukan operasi boolean NOT pada operand atau ekspresi tunggal. Operator ini mengecek nilai boolean dari suatu operand atau expresi kemudian membalik nilainya (dari true ke false atau false ke true). Berikut ini adalah tabel kebenaran operator NOT.

Operator Ternary (?:) Java memiliki operator berkondisi lain yang disebut ternary “?:”, yang pada dasarnya merupakan bentuk pendek dari if-then-else. Secara umum

kondisi ? jika_benar : jika_salah

Pada dasarnya operator “?:” akan mengevaluasi “kondisi”. Apabila kondisi bernilai “true”, operator akan mengembalikan “jika_benar”, tetapi apabila “kondisi” bernilai “false”, operator akan mengembalika “jika_salah”. Misalnya

x = (1 > 2) ? 10 : 20

Dari contoh di atas, “x” akan memiliki nilai 20, karena ekspresi (1 > 2) adalah salah (atau “false”).

public class OperatorKondisi {
	/**
	 * Contoh program menggunakan operator kondisi
	 *
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		int x = 5;
		int y = 10, angka = 0;
		boolean bl = true;
		if((x == 5) && (x < y))
			System.out.println("Nilai x adalah " + x);
		if((x == y) || (y > 1))
			System.out.println("Nilai y lebih besar dari x");
		angka = bl ? x : y;
		System.out.println("Angka yang keluar adalah " + angka);
	}
}

- Operator minus; menyatakan nilai negatif, dapat pula digunakan untuk menegatifkan suatu bilangan

++ Operator kenaikan; menambah suatu bilangan dengan 1

– Operator penurunan; mengurangkan suatu bilangan dengan 1

! Operator lawan; membalik nilai suatu boolean

Operator tunggal hanya membutuhkan satu operan untuk melakukan operasinya. Operator ini tidak dapat digunakan untuk variabel final, karena variabel final berupa konstanta yang tidak dapat diubah-ubah. Beberapa jenis operator tunggal diberikan pada tabel di bawah ini.

angka = +1;

angka = -1;
angka = -angka; // sekarang angka bernilai 1

angka = ++angka;

angka = --angka;

ok = !true;

Operator kenaikan dan penurunan dapat diletakkan di belakang atau di depan suatu variabel. Jika diletakkan di depan (++x atau –x), penambahan/pengurangan dilakukan sebelumnya, sedangkan apabila diletakkan di akhir (x++ atau x–) penambahan/pengurangan dilakukan setelahnya. Walau bagaimanapun pada akhirnya keduanya akan menghasilkan x = x+1 atau x = x-1.

Mari kita lihat contohnya untuk membedakan lebih jelas perbedaan penempatan operator tunggal ++ dan –

public class OperatorTunggal {
	/**
	 * Contoh program menggunakan operator tunggal
	 *
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		int x = 0;
		int y = 0;
		y = ++x;
		System.out.println("Contoh operator pada prefix (awalan)");
		System.out.println("---------------------------");
		System.out.println("Nilai x baru : " + x);
		System.out.println("Nilai y = ++x : " + y);
		x = 0;
		y = 0;
		y = x++;
		System.out.println("\nContoh operator pada sufix (akhiran)");
		System.out.println("---------------------------");
		System.out.println("Nilai x baru :" + x);
		System.out.println("Nilai y = x++ :" + y);
	}
}