Tài liệu Bài giảng lập trình hướng đối tượng

HỌC VIỆN CÔNG NGHỆ BƯU CHÍNH VIỂN THÔNG CƠ SỞ TẠI TP. HỒ CHÍ MINH Bài giảng: LẬP TRÌNH HƯỚNG ĐỐI TƯỢNG Tài liệu dùng cho hệ Đại học ngành Công Nghệ Thông Tin Đã được Hội đồng khoa học khoa Thông qua ngày 18/09/2010 Biên soạn :Ths. Bùi Công Giao LƯU HÀNH NỘI BỘ Tp. Hồ Chí Minh – Năm 2010 Lời nói đầu Lập trình là một kỹ năng rất cần thiết cho sinh viên ngành Công nghệ thông tin. Sau khi đã học qua lập trình căn bản với ngôn ngữ C, sinh viên sẽ được tiếp cận với một phương pháp lập trình theo tư duy mới, gần với thế giới thực hơn, phù hợp với các dự án phần mềm lớn, đó là lập trình hướng đối tượng. Nội dung môn học này bao gồm những khái niệm, mô hình về đối tượng và phương pháp lập trình hướng đối tượng bằng ngôn ngữ lập trình Java. Các đặc trưng quan trọng của lập trình hướng đối tượng như đóng gói, kế thừa, đa hình…và các quan hệ lớp; xử lý vào/ra, xử lý ngoại lệ, lập trình luồng xử lý và giao diện sẽ được thể hiện trong Java. Bài giảng này được biên soạn chủ yếu dựa vào hai quyển sách : Beginning Java Objects: From Concepts to Code, Second Edition, Apress, 2005 của Jacquie Barker và Bài giảng Lập trình Hướng đối tượng, Học viện Công nghệ Bưu chính Viễn thông của Trần Đình Quế và Nguyễn Mạnh Hùng, Người soạn chân thành cảm ơn các tác giả trên. Mục lục Chương 1.  Tổng quan về lập trình hướng đối tượng ................... 1  1.1 Phương pháp tiếp cận của lập trình truyền thống ......................... 1  1.1.1 Lập trình tuyến tính............................................................................. 1  1.1.2 Lập trình cấu trúc ................................................................................ 1  1.2 Phương pháp tiếp cận lập trình hướng đối tượng .......................... 3  1.3 Các đặc trưng của lập trình hướng đối tượng ................................ 3  1.3.1 Tính đóng gói dữ liệu.................................................................................. 3  1.3.2 Tính kế thừa ................................................................................................ 4  1.3.3 Tính đa hình ................................................................................................ 4  1.4 Trừu tượng hóa ................................................................................. 4  1.4.1 Tổ chức trừu tượng theo sự phân cấp lớp ......................................... 4  1.4.2 Trừu tượng hóa – cơ sở của phát triển phần mềm ........................... 5  1.5 Xu hướng phát triển của lập trình hướng đối tượng ..................... 6  1.5.1 Lập trình hướng thành phần (Component-oriented programmingCOP) ................................................................................................................ 6  1.5.2 Lập trình hướng tác nhân ................................................................... 7  1.5.3 Lập trình hướng khía cạnh ................................................................. 7  Chương 2.  Cơ bản ngôn ngữ lập trình Java ................................. 9  2.1 Đặc trưng của ngôn ngữ Java .......................................................... 9  2.2 Kiến trúc chương trình và cơ chế thực thi của Java .................... 14  2.3 Các kiểu dữ liệu cơ bản và biến ..................................................... 18  2.3.1 Kiểu dữ liệu cơ bản ............................................................................ 18  2.3.2 Biến ...................................................................................................... 19  2.3.2.1 Khai báo biến .........................................................................................19  2.3.2.2 Phạm vi hoạt động của biến ..................................................................20  2.3.2.3 Khởi tạo biến ..........................................................................................20  2.3.2.4 Ép kiểu ....................................................................................................20  2.4 Các toán tử và biểu thức................................................................. 21  2.4.1 Các toán tử .......................................................................................... 21  2.4.2 Biểu thức ............................................................................................. 25  2.5 Các cấu trúc lệnh ............................................................................ 26  2.5.1 Lệnh if-else .......................................................................................... 26  2.5.2 Lệnh switch-case ................................................................................ 27  2.5.3 Vòng lặp while .................................................................................... 28  2.5.4 Vòng lặp do-while............................................................................... 29  2.5.5 Vòng lặp for ........................................................................................ 29  2.6 Phong cách lập trình ....................................................................... 31  2.7 Case Study ....................................................................................... 33  Chương 3.  Đối tượng và lớp ......................................................... 38  3.1 Phân rã phần mềm theo cách tiếp cận hướng đối tượng ............. 38  3.2 Khái niệm đối tượng ....................................................................... 39  3.3 Khái niệm lớp .................................................................................. 42  3.4 Khái niệm đóng gói ......................................................................... 43  3.5 Biến tham chiếu ............................................................................... 44  3.6 Khởi tạo đối tượng .......................................................................... 45  Chương 4.  Tương tác giữa các đối tượng.................................... 50  4.1 Cộng tác giữa các đối tượng ........................................................... 50  4.2 Thuộc tính........................................................................................ 51  4.3 Phương thức .................................................................................... 52  4.3.1 Khai báo phương thức ....................................................................... 52  4.3.2 Biến this ............................................................................................... 53  4.3.3 Gọi phương thức ................................................................................ 53  4.3.4 Nạp chồng phương thức .................................................................... 54  4.3.5 Phương thức xây dựng....................................................................... 54  4.3.6 Che dấu thông tin ............................................................................... 56  4.4 Truyền thông điệp giữa các đối tượng .......................................... 57  Chương 5.  Quan hệ giữa các đối tượng....................................... 61  5.1 Kết hợp và liên kết .......................................................................... 61  5.2 Kế thừa ............................................................................................ 63  5.3 Đa hình ............................................................................................. 64  5.4 Lớp trừu tượng ............................................................................... 71  5.5 Giao tiếp ........................................................................................... 74  5.6 Tính chất tĩnh .................................................................................. 76  5.7 Kiểu liệt kê ....................................................................................... 79  5.8 Case Study ....................................................................................... 83  Chương 6.  Tập đối tượng ............................................................. 95  6.1 Khái niệm tập đối tượng................................................................. 95  6.2 Ba kiểu tập đối tượng cơ bản ......................................................... 95  6.3 Mảng ................................................................................................ 97  6.4 Các loại tập đối tượng thường gặp .............................................. 100  6.4.1 LinkedList ......................................................................................... 100  6.4.2 HashMap ........................................................................................... 102  6.4.3 TreeMap ............................................................................................ 104  6.4.4 HashSet.............................................................................................. 106  6.4.5 TreeSet .............................................................................................. 107  6.5 Tạo kiểu tập hợp ........................................................................... 108  6.6 Phương thức trả về kiểu tập hợp ................................................. 110  Chương 7.  Xử lý ngoại lệ ............................................................ 113  7.1 Giới thiệu ngoại lệ ......................................................................... 113  7.2 Cơ chế xử lý ngoại lệ ..................................................................... 115  7.2.1 Khối try ............................................................................................. 115  7.2.2 Khối catch ......................................................................................... 115  7.2.3 Khối finally ....................................................................................... 119  7.3 Bắt các ngoại lệ .............................................................................. 121  7.4 Phân cấp lớp ngoại lệ .................................................................... 126  7.5 Các điểm cần lưu ý thêm về ngoại lệ ........................................... 129  7.5.1 Bắt ngoại lệ tổng quát ...................................................................... 129  7.5.2 Trình biên dịch Java yêu cầu phải có xử lý ngoại lệ..................... 129  7.5.3 Tận dụng xử lý ngoại lệ để làm rõ lỗi phát sinh ............................ 131  7.5.4 try/catch lồng nhau .......................................................................... 131  7.5.5 Kiểu ngoại lệ do người dùng định nghĩa ........................................ 132  7.5.6 Ném nhiều kiểu ngoại lệ .................................................................. 134  7.6 Case Study ..................................................................................... 134  Chương 8.  Xử lý vào/ra .............................................................. 137  8.1 Luồng vào/ra ................................................................................. 137  8.1.1 Giới thiệu luồng vào/ra .................................................................... 137  8.1.2 Luồng byte ........................................................................................ 138  8.1.3 Luồng ký tự ....................................................................................... 140  8.1.4 Luồng bộ đệm ................................................................................... 141  8.2 Scanning và Formatting ............................................................... 143  8.2.1 Scanning ............................................................................................ 143  8.2.2 Formatting ........................................................................................ 146  8.3 Vào ra từ chế độ dòng lệnh .......................................................... 148  8.3.1 Vào ra qua luồng chuẩn .................................................................. 148  8.3.2 Vào ra qua Console .......................................................................... 154  8.4 Làm việc với CSDL ....................................................................... 157  8.4.1 JDBC ................................................................................................. 157  8.4.1.1 Giới thiệu JDBC ..................................................................................157  8.4.1.2 Kiến trúc JDBC ...................................................................................157  8.4.2 MySQL và Java ................................................................................ 158  8.4.2.1 Cài đặt Connector/J - JDBC Driver của MySQL ............................158  8.4.2.2 Kiểm tra Connector/J..........................................................................159  8.4.2.3 Thực hiện các câu truy vấn.................................................................160  Chương 9.  Lập trình giao diện................................................... 166  9.1 Giao diện với các đối tượng cơ bản ............................................. 166  9.1.1 Các đối tượng container cơ bản ...................................................... 166  9.1.1.1 Frame ....................................................................................................166  9.1.1.2 Panel ......................................................................................................167  9.1.1.3 Dialog ....................................................................................................168  9.1.2 Các đối tượng component cơ bản ................................................... 169  9.1.2.1 Label .....................................................................................................169  9.1.2.2 TextField và TextArea ........................................................................170  9.1.2.3 Button ...................................................................................................172  9.1.3 Xử lý sự kiện ..................................................................................... 173  9.2 Giao diện với các đối tượng Multimedia ..................................... 180  9.2.1 Ô đánh dấu và nút chọn .................................................................. 180  9.2.2 Lựa chọn ........................................................................................... 182  9.2.3 Danh sách .......................................................................................... 184  9.3 Các kỹ thuật trình bày.................................................................. 186  9.3.1 Trình bày Flow Layout .................................................................... 186  9.3.2 Trình bày Grid Layout .................................................................... 187  9.3.3 Trình bày Border Layout ................................................................ 189  9.3.4 Trình bày GridBag Layout ............................................................. 190  9.3.5 Trình bày Null Layout ..................................................................... 192  9.4 Applet ............................................................................................. 193  9.4.1 Cấu trúc của một Applet ................................................................. 194  9.4.2 Sử dụng Applet ................................................................................. 195  9.4.3 Truyền tham số cho Applet ............................................................. 199  9.5 SWING........................................................................................... 200  9.5.1 Mở rộng các đối tượng component................................................. 201  9.5.2 Mở rộng các đối tượng container ................................................... 202  9.6 Case Study ..................................................................................... 210  Chương 10.  Luồng xử lý .............................................................. 219  10.1 Giới thiệu luồng ........................................................................... 219  10.2 Tạo và quản lý luồng .................................................................. 220  10.2.1 Tạo luồng ........................................................................................ 220  10.2.2 Phương thức của lớp luồng ........................................................... 223  10.2.3 Quyền ưu tiên của luồng................................................................ 225  10.2.4 Luồng ngầm .................................................................................... 226  10.2.5 Đa luồng với Applet ....................................................................... 227  10.3 Nhóm luồng ................................................................................. 229  10.3.1 Giới thiệu nhóm luồng ................................................................... 229  10.3.2 Sự đồng bộ luồng ............................................................................ 233  10.3.3 Mã đồng bộ ..................................................................................... 233  10.3.4 Sử dụng khối đồng bộ .................................................................... 235  10.3.5 Kỹ thuật đợi – thông báo ............................................................... 237  10.3.6 Sự bế tắt .......................................................................................... 240  10.4 Thu rác ......................................................................................... 242  Tham khảo ...................................................................................... 247  Danh sách hình Hình 1.1 Sơ đồ phân cấp trừu tượng của các đối tượng tự nhiên. .................................. 5  Hình 2.1 Cách biên dịch truyền thống .......................................................................... 10  Hình 2.2 Dịch chương trình Java.................................................................................. 11  Hình 2.3 Máy ảo Java thực hiện mã bytecode độc lập môi trường hoạt động ............. 12  Hình 2.4 Cùng mã bytecode có thể được hiểu bởi hai máy ảo..................................... 13  Hình 2.5 Phân tích một chương trình Java đơn giản .................................................... 14  Hình 3.1 Phân rã ứng dụng từ trên xuống. ................................................................... 38  Hình 3.2 Gắn ứng dụng từ dưới lên. ............................................................................. 39  Hình 3.3 Sử dụng một biến tham chiếu để chỉ tới đối tượng trong bộ nhớ. ................. 45  Hình 3.4 Hai biến tham chiếu tới cùng một đối tượng. ................................................ 46  Hình 3.5 Chuyển y tham chiếu tới Student thứ hai. ..................................................... 46  Hình 3.6 Chuyển x tham chiếu tới Student thứ hai. ..................................................... 47  Hình 3.7 Đối tượng Student mồ côi. ............................................................................. 47  Hình 4.1 Các đối tượng trong hệ thống phải cộng tác với nhau để hoàn tất sứ mệnh SRS ............................................................................................................................... 51  Hình 4.2 Thông điệp được truyền qua lại giữa các đối tượng Course và Student ....... 58  Hình 4.3 Người yêu cầu chỉ thấy chi tiết bên ngoài của việc trao đổi thông điệp. ...... 58  Hình 5.1 Kết hợp ba ngôi ............................................................................................. 62  Hình 5.2 Một thể hiện tương đương bằng ba kết hợp hai ngôi .................................... 62  Hình 6.1 Hầu hết tập hợp tự động co lại khi một phần tử bị lấy ra .............................. 96  Hình 6.2 Dùng khoá để truy cập trực tiếp đối tượng trong tập hợp từ điển ................. 96  Hình 6.3 Các tập hợp không phải là bộ cho phép nhiều tham chiếu tới cùng một đối tượng. ............................................................................................................................ 97  Hình 7.1 Khi máy ảo Java ném một ngoại lệ, như phát ra một pháo để thông báo cho ứng dụng một vấn đề phát sinh................................................................................... 114  Hình 7.2 Nếu không có ngoại lệ được ném ra trong khối try, tất cả các khối catch được bỏ qua. ........................................................................................................................ 117  Hình 7.3 Nếu một ngoại lệ phát sinh, khồi catch đầu tiên chặn bắt, nếu có, được thực thi, và phần còn lại được bỏ qua. ................................................................................ 118  Hình 7.4 Máy ảo Java theo dõi việc thứ tự các phương thức được gọi bằng cách tạo chồng gọi (call stack).................................................................................................. 123  Hình 7.5 Khi một phương thức chấm dứt, nó bị lấy ra khỏi chồng. .......................... 123  Hình 7.6 Khối lệnh try/catch trong trong phương thức methodY nhận biết ngoại lệ trong mức hiện hành của chồng gọi. .......................................................................... 123  Hình 7.7 Ngoại lệ thoát khỏi p.methodY() và chuyển xuống s.methodX() xử lý ...... 124  Hình 7.8 NullPointerException thông qua chồng gọi được chuyển tới phương thức main. ........................................................................................................................... 125  Hình 7.9 Nếu ứng dụng bỏ qua xử lý ngoại lệ, máy ảo Java chấm dứt ứng dụng và báo cáo ngoại lệ tới cửa cửa sổ dòng lệnh cho người sử dụng để quan sát. ..................... 126  Hình 7.10 Lớp java.lang.Exception có nhiều lớp con ................................................ 127  Hình 7.11 Cây thừa kế của kiểu ngoại lệ java.sql.DataTruncation ............................ 127  Hình 7.12 Kết quả demo của NumberOfDigits.java .................................................. 135  Hình 8.1 Đọc dữ liệu vào chương trình. ..................................................................... 137  Hình 8.2 Viết dữ liệu từ chương trình. ....................................................................... 138  Hình 8.3 Luồng byte vào ra đơn giản ......................................................................... 139  Hình 8.4 Các thành phần đặc tả qui cách. .................................................................. 148  Hình 9.1 Kết quả demo Frame ................................................................................... 167  Hình 9.2 Kết quả demo Panel ..................................................................................... 168  Hình 9.3 Kết quả demo Dialog ................................................................................... 169  Hình 9.4 Kết quả demo Label..................................................................................... 170  Hình 9.5 Kết quả demo Text ...................................................................................... 172  Hình 9.6 Kết quả demo Button ................................................................................... 173  Hình 9.7 Kết quả demo sự kiện .................................................................................. 179  Hình 9.8 Kết quả demo Radio Button ........................................................................ 182  Hình 9.9 Kết quả demo Choice Button ...................................................................... 184  Hình 9.10 Kết quả demo Listbox ............................................................................... 186  Hình 9.11 Kết quả demo Flow layout ........................................................................ 187  Hình 9.12 Kết quả demo Grid layout ......................................................................... 188  Hình 9.13 Kết quả demo Border layout..................................................................... 190  Hình 9.14 Kết quả demo Gridbag layout.................................................................... 192  Hình 9.15 Kết quả demo Null layout.......................................................................... 193  Hình 9.16 Kết quả demo Applet ................................................................................. 195  Hình 9.17 Kết quả demo Applet bảng tính ................................................................. 198  Hình 9.18 Kết quả demo Applet có tham số .............................................................. 200  Hình 9.19 Kết quả demo JButton ............................................................................... 202  Hình 9.20 Kết quả demo gắn các đối tượng vào các tầng .......................................... 205  Hình 9.21 Kết quả demo JMenu ................................................................................. 210  Hình 9.22 Kết quả demo Case Study.......................................................................... 216  Hình 10.1 Vòng đời của luồng ................................................................................... 220  Hình 10.2 Đa luồng với Applet .................................................................................. 228  Danh sách bảng Bảng 2.1 Các toán tử số học ......................................................................................... 22  Bảng 2.2 Các toán tử bit ............................................................................................... 23  Bảng 2.3 Các toán tử quan hệ. ...................................................................................... 24  Bảng 2.4 Các toán tử logic ........................................................................................... 24  Bảng 2.5 Thứ tự ưu tiên các toán tử ............................................................................. 25  Bảng 4.1 Phạm vi truy cập của các thành viên của lớp ................................................ 52  Bảng 7.1 Danh sách một số ngoại lệ .......................................................................... 128  Bảng 10.1 Các phương thức của một lớp luồng ......................................................... 224  Thuật ngữ viết tắt API Application Programming Interface CSDL Cơ sở dữ liệu CTDL Cấu trúc dữ liệu GUI Graphic User Interface JDBC Java DataBase Connectivity JFC Java Foundation Class JVM Java Virtual Machine LIFO Last in, First out ODBC Open Database Connectivity RDBMS Relational Database Management Systems SRS Student Registration System Chương 1: Tổng quan về lập trình hướng đối tượng Chương 1. Tổng quan về lập trình hướng đối tượng Nội dung chương này nhằm giới thiệu một cách tổng quan về cách tiếp cận hướng đối tượng. Nội dung trình bày bao gồm:  Giới thiệu về cách tiếp cận của lập trình truyền thống.  Giới thiệu cách tiếp cận của lập trình hướng đối tượng.  Sự trừu tượng hóa là cơ sở của phát triển phần mềm hướng đối tượng.  Nêu các đặc trưng của lập trình hướng đối tượng.  Xu hướng hiện nay của lập trình hướng đối tượng. 1.1 Phương pháp tiếp cận của lập trình truyền thống Lập trình truyền thống đã trải qua hai giai đoạn:  Giai đoạn sơ khai, khi khái niệm lập trình mới ra đời, là lập trình tuyến tính.  Giai đoạn tiếp theo, là lập trình hướng cấu trúc. 1.1.1 Lập trình tuyến tính Đặc trưng cơ bản của lập trình tuyến tính là tư duy theo lối tuần tự. Chương trình sẽ được thực hiện tuần tự từ đầu đến cuối, lệnh này kế tiếp lệnh kia cho đến khi kết thúc chương trình. Đặc trưng Lập trình tuyến tính có hai đặc trưng:  Đơn giản: chương trình được tiến hành đơn giản theo lối tuần tự, không phức tạp.  Đơn luồng: chỉ có một luồng (thread) công việc duy nhất, và các công việc được thực hiện tuần tự trong luồng đó. Tính chất  Ưu điểm: Do tính đơn giản, lập trình tuyến tính có ưu điểm là chương trình đơn giản, dễ hiểu. Lập trình tuyến tính được ứng dụng cho các chương trình đơn giản.  Nhược điểm: Với các ứng dụng phức tạp, người ta không thể dùng lập trình tuyến tính để giải quyết. Ngày nay, lập trình tuyến tính chỉ tồn tại trong phạm vi các mô đun nhỏ nhất của các phương pháp lập trình khác. Ví dụ trong một chương trình con của lập trình cấu trúc, các lệnh cũng được thực hiện theo tuần tự từ đầu đến cuối chương trình con. 1.1.2 Lập trình cấu trúc Trong lập trình hướng cấu trúc, chương trình chính được chia nhỏ thành các chương trình con và mỗi chương trình con thực hiện một công việc xác định. Chương trình Biên soạn : Bùi Công Giao --------------------------------------- 1 -------------------------------------- Chương 1: Tổng quan về lập trình hướng đối tượng chính sẽ gọi đến chương trình con theo một giải thuật, hoặc một cấu trúc được xác định trong chương trình chính. Các ngôn ngữ lập trình cấu trúc phổ biến là Pascal, C và C++. Riêng C++ ngoài việc có đặc trưng của lập trình cấu trúc do kế thừa từ C, còn có đặc trưng của lập trình hướng đối tượng. Cho nên C++ còn được gọi là ngôn ngữ lập trình nửa cấu trúc, nửa hướng đối tượng. Đặc trưng Đặc trưng cơ bản nhất của lập trình cấu trúc thể hiện ở mối quan hệ: Chương trình = CTDL + Giải thuật Trong đó:  CTDL là cách tổ chức dữ liệu, cách mô tả bài toán dưới dạng ngôn ngữ lập trình  Giải thuật là một quy trình để thực hiện một công việc xác định Trong chương trình, giải thuật có quan hệ phụ thuộc vào CTDL:  Một CTDL chỉ phù hợp với một số hạn chế các giải thuật.  Nếu thay đổi CTDL thì phải thay đổi giải thuật cho phù hợp.  Một giải thuật thường phải đi kèm với một CTDL nhất định. Tính chất  Mỗi chương trình con có thể được gọi thực hiện nhiều lần trong một chương trình chính.  Các chương trình con có thể được gọi đến để thực hiện theo một thứ tự bất kỳ, tuỳ thuộc vào giải thuật trong chương trình chính mà không phụ thuộc vào thứ tự khai báo của các chương trình con.  Các ngôn ngữ lập trình cấu trúc cung cấp một số cấu trúc lệnh điều khiển chương trình. Ưu điểm  Chương trình sáng sủa, dễ hiểu, dễ theo dõi.  Tư duy giải thuật rõ ràng. Nhược điểm  Lập trình cấu trúc không hỗ trợ việc sử dụng lại mã nguồn: Giải thuật luôn phụ thuộc chặt chẽ vào CTDL, do đó, khi thay đổi CTDL, phải thay đổi giải thuật, nghĩa là phải viết lại chương trình.  Không phù hợp với các phần mềm lớn: tư duy cấu trúc với các giải thuật chỉ phù hợp với các bài toán nhỏ, nằm trong phạm vi một mô đun của chương trình. Với dự án phần mềm lớn, lập trình cấu trúc tỏ ra không hiệu quả trong việc giải quyết mối quan hệ vĩ mô giữa các mô đun của phần mềm. Biên soạn : Bùi Công Giao --------------------------------------- 2 -------------------------------------- Chương 1: Tổng quan về lập trình hướng đối tượng Vấn đề Vấn đề cơ bản của lập trình cấu trúc là bằng cách nào để phân chia chương trình chính thành các chương trình con cho phù hợp với yêu cầu, chức năng và mục đích của mỗi bài toán. 1.2 Phương pháp tiếp cận lập trình hướng đối tượng Xuất phát từ hai hạn chế chính của phương pháp lập trình cấu trúc:  Không quản lý được sự thay đổi dữ liệu khi có nhiều chương trình cùng thay đổi một biến chung. Vấn đề này đặc biệt nghiêm trọng khi các ứng dụng ngày càng lớn, người ta không thể kiểm soát được sự truy nhập đến các biến dữ liệu chung.  Không tiết kiệm được tài nguyên con người: Giải thuật gắn liền với CTDL, nếu thay đổi CTDL, sẽ phải thay đổi giải thuật, và do đó, phải viết lại mã chương trình từ đầu. Để khắc phục được hai hạn chế này khi giải quyết các bài toán lớn, người ta xây dựng một phương pháp tiếp cận mới, là phương pháp lập trình hướng đối tượng, với hai mục đích chính:  Đóng gói dữ liệu để hạn chế sự truy nhập tự do vào dữ liệu, không quản lý được.  Cho phép sử dụng lại mã nguồn, hạn chế việc phải viết lại mã từ đầu cho các chương trình. Ngôn ngữ lập trình hướng đối tượng phổ biến hiện nay là Java và C++. Tuy nhiên, C++ mặc dù cũng có những đặc trưng cơ bản của lập trình hướng đối tượng nhưng vẫn không phải là ngôn ngữ lập trình thuần hướng đối tượng. Java thật sự là một ngôn ngữ lập trình thuần hướng đối tượng. 1.3 Các đặc trưng của lập trình hướng đối tượng 1.3.1 Tính đóng gói dữ liệu Dữ liệu luôn được tổ chức thành các thuộc tính của lớp đối tượng. Việc truy nhập đến dữ liệu phải thông qua các phương thức của đối tượng lớp. Trong một đối tượng, dữ liệu hay thao tác hay cả hai có thể là riêng (private) hoặc chung (public) của đối tượng đó. Thao tác hay dữ liệu riêng là thuộc về đối tượng đó chỉ được truy cập bởi các thành phần của đối tượng, điều này nghĩa là thao tác hay dữ liệu riêng không thể truy cập bởi các phần khác của chương trình tồn tại ngoài đối tượng. Khi thao tác hay dữ liệu là chung, các phần khác của chương trình có thể truy cập nó mặc dù nó được định nghĩa trong một đối tượng. Các thành phần chung của một đối tượng dùng để cung cấp một giao diện có điều khiển cho các thành thành riêng của đối tượng. Cơ chế đóng gói (encapsulation) là phương thức tốt để thực hiện cơ chế che dấu thông tin so với các ngôn ngữ lập trình cấu trúc. Biên soạn : Bùi Công Giao --------------------------------------- 3 -------------------------------------- Chương 1: Tổng quan về lập trình hướng đối tượng 1.3.2 Tính kế thừa Cho phép sử dụng lại mã nguồn. Các lớp đối tượng có thể kế thừa (inheritance) từ các lớp đối tượng khác. Khi đó, trong các lớp kế thừa, có thể sử dụng các phương thức hoạt động của các lớp bị kế thừa, mà không cần phải định nghĩa lại. Việc cho phép sử dụng lại mã nguồn được thực hiện thông qua cơ chế kế thừa trong lập trình hướng đối tượng. Theo đó:  Các lớp có thể được kế thừa nhau để tận dụng các thuộc tính, các phương thức của nhau.  Trong lớp dẫn xuất (lớp kế thừa) có thể sử dụng lại các phương thức của lớp cơ sở (lớp bị lớp khác kế thừa) mà không cần thiết phải cài đặt lại mã nguồn.  Ngay cả khi lớp dẫn xuất định nghĩa lại các phương thức cho mình, lớp cơ sở cũng không bị ảnh hưởng và không phải sửa lại bất kỳ một đoạn mã nguồn nào. 1.3.3 Tính đa hình Khả năng để cho một thông điệp có thể thay đổi cách thực hiện của nó theo lớp cụ thể của đối tượng nhận thông điệp. Khi một lớp dẫn xuất được tạo ra, nó có thể thay đổi cách thực hiện các phương thức nào đó mà nó thừa hưởng từ lớp cơ sở của nó. Một thông điệp khi được gởi đến một đối tượng của lớp cơ sở, sẽ dùng phương thức đã định nghĩa cho nó trong lớp cơ sở. Nếu một lớp dẫn xuất định nghĩa lại một phương thức thừa hưởng từ lớp cơ sở của nó thì một thông điệp có cùng tên với phương thức này, khi được gởi tới một đối tượng của lớp dẫn xuất sẽ gọi phương thức đã định nghĩa cho lớp dẫn xuất. Như vậy đa hình (polymorphism) là khả năng cho phép gởi cùng một thông điệp đến những đối tượng khác nhau có cùng chung một đặc điểm, nói cách khác thông điệp được gởi đi không cần biết thực thể nhận thuộc lớp nào, chỉ biết rằng tập hợp các thực thể nhận có chung một tính chất nào đó. Chẳng hạn, thông điệp vẽ hình được gởi đến cả hai đối tượng hình hộp và hình tròn. Trong hai đối tượng này đều có chung phương thức vẽ hình, tuy nhiên tuỳ theo thời điểm mà đối tượng nhận thông điệp, hình tương ứng sẽ được vẽ lên. 1.4 Trừu tượng hóa 1.4.1 Tổ chức trừu tượng theo sự phân cấp lớp Thậm chí mặc dù nảo con người giỏi ở sự trừu tượng các khái niệm như bản đồ đường đi và cảnh quan, vẫn còn số lượng rất lớn các công việc trừu tượng hoá riêng lẻ mà chúng ta thường gặp trong cuộc sống. Để đối phó sự phức tạp này con người phải sắp xếp thông tin một cách có hệ thống theo các tiêu chuẩn nào đó; Xử lý này gọi là sự phân lớp (classification). Ví dụ như khoa học đã phân cấp theo lớp tất cả đối tượng tự nhiên thuộc về động vật, hoặc cây, hoặc khoáng sản. Để được phân là động vật, nó phải thoả điều kiện sau: Biên soạn : Bùi Công Giao --------------------------------------- 4 -------------------------------------- Chương 1: Tổng quan về lập trình hướng đối tượng  Vật thể sống.  Tự di chuyển.  Phản ứng khi bị kích thích. Qui luật cho một đối tượng là cây thì hơi khác:  Vật thể sống (như động vật).  Không có hệ thần kinh.  Có màn cellulose. Sau khi phân lớp đơn giản như trên ta có thể thêm vài qui luật để có các loại động vật cụ thể hơn cho đến khi có một sự phân cấp theo sự trừu tượng từ cao (đỉnh) xuống thấp (đáy). Sơ đồ phân cấp trừu tượng của các đối tượng tự nhiên được thể hiện như hình 1.1. Các đối tượng tự nhiên Cây Động vật có vú Chó Cá Bò Động vật Chim Bò sát Khoáng sản Lưởng cư Côn trùng Khỉ … Hình 1.1 Sơ đồ phân cấp trừu tượng của các đối tượng tự nhiên. 1.4.2 Trừu tượng hóa – cơ sở của phát triển phần mềm Khi ghi nhận các yêu cầu cho một dự án phần mềm, chúng ta thường bắt đầu bằng cách thu thập thông tin chi tiết về tình hình thực tế mà trên đó hệ thống sẽ hoạt động. Những chi tiết này thường là một sự tổng hợp của  Thông tin từ những người sử dụng hệ thống được chúng ta phỏng vấn.  Những hoạt động mà chúng ta quan sát từ nghiệp vụ hàng ngày của người sử dụng hệ thống. Kế đến chúng ta phải chọn lọc ra những chi tiết nào liên quan tới mục đích sử dụng hệ thống. Việc này là cần thiết vì chúng ta không thể tự động hoá tất cả hệ thống nghiệp vụ bằng phần mềm! Việc bao gồm quá nhiều chi tiết sẽ làm hệ thống phức tạp và khó Biên soạn : Bùi Công Giao --------------------------------------- 5 -------------------------------------- Chương 1: Tổng quan về lập trình hướng đối tượng khăn hơn trong việc thiết kế, kiểm tra chương trình, dò lỗi, tạo sưu liệu, bảo trì và mở rộng chương trình sau này. Sự trừu tưởng hoá sẽ giúp người phân tích hệ thống có được các nét đặc trưng của hệ thống trong miền (domain) bài toán, tập trung vào vấn đề của hệ thống dự định phát triển. Như khi thể hiện một người trong chương trình, màu mắt của họ có quan trọng không? Về gien ? Lương ? Sở thích ? Câu trả lời là bất kỳ đặc tính nào của người có thể liên quan hay không liên quan tuỳ thuộc vào hệ thống mà ta định phát triển là  Chương trình tính lương  Chương trình tiếp thị theo tuổi tác  CSDL bệnh nhân nhãn khoa  Hệ thống theo dõi những kẻ bị truy nã Một khi đã xác định các đặc trưng quan trọng của một tình huống, ta cần chuẩn bị một mô hình hoá cho nó. Mô hình hoá là xử lý nhằm phát triển một khuôn mẫu để tạo ra một thứ gì đó; ví dụ như bản thiết kế ngôi nhà, sơ đồ mạch điện, một khuôn bánh. Một mô hình đối tượng của hệ thống phần mềm là một mẫu như vậy. Mô hình hoá và trừu tượng hoá luôn đi với nhau vì một mô hình là sự mô tả đồ hoạ hay vật lý của trừu tượng; Trước khi mô hình vật gì đó một cách có hiệu quả, ta phải xác định các chi tiết cần thiết của chủ thể cần được mô hình. 1.5 Xu hướng phát triển của lập trình hướng đối tượng 1.5.1 Lập trình hướng thành phần (Component-oriented programming-COP) Xuất phát từ lập trình hướng đối tượng, tư duy lập trình hướng thành phần theo ý tưởng:  Giải quyết bài toán bằng cách xây dựng một tập các thành phần (component) có tính độc lập tương đối với nhau. Mỗi thành phần đảm nhiệm một phần công việc nhất định.  Sau đó, người ta ghép các thành phần với nhau để thu được một phần mềm thoả mãn một tập các yêu cầu xác định. Với lập trình hướng thành phần, người ta có thể tiến hành lập trình theo phương pháp sau:  Xây dựng một thư viện các thành phần, mỗi thành phần thực hiện một công việc xác định.  Khi cần phát triển một phần mềm cụ thể, người ta chỉ cần chọn những thành phần có sẵn trong thư viện để ghép lại với nhau. Người lập trình chỉ phải phát triển thêm các thành phần mình cần mà chưa có trong thư viện. Biên soạn : Bùi Công Giao --------------------------------------- 6 -------------------------------------- Chương 1: Tổng quan về lập trình hướng đối tượng Phương pháp này có những ưu điểm rất lớn:  Lập trình viên có thể chia sẻ với nhau những thành phần mình đã xây dựng cho nhiều người khác dùng chung.  Khi cần, lập trình viên có thể lắp ghép các thành phần có sẵn khác nhau để tạo thành các chương trình có chức năng khác nhau. Tất cả chỉ cần dựa trên công nghệ lắp ghép thành phần, tiết kiệm được rất nhiều công sức lập trình. Trong xu hướng lập trình hướng thành phần, một số phương pháp lập trình khác đã nảy sinh và đang phát triển mạnh mẽ:  Lập trình hướng tác nhân (Agent-Oriented Programming)  Lập trình hướng khía cạnh (Aspect-Oriented Programming-AOP) 1.5.2 Lập trình hướng tác nhân Lập trình hướng agent có thể xem là một mức trừu tượng cao hơn của lập trình hướng thành phần. Trong đó, các agent là các thành phần có khả năng hoạt động độc lập, tự chủ để hoàn thành công việc của mình. Hơn nữa, các agent có khả năng chủ động liên lạc với các agent khác để có thể phối hợp, cộng tác hay cạnh tranh nhau để hoàn thành nhiệm vụ. Lập trình hướng agent có hai đặc trưng cơ bản:  Thứ nhất là khả năng tự chủ của mỗi agent để hoàn thành nhiệm vụ riêng của nó.  Thứ hai là tính tổ chức xã hội giữa các agent, cho phép các agent phối hợp, cộng tác, cạnh tranh nhau để hoàn thành nhiệm vụ chung của toàn hệ thống. 1.5.3 Lập trình hướng khía cạnh Phương pháp lập trình hướng khía cạnh là phương pháp lập trình phát triển tư duy tách biệt các mối quan tâm khác nhau thành các mô đun khác nhau. Ở đây, một mối quan tâm thường không phải một chức năng nghiệp vụ cụ thể và có thể đóng gói mà là một khía cạnh (thuộc tính) chung mà nhiều mô đun phần mềm trong cùng hệ thống nên có, ví dụ lưu vết thao tác và lỗi (error logging). Với AOP, chúng ta có thể cài đặt các mối quan tâm chung cắt ngang hệ thống bằng các mô đun đặc biệt gọi là aspect thay vì dàn trải chúng trên các mô đun nghiệp vụ liên quan. Các aspect sau đó được tự kết hợp với các mô đun nghiệp vụ khác bằng quá trình gọi là đan (weaving) bằng bộ biên dịch đặc biệt. AspectJ là một công cụ AOP cho ngôn ngữ lập trình Java. Trình biên dịch AspectJ sẽ đan xen chương trình Java chính với các aspect thành các tập tin bytecode chạy trên máy ảo Java. TỔNG KẾT CHƯƠNG 1 Nội dung chương 1 đã trình bày các vấn đề tổng quan liên quan đến phương pháp tiếp cận hướng đối tượng trong lập trình: Biên soạn : Bùi Công Giao --------------------------------------- 7 --------------------------------------