Mục đích của công nghệ phần mềm là: Xây dựng các module phần mềm tốt, đảm bảo chúng làm việc được trong mọi tình huống và dễ dàng thích ứng với mọi điều kiện. Muốn đảm bảo hệ thống có được những tính chất trên thì phải có cơ chế để xử lý được tất cả các ngoại lệ, các tình huống liên qua tới phạm vi xác định của các phần tử trong các cấu trúc dữ liệu. Một ngoại lệ (exception) trong chương trình Java là dấu hiệu chỉ ra rằng có
sựxuất hiện một điều kiện không bình thường nào đó.
Java cung cấp một cơ chế để kiểm tra một cách có hệ thống các điều kiện ngoại lệ. Để xử lý ngoại lệ trong Java, chúng ta sử dụng khối lệnh try- catch-finally.
5.4.1 Các khối lệnh try, catch và finally
Cấu trúc try-catch-finally cho phép sử dụng để xử lý các ngoại lệ có dạng:
try { // Khối try <Các câu lệnh>
} catch (<Kiểu ngoại lệ 1> <Tham biến 1>) { // Khối catch <Các câu lệnh xử lý khi xuất hiện kiểu ngoại lệ 1>
} . . .
catch (<Kiểu ngoại lệ n> <Tham biến n>) { // Khối catch <Các câu lệnh xử lý khi xuất hiện kiểu ngoại lệ n>
} finally {
< Các câu lệnh phải thực hiện đến cùng> // Khối finally }
Các ngoại lệ sẽ được cho qua trong quá trình thực hiện khối try và sẽ bị tóm lại để xử lý ở các khối catch tương ứng. Khối finally phải thực hiện đến cùng, bất luận có gặp phải ngoại lệ hay không.
Hình H5-6 Khối try-catch-finally Khối try
Khối try xác định ngữ cảnh cần xử lý sự kết thúc thực hiện của một khối lệnh. Sự kết thúc thực hiện của khối lệnh xuất hiện khi: Gặp phải một ngoại lệ, Hoặc thực hiện thành công khối try (không gặp ngoại lệ).
Thực hiện xong khối try và xử lý xong các ngoại lệ khi chúng xuất hiện thì phải thực hiện khối finally nếu nó được chỉ ra trong cấu trúc đó.
Khối catch
Lối ra của khối try khi gặp phải ngoại lệ có thể chuyển điều khiển chương trình đến khối catch. Khối này chỉ được sử dụng để xử lý ngoại lệ. Khi một khối catch được thực hiện thì các khối catch còn lại sẽ bị bỏ qua.
Trong trường hợp khối finally không xuất hiện thì chúng ta có cấu trúc try- catch.
Ví dụ 4.5 Cấu trúc try-catch
public class ChiaChoKhong { public void chia(){
int n1 = 20; int n2 = 0; try {
System.out.println(n1+" / "+n2+" = "+(n1/n2)); } catch (ArithmeticException e) { // (1)
System.out.println("Gap phai loi: "+e); // (2) }
System.out.println("Ket thuc ham chia()"); } // (3)
public static void main(String args[]){ new ChiaChoKhong().chia(); // (4)
System.out.println("Quay lai tu ham main!"); // (5) }
}
Khối finally
Khi khối finally có trong đặc tả khối try-catch-finally thì nó được đảm bảo phải thực hiện đến cùng bất luận trong khối try thực hiện như thế nào.
Ví dụ 4.6 Cấu trúc try-catch-finally
public class ChiaChoKhong1 { public void chia(){
int n1 = 20; int n2 = 0; try {
System.out.println(n1+" / "+n2+" = "+(n1/n2)); // (1) } catch (ArithmeticException e) { // (2)
System.out.println("Gap phai loi: "+e); }finally { // (3)
System.out.println("Nhung viec can thuc hien"); }
public static void main(String args[]){ new ChiaChoKhong1().chia(); // (5)
System.out.println("Quay lai tu ham main!"); // (6) }
}
Kết quả thực hiện của chương trình ChiaChoKhong1: Gap phai loi: java.lang.ArithmeticException: /by zero Nhung viec can thuc hien
Ket thuc ham chia() Quay lai tu ham main!
Lưu ý:
Khi không sử dụng khối catch để xử lý các ngoại lệ thì khối finally vẫn phải được thực hiện nhưng sau đó các phần còn lại của chương trình sẽ không được thực hiện nếu xuất hiện những ngoại lệ tệ hại như chia cho 0.
Ví dụ 5.7 Cấu trúc try-finally
public class ChiaChoKhong2 { public void chia(){
int n1 = 20; int n2 = 0; try {
System.out.println(n1+" / "+n2+" = "+(n1/n2)); // (1) }finally { // (2)
System.out.println("Nhung viec can thuc hien"); }
System.out.println("Ket thuc ham chia()"); // (3) }
public static void main(String args[]){ new ChiaChoKhong2().chia(); // (4)
System.out.println("Quay lai tu ham main!"); // (5) }
}
Kết quả thực hiện của chương trình ChiaChoKhong2: Nhung viec can thuc hien
Gap phai loi: java.lang.ArithmeticException: /by zero at ChiaChoKhong2.chia(ChiaChoKhong2.java)
ChiaChoKhong2.main(ChiaChoKhong2.java) Câu lệnh throw
Để tạm thời bỏ qua ngoại lệ chúng ta có thể sử dụng câu lệnh throw. Câu lệnh này có dạng như sau:
throw <Biểu thức tham chiếu đối tượng ngoại lệ>
<Biểu thức tham chiếu đối tượng ngoại lệ> là biểu thức xác định một đối tượng của lớp Throwable hoặc của một trong các lớp con của nó. Thông thường một đối tượng ngoại lệ sẽ được tạo ra trong câu lệnh throw để sau đó chúng sẽ được tóm lại và xử lý ở khối catch. Ví dụ câu lệnh throw new ChiaCho0Exception(“ / by zero”); Trong đó lớp
ChiaCho0Exception là lớp con của Exception có thể định nghĩa đơn giản như sau:
ChiaCho0Exception(String msg) {super(msg);} }
Khi một ngoại lệ xuất hiện và được cho qua thì sự thực hiện bình thường của chương trình sẽ bị treo lại để đi tìm khối catch tương ứng và xử lý ngoại lệ đó.
Sau đó khối finally được thực hiện nếu có. Nếu không tìm thấy bộ xử lý ngoại lệ tương ứng trong chương trình thì ngoại lệ đó được xử lý theo cơ chế xử lý ngoại lệ mặc định của hệ thống.
Ví dụ 5.8 Câu lệnh tạm thời cho qua ngoại lệ
class ChiaCho0Exception extends Exception {
ChiaCho0Exception(String msg) {super(msg);} }
public class ChiaChoKhong3 { public void chia(){
int n1 = 20; int n2 = 0; try { // (1)
if(n2 == 0)throw new ChiaCho0Exception(“/ by 0”);// (2) System.out.println(n1+" / "+n2+" = "+(n1/n2)); // (3) }catch (ChiaCho0Exception er){ // (4)
System.out.println("Gap loi: " +er); }finally {
System.out.println("Nhung viec can thuc hien");// (5) }
System.out.println("Ket thuc ham chia()"); // (6) }
public static void main(String args[]){ new ChiaChoKhong3().chia();
System.out.println("Quay lai tu ham main!"); // (7) }
}
Kết quả thực hiện của chương trình ChiaChoKhong3: Gap phai loi: ChiaChoException: /by zero
Nhung viec can thuc hien Ket thuc ham chia() Quay lai tu ham main!
Trong ví dụ 4.8, khối try (1) trong hàm chia() tạm thời cho qua ngoại lệ xuất hiện ở (2). Lưu ý phần còn lại (3) của khối try không được thực hiện.
Khối finally (5) được thực hiện sau đó tiếp tục thực hiện bình thường các lệnh (6), (7).
Mệnh đề throws
Khi thiết kế các hàm thành phần, chúng ta có thể sử dụng mệnh đề throws để tạm thời cho qua ngoại lệ mà thực hiện một số công việc cần thiết khác. Những hàm này lại được sử dụng theo cấu trúc try-catch-finally sau đó để xử lý các ngoại lệ khi chúng xuất
<Thuộc tính của hàm> <tên hàm>(<Danh sách các tham biến>) throws <Danh sách các kiểu ngoại lệ> { /* ... */}
Trong đó <Danh sách các kiểu ngoại lệ> là các lớp xử lý ngoại lệ được kế thừa từ lớp Exception và được phân tách bởi dấu ‘,’. Ví dụ,
class A{
protected void classMethA() throws FirstException, SecondException{ /* . . . */
}
Ví dụ 4.9 Mô tả cách sử dụng mệnh đề throws trong định nghĩa hàm
class ChiaCho0Exception extends Exception { // (1) ChiaCho0Exception(String msg) {super(msg);} }
public class ChiaChoKhong4 {
public void chia() throws ChiaCho0Exception { // (2) int n1 = 20;
int n2 = 0;
if(n2 == 0)throw new ChiaCho0Exception(“/ by 0”); // (3) System.out.println(n1+" / "+n2+" = "+(n1/n2));
System.out.println("Ket thuc ham chia()"); }
public static void main(String args[]){ try {
new ChiaChoKhong3().chia(); // (4) }catch (ChiaCho0Exception er){
System.out.println("Trong main() gap loi: " +er); }finally {
System.out.println("Nhung viec can thuc hien");// (5) }
System.out.println("Quay lai tu ham main!"); // (7) }
}
Chương trình thực hiện và cho kết quả:
Trong main() gap loi: ChiaCho0Exception: / by 0 Nhung viec can thuc hien
Quay lai tu ham main!
Lưu ý:
Khi xây dựng hệ thống thường có rất nhiều loại lỗi (ngoại lệ) khác nhau có thể xảy ra. Để tiện lợi cho việc kiểm soát chúng, người lập
trình nên đặt tên cho từng loại ngoại lệ đó cho phù hợp với ngữ cảnh mà chúng xuất hiện và sao cho dễ nhớ.
Bài tập
1. Viết chương trình tạo dãy số nguyên ngẫu nhiên có giá trị khác nhau. 2. Viết chương trình giải phương trình bậc II dạng:
ax2 + bx + c = 0
3. Viết chương trình giải bất phương trình bậc II dạng ax2 + bx + c > 0
5. Viết chương trình mô phỏng một máy tính có thể dùng để thực hiện các phép tính số học. tính số học.
Chương VI: Lớp và các thành phần của lớp các đối tượng
Nội dung:
Cấu trúc lớp và khai báo các thành phần của lớp,
Định nghĩa hàm thành phần và cơ chế nạp chồng, viết đè trong Java, Các thuộc tính kiểm soát truy nhập các thành phần của lớp,
Toán tử tạo lập các đối tượng, Kế thừa giữa các lớp đối tượng,
Các giao diện (interface) và sự mở rộng quan hệ kế thừa (đa kế thừa) trong Java.