Ngoại lệ ném Java

Bất cứ nơi nào chúng ta đi, những sự kiện không thể đoán trước đang chờ đợi chúng ta. Động đất, hành động phi lý của con người, thiên thạch... hay điều gì đó đơn giản hơn - một bóng đèn cháy, thẻ ngân hàng mất từ ​​tính, đồng hồ đo xăng bị hỏng. Chúng ta không thể vô hiệu hóa các sự kiện không thể đoán trước, nhưng ít nhất chúng ta có thể chuẩn bị một phần cho chúng. Tức là chúng ta phải chuẩn bị những cơ chế nhất định để đối phó với chúng. Trong thế giới lập trình, đặc biệt là trong ngôn ngữ Java, các sự kiện ngăn chương trình hoạt động bình thường được gọi là ngoại lệ và cơ chế ngăn chặn sự cố chương trình được gọi là xử lý ngoại lệ. Vì vậy, khi một sự kiện không mong muốn xảy ra trong một chương trình, chẳng hạn như chia cho 0, nó sẽ "ném" một ngoại lệ. Xử lý ngoại lệ là một khía cạnh quan trọng của lập trình Java, giúp các nhà phát triển quản lý các lỗi và ngoại lệ có thể xảy ra trong quá trình thực thi chương trình. Trong bài viết này, chúng ta sẽ tập trung vào một trong những khái niệm cơ bản về xử lý ngoại lệ: từ khóa ném Java và cách sử dụng nó để ném ngoại lệ.

Ngoại lệ trong Java là gì?

Ngoại lệ là một sự kiện xảy ra trong quá trình thực thi một chương trình làm gián đoạn luồng lệnh thông thường của chương trình. Khi xảy ra ngoại lệ, quá trình thực thi chương trình bị tạm dừng và thông báo lỗi được hiển thị trên bảng điều khiển. Trong Java, có hai loại ngoại lệ: được chọn và không được chọn. Các ngoại lệ đã kiểm tra được kiểm tra tại thời điểm biên dịch và trình biên dịch đảm bảo rằng chúng được bắt hoặc khai báo bằng phương thức gọi. Mặt khác, các ngoại lệ không được kiểm tra sẽ không được kiểm tra tại thời điểm biên dịch và chúng có thể bị bắt hoặc không bị bắt. Đây là một ví dụ về mã trong đó có thể xảy ra lỗi nhưng trình biên dịch sẽ bỏ qua lỗi đó.

public class Factorial {
   public static long getFactorial(final int number) {
           long fact = 1;
           for (int i = 1; i <= number; i++) {
               fact = fact * i;
           }
           return fact;
   }

   public static void main(String[] args) {
       System.out.println(getFactorial(-5));
       System.out.println(getFactorial(21));

   }

}

Đây là đầu ra của chương trình: Chương trình đã thoát chính xác nhưng tạo ra kết quả không chính xác. Trong trường hợp đầu tiên, vì đối số của hàm là số âm và giai thừa không hoạt động đối với số âm. Trong trường hợp thứ hai, kết quả sai vì số đó quá lớn để tính giai thừa của nó trong phạm vi loại dài. Đây là một ví dụ khác. Hãy viết một chương trình trong đó chúng ta sẽ chia một số cho một số khác.

public class DivisionExample {

       public static void main(String[] args) {
           int a = 10;
           int b = 0;
           int result = divide(a, b);
           System.out.println(result);
       }

       public static int divide(int a, int b) {
           return a / b;
       }
}

Trong ví dụ này, một ngoại lệ ArithmeticException sẽ bị ném ra vì biến b bằng 0. Tuy nhiên, lỗi này không được xử lý nên chương trình thoát ra với trạng thái không chính xác.

Cách ném ngoại lệ trong Java

Trong Java, các ngoại lệ cũng là các đối tượng, do đó một ngoại lệ được ném ra giống như một đối tượng Ngoại lệ mới được tạo. Một ngoại lệ được đưa vào chương trình bằng câu lệnh ném. Thông thường, hai thao tác này (tạo đối tượng và ném ngoại lệ) được kết hợp thành một:

throw new Exception("error…");

Từ khóa ném trong Java được sử dụng để ném ngoại lệ khỏi một phương thức hoặc khối mã khi xảy ra lỗi hoặc điều kiện ngoại lệ mà chương trình không thể xử lý khi chạy. Luồng chương trình được chuyển hướng đến khối bắt gần nhất. Khối này có thể quản lý ngoại lệ.

Ví dụ về cách sử dụng từ khóa 'ném'

Để minh họa chức năng của từ khóa ném trong Java, hãy lấy một ví dụ. Hãy viết một phương pháp tính giai thừa của một số. Nếu số âm thì không thể tính được nên phải đưa ra một ngoại lệ. Tương tự, nếu số quá lớn, kết quả giai thừa sẽ vượt quá kích thước tối đa của loại dài và một ngoại lệ khác sẽ được đưa ra. Ở đây chúng tôi có một cách thực hiện phương pháp:

public Class Factorial {

public static long getFactorial(final int number) {
   if ((number >= 0) && (number < 21)) {
       long fact = 1;
       for (int i = 1; i <= number; i++) {
           fact = fact * i;
       }
       return fact;
   } else {

//throw new exception here
       throw new IllegalArgumentException("THe argument isn't legal");
   }
}

 public static void main(String[] args) {
       System.out.println(getFactorial(-5));
       System.out.println(getFactorial(21));

   }
}

Trong ví dụ này, nếu giá trị của số là âm, từ khóa ném được sử dụng để ném một thể hiện của lớp IllegalArgumentException . Nếu bạn chạy chương trình, thông báo "Đối số không hợp pháp" sẽ được hiển thị trên bảng điều khiển. Việc thực hiện chương trình sẽ bị dừng lại.

Không còn lỗi nữa: bắt một ví dụ ngoại lệ

Bây giờ hãy nhớ lại ví dụ thứ hai, chia cho 0 và thực hiện nó bằng cách xử lý ngoại lệ.

public class DivisionExample {

    public static void main(String[] args) {
        int a = 10;
        int b = 0;
        try {
            int result = divide(a, b);
            System.out.println(result);
        } catch (ArithmeticException e) {
            System.out.println("Error: division by zero");
        }
    }

    public static int divide(int a, int b) {
        return a / b;
    }
}

Trong ví dụ này, chúng tôi đã thêm cấu trúc try-catch để xử lý ngoại lệ chia cho 0. Nói ngắn gọn, try-catch-cuối cùng là một cấu trúc ngôn ngữ lập trình Java cho phép bạn xử lý các ngoại lệ và thực thi mã bất kể ngoại lệ có xảy ra hay không. try-catch-cuối cùng bao gồm ba khối:

• Khối thử . Mã nguy hiểm tiềm tàng đang được thực thi ở đây. Đó là mã có thể đưa ra một ngoại lệ. Nếu một ngoại lệ xảy ra trong khối thử , việc thực thi mã trong khối đó sẽ bị hủy bỏ và quyền điều khiển được chuyển sang khối bắt.
• Khối bắt . Ở đây ngoại lệ ném được xử lý. Trong khối bắt , bạn có thể chỉ định ngoại lệ nào cần bắt và logic nào sẽ thực thi khi nó bị bắt.
Khối cuối cùng . Điều này được thực thi bất kể ngoại lệ có xảy ra hay không. Ví dụ, khối cuối cùng được sử dụng để giải phóng tài nguyên (chẳng hạn như đóng tệp hoặc ổ cắm) đã được phân bổ trong khối thử. Bạn có thể bỏ qua khối này.

Cấu trúc try-catch-cuối cùng cho phép kiểm soát chính xác hơn việc thực hiện chương trình trong trường hợp có tình huống đặc biệt và giúp ngăn chặn việc chấm dứt chương trình bất ngờ trong trường hợp có lỗi. Bây giờ, hãy quay lại ví dụ của chúng tôi. Nếu việc chia cho 0 xảy ra trong phương thức chia, một ngoại lệ ArithmeticException sẽ được ném ra và bị khối bắt giữ. Trong khối bắt , chúng ta chỉ cần in một thông báo lỗi ra bàn điều khiển. Nếu không có ngoại lệ xảy ra, chương trình sẽ tiếp tục thực hiện.

ném từ khóa

Từ khóa ném được sử dụng trong chữ ký phương thức. Nếu vậy, điều đó có nghĩa là một ngoại lệ đang được đưa vào phương thức. Điều này có thể truyền các ngoại lệ lên ngăn xếp cuộc gọi và chỉ ra rằng các ngoại lệ không cần phải được xử lý trong phương thức hiện tại. Trong Java, "ném" cũng có thể được sử dụng để chỉ các ngoại lệ tùy chỉnh được xác định trong một chương trình. Ví dụ: một phương thức có thể thực hiện phép chia hai số nhưng đưa ra IllegalArgumentException nếu đối số thứ hai bằng 0:

public static double divide(double a, double b) throws IllegalArgumentException {
    if (b == 0) {
        throw new IllegalArgumentException("Division by zero is not allowed");
    }
    return a / b;
}

Phương thức này sử dụng từ khóa ném để chỉ ra rằng IllegalArgumentException có thể được ném nếu đối số thứ hai là null. Nếu một ngoại lệ như vậy xảy ra trong khi thực thi phương thức, nó sẽ được chuyển đến phương thức gọi để xử lý. Ví dụ gọi phương thức:

public static void main(String[] args) {
    double result = 0;
    try {
        result = divide(10, 0);
    } catch (IllegalArgumentException e) {
        System.out.println("Error: " + e.getMessage());
    }
    System.out.println("Result: " + result);
}

Trong ví dụ này, phương thức chia() được gọi với các đối số 10 và 0, phương thức này sẽ đưa ra một ngoại lệ IllegalArgumentException do việc chia cho 0 là không thể. Ngoại lệ sẽ bị chặn bởi khối try-catch và thông báo lỗi sẽ được hiển thị. Chương trình sẽ trả về giá trị bằng 0 do ngoại lệ chấm dứt việc thực thi phương thức Divide() .