Sabtu, 17 Desember 2011

CALL STACK, STACK TRACE, UNCAUGHT EXCEPTION

Call stack adalah urutan pemanggilan method pada aplikasi java. Awal pemanggilan method main, kemudian dalam method main ada pemanggilan ke method lain dan seterusnya hingga pemanggilan method bertumpuk, tumpukan - tumpukan pemanggilan method disebut call stack.

Uncaught exception menyebabkan sebuah method keluar dari eksekusinya untuk dilanjutkan ke method berikutnya sambil berharap bahwa ada kode untuk menangkap exception itu. Kalau dianalogikan dalam gedung uncaught exception adalah kejadian dimana sebuah lantai dalam gedung rubuh, runtuhan tersebut berharap ada yang menahan (menangkap) di lantai bawahnya, kalau tidak ada yang menangkap maka gedung akan kolaps, atau aplikasi akan berhenti bekerja.

Stack trace adalah rekaman jejak call stack ketika exception terjadi. Dengan adanya stack trace kita bisa menganalisis root cause (penyebab utama) terjadinya exception, selama root cause belum di ketahui, hanya dapat menebak - nebak apa yang terjadi dengan aplikasi tetapi tidak bisa  memastikan bagian mana yang bermasalah. Stack trace dengan gamblang akan menunjukkan root cause terjadinya exception, penting sekali melakukan log terhadap stack trace ini agar mempercepat pencarian kesalahan pada aplikasi.

public class StackTraceRootCause{
           public void methodPertama(){
                      System.out.println("method pertama dipanggil");
                       methodKedua();
           }
           public void methodKedua(){
                      System.out.println("method kedua dipanggil");
                       methodKetiga();

           }
           public void methodKetiga(){
                      System.out.println("method ketiga dipanggil");
                       methodKeempat();

           }
           public void methodKeempat(){
                      System.out.println("method keempat dipanggil");
                       methodKelima();

           }
           public void methodKelima(){
                      System.out.println("method kelima dipanggil");
                      String abc = null;
                      abc.toString(); // kode ini menyebabkan NullPointerException

           }           public static void main(String[] args){
                       StackTraceRootCause strc = new StackTraceRootCause();
                       strc.methodPertama();
                       System.out.println("Kode ini tidak akan dieksekusi karena program sudah keluar ketika exception di method ke lima tidak ditangkap ");
           }

}

6 methodKelima()
5 methodKeempat()
4 methodKetiga()
3 methodKedua()
2 methodPertama()
1 main()
-------------------------------------- CALL STACK

Awal method main kemudian memanggil method pertama sampai method kelima. Di dalam method ke lima terjadi exception yang tidak dapat ditangkap oleh method dibawahnya sehingga aplikasi keluar

method pertama dipanggil
method kedua dipanggil
method ketiga dipanggil
method keempat dipanggil
method kelima dipanggil
Exception in thread "main" java.lang.NullPointerException
    at StackTraceRootCause.methodKelima(StackTraceRootCause.java:41)
    at StackTraceRootCause.methodKeempat(StackTraceRootCause.java:31)
    at StackTraceRootCause.methodKetiga(StackTraceRootCause.java:23)
    at StackTraceRootCause.methodKedua(StackTraceRootCause.java:15)
    at StackTraceRootCause.methodPertama(StackTraceRootCause.java:7)
    at StackTraceRootCause.main(StackTraceRootCause.java:48)

Stack Trace adalah output yang dimulai dengan kalimat Exception in thread "main"..... hingga ke bawah. Dari output stack trace ini dapat dilihat dengan jelas apa jeni exception yang terjadi, dari awal mulai hingga di class apa dan di baris berapa kejadian exception itu.

SYNTAX EXCEPTION

keyword yang dipakai dalam exception handling adalah try, catch, finally, throw, throws.

Konsep penggunaan syntax try, catch

try{
          // di sini adalah baris yang dilindungi oleh try
          // letakkan kode yang potensial mengalami exception di sini
}catch(ClassException variableException){
          // kalau terjadi exception lakukan sesuatu
          // setidaknya lakukan logging
          // blok catch yang kosong bisa disebut sebagai kode konyol dan mengerikan
          // pastikan ada kode untuk memberi keterangan tentang exception apa yang terjdi
}catch(ExceptionLain variableException){
          // sama
}

kode didalam try adalah kode yang melempar excepton (throw) kalau kode didalamnya berjalan normal dan tidak ada exception yang terjadi, eksekusi akan sampai ke baris terakhir, kalau ada exception dengan tipe ClassException maka eksekusi akan lompat pada blok catch pertama, kalau ada exception dengan tipe exception lagi maka eksekusi akan loncat ke dalam blok catch kedua.

Struktur kode membaca file dalam hardisk
try{
            bukaFileDalamHardisk
            bacaFileBarisPerBaris
            tampilkanIsiFileKeConsole
}catch(IOException ioe){
            tampilakanErrorDiLogDanDiConsole
}

kalau kode bukaFileDalamHardisk gagal maka eksekusi langsung loncat ke catch, kode bacaFileBarisPerBaris dan tampilkanIsiFileKeConsole tidak akan dieksekusi dengan begitu aplikasi tetap bisa berjalan dan tidak langsung keluar.

try-catch-finally, penambahan blok kode finally. kalau kode di dalam try menimbulkan exception maka kode akan loncat ke dalam blok kode catch, sedangkan blok kode finally akan selalu dieksekusi baik terjadi eksekusi di try maupun tidak. Kode didalam finally biasanya adalah kode yang digunakan untuk melepas resource, membersihkan variable yang sudah tidak terpakai lagi, bisa dibilang kode finally itu digunakan untuk bersih bersih aplikasi agar tidak menggunakan resource yang sudah tidak diperlukan lagi.

try{
        // kode yang ada exceptionnya
}catch(ExceptionPertama ex){
       // handle exception dengan tipe exception pertama
}catch(ExceptionKedua ex){
      // handle exception dengan tipe exception kedua
}finally{
      // bersihkan resource yang terpakai, baik terjadi exception atau tidak
}

try bisa langsung diikuti dengan finally tanpa catch, pada konsep uncaught exception atau exception yang tidak tertangkap yang pada akhirnya menyebabkan aplikasi berhenti berjalan.

EXCEPTION

exception adalah feature yang tidak perlu lagi mengetest hasil dari suatu fungsi untuk mengetahui apakah ada yang error atau tidak, dengan begitu pengecekan kesalahan bisa lebih jelas dan elegan

Jumat, 16 Desember 2011

SWITCH

Switch digunakan kalau ingin mengevaluasi nilai dari sebuah variable yang mempunyai banyak kemungkinan, bisa digunakan kalau variablenya bertipe angka atau enum.

syntax dasar
int x  = 10;
switch ( x ){
          case 1 :
          System.out.println ("satu");
          breakl;
          case 2 :
          System.out.println ("dua");
          default :
          System.out.println ("bukan satu atau dua");
}

dalam switch ada efek fall-through yang akan mengeksekusi case berikutnya. sebab itu ada keyword break untuk menghentikan efek fall-through.

public class FallThrough{
          public static void main (String[] args){
                        int x = 1;
                        switch(x){
                                      case 1 :
                                               System.out.println("satu");
                                      case 2 :  
                                               System.out.println("fall-through dua");
                                      case 3 :  
                                               System.out.println("fall-through tiga");
                                      case 4 :  
                                               System.out.println("fall-through empat");
                                      default :  
                                               System.out.println("fall-through default");

                        }
          }
}

Hasil

satu
fall-through dua
fall-through tiga
fall-through empat
fall-through default


semua kode dalam case akan dieksekusi hingga ketemu keyword break atau blok kode switch berakhir.

public class FallThrough{
          public static void main (String[] args){
                        int x = 1;
                        switch(x){
                                      case 1 :
                                               System.out.println("satu");
                                               break; // stop fall-through dan keluar dari case
                                      case 2 :  
                                               System.out.println("fall-through dua");
                                      case 3 :  
                                               System.out.println("fall-through tiga");
                                      case 4 :  
                                               System.out.println("fall-through empat");
                                      default :  
                                               System.out.println("fall-through default");


                        }

          }

}

Hasil

satu

IF

Statement if digunakan dalam aplikasi untuk mengatur aliran eksekusi program berdasarkan kondisi tertentu.

Syntax dasar :
int x = 10;
if ( x == 10 ) {
     System.out.println("Lakukan sesuatu disini kalau kondisi di dalam if bernilai true");
}

Statemen if dapat digabungkan dengan else, kode di dalam else akan dieksekusi kalau kondisi didalam if bernilai false.
int x  = 11;
if ( x == 10 ) {
       System.out.println ("Lakukan sesuatu disini kalau kondisi di dalam if bernilai true");
} else {
             System.out.println ("Lakukan sesuatu disini kalau kondisi di dalam if bernilai false");
}

ada juga statement else if untuk beberapa pernyataan
int nilai  = 78;
if ( nilai >= 0 && nilai < 40 ) {
   System.out.println ("nilai < 40 = D");
} else if ( nilai >= 40 && nilai < 60 ) {
    System.out.println ("nilai >= 40 && nilai < 60 = C");
} else if ( nilai >=60 && nilai < 80 ) {
    System.out.println ("nilai >= 60 && nilai < 80 = B");
} else if ( nilai >=80 && nilai <=100 ) {
     System.out.println ("nilai >= 80 && nilai <= 100 = A");
} else {
      System.out.println ("range nilai harus 0 - 100");
}

Tanda kurung tidak diperlukan jika blok kode yang dieksekusi dalam if hanya satu.
int x = 0
if( x >= 10)
       System.out.println ("nilai positif");

jika dalam blok kode lebih dari satu maka akan diabaikan oleh if
int x = 0
if( x >= 10)
       System.out.println ("nilai positif");
       System.out.println("selalu dieksekusi. Bukan bagian dari blok kode if");

kalau kode di eksekusi, println yang kedua akan selalu di eksekusi karena bukan bagian dari if

FLOW CONTROL

Kontrol terhadap aliran eksekusi aplikasi adalah salah satu feature utama dari sebuah bahasa pemprograman. if dan switch, selain itu juga ada mekanisme exception yang dapat mempengaruhi aliran eksekusi program

OPERATOR LOGIKA

Ada enam operator logika dalam java
& operator dan, dapat juga menjadi operator bitwise jika operandnya berupa angka
| operator or, dapat juga menjadi operator bitwise jika operandnya berupa angka
 ^ operator xor, dapat juga menjadi operator bitwise jika operandnya berupa angka
! operator logika negasi
&& operator singkatan dan
|| operator singkatan or

operator & dan jika operandnya bertipe boolean akan menghasilkan nilai true kalau kedua nilainya true, selainnya menghasilkan false.

int x = 10
int y = 11
boolean z = (x < 10 ) & ( y < 100 )

z menghasilkan nilai false karena operand sebelah kiri (x < 10 ) menghasilkan false dan operand sebelah kanan ( y < 100 ) menghasilkan true, sehingga nilai z adalah false. Operand sebelah kanannya tetap dilihat walaupun operand sebelah kirinya nilainya false.

Berbeda dengan operator &&, jika operand sebelah kirinya menghasilkan nilai false maka tidak melihat operand yang ada di sebelah kanannya ( diabaikan ). Operator ini penting untuk memastikan bahwa nilai suatu variable object tidak bernilai null sebelum memanggil method dari object tersebut.

public class LogicalOperator{
          public static void main(String[] args){
                     String nama = null;
                     boolean z = (nama != null) & (nama.equals("saya"));
                     System.out.println(z);
          }
}

akan menghasilkan null pointer exception, walaupun hasil operand sebelah kiri false, operand sebelah kanan tetap dijalankan . ganti operator & dengan operator &&

public class LogicalOperator{
           public static void main(String[] args){
                      String nama = null;
                      boolean z = (nama != null) && (nama.equals("saya"));
                      System.out.println(z);
           }
}

Operator | pada angka akan menjadi operator bitwise, sedangkan pada variable boolean akan menghasilkan true jika salah satu atau kedua operand bernilai true. jika operand yang disebelah kiri bernilai true, maka operand yang ada dikanannya tetap dilihat. berbeda dengan operator || jika operand yang disebelah kiri bernilai true, maka tidak melihat operand yang ada dikanan.

Operator ^ xor akan menghasilkan nilai true jika nilai operand yang ada di sebelah kiri berbeda dengan nilai operand yang ada di sebelah kanan. jika nilai kedua operand sama maka akan menghasilkan nilai false.

int x = 10;
int y = 11;
boolean z = ( x > 10 ) ^ ( y < 100 )

variable z akan bernilai true karena ( x > 10 ) menghasilkan false ( y < 100 ) menghasilkan true, jika nilai operand yang disebelah kiri berbeda nilainya dengan operand yang ada disebelah kanan maka menghasilkan nilai true.

operator ! disebut inversi atau negasi akan membalikkan nilai true menjadi false, false menjadi true

int x = 10
int y = 11
boolean z = !( ( x > 10) ^ ( y < 100 ) )

variable z akan bernilai false