Java try-catch: معالجة الاستثناءات دون تعطّل البرنامج

التقاط استثناء بدلًا من التعطّل

أنت تعرف بالفعل أنه حين يحدث خطأ ما، فإن جافا تُطلق استثناءً، وأن الاستثناء غير المُعالَج يوقف برنامجك مع تتبُّع للمكدّس (stack trace). كتلة try-catch هي طريقتك لتولّي زمام الأمور: تُحيط الكود الخطِر بـ try، وإن أطلق استثناءً تنتقل جافا إلى كتلة catch المطابقة بدلًا من التعطّل.

public class Main {
    public static void main(String[] args) {
        try {
            int result = 10 / 0;          // يُطلق ArithmeticException
            System.out.println(result);   // لا يُبلَغ أبدًا
        } catch (ArithmeticException e) {
            System.out.println("Cannot divide by zero");
        }

        System.out.println("Program keeps running");
    }
}

في اللحظة التي يُطلق فيها 10 / 0 الاستثناء، يُتجاوَز باقي كتلة try وينتقل التحكّم إلى catch. وبعد انتهاء catch، يستمر التنفيذ بشكل طبيعي - فالبرنامج لا يموت.

متغيّر catch يحمل الاستثناء

الـ e في catch (ArithmeticException e) هو كائن حقيقي. إنه يحمل معلومات عمّا حدث من خطأ، وأكثرها فائدةً رسالة:

public class Main {
    public static void main(String[] args) {
        try {
            int n = Integer.parseInt("not a number");
            System.out.println(n);
        } catch (NumberFormatException e) {
            System.out.println("Bad input: " + e.getMessage());
        }
    }
}

تُعيد e.getMessage() وصفًا موجزًا. أثناء التنقيح، يطبع e.printStackTrace() التتبُّع الكامل الذي يُظهر بالضبط من أين جاء الاستثناء - لُذ به حين لا تكفي الرسالة وحدها للعثور على السبب.

التقط النوع المحدد، لا كل شيء

تلتقط كتلة catch الاستثناءات المطابقة لنوعها المُصرَّح به (أو لأحد أنواعه الفرعية) فقط. أكبر خطأ يقع فيه المبتدئون هو التقاط Exception لجعل مشكلة ما "تختفي":

// لا تفعل هذا - فهو يُخفي عللًا حقيقية
try {
    doWork();
} catch (Exception e) {
    // يبتلع NullPointerException والأخطاء المطبعية وأخطاء المنطق... كل شيء
}

التقط أضيق نوع تستطيع معالجته فعلًا. إن كنت تتوقع إدخالًا رقميًا خاطئًا، فالتقط NumberFormatException. وأي شيء لم تتوقعه ينبغي أن يُسمح له بالانتشار كي تعرف بأمره حقًا بدلًا من الاستمرار بصمت في حالة معطوبة.

معالجة عدة أنواع من الاستثناءات

يمكنك رصّ عدة كتل catch. تفحصها جافا من الأعلى إلى الأسفل وتُنفّذ أول كتلة مطابقة، لذا رتّبها من الأكثر تحديدًا إلى الأكثر عمومية:

public class Main {
    public static void main(String[] args) {
        String[] inputs = {"42", "oops", null};

        for (String s : inputs) {
            try {
                int n = Integer.parseInt(s);
                System.out.println("Parsed: " + n);
            } catch (NumberFormatException e) {
                System.out.println("Not a number: " + s);
            } catch (NullPointerException e) {
                System.out.println("Got a null value");
            }
        }
    }
}

حين يتشارك نوعان المعالجة نفسها، استخدم كتلة multi-catch واحدة مع | بدلًا من تكرار الكتلة:

public class Main {
    public static void main(String[] args) {
        try {
            Object[] words = {"a", "b"};
            System.out.println(words[5]);   // ArrayIndexOutOfBoundsException
        } catch (ArrayIndexOutOfBoundsException | NullPointerException e) {
            System.out.println("Bad access: " + e.getClass().getSimpleName());
        }
    }
}

مَزلق ينبغي الانتباه له: النوع الأكثر عمومية يجب أن يأتي بعد الأنواع المحددة. وضع catch (Exception e) أولًا يجعل الكتل الأكثر تحديدًا التالية غير قابلة للوصول، ويرفض المُصرِّف ذلك.

finally تُنفَّذ دائمًا

تُنفَّذ كتلة finally بعد الـ try وأي catch، بصرف النظر عمّا حدث - نجاح، أو استثناء مُلتقَط، أو حتى return مبكر. وهي المكان الذي تنتمي إليه أعمال التنظيف التي يجب أن تحدث دائمًا.

public class Main {
    public static void main(String[] args) {
        try {
            System.out.println("Opening resource");
            int x = 1 / 0;                 // يُطلق استثناءً
            System.out.println("Working");  // يُتجاوَز
        } catch (ArithmeticException e) {
            System.out.println("Caught: " + e.getMessage());
        } finally {
            System.out.println("Closing resource");  // تُنفَّذ مهما حدث
        }
    }
}

تُطبَع "Closing resource" سواء أطلق الاستثناء أم لم يُطلق. لكن تجنّب تنفيذ return من داخل finally - فقد يتجاهل بصمت استثناءً أو يطغى على قيمة أُعيدت من كتلة try.

try-with-resources يغلق الأشياء نيابةً عنك

حين تتعامل مع شيء يجب إغلاقه - ملف، أو اتصال شبكي، أو تعليمة قاعدة بيانات - فإن التصريح به داخل try (...) يغلقه تلقائيًا عند انتهاء الكتلة، حتى لو أُطلق استثناء. ويعمل ذلك مع أي نوع يُطبّق AutoCloseable.

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        // Scanner يُطبّق AutoCloseable، لذا يُغلَق تلقائيًا
        try (Scanner sc = new Scanner("10 20 30")) {
            int sum = 0;
            while (sc.hasNextInt()) {
                sum += sc.nextInt();
            }
            System.out.println("Sum: " + sum);
        }
    }
}

يحل هذا محل النمط القديم القائم على الفتح في try والإغلاق في finally، وهو أقل عرضةً للأخطاء لأنك لا تستطيع نسيان الإغلاق. فضّله كلما كنت تتعامل مع مورد قابل للإغلاق.

لا تستخدم الاستثناءات في تدفّق التحكّم العادي

try-catch مخصص للحالات الاستثنائية، لا للظروف الاعتيادية. التقاط استثناء أكثر كلفةً من فحص بسيط، ويجعل الكود أصعب قراءةً. إن كان بإمكانك فحص الشرط أولًا، فافعل ذلك بدلًا منه:

// تجنّب: استخدام catch لفحص مفتاح مفقود
try {
    process(map.get(key).trim());
} catch (NullPointerException e) {
    // معالجة المفتاح المفقود
}

// فضّل: الفحص الصريح
String value = map.get(key);
if (value != null) {
    process(value.trim());
}

احتفظ بـ catch للأمور الخارجة فعلًا عن سيطرتك - إدخال مستخدم خاطئ، أو ملفات مفقودة، أو أعطال شبكية.

التالي: NullPointerException

الاستثناء الأكثر شيوعًا الذي ستلتقطه (وتُسبّبه) في جافا هو NullPointerException - يظهر في اللحظة التي تستدعي فيها دالةً على شيء تبيّن أنه null. سنتعمّق تاليًا فيما يُطلقه بالضبط، وكيف تقرأ تتبُّع مكدّسه، والعادات التي تمنع حدوثه من الأساس.