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 tiếp 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 ................................................................................ 70
5.5 Giao tiếp ........................................................................................... 73
5.6 Tính chất tĩnh................................................................................... 75
5.7 Kiểu liệt kê ....................................................................................... 78
5.8 Case Study ........................................................................................ 82

Chương 6.

Tập đối tượng .............................................................. 94

6.1 Khái niệm tập đối tượng ................................................................. 94
6.2 Ba kiểu tập đối tượng cơ bản ......................................................... 94
6.3 Mảng ................................................................................................. 96
6.4 Các loại tập đối tượng thường gặp ................................................ 99
6.4.1 LinkedList .......................................................................................... 99
6.4.2 HashMap .......................................................................................... 101
6.4.3 TreeMap ........................................................................................... 103
6.4.4 HashSet ............................................................................................. 105
6.4.5 TreeSet .............................................................................................. 106

6.5 Tạo kiểu tập hợp ............................................................................ 107
6.6 Phương thức trả về kiểu tập hợp ................................................. 109

Chương 7.

Xử lý ngoại lệ ............................................................ 112

7.1 Giới thiệu ngoại lệ.......................................................................... 112

7.2 Cơ chế xử lý ngoại lệ ..................................................................... 114
7.2.1 Khối try ............................................................................................. 114
7.2.2 Khối catch ......................................................................................... 114
7.2.3 Khối finally ....................................................................................... 118

7.3 Bắt các ngoại lệ .............................................................................. 120
7.4 Phân cấp lớp ngoại lệ .................................................................... 125
7.5 Các điểm cần lưu ý thêm về ngoại lệ ........................................... 128
7.5.1 Bắt ngoại lệ tổng quát ...................................................................... 128
7.5.2 Trình biên dịch Java yêu cầu phải có xử lý ngoại lệ ..................... 128
7.5.3 Tận dụng xử lý ngoại lệ để làm rõ lỗi phát sinh ............................ 130
7.5.4 try/catch lồng nhau .......................................................................... 130
7.5.5 Kiểu ngoại lệ do người dùng định nghĩa ........................................ 131


7.5.6 Ném nhiều kiểu ngoại lệ .................................................................. 133

7.6 Case Study ...................................................................................... 133

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 ............................................................... 224
10.2.4 Luồng ngầm.................................................................................... 226
10.2.5 Đa luồng với JApplet ..................................................................... 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 .......................................................................................... 241

10.4 Thu rác ......................................................................................... 242

Tham khảo ...................................................................................... 248


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 để hồ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 ngồ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 .............................. 95
Hình 6.2 Dùng khố để truy cập trực tiếp đối tượng trong tập hợp từ điển ................. 95
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. ............................................................................................................................ 96
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................................................................................... 113
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. ........................................................................................................................ 116
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. ................................................................................ 117
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).................................................................................................. 122
Hình 7.5 Khi một phương thức chấm dứt, nó bị lấy ra khỏi chồng. .......................... 122


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. .......................................................................... 122
Hình 7.7 Ngoại lệ thốt khỏi p.methodY() và chuyển xuống s.methodX() xử lý ...... 123

Hình 7.8 NullPointerException thơng qua chồng gọi được chuyển tới phương thức
main. ........................................................................................................................... 124
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. ..................... 125
Hình 7.10 Lớp java.lang.Exception có nhiều lớp con ................................................ 126
Hình 7.11 Cây thừa kế của kiểu ngoại lệ java.sql.DataTruncation ............................ 126
Hình 7.12 Kết quả demo của NumberOfDigits.java .................................................. 134
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ệ .......................................................................... 127
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++ ngồ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 tố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 tố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 tố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 số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 ln đượ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 ngồ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 tiếp 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 hố 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

Khố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 hố 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 hố cho nó. Mơ hình hố là xử lý nhằm phát triển một khn 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 khn 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 hố và trừu
tượng hố ln đ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 tố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 để hồ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 để hồ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 --------------------------------------


Chương 1: Tổng quan về lập trình hướng đối tượng

• Các phương pháp tiếp cận truyền thống: lập trình tuyến tính và lập trình cấu
trúc.
• Phương pháp tiếp cận hướng đối tượng với các đặc trưng cơ bản: đóng gói dữ
liệu, tính đa hình và sử dụng lại mã nguồn.
• Lập trình hướng đối tượng trên nền tảng là trừu tượng hố là cơ sở lập trình
hiện đại.
• Hiện nay, lập trình hướng thành phần, lập trình hướng agent và lập trình hướng
aspect tiến hố từ lập trình hướng đối tượng đang là xu hướng phát triển mạnh mẽ.

❖ BÀI TẬP
1. Vẽ một sơ đồ phân cấp lớp cho các lớp sau đây: táo, chuối, thịt bị, nước giải khát,
phó mát, thứ có thể ăn uống, sản phẩm bơ sửa, đồ ăn, trái cây, đậu xanh, thịt, sửa, thịt
heo, rau muống, rau.
2. Những đặc điểm nào của tivi mà chúng cần thiết để được trừu tượng từ góc nhìn
của
•

Một khách hàng?

•

Một kỹ sư thiết kế?

•

Người bán?

•

Nhà sản xuất?

3. Chọn một bài tốn mà bạn muốn mơ hình hố từ cách tiếp cận hướng đối tượng.

Bạn nên chọn các lĩnh vực mà bạn quan tâm hay bạn thường gặp trong công việc hàng
ngày. Giả sử bạn sẽ viết một chương trình để tự động vài chức năng của bài toán. Đầu
tiên viết một trang giấy mô tả yêu cầu của chương trình. Đoạn văn đầu tiên mơ tả tổng
qt hệ thống dự định. Kế đến nêu rõ yêu cầu chức năng mà người sử dụng bình
thường mơ tả hệ thống, tránh dùng các từ kỹ thuật như, “Hệ thống này phải chạy trên
môi trường Windows NT, và dùng giao thức TCP/IP để . . .”

Biên soạn : Bùi Công Giao --------------------------------------- 8 --------------------------------------


Chương 2: Cơ bản ngơn ngữ lập trình Java

Chương 2.

Cơ bản ngơn ngữ lập trình Java

Trước khi tìm hiểu ngơn ngữ Java người đọc cần biết về lịch sử hình thành ngơn ngữ
lập trình này. Java được khởi đầu bởi James Gosling và bạn đồng nghiệp ở Sun
Microsystems năm 1991. Ban đầu ngơn ngữ này được gọi là Oak (có nghĩa là cây sồi;
do bên ngồi cơ quan của ơng Gosling có trồng nhiều loại cây này), họ dự định ngơn
ngữ đó thay cho C++. Java được sử dụng chủ yếu trên mơi trường mạng, Internet và
lập trình Game trên thiết bị di động. Không nên lẫn lộn Java với JavaScript, hai ngơn
ngữ đó chỉ giống tên và loại cú pháp như C. Công ty Sun Microsystems đang giữ bản
quyền và phát triển Java thường xuyên.
Java được tìm hiểu trong chương này như sau:
• Kiến trúc tổng quát một chương trình xây dựng trên Java
• Các tốn tử và các CTDL cơ bản trên Java
• Các cấu trúc lệnh của Java

2.1 Đặc trưng của ngơn ngữ Java
Java có những đặc trưng cơ bản sau:
• Đơn giản
• Hướng đối tượng
• Độc lập phần cứng và hệ điều hành
• Mạnh mẽ
• Bảo mật
• Phân tán
• Đa luồng
• Linh động
Đơn giản
Những người thiết kế mong muốn phát triển một ngôn ngữ dễ học và quen thuộc với
đa số người lập trình. Do vậy Java loại bỏ các đặc trưng phức tạp của C và C++ như:
• Loại bỏ thao tác con trỏ, thao tác định nghĩa chồng tốn tử (operator
overloading)…
• Khơng cho phép đa kế thừa (multi-inheritance) mà sử dụng các giao tiếp
(interface)

• Khơng sử dụng lệnh goto cũng như file header (.h).
• Loại bỏ cấu trúc struct và union.
Hướng đối tượng

Biên soạn : Bùi Công Giao --------------------------------------- 9 --------------------------------------


Chương 2: Cơ bản ngơn ngữ lập trình Java

Java là ngơn ngữ lập trình hồn tồn hướng đối tượng:
• Mọi thực thể trong hệ thống đều được coi là một đối tượng, tức là một thể hiện
cụ thể của một lớp xác định.
• Tất cả các chương trình đều phải nằm trong một lớp nhất định.
• Khơng thể dùng Java để viết một chức năng mà không thuộc vào bất kỳ một lớp
nào. Tức là Java không cho phép định nghĩa dữ liệu và hàm tự do trong chương
trình.
// Chương trình C
#include <stdio.h>
main() {
printf(“Hello!”);

Mã nguồn viết trên
C phụ thuộc mơi
trường hoạt động.

}

Trình biên dịch
C cho Solaris

Trình biên dịch
C cho Windows

Trình biên dịch
C cho Linux

… tạo ra
…

Mã nhị phân phụ
thuộc môi
trường hoạt
động.
Phiên bản Solaris

Phiên bản Windows

Phiên bản Linux

Hình 2.1 Cách biên dịch truyền thống
Độc lập phần cứng và hệ điều hành
Đối với các ngơn ngữ lập trình truyền thống như C/C++, phương pháp biên dịch được
thực hiện như sau (Hình 2.1): với mỗi một nền phần cứng khác nhau, có một trình biên
dịch khác nhau để biên dịch mã nguồn chương trình cho phù hợp với nền phần cứng
ấy. Do vậy, khi chạy trên một nền phần cứng khác, bắt buộc phải biên dịch lại mã
nguồn.

Biên soạn : Bùi Công Giao --------------------------------------- 10 --------------------------------------

Chương 2: Cơ bản ngơn ngữ lập trình Java
// Chương trình Java
public class Hello {
public static void main( String[ ] args) {
System.out.println(“Hello!”);

Mã nguồn Java độc
lập mơi trường hoạt
động.

}
}

Trình biên dịch
Java cho Solaris

Trình biên dịch
Java cho Windows

Trình biên dịch
Java cho Linux

… tạo ra
…

Mã bytecode độc lập
mơi trường hoạt động.
Hình 2.2 Dịch chương trình Java
Đối các chương trình viết bằng Java, trình biên dịch javac sẽ biên dịch mã nguồn thành
dạng mã bytecode. Sau đó, khi chạy chương trình trên các nền phần cứng khác nhau,

máy ảo Java (JVM) dùng trình thơng dịch Java để chuyển mã bytecode thành dạng
chạy được trên các môi trường tương ứng. Do vậy, khi thay đổi môi trường (phần cứng
hoặc hệ điều hành), không phải biên dịch lại mã bytecode. Hình 2.2 minh hoạ quá
trình biên dịch mã nguồn Java.
Máy ảo Java là một chương trình đặc biệt để thông dịch và thực hiện mã nguồn Java.
Khi chương trình Java chạy nó sẽ nằm dưới sự quản lý của máy ảo này, và máy ảo thì
chịu sự quản lý của hệ điều hành của một loại máy tính cụ thể. Máo ảo sẽ thơng dịch
mã bytecode thành ngơn ngữ máy mà máy tính có thể hiểu được. Như vậy sẽ có nhiều
máy ảo Java cho từng mơi trường cụ thể. Hình 2.3 minh hoạ q trình thực thi của mã
nguồn Java.
Do chương trình Java phải chạy dưới máy ảo nên tốc độ thực hiện của nó hợi chậm
hơn các chương trình được biên dịch và chạy trực tiếp trên hệ điều hành. Tuy nhiên tốc
độ máy tính ngày càng cao thì sự chênh lệch về tốc độ không đáng kể.

Biên soạn : Bùi Công Giao --------------------------------------- 11 --------------------------------------


Chương 2: Cơ bản ngơn ngữ lập trình Java

Khi chuyển mã bytecode từ môi trường này sang môi trường khác như từ Windows
sang Linux thì ta khơng cần phải biên dịch lại chương trình. Hình 2.4 minh hoạ điều
này.
Mã nhị phân đã được
biên dịch viết bằng C hay
C++ chạy trực tiếp trên
một kiến trúc phần cứng
cụ thể (dưới sự quản lý
của hệ điều hành)

Máy ảo Java chạy

trên một kiến trúc
phần cứng cụ thể
(dưới sự quản lý của
hệ điều hành)

Mã bytecode độc lập môi
trường hoạt động chạy dưới
sự quản lý của máy ảo

Hình 2.3 Máy ảo Java thực hiện mã bytecode độc lập môi trường hoạt động
Mạnh mẽ
Java là ngôn ngữ yêu cầu chặt chẽ về kiểu dữ liệu:
• Kiểu dữ liệu phải được khai báo tường minh.
• Java khơng sử dụng con trỏ và các phép tốn con trỏ.
• Java kiểm tra việc truy nhập đến mảng, chuỗi khi thực thi để đảm bảo rằng các
truy nhập đó khơng ra ngồi giới hạn kích thước mảng.
• Q trình cấp phát, giải phóng bộ nhớ cho biến được thực hiện tự động, nhờ
dịch vụ thu rác những đối tượng khơng cịn sử dụng nữa.
• Cơ chế bẫy lỗi của Java giúp đơn giản hóa q trình xử lý lỗi và hồi phục sau
lỗi.

Biên soạn : Bùi Công Giao --------------------------------------- 12 --------------------------------------