Lap trinh HDT Java, Object-Oriented Programming in Java

KHOA CỌNG NGH THỌNG TIN & TRUY N THỌNG
L P TRÌNH H NG Đ I T NG
JAVA
Biên so n: Vũ Duy Linh
CTU - 2015
Object Oriented Progamming in Java
TR NG Đ I H C C N TH
KHOA CỌNG NGH THỌNG TIN & TRUY N THỌNG

L i nói đ u
Giáo trình L p trình h ng đ i t ng Java được biên soạn nh m phục vụ cho
ngư i học, nhất là cho sinh viên ngành Công nghệ thông tin, có được một tài liệu học tập
chính th c và hiệu quả trong môi trư ng đào tạo, giảng dạy bậc đại học c a trư ng Đại
học Cần Thơ.
Học phần được phân bố với số lượng là 03 tín chỉ, dành cho những đối tượng ngư i
học mà đa phần chỉ mới tiếp cận được với ngôn ngữ lập trình căn bản C. Do vậy, việc
cấu trúc và s p xếp kiến th c trong các chương cho giáo trình cũng được xem xét cẩn
thận. Sau nhiều năm học phần này được giảng dạy, với th i lượng 02 tín chỉ lý thuyết và
01 tín chỉ thực hành, giáo trình đã xác định được cấu trúc hợp lý và chặt chẽ với kỳ vọng
hướng ngư i học, từ mới b t đầu cũng như đã biết ngôn ngữ Java, đều có thể tiếp thu và
đạt được mục tiêu c a học phần hướng đối tượng này. Trong đó, phần đầu giáo trình
được đề cập đến những kiến th c cơ bản c a ngôn ngữ Java, sau đó sẽ được đưa từng
phần kiến th c về đối tượng cũng như hướng đối tượng vào những phần tiếp theo, và
cuối cùng là các kiến th c lập trình về giao diện ngư i dùng cũng như về cơ s dữ liệu.
Như vậy, mục tiêu c a học phần này là ngư i học sẽ được trang bị đầy đ về các kiến
th c như lập trình có cấu trúc, phân tích và thiết kế mô hình đối tượng cũng như hướng
đối tượng, để từ đó có thể cài đặt chúng b ng ngôn ngữ Java, và quan trọng nhất là ngư i
học có thể đọc hiểu được các sơ đồ c a những frameworks đã và đang phát triển rất
mạnh gần đây c a những công nghệ như: Java, .Net hoặc .PHP,…
Giáo trình bao gồm 12 chương, mỗi chương đều có ví dụ minh họa với mã nguồn
chạy trên môi trư ng Java SE 5 tr lên và các bài tập yêu cầu, nh m giúp sinh viên có
các bài thực hành trong phòng máy và tự rèn luyện thêm nhà. Số ví dụ và bài tập này
được đề cập từ đơn giản đến nâng cao mà đích đến là các bài tập lớn theo dạng case
study cho các chương chính c a lập trình hướng đối tượng, điều hữu ích cần được trải
nghiệm b i sinh viên học học phần này.
Với mong muốn có một tài liệu hữu ích cho sinh viên học tập và để tham khảo cho
cộng đồng Java vùng đồng b ng Sông Cửu Long cũng như Việt Nam, giáo trình đã
được biên soạn dựa vào kiến th c và các ví dụ minh họa từ nhiều nguồn trong và ngoài
nước, cũng như từ những kinh nghiệm giảng dạy c a bản thân ngư i viết. Tuy nhiên, sự
hiểu biết là hữu hạn nên những thiếu sót ch c hẳn sẽ khó tránh khỏi. Giáo trình rất mong
nhận được sự chia xẻ và góp ý c a ngư i đọc cũng như c a sinh viên qua địa chỉ email:
vdlinh@ctu.edu.vn, để hoàn thiện và phục vụ cho việc học và giảng dạy tốt hơn.
Ngư i biên soạn,
Vũ Duy Linh

Lập trình hướng đối tượng Java i
M C L C
Ch ng 1. Tổng quan v ngôn ngữ l p trình Java.....................................................1
1.1 Giới thiệu...............................................................................................................1
1.1.1 Môi trư ng phát triển ng dụng Java .............................................................1
1.1.2 Cài đặt môi trư ng phát triển ng dụng Java.................................................3
1.2 Những đặc tính và phạm vi ng dụng c a Java.....................................................5
1.2.1 Đặc tính Java ..................................................................................................5
1.2.2 Phạm vi ng dụng Java...................................................................................6
Bài tập chương 1..........................................................................................................6
Ch ng 2. L p trình Java c bản ................................................................................7
2.1 Cấu trúc chương trình Java đơn giản.....................................................................7
2.2 Các thành phần cơ bản...........................................................................................8
2.2.1 Từ khóa...........................................................................................................8
2.2.2 Kiểu dữ liệu nguyên th y ...............................................................................9
2.2.3 Danh hiệu tự đặt .............................................................................................9
2.2.4 Biến.................................................................................................................9
2.2.5 Biến h ng......................................................................................................11
2.2.6 Chú thích ......................................................................................................11
2.3 Các cấu trúc kiểm soát dòng lệnh........................................................................11
2.3.1 Lệnh rẽ nhánh if............................................................................................11
2.3.2 Lệnh rẽ nhánh switch....................................................................................13
2.3.2 Lệnh lặp có số lần xác định trước.................................................................14
2.3.2.1 Dạng 1: for..................................................................................................................... 14
2.3.2.2 Dạng 2: for-each............................................................................................................ 14
2.3.2 Lệnh lặp có số lần chưa xác định trước........................................................15
2.3.2.1 Dạng 1: while .. do......................................................................................................... 15
2.3.2.2 Dạng 2: do .. while......................................................................................................... 15
2.4 Phương th c tự định nghĩa .................................................................................16
2.4.1 Định nghĩa phương th c...............................................................................16
2.4.2 L i gọi phương th c.....................................................................................17
Bài tập chương 2........................................................................................................20

Lập trình hướng đối tượng Java ii
Ch ng 3. Khái ni m v l p trình h ng đ i t ng................................................21
3.1 Giới thiệu.............................................................................................................21
3.1.1 Đối tượng......................................................................................................22
3.1.2 Lớp ...............................................................................................................23
3.2 Các giai đoạn phát triển hệ thống hướng đối tượng............................................24
3.2.1 Phân tích hệ thống hướng đối tượng ............................................................25
3.2.2 Thiết kế hệ thống..........................................................................................25
3.2.3 Thiết kế đối tượng ........................................................................................26
3.2.3.1 Trừu tượng hóa ............................................................................................................. 26
3.2.3.2 Thừa kế.......................................................................................................................... 28
3.2.4 Giai đoạn cài đặt...........................................................................................28
3.3 Quá trình phát triển chương trình hướng đối tượng............................................31
3.4 Các đặc tính c a lập hướng đối tượng Java ........................................................33
3.4.1 Tính trừu tượng ............................................................................................33
3.4.2 Tính bao đóng .............................................................................................33
3.4.3 Tính thừa kế ................................................................................................34
3.4.4 Tính đa hình .................................................................................................34
3.4.5 Tính bền vững ..............................................................................................35
Bài tập chương 3 .......................................................................................................36
Ch ng 4. L p, đ i t ng, truy n thông đi p và gói...............................................37
4.1 Lớp ......................................................................................................................37
4.1.1 Khái niệm .....................................................................................................37
4.1.2 Lớp tự định nghĩa.........................................................................................37
4.1.2.1 Cú pháp khai báo tổng quát .......................................................................................... 38
4.1.2.2 Kiểm soát truy cập đến các thành viên của lớp............................................................. 39
4.1.2.3 Lớp tận cùng..............................................................................................40
4.2 Đối tượng.............................................................................................................40
4.2.1 Khái niệm .....................................................................................................40
4.2.2 Tạo đối tượng ...............................................................................................40
4.3 Thành viên thể hiện và thành viên lớp ................................................................43
4.3.1 Thành viên thể hiện......................................................................................43
4.3.2 Thành viên lớp..............................................................................................43
4.4 Phương th c dựng ..............................................................................................45
4.5 Phương th c ghi và đọc.......................................................................................46

Lập trình hướng đối tượng Java iii
4.6 Phương th c h y ................................................................................................48
4.7 Truyền tham số....................................................................................................50
4.8 Truyền thông điệp giữa các đối tượng.................................................................57
4.9 Gói.....................................................................................................................62
Bài tập chương 4........................................................................................................65
Ch ng 5. Mảng chuẩn, l p Arrays và khung n n t p h p Java...........................67
5.1 Mảng chuẩn .........................................................................................................67
5.1.2 Mảng một chiều............................................................................................67
5.1.3 Mảng nhiều chiều .........................................................................................69
5.1.4 Truyền tham số b ng mảng ..........................................................................71
5.1.5 Lớp mảng Arrays..........................................................................................72
5.2 Khung nền tập hợp Java ......................................................................................73
5.2.1 Giới thiệu......................................................................................................73
5.2.2 Danh sách mảng ...........................................................................................74
5.2.3 Tập HashMap ...............................................................................................76
5.2.4 LinkedHashMap và LinkedHashSet.............................................................78
Bài tập chương 5........................................................................................................80
Ch ng 6. L p bao gói kiểu nguyên thủy, và các l p chuỗi ký tự..........................81
6. 1 Lớp bao kiểu nguyên th y..................................................................................81
6.2 Lớp chuỗi ký tự String.........................................................................................83
6.2.1 Khai báo và kh i tạo.....................................................................................83
6.2.2 Truyền tham số b ng chuỗi String ...............................................................84
6.3 Chuỗi StringBuffer ..............................................................................................86
6. 4 Lớp StringTokenizer...........................................................................................87
Bài tập chương 6........................................................................................................88
Ch ng 7. Bao đóng, m i k t h p và thừa k ...........................................................89
7. 1 Tính bao đóng.....................................................................................................89
7.2 Các mối kết hợp...................................................................................................90
7.2.1 Mối kết hợp phụ thuộc..................................................................................92
7.3.2 Mối kết hợp ..................................................................................................94
7.3.2.1 Mối kết hợp có hướng/một chiều................................................................................. 94
7.3.2.2 Mối kết hợp hai chiều ................................................................................................... 95
7.3.3 Mối kết hợp hạn định..................................................................................101

Lập trình hướng đối tượng Java iv
7.3.4 Lớp liên kết ................................................................................................102
7.3.5 Kết tập chặt.................................................................................................102
7.3.6 Kết tập lỏng ................................................................................................104
7.3.8 Mối kết hợp thực thi...................................................................................105
7.3 Thừa kế..............................................................................................................108
7.3.1 Các cơ chế trừu tượng ................................................................................108
7.3.1.1 Cơ chế phân lớp........................................................................................................... 108
7.3.1.2 Tổng quát hóa.............................................................................................................. 109
7.3.1.3 Chuyên biệt hóa........................................................................................................... 109
7.3.2 Phương pháp thiết kế..................................................................................110
Bài tập chương 7 .....................................................................................................117
Ch ng 8. Đa hình ....................................................................................................125
8.1 Khái niệm đa hình .............................................................................................125
8.2 Đa hình tĩnh.......................................................................................................126
8.3 Chuyển đổi (ép) kiểu.........................................................................................127
8.4 Đa hình động .....................................................................................................131
Bài tập chương 8 .....................................................................................................137
Ch ng 9. L p trừu t ng và giao di n .................................................................139
9.1 Khái nhiệm về lớp trừu tượng...........................................................................139
9.2 Cách khai báo lớp trừu tượng............................................................................139
9.3 Khái niệm giao diện ..........................................................................................146
9.3.1 Cú pháp khai báo........................................................................................147
9.3.2 Sự cài đặt giao diện ....................................................................................147
9.3.3 Thừa kế bội b ng giao diện........................................................................153
Bài tập chương 9 .....................................................................................................172
Ch ng 10. Ngo i l và xử lý ngo i l .....................................................................175
10.1 Giới thiệu.........................................................................................................175
10.2 Ngoại lệ.........................................................................................................176
10.2.1 Lớp chuẩn ngoại lệ Error..........................................................................177
10.2.2 Lớp chuẩn Exception .............................................................................178
10.3 Xử lý ngoại lệ................................................................................................180
10.3.1 Thẩy ngoại lệ............................................................................................180
10.3.2 Xử lý ngoại lệ...........................................................................................181
10.3.2.1 Câu lệnh try .. catch .. finally ..................................................................................... 181

Lập trình hướng đối tượng Java v
10.3.2.2 Lan truyền ngoại lệ.................................................................................................... 184
10.3.2 Câu lệnh kiểm ch ng biểu th c................................................................185
Bài tập chương 10....................................................................................................190
Ch ng 11. Luồng và t p tin....................................................................................191
11.1 Tập tin ............................................................................................................191
11.2 Luồng...............................................................................................................195
11.2.1 Khái niệm .................................................................................................195
11.2.2 Các luồng xuất nhập chuẩn (Stream I/O in Standard I/O) .....................196
Bài tập chương 11....................................................................................................205
Ch ng 12. Giao di n ng i dùng và k t n i c sở dữ li u ................................207
12.1 Lập trình giao diện Java với SWT...................................................................207
12.2 Lập trình giao diện Java với Swing.................................................................211
12.3 Kết nối cơ s dữ liệu........................................................................................216
Bài tập chương 12....................................................................................................228
Tài li u tham khảo.....................................................................................................229

Lập trình hướng đối tượng Java 1
Ch ng 1.
Tổng quan v ngôn ngữ l p trình Java
Chương này sẽ cung cấp cho ngư i học các kiến th c cần thiết về môi trư ng, công
nghệ và các lĩnh vực ng dụng c a Java. Giúp cho ngư i mới học đ thông tin để b t tay
vào việc lập trình trên môi trư ng Java, đồng th i, có cái nhìn tổng thể về công nghệ
Java đã và đang phát triển và được ng dụng trên thế giới.
1.1 Gi i thi u
Java là ngôn ngữ lập trình máy tính cấp cao được sử dụng rộng rãi nhất hiện nay trên
thế giới. Nó được phát triển b i hãng Sun Microsystems vào năm 1991, và phiên bản
đầu tiên gọi là Oak do James Gosling phát triển, đến năm 1995 tên chính th c được gọi
là Java. Các nhà phát triển Java đầu tiên được kể đến là: James, Arthur Van, Karl Jacob
cũng như các nhân vật nổi bật khác. Phương pháp lập trình hướng đối được Java hỗ trợ
mạnh và lập trình viên được cung cấp một thư viện rất phong phú và đồ sộ để có thể triển
khai các dự án nhiều cấp độ khác nhau. Ngôn ngữ Java thư ng được ưu tiên chọn lựa
để phát triển các ng dụng tầm doanh nghiệp.
Trong các lãnh vực IT hiện nay, ngôn ngữ Java có thể phát triển được hầu hết các loại
ng dụng mà điển hình có thể kể ra là: lập trình ng dụng nền web, lập trình di động, lập
trình trò chơi, lập trình mạng, phân tán và lập trình trên công nghệ đám mây (Cloud).
1.1.1 Môi tr ng phát triển ứng d ng Java
Hình 1.1: Java SE Platform

th i điểm hiện nay, phiên bản Java SE 8 (Java platform standard edition) đang
được sử dụng rộng rãi. Nó bao gồm bộ công cụ phát triển JDK 8 (Java SE Development
Kit) và môi trư ng thực thi JRE 8 (Java SE Runtime Environment) như hình 1.1.
Hình 1.2: Môi trường phát triển và thực thi chương trình
Môi trư ng JRE cung cấp các lớp thư viện API (Application Programming
Interface) và máy tính ảo Java (Java Virtual Machine). Máy tính ảo là công cụ thực thi
mã (Java bytecode) trong tập tin .class dựa vào cách thông dịch (interpreter).
Hình 1.3: Kiến trúc mã trung gian c a Java
Như vậy, môi trư ng phát triển và thực thi Java được bộ JDK thực hiện qua hai giai
đoạn: Biên dịch và thông dịch. Dựa vào các lệnh như java, javac mà mã nguồn Java
được biên dịch thành các tập tin bytecode. Tiếp đến chúng được chuyển vào máy tính

ảo Java để thông dịch thành mã máy (machine code) tương ng cho mỗi hệ điều hành
mà JVM được cài vào đó như hình 1.2.
Do vậy, khác với ngôn ngữ C/C++ hoặc Delphi, Java sử dụng kiến trúc độc lập với
mọi hệ điều hành (architecture independent) dựa trên mã trung gian (chính là tập tin byte
code) để tạo nên một cuộc cách mạng mới cho lập trình: Viết một lần, chạy mọi nơi –
write one, run anywhere như hình 1.3.
1.1.2 CƠi đặt môi tr ng phát triển ứng d ng Java
Trước hết, chúng ta download bộ JDK được hỗ trợ miễn phí cho nhiều hệ điều hành
như Windows, Linux, Mac OS,… Chúng ta có thể lên địa chỉ website:
http://www.oracle.com/technetwork/java/javase/downloads/index.html để tải về và cài
đặt vào hệ thống máy tính. Sau khi cài đặt xong, cần thiết lập biến môi trư ng để Java có
thể biên dịch và thực thi từ bất kỳ nơi nào trên hệ điều hành hỗ trợ nó.
Tiếp theo, chúng ta cũng cần tải và cài đặt các phần mềm hỗ trợ soạn thảo mã nguồn.
giai đoạn mới học tập, ngư i học có thể sử dụng các trình soạn thảo văn bản đơn giản
như: NotePad++, jEdit, EditPlus, KompoZer,… hoặc các phần mềm có hỗ trợ môi
trư ng phát triển tích hợp (Integrated Development Environment) như: NetBeans IDE,
Eclipse IDE, JCreator IDE,... để soạn thảo các ng dụng đơn giản cũng như phát triển
các ng dụng dựa trên các khung làm việc (Frameworks) phải cấu hình ph c tạp. Một số
links hữu ích cho các phần mềm này như: https://netbeans.org/, http://www.eclipse.org/,
http://www.jcreator.com/,...
Một số lệnh chế độ command line sau khi đã cài đặt JDK:
javac: Trình biên dịch java
java : Chạy ng dụng độc lập
jdb : Gỡ rối (Java Debugger)
appletviewer : Chạy ng dụng applets
javap: Để in mã trung gian Java (bytecodes)
javah: Tạo ra header files cho ngôn ngữ C.
Ví d 1.1: Sử dụng trình soản thảo như NotePad++, EditPlus, hoặc Wordpad rồi
nhập vào mã lệnh java (source code) như chương trình đơn giản sau:
//Filename: HelloJavaApp.java
public class HelloJavaApp {
public static void main(String[] args) {
System.out.println("Hello! This is a Java application...");
}
}
Biên dịch mã nguồn: javac HelloJavaApp.java ↲
(Tạo file: HelloJavaApp.class)
Thực thi chương trình: java HelloJavaApp

Kết quả chạy chương trình: Hello! This is a Java application…
Ví d 1.2: Viết ng dụng Java b ng Netbean IDE
Hình 1.4: Cấu trúc dự án đơn giản trên Netbean IDE
Ví d 1.3: Viết chương trình tính cộng 2 số a và b, với a, b là 2 số bất kỳ được nhập
từ bàn phím theo cách nhập từ đối số dòng lệnh (command line)
package ctu.vdlinh.chapter1;
/**
* @author Vũ Duy Linh
*/
public class Cong {
double a, b;
a = Double.parseDouble(args[0]);
b = Double.parseDouble(args[1]);
System.out.printf("a + b= %.2fn", a+b);
}
}
* Từ dấu nh c lệnh c a MS-DOS hoặc Linux gõ lệnh:
java ctu.vdlinh.chapter1 Cong 5.5 12.7 ↲
* Từ Netbean IDE 7.4: Vào ch c năng Run/Set Project Configuration/Customize...
để thiết lập các đối số:

Hình 1.5: Xác định giá trị cho các đối số c a phương th c main trong Netbean
* Từ Eclipse Mars IDE : Vào ch c năng Run/Run Configurations... để thiết lập các
đối số đầu vào c a chương trình:
Hình 1.6: Xác định giá trị cho các đối số c a phương th c main trong Eclipse
1.2 Những đặc tính và ph m vi ứng d ng của Java
1.2.1 Đặc tính Java
Java là ngôn ngữ bậc cao, có tính thân thiện, đơn giản và dễ sử dụng. Java là ngôn ngữ
kh i sướng việc sử dụng kiến trúc mã trung gian nên nó cần được biên dịch (compiled)
và thông dịch (interpreted) để chạy chương trình. Bên cạnh đó, ngôn ngữ Java có có tính
định kiểu mạnh, tư ng minh và hướng đối tượng.
Điểm nổi bật nhất là Java có tính bảo mật (secure) cao và an toàn hơn các ngôn ngữ
khác do được kiểm tra an toàn trước từng bước (ngôn ngữ  biên dịch  thực thi: tính
đóng gói  .java  .class  class loader  machine code) nên từ bên ngoài khó có thể
xâm nhập vào chương trình được.

Đặc tính quan trọng nữa là Java có tính khả chuyển cao vì JVM dựa trên nền tảng
chính POSIX (Portable Operating System Interface [for Unix]) – Giao diện hệ điều hành
linh động: Cung cấp mã nguồn di động cho các thiết bị đầu cuối, ngoại vi. Nó cung cấp
khả năng lập trình phân tán (distribution): Hỗ trợ TCP, UDP, Socket và Network
communication: Applets, servlets, aglets – hệ thống mobile agents, remote method
invocation (RMI), Common Object Request Broker Architecture (CORBA),…
1.2.2 Ph m vi ứng d ng Java
Java là nền tảng cho hầu như mọi loại ng dụng mạng và là tiêu chuẩn toàn cầu cho
việc phát triển và cung cấp các ng dụng nhúng và di động, trò chơi, ng dụng web, và
phần mềm doanh nghiệp. Với hơn 9 triệu nhà phát triển trên toàn thế giới, Java cho phép
bạn để phát triển và triển khai các ng dụng, các dịch vụ một cách hiệu quả.
Hiện nay, có thể nói, phạm vi ng dụng c a ngôn ngữ và công nghệ Java có mặt
kh p mọi nơi: Từ máy tính xách tay đến trung tâm dữ liệu, từ ng dụng Console cho đến
siêu máy tính khoa học, từ điện thoại di động đến ng dụng Internet. Dưới đây là các
thông tin về ng dụng c a công nghệ Java theo http://www.java.com/en/about/
 97% of Enterprise Desktops Run Java
 89% of Desktops (or Computers) in the U.S. Run Java
 9 Million Java Developers Worldwide
 #1 Choice for Developers
 #1 Development Platform
 3 Billion Mobile Phones Run Java
 100% of Blu-ray Disc Players Ship with Java
 5 Billion Java Cards in Use
 125 million TV devices run Java
 5 of the Top 5 Original Equipment Manufacturers Ship Java ME
Bài t p ch ng 1
Bài 1.1: Sử dụng trình soạn thảo tùy ý, viết chương trình hiển thị câu ca dao:
“Công cha như núi Thái Sơn,
Nghĩa mẹ như nước trong nguồn chảy ra.
Một lòng thờ mẹ kính cha,
Cho tròn chữ hiếu mới là đạo con!”
Bài 1.2: Sử dụng Netbean IDE, Eclipse IDE, JCreator IDE hoặc trình soạn thảo văn
bản tùy ý để viết chương trình hiển thị kết quả phép nhân hai số nguyên được nhập từ
dòng lệnh command line.

Ch ng 2. L p trình Java c bản
Chương này sẽ trình bày các kiến th c c a ngôn ngữ lập trình Java căn bản để giúp
cho ngư i học, học môn L p trình h ng đ i t ng Java, được dễ dàng hơn. Tuy
nhiên, giáo trình chỉ trình bày ng n gọn các kiến th c Java cơ bản vì ngư i học đã được
học phần L p trình căn bản như C. Các kiến th c bao gồm cấu trúc một chương trình
Java cơ bản, các từ khóa, các kiểu dữ liệu cơ bản/nguyên th y, câu lệnh có cấu trúc rẽ
nhánh và lặp, phân biệt sự khác biệt giữa dạng hàm và th tục c a phương th c,…
Có thể nói, m c độ lập trình căn bản, ngôn ngữ lập trình C và Java giống nhau nên
ngư i học cần dành th i gian để tự rèn luyện phần Java căn bản này thông qua các kiến
th c đã được học ngôn ngữ C. Trong học phần này, giáo trình cũng dành hơn một phần
sáu th i lượng thực hành để sinh viên được hướng dẫn từ giảng viên.
2.1 C u trúc ch ng trình Java đ n giản
Cấu trúc chương trình Java dạng aplication cần có ít nhất một lớp chính (main class).
Lớp chính là lớp mà có ch a phương th c main. Khái niệm về lớp và đối tượng sẽ được
trình bày chi tiết trong phương pháp lập trình hướng đối tượng (HĐT) các phần sau.
Cấu trúc cơ bản c a một chương chương trình Java có dạng như hình 2.1.
Hình 2.1: Cấu trúc chương trình Java cơ bản
Ví d 2.1: Minh họa cấu trúc chương trình đơn giản c a ngôn ngữ Java với chỉ một
lớp chính (main class).
Các câu lệnh ví dụ trên được giải thích như sau:
Dòng (1): Tạo các gói (package) là ctu.vdlinh.simple
Dòng (3) đến (8): Phần mô tả chương trình. Đây là phong cách lập trình chuyên
nghiệp mà lập trình viên cần lưu ý khi viết và chuyển giao dự án.
Dòng (9): Nạp thư viện cần thiết cho chương trình.

Dòng (11) đến (15) là lớp chính, FirstSample. Lớp chính là lớp có ch a phương th c
main trong nó. Khi là lớp chính, nó phải được lưu tên tập tin (file name) trùng với tên
lớp, FirstSample.java.
Từ khóa public sẽ chỉ ra lớp hoặc phương th c đó được truy cập mọi nơi c a dự án.
Từ khóa static c a phương th c main được gọi là phương th c lớp, và phương th c này
có thể được gọi mà không cần phải kh i tạo đối tượng c a lớp ch a nó (phương th c
static chỉ được phép truy xuất tới các biến static c a lớp do đã được fix sẵn trong bộ
nhớ). Còn từ khóa void xác định đây là một phương th c dạng th tục: không trả về
(return;) giá trị nào cả khi phương th c thực hiện xong.
2.2 Các thành ph n c bản
2.2.1 Từ khóa
Từ khóa (keywords) là các từ dành riêng cho ngôn ngữ Java, nó có ý nghĩa và ch c
năng đã được xác định, và không được dùng nó vào các việc khác hoặc đặt tên danh hiệu
trùng với các từ khóa này.
Dưới đây là danh sách một số từ khóa thông dụng c a ngôn ngữ Java:
abstract default if private this
assert do implements protected throw
boolean double import public throws
break else instanceof return transient
byte enum int short try
case extends interface static void
catch final long strictfp volatile
char finally native super while
class float new switch
continue for package synchronized

2.2.2 Kiểu dữ li u nguyên thủy
Kiểu nguyên thuỷ (primitive data type): Còn được gọi là kiểu căn bản, đó là kiểu mà
các phép toán được dịch trực tiếp sang các lệnh c a máy (operational data).
Vì Java là một ngôn ngữ định kiểu mạnh nên khi khai báo biến, h ng, chúng ta cần
xác định cho chúng một kiểu dữ liệu nhất định.
Kiểu Kích
th c
Khoảng giá tr
boolean 8 bit true hoặc false
byte 8 bit -128 đến 127
short 16 bit -32,768 đến 32,767
int 32 bit -2,147,483,648 đến +2,147,483,647
long 64 bit -9,223,372,036,854,775,808  +9,223,372,036,854,775,807
char 16 bit u0000 đến uFFFF (chuẩn unicode)
float 32 bit -3.40292347E+38  +3.40292347E+38
double 64 bit -1.7976931348623157E+308  +1.7976931348623157E+308
2.2.3 Danh hi u tự đặt
Quy t c đặt tên danh hiệu (identifier): B t đầu b ng một chữ cái, một dấu gạch dưới,
hoặc một dấu dollard ($), không có khoảng tr ng, không trùng với các từ khoá và có
phân biệt chữ hoa chữ thư ng. Trong lập trình, các danh hiệu được sử dụng phổ biến cho
đặt tên biến, h ng, tên kiểu/lớp ngư i dùng.
Ví d 2.2: Đặt tên cho biến, h ng, tên phương th c… theo quy ước camel-case
Danh hiệu tự đặt hợp lệ: myList1, x1, tinhDelta…
Danh hiệu không hợp lệ: my List1, 1x, tinh-Delta,…
Ví d 2.3: Đặt tên lớp ngư i dùng theo quy ước proper-case
Đúng style: SinhVien, GiangVien, DBConnection,… //chuyên nghiệp
Sai style: sinhvien, giangVien, DBconnection,… //không nên sử dụng
2.2.4 Bi n
Biến (variable): Theo định nghĩa c a Khoa học máy tính, biến gồm một số ô nhớ
được định danh duy nhất b i một danh hiệu. Chúng ta sử dụng biến để ch a một giá trị
nào đó thuộc một kiểu dữ liệu xác định trước, và giá trị c a nó có thể thay đổi trong quá
trình thực thi chương trình.
Cách 1: Khai báo và kh i tạo riêng biệt
kiểu_nguyên_thuỷ tên_Biến;

tên_Biến = giá_trị;
Cách 2: Khai báo và kh i tạo đồng th i
kiểu_nguyên_thuỷ tên_Biến = giá_trị;
Mỗi biến được khai báo chỉ tồn tại trong phạm vi (scope) c a nó – tương tự như ngôn
ngữ C đã học.
Cần chú ý việc chuyển kiểu để tương thích với nhau, như minh họa th tự gán hợp
lệ: double  float  long  int  short, char  byte.
Ví d 2.4: Khai báo và kh i tạo đúng cho các biến
Boolean kiemTra = true; byte b = 100; short s = -100; int tich = 1;
int decVal = 26; int octVal = 032; int hexVal = 0x1a;
float diemTrB = 9.5f; double dienTich = 7278.25;
char capitalC = 'C'; char unicodeC='u1EE9'; // Java sử dụng UTF-16
String uniGreeting="Chu00e0o bu00e9: Vu0169u0020Duyu0020Thu1EE9c!"
Hình 2.2: Hiển thị chuỗi ký tự unicode
Việc cấp pháp bộ nhớ cho các biến kiểu nguyên th y được quản lý b i Stack trong
JVM nên mỗi biến đều được cấp phát một địa chỉ riêng biệt như sau:
Hình 2.3: Sơ đồ cấp phát bộ nhớ cho kiểu nguyên th y

2.2.5 Bi n hằng
H ng (constant) cũng tương tự như biến ngoại trừ nó giữ một giá trị cố định (hay
được gọi là các biến chỉ đọc). Trong Java, chúng được khai báo b i từ khóa final và quy
định viết in hoa (upper-case), chẳng hạn như:
final int SI_SO = 40; final double PI = 3.1428;
Ví d 2.5: Viết chương trình với một lớp chính để nhập bán kính r c a hình tròn,
tính diện tích và hiển thị các thông tin c a nó lên màn hình b ng Eclipse IDE:
/**
* Filename: HinhTron.java
*/
public class HinhTron {
final double PI = 3.1428; // hằng PI
double bk = 5.5; // biến bán kính
double dt; // biến diện tích
dt = PI * bk * bk;
System.out.println("Bán kính= " + bk + ", diện tích= " + dt);
}
}
2.2.6 Chú thích
Java cung cấp 03 kiểu ghi chú thích (comments) khác nhau:
Cặp dấu /* */ được sử dụng cho chú thích có nhiều hàng
Cặp dấu xổ trái // được sử dụng cho chú thích đơn hàng
Cặp dấu /** */ được sử dụng để tạo tài liệu
Sử dụng Javadoc để tạo tập tin hướng dẫn dạng .html cho cácchú thích trong cặp
dấu /** và */
2.3 Các c u trúc kiểm soát dòng l nh
2.3.1 L nh rẽ nhánh if
Trong Java có 3 dạng câu lệnh if
Dạng 1: if
if (booleanExpression) {
statement(s); //Khối lệnh với điều kiện true
}

Dạng 2: if .. else
if (booleanExpression) {
true-statement(s); //Khối lệnh với điều kiện true
} else {
false-statement(s); //Khối lệnh với điều kiện false
}
Ví d 2.6: Chương trình minh họa sử dụng lệnh if .. else
//File name: LenhIfElse.java
package edu.vdlinh.chapter2;
public class LenhIfElse {
double markIELTS = 7.0;
if (markIELTS >= 6.5) {
System.out.println("Chúc mừng bạn!");
System.out.println("Bạn thật giỏi Anh văn!" ;
} else {
System.out.println("Hãy luyện tập và thử lại!");
}
}
}
Một toán tử điều kiện (conditional operator) có ch c năng tương tự như lệnh if .. else
trên là dạng booleanExpr ? trueExpr : falseExpr;
Ví d 2.6: Minh họa toán tử điều kiện để tìm giá trị nhỏ hơn c a hai số nguyên.
int a =10, b =17;
int min = (a < b) ? a : b;
D ng 3: if .. elseif .. elseif .. else (nested-if)
if (booleanExpr_1) {
block_1; //Khối lệnh 1
} else if (booleanExpr_2){
block_2 ; //Khối lệnh 2
} else if ( booleanExpr_3 ) {
... // Khối lệnh tiếp theo
} else {

block_else ; // Khối lệnh cuối cho else
}
Ví d 2.7: Minh họa lệnh sử dụng nested-if cho 5 trư ng hợp phân biệt nhau
if (diemThi >= 8.5)
System.out.println("A");
else if (diemThi >= 7.5)
System.out.println("B");
System.out.println("C");
System.out.println("D");
else System.out.println("F");
2.3.2 L nh rẽ nhánh switch
switch (evaluatedExpression) {
case constantExpr_1:
block_1;
break;
case constantExpr_2:
block_2;
break;
…
case constantExpr_n:
block_n;
break;
default:
default_block;
}
Chú ý: Khác với lệnh if trên, biểu th c chọn lựa evaluatedExpression để rẽ nhánh
trong lệnh switch có kiểu r i rạc như: int, char, hoặc enum.
Ví d 2.8: Minh họa sử dụng câu lệnh rẽ nhánh switch với kiểu liêt kê (enum)
//File name: JavaEnumSwitchCase.java
public class JavaEnumSwitchCase{
enum ThucUong {

Coffee, LaVie, Camvat
}
ThucUong chon = ThucUong.Coffee;
switch (chon) {
case Coffee:
System.out.println("Bạn chọn uống cafe. ");
break;
case LaVie:
System.out.println("Bạn chọn nước suối Lavie.");
break;
case Camvat:
System.out.println("Bạn chọn uống nước cam vắt.");
break;
}
}
}
2.3.2 L nh lặp có s l n xác đ nh tr c
2.3.2.1 Dạng 1: for
for ( initialization; booleanExpression; step ){
statement(s);
}
Trong đó: initialization để kh i tạo giá trị ban đầu c a biến chạy; boolean-expression:
là điều kiện dừng, step: bước nhảy tăng hoặc giảm.
Ví d 2.9: Đoạn mã minh họa lệnh lặp với biến chạy i có giá trị đầu (kh i tạo) là 1 và
giá trị cuối là 9 với bước nhảy là 2 rồi hiển thị nó.
for (int i = 1; i < 10; i+=2) {
System.out.print(i +"t");
}
Kết quả của câu lệnh for là: 1 3 5 7 9
2.3.2.2 Dạng 2: for-each
for ( datatype variable: array | collection ){
statement(s);
}

Câu lệnh for-each được sử dụng rất phổ biến trong lập trình kiểu đối tượng như ngôn
ngữ Java. Trong hầu hết các mã lệnh, lập trình viên đều sử dụng collection để quản lý
các đối tượng cho hiệu quả và tối ưu.
Ví d 2.10: Minh họa sử dụng câu lệnh for-each trên kiểu enum
//File name: JavaEnumSwitchCaseExample.java
public class JavaEnumSwitchCaseExample {
enum WeekDay {
Sun, Mon, Tue, Wed, Thu, Fri, Sat
}
System.out.print("Days of week: ");
for (WeekDay day : WeekDay.values()) {
System.out.print(day + ", ");
}
}
}
2.3.2 L nh lặp có s l n ch a xác đ nh tr c
2.3.2.1 Dạng 1: while .. do
while (booleanExpression) {
statement(s);
}
Đây là dạng vòng lặp kiểm tra điều kiện trước khi thực hiện công việc hay khối
lệnh. Nó sẽ lặp cho đến khi điều kiện tr thành false thì ngừng.
Ví d 2.11: Minh họa sử dụng câu lệnh while .. do với mỗi bước lặp là tăng 2
int i = 1;
while (i < 10) {
i += 2;
}
Kết quả c a câu lệnh while .. do là: 1 3 5 7 9
2.3.2.2 Dạng 2: do .. while
do {
statement(s);
} while (booleanExpression);

Tương tự như while .. do trên nhưng nó sẽ thực hiện công việc hay khối lệnh trước
rồi mới kiểm tra điều kiện.
Ví d 2.12: Minh họa sử dụng câu lệnh do .. while với ít nhất một lần công việc
(statements) được thực hiện.
int i = 1;
do {
i += 2;
}while (i < 10 );
Kết quả c a câu lệnh do .. while là: 1 3 5 7 9
2.4 Ph ng thức tự đ nh nghĩa
trong các phương pháp lập trình trước đây như lập trình hướng th tục, các đoạn
lệnh mà có ch c năng riêng biệt hoặc lặp đi lặp lại nhiều lần thư ng được tách thành các
th tục (procedure) hoặc hàm (function) riêng biệt khỏi chương trình chính (phương
th c main) và thư ng được gọi là các chương trình con (sub-program). Lợi ích c a
chương trình con là hữu dụng vì tính module hóa theo từng ch c năng, tránh lặp lại các
dòng code, và khả năng tái sử dụng.
2.4.1 Đ nh nghĩa ph ng thức
Trong giáo trình này, lập trình theo phương pháp hướng đối tượng, th tục và hàm
được gọi là phương th c (method). Phương th c ngư i dùng (lập trình viên) tự định
nghĩa (user-defined method) có cú pháp như sau:
[modifiers] returnType methodName([ parameterList ] ){
Body; //Gồm declarations; và statements;
}
Tên phương th c (methodName): Là phần b t buộc phải có. Nó thư ng được đặt theo
dạng động từ vì hàm ch a ý nghĩa cho một thao tác (operation), một ng xử (behavior),
hay thông điệp (message) nào đó c a đối tượng.
Danh sách các tham số (parameterList): Mỗi tham số bao gồm (tên) tham số hình th c
(formal parameter) và kiểu dữ liệu (data type) c a nó. Nếu có nhiều tham số thì chúng sẽ
được phân cách nhau b i dấu phẩy.
Tên phương th c và danh sách các tham số c a nó được gọi chung là chữ ký phương
th c (method signature).
Các bổ từ (modifiers): Chúng là một trong những từ khóa c a bổ từ truy cập như:
public, protected, private hoặc mặc định để trống (friendly) nh m xác định phạm vi truy
cập c a phương th c này khi được gọi và/hoặc các bổ từ khác như static, abstract,
synchronized,...
Kiểu dữ liệu trả về (returnValueType) : Khi một phương th c dạng hàm thì cần phải
trả về một kết quả cho nó thông qua câu lệnh return ketQuaTraVe; còn khi phương th c
dạng th tục ta sử dụng câu lệnh return; để không trả về kết quả nào cả.

Thân phương th c (body method): Bao gồm khối các câu lệnh để khai báo biến, h ng
cục bộ (phạm vi hoạt động chỉ trong phương th c ch a nó) và các câu lệnh tuần tự để
thực hiện các nhiệm vụ theo ý c a lập trình viên và/hoặc trả về kết quả tính được cho
phương th c.
Ví d 2.13: Phương th c tính tổng hai số thực
public static final double tinhTong(double a, double b){
double tong; //khai báo cục bộ (local)
tong = a + b; //lệnh tính tổng;
return tong; //lệnh trả về giá trị cho phương thức hàm
}
2.4.2 L i g i ph ng thức
Để phương th c được thực thi (run), thì phương th c đó phải được gọi thông qua tên
phương th c và các tham số thực (actual parameters) được truyền đến cho các tham số
hình th c (formal parameters) nếu có.
Ví d 2.14: Viết chương trình giải phương trình bậc nhất ax +b = 0

Ví d 2.15: Tính dãy Fibonacci được định nghĩa: F1 = 1, F2 = 1 và Fn = Fn - 2 + Fn -1.
Hãy in dãy n số Fibonacci theo hai cách đệ quy và không đệ quy, với n là một số nguyên
dương được nhập từ bàn phím.
// Filename: Fibonacci.java
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
public class Fibonacci {
void nonRecursiveFibo(int m){ //không đệ quy
System.out.print("1");
int i=2; //xử lý từ số đến m
int f1=0, f2=1, f3;
while(i <= m){
f3 = f1 + f2;
System.out.print("t"+f3);
f1 = f2; f2 = f3;
i++;
}
System.out.println();
}
int recursiveFibo(int m){ //đệ quy
if(m <= 2)return 1;
else return recursiveFibo(m-1) + recursiveFibo(m-2);
}
public static void main(String arg[])throws IOException {
BufferedReader br=new BufferedReader(new
InputStreamReader(System.in));
System.out.print("Nhập giá trị n= ");
int n = Integer.parseInt(br.readLine());
System.out.println("Dãy n số Fibonacci không đệ quy) là:");
Fibonacci fibo = new Fibonacci();
fibo.nonRecursiveFibo(n);
System.out.println("Dãy n số Fibonacci đệ quy) là:");
for(int i=1; i<=n; i++) {

System.out.print(fibo.recursiveFibo(i) + "t");
}
}
}
Kết quả chạy chương trình:
Nhập giá trị n= 9
Dãy n số Fibonacci không đệ quy) là:
1 1 2 3 5 8 13 21 34
Dãy n số Fibonacci đệ quy) là:
1 1 2 3 5 8 13 21 34
Ví d 2.16: Viết chương trình nhập một số nguyên dương n>=2, in các số nguyên tố
tìm được trong các số từ 1 đến n, với số nguyên tố là số chỉ chia hết cho 1 và chính nó.
// File name: SoNguyenTo.java
import java.util.Scanner;
public class SoNguyenTo {
Scanner scan = new Scanner(System.in);
System.out.print("Nhập số nguyên dương n= " ;
short n = scan.nextShort();
scan.close();
System.out.println("Dãy các số nguyên tố tìm được:");
for (short i = 1; i <= n; i++) {
//kiểm tra i có là số nguyên tố không
short dem = 0;
for(short j=1; j<= i/2; j++){ //nên viết theo while/do
if(i % j == 0) dem++;
}
if(dem == 1) // i là SNT
System.out.printf("%4d", i);
}
}
}

Chạy thử chương trình:
Nhập số nguyên dương n= 0
Dãy các số nguyên tố tìm được:
2 3 5 7
Bài t p ch ng 2
Bài 2.1: Viết chương trình giải phương trình ax + b = 0, với a, b là hai số thực được
nhập tùy ý từ bàn phím.
Bài 2.2: Viết chương trình giải phương trình ax2
+ bx + c = 0, với các hệ số kiểu
số thực được nhập tùy ý từ bàn phím.
Bài 2.3: Viết chương trình nhập hai số thực a, b bất kỳ từ bàn phím. Hãy viết các
phương th c sau:
a. phuongThucCong(a, b) // cộng hai số a và b
b. phuongThucTru(a, b) // trừ hai số a và b
c. phuongThucNhan(a, b) // nhân hai số a và b
d. phuongThucChia(a, b) // chia hai số a và b
rồi tính biểu th c
a
ba
S



25
/)5(*12
// sử dụng các phương th c trên
Bài 2.4: Viết chương trình tính n!, với n được nhập từ bàn phím.
Bài 2.5: Viết chương trình nhập vào 2 số nguyên dương n và một số thực a tùy ý.
Hãy tính và in kết quả lên màn hình cho biểu th c S1 và S2 như sau:
n
naaaaS  ...321 32
!...!3!21
...
2
32
n
aaaa
S
n




Ch ng 3.
Khái ni m v l p trình h ng đ i t ng
Thế giới hiện hữu là các đối tượng, bao gồm thế giới tự nhiên và nhân tạo. Làm sao
để đưa các đối tượng hữu hình và vô hình c a bài toán vào trong hệ thống máy tính là
mục tiêu c a môn học.
Chương này, giáo trình sẽ đề cập đến các khái niệm cơ bản c a phương pháp lập
trình đối tượng, hướng đối tượng đó là: Đối tượng, lớp các đối tượng, quá trình phân tích
và mô hình đối tượng để ánh xạ thế giới thực vào máy tính. Đồng th i cũng đưa ra những
đặc tính, những ưu điểm c a phương pháp hướng đối tượng so với các phương pháp lập
trình trước đó.
3.1 Gi i thi u
Trong khoa học máy tính, thông thư ng, khi viết chương trình chúng ta thư ng dựa
trên một phương pháp lập trình nào đó. Thông qua học phần Lập trình căn bản A b ng
ngôn ngữ Pascal hoặc C, chúng ta đã làm quen với các phương pháp tiếp cận th tục
(Procedural programming). Với phương pháp này, mã lệnh được module dựa trên các
dựa trên các chương trình con (routines hoặc subroutines) để tránh sự lặp lại c a các
dòng lệnh được thực hiện nhiều lần. Phương pháp lập này đã được sử dụng phổ biến từ
những năm 1970, tuy nhiên nó tồn tại những khuyết điểm, bất lợi đối với xu hướng phát
triển c a lãnh vực công nghệ phần mềm như: Khó thể hiện những thực thể trong tự
nhiên, khó bảo trì, không bảo mật, chỉ phù hợp với những dự án nhỏ.
Ngược lại, triết lý c a lập trình hướng đối tượng lại tập trung vào các đối và sự tương
tác c a chúng trong không gian c a bài toán. Và hệ thống ng dụng sẽ được xây dựng
dựa trên mô hình các đối tượng này. Vì các đối tượng và sự tương tác c a chúng thuộc
nhiều ch ng loại và rất đa dạng trong tự nhiên cũng như những sản phẩm nhân tạo (thế
giới thực), nên một ng dụng phần mềm được phát triển b ng cách sử dụng phương
pháp lập trình hướng đối tượng sẽ có tính tương đồng và sát với thực tế hơn so với các
phương pháp lập trình hướng th tục hoặc có cấu trúc.
Hình 3.1: Các đối tượng và sự tương tác giữa chúng trong hệ thống
Về mặt kỹ thuật, phương pháp lập trình dạng th tục thư ng xem nhẹ việc bảo vệ dữ
liệu mà đặt nặng vào việc sử dụng các thuật toán để áp lên các dữ liệu nh m đạt được kết
quả mong muốn (Program = Data structure + Algorithm). Ngược lại với phương pháp

trên, phương pháp lập trình HĐT lại nâng dữ liệu lên hàng ưu tiên. Điều này được thực
hiện b ng cách đóng gói các dữ liệu và các phương th c phương th c biến đổi (Mutator
methods /Setters) và phương th c truy cập (Accessor methods /Getters) mà chúng có
quyền truy cập đến dữ liệu vào trong một đơn vị duy nhất đó là chính là đối tượng
(Object).
Hình 3.2: Sự khác biệt quan điểm c a hai phương pháp lập trình
3.1.1 Đ i t ng
Đối tượng (object) là một khái niệm rất trực quan và phổ biến trong thế giới thực, nó
là một đối tượng bất kỳ thuộc vào một loài nào đó trong tự nhiên, trong các thực thể nhân
tạo, trong kinh doanh, trong các sản phẩm sử dụng, v.v… như hình 3.3.
Hình 3.3: Các đối tượng trong môi trường học tập
Mỗi đối tượng phần mềm (software object) là khái niệm tương tự như các đối tượng
trong thế giới thực: chúng cũng bao gồm các trạng thái (state) và và các hành vi

(behavior) c a nó. Trạng thái đại diện giá trị dữ liệu c a đối tượng (object’s data), còn
hành vi là các thao tác mà đối tượng đó có thể thực hiện như hình 3.4.
Hình 3.4: Một đối tượng phần mềm
Ví d 3.1: Từ vi.wikipedia.org, có đưa các thông tin về danh hài Hoài Linh. Để minh
họa cho khái niệm đối tượng, một số thông tin được trích ra như hình 3.5.
Hình 3.5: Danh hài Hoài Linh
Danh hài Hoài Linh này, hiển nhiên, là một đối tượng con ngư i, và được sống trong
cộng đồng các đối tượng con ngư i khác. Một số thông tin c a đối tượng này gồm: họ
tên là ắNguyễn Bảo Hoài LinhẰ, phái là nam, và tuổi hiện tại là 45, … Đối tượng này có
các hành vi như diễn hài, làm MC, giám khảo,... Khi cần, danh hài này có thể tương tác
với các đối tượng xung quanh khác b ng các hành vi như diễn kịch cho khán giải xem,
làm giám khảo cho các thí sinh dự thi,….
Như vậy các thông tin này chính là trạng thái hiện hành c a đối tượng. Có những
trạng thái bất biến theo th i gian như họ tên, phái, nhưng cũng có trạng thái thay đổi như
tuổi chẳng hạn. Các hành vi thì luôn luôn tồn tại trong đối tượng này, nhưng mỗi th i
điểm thì đối tượng này có thể có những hành vi khác nhau, chẳng hạn có ngày thì diễn
kịch, có ngày thì làm MC,…
3.1.2 L p
Lớp (class) là một nguyên mẫu (prototype) định nghĩa cấu trúc cho sự đại diện các đối
tượng có chung những đặc điểm (thuộc tính và các hành vi) c a chúng. Các đặc điểm
này phải cung cấp được các thông tin khi đề cập đến nhóm đối tượng thuộc lớp đó và
được gọi là thuộc tính c a đối tượng (object attributes). Các hành vi được sử chung cho

các đối tượng cùng loại được gọi là hoạt động/phương th c c a đối tượng (object
operations).
Theo Booch: một lớp là một tập các đối tượng chia sẻ từ một cấu trúc và hành vi
chung (A class is a set of objects that share a common structure and a common
behavior).
Hình 3.6: Các đối tượng cùng chung một cấu trúc lớp Student
Trên sơ đồ sử dụng ký hiệu UML, một lớp có 03 phần đó là: Tên lớp (class name), các
thuộc tính (attributes) và các hành vi (operations). Với ngôn ngữ lập trình, chúng được
gọi là các trư ng (fields) và các phương th c (methods) tương ng.
Ví d 3.2: Lớp DienVien, được viết b ng ngôn ngữ giả và theo sơ đồ UML
class DienVien
Fields: //các trư ng
hoTen
gioiTinh
tuoi
Methods: //các phương th c
dienHai(){…}
lamGiamKhao(){…}
lamMC(){…}
Giả sử, trên sân khấu (hệ thống) có 3 diễn viên hài khác nhau như: Trư ng Giang, Chí
Tài, và Hoài Linh, thì từ lớp DienVien tạo ra 3 đối tượng diễn viên với các định danh là
dienVien1, dienVien2, dienVien3.
3.2 Các giai đo n phát triển h th ng h ng đ i t ng
Phát triển hệ thống hướng đối tượng đòi hỏi các kỹ thuật hướng đối tượng
(Object-Oriented techiques) được sử dụng trong suốt quá trình phân tích và cài đặt c a
hệ thống. Phương pháp này đòi hỏi ngư i phân tích phải xác định được các đối tượng
trong hệ thống là cái gì, chúng sẽ ng xử (behave) như thế nào theo th i gian hoặc trong

sự đáp ng (response) lại với các sự kiện, và các mối quan hệ nào giữa đối tượng này với
các đối tượng khác trong hệ thống.
Hình 3.7: Các khái niệm chính c a hướng đối tượng
Mô hình hóa đối tượng (Object modeling) được dựa trên sự xác định (identifying) các
đối tượng trong hệ thống và mối quan hệ giữa chúng. Các giai đoạn cơ bản vệc thiết kế
hệ thống sử dụng mô hình hóa đối tượng là: Phân tích (Analysis stage), thiết kế hệ thống
(System design stage), thiết kế đối tượng (Object design stage) và cuối là sự cài đặt
chúng (Implementation).
3.2.1 Phân tích h th ng h ng đ i t ng
Phân tích hệ thống (System analysis stage) là giai đoạn đầu tiên c a phát triển phần
mềm và cũng là bước đầu tiên trong kỹ thuật mô hình hóa đối tượng (OMT) mà triết lý
c a nó là xem hệ thống ban đầu như là một tập các hệ thống con nhỏ hơn mà trong đó
mỗi hệ thống con gồm các đối tượng tương tác với nhau. Do vậy, ngư i phát triển
(developer) hệ thống cần tham khảo với các ngư i dùng để tìm ra những yêu cầu
(requirements), và phân tích chúng để hiểu rõ ch c năng c a hệ thống đang quan tâm.
Dựa vào sự phân tích trên, ngư i phân tích sẽ phác thảo và đưa ra một mô hình
(model) c a hệ thống mong muốn sao cho giống với những tình huống trong thế giới
thực. Trong mô hình này chỉ đưa ra cái gì (what) mà hệ thống đòi hỏi phải thực hiện mà
không cần quan tâm đến các chi tiết cần cài đặt.
Như vậy , trong thiết kế hướng đối tượng, ngư i phân tích phải trừu tượng sao cho tìm
ra được một mô hình c a dự án mà đó nhấn mạnh vào việc tìm kiếm và mô tả các lớp
đối tượng (class), hay các khái niệm (concepts) trong phạm vi bài toán.
3.2.2 Thi t k h th ng
Sau khi kiến trúc tổng thể c a hệ thống mong muốn đã được quyết định, giai đoạn tiếp
theo là thiết kế đối tượng (System design stage). Trong giai đoạn này, hệ thống được tổ

ch c thành một tập các hệ thống con (sub-systems) mà chúng tương tác qua lại được với
nhau. Giai đoạn phân rã này, ngư i phân tích cần quan tâm đến các đặc điểm kỹ thuật
cũng như những yêu cầu nào c a hệ thống đối với ngư i dùng đầu cuối (end-user).
Trong thực tế, giai đoạn này là xây dựng mô hình vật lý c a hệ thống thông tin từ mô
hình được phân tích hệ thống nên phải tập trung để quyết định các vấn đề liên quan như
chọn chiến lược nào để cài đặt data-stores như data structure, file hoặc database; xác
định các nguồn tài nguyên (resources) và cơ chế để kiểm soát việc truy xuất chúng,…
3.2.3 Thi t k đ i t ng
Trong giai đoạn thiết kế đối (Object design stage), các chi tiết c a giai đoạn phân tích
hệ thống và thiết kế hệ thống trên sẽ được cài đặt (implemented). Các đối tượng được
xác định trong giai đoạn thiết kế hệ thống sẽ được thiết kế. Việc thiết kế các đối tượng
này là chia mỗi nhóm đối tượng có đặc tính giống nhau được đại diện b i một đối tượng
phần mềm (class) cũng như những cách chúng tương tác với nhau (thông qua mối kết
hợp Has-a hoặc mối liên kết thừa kế sự Is-a giữa chúng) để thực hiện đầy đ và trọn vẹn
các yêu cầu đề ra.
Các đoạn này được thực hiện nh vào quá trình trừu tượng hóa.
3.2.3.1 Trừu tượng hóa
Một trong những cơ chế then cơ nhất c a hướng đối tượng là sự trừu tượng hóa
(abstraction). Trừu tượng là một phương pháp mạnh mẽ để quản lý xuyên suốt các hệ
thống ph c tạp và nó được dùng để xác định các loại đối tượng, sự tương tác cũng như
phân loại theo th bậc c a chúng.
Các đối tượng này được xác định dựa vào nguyên lý OBD, mà đó một tập các đối
tượng tương tự nhau sẽ được quan sát và các đặc điểm chung c a chúng sẽ được liệt kê
ra. Mỗi nhóm đối tượng giống nhau này được đại diện b i các thuộc tính và các phương
th c c a chúng và ta gọi là lớp đối tượng (class).
Hình 3.8: Từ quan niệm tới đối tượng phầm mềm
Như vậy, quá trình trừu tượng hóa sẽ được dùng để hình thành được một mô hình các
đối tượng (model hay abstraction). Khi xây dựng mô hình (model), chúng ta cần tránh
rơi vào các m c chi tiết, mà thay vào đó cần tập trung vào một số tính năng quan trọng
c a hệ thống. Quá trình này thư ng được dùng với một thuật ngữ khác là sự che dấu
thông tin (Information Hiding).

Lưu ý r ng, việc trừu tượng ra c a một lớp đối tượng thay đổi tùy theo vào mỗi ng
dụng cụ thể c a nó. Chẳng hạn hạn như khi trừu tượng để định nghĩa một lớp các đối
tượng cây bút (lớp Pen) cửa tiệm, các thuộc tính có thể quan tâm như là: màu s c bút,
màu mực, loại bút,… trong khi đó, nếu ta định nghĩa một lớp Pen mà hệ thống quản lý
nó là xư ng sản xuất thì các thuộc tính quan tâm có thể khác trên như: hình dạng,
đư ng kính, kích thước,… c a nó.
Có nhiều m c (layers) c a sự trừu tượng hóa: M c trừu tượng cao nhất là dự án
đang quan tâm sẽ được xem xét như một cộng đồng các đối tượng tương tác với nhau để
đạt được những mục đích chung đề ra. M c trừu tượng tiếp theo là nhóm (group) các đối
tượng hoạt động chung với nhau thành một đơn vị (unit) như package trong java,
namespace trong C++ hoặc unit trong Delphi để dễ quản lý. M c trừu tượng th 3 đó là
cung cấp dịch vụ (service) cho nhau giữa các đối tượng.
Khi ta xem xét sự tương tác giữa 02 lớp đối tượng riêng biệt trên mô hình dịch vụ thì
đó chính là sự tương tác giữa client và server. Trong đó server có thể là một Interface
trong Java (như ví dụ 3.3) để cung cấp những dịch vụ là các ch c năng (abstract
behaviors/methods) cần phải có, còn client như là các lớp hoặc các lớp trừu tượng để cài
đặt cụ thể các dịch vụ c a server. Khái niệm này sẽ được đề cập thêm trong phần truyền
thông điệp (messages) giữa các đối tượng phần sau.
Ví d 3.3: Vai trò server c a interface List<E> phục vụ cho client là lớp trừu tượng
AbstractList<E>
interface List <E>{
public boolean add(E e);
public boolean add(int index, E element);
public Iterator<E> iterator();
//…
}
public abstract class AbstractList<E> extends AbstractColletion <E>
implements List <E> {
//…
}
M c trừu tượng tiếp nữa đó là xem xét trong cùng một phạm vi phía server thì nó
phục vụ được gì từ phía client. Vs dụ như cùng List<E> nhưng phía Client có thể là
LinkedList, có thể là ArrayList, Stack hoặc Vector.

Hình 3.9: Dịch vụ và cung cấp dịch vụ
M c trừu tượng sau cùng là trừu tượng để thực hiện một nhiệm vụ (a single task,
single method) riêng biệt duy nhất. Những quan tâm m c trừu tượng này là một dãy
chính xác các thao tác tuần tự được sử dụng để thực hiện cho hoạt động (activity) đó.
Một dạng khác c a trừu tượng hóa còn là sự áp đặt cấu trúc (structure) lên một hệ
thống c a dự án đang phát triển. Dạng trừu tượng cấu trúc này có thể phản ảnh một số
khía cạnh thực tế c a hệ thống hoặc giúp chúng ta hiểu rõ được hệ thồng ph c tạp c a dự
án hơn. Có thể thực hiện điều này thông qua nhiều cơ chế khác nhau như: Phân chia
thành các bài toán con (division into parts), Sự bao gói và thay thế lẫn nhau
(Encapsulation and interchangeability), giao diệm và lớp cài đặt (interface and
implementation), dịch vụ (service view), các thành phần kết hợp Has-a (composition),
chuyên biệt hóa Is-a (specialization), và các mẫu (patterns) . Một số trong các phần này
sẽ được trình bày các chương sau.
3.2.3.2 Thừa kế
Có thể nói sự trừu tượng có mặt trong suốt quá trình phát triển phần mềm hướng đối
tượng. Trong giai đoạn thiết kế đối tượng (Object design stage), sự trừu tượng còn được
thể hiện rõ nét hơn trong khái niệm thừa kế. Thừa kế (Inheritance) là một trong những
nguyên lý quan trọng nhất c a OOP, khái niệm này được sử dụng cho ý tư ng về tính tái
sử dụng (reusability) c a các lớp đối tượng: Một lớp đối tượng mới có thể được định
nghĩa b ng cách sử dụng (một) lớp tương tự đã tồn tại và thêm vào một vài đặc điểm mới
cần quan tâm.
Bên cạnh việc dữ liệu là trung tâm, OOP còn thêm vào nhiều ý tư ng mới quan trọng
như cơ chế gửi nhận thông điệp (messages) và đa hình (polymorphism).
3.2.4 Giai đo n cƠi đặt
Giai đoạn cài đặt (Implementation) này, các đối tượng được thiết kế sẽ được cài đặt
hay lập trình theo ngôn ngữ lập trình hướng đối tượng nào đó, chẳng hạn b ng Java hoặc
.Net, .PHP,…

Ví d 3.4: Cài đặt lớp DienVien b ng mã lệnh Java
class DienVien{
public String hoTen;
private Boolean gioiTinh;
private Integer tuoi;
public void dienHai(){
//...
}
public void lamGiamKhao(){
//...
}
public void lamMC(){
//...
}
}
Ví d 3.5: Minh họa tính trừu tượng hóa để xây dựng mô hình đối tượng cho bài toán
(đơn giản) quản lý máy laptop c a hãng Toshiba như hình 3.12.
Hình 3.12: Một sản phẩm máy laptop trên thị trường
Giai đoạn phân tích, thiết kế đối tượng: Để lưu giữ các thông tin sản xuất về máy
laptop, các nhà quản lý Toshiba sẽ định nghĩa ra một lớp ToshibaLaptop chẳng hạn.
Trong đó có các trư ng để lưu giữ các thông tin như số đơn vị hệ thống (system unit
number), số hiệu mẫu (model/part number) và số sơ-ri (serial number). Các hành vi/hoạt
động c a máy có thể thực hiện được như: kh i động máy, nhập/xuất và xử lý dữ liệu,…
Như vậy ta có thể định nghĩa một lớp máy laptop Toshiba qua các m c như sau:

Hình 3.13: Minh họa các m c thiết kế một lớp
Mỗi đối tượng (phần mềm) lưu trữ trạng thái c a nó trong các biến trư ng (fields) và
thực hiện các hành vi c a mình thông qua các phương th c, chẳng hạn như máy laptop
hình 3.12 là một thể hiện (sản phẩm cụ thể) mà hãng Toshiba đưa ra thị trư ng.
Hình 3.14: Đối tượng myLaptop
Dựa vào giá trị các trạng thái c a các thuộc tính mà hãng sẽ phân biệt được máy này
với các máy cùng loại được phân phối trên toàn thế giới.
Sau khi đã có mô hình đối tượng, kế đến là giai đoạn cài đặt mã lệnh Java cho lớp
ToshibaLaptop như sau:
class ToshibaLaptop {
private String systemUnitNumber;
private String modelNumber;
private String serialNumber;
void boot() {
// ...
}
void readData() {
// ...

}
void writeData() {
// ...
}
void processing() {
// ...
}
}
3.3 Quá trình phát triển ch ng trình h ng đ i t ng
Theo các tác giả R. Morelli và R.Walde, quá trình phát triển chương trình được thể
hiện b i hình 3.15. Trong sơ đồ này, bước đầu là phải xác định rõ được các vấn đề c a
dự án. Tiếp đến, phân rã bài toán ban đầu thành các bài toán nhỏ hơn dựa trên nguyên t c
chia-để-trị (the divide-and-conquer principle) với tư duy xác định các đối tượng có thể
có trong hệ thống và các kịch bản mà chúng sẽ tương tác với nhau như thế nào. Bước th
ba là quá trình trừu tượng hóa để tạo ra một mô hình (model) các đối tượng trên nền tảng
đối tượng (OBP-Object-based programming) hoặc hướng đối tượng. Hay nói cách khác,
đây là bước phân tích và thiết kế sơ đồ lớp theo nền tảng OBP hoặc m rộng hơn OOP.
Bước 4 là viết mã lệnh Java, và bước cuối cùng là kiểm thử và chỉnh sửa.
Hình 3.15: Sơ đồ phát triển chương trình

Dưới đây là một ví dụ ng n gọn để minh họa việc phân tích và thiết kế hướng đối
tượng cho một ng dụng là trò chơi tung xúc s c.
Ví d 3.6: Phân tích và thiết kế hướng đối tượng cho trò chơi đơn giản xúc s c ắDice
gameẰ mà ngư i chơi đươc tung 2 lần. Nếu tổng điểm b ng 7 thì th ng ngược lại thua.
B c 1 - Xác đ nh s đồ use cases: Yêu cầu ngư i chơi phải l c xúc x c hai lần. Hệ
thống sẽ hiển thị kết quả: Nếu giá trị mặt xúc x c có tổng cộng bảy, ngư i chơi chiến
th ng; ngược lại, ngư i chơi bị thua.
Hình 3.16: Use case c a trò chơi
B c 2 - Xác đ nh mô hình mi n (Domain model = static view + conceptual
class): Gồm các lớp khái niệm là Player, Die, và DiceGame, cùng với các mối kết hợp
(associations) và các thuộc tính c a chúng.
Hình 3.17: Mô hình miền c a trò chơi
B c 3 - Xác đ nh biểu đồ t ng tác (Interaction Diagrams = dynamic view): Để
minh họa cho quá trình tương tác c a các đối tượng b ng sơ đồ trình tự (sequence
diagram). Nó chỉ ra một cách tuần tự các thông điệp (message) giữa các đối tượng phần
mềm, và các l i gọi phương th c tương ng.
Hình 3.18: Mô hình tương tác c a trò chơi

B c 4 - Xác đ nh s đồ l p thi t k (Design class diagrams = Static view): Ngược
lại với mô hình miền, sơ đồ này không minh họa các lớp khái niệm trong thế giới thực
mà nó chỉ ra các lớp phần mềm (software classes) bao gồm các thuộc tính và phương
th c c a các lớp .
Hình 3.19: Sơ đồ lớp c a trò chơi
3.4 Các đặc tính của l p h ng đ i t ng Java
Lập trình hướng đối tượng là phương pháp lập trình dựa trên OBP và có m rộng
thêm tính thừa kế và đa hình. Như vậy, tổng quát, phương pháp lập trình hướng đối
tượng có các đặc tính sau:
3.4.1 Tính trừu t ng
Như đề cập trên, trừu tượng hóa công cụ để xây dựng được mô hình (model) c a hệ
thống thực hướng đối tượng. Nó được sử dụng xuyên suốt từ giai đoạn phân tích đến giai
đoạn cài đặt mã lệnh, thuật toán. Nh vào các phương c a trừu tượng mà một bài toán
ban đầu ph c tạp khó hình dung, dần dần tr nên rõ ràng, cụ thể và có thể cài đặt được.
Trong giáo trình này, việc trừu tượng hóa sao cho giải quyết được một bài toán đang
xét trong thế giới thực vào hệ thống máy tính b ng phương pháp hướng đối tượng thông
qua kỹ thuật mô hình hóa đối tượng (Object-modeling technique), chỉ yêu cầu giới hạn
qua (ít nhất) hai bước sau:
Bước 1: Xây dựng mô hình tĩnh các lớp đối tượng (sơ đồ lớp) hoặc mô hình động
(mô hình tuần tự) giữa các đối tượng.
Bước 2: Sử dụng ngôn ngữ Java, với các tính năng mạnh c a nó, để viết và cài đặt
bài toán (dự án, một hệ thống IT đang quan tâm) đã được thiết kế bước trên.
3.4.2 Tính bao đóng
Tính bao đóng (encapsulation): Là việc cài đặt mã lệnh cho các phương th c nội tại
và cách th c truy xuất các thuộc tính c a lớp thành một đơn vị duy nhất  Cung cấp một
cơ chế duy nhất để bảo vệ dữ liệu (che dấu và bảo vệ dữ liệu khỏi ngư i dùng muốn can
thiệp hoặc thao tác sai mục đích) là thông qua các interfaces (methods) mới có thể
modify được các dữ liệu.

Hình 3.20: Bao đóng
3.4.3 Tính thừa k
Thừa kế (inheritance): Là một cơ chế cho phép lập trình viên định nghĩa lớp con mới
(child/ sub/ derived class) b ng cách m rộng từ (các) lớp cha/cơ s (parent/ super/
base class) đã tồn tại. Lớp con thừa hư ng các đặc điểm (properties = attribute +
operations) từ lớp cha trong phạm vi truy xuất được phép. Quá trình phân tích tìm các
lớp con dẫn xuất từ lớp cha được thực hiện qua cơ chế chuyên biệt hoá (specialization).
Hình 3.21: Thừa kế
Thừa kế là một trong những đặc tính quan trọng nhất trong phương pháp hướng đối
tượng và có thể nói đó là một cuộc cách mạng c a lĩnh vực công nghệ phần mềm trong
những năm gần đây.
3.4.4 Tính đa hình
Đa hình (polymorphism): là khả năng đảm nhận nhiều dạng: Một hành động (thông
qua phương th c) được đối tượng thực hiện b ng nhiều cách khác nhau, và các đối
tượng khác loại có thể thực hiện chung một ng xử theo cách riêng c a mình.

3.4.5 Tính b n vững
Mục đích c a tính bền vững (persistence) là lưu giữ sự tồn tại c a đối tượng lâu hơn
sự thực thi c a chương trình.
JFC sử dụng tuần tự hoá (serialization): Cơ chế để đảm bảo sự bền vững là sự tuần tự
hóa - java.io.Serializable; Nó chuyển đổi dữ liệu (đối tượng) vào luồng (byte stream) và
ghi nó vào tập tinđể lưu trữ - sử dụng phương th c writeObject(). Sau đó, chương trình
sẽ được java bean khôi phục lại b ng cơ chế deserialization để có được trạng thái ban
đầu c a đối tượng - sử dụng phương th c readObject().
Hình 3.22: Native Java persistence
Với công nghệ Java, các framework được phát triển để hỗ trợ cho tính năng
persistence như: JPO/OpenJPA, TopLink, EclipseLink, Hibernate,…
Hình 3.23: Persistence frameworks
3.4.6 Tính đồng b hóa
Cơ chế đồng bộ hóa (concurrency) cho phép thực hiện nhiều ch c năng/công việc tại
một th i điểm. Ví dụ như hệ điều hành đa nhiệm - Java thực hiện thông qua cơ chế tiến
trình (processes) và tuyến đoạn (threads) và tuần tự hoá (synchronization). Java API là
gói java.util.concurrent; Chú ý: Concurrent và Synchronized collection class đều cung

cấp thread-safety, nhưng Synchronized collection như HashMap, ArrayList lại chậm
hơn Concurrent collection như ConcurrentHashMap, CopyOnWriteArrayList. Lý do
chính là khi locking, Synchronized collection lock toàn bộ đối tượng (whole object)
trong khi đó Concurrent collection lại sử dụng thread-safety thông minh hơn (smartly).
3.4.7 Tính ủy quy n
Tính y quyền (delegation) là ch c năng cho phép một phương th c method_A c a
lớp A thực hiện một nhiệm vụ thông qua một phương th c method_B lớp B. Điều này
có thể thực hiện được thông qua các mối kết tập (associations) và và thừa kế
(inheritance).
3.4.8 Tính tổng quát
Tính tổng quát (generics) cho phép các kiểu dữ liệu classes và interfaces là các tham
số khi định nghĩa lớp, giao diện và phương th c. Các tham số kiểu (type parameters)
cung cấp một cách để bạn có thể tái sử dụng cùng một đoạn mã (lớp generics, giao diện
generics và phương th c generic) với các kiểu dữ liệu đầu vào khác nhau.
Với Java generics, cho phép sự trừu tượng hóa có đặc tính đa hình (parametric
polymorphism) cũng như thừa kế các lớp generics.
Tóm l i: Trong phương pháp OOP, bốn nguyên lý chính được đề cập là: Trừu tượng,
bao đóng, thừa kế và đa hình.
Bài t p ch ng 3
Bài 3.1: Hình dung bạn đang gia đình, hãy liệt kê càng nhiều càng tốt:
- Các đối tượng và số lượng có trong gia đình bạn
- Cho biết những đối tượng nào chung loài (lớp) nhau
- Với mỗi loại đối tượng đó có những đặc điểm và hoạt động nào có thể có
Bài 3.2: Hãy trừu tượng hóa để xây dựng mô hình cho mỗi một đối tượng trong môi
trư ng học tập bậc đại học:
- Đối tượng sinh viên
- Đối tượng giảng viên
- Đối tượng chuyên viên
- Đối tượng môn học/ học phần
- Đối tượng lớp học
Bài 3.3: Hãy liệt kê ra ít nhất 03 mô hình (mỗi mô hình có nhiều nhất là 3 lớp) mà có
tính thừa kế b ng ngôn ngữ tự nhiên hoặc sơ đồ UML.
Bài 3.4: Sử dụng ngôn ngữ tự nhiên, hãy chỉ ra một ví dụ có trong thực tế tự nhiên
hoặc những sản phảm nhân tạo mà có tính đa hình.
Bài 3.5: Dịch vụ ATM mà bạn được cung cấp để giao dịch thông qua thẻ có thể có
những đặc tính nào c a hướng đối tượng? Hãy nêu ra và cho ví dụ cụ thể để minh họa
điều đó.

Ch ng 4.
L p, đ i t ng, truy n thông đi p và gói
Trong chương này sẽ trình bày các kiến th c về lớp, việc tạo và h y các đối tượng,
các cách truyền tham số kiểu dữ liệu nguyên th y và kiểu đối tượng, cách truyền nhận
thông điệp giữa chúng và cách gom các lớp vào chung một gói (một không gian tên
vùng) theo ngôn ngữ Java.
4.1 L p
4.1.1 Khái ni m
Lớp (class) đại diện cho một mẫu các đối tượng (vật thể hoặc phi vật thể) có chung
những đặc điểm giống nhau, bao gồm các tên trư ng (fields) và các phương th c
(methods) c a nó. Trong sơ đồ UML, ngư i ta thư ng sử dụng thêm thuật ngữ khác đó
là tên thuộc tính (attributes) thay cho tên trư ng, và hành vi (behaviors/ operations) thay
cho phương th c.
Trên sơ đồ UML, lớp có 03 phần là Tên lớp (Class name), các thuộc tính và hành vi
như hình 4.1:
Hình 4.1: Ký hiệu UML cho lớp
Ví d 4.1: Các thầy cô giảng dạy trong trư ng Đại học Cần Thơ đều là đối tượng
giảng viên nên định nghĩa một lớp GiangVien đại diện cho các thầy cô trong trư ng.
Hình 4.2: Định nghĩa lớp giảng viên
Lớp Giảng viên, ta quan tâm đến 03 thông tin: Mã số giảng viên, họ tên, chuyên
ngành, và 02 phương th c là: giảng dạy học phần và nghiên c u khoa học.
4.1.2 L p tự đ nh nghĩa
Trong ngôn ngữ Java, lập trình viên có thể định nghĩa một lớp để đại diện cho một
nhóm các đối tượng có chung những thuộc tính và phương th c như cú pháp sau.

4.1.2.1 Cú pháp khai báo tổng quát
[Doc comment]
[Modifier] class Identifer [extends SuperClassName]
[implements Interfaces] {
ClassBody; //Members
}
Trong đó, từ khóa (keyword) class đ ng trước một danh hiệu là tên lớp (Identifer)
và cặp dấu móc nhọn { } để b t đầu và kết thúc một lớp. Các thành phần tùy chọn (trong
cặp [ ]) còn lại sẽ được đề cập sau.
Với ClassBody là phần định phần nghĩa thân c a lớp. Nó gồm phần khai báo các
thuộc tính (còn được gọi là biến thành viên member variables) và các phương th c hay
còn được gọi những phương th c thành viên (member methods).
Cú pháp chi tiết c a lớp tự định nghĩa:
[Doc comment]
[Modifier] class Identifer [extends SuperClassName]
[implements Interfaces] {
[Modifier] dataType fieldName1;
[Modifier] dataType fieldName2;
//...
[Modifier] returnType Identifer1( [ParameterList] )[throws] {
MethodBody
}
[Modifier] returnType Identifer2( [ParameterList] )[throws] {
MethodBody
}
//…
}
Trong đó, cần phân biệt các loại biến khác nhau: Các biến thành viên được gọi là các
trư ng (fields), các biến trong phương th c hoặc trong khối lệnh là các biến cục bộ
(local variable), và các biến trong phần khai báo trong chữ ký phương th c (method
signature) được gọi là các tham số (parameters).
Ví d 4.2: Với thực thể giảng viên trong sơ đồ UML hình 4.2 trên, ta có lớp
GiangVien theo ngôn ngữ Java như sau:

public class GiangVien {
private String maGV;
public Boolean gioiTinh;
public void giangDay(String maHP) {
//cài đặt thân phương thức
}
protected void nghienCuuKH() {
//cài đặt thân phương thức
}
}
4.1.2.2 Kiểm soát truy cập đến các thành viên của lớp
Các bổ từ m c độ truy cập (access level modifiers) xác định xem liệu các lớp khác
có thể sử dụng biến trư ng hoặc gọi đến một phương th c cụ thể nào đó c a nó hay
không. Có hai cấp độ kiểm soát truy cập đến các thành viên c a một lớp:
mức lớp (class level/ top level): được xác định b i bổ từ truy cập đ ng ngay trước
từ khóa class. Nó có 2 dạng public hoặc không có modifier.
public: Lớp sẽ được truy cập mọi nơi trong dự án – anywhere.
Không có modifier: Lớp chỉ được truy cập trong phạm vi cùng gói
(package-private hay friendly).
mức các thành viên của lớp (member level): được xác định b i bổ từ truy cập
đ ng trước tên biến trư ng hoặc trước tên mỗi phương th c (fields và methods). Nó có
thể là một trong 4 bổ từ truy cập sau:
private: Các thành viên chỉ có thể truy xuất được phạm vi bên trong lớp c a
chính nó mà thôi, ngay cả các thành viên lớp con cũng không thể truy xuất tới
được (không được thừa kế).
public: Các thành viên c a lớp sẽ được truy cập từ tất cả các lớp khác.
Không có modifier (friendly/ package access): Trong cùng gói là public còn
khác gói là private.
protected: Các thành viên được truy xuất b i các phương th c cùng lớp, các
phương th c trong các lớp con (được thừa kế) và các phương th c khác lớp
nhưng phải cùng gói.
Ví d 4.3: Định nghĩa kiểu dữ liệu lớp HinhTron mà lớp này và phương th c
tinhDienTich được truy xuất mọi nơi, biến trư ng banKinh chỉ được truy xuất trong
thân c a lớp HinhTron, còn phương th c tinhChuVi được truy xuất trong phạm vi c a
gói hiện hành.

public class HinhTron { // mức lớp: public
private double banKinh; // mức thành viên: private
double tinhChuVi() { // mức thành viên: friendly
return 2 * Math.PI * banKinh; // có phương thức thể hiện
}
public double tinhDienTich() { // mức thành viên: public
return Math.PI * banKinh * banKinh;
}
}
4.1.2.3 L p t n cùng
Ngoài các bổ từ truy cập trên, còn có các bổ từ khác như final, synchronized,
transient, native,…
Nếu m c lớp được khai báo với bổ từ modifier là final, thì được gọi là lớp tận cùng
(final class), nghĩa là không cho phép m rộng hoặc thừa kế (inheriance) cho các lớp con
làm hậu duệ c a nó.
Nếu m c thành viên được khai báo thêm từ khóa final thì đó là phương th c h ng
(final method) hoặc biến h ng (final variable). Với phương th c h ng, thì không được
phép ghi chồng (over-riding) lên nó.
4.2 Đ i t ng
4.2.1 Khái ni m
Đối tượng (object) là một thể hiện, instance, c a một lớp. Mỗi đối tượng phần mềm
(A software object) lưu giữ các trạng thái (states) c a nó trong các biến trư ng (fields)
ngay tại mỗi th i điểm run-time và được gọi là giá trị hiện hành c a đối tượng (object's
data, và thực hiện các hành vi (behaviors) c a nó b ng các phương th c (methods).
Phương th c là khối lệnh có cấu trúc (như phương pháp lập trình hướng th tục) được
cài đặt để thao tác trên các biến trư ng (setter/getter) c a đối tượng cũng như thực hiện
hành vi khác c a nó mà điển hình nhất là để truyền nhận thông điệp (message passing)
giữa các đối tượng với nhau.
4.2.2 T o đ i t ng
Trước khi tạo đối tượng, chúng ta cần biết đối tượng sẽ được tạo ra từ một trong các
lớp chuẩn Java, hoặc các lớp tự định nghĩa nào. Mỗi đối tượng có một định danh
(identity/ name) để phân biệt nhau như: gv1, gv2 và được tạo ra thông qua từ khóa new
trong Java.

Hình 4.3: Tạo 2 đối tượng gv1, gv2 từ lớp Giảng viên
Cách 1: Khai báo và kh i tạo riêng biệt
TênLớp biếnThamChiếu;
biếnthamChiếu = new TênLớp([Các đối số]);
Biến tham chiếu (reference variable) là biến lưu trữ giá trị địa chỉ ô nhớ c a đối
tượng được tạo mà nó trỏ đến. Nếu đối tượng chưa được tạo thì địa chỉ c a ô nhớ đó
chưa xác định, còn ngược lại thì địa chỉ ô nhớ đó sẽ được cấp phát để ch a đối tượng.
Chú ý r ng, trong Java, địa chỉ c a các biến c a tham chiếu được quản lý b i Stack,
còn địa chỉ ch a đối tượng thì được quản lý b i Heap.
Ví d 4.4: HinhTron ht1; //khai báo biến tham chiếu ht1
Biến ht1 được gọi là tham chiếu đến đối tượng lớp hình tròn nhưng đối tượng chưa
được tạo ra (địa chỉ Heap c a đối tượng hình tròn chưa xác định, no object instance)
ht1 = new HinhTron();
Biến ht1 được gọi là tham chiếu đối tượng (object reference) hình tròn. Các cách
đọc khác có thể là: tham chiếu (tới đối tượng hình tròn) ht1; hoặc: Địa chỉ ch a đối
tượng hình tròn được trỏ b i tham chiếu ht1.
Ta cũng có thể h y và giải phóng đối tượng khỏi bộ nhớ b ng cách gán giá trị null
cho tham chiếu đối tượng như lệnh:
ht1 = null; //null reference
Cách 2: Khai báo và kh i tạo
TênLớp biếnThamChiếu = new TênLớp([Các đối số]);
Ví d 4.5: Khai báo và kh i tạo biến tham chiếu ht2 tới đối tượng HinhTron
HinhTron ht2 = new HinhTron();
Sau khi đã khai báo và kh i tạo, để truy xuất đến các biến trư ng và phương th c c a
đối tượng xem hình 4.4, ta sử dụng theo dạng sau:

thamChiếuĐốiTượng.tênBiếnTrư ng
thamChiếuĐốiTượng.tênPhươngThức([Các_đối_số])
Hình 4.4: Minh họa intelligent code completion c a Eclipse IDE
Sau đây là một số ví dụ minh cách cấp phát và quản lý bộ nhớ cho loại biến nguyên
th y và biến kiểu đối tượng trong Java:
Hình 4.5: Minh họa cấp phát trong Stack và Heap
Ví d 4.6: Viết chương trình (theo OBP) để tạo một hình tròn có toạ độ tâm
O(50,100), bán kính b ng 30 và hiển thị thông tin và diện tích c a nó.
//File name: LopChinh.java
class HinhTron {
int x = 50;
int y = 100;

double banKinh = 30;
double tinhDienTich() {
return Math.PI * Math.pow(banKinh, 2);
}
}
public class LopChinh {
HinhTron ht = new HinhTron();
System.out.printf("Hình tròn vừa tạo có tâm O(%d,%d)" +
" và diện tích= %.4fn", ht.x, ht.y, ht.tinhDienTich());
}
}
4.3 Thành viên thể hi n và thành viên l p
Khi định nghĩa một lớp, chúng ta cần chú ý phân biệt rõ hai ch c năng cho hai loại
biến trư ng và phương th c (gọi chung là các thành viên, members) đó là các thành viên
thể hiện (instance members) và các thành viên lớp (class members) .
4.3.1 Thành viên thể hi n
Là các biến thể hiện (instance variables) và các phương th c thể hiện (instance
methods). Đây là phần dữ liệu dành riêng cho mỗi đối tượng được tạo ra. Với cách này,
địa chỉ c a mỗi đối tượng được tạo sẽ lưu vào trong vùng nhớ riêng biệt nhau.
Mục đích sử dụng tính năng này là khi chúng ta muốn các đối tượng được tạo ra
cùng từ một lớp nhưng giá trị c a các thuộc tính (hay trạng thái) giữa chúng là được lưu
giữ riêng biệt nhau. Ví dụ như: giá trị mã số sinh viên, họ tên, tuổi,… c a mỗi sinh viên
là khác nhau nên chúng được gọi là biến thể hiện.
Với các phương th c thể hiện thì có thể thao tác/truy xuất trên cả hai loại biến
trư ng: biến thể hiện (instance variables) và biến lớp (class variables).
4.3.2 Thành viên l p
Ngược lại với instance member, các thành viên (c a) lớp bao gồm các biến lớp (class
variables) và phương th c lớp (class methods). Nó được xác định b i từ khóa static,
được khai báo đ ng trước mỗi biến trư ng hoặc phương th c.
Đây là phần dữ liệu dành riêng cho lớp và được truy xuất trực tiếp b i tên lớp. Với
cách này, các thành viên c a các đối tượng được tạo ra từ một lớp sẽ có chung địa chỉ
c a biến lớp và được xem như biến dùng chung cho các đối tượng được tạo ra cùng từ
một lớp.
Từ các phương th c thể hiện, chúng ta có thể truy xuất đến các biến thể hiện cũng
như các biến lớp. Ngược lại, từ các phương th c lớp, chúng ta không thể truy cập đến
các biến thể hiện được khai báo trong lớp hiện tại mà chỉ có thể đến các biến lớp và các

phương th c lớp (khác) và không sử dụng từ khóa this và sufer. Các thành viên lớp
được gọi thông qua tên lớp mà không cần phải thông qua tên đối tượng.
Thành viên lớp được sử dụng với mục đích khi chúng ta muốn giá trị thuộc tính (hay
trạng thái) là chia xẻ chung với nhau giữa các đối tượng cùng lớp. Chẳng hạn như: Mỗi
một nhiệm kỳ, mọi ngư i dân Việt nam đều có chung một ông Ch tịch nước, như vậy
thuộc tính ắtên ch tịch nướcẰ c a mỗi đối tượng ngư i Việt là loại biến lớp. Ví dụ khác
sinh động hơn là trong các trò chơi (games), chúng ta thư ng có kịch bản đối kháng giữa
các nhóm đối tượng, nhóm đối tượng A đấu với nhóm các đối tượng B. Nếu số đối tượng
A tồn tại trong hệ thống trong khi số đối tượng B không còn thì ta có thể kết luận ắBên A
th ng bên BẰ. Như vậy việc đếm số lượng các đối tượng tồn tại c a mỗi loại trong hệ
thống thực (run-time) cần phải sử dụng đến biến dùng chung này.
Ví d 4.7: Lớp giảng viên có ch a instance và class members
Hình 4.6: Minh họa thành viên thể hiện và thành viên lớp
//Filename: GiangVien.java
class GiangVien {
public Boolean gioiTinh = true; //Nam
public static String donViCQ = "Đại học Cần Thơ - CTU";
public void giangDay(String maHP) {
System.out.println("Giảng viên: " + maGV+ ", dạy mã số học
phần " + maHP);
}
protected void nghienCuuKH() {
System.out.println("Nghiên cứu trong các lĩnh vực phù hợp.n");
}

System.out.println("Các giảng viên thuộc cơ quan chủ quản: "+
GiangVien.donViCQ +":n");
GiangVien gv1 = new GiangVien();
gv1.maGV = "000001"; gv1.hoTen = "Trần Phước Đường";
gv1.giangDay("SH001"); gv1.nghienCuuKH();
gv2.maGV = "000002"; gv2.hoTen = "Võ Tòng Xuân";
gv2.giangDay("SH002"); gv2.nghienCuuKH();
gv3.maGV = "000514"; gv3.hoTen = "Phạm Thị Xuân Lộc";
gv3.gioiTinh = false; //Nữ
gv3.giangDay("CT106"); gv3.nghienCuuKH();
}
}
4.4 Ph ng thức dựng
Trong quá trình xây dựng lớp, chúng ta thư ng cài đặt các phương th c dựng c a nó.
Phương th c dựng (constructors) được dùng để tạo mới một đối tượng, xác định giá trị
ban đầu cho các thuộc tính c a đối tượng nếu có.
Trong một lớp có thể có nhiều phương th c dựng, tên c a mỗi phương th c dựng
phải giống với tên lớp và là dạng th tục nên nó không có kiểu trả về (kiểu void).
Trong phương th c dụng, từ khóa this thư ng được sử dụng để phân biệt tên biến
trư ng (variables ) với tên tham số hình th c (parametters) nếu chúng có tên giống nhau.
Từ khóa this là một tham chiếu (reference to the current object) chỉ đến đối tượng hiện
hành. Nó được dùng để phân biệt giữa biến thể hiện (instance variables) và các tham số
hình th c khi chúng giống tên nhau
Sử dụng từ khóa super để tham chiếu tới đối tượng thuộc lớp cha. Nó được dùng để
gọi các phương th c, các biến thành viên từ lớp cha. Trong Java có sẵn một phương th c
dựng mặc định (không có tham số) và chúng ta có thể ghi chồng (overriding ) phương
th c mặc định này.
Ví d 4.8: Lớp giảng viên có ch a instance, class members và có constructors
class GiangVien {
public Boolean gioiTinh = true;
public static String donViCQ = "CTU";

Lap trinh HDT Java, Object-Oriented Programming in Java

Lap trinh HDT Java, Object-Oriented Programming in Java

Recomendados

Recomendados

Mais conteúdo relacionado

Mais procurados

Mais procurados (19)

Destaque

Destaque (18)

Semelhante a Lap trinh HDT Java, Object-Oriented Programming in Java

Semelhante a Lap trinh HDT Java, Object-Oriented Programming in Java (20)

Lap trinh HDT Java, Object-Oriented Programming in Java