Program Hatalarını Çözümleme

Transkript

1 Program Hatalarını Çözümleme (Exceptퟎ ons handlퟎ ng) Programlamanın altın bퟎ r kuralı vardır. Program, ya doğru sonuçlar vermelퟎ ya da hퟎ çbퟎ r sonuç vermemelퟎ. Çünkü yanlış sonuçlar, cퟎ ddퟎ sorunlar yaratabퟎ lퟎ r. Program hatalarını üç gruba ayırabퟎ lퟎ rퟎ z. Sözdᾂzᾂmᾂ yanlışları (syntax errors) Bunlar programcının canını sıkabퟎ lퟎ rler, ama başkalarına zarar veremezler, çünkü derlenemezler, koşturulamazlar. Dolayısıyla yanlış sonuç vermelerퟎ olanaksızdır. Bu gruptakퟎ ler tehlퟎ kesퟎ z yanlışlardır. Mantıksal yanlışlar (logᾂcal errors) Programın sözdퟎ zퟎ mퟎ doğrudur,derlenebퟎ lퟎ r, koşturulabퟎ lퟎ r. Ama yapılmak ퟎ stenen ퟎ şler ퟎ çퟎ n kullanılan deyퟎ mler yanlıştır. Yanlış ퟎ şlemler, yanlış hesaplar yapar. Programın denenme aşamasında bu tür yanlışlar ortaya çıkmazsa, programın kullanılması cퟎ ddퟎ sorunlar yaratabퟎ lퟎ r. Örneğퟎ n, bퟎ r bankada hesaplar arasında para akışını kaydeden bퟎ r program modülünün eksퟎ k veya fazla toplama yaptığını düşününüz. Kısa zamanda, üstesퟎ nden gelퟎ nmesퟎ zor sorunlar yaratır. Bu tür yanlışlar, programcılıkta en tehlퟎ kelퟎ sayılan yanlışlardır. Koşma zamanı yanlışları (run tᾂme errors) Program sözdퟎ zퟎ mퟎ ya da mantıksal yanlış ퟎ çermퟎ yor, ama bazı nedenlerle koşamıyor olabퟎ lퟎ r. Örneğퟎ n, gereklퟎ verퟎ lerퟎ bퟎ r gퟎ rퟎ ş bퟎ rퟎ mퟎ nden okuyamaması, yada verퟎ lerퟎ bퟎ r çıkış bퟎ rퟎ mퟎ ne gönderememesퟎ, ퟎ şlemlerde sıfıra bölme gퟎ bퟎ olanaksız bퟎ r durumla karşılaşması, vb. Bퟎ z bu bölümde, üçüncü tür yanlışlarla, yanퟎ koşma sırasında oluşan yanlışlarla ퟎ lgퟎ leneceğퟎ z. Teknퟎ k ퟎ fadesퟎ yle söylersek, program yazılırken bퟎ lퟎ nemeyecek, ama program koşarken oluşabퟎ lecek ퟎ stퟎ snaퟎ (exceptퟎ ons) hallerퟎ konu edퟎ neceğퟎ z. Koşma sırasında beklenmedퟎ k bퟎ r hata ퟎ le karşılaştığında, kaynak program başka bퟎ r önlem koymamışsa, sퟎ stem program akışını durdurur. Bu durum bazen zararlı sonuçlar da yaratabퟎ lퟎ r. Örneğퟎ n, bퟎ r I/O ퟎ şlemퟎ nde, gereklퟎ verퟎ dönüşümünün bퟎ r nedenle yapılamaması ퟎ stퟎ snaퟎ bퟎ r haldퟎ r ve bu noktadan sonra programın koşması anퟎ den durmak zorundadır. Ama, programın koşması durunca, verퟎ alış verퟎ şퟎ yaptığı dosyaları kapatamaz. Böylece o dosyalarda verퟎ kaybına yol açabퟎ lퟎ r. Programlamanın ퟎ lk yıllarında, bu tür yanlışların üstesퟎ nden gelebퟎ lmek ퟎ çퟎ n haylퟎ zorluk çekퟎ lퟎ rdퟎ. Java, koşma sırasında oluşan bퟎ r çok yanlışı kendퟎ lퟎ ğퟎ nden belퟎ rler, durumu kullanıcıya bퟎ ldퟎ rퟎ r ve programı kapatıp ퟎ şletퟎ m sퟎ stemퟎ ne döner. Buna ek olarak, bu tür yanlışlar oluştuğunda, programcı ne yapmak ퟎ stퟎ yorsa, onu yapmasını sağlayan araçlara da sahퟎ ptퟎ r. Bu bölümde, bu araçların nasıl kullanıldığını göreceğퟎ z. Java nesne yönelퟎ mlퟎ bퟎ r programlama dퟎ lퟎ olduğuna göre, ퟎ stퟎ snaퟎ hallerퟎ bퟎ r sınıf olarak düşünmüş olması doğaldır. Java.lang paketퟎ ퟎ çퟎ nde Throwable sınıfı bu ퟎ ş ퟎ çퟎ n yaratılmıştır. Throwable sınıfı, karşılaşılabퟎ lecek bütün ퟎ stퟎ snaퟎ hallerퟎ ortaya koyabퟎ lecek zengퟎ nlퟎ ktedퟎ r. Çok sayıda alt sınıflara ve metotlara sahퟎ ptퟎ r. Throwable sınıfı, önce ퟎ kퟎ büyük alt sınıfa ayrılır: Exceptions ve Error. Programın yakalamasını ퟎ stedퟎ ğퟎ mퟎ z ퟎ stퟎ snaퟎ hallerퟎ, Exceptions sınıfının alt sınıfları ve onlar ퟎ çퟎ ndekퟎ metotlarla hallederퟎ z. Ayrıca, programcı, kendퟎ sퟎ ne gereklퟎ olan sınıfları da buradan türetebퟎ lퟎ r. Throwable sınıfının 60 dan çok dퟎ rek alt sınıfı vardır ve her bퟎ r alt sınıfın da başka alt sınıfları, constructor ları ve metotları vardır. Örneğퟎ n, çok kullanacağımız alt sınıflardan bퟎ rퟎ sퟎ RunTimeExceptionsınıfı ퟎ le onun alt sınıfı ArithmeticExceptionolan sınıfıdır. Error sınıfı ퟎ se, normal koşullarda programın yakalayamayacağı hataları sퟎ stemퟎ n yakalaması ퟎ çퟎ ndퟎ r. Örneğퟎ n stack overflow gퟎ bퟎ ퟎ stퟎ snalardır. Bu gruba gퟎ ren hataları, normal koşullarda, program ퟎ çퟎ nde çözümleme olanağı yoktur. Bunlar, programdan çok, sퟎ stemle ퟎ lgퟎ lퟎ ퟎ stퟎ snalardır. Çoğunlukla, programın koşmasının durmasıyla sonuçlanır. Dolayısıyla, bu bölümde o tür ퟎ stퟎ snaları gퟎ dermeye uğraşmayacağız. Yukarıda sözü geçen sınıfların hퟎ yerarşퟎ k yapıları şöyledퟎ r: java.lang.object java.lang.throwable java.lang.object java.lang.throwable java.lang.error java.lang.object java.lang.throwable java.lang.exception java.lang.runtimeexception java.lang.arithmeticexception Hata yakalanmazsa 1/11

2 Program koşarken oluşabퟎ lecek hataları yakalamanın ne kadar önemlퟎ olduğunu anlamak ퟎ çퟎ n aşağıdakퟎ basퟎ t örneğퟎ verelퟎ m. class Hata01 { int payda = 0; int pay = 38/payda ; Bu programı koşturduğumuzda, sıfıra bölme (dᾂvᾂde by zero) ퟎ şlemퟎ yle karşılaşır. Matematퟎ ksel olarak bu ퟎ şlem olanaksızdır. Bu durumda, java run tퟎ me sퟎ stemퟎ, programın koşmasını keser ve kullanıcıya aşağıdakퟎ mesajı verퟎ r. Bu mesaj şunları söylüyor. Yakalanan hata, Exceptions sınıfının ArithmeticException adlı alt sınıfı ퟎ le belퟎ rlenen hatadır. Bu hatanın açıklaması olarak yazılan ( / by zero) kısa mesajı, divide by zero (sıfıra bölme) hatası yakalandı anlamındadır. Hata01.main(Hata01.java:4 dퟎ zퟎ sퟎ ퟎ se, Hata01, main, Hata01.java, 4 verퟎ lerퟎ nퟎ n programı yöneten stack tan, yazıldığı sıra ퟎ le alındığını gösterퟎ r. Exception in thread "main" java.lang.arithmeticexception: / by zero at Hata01.main(Hata01.java:4) Şimdi, aynı programı, bir metot kullanarak yeniden kodlayalım. class Hata02 { static void kesir() { int d = 0; int a = 10 / d; Hata02.kesir(); Bu kez de aynı hata oluşacak, programın koşması kesퟎ lecek ve aşağıdakퟎ mesaj gelecektퟎ r. Bu mesaj, yukarıdakퟎ mesajın anlamını taşır. Ancak, programın yapısı farklı olduğundan, yönetퟎ cퟎ stack tan çıkanlar farklıdır: Exception in thread "main" java.lang.arithmeticexception: / by zero at Hata02.subroutine(Hata02.java:4) at Exc1.main(Exc1.java:7) Bu mesajı şöyle yorumlayacağız. 7 ퟎ ncퟎ satırda main ퟎ n çağırdığı kesir() metodunun 4 üncü satırında ArithmeticException sınıfının belퟎ rledퟎ ğퟎ divide by zero hatası yakalanmıştır. Yönetퟎ cퟎ stack ın bu bퟎ çퟎ mde hataları lퟎ stelemesퟎ, programın düzeltퟎ lebퟎ lmesퟎ (debug) ퟎ çퟎ n çok yararlıdır. Çünkü hatanın nerede oluştuğunu görmemퟎ zퟎ sağlar. Hata yakalama Java da koşma zamanı oluşan hatalara exceptퟎ ons (ퟎ stퟎ snaퟎ haller) denퟎ r. İstퟎ snaퟎ haller beş anahtar sözcükle ퟎ şlenퟎ r: try catch throw throws finally Şퟎ mdퟎ bunların nasıl kullanıldığını açıklayacağız. try/catch Öncekퟎ ퟎ kퟎ programda gördüğümüz gퟎ bퟎ, java run tퟎ me sퟎ stemퟎ nퟎ n, koşturma anında oluşan hatayı yakalayıp, koşmayı kesmesퟎ ve hatayı belퟎ rten bퟎ r mesaj vermesퟎ, kuşkusuz çok yararlıdır. Bunu görünce, kaynak programımıza dönüp, oluşan hataları gퟎ derecek düzeltmelerퟎ (debug) programda yapmamız kolaylaşır. Ama, çoğunlıkla, program koşarken oluşabퟎ lecek hataları, programın koşmasını kesmeden gퟎ derme olanağı olabퟎ lퟎ r. Java, Throwable sınıfını bunun ퟎ çퟎ n yaratmıştır. İstퟎ snaퟎ hallerퟎ çözümlemek ퟎ çퟎ n, java try/catch bloklarını kullanır. Şퟎ mdퟎ, örneklerle bu ퟎ şퟎ n nasıl yapıldığını açıklayacağız. Programda, ퟎ stퟎ snaퟎ hallerퟎ n (exceptퟎ ons) oluşabퟎ leceğퟎ yerler try{ bloku ퟎ çퟎ ne alınır. Bu blokta bퟎ r hata oluşursa, sퟎ stem o hatayı ortaya atar (throw). Hatanın ortaya atılması demek, hatayı temsퟎ l eden bퟎ r nesnenퟎ n yaratılması demektퟎ r. Bu nesne, Throwable sınıfının alt sınıflarından 2/11

3 bퟎ rퟎ sퟎ ne aퟎ ttퟎ r. Hangퟎ alt sınıfa aퟎ t olacağı konusu, oluşan hataya bağlıdır. Nesne, oluşan hata ퟎ le ퟎ lgퟎ lퟎ bütün ayrıntılara sahퟎ ptퟎ r. catch{ bloku atılan hatayı (yaratılan nesneyퟎ ) yakalar, hatanın ne olduğunu belퟎ rlemeye çalışır ve gereklퟎ önlemlerퟎ alır. Hata gퟎ derퟎ lemeyecek türden ퟎ se, program kapatılır ve kullanıcıya açıklama gönderퟎ lퟎ r. Her durumda, program akışının durmasıyla sퟎ stemퟎ n kퟎ tlenmesퟎ ve dퟎ ğer kaynakların zarar görmesퟎ kesퟎ nlퟎ kle önlenebퟎ lퟎ r. Eğer, programcı, yakalanan hata ퟎ çퟎ n bퟎ r çözüm öngörmüyorsa, java run tퟎ me sퟎ stemퟎ nퟎ n öngördüğü ퟎ şlemler default olarak etkퟎ n olacaktır. Java run tퟎ me sퟎ stemퟎ, ퟎ stퟎ snaퟎ hal oluştuğunda, sퟎ stem kaynaklarına zarar vermeden program akışını durdurur ve oluşan ퟎ stퟎ snaퟎ durum hakkında kullanıcıya bퟎ r açıklama gönderퟎ r. Try/catch bloklarının sözdퟎ zퟎ mퟎ şöyledퟎ r: // istisna yaratıp yaratmadığı denenecek kodlar catch(exceptiontype1 e1){ // ExceptionType1 için yapılacak işler catch(exceptiontype2 e2){ // ExceptionType2 için yapılacak işler catch(exceptiontypen en){ // ExceptionTypeN için yapılacak işler finally{ // blok bitmeden yapılması istenen işler try blokunda atılan hatayı catch bloku yakalar ve onun hangퟎ tퟎ p olduğunu belퟎ rlemeye çalışır. Önce, hatanın ExceptionType1 tퟎ pퟎ nden olup olmadığına bakar. O tퟎ pten ퟎ se, ퟎ stenen önlemlerퟎ alacak kodları çalıştırır. Değퟎ lse, hatayı kendퟎ sퟎ nden sonra gelen catch blokuna yollar. Bu süreç hata tퟎ pퟎ belퟎ rlenene kadar arka arkaya devam eder. Eğer, hퟎ çbퟎ r catch bloku hata ퟎ le uyuşmazsa, finally bloku gerekenퟎ yapar. catch{ bloku bퟎ r tek olabퟎ leceğퟎ gퟎ bퟎ, programcının ퟎ stedퟎ ğퟎ sayıda olabퟎ lퟎ r. Bu blok ퟎ çퟎ nde uygun java deyퟎ mlerퟎ yer alır. ExceptinType javada Throwable sınıfının herhangퟎ bퟎ r altsınıfı olabퟎ leceğퟎ gퟎ bퟎ, programcının türettퟎ ğퟎ bퟎ r sınıf da olabퟎ lퟎ r. Aşağıdakퟎ program, öncekퟎ ퟎ kퟎ programın yaptığı ퟎ şퟎ yapar. Hata oluşabퟎ lecek kodlar try{ bloku ퟎ çퟎ ne alınmıştır. Bu blokta bퟎ r arퟎ tmetퟎ k ퟎ şlem yapılmaktadır. Oluşan ퟎ stퟎ sna sıfıra bölme hatasıdır. Bu tür hatalar ArithmeticException sınıfına aퟎ ttퟎ r. O nedenle, oluşabퟎ lecek hatanın ArithmeticException tퟎ pퟎ nden olacağını öngörüp, o tퟎ pten bퟎ r nesneyퟎ ퟎ şaret etmek üzere e referans (poퟎ nter) değퟎ şkenퟎ nퟎ tanımlıyoruz. Böylece catch(arithmeticexception e){ blokunu oluşturuyoruz. Bu blok hatayı yakalayacaktır. E referans değퟎ şkenퟎ, yakalanan hatayı (nesne) ퟎ şaret edퟎ yor olacaktır. Aşağıdakퟎ program, hatayı yakaladıktan sonra kullanıcıya Sıfıra bölme hatası. mesajını gönderecek, ama program akışını kesmeden gerퟎ de kalan kodları çalıştırmayı sürdürecektퟎ r. class Hata03 { int d, a; // denenecek blok. d = 0; a = 38 / d; System.out.println("Bu satır yazılmaz."); catch (ArithmeticException e) {// catch dퟎ vퟎ de by zero error System.out.println("Sıfıra bölme hatası."); System.out.println("catch blokundan sonraki kodlar."); Programın çıktısı aşağıdadır. Dퟎ kkat edersenퟎ z, 7 ퟎ ncퟎ satır ퟎ şlevퟎ nퟎ görmemퟎ ştퟎ r. Çünkü, 6 ıncı satırda hata oluşmuş ve programın koşması kesퟎ lmퟎ ştퟎ r. Sıfıra bölme hatası. After catch statement. Programda hatayı yakalayınca, mümkünse onu gퟎ derퟎ p, programın, sonuna kadar koşmayı sürdürmesퟎ nퟎ ퟎ sterퟎ z. Aşağıdakퟎ program bunun nasıl yapılacağını gösteren basퟎ t bퟎ r örnektퟎ r. Program ퟎ kퟎ tane rasgele (random) sayı alıyor, onun bퟎ rퟎ sퟎ nퟎ ötekퟎ ne bölüyor sayını, çıkan sayıya 3/11

4 bölüyor. Bu ퟎ şlemퟎ bퟎ r for döngüsü altında kez tekrarlıyor; yanퟎ tane random sayı yaratıyor. catch blokuna önlem alıcı kodlar yazılmazsa, bölenlerden bퟎ rퟎ sퟎ sıfır olduğunda run tퟎ me sퟎ stemퟎ program akışını kesecektퟎ r. Ama, aşağıdakퟎ catch blokunda, sıfıra bölme hatası oluştuğunda, a=0 ataması yapılarak, programın koşmaya devam etmesퟎ sağlanmıştır. import java.util.random; class Hata04 { int a=0, b=0, c=0; Random r = new Random(); for(int i=0; i<22000; i++) { b = r.nextint(); c = r.nextint(); a = / (b/c); catch (ArithmeticException e) { System.out.println("Sıfıra bölme hatası."); a = 0; // devam etmek ퟎ çퟎ n 0 atandı System.out.println("a: " + a); Throwable sınıfı tostring() metodunu overrퟎ de ederek, hatanın açıklamasını yapacak hale getퟎ rmퟎ ştퟎ r. Bu özellퟎ ğퟎ kullanarak, yukarıdakퟎ programı şu şekle getퟎ rebퟎ lퟎ rퟎ z. import java.util.random; class Hata05 { int a=0, b=0, c=0; Random r = new Random(); for(int i=0; i<12000; i++) { b = r.nextint(); c = r.nextint(); a = / (b/c); catch (ArithmeticException e) { System.out.println("Exception: " + e); a = 0; // devam etmek ퟎ çퟎ n 0 atandı System.out.println("a: " + a); Ayrıca, Throwable sınıfının ve alt sınıflarının çok sayıda metotları vardır. Örneğퟎ n printstacktrace()metodu, ퟎ lk ퟎ kퟎ programdakퟎ ne benzer açıklamaları yazar. Çoklu Hata Yakalama (Multiple Catch) Bazen bퟎ r try bloku ퟎ çퟎ nde bퟎ rden çok hata oluşması olasılığı doğabퟎ lퟎ r. Bu durumlarda, catch bloku ퟎ çퟎ ne bퟎ rden çok hata atıcı deyퟎ m konabퟎ lퟎ r. Program koşarken, hangퟎ hata oluşmuş ퟎ se, ona aퟎ t deyퟎ m atılır. Bퟎ rden fazlası atılamaz. İlk hataya karşılık gelen deyퟎ m ퟎ şlerlퟎ k kazanır. Aşağıdakퟎ örnek bunu göstermektedퟎ r. // Çoklu catch deyퟎ mlerퟎ. class Hata06 { int a = args.length; System.out.println("a = " + a); int b = 38 / a; int c[] = { 1 ; 4/11

5 c[38] = 99; catch(arithmeticexception e) { System.out.println("0 ile bölme : " + e); catch(arrayindexoutofboundsexception e) { System.out.println("Array index oob: " + e); System.out.println("try/catch blokundan sonraki kodlar."); Bu program koşturulmak üzere çağrılırken komut satırından hퟎ ç parametre gퟎ rퟎ lmezse, a=0 olur. Dolayısıyla, sıfıra bölme hatası oluşur. Öte yandan, koşturulmak üzere çağrılırken komut satırından parametreler gퟎ rퟎ lퟎ rse a>0 olur, dolayısıyla sıfıra bölme hatası oluşmaz. Ancak, hemen arkasından şu hatayla karşılaşır. 7 ퟎ ncퟎ satırdakퟎ tanımı uyarınca c[] dퟎ zퟎ mퟎ nퟎ n (array) bퟎ rtek bퟎ leşenퟎ vardır, o da c[0] = 1 dퟎ r. 8 ퟎ ncퟎ satırdakퟎ deyퟎ m ퟎ se c[37] = 89 atamasını yapmaktadır. Bu olanaksızdır ve hata oluşur. Bu hata ArrayIndexOutOfBoundsException adıyla bퟎ lퟎ nen hatadır. Öyleyse, bu program mutlaka hata verecektퟎ r. Bu program koşturulmak üzere çağrılırken komut satırından hퟎ ç parametre gퟎ rퟎ lmezse, sıfıra bölme hatası dedퟎ ğퟎ mퟎ z şu hatayı atar: a = 0 Divide by 0: java.lang.arithmeticexception: / by zero After try/catch blocks. Bu program koşturulmak üzere çağrılırken komut satırından parametre(ler) gퟎ rퟎ lퟎ rse, sıfıra bölme hatasını atlar, arkasından gelen şu hata atımını yapar: a = 1 Array index oob: java.lang. java.lang.arithmeticexception:38 try/catch blokundan sonraki kodlar. catch blokunda alt sınıflardakퟎ hatalar daퟎ ma üst sınıftakퟎ hatalardan önce yazılmalıdır. Çünkü, catch deyퟎ mퟎ, üst sınıftakퟎ hatalardan başlayarak alt sınıflara doğru ퟎ ner. Eğer üstlerde bퟎ r hata yakalamışsa, o hatayı atar ve alttakퟎ hatalara ulaşamaz. Java da erퟎ şퟎ lemeyen kodlar da hata atımına neden olur. Aşağıdakퟎ buna bퟎ r örnektퟎ r: Bu program hatalıdır. Bퟎ r dퟎ zퟎ catch deyퟎ mퟎ varsa, bu deyퟎ mler alt sınıftakퟎ lerden başlayarak üst sınıflara doğru sıralanmalıdır. Aksퟎ halde, ulaşılamayan deyퟎ mler derleme zamanı hatası (compퟎ le tퟎ me error)oluşturur. class Hata07 { publퟎ c statퟎ c voퟎ d maퟎ n(strퟎ ng args[]) { ퟎ nt a = 0; ퟎ nt b = 38 / a; catch(exceptퟎ on e) { System.out.prퟎ ntln("generퟎ c Exceptퟎ on catch."); Aşağıdakퟎ koda ulaşılamaz, çünkü Arퟎ thmetퟎ cexceptퟎ on sınıfı Exceptퟎ on sınıfının bퟎ r alt sınıfıdır. catch(arퟎ thmetퟎ cexceptퟎ on e) { // HATA ulaşılamaz System.out.prퟎ ntln("bu koda ulaşılamaz."); İç çe hata dey mler try deyퟎ mlerퟎ ퟎ ç ퟎ çe konabퟎ lퟎ r. Aşağıdakퟎ buna bퟎ r örnektퟎ r. // İç ퟎ çe try deyퟎ mlerퟎ. 5/11

6 class Hata08 { int a = args.length; *Satır komutundan parametre gퟎ rퟎ lmezse *aşağıdakퟎ atama sıfıra bölme hatası oluşur. int b = 38 / a; // sıfıra bölme hatası System.out.println("a = " + a); // ퟎ ç ퟎ çe try blokları *Satır komutundan tek parametre gퟎ rퟎ lퟎ rse *aşağıdakퟎ deyퟎ m sıfıra bölme hatası oluşur. if(a==1) a = a/(a a); // sıfıra bölme hatası *Komut satırından ퟎ kퟎ parametre gퟎ rퟎ lퟎ rse *aşağıdakퟎ deyퟎ m out of bounds hatası oluşturur. if(a==2) { int c[] = { 1 ; c[37] = 89; // out of bounds hatası catch(arrayindexoutofboundsexception e) { System.out.println("Array indisini aşar : " + e); catch(arithmeticexception e) { System.out.println("0 ile bölme: " + e); Bu programdakퟎ hata atımları şöyledퟎ r: Bu program koşturulmak üzere çağrılırken komut satırından ya hퟎ ç bퟎ r parametre gퟎ rퟎ lmez, ya bퟎ r tane gퟎ rퟎ lퟎ r ya da bퟎ rden çok parametre gퟎ rퟎ lퟎ r. Program 4 üncü satırdakퟎ a=args.length deyퟎ mퟎ ퟎ le a ya mutlaka bퟎ r atama yapacaktır. Eğer parametre gퟎ rퟎ lmemퟎ şse, a=0 olur. Dolayısıyla, b= 38/a deyퟎ mퟎ nde sıfıra bölme hatası oluşur. Bu durumda sퟎ stem sıfıra bölme (dퟎ vퟎ de byzero) hatasını kendퟎ lퟎ ğퟎ nden atacaktır. Eğer çağrıda parametre gퟎ rퟎ lmퟎ şse, dıştakퟎ try blokunda hata oluşmaz ve b=38 değerퟎ nퟎ atar ve ퟎ çtekퟎ try blokuna gퟎ rer. Burada ퟎ kퟎ ퟎ f deyퟎ mퟎ vardır. Onları sırayla yoklayacaktır. Eğer gퟎ rퟎ len parametre tek ퟎ se, a=args.length=1 olur. Bu durumda a=a/(a 1) deyퟎ mퟎ nde sıfıra bölme hatası oluşur. Bu durumda da, gene, sퟎ stem sıfıra bölme (dퟎ vퟎ de by zero) hatasını kendퟎ lퟎ ğퟎ nden atacaktır. Eğer 2 parametre gퟎ rퟎ lmퟎ şse, sퟎ stem ퟎ lk ퟎ f deyퟎ mퟎ nde bퟎ r hata ퟎ le karşılaşmaz. Dolayısıyla, sonrakퟎ ퟎ f deyퟎ mퟎ ne gퟎ rer. Ancak, yukarıda açıklandığı gퟎ bퟎ, hemen arkasından şu hatayla karşılaşır. c[] dퟎ zퟎ mퟎ nퟎ n (array) bퟎ rtek bퟎ leşenퟎ olduğundan, c[37] = 89 ataması geçersퟎ z bퟎ r deyퟎ mdퟎ r, ArrayIndexOutOfBoundsException adıyla bퟎ lퟎ nen hata oluşur. Metot çağrılarında try bloku gퟎ zlenmퟎ ş olarak çalışabퟎ lퟎ r. Aşağıdakퟎ program, yukardakퟎ programın, metot kullanılarak yenퟎ den kodlanmış bퟎ çퟎ mퟎ dퟎ r. * Bellퟎ belퟎ rsퟎ z ퟎ ç ퟎ çe try blokları * calls to methods. class Hata09 { static void nesttry(int a) { // ퟎ ç ퟎ çe try bloku Tek parametre gퟎ rퟎ lퟎ rse aşağıdakퟎ deyퟎ m dퟎ vퟎ de by zero exceptퟎ on oluşturur. if(a==1) a = a/(a a); // dퟎ vퟎ sퟎ on by zero 6/11

7 İkퟎ parametre gퟎ rퟎ lퟎ rse array ퟎ ndퟎ s sınırı aşılır, out of bounds exceptퟎ on oluşur. if(a==2) { int c[] = { 1 ; c[38] = 99; // out of bounds exceptퟎ on oluşma yerퟎ catch(arrayindexoutofboundsexception e) { System.out.println("Array indis sınırı aşılıyor : " + e); int a = args.length; If no command lퟎ ne args are present, the followퟎ ng statement wퟎ ll generate a dퟎ vퟎ de by zero exceptퟎ on. int b = 38 / a; System.out.println("a = " + a); nesttry(a); catch(arithmeticexception e) { System.out.println("0 ile bölme: " + e); throw Buraya kadar yazdığımız programlarda hataları java run tퟎ me sퟎ stem yakalıyordu. Bunun yerퟎ ne, ퟎ stenퟎ rse hata bellퟎ bퟎ r nesne olarak atılabퟎ lퟎ r. Atılan nesne API dekퟎ bퟎ r throwable nesne olacağı gퟎ bퟎ, programcının onlardan türettퟎ ğퟎ bퟎ r nesne de olabퟎ lퟎ r. Bunun sözdퟎ zퟎ mퟎ şöyledퟎ r: if (flag < 0) { throw new ThrowableNesne(); Aşağıdakퟎ örnekler bunun nasıl olduğunu göstermektedퟎ r. // throw. class ThrowDemo { static void demoyap() { throw new NullPointerException("demo"); catch(nullpointerexception e) { System.out.println("hata, demoyap içinde yakalandı."); throw e; // hata tekrar atılıyor demoyap(); catch(nullpointerexception e) { System.out.println("Tekrar yakalanıyor: " + e); throw new NullPointerException("demo"); 7/11

8 throws Bퟎ r metodun atması olasılığı olan ퟎ stퟎ snaları lퟎ steler. throw dan farklıdır. Sözdퟎ zퟎ mퟎ şöyledퟎ r: public void metod_adı() throws Exception1, Exception2,,ExceptionN { try { deyimler catch(exception1 ex1) { deyimler catch(exceptionn exn) { deyimler // Bu program hata ퟎ çerdퟎ ğퟎ ퟎ çퟎ n derlenemez. class ThrowsDemo { static void throwbir() { System.out.println("Inside throwbir."); throw new IllegalAccessException("demo"); throwbir(); // Bu program doğrudur, derlenebilir. class ThrowsDemo { static void throwbir() throws IllegalAccessException { System.out.println("throwBir içinde."); throw new IllegalAccessException("demo"); throwbir(); catch (IllegalAccessException e) { System.out.println("Yakalanıyor " + e); finally Bퟎ r hata oluştuğunda, onun oluştuğu kodu ퟎ çeren metot (blok) duracak ve ퟎ şlemퟎ sürdüremeyecektퟎ r. Bu sırada metot bퟎ r I/O ퟎ şlemퟎ yapıyorsa, açık dosyaları kapatamayacaktır. finally bloku bu gퟎ bퟎ durumların üstesퟎ nden gelmek ퟎ çퟎ n kullanılır. Başka bퟎ r deyퟎ şle, çevreyퟎ temퟎ zler. finally bloku şu ퟎ şlerde çok kullanışlıdır: I/O ퟎ çퟎ n açılmış dosyaları kapatma, Verퟎ tabanı programlarında açılan result set ퟎ kapatma, Verퟎ tabanına yapılan bağlantıyı kapatma finally blokunun kullanılması ퟎ steğe bağlıdır. Hퟎ ç kullanılmayabퟎ lퟎ r. Ama kullanılacaksa, son catch blokunun hemen arkasına konulmalıdır. 8/11

9 Örnek 1: Aşağıdakퟎ program program parçası, açılan dosyayı kapatır. SomeFileClass f = new SomeFileClass(); if (f.open("/a/file/name/path")) { somereallyexceptionalmethod(); catch (Throwable t) { f.close(); throw t; Örnek 1: Aşağıdakퟎ program program parçası da aynı ퟎ şퟎ yapar. SomeFileClass f = new SomeFileClass(); if (f.open("/a/file/name/path")) { somereallyexceptionalmethod(); finally { f.close(); Örnek 3: finally blokunu yalnızca exceptퟎ on dan sonra değퟎ l, return, break ve continue deyퟎ mlerퟎ nden sonra da kullanabퟎ lퟎ rퟎ z. public class MyFinalExceptionalClass extends ContextClass { public static void main(string argv[]) { int mysteriousstate = getcontext(); while (true) { System.out.print("Who "); System.out.print("is "); if (mysteriousstate == 1) return; System.out.print("that "); if (mysteriousstate == 2) break; System.out.print("strange "); if (mysteriousstate == 3) continue; System.out.print("but kindly "); if (mysteriousstate == 4) throw new UncaughtException(); System.out.print("not at all "); finally { System.out.print("amusing man?\n"); System.out.print("I'd like to meet the man "); System.out.print("Please tell me.\n"); mysteriousstate değerlerퟎ ne bağlı olarak bu programın çıktısı şöyledퟎ r. : 1 Who is amusing man? 2 Who is that amusing man? 3 Please tell me 4 Who is that strange amusing man?... 5 Who is that strange but kindly amusing man? 9/11

10 6 Who is that strange but kindly not at all amusing man? 7 I'd like to meet the man Who is that strange...? Örnek 4: // finally için demo. class FinallyDemo { // metot dışında exceptퟎ on static void proca() { System.out.println("procA içinde"); throw new RuntimeException("demo"); finally { System.out.println("procA's finally"); // Bퟎ r try blokundan gerퟎ dön static void procb() { System.out.println("procB içinde"); return; finally { System.out.println("procB'deki finally"); // Bퟎ r try blokunu normal ퟎ şle. static void procc() { System.out.println("procC içinde"); finally { System.out.println("procC'deki finally"); proca(); catch (Exception e) { System.out.println("Exception yakalanıyor"); procb(); procc(); class MyException extends Exception { private int sayac; MyException(int a) { sayac = a; public String tostring() { return "MyException[" + sayac + "]"; class ExceptionDemo { static void compute(int a) throws MyException { System.out.println("Çağrı(" + a + ")"); if(a > 10) throw new MyException(a); System.out.println("Normal çıkış"); 10/11

11 compute(1); compute(20); catch (MyException e) { System.out.println("Yakalanıyor " + e); 11/11