4. Statemen Kendali

Bahasa pemrograman menggunakan statemen kendali untuk memengaruhi (maju atau bercabang) aliran eksekusi berdasarkan perubahan keadaan dari sebuah program. Statemen kendali program dalam Java dapat dikategorikan menjadi: seleksi, iterasi, dan lompatan: Statemen seleksi membuat program Anda memilih jalur eksekusi berbeda yang didasarkan pada keluaran dari ekspresi atau keadaan dari sebuah variabel. Statemen iterasi memampukan eksekusi program diterapkan berulang terhadap satu atau lebih eksekusi. Statemen lompatan dapat membuat program Anda untuk dieksekusi dengan cara tak-linier.

Statemen Seleksi Java

Java mendukung dua statemen seleksi: if dan switch. Kedua statemen ini dapat Anda pakai untuk mengendalikan aliran eksekusi program yang didasarkan pada kondisi-kondisi selama waktu program dijalankan. 

Statemen if

Statemen if telah dikenalkan pada Bab 1, yang merupakan statemen percabangan kondisional dalam Java. Statemen ini dapat dipakai untuk memilih salah satu dari dua jalur eksekusi program. Berikut adalah bentuk umum dari statemen if:

if (kondisi) statemen1;
else statemen2;

Di sini, setiap statemen dapat berupa satu statemen atau statemen gabungan yang diapit dengan kurung kurawal (blok kode). Komponen kondisi dapat berupa sembarang ekspresi yang menghasilkan nilai balik berupa nilai boolean. Klausa else bersifat opsional.

Statemen if bekerja seperti ini: Jika kondisi bernilai true, maka statemen1 akan dieksekusi. Sebaliknya, statemen2 (jika ada) yang akan dieksekusi. Sebagai contoh,

int a, b;
//…
if(a < b) a = 0;
else b = 0

Di sini, jika a bernilai kurang dari b, maka a ditetapkan menjadi 0. Sebaliknya, b ditetapkan menjadi 0.

Pada banyak kasus, ekspresi yang dipakai untuk mengendalikan if melibatkan operator-operator relasional. Namun, ini bukanlah keharusan. Adalah dimungkinkan untuk mengendalikan if menggunakan sebuah variabel boolean, seperti ditunjukkan pada fragmen kode berikut:

boolean dataTersedia;
//...
if (dataTersedia)
   ProsesData();
else
   tungguDataLain();

Ingat, hanya ada satu statemen yang dapat ditempatkan setelah if atau else. Jika Anda menginginkan lebih dari satu statemen, Anda perlu menciptakan blok kode, seperti pada fragmen kode ini:

int byteTersedia;
// ...
if (byteTersedia > 0) {
   ProsesData();
   byteTersedia -= n;
} else
   tungguDataLain();

Di sini, kedua statemen di dalam blok if akan dieksekusi jika byteTersedia lebih besar dari nol.

Sejumlah programer merasa lebih nyaman untuk mencantumkan kurung kurawal ketika menggunakan if, bahkan ketika hanya ada satu statemen pada tiap klausa. Ini mempermudah dalam menambahkan statemen lain nanti di waktu kemudian, dan Anda tidak perlu khawatir tentang kelupaan menambahkan kurung kurawal. Pada faktanya, lupa menambahkan blok ketika diperlukan bisa menyebabkan error. Sebagai contoh, perhatikan fragmen kode berikut:

int byteTersedia;
// ...
if (byteTersedia > 0) {
   ProsesData();
   byteTersedia -= n;
} else
   tungguDataLain();
   byteTersedia = n;

Tampak jelas bahwa statemen byteTersedia = n; dimaksudkan untuk dieksekusi di dalam klausa else, karena level indentasi (penyejajaran) pada kode. Namun, seperti yang Anda pasti ingat, spasi putih diabaikan dalam Java, dan tidak ada cara lain bagi kompilator untuk mengetahui apa yang dimaksudkan programer. Kode ini akan tetap bisa dikompilasi tanpa ada error, tetapi hasilnya tidak sesuai dengan yang diinginkan. Fragmen kode tersebut dapat diperbaiki seperti berikut:

int byteTersedia;
// ...
if (byteTersedia > 0) {
   ProsesData();
   byteTersedia -= n;
} else {
   tungguDataLain();
   byteTersedia = n;
}

Statemen if Bersarang
Statemen if bersarang ditempatkan ke dalam klausa if atau else lain. Statemen if bersarang sangat banyak dijumpai pada kasus pemrograman. Ketika Anda menyarangkan if, hal utama yang diingat adalah bahwa statemen else selalu terikat dengan statemen if terdekat yang berada di dalam blok kode yang sama dengan klausa else. Berikut adalah sebuah contoh statemen if bersarang:

if(i == 10) {
   if(j < 20) a = b;
   if(k > 100) c = d; // statemen if ini
   else a = c; // terikat dengan else ini
}
else a = d; // klausa else ini terikat dengan if(i == 10)

Seperti yang dijelaskan pada komentar, else akhir tidak terikat dengan klausa if(j<20) karena tidak berada pada blok yang sama. Klausa else akhir terikat dengan if(i==10). Klausa else sebelah dalam terikat dengan if(k>100) karena ia merupakan if terdekat pada blok kode yang sama.


Statemen if-else-if Bertangga
Konstruksi pemrograman yang umum dijumpai yang didasarkan pada runtun bersarang if adalah if-else-if bertangga, seperti berikut:

if(kondisi)
   statemen;
else if(kondisi)
   statemen;
else if(kondisi)
   statemen;
.
.
.
else
   statemen;

Statemen-statemen if dieksekusi dari atas ke bawah. Jika salah satu kondisi yang mengendalikan if bernilai true, maka statemen yang berkaitan dengan if tersebut akan dieksekusi, dan sisa tangga akan dilewati. Jika tidak ada kondisi yang bernilai true, maka klausa else akhiri akan dieksekusi. Klausa else akhir berperan sebagai kondisi default; jadi, jika semua kondisi gagal atau tidak bernilai true, maka statemen else akhir yang dieksekusi. Jika tidak ada klausa else akhir dan semua kondisi bernilai false, maka tidak ada apapun yang dieksekusi.

Berikut adalah sebuah program yang menggunakan if-else-if bertangga untuk menentukan musim apa yang sedang berlangsung:

//Mendemonstrasikan statemen if-else-if
public class IfElse {
   public static void main(String args[]) {
      int bulan = 4; // April
      String musim;
  
      if(bulan == 12 || bulan == 1 || bulan == 2)
         musim = "Musim Dingin";
      else if(bulan == 3 || bulan == 4 || bulan == 5)
         musim = "Musim Semi";
      else if(bulan == 6 || bulan == 7 || bulan == 8)
         musim = "Musim Panas";
      else if(bulan == 9 || bulan == 10 || bulan == 11)
         musim = "Musim Gugur";
      else
         musim = "Bulan Palsu";
   
      System.out.println("April merupakan  " + musim + ".");
   }
}

Berikut adalah keluaran dari program di atas:

April merupakan  Musim Semi.

Statemen switch
Statemen switch adalah statemen bercabang banyak dalam Java. Statemen ini menawarkan cara mudah dalam mengubah aliran eksekusi ke sejumlah jalur eksekusi sesuai dengan nilai dari sebuah ekspresi. Berikut adalah bentuk umum dari statemen switch:

switch (ekspresi) {
   case nilai1:
      // runtun statemen
      break;
   case nilai2:
      // runtun statemen
      break;
   ...

   case nilaiN :
      // runtun statemen
      break;
   default:
      // runtun statemen default
}

Untuk versi Java sebelum JDK 7, ekspresi harus bertipe data byte, short, int, char, atau sebuah enumerasi. Mulai dari JDK 7, ekspresi dapat berupa String. Setiap nilai yang ditetapkan pada statemen case harus merupakan sebuah ekspresi konstanta yang unik (seperti nilai literal). Nilai case duplikat tidak diijinkan. Tipe data dari tiap nilai harus kompatibel dengan tipe data dari ekspresi.

Statemen switch bekerja seperti ini: Nilai dari ekspresi dibandingkan dengan tiap nilai pada statemen case. Jika kecocokan ditemukan, maka runtun kode yang ada setelah statemen case tersebut akan dieksekusi. Jika tidak ada kecocokan, maka statemen default yang dieksekusi. Namun, statemen default bersifat opsional. Jika tidak ada case yang cocok dan statemen default tidak disediakan, maka tidak ada apapun yang dieksekusi.

Statemen break dipakai di dalam switch untuk menghentikan sebuah runtun statemen. Ketika sebuah statemen break dijumpai, maka aliran eksekusi akan melompat ke baris kode pertama yang ada setelah statemen switch. Ini merupakan tindakan untuk keluar dari switch.

Berikut adalah sebuah contoh sederhana yang menggunakan statemen switch:

//Sebuah contoh switch sederhana
public class SwitchSederhana {
   public static void main(String args[]) {
      for(int i=0; i<6; i++)
         switch(i) {
            case 0:
               System.out.println("i bernilai nolo.");
               break;
            case 1:
               System.out.println("i bernilai satu.");
               break;
            case 2:
               System.out.println("i bernilai dua.");
               break;
            case 3:
               System.out.println("i bernilai tiga.");
               break;
            default:
               System.out.println("i bernilai lebih besar dari 3.");
         }
   }
}

Keluaran yang dihasilkan program ini ditampilkan berikut:

i bernilai satu.
i bernilai dua.
i bernilai tiga.
i bernilai lebih besar dari 3.
i bernilai lebih besar dari 3.

Seperti yang dapat Anda lihat, setiap kali loop beriterasi, statemen-statemen yang berkaitan dengan konstanta case yang cocok dengan i akan dieksekusi. Semua yang lain akan diabaikan. Setelah i bernilai lebih besar dari 3, maka tidak ada statemen case yang cocok dengan nilai itu, jadi statemen default yang dieksekusi.

Statemen break bersifat opsional. Anda tidak harus menambahkannya. Jika Anda mengabaikan break, eksekusi akan dilanjutkan ke statemen case berikutnya. Kadangkala Anda bisa jadi ingin memiliki sejumlah case tanpa statemen break. Sebagai contoh, perhatikan program berikut:

//Pada switch, statemen break opsional
public class BreakTidakAda {
   public static void main(String args[]) {
      for(int i=0; i<12; i++)
         switch(i) {
            case 0:
            case 1:
            case 2:
            case 3:
            case 4:
               System.out.println("i kurang dari 5");
               break;
            case 5:
            case 6:
            case 7:
            case 8:
            case 9:
               System.out.println("i kurang dari 10");
               break;
            default:
               System.out.println("i bernilai 10 atau lebih");
         }
   }
}

Keluaran yang dihasilkan program ini ditampilkan berikut:

i kurang dari 5
i kurang dari 5
i kurang dari 5
i kurang dari 5
i kurang dari 5
i kurang dari 10
i kurang dari 10
i kurang dari 10
i kurang dari 10
i kurang dari 10
i bernilai 10 atau lebih
i bernilai 10 atau lebih

Seperti yang dapat Anda lihat, eksekusi akan melewati semua case sampai statemen break dijumpai (atau sampai akhir dari switch). Hal ini membuktikan pengabaian break memiliki banyak aplikasi pada program di dunia nyata. Berikut diberikan program contoh lain dimana pengabaian break bisa menjadi solusi:

//Versi terperbaiki dari program musim
public class SwitchEfisien {
   public static void main(String args[]) {
      int bulan = 4;
      String musim;
  
      switch (bulan) {
         case 12:
         case 1:
         case 2:
            musim = "Musim Dingin";
            break;
         case 3:
         case 4:
         case 5:
            musim = "Musim Semi";
            break;
         case 6:
         case 7:
         case 8:
            musim = "Musim Panas";
            break;
         case 9:
         case 10:
         case 11:
            musim = "Musim Gugur";
            break;
         default:
            musim = "Bulan Palsu";
      }
      
      System.out.println("April adalah " + musim + ".");
   }
}

Seperti disebutkan sebelumnya, dimulai dari JDK 7, Anda bisa menggunakan sebuah string untuk mengendalikan statemen switch. Sebagai contoh,

//Menggunakan string untuk mengendalikan switch
public class SwitchString {
   public static void main(String args[]) {
      String str = "dua";
  
      switch(str) {
         case "satu":
            System.out.println("satu");
            break;
         case "dua":
            System.out.println("dua");
            break;
         case "tiga":
            System.out.println("tiga");
            break;
         default:
            System.out.println("tidak ada yang cocok");
            break;
      }
   }
}

Seperti yang Anda duga, keluaran dari program ini adalah:

dua

String yang dimuat pada str (yaitu “dua” pada program ini) diuji terhadap konstanta-konstanta case. Ketika kecocokan ditemukan (seperti pada case kedua), maka runtun kode yang berkaitan dengan case tersebut akan dieksekusi.


Statemen switch Bersarang
Anda dapat menggunakan sebuah statemen switch sebagai bagian dari runtun statemen dari sebuah switch sebelah luar. Ini dinamakan dengan switch bersarang. Karena sebuah statemen switch mendefinisikan blok kodenya sendiri, maka tidak akan ada konflik antara konstanta-konstanta case pada switch sebelah dalam dan pada switch sebelah luar. Sebagai contoh, fragmen kode berikut adalah valid:

switch(cacah) {
   case 1:
      switch(target) { // switch bersarang
         case 0:
            System.out.println("target nol");
            break;
         case 1: // tidak ada konflik dengan switch sebelah luar
            System.out.println("target satu");
            break;
      }
      break;
case 2: // ...

Di sini, statemen case 1: pada switch sebelah dalam tidak berkonflik dengan statemen case 1: pada switch sebelah luar. Variabel cacah hanya dibandingkan dengan sejumlah case pada switch sebelah luar. Jika cacah bernilai 1, maka target akan dibandingkan dengan sejumlah case pada switch sebelah dalam.

Selanjutnya  >>>