Java'daki istisnalar

Merhaba! Bugünkü dersimizde Java İstisnalarından bahsedeceğiz. Günlük yaşam, tahmin etmediğimiz durumlarla doludur. Örneğin sabah işe gitmek için kalkıp telefonunuzun şarj aletini arıyorsunuz ama hiçbir yerde bulamıyorsunuz. Duş almak için banyoya gittiğinizde boruların donmuş olduğunu keşfedersiniz. Arabanıza biniyorsunuz ama çalışmıyor. Bir insan bu tür öngörülemeyen durumlarla oldukça kolay başa çıkabilir. Bu yazıda, Java programlarının bunlarla nasıl başa çıktığını anlamaya çalışacağız.

Java istisnası nedir?

Programlama dünyasında, bir programın yürütülmesindeki hatalara ve öngörülemeyen durumlara istisna denir. Bir programda, geçersiz kullanıcı eylemleri, yetersiz disk alanı veya sunucuyla ağ bağlantısının kesilmesi nedeniyle istisnalar meydana gelebilir. İstisnalar, programlama hatalarından veya bir API'nin yanlış kullanımından da kaynaklanabilir. Gerçek dünyadaki insanlardan farklı olarak, bir programın bu durumlarla nasıl başa çıkacağını tam olarak bilmesi gerekir. Bunun için Java, istisna işleme olarak bilinen bir mekanizmaya sahiptir.

Anahtar kelimeler hakkında birkaç kelime

Java'da istisna işleme, programda aşağıdaki anahtar kelimelerin kullanımına dayanır:

• try - bir istisnanın meydana gelebileceği bir kod bloğunu tanımlar;
• catch - istisnaların işlendiği bir kod bloğu tanımlar;
• nihayet - varsa, try bloğunun sonuçlarından bağımsız olarak yürütülen isteğe bağlı bir kod bloğunu tanımlar.

Bu anahtar kelimeler, kodda özel yapılar oluşturmak için kullanılır: try{}catch , try{}catch{}finally , try{}finally{} .

• throw - bir istisna oluşturmak için kullanılır;
• throws - yöntemin bir istisna oluşturabileceği konusunda uyarmak için yöntem imzasında kullanılır.

Bir Java programında anahtar sözcük kullanımına bir örnek:

// This method reads a string from the keyboard

public String input() throws MyException { // Use throws to warn 
// that the method may throw a MyException
      BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
    String s = null;
// We use a try block to wrap code that might create an exception. In this case,
// the compiler tells us that the readLine() method in the 
// BufferedReader class might throw an I/O exception
    try {
        s = reader.readLine();
// We use a catch block to wrap the code that handles an IOException  
    } catch (IOException e) {
        System.out.println(e.getMessage());
// We close the read stream in the finally block
    } finally {
// An exception might occur when we close the stream if, for example, the stream was not open, so we wrap the code in a try block
        try {
            reader.close();
// Handle exceptions when closing the read stream
        } catch (IOException e) {
            System.out.println(e.getMessage());
        }
    }

    if (s.equals("")) {
// We've decided that an empty string will prevent our program from working properly. For example, we use the result of this method to call the substring(1, 2) method. Accordingly, we have to interrupt the program by using throw to generate our own MyException exception type.
        throw new MyException("The string cannot be empty!");
    }
    return s;
}

Neden istisnalara ihtiyacımız var?

Gerçek dünyadan bir örneğe bakalım. Bir karayolunun bir bölümünde sınırlı ağırlık kapasitesine sahip küçük bir köprü olduğunu hayal edin. Köprünün sınırından daha ağır bir araba üzerinden geçerse çökebilir. Sürücünün durumu, en hafif deyimiyle olağanüstü hale gelirdi. Bunu önlemek için ulaşım departmanı, bir şeyler ters gitmeden önce yola uyarı işaretleri yerleştirir. Uyarı levhasını gören sürücü, aracının ağırlığını köprünün maksimum ağırlığıyla karşılaştırır. Araç çok ağırsa, sürücü yan yol kullanır. Ulaşım dairesi, önce TIR sürücülerinin gerekirse rota değiştirmesine olanak sağladı, ikinci olarak sürücüleri ana yoldaki tehlikelere karşı uyardı, üçüncü olarak da köprünün belirli koşullar altında kullanılmaması konusunda sürücüleri uyardı. Bir programdaki istisnai durumları önleme ve çözme yeteneği, programın çalışmaya devam etmesine izin vermek, Java'da istisnaların kullanılmasının bir nedenidir. İstisna mekanizması, herhangi bir girişi doğrulayarak (kontrol ederek) kodunuzu (API) uygunsuz kullanımdan korumanıza da olanak tanır. Şimdi bir anlığına ulaşım departmanı olduğunuzu hayal edin. Öncelikle, sürücülerin sorun bekleyebilecekleri yerleri bilmeniz gerekir. İkincisi, uyarı işaretleri oluşturmanız ve yerleştirmeniz gerekir. Ve son olarak, ana rotada sorunlar çıkarsa, sapmalar sağlamanız gerekir. Java'da istisna mekanizması benzer şekilde çalışır. Geliştirme sırasında, kodun tehlikeli bölümleri etrafında bir "istisna engeli" oluşturmak için bir try bloğu kullanırız , bir catch {} kullanarak "yedekleme yolları" sağlarız.blok ve bir nihayet{} bloğunda ne olursa olsun çalışması gereken kodu yazıyoruz . Bir "yedek rota" sağlayamıyorsak veya kullanıcıya seçme hakkı vermek istiyorsak, en azından onu tehlikeye karşı uyarmalıyız. Neden? Tek bir uyarı işareti görmeden geçemeyeceği küçük bir köprüye ulaşan bir sürücünün öfkesini hayal edin! Programlamada, sınıflarımızı ve yöntemlerimizi yazarken, bunların diğer geliştiriciler tarafından nasıl kullanılabileceğini her zaman öngöremeyiz. Sonuç olarak, istisnai bir durumu çözmenin %100 doğru yolunu öngöremiyoruz. Bununla birlikte, istisnai durumlar olasılığı hakkında başkalarını uyarmak iyi bir biçimdir. Java'nın istisna mekanizması, bunu fırlatmalarla yapmamızı sağlar .anahtar kelime — esasen, yöntemimizin genel davranışının bir istisna atmayı içerdiğine dair bir beyan. Bu nedenle, yöntemi kullanan herkes istisnaları işlemek için kod yazması gerektiğini bilir.

Başkalarını "bela" hakkında uyarma

Metodunuzda istisnaları işlemeyi planlamıyorsanız ancak başkalarını istisnaların olabileceği konusunda uyarmak istiyorsanız, throws anahtar kelimesini kullanın. Yöntem imzasındaki bu anahtar sözcük, belirli koşullar altında yöntemin bir istisna atabileceği anlamına gelir. Bu uyarı, yöntem arayüzünün bir parçasıdır ve kullanıcılarının kendi istisna işleme mantığını uygulamalarına izin verir. Atışlardan sonra, atılan istisna türlerini belirtiriz. Bunlar genellikle Java'nın İstisna sınıfından gelir. Java, nesne yönelimli bir dil olduğundan, tüm istisnalar Java'daki nesnelerdir.

İstisna hiyerarşisi

Bir program çalışırken bir hata oluştuğunda, JVM, Java istisna hiyerarşisinden uygun türde bir nesne oluşturur - ortak bir atadan - Throwable sınıfından gelen bir dizi olası istisna . Olağanüstü çalışma zamanı durumlarını iki gruba ayırabiliriz:

1. Programın kurtarılamadığı ve normal çalışmaya devam edemediği durumlar.
2. İyileşmenin mümkün olduğu durumlar.

İlk grup, Error sınıfından türeyen bir istisnayı içeren durumları içerir . Bunlar bir JVM arızası, bellek taşması veya sistem arızası nedeniyle oluşan hatalardır. Genellikle yazılımla çözülemeyecek ciddi sorunları gösterirler. Java'da, bu tür istisnaların olasılığı derleyici tarafından kontrol edilmez, bu nedenle bunlar kontrol edilmeyen istisnalar olarak bilinir. Bu grup, İstisnadan kaynaklanan istisnalar olan RuntimeExceptions'ı da içerir.class ve çalışma zamanında JVM tarafından üretilir. Genellikle programlama hatalarından kaynaklanırlar. Bu istisnalar ayrıca derleme zamanında kontrol edilmez (işaretlenmez), dolayısıyla bunları işlemek için kod yazmanız gerekmez. İkinci grup, programı yazarken öngörülebilen istisnai durumları içerir (ve bu nedenle bunları işlemek için kod yazmalısınız). Bu tür istisnalara kontrol edilen istisnalar denir. İstisnalar söz konusu olduğunda, bir Java geliştiricisinin işinin çoğu bu tür durumları ele almaktır.

İstisna oluşturma

Bir program çalıştığında, istisnalar ya JVM tarafından ya da bir throw deyimi kullanılarak manuel olarak oluşturulur. Bu olduğunda, bellekte bir istisna nesnesi oluşturulur, programın ana akışı kesilir ve JVM'nin istisna işleyicisi istisnayı işlemeye çalışır.

İstisna işleme

Java'da, try{}catch , try{}catch{}finally ve try{}finally{} yapılarını kullanarak istisna işleme ihtiyacını öngördüğümüz kod blokları oluştururuz . Bir try bloğunda bir istisna atıldığında , JVM bir sonraki catch bloğunda uygun bir istisna işleyici arar . Bir catch bloğu gerekli istisna işleyiciye sahipse, kontrol ona geçer. Değilse, JVM uygun işleyici bulunana kadar yakalama blokları zincirinin daha aşağısına bakar. Bir catch bloğu yürütüldükten sonra kontrol, isteğe bağlı finally bloğuna aktarılır . Eğer uygun bir yakalamablok bulunamadı, ardından JVM programı durdurur ve varsa , ilk önce nihayet bloğu gerçekleştirdikten sonra yığın izlemeyi (geçerli yöntem çağrıları yığını) görüntüler. İstisna işleme örneği:

public class Print {

     void print(String s) {
        if (s == null) {
            throw new NullPointerException("Exception: s is null!");
        }
        System.out.println("Inside print method: " + s);
    }

    public static void main(String[] args) {
        Print print = new Print();
        List list= Arrays.asList("first step", null, "second step");

        for (String s : list) {
            try {
                print.print(s);
            }
            catch (NullPointerException e) {
                System.out.println(e.getMessage());
                System.out.println("Exception handled. The program will continue");
            }
            finally {
                System.out.println("Inside finally block");
            }
            System.out.println("The program is running...");
            System.out.println("-----------------");
        }

    }
    }

İşte ana yöntemin sonuçları:

Inside print method: first step
Inside finally block
The program is running...
-----------------
Exception: s is null!
Exception handled. The program will continue
Inside finally block
The program is running...
-----------------
Inside print method: second step
Inside finally block
The program is running...
-----------------

Nihayet, tipik olarak herhangi bir akışı kapatmak ve bir try bloğunda açılan/tahsis edilen kaynakları serbest bırakmak için kullanılır . Ancak, bir program yazarken, tüm kaynakların kapanışını takip etmek her zaman mümkün değildir. Hayatımızı kolaylaştırmak için Java geliştiricileri, bir try bloğunda açılan tüm kaynakları otomatik olarak kapatan try-with-resources yapısını sunar . İlk örneğimiz try-with-resources ile yeniden yazılabilir :

public String input() throws MyException {
    String s = null;
    try (BufferedReader reader = new BufferedReader(new InputStreamReader(System.in))){
        s = reader.readLine();
   } catch (IOException e) {
       System.out.println(e.getMessage());
   }
    if (s.equals("")) {
        throw new MyException ("The string cannot be empty!");
    }
    return s;
}

Sürüm 7'de tanıtılan Java yetenekleri sayesinde, heterojen istisnaları yakalamayı tek bir blokta birleştirerek kodu daha derli toplu ve okunabilir hale getirebiliriz. Örnek:

public String input() {
    String s = null;
    try (BufferedReader reader = new BufferedReader(new InputStreamReader(System.in))) {
        s = reader.readLine();
        if (s.equals("")) {
            throw new MyException("The string cannot be empty!");
        }
    } catch (IOException | MyException e) {
        System.out.println(e.getMessage());
    }
    return s;
}

Alt çizgi

Java'da istisnaların kullanılması, "yedekleme yolları" oluşturarak programlarınızı daha güçlü hale getirmenize, ana kodu istisna işleme kodundan ayırmak için catch bloklarını kullanmanıza ve istisna işleme sorumluluğunu yönteminizi kullanan kişiye kaydırmak için atışları kullanmanıza olanak tanır .