TLGD LapTrinhJava 2021

TẬP ĐOÀN DỆT MAY VIỆT NAM
TRƯỜNG CAO ĐẲNG CÔNG NGHỆ TPHCM
GIÁO TRÌNH
MÔN HỌC/MÔ ĐUN: LẬP TRÌNH JAVA
NGÀNH/NGHỀ: CÔNG NGHỆ THÔNG TIN
TRÌNH ĐỘ: 12/12
Ban hành kèm theo Quyết định số: /QĐ-... ngày ………tháng.... năm……
...........……… của ……………………
…………, năm 2021
1
TUYÊN BỐ BẢN QUYỀN
Tài liệu này thuộc loại sách giáo trình nên các nguồn thông tin có thể được phép dùng
nguyên bản hoặc trích dùng cho các mục đích về đào tạo và tham khảo.
Mọi mục đích khác mang tính lệch lạc hoặc sử dụng với mục đích kinh doanh thiếu
lành mạnh sẽ bị nghiêm cấm.
LỜI GIỚI THIỆU
Giáo trình “Lập trình Java” được biên soạn để phục vụ cho công tác giảng
dạy và học tập của giảng viên, học sinh, sinh viên chuyên ngành Công nghệ thông tin,
và là tài liệu tham khảo cho các lập trình viên tại các doanh nghiệp. Cấu trúc của giáo
trình gồm 6 chương:
Chương 1 : Tổng quan về Java bao gồm xứ mệnh lịch sử của Java, một số đặc
trưng của java và công cụ để lập trình java
Chương 2 : Ngôn ngữ Java bao gồm các cấu trúc chương trình, các kiểu dữ liệu
cơ bản, kiểu nhập xuất, cấu trúc rẽ nhánh, cấu trúc lặp, mảng 1 chiều, 2 chiều.
Chương 3 : Hướng đối tượng trong Java bao gồm các thành phần trong file mã
nguồn, các class, viết chồng, viết đè, tính kế thừa, tính đa hình trong java
Chương 4 : Lớp xử lý ứng dụng Java bao gồm xử lý loại trừ, xử lý toán học, xử
lý chuỗi trong Java, xử lý ngày tháng, xử lý tập hợp nâng cao.
Chương 5 : Lập trình giao diện bao gồm các thành phần trong giao diện, các
Gui, các Jframe, các Layout Manager.
Chương 6 : Xây dựng ứng dụng Java bao gồm các thành phần ứng dụng, mô
hình 2 lớp, cài đặt jdbc và một số kỹ thuật sử dụng Jdbc.
Trong quá trình biên soạn, mặc dù đã có nhiều cố gắng nhưng không tránh khỏi
những hạn chế và thiếu sót nhất định, tác giả rất mong nhận được những ý kiến đóng
góp của quý đọc giả để giáo trình này ngày càng hoàn thiện hơn.
Xin chân thành cảm ơn.
Tp. HCM, ngày……tháng……năm………
Biên soạn
BỘ MÔN TIN HỌC
MỤC LỤC
Tên môn học: Lập trình Java............................................................................... 1
Chương 1 ................................................................................................................ 6
TỔNG QUAN VỀ JAVA ...................................................................................... 6
1. Xứ mệnh lịch sử của Java ............................................................................... 6
2. Một số đặc trưng của Java .............................................................................. 6
3. Sử dụng Java có thể xây dựng được ứng dụng gì? ....................................... 7
4. Công cụ lập trình JDK .................................................................................... 8
5. Chương trình HelloWord.java với JDK ........................................................ 9
Chương 2 .............................................................................................................. 10
NGÔN NGỮ JAVA ............................................................................................. 10
1. Cấu trúc chương trình .................................................................................. 10
2. Kiểu dữ liệu cơ bản ........................................................................................ 11
3. Chuyển đổi kiểu dữ liệu ................................................................................ 12
4. Nhập xuất console .......................................................................................... 12
5. Cấu trúc rẽ nhánh.......................................................................................... 12
6. Cấu trúc lặp .................................................................................................... 14
7. Mảng 1 chiều .................................................................................................. 15
8. Mảng 2 chiều .................................................................................................. 17
9. Break và Continue ......................................................................................... 18
10. Math ................................................................................................................ 18
Chương 3 .............................................................................................................. 20
HƯỚNG ĐỐI TƯỢNG TRONG JAVA ........................................................... 20
1. Các thành phần trong file mã nguồn (*.java) ............................................. 20
2. Khai báo class................................................................................................. 20
3. Modifiers......................................................................................................... 20
4. Viết chồng và viết đè (Overloading & Overriding) .................................... 21
5. Giao tiếp (interface) ....................................................................................... 22
6. Kế thừa trong java ......................................................................................... 22
7. Tính đa hình trong java ................................................................................ 25
Chương 4 .............................................................................................................. 28
LỚP XỬ LÝ ỨNG DỤNG JAVA ...................................................................... 28
1. Xử lý loại trừ (ngoại lệ) ................................................................................. 28
2. Xử lý toán học ................................................................................................ 30
3. Xử lý chuỗi trong java ................................................................................... 31
4. Xử lý ngày tháng ............................................................................................ 34
5. Xử lý tập hợp nâng cao ................................................................................. 35
Chương 5 .............................................................................................................. 39
LẬP TRÌNH GIAO DIỆN .................................................................................. 39
1. Các thành phần giao diện ............................................................................. 39
2. Java Gui Api................................................................................................... 39
3. Jframe ............................................................................................................. 41
4. Layout Manager ............................................................................................ 41
5. Điều khiển sự kiện ......................................................................................... 42
Chương 6 .............................................................................................................. 44
XÂY DỰNG ỨNG DỤNG JAVA ...................................................................... 44
1. Các thành phần ứng dụng java .................................................................... 44
2. Mô hình 2 lớp ................................................................................................. 44
3. Cài đặt jdbc .................................................................................................... 44
4. Một số class và interface của Jdbc Api ........................................................ 45
5. Một số kỹ thuật sử dụng Jdbc ...................................................................... 47
THỰC HÀNH 1: NGÔN NGỮ JAVA............................................................... 49
THỰC HÀNH 2: JAVA + NETBEANS ............................................................ 51
BÀI TẬP TỔNG HỢP 1 ..................................................................................... 70
BÀI TẬP TỔNG HỢP 2 ..................................................................................... 71
BÀI TẬP TỔNG HỢP 3 ..................................................................................... 72
BÀI TẬP TỔNG HỢP 4 ..................................................................................... 73
BÀI TẬP TỔNG HỢP 5 ..................................................................................... 74
BÀI TẬP TỔNG HỢP 6 ..................................................................................... 75
BÀI TẬP TỔNG HỢP 7 ..................................................................................... 76
Tài liệu tham khảo .............................................................................................. 77
GIÁO TRÌNH MÔN HỌC/MÔ ĐUN
Tên môn học: Lập trình Java
Mã môn học: MH 22
Thời gian thực hiện môn học: 75 giờ; (Lý thuyết: 15 giờ; Thực hành, thí nghiệm, thảo
luận, bài tập: 55 giờ ; Kiểm tra: 5 giờ)
I. Vị trí, tính chất của môn học:
- Vị trí: học sau môn cấu trúc dữ liệu, Lập trình hướng đối tượng.
- Tính chất: môn học chuyên môn bắt buộc.
II. Mục tiêu môn học:
- Về kiến thức:
+ Hiểu được cấu trúc và các thành phần cơ bản của ngôn ngữ Java.
+ Làm quen với môi trường lập trình Java và các ứng dụng thực tế.
+ Lập trình giao diện người dùng bằng ngôn ngữ Java.
+ Hiểu và vận dụng công nghệ mới để xây dựng ứng dụng bằng ngôn ngữ Java.
- Về kỹ năng:
+ Hình thành và phát triển khả năng giải quyết các bài toán lập trình.
+ Xây dựng chương trình ứng dụng bằng ngôn ngữ Java.
+ Rèn luyện kỹ năng lập trình, khả năng tư duy về lập trình hướng đối tượng.
- Về năng lực tự chủ và trách nhiệm:
+ Hình thành niềm say mê lập trình, tin thần không ngừng học hỏi.
+ Nhạy bén với cái mới, chủ động thích ứng với thay đổi.
III. Nội dung môn học:
1. Nội dung tổng quát và phân bổ thời gian:
Thời gian (giờ)
Thực hành,
Số
Tên chương, mục Tổng Lý thí nghiệm, Kiểm
TT
số thuyết thảo luận, tra
bài tập
1 Chương 1: Tổng quan về Java 5 1 4
2 Chương 2: Ngôn ngữ Java 15 3 11 1
3 Chương 3: Hướng đối tượng trong Java 15 3 10 2
4 Chương 4: Lớp xử lý ứng dụng Java 10 2 8
5 Chương 5: Lập trình giao diện 10 2 8
6 Chương 6: Xây dựng ứng dụng Java 20 4 14 2
Cộng 75 15 55 5
2. Nội dung chi tiết:
Chương 1: Tổng quan về Java Thời gian: 5 giờ
1. Mục tiêu:
- Trình bày được các đặc trưng trong Java.
- Nêu được các ứng dụng thường được viết bằng ngôn ngữ Java.
- Tạo được chương trình đơn giản bằng Java.
1
2. Nội dung chương:
2.1. Xứ mệnh lịch sử của Java
2.2. Một số đặc trưng của Java
2.3. Sử dụng Java có thể xây dựng được ứng dụng gì?
2.4. Công cụ lập trình JDK
2.5. Chương trình HelloWord.java với JDK
Chương 2: Ngôn ngữ Java Thời gian: 15 giờ
1. Mục tiêu:
- Trình bày được các cấu trúc trong Java.
- Xây dựng được chương trình bằng các cấu trúc Java như cấu trúc rẽ nhánh, cấu trúc
lặp, mảng 1 chiều, mảng 2 chiều…
2.1. Cấu trúc chương trình Thời gian: 1 giờ
2.2. Kiểu dữ liệu cơ bản Thời gian: 1 giờ
2.3. Chuyển đổi kiểu dữ liệu Thời gian: 1 giờ
2.4. Nhập xuất Console Thời gian: 1 giờ
2.5. Cấu trúc rẽ nhánh Thời gian: 2 giờ
2.6. Cấu trúc lặp Thời gian: 2 giờ
2.7. Mảng 1 chiều Thời gian: 2 giờ
2.8. Mảng 2 chiều Thời gian: 2 giờ
2.9. Break và Continue Thời gian: 1 giờ
2.10. Math Thời gian: 1 giờ
Kiểm tra Thời gian: 1 giờ
Chương 3: Hướng đối tượng trong Java Thời gian: 15 giờ
1. Mục tiêu:
- Trình bày được các thành phần trong file mã nguồn Java.
- Tạo được các Class có sử dụng Overloading , Overriding, Interface, kế thừa và đa hình
trong Java.
2.1. Các thành phần trong file mã nguồn (*.java) Thời gian: 1 giờ
2.2. Khai báo Class Thời gian: 2 giờ
2.3. Modifiers Thời gian: 2 giờ
2.4. Viết chồng và viết đè(Overloading & Overriding) Thời gian: 2 giờ
2.5. Giao tiếp (Interface) Thời gian: 2 giờ
2.6. Kế thừa trong Java Thời gian: 2 giờ
2.7. Tính đa hình trong Java Thời gian: 2 giờ
2
Chương 4: Lớp xử lý ứng dụng Java Thời gian: 10 giờ
1. Mục tiêu:
- Tạo được xử lý loại trừ, xử lý toán học trong Java
- Tạo được chương trình Java có sử dụng các xử lý chuỗi, ngày tháng và tập hợp nâng
cao trong Java.
2.1. Xử lý loại trừ Thời gian: 2 giờ
2.2. Xử lý toán học Thời gian: 2 giờ
2.3. Xử lý chuỗi trong Java Thời gian: 2 giờ
2.4. Xử lý ngày tháng Thời gian: 2 giờ
2.5. Xử lý tập hợp nâng cao Thời gian: 2 giờ
Chương 5: Lập trình giao diện Thời gian: 10 giờ
1. Mục tiêu:
- Nêu được các thành phần giao diện.
- Sử dụng Java Gui Api, Jframe, điều khiển sự kiện,… trong ngôn ngữ Java.
2.1. Các thành phần giao diện Thời gian: 2 giờ
2.2. Java Gui Api Thời gian: 2 giờ
2.3. Jframe Thời gian: 2 giờ
2.4. Layout Manager Thời gian: 2 giờ
2.5. Điều khiển sự kiện Thời gian: 2 giờ
Chương 6: Xây dựng ứng dụng Java Thời gian: 20 giờ
1. Mục tiêu:
- Nêu được các thành phần trong ứng dụng Java.
- Xây dựng được mô hình 2 lớp.
- Cài đặt được JDBC và các Class và Interface thường dùng.
2.1. Các thành phần của một ứng dụng Java Thời gian: 2 giờ
2.2. Mô hình 2 lớp Thời gian: 5 giờ
2.3. Cài đặt JDBC Thời gian: 5 giờ
2.4. Một số Class và Interface của JDBC API thường dùng Thời gian: 5 giờ
2.5. Một số kỹ thuật cơ bản sử dụng JDBC Thời gian: 3 giờ
IV. Điều kiện thực hiện môn học:
1. Phòng học chuyên môn hóa/nhà xưởng: phòng lab tin học.
2. Trang thiết bị máy móc: máy vi tính có phần mềm chuyên dụng.
3. Học liệu, dụng cụ, nguyên vật liệu: sách, tập, máy tính có phần mềm chuyên dụng.
4. Các điều kiện khác: không
V. Nội dung và phương pháp đánh giá:
1. Nội dung:
- Kiến thức:
+ Nêu được cấu trúc và các thành phần cơ bản của ngôn ngữ Java.
+ Nêu được hình thành và phát triển khả năng giải quyết các bài toán lập trình.
- Kỹ năng:
3
+ Sử dụng được các cú pháp trong môi trường lập trình Java và các ứng dụng thực tế.
+ Lập trình giao diện người dùng bằng ngôn ngữ Java.
+ Vận dụng công nghệ mới để xây dựng ứng dụng bằng ngôn ngữ Java.
+ Xây dựng chương trình ứng dụng bằng ngôn ngữ Java.
+ Rèn luyện kỹ năng lập trình, khả năng tư duy về lập trình hướng đối tượng.
- Năng lực tự chủ và trách nhiệm:
+ Tích cực tham gia tự học, tham gia xây dựng bài, làm việc nhóm
2. Phương pháp:
Các kiến thức và kỹ năng trên sẽ được đánh giá qua các nội dung tự nghiên cứu, ý thức
thực hiện môn học, kiểm tra thường xuyên, kiểm tra định kỳ và kiểm tra kết thúc môn học:
- Điểm môn học bao gồm điểm trung bình các điểm kiểm tra: tự nghiên cứu, điểm kiểm
tra thường xuyên, kiểm tra định kỳ có trọng số 0,4 và điểm thi kết thúc môn học có
trọng số 0,6.
- Điểm trung bình các điểm kiểm tra là trung bình cộng của các điểm kiểm tra thường
xuyên, điểm kiểm tra định kỳ và tự nghiên cứu theo hệ số của từng loại điểm. Trong
đó, điểm kiểm tra thường xuyên và điểm tự nghiên cứu được tính hệ số 1, điểm kiểm
tra định kỳ tính hệ số 2.
- Hình thức thi: trắc nghiệm (60 phút) (được thông báo vào đầu mỗi học kỳ).
VI. Hướng dẫn thực hiện môn học:
1. Phạm vi áp dụng môn học: Chương trình môn học được sử dụng để giảng dạy cho trình
độ Cao đẳng.
2. Hướng dẫn về phương pháp giảng dạy, học tập môn học:
- Đối với giảng viên:
+ Trước khi giảng dạy cần phải căn cứ vào nội dung của từng bài học chuẩn bị đầy đủ
các điều kiện cần thiết để đảm bảo chất lượng giảng dạy.
+ Khi thực hiện chương trình môn học cần xác định những điểm kiến thức cơ bản, xác
định rõ các yêu cầu về kiến thức, kỹ năng ở từng nội dung.
+ Cần liên hệ kiến thức với thực tế sản xuất và đời sống, đặc biệt là các phần mềm
thực tế sử dụng mạng Internet có hiệu quả.
- Đối với người học:
+ Chủ động, tích cực tiếp thu kiến thức, tự nghiên cứu, chuẩn bị bài theo nội dung
giảng viên hướng dẫn, yêu cầu trước khi đến lớp.
+ Cần thực hiện tất cả các bài tập và tự nghiên cứu các bài toán thực tế về môn học đã
có sẵn nhằm mục đích củng cố, ghi nhớ, khắc sâu kiến thức đã học.
+ Xây dựng kế hoạch tự học, tự nghiên cứu cho cá nhân.
+ Tham dự ít nhất 70% thời gian học lý thuyết và đầy đủ các bài học tích hợp, bài học
thực hành, thực tập và các yêu cầu của môn học được quy định trong chương trình
môn học.
3. Những trọng tâm cần lưu ý:
- Tổng quan về Java.
- Ngôn ngữ Java.
- Hướng đối tượng trong Java.
- Lớp xử lý ứng dụng Java.
4
- Lập trình giao diện.
- Xây dựng ứng dụng Java.
4. Tài liệu tham khảo:
[1]. Đề cương bài giảng Lập trình Java, Trường CĐ Kinh Tế - Kỹ Thuật Vinatex
TP.HCM.
[2]. Phương Lan – Bước đầu làm quen Java – NXB Lao động xã hội, 2005
[3]. Đỗ Quang Thái – Tự học ngôn ngữ lập trình Java, NXB Giáo dục, 2000
[4]. Nguyễn Tiến Dũng–Giáo trình lý thuyết và bài tập Java–NXB Giáo dục,1999
5
Chương 1
TỔNG QUAN VỀ JAVA
1. Xứ mệnh lịch sử của Java
− Năm 1990, Nhóm lập trình do James Gosling dùng C++ để xây
dựng một phần mềm lập trình cho các mặt hàng gia dụng, nhưng
nhanh chóng nhận thấy rằng C++ không thích hợp, vì quá cồng
kềnh và đòi hỏi rất nhiều hỗ trợ như: bộ nhớ, đĩa … Nhóm của
Gosling đã quyết định xây dựng một ngôn ngữ mới và đặt tên là
Oak (nghĩa là cây sồi).
− Qua các dự án mà nhóm đã thực hiện, Oak đã phát triển và
trưởng thành nhanh chóng, và được đặt tên là Java.
− Năm 1995, Sun MicroSystem chính thức công bố Java.
− Java nhanh chóng được đón nhận như một công cụ mạnh mẽ cho việc phát triển các ứng
dụng Internet, vì nó cung cấp tiến trình xử lý tương tác và cách dùng đồ họa và hoạt
hình trên Internet.
2. Một số đặc trưng của Java
− Đơ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. Java tựa như C++, nhưng đã lược bỏ đi các đặc trưng phức tạp, không
cần thiết của C và C++ như: thao tác con trỏ, thao tác định nghĩa chồng toán tử (operator
overloading),… Java không sử dụng lệnh “goto” cũng như file header (.h). Cấu trúc
“struct” và “union” cũng được loại bỏ khỏi Java. Nên có người bảo Java là “C++--“,
ngụ ý bảo java là C++ nhưng đã bỏ đi những thứ phức tạp, không cần thiết.
− Hướng đối tượng
Có thể nói java là ngôn ngữ lập trình hoàn toàn hướng đối tượng, tất cả trong java đều
là sự vật, đâu đâu cũng là sự vật.
− Độc lập với hệ nền
Mục tiêu chính của các nhà thiết kế java là độc lập với hệ nền hay còn gọi là độc lập
phần cứng và hệ điều hành. Đây là khả năng một chương trình được viết tại một máy
nhưng có thể chạy được bất kỳ đâu.
Tính độc lập với phần cứng được hiểu theo nghĩa một chương trình Java nếu chạy đúng
trên phần cứng của một họ máy nào đó thì nó cũng chạy đúng trên tất cả các họ máy
khác. Một chương trình chỉ chạy đúng trên một số họ máy cụ thể được gọi là phụ thuộc
vào phần cứng.
Tính độc lập với hệ điều hành được hiểu theo nghĩa một chương trình Java có thể chạy
được trên tất cả các hệ điều hành. Một chương trình chỉ chạy được trên một số hệ
điều hành được gọi là phụ thuộc vào hệ điều hành.
Các chương trình viết bằng java có thể chạy trên hầu hết các hệ nền mà không cần phải
thay đổi gì, điều này đã được những người lập trình đặt cho nó một khẩu hiệu ‘viết một
lần, chạy mọi nơi’, điều này là không thể có với các ngôn ngữ lập trình khác.
Đối với các chương trình viết bằng C, C++ hoặc một ngôn ngữ nào khác, trình biên
dịch sẽ chuyển tập lệnh thành mã máy (machine code), hay lệnh của bộ vi xử lý. Những
6
lệnh này phụ thuộc vào CPU hiện tại trên máy bạn. Nên khi muốn chạy trên loại CPU
khác, chúng ta phải biên dịch lại chương trình.
− Mạnh mẽ
Java là ngôn ngữ yêu cầu chặt chẽ về kiểu dữ liệu, việc ép kiểu tự động bừa bãi của C,
C++ nay được hạn chế trong Java, điều này làm chương trình rõ ràng, sáng sủa, ít lỗi
hơn.
Java kiểm tra lúc biên dịch và cả trong thời gian thông dịch vì vậy Java loại bỏ một một
số loại lỗi lập trình nhất định. Java không sử dụng con trỏ và các phép toán con trỏ.
Java kiểm tra tất cả cá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 ngoài giới hạn kích thước.
Trong các môi trường lập trình truyền thống, lập trình viên phải tự mình cấp phát bộ
nhớ. Trước khi chương trình kết thúc thì phải tự giải phóng bộ nhớ đã cấp. Vấn đề nảy
sinh khi lập trình viên quên giải phóng bộ nhớ đã xin cấp trước đó. Trong chương trình
Java, lập trình viên không phải bận tâm đến việc cấp phát bộ nhớ. Quá trình cấp phát,
giải phóng được thực hiện tự động, nhờ dịch vụ thu nhặt những đối tượng không còn
sử dụng nữa (garbage collection).
Cơ chế bẫy lỗi của Java giúp đơn giản hóa quá trình xử lý lỗi và hồi phục sau lỗi.
− Hỗ trợ lập trình đa tuyến
Đây là tính năng cho phép viết một chương trình có nhiều đoạn mã lệnh được chạy song
song với nhau. Với java ta có thể viết các chương trình có khả năng chạy song song một
cách dễ dàng, hơn thế nữa việc đồng bộ tài nguyên dùng chung trong Java cũng rất đơng
giản. Điều này là không thể có đối với một số ngôn ngữ lập trình khác như C/C++,
pascal …
− Phân tán
Java hỗ trợ đầy đủ các mô hình tính toán phân tán: mô hình client / server, gọi thủ tục
từ xa…
− Hỗ trợ internet
Mục tiêu quan trọng của các nhà thiết kế java là tạo điều kiện cho các nhà phát triển ứng
dụng có thể viết các chương trình ứng dụng internet và web một cách dễ dàng, với java
ta có thể viết các chương trình sử dụng các giao thức TCP, UDP một cách dễ dàng, về
lập trình web phía máy khách java có công nghệ java pplet, về lập trình web phía máy
khách java có công nghệ servlet/JSP, về lập trình phân tán java có công nghệ RMI,
CORBA, EJB, Web Service.
− Thông dịch
Các chương trình java cần được thông dịch trước khi chạy, một chương trình java được
biên dịch thành mã byte code mã độc lập với hệ nền, chương trình thông dịch java sẽ
ánh xạ mã byte code này lên mỗi nền cụ thể, điều này khiến java chậm chạp đi phần
nào.
3. Sử dụng Java có thể xây dựng được ứng dụng gì?
− Applets: được tạo ra để sử dụng trên Internet thông qua các trình duyệt hỗ trợ Java như
IE hay Netscape. Applet được nhúng bên trong trang web. Khi trang web hiển thị trong
trình duyệt, Applet sẽ được tải về để thực thi tại trình duyệt.
7
− Command Line: được chạy từ dấu nhắc lệnh và không sử dụng giao diện đồ họa.
− GUI (Graphics User Interface): là chương trình chạy độc lập cho phép người dùng
tương tác qua giao diện đồ họa.
− Servlets/JSP: Java thích hợp để phát triển ứng dụng nhiều lớp. Applet là chương trình
đồ họa chạy trên trình duyệt tại máy trạm. Ở các ứng dụng Web, máy trạm gửi yêu cầu
tới máy chủ. Máy chủ xử lý và gửi kết quả trở lại máy trạm. Các Java API chạy trên
máy chủ chịu trách nhiệm xử lý tại máy chủ và trả lời các yêu cầu của máy trạm. Các
Java API chạy trên máy chủ này mở rộng khả năng của các ứng dụng Java API chuẩn.
Các ứng dụng trên máy chủ này được gọi là các JSP/Servlet. hoặc Applet tại máy chủ.
Xử lý Form của HTML là cách sử dụng đơn giản nhất của JSP/Servlet. Chúng còn có
thể được dùng để xử lý dữ liệu, thực thi các giao dịch và thường được thực thi thông
qua máy chủ Web.
− Database: cho phép quản lý CSDL quan hệ (SQL Server, Oracle,...)
− Ứng dụng mạng: Java là ngôn ngữ rất thích hợp cho việc xây dựng các ứng dụng mạng.
Với thư viện Socket bạn có thể lập trình với hai giao thức: UDP và TCP.
− Ứng dụng nhiều tầng: Với Java bạn có thể xây dựng phân tán nhiều tầng với nhiều hỗ
trợ khác nhau như: RMI, CORBA, EJB, Web Service
− Ứng dụng cho các thiết bị di động: sử dụng các ứng dụng Java chạy trên các thiết bị di
động này.
4. Công cụ lập trình JDK
Trong giới Java hiện nay có 4 công cụ được sử dụng nhiều nhất: JCreator, NetBeans,
Eclipse, JBuilder và mỗi một công cụ có ưu và nhược điểm riêng.
JCreator ▪ Ưu điểm: gọn nhẹ, dễ cài đặt, dễ sử dụng (như Turbo Pascal)
▪ Khuyết điểm: hỗ trợ về lập trình không tốt đặc biệt là thiết kế giao
diện.
▪ Khuyên dùng: chương trình này phù hợp với những bạn mới bắt
đầu làm quen với java.
NetBeans ▪ Ưu điểm: miễn phí, ngày càng được hỗ trợ nhiều tính năng hơn bởi
Sun.
▪ Khuyết điểm: các plugin mở rộng không nhiều
▪ Khuyên dùng: phù hợp với những bạn sau một thời gian làm quen
với java chuẩn bị chuyển sang phần java nâng cao.
Eclipse ▪ Ưu điểm: miễn phí, nhiều plugin mở rộng, hỗ trợ lập trình tốt
▪ Nhược điểm: hơi nặng
▪ Khuyên dùng: các công ty lập trình chuyên nghiệp họ đang dùng
chương trình này
Jbuilder ▪ Ưu điểm: hỗ trợ lập trình tốt
▪ Nhược điểm: không miễn phí và nặng
8
▪ Cài đặt JDK
− Download JDK tại địa chỉ: http://java.sun.com/javase/downloads/index.jsp
− Chọn phiên bản JDK phù hợp, cài đặt JDK trước khi bắt đầu cài đặt NETBEAN.
▪ Cài đặt Creator
− Download JCreator tại địa chỉ: http://www.jcreator.com/download.htm
− Cài đặt Jcreator + chạy file keygen để lấy serial number, nhập số serial khi chạy
chương trình.
▪ Cài đặt Netbean
− Download Netbean tại địa chỉ: http://netbeans.org/downloads/index.html, chọn phiên
bản mới nhất, nếu cần lập trình cho điện thoại j2me thì download phiên bản full.
− Để bắt đầu làm việc với một ứng dụng Java: chọn New Project, nhấn next, chọn Java
Application, đặt tên cho dự án và nhấn Finish
5. Chương trình HelloWord.java với JDK
− Ví dụ : In ra màn hình Console: Welcome To Java.
Tên file là Helloworld.java.
public class Helloworld
{
public static void main (String args[])
{
System.out.println(“Welcome To Java”);
}
}
(*) Chú ý :
+ Trong file phải có ít nhất một lớp và có duy nhất một lớp chính (public) và phải
có một hàm main.
+ Câu lệnh : System.out.println thì phải ghi hoa chữ S đầu tiên.
+ Tham số String args[] là tham số bắt buộc cho hàm main.
9
Chương 2
NGÔN NGỮ JAVA
1. Cấu trúc chương trình
1.1. Định danh:
- Dùng để đặt tên cho biến, hằng, phương thức, lớp gói.
- Nguyên tắc sử dụng định danh :
• Chỉ bắt đầu bằng 1 ký tự chữ , 1 dấu gạch dưới _, hay 1 dấu dollar $.
• Không có khoảng trắng trong tên biến.
• Không trùng với các từ khóa.
• Không chứa các toán tử +, - , *, /.
• Có chiều dài tùy ý.
- Chú ý : trong Java có phân biệt chữ thường với chữ hoa.
- Ví dụ :
a_1234_5, $dhfi,1aws, _ahks, a sas, %ats.
❖ Quy ước đặt tên :
- Đối với biến và phương thức: luôn dùng chữ thường. Nếu tên có nhiều từ thì ghép
tất cả thành 1, từ đầu tiên viết chữ thường, các từ còn lại viết hoa ký tự đầu tiên.
- Đối với hằng : viết hoa toàn bộ các ký tự, nếu có nhiều từ thì dùng dấu _ để nối
các từ. (Ví dụ : MAX_VALUE).
1.2. Biến và khai báo biến:
- Biến : dùng để lưu dữ liệu.
- Cú pháp : < kiểu dữ liệu> <tên biến>;
- Ví dụ : int x;
- Cách gán giá trị : x= 2.
- Có thể vừa khởi tạo vừa khai báo : int x=2;
▪ Chú ý : tốt hơn nên vừa khai báo vừa khởi tạo luôn giá trị cho biến.. Vì nếu biến
chưa có giá trị thì khi in ra sẽ bị báo lỗi (tốn thời gian kiểm tra, không như ngôn
ngữ C thì khi khai báo, biến sẽ tự động được gán giá trị mặc nhiên chứ không bị
báo lỗi).
▪ Đối với hằng : final <kiểu dữ liệu> <tên hằng> = <giá trị>;
- Phạm vi biến:
▪ Mỗi biến được khai báo ra có một phạm vi hoạt động, phạm vi của biến là nơi
biến có thể được truy cập, thấy được và thời gian sống của biến.
▪ Biến phạm vi lớp là biến được khai báo bên trong lớp nhưng bên ngoài các
phương thức và hàm tạo, tuy nhiên việc khai báo phải xuất hiện trước khi biến
được sử dụng.
▪ Biến phạm vi cục bộ là biến được khai báo bên trong một khối, phạm vi của biến
tính từ điểm biến được khai báo cho đến cuối khối mà biến được khai báo.
1.3. Chú thích trong chương trình:
Trong Java có 3 cách để ghi chú thích:
- Sử dụng cặp /* và */ để ghi chú thích trên nhiều dòng.
- Sử dụng cặp // để ghi chú thích trên một dòng.
10
- Sử dụng cặp /** và */, đây là kiểu hcú thích tài liệu (không có trong C/C++), nó dùng
để tạo ra tài liệu chú thích cho chương trình.
2. Kiểu dữ liệu cơ bản
2.1. Kiểu dữ liệu số:
Tên Kích thước Khoảng biến thiên Lớp bao hàm
(kiểu số nguyên)
byte 8 bit -128 → 127 Byte
short 16 bit -32768 → 32767 Short
int 32 bit -231 → 231-1 Integer
long 64 bit -263 → 263-1 Long
(kiểu số thực)
float 32 bit - 34*1038 → 34*1038 Float
double 64 bit - 17 * 10308 → 17 * 10308 Double
- Ví dụ :
Kiểu int: int a= 18; // hệ thập phân
int a= 022; // hệ bát phân : thêm số 0 đầu
int a= 0x12 ; // hệ thập lục phân : thêm 0x đầu.
Kiểu float: float f = 43.3f ; // thêm f hay F cuối
Kiểu double: double d = 3.12d ; // hay d=3.12
❖ Các toán tử:
- Phép toán : +, -, *, /, %, +=, -=, *=, /=, %=, ++, --.
- So sánh : = =, >, <, !=, >=, <=.
- Các phép toán trên bit : &, |, ~, ^ ,<< , >>, >>> .
2.2. Kiểu ký tự (char):
- Dùng để biểu thị một ký tự.
- Kích thước là 16 bit, nhận giá trị từ ' \u0000 ' to ' \uffff ' (0 đến
65535)
(Ví dụ : ‘A’ -> ‘\0041’)
❖ Các ký tự đặc biệt:
\b : backspace \” : dấu nháy kép ”
\t : tab ngang \’ : dấu nháy đơn ‘
\n : xuống dòng \\ : dấu sổ ngược \
\r : dấu enter ‘\x’ : mã ký tự dạng ASCII
\f : đẩy trang ‘\u’ : mã ký tự dạng UNICODE
- Có thể chuyển đổi giữa số và ký tự :
int i = (int) ‘0’; //in ra mã ASCII của ký tự → i = 48
2.3. Kiểu boolean:
- Kích thước : 1 bit.
- Nhận 2 giá trị : true, false.
- Ví dụ : boolean b = true;
- Các phép toán so sánh cho kết quả thuộc kiểu boolean : = =, >, <, !=, >=, <=.
- Các phép toán dùng cho kiểu boolean : &, |, ! .
2.4. Toán tử điều kiện:
11
- Toán tử điều kiện (?:) là một loại toán tử đặc biệt vì nó gồm ba thành phần cấu thành
biểu thức điều kiện, hay nói cách khác toán tử điều kiện là toán tử 3 ngôi.
- Cú pháp : < điều kiện > ? <biểu thức 1> : < biểu thức 2>.
- Trong đó :
• điều kiện là một biểu thức logic (True / False).
• biểu thức 1, biểu thức 2 có thể là 2 giá trị, 2 biểu thức hay 2 hành động.
→ Nếu điều kiện đúng thì biểu thức 1 sẽ được thực hiện, ngược lại thì biểu thức
2 sẽ được thực hiện.
- Ví dụ :
int max=(5>7) ? 5:7 ;
String result = a%2==0? "a la so chan": "a la so le";
3. Chuyển đổi kiểu dữ liệu
- Chuyển kiểu tự động: số có kiểu độ chính xác thấp sang số có kiểu độ chính xác cao.
byte ->short -> int -> long -> float -> double
- Chuyển kiểu không tường minh:
Ví dụ:
int two =2, three =3;
float result = 1.5 + three / two;
float result = 1.5 + (float)three / two;
float result = 1.5 + three / (float)two;
float result = 1.5 + (float)three / (float)two;
- Chuyển kiểu tường minh (ép kiểu) :
(kiểu) biểu_thức;
Ví dụ :
double x = (double) 5 / 2;
float f = 3.5;
int i = x + (int) f;
int j = (int)2.5 * 2.5, k = (int)(2.5 * 2.5);
Lưu ý:
• Phép toán chuyển kiểu là phép toán có độ ưu tiên cao.
• Khi chuyển một biểu thức kiểu dữ liệu có miền giá trị lớn sang một kiểu có
miền giá trị nhỏ hơn thì có thể bạn sẽ bị mất thông tin.
4. Nhập xuất console
- Thư viện nhập xuất: java.util.Scanner; java.io.*;
- Câu lệnh xuất: System.print.out(“Chuỗi cần xuất ra màn hình”);
- Câu lệnh nhập: Scanner in =new Scanner(System.in);
int a = in.nextInt(); //chọn kiểu dữ liệu phù hợp
5. Cấu trúc rẽ nhánh
5.1. Câu lệnh if:
- Dạng 1:
if (điều_kiện) lệnh;
- Dạng 2:
12
if (điều_kiện)
lệnh 1;
else // điều kiện == false
lệnh 2;
- Dạng 3:
if (điều_kiện 1)
if (điều_kiện 2)
lệnh 1;
else //điều kiện 2== false
lệnh 2;
else // điều kiện 1== false
lệnh 3;
…….
- Ví dụ :
import java.util.Date;
class thu
{
public static void main(String args[])
{
Date today=new Date();
if (today.getDay() == 0)
System.out.println("Hom nay la ngay chu nhat.");
else
System.out.println("Hom nay khong phai la ngay chu nhat.");
}
}
5.2. Câu lệnh switch:
switch (biểu_thức)
{
case giá_trị_1 : lệnh 1; [break];
case giá_trị_2 : lệnh 2; [break];
……
case giá_trị_n : lệnh n; [break];
default : lệnh n+1;
}
- Ví dụ:
import java.io.*;
public class CaseOp {
public static void main(String args[]) {
System.out.print("Enter a number character: ");
try {
int ch = System.in.read();
switch(ch) {
case '0': { System.out.print("Zero");break;}
case '1': { System.out.print("One"); break;}
case '2': { System.out.print("Two"); break;}
case '3': { System.out.print("Three");break;}
13
case '4': { System.out.print("Four"); break;}
case '5': { System.out.print("Five"); break;}
case '6': { System.out.print("Six"); break;}
case '7': { System.out.print("Seven");break;}
case '8': { System.out.print("Eight");break;}
case '9': { System.out.print("Nine"); break;}
default: { System.out.print("I don't know"); break;}
}
} catch(IOException ie) { System.out.print("Error "+ie);
}
}
6. Cấu trúc lặp
6.1. Vòng lặp for
- Sử dụng vòng lặp for khi biết trước số lần lặp, dùng để thực thi lặp đi lặp lại một
lệnh hoặc khối lệnh nào đó.
- Cú pháp:
for ( giá_trị_đầu; điều_kiện_lặp; bước_nhảy)
{
<khối_lệnh>;
}
- Ví dụ: Tính tổng 1 + 2 + ... + n. Với n là số nguyên dương nhập từ bàn phím.
java.util.Scanner; java.io.*;
class vong_lap_for
{
{
int n, s=0;
System.out.println("Nhap n: ");
Scanner in =new Scanner(System.in);
int a = in.nextInt();
for(int i=0; i<=a; i++)
s + = i;
System.out.println("Tong s =" + s);
}
}
6.2. Vòng lặp while

- Sử dụng cấu trúc while khi không biết số lần lặp, dùng để thực thi lặp đi lặp lại một
lệnh hoặc một khối lệnh trong khi điều kiện đúng.
- Cú pháp:
while (điều kiện = = true)
{
<khối_lệnh>;
}
- Ví dụ: Tính tổng 1 + 2 + ... + n. Với n là số nguyên dương nhập từ bàn phím.
java.util.Scanner; java.io.*;
14
class vong_lap_while
{
{
int n, s=0;
System.out.println("Nhap n: ");
while(i<=n)
{
s + = i;
i++;
}
System.out.println("Tong s =" + s);
}
}
6.3. Vòng lặp do … while
- Sử dụng cấu trúc do ... while sẽ thực hiện khối lệnh lặp ít nhất 1 lần, rồi mới kiểm
tra điều kiện lặp.
- Cú pháp:
do
{
<khối_lệnh>;
} while (điều kiện == true);
- Ví dụ: Viết đoạn lệnh cho phép nhập vào bàn phím số có giá trị từ 0-100, nếu nhập
ngoài khoảng [0-100] yêu cầu nhập lại.
class vong_lap_while
{
{ do
{ System.out.println("Nhap so nguyên 0-100: ");
} while(a<=100);
}
7. Mảng 1 chiều
- Mảng là một tập hợp các phần tử có cùng kiểu dữ liệu, có thể được lưu trữ trong các vị
trí liền kề trong bộ nhớ.
7.1. Khai báo:
< kiểu dữ liệu > <tên biến > [ ];
< kiểu dữ liệu >[ ] <tên biến >;
- Có 2 cách khai báo : cặp ngoặc vuông để sau tên biến hay đặt sau kiểu dữ liệu.
Ví dụ : int a[ ];
int[ ] a;
- Sau khi khai báo, bản thân mảng chưa được xác định, mảng cần được định vị trong
vùng nhớ, nói cách khác là cần được cấp vùng nhớ.
- Không như các ngôn ngữ khác, kích thước mảng không được xác định ngay khi khai
báo . Nếu như khai báo int a[5] thì sẽ bị báo lỗi.
15
- Cần nhớ rằng mọi hoạt động trong Java đều thông qua các đối tượng , nên ta cần
dùng từ khóa new để định vị một mảng trong vùng nhớ :
int a[ ] = new int [5];
int a[ ];
a= new int [5];
a[0] = 10;
- Có thể định vị một mảng bằng cách liệt kê các phần tử của nó (vừa khai báo, vừa
khởi tạo mảng):
- Ví dụ:
int int_array [ ]= {1,2,3,4,5};
char [ ] char_array = {‘a’, ’b’, ’c’, ’d’};
String [ ] string_array = { “abc”, “A”, “DEF”, “aaaaaaa”};
7.2. Truy cập một mảng :
- Các phần tử trong mảng luôn được đánh số thứ tự từ 0 .
- Để tham khảo giá trị của một phần tử trong mảng, ta gán số thứ tự của phần tử giữa
2 cặp ngoặc vuông [ ].
Ví dụ : int a[ ] = { 1, 2, 3, 4, 5};
int b = a[2]; // b = 3
int c = a[0]; // c = 1
- Để lấy về số phần tử của mảng ta sử dụng thuộc tính length: Tên_mảng.length
7.3. Sử dụng mảng 1 chiều:
- Ví dụ 1: Nhập vào một mảng và in ra màn hình.
import java.util.Scanner;
class ArrayDemo{
public static void main(String[] args) {
Scanner sn = new Scanner(System.in);
System.out.print("Nhập số phần tử của mảng:");
int n = sn.nextInt();
//Khai báo mảng với số phần tử bằng n
int a[]=new int[n];
//Nhập dữ liệu cho mảng
for(int i=0;i<a.length;i++){
System.out.print("a[" + i + "]=");
a[i]= sn.nextInt();
}
//In mảng ra màn hình
System.out.println("Mảng vừa nhập là");
for (int i = 0; i < a.length; i++)
System.out.print(a[i] + " ");
}
}
- Ví dụ 2: Nhập vào một mảng số thực sau đó kiểm tra xem mảng có phải là một dãy
tăng hay không.
class ArrayDemo2{
Scanner sn = new Scanner(System.in);
System.out.print("Nhập số phần tử của mảng:");
16
int n= sn.nextInt();
int a[]=new int[n];
for(int i=0;i<a.length;i++){
System.out.print("a[" + i + "]=");
a[i]= sn.nextInt();
}
//Kiểm tra dãy tăng
boolean kt=true;
for (int i = 0; i < a.length-1; i++)
if(a[i+1]-a[i]<0){
kt=false; //thay đổi trạng thái cờ
break; //Thoát khỏi vòng lặp
}
if(kt) System.out.println("Day tang dan");
else System.out.println("Day khong phai tang dan");
}
}
8. Mảng 2 chiều
- Khai báo :
<kiểu dữ liệu> <tên biến>[ ][ ];
Hay <kiểu dữ liệu>[ ][ ] <tên biến>;
- Khởi tạo :
int a[ ][ ] = new int [2][2];
int [ ][ ] a = { {1,2,3}, {4,5,6}};
- Ví dụ: Nhập vào một ma trận và in ra màn hình.
import com.theht.Keyboard;
class MaTran {
//Nhập số hàng và số cột
System.out.print("Nhập số hàng:");
int sh = Keyboard.readInt();
System.out.print("Nhập số cột:");
int sc = Keyboard.readInt();
//Khai báo mảng hai chiều gồm sh hàng và sc cột
float a[][] = new float[sh][sc];
//Nhập dữ liệu cho mảng hai chiều
for (int i = 0; i < a.length; i++)
for (int j = 0; j < a[i].length; j++) {
System.out.print("a[" + i + "," + j + "]=");
//Nhập liệu cho phần tử hàng i, cột j
a[i][j] = Keyboard.readFloat();
}
//In mảng hai chiều ra màn hình
for (int i = 0; i < a.length; i++) {
for (int j = 0; j < a[i].length; j++)
System.out.print(a[i][j] + " ");
System.out.println();
}
}
}
17
9. Break và Continue
- Lệnh break sẽ chấm dứt quá trình lặp mà không thực hiện nốt phần còn lại của cấu
trúc lặp. Nếu có nhiều vòng lặp lồng nhau, thì lệnh break sẽ thoát khỏi vòng lặp mà
nó được đặt.
- Lệnh continue sẽ ngưng thực thi phần còn lại của thân vòng lặp và chuyển điều khiển
về điểm bắt đầu của vòng lặp, để thực hiện lần lặp tiếp theo.
- Ví dụ: Tìm kết quả thực thi đoạn chương trình sau:
public class BreakAndContinue {
public static void main(String[] args)
{ for(int i = 0; i < 100; i++)
{ if(i == 74) break;
if(i % 9! = 0) continue;
System.out.println(i);
}
int i = 0;
while(true)
{ i++;
int j = i * 27;
if(j == 1269) break;
if(i % 10! = 0) continue;
System.out.println(i);
}
}
}
10. Math
- Các hàm toán học như abs, max, min, sqrt được java viết sẵn trong lớp Math.
- Lớp này nằm trong gói java.lang (gói mặc định) do vậy bạn không cần phải thêm
câu lệnh import ở đầu chương trình để có thể sử dụng lớp này. Các hàm này được
viết là các phương thức tĩnh do vậy ta không cần phải tạo ra thể hiện của lớp Math.
- Bảng sau liệt kê một số phương thức tĩnh trong lớp Math:
Phương thức Mô tả ý nghĩa Kiểu tham số Kiểu trả về
abs(arg) Tính giá trị tuyệt đối int, long, float, double Kiểu tham số
max(arg1,arg2) Tìm giá trị lớn nhất int, long, float, double Kiểu tham số
min(arg1,arg2) Tìm giá trị nhỏ nhất int, long, float, double Kiểu tham số
ceil(arg) Nhận về giá trị nguyên float, double double
nhỏ hơn hoặc bằng arg
floor(arg) Nhận về giá trị nguyên float, double double
lớn hơn hoặc bằng arg
round(arg) Trả về giá trị nguyên float, double float -> int
gần arg nhất double -> long
rint(arg) Giống round(arg) double double
sqrt(arg) Tính căn bậc hai double double
pow(arg1,arg2) Tính lũy thừa double double
18
log(arg) Tính logarit hàm số e double double
random() Nhận về một số giả Không có tham số double
ngẫu nhiên nằm trong
khoản [0, 1)
19
Chương 3
HƯỚNG ĐỐI TƯỢNG TRONG JAVA
Lớp (class) là khái niệm trọng tâm của lập trình hướng đối tượng, java là ngôn ngữ
lập trình hướng đối tượng, một chương trình java gồm một tập các đối tượng, các đối tượng
này phối hợp với nhau để tạo thành một ứng dụng hoàn chỉnh. Các đối tượng được mô tả
qua khái niệm lớp, lớp là sự mở rộng khái niệm record trong pascal, hay struct của C,
ngoài các thành phần dữ liệu, lớp còn có các hàm (phương thức, hành vi), ta có thể
xem lớp là một kiểu dữ liệu, vì vậy người ta còn gọi lớp là kiểu dữ liệu đối tượng. Sau khi
định nghĩa lớp ta có thể tạo ra các đối tượng (bằng cách khai báo biến) của lớp vừa tạo, do
vậy có thể quan niệm lớp là tập hợp các đối tượng cùng kiểu.
1. Các thành phần trong file mã nguồn (*.java)
▪ package : Định nghĩa gói
▪ imports : Chỉ định các gói cần sử dụng
▪ classes : Định nghĩa các lớp
▪ interfaces : Định nghĩa các interface
▪ Comments : Các loại ghi chú
2. Khai báo class
- Khai báo một class:
class className Ví dụ: //Circle.java
{ class Circle
type data1; //thuộc tính 1 {
type data1; //thuộc tính 2 double radius ;
… double findArea( )
method 1; // phương thức 1 {
method 2; // phương thức 2 return radius*radius*3.14;
… }
} }
3. Modifiers
- Cú pháp : <modifier><datatype><variable name>[=<init value>];
- Tính chất bổ sung của dữ liệu vào phương thức:
▪ public : có thể truy cập dữ liệu hay phương thức từ bên ngoài lớp định nghĩa nó.
▪ private : chỉ được truy cập dữ liệu hay phương thức trong bản thân lớp định nghĩa.
▪ protected : chỉ được truy cập dữ liệu hay phương thức trong bản thân lớp định
nghĩa và những lớp dẫn xuất (lớp con) của lớp đó.
▪ static : một dữ liệu hay phương thức chung cho mọi thực thể của lớp.
▪ abstract : không được cài đặt gì trong lớp (lớp ảo)
▪ final : không bị định nghĩa chồng ở các lớp dẫn xuất (hằng)
- Chú ý:
▪ Các thuộc tính nên để mức truy cập private để đảm bảo tính dấu kín và lúc đó để
bên ngoài phạm vi của lớp có thể truy cập được đến thành phần private này ta phải
tạo ra các phương thức get và set.
▪ Các phương thức thường khai báo là public, để chúng có thể truy cập từ bất cứ đâu.
20
▪ Trong một file chương trình chỉ (hay còn gọi là một đơn vị biên dịch) chỉ có một lớp
được khai báo là public, và tên lớp public này phải trùng với tên của file kể cả chữ
hoa, chữ thường.
- Ví dụ: Tạo một hồ sơ của học sinh gồm: Họ tên học sinh và Tổng số học sinh sau khi
tạo xong đối tượng?
class hoso
{ static int tongHS;
String hoten;
hoso(String ht)
{
tongHS++;
hoten = ht;
}
static void tongket()
{
System.out.println("Tong so hs: "+ tongHS);
}
void xuatHS()
{
System.out.println(""+hoten);
}
}
public class HocSinh{
public HocSinh() {
}
hoso hs1 = new hoso("Trinh Van Minh");
hoso hs2 = new hoso("Nguyen Nghiem");
hoso hs3 = new hoso("Nguyen Van Kien");
hoso hs4 = new hoso("Nguyen Khoa Diem");
hoso.tongket();
hs1.xuatHS();
hs2.xuatHS();
hs4.xuatHS();
}
}
4. Viết chồng và viết đè (Overloading & Overriding)
- Đa năng hóa phương thức là tạo ra nhiều phương thức có cùng tên và khác nhau ở tham
số (số lượng tam số và kiểu của tham số).
- Ví dụ:
class Overload
{
static void test () {
System.out.println(“Khong co tham so ”);
}
static void test (int a) {
System.out.println(“Tham so la so nguyen :” + a);
}
static void test (int a, int b) {
System.out.println(“Tham so la ca so nguyen :” + a + “ va ” + b);
21
}
static void test(double d) {
System.out.println(“ Tham so la so thuc: ” + d );
}
public static void main (String args[])
{ test();
int a=5;
test(a);
int b=10;
test(a,b);
double d= 4;
test(d);
}
}
5. Giao tiếp (interface)
- Java không cho phép đa kế thừa, thay vào đó, chúng ta có thể ứng dụng giao diện
(interface) để khắc phục hạn chế của kế thừa đơn.
- Giao diện là một lớp đặc biệt trong Java: giao diện cũng được biên dịch thành file chứa
mã bytecode (file.class) như các lớp bình thường, nhưng không thể tạo thực thể.
- Cấu trúc một giao diện :
Các dữ liệu là dữ liệu hằng (public static final).
Các phương thức đều là phương thức ảo.
<modifier>interface< InterfaceName>
→ Giao diện cũng phải được đặt trong file <InterfaceName>.java.
6. Kế thừa trong java
6.1. Khái niệm:
- Sự kế thừa là việc xây dựng một lớp mới dựa trên lớp đã có sẵn.
- Khi đó, lớp mới sẽ có tất cả các thuộc tính, dữ liệu và phương thức của lớp cũ. Và
lớp mới có thể tái sử dụng hay thay đổi phương thức của lớp cũ, cũng như bổ sung
thêm dữ liệu mới và phương thức mới.
- Ta gọi lớp mới là lớp dẫn xuất hay lớp con (subclass). Lớp cũ là siêu lớp hay lớp cha
(superclass).
- Để chỉ ra việc kế thừa, ta dùng từ khóa extends.
- Ví dụ : class Cylinder extends Circle
Lớp Cylinder kế thừa lớp Circle.
Lớp Circle gọi là lớp cha hay siêu lớp (superclass).
Lớp Cylinder gọi là lớp dẫn xuất hay lớp con (subclass).
6.2. Từ khóa "this":
- Dùng để tham chiếu đến các thuộc tính của đối tượng đó bên trong của một phương
thức.
- Trong một số tình huống đặc biệt như tên của tham số trùng với tên của thuộc tính,
lúc đó để chỉ các thành viên của đối tượng đó ta dùng từ khóa this, từ khóa this dùng
để chỉ đối tượng này.
6.3. Từ khóa "final":
22
- Trong java cách duy nhất để tạo ra một hằng là khai báo thuộc tính là final.
- Ví dụ:
public class A {
// định nghĩa hằng tên MAX_VALUE giá trị 100
static final int MAX_VALUE = 100;
public static void main (String arg[] ){
A thu = new A ();
System.out.println("MAX_VALUE= " + thu.MAX_VALUE);
}
}
- Chú ý:
• Khi đã khai báo một thuộc tính là final thì thuộc tính này là hằng, do vậy ta không
thể thay đổi giá trị của nó.
• Khi khai báo một thuộc tính là final thì ta phải cung cấp giá trị ban đầu cho nó.
• Nếu một thuộc tính vừa là final vừa là static thì nó chỉ có một vùng nhớ chung
duy nhất cho cả lớp.
6.4. Hàm khởi tạo (contructor)
- Dùng để khởi tạo đối tượng mới, để khởi gián giá trị cho các thuộc tính của đối tượng
và có thể thực hiện một số công việc cần thiết khác nhằm chuẩn bị cho đối tượng mới.
- Đặc điểm của hàm khởi tạo:
• Trùng tên với tên của lớp.
• Không bao giờ trả về giá trị.
• Nó được Java gọi tự động khi một đối tượng của lớp được tạo ra.
• Hàm có thể có đối số như các phương thức thông thường khác.
• Trong một lớp có thể có nhiều hàm tạo.
- Ví dụ: Sử dụng hàm khởi tạo để in ra màn hình xâu "Creating Rock"
• Hàm khởi tạo không có đối số:
class Rock {
Rock() { // Đây là hàm khởi tạo
System.out.println("Creating Rock");
}
}
public class SimpleConstructor {
for(int i = 0; i < 10; i++)
new Rock(); // gọi hàm khởi tạo
}
}
• Hàm khởi tạo có đối số:

class Rock {
Rock(int i) {
System.out.println("Creating Rock number " + i);
}
}
public class SimpleConstructor {
for(int i = 0; i < 10; i++)
23
new Rock(i);
}
}
6.5. Từ khóa “super” :
- Dùng để tham chiếu đến lớp cha của lớp hiện hành (dùng tương tự từ khóa this).
- Có 2 cách để áp dụng từ khóa super :
• Gọi constructor của lớp cha (được gọi đầu tiên trong constructor của lớp con).
• Gọi phương thức của lớp cha.
- Ví dụ: TestCylinder.java
public class TestCylinder
{
Cylinder myCylinder = new Cylinder(5.0, 2.0);
System.out.println("The length is " + myCylinder.getLength());
System.out.println("The radius is " + myCylinder.getRadius());
System.out.println("The volume of the cylinder is " +
myCylinder.findVolume());
System.out.println("The area of the circle is " + myCylinder.findArea());
}
}
class Circle
{
private double radius;
private String color;
static double weight; //Bien lop
public Circle() {
radius = 1.0;
color = "white";
weight = 1.0;
}
public Circle(double r) {
radius = r;
}
public Circle(double r, String c) {
radius = r;
color = c;
}
public Circle(double r, String c,double w) {
radius = r;
color =c;
weight = w;
}
public double getRadius() { //Lấy radius
return radius;
}
public void setColor(String color) { // Thiết lập color
this.color = color;
}
public double findArea() {
return radius*radius*Math.PI;
}
24
}
class Cylinder extends Circle
{
private double length; // bao gồm các thuộc tính radius, color, weight
public Cylinder() {
super(); //gọi constructor của lớp cha
length = 1.0;
}
public Cylinder(double r, double l) {
super(r);
length = l;
}
public double getLength() {
return length;
}
public double findVolume() { // tính thể tích hình trụ
return findArea()*length; //phương thức findArea() kế thừa từ lớp cha.
}
}
7. Tính đa hình trong java
- Tính đa hình trong lập trình hướng đối tượng đề cập đến khả năng quyết định trong lúc
thi hành (runtime) mã nào sẽ được chạy, khi có nhiều phương thức trùng tên nhau nhưng
ở các lớp có cấp bậc khác nhau.
- Tính đa hình cho phép các vấn đề khác nhau, các đối tượng khác nhau, các phương thức
khác nhau, các cách giải quyết khác nhau theo cùng một lược đồ chung.
- Các bước để tạo tính đa hình:
• (1) Xây dựng lớp cơ sở (thường là lớp cơ sở trừu tượng, hoặc là một giao diện),
lớp này sẽ được các lớp con mở rộng (đối với lớp thường, hoặc lớp trừu
tượng).
• (2) Xây dựng các lớp dẫn xuất từ lớp cơ sở vừa tạo. trong lớp dẫn xuất này ta sẽ
ghi đè các phương thức của lớp cơ sở (đối với lớp cơ sở thường), hoặc triển khai chi
tiết nó (đối với lớp cơ sở trừu tượng hoặc giao diện).
- Ví dụ:
• Viết chương trình tính lương cho Nhân Viên gồm: HoTen, DiaChi, Lương
• Các phương thức: Xuất thông tin nhân viên, tính Lương
• Công ty có 2 phòng ban là NV_VP và NV_SX
- NV_VP : tính lương theo ngày công (Lương =(Số ngày công/22)*700000)
- NV_SX: tính luơng theo số sản phẩm (Lương =Số sản phẩm*20000)
• Ý tưởng:
25
NHAN_VIEN
Thuộc tính: ho_ten, dia_chi
Phương thức: Xuat, Tinh_Luong
NV_VP NV_SX
Thuộc tính: So_nc Thuộc tính: So_sp
Phương thức: Tinh_luong, Xuat Phương thức: Tinh_luong, Xuat
abstract class NHANVIEN

{ String HoTen="",DiaChi="";
float luong;
public Nhanvien(String ht, String dc) {
HoTen = ht;
DiaChi=dc;
}
public void xuat() {
System.out.println(HoTen);
System.out.println(DiaChi);
}
abstract float tinhluong();
}
class NV_VP extends NHANVIEN
{ float sonc;
public NV_VP(String ht, String dc, float nc)
{
super(ht,dc);
sonc = nc;
}
float tinhluong() {
return (sonc/22 * 700);
}
public void xuat_vp() {
xuat();
System.out.println("Tien luong la: " + tinhluong());
System.out.println("---------------------------");
}
}
class NV_SX extends Nhanvien
{ float sosp;
public NV_SX(String ht, String dc, float sp) {
super(ht,dc);
sosp = sp;
}
float tinhluong() {
return (sosp * 200);
}
public void xuat_sx() {
xuat();
System.out.println("Tien luong la: " + tinhluong());
System.out.println("---------------------");
26
}
}
public class kt {
NV_VP a = new NV_VP("Nguyen xuan Nhut","Tien Giang",20);
a.xuat_vp();
NV_SX sx = new NV_SX("Nguyen An","Can Tho",45);
sx.tinhluong();
sx.xuat_sx();
}
}
27
Chương 4
LỚP XỬ LÝ ỨNG DỤNG JAVA
1. Xử lý loại trừ (ngoại lệ)
1.1. Khái niệm
- Đối với người lập trình họ có thể gặp một trong các lỗi sau:
• Lỗi cú pháp (syntac error)
• Lỗi logic thuật toán
• Lỗi lúc thực thi (runtime error)
- Đối với lỗi cú pháp người lập trình có thể phát hiện và sửa lỗi, dựa vào trình biên dịch,
đây là lỗi dễ phát hiện và sửa chữa, tuy nhiên đây cũng là lỗi gây khó khăn và chán nản
đối với người mới học lập trình.
- Đối với lỗi thuật toán, đây là lỗi khó phát hiện và sửa chữa nhất, tuy nhiên trong bài này
ta không bàn luận về vấn đề này.
- Đối với lỗi lúc thực thi, ta hoàn toàn có thể kiểm soát được chúng, thông thường lỗi
runtime thường do nguyên nhân khách quan như: truy cập vào một ổ đĩa nhưng ổ đĩa này
lại chưa sẵn sàng, hay thực hiện phép chia nhưng mẫu số lại bằng 0, kết nối với máy tính
ở xa nhưng máy đó lại không tồn tại…, khi một lỗi runtime xẩy ra JVM sẽ phát sinh một
ngoại lệ, nếu một chương trình không cung cấp mã xử lý ngoại lệ thì chương trình có thể
kết thúc không bình thường.
- Là lỗi xuất hiện trong quá trình chương trình thực hiện của đoạn code. Nếu không xử lý
thì chương trình có thể bị dừng.
1.2. Mục đích của việc xử lý ngoại lệ
- Một chương trình nên có cơ chế xử lý ngoại lệ thích hợp. Nếu không, chương trình sẽ bị
ngắt khi một ngoại lệ xảy ra. Trong trường hợp đó, tất cả các nguồn tài nguyên mà hệ
thống đã cấp không được giải phóng, điều này gây lãng phí tài nguyên. Để tránh trường
hợp này, tất cả các nguồn tài nguyên mà hệ thống cấp nên được thu hồi lại. Tiến trình này
đòi hỏi cơ chế xử lý ngoại lệ thích hợp.
- Ví dụ, xét thao tác vào ra (I/O) trong một tập tin. Nếu việc chuyển đổi kiểu dữ liệu không
thực hiện đúng, một ngoại lệ sẽ xảy ra và chương trình bị hủy mà không đóng tập tin lại.
Lúc đó tập tin dễ bị hư hại và các nguồn tài nguyên được cấp phát cho tập tin không được
trả lại cho hệ thống.
1.3. Mô hình xử lý ngoại lệ của Java
Mô hình xử lý ngoại lệ của java dựa trên ba hoạt động chính: đặc tả ngoại lệ, ném ra
ngoại lệ, và bắt ngoại lệ.
- Đặc tả ngoại lệ: là khai báo cho trình biên dịch biết là phương thức này có thể gây ra
ngoại lệ lúc thi hành. Để khai báo ngoại lệ ta sử dụng từ khoá throws trong khai báo
phương thức:
Ví dụ:
public void myMethod() throws IOException, RemoteException // từ khoá
throws chỉ cho trình biên dịch java biết rằng phương thức này có thể ném ra ngoại lệ
28
IOException và RemoteException, nếu một phương thức ném ra nhiều ngoại lệ thì các
ngoại lệ được khai báo cách nhau bởi dấu phẩy ‘,’.
- Bắt ngoại lệ: là dấu hiệu chỉ ra rằng có sự xuất hiện một điều kiện không bình thường
nào đó.
Khuôn dạng tổng quát như sau:
try{
//Các lệnh có khả năng gây lỗi
}
catch (TypeException1 ex){
//Mã đựơc thực thi khi một ngoại lệ TypeException1
//đựơc phát sinh trong khối try
}
catch (TypeException2 ex){
//Mã đựơc thực thi khi một ngoại lệ TypeException2
}
...
catch ( TypeExceptionN ex){
// Mã đựơc thực thi khi một ngoại lệ TypeExceptionN
} finally{ //khối lệnh này là tùy chọn, có thể có hoặch không,
// nếu có thì khối lệnh này luôn được thực hiện cho dù
/ /ngoại lệ có xảy ra trong khối try hay không.
}
- Khối finally: khi một ngoại lệ xuất hiện, phương thức đang được thực thi có thể bị dừng
mà không được hoàn thành. Nếu điều này xảy ra, thì các đoạn mã phía sau sẽ không bao
giờ được gọi. Java cung cấp khối finally để giải quyết việc này. Thông thường khối finally
chứa các câu lệnh mang tính chất dọn dẹp như: đóng kết nối CSDL, đóng tệp tin,….
- Khối finally là tuỳ chọn, không bắt buộc phải có. Khối này được đặt sau khối catch cuối
cùng. Chương trình sẽ thực thi câu lệnh đầu tiên của khối finally ngay sau khi gặp câu
lệnh return hay lệnh break trong khối try.
- Khối finally bảo đảm lúc nào cũng được thực thi, bất chấp có ngoại lệ xảy ra hay không.
1.4. Một số lớp ngoại lệ:
Tên lớp ngoại lệ Ý nghĩa
Throwable Đây là lớp cha của mọi lớp ngoại lệ trong Java
Exception Đây là lớp con trực tiếp của lớp Throwable, nó

mô tả một ngoại lệ tổng quát có thể xẩy ra trong
RuntimeException ứng
Lớp dụng
cơ sở cho nhiều ngoại lệ java.lang
ArthmeticException Lỗi về số học, ví dụ như ‘chia cho 0’.
IllegalAccessException Lớp không thể truy cập.
29
IllegalArgumentException Đối số không hợp lệ.
ArrayIndexOutOfBoundsExeption Lỗi truy cập ra ngoài mảng.
NullPointerException Khi truy cập đối tượng null.
SecurityException Cơ chế bảo mật không cho phép thực hiện.
ClassNotFoundException Không thể nạp lớp yêu cầu.
NumberFormatException Việc chuyển đối từ chuỗi sang số không thành
AWTException công.
Ngoại lệ về AWT
IOException Lớp cha của các lớp ngoại lệ I/O
FileNotFoundException Không thể định vị tập tin
EOFException Kết thúc một tập tin.
NoSuchMethodException Phương thức yêu cầu không tồn tại.
InterruptedException Khi một luồng bị ngắt.
2. Xử lý toán học
- Lớp final class Math định nghĩa một tập các hàm tĩnh để thực hiện các chức năng chung
của toán học như các phép làm tròn số, sinh số ngẫu nhiên, tìm số cực đại, cực tiểu, v.v.
- Lớp final class Math còn cung cấp những hằng số như số e (cơ số của logarithm), số pi
thông qua Math.E và Math.PI.
2.1. Hàm abs()
• static int abs(int i);
• static long abs(long l);
• static float abs(float f);
• static double abs(double d);
Hàm abs() được nạp chồng để trả lại giá trị tuyệt đối của đối số.
2.2. Các hàm làm tròn
• static double ceil(double d): trả lại giá trị nhỏ nhất kiểu double mà không nhỏ hơn
đối số và lại bằng số nguyên.
Ví dụ: ceil(3.14) //4.0
• static double floor(double d): trả lại giá trị lớn nhất kiểu double mà không lớn
hơn đối số và lại bằng số nguyên.
Ví dụ: floor(3.14) //3.0
• static int round(float f d)
• static long round(double d)
Hàm round() được nạp chồng để trả lại số nguyên gần nhất của đối số.
2.3. Hàm max(); min()
• static int max(int a, int b)
• static long max(long a, long b)
• static float max(float a, float b)
• static double max(double a, double b)
Hàm max() được nạp chồng để trả lại giá trị cực đại của hai đối số.
30
• static int min(int a, int b)
• static long min(long a, long b)
• static float min(float a, float b)
• static double min(double a, double b)
Hàm min() được nạp chồng để trả lại giá trị cực tiểu của hai đối số.
2.4. Các hàm lũy thừa
• static double pow(double d1, double d2)
Hàm pow() trả lại giá trị là lũy thừa của d1 và d2 (d1,d2).
• static double exp(double d): trả lại giá trị là luỹ thừa cơ số e và số mũ d (ed).
• static double log(double d): trả lại giá trị là lô-ga-rit tự nhiên (cơ số e) của d.
• static double sqrt(double d):trả lại giá trị là căn bậc hai của d , hoặc giá trị NaN
nếu đối số âm.
2.5. Các hàm lượng giác
• static double sin(double d): trả lại giá trị sine của góc d dưới dạng radian.
• static double cos(double d: trả lại giá trị là cose của góc d dưới dạng radian.
• static double tan(double d): trả lại giá trị là tangent của góc d dưới dạng radian.
2.6. Hàm sinh số ngẫu nhiên
• static double random(): cho lại giá trị là số ngẫu nhiên trong khoảng từ 0.0 đến
1.0.
3. Xử lý chuỗi trong java
- Java được hỗ trợ bởi hai lớp String và StringBuffer để xử lý chuỗi.
- Lớp String dùng cho những xâu ký tự bất biến, nghĩa là những xâu chỉ đọc và sau khi
dược khởi tạo giá trị thì nội dung bên trong xâu không thể thay đổi được.
- Lớp StringBuffer được sử dụng đối với những xâu ký tự động, tức là có thể thay đổi
được nội dung bên trong của xâu.
3.1. Lớp String:
- Chuỗi là một dãy các ký tự. Lớp String cung cấp các phương thức để thao tác với
các chuỗi. Nó cung cấp các phương thức khởi tạo (constructor) khác nhau:
String str1 = new String( ); //str1 chứa một chuỗi rỗng.
String str2 = new String(“Hello World”); //str2 chứa xâu “Hello World”
Char ch[] = {‘A’,’B’,’C’,’D’,’E’};
String str3 = new String(ch); //str3 chứa “ABCDE”
String str4 = new String(ch,0,2); /*str4 chứa “AB” vì 0- tính từ ký tự bắt đầu,
2- là số lượng ký tự kể từ ký tự bắt đầu.*/
- Toán tử “+” được sử dụng để cộng chuỗi khác vào chuỗi đang tồn tại. Toán tử “+”
này được gọi như là “nối chuỗi”.
- Các phương thức của lớp String:
• char CharAt(int index): trả về một ký tự tại vị trí index trong chuỗi.
String name = new String(“Java Language”);
char ch = name.CharAt(5);
• boolean startsWith(String s): trả về giá trị kiểu logic (Boolean), phụ thuộc
vào chuỗi có bắt đầu với một chuỗi con cụ thể nào đó không.
31
String strname = “Java Language”;
boolean flag = strname.startsWith(“Java”); //flag = true
• boolean endsWith(String s): trả về một giá trị kiểu logic (boolean), phụ thuộc
vào chuỗi kết thúc bằng một chuỗi con nào đó không.
String strname = “Java Language”;
boolean flag = strname.endsWith(“Java”); //flag = true
• String copyValueOf(char data[], int offset, int count): trả về một chuỗi được rút
ra từ một mảng ký tự data được truyền như một đối số. Tham số offset chỉ định
vị trí từ nơi các ký tự bắt đầu được rút ra, và tham số count chỉ định số ký tự
được rút ra từ mảng data.
Char name[] = {‘L’,’a’,’n’,’g’,’u’,’a’,’g’,’e’};
String subname = String .copyValueOf(name,5,2); //subname = ag
• Char[] toCharArray( ): chuyển chuỗi thành một mảng ký tự.
String text = new String(“Hello World”);
Char textArray[] = text.toCharArray( );
• int indexOf(String sunString ): trả về thứ tự của một ký tự nào đó, hoặc một
chuỗi trong phạm vi một chuỗi. Các câu lệnh sau biểu diễn các cách khác nhau
của việc sử dụng hàm.
String day = new String(“Sunday”);
int index1 = day.indexOf(‘n’); //chứa 2
int index2 = day.indexOf(‘z’,2); //chứa –1 nếu “z”không tìm thấy tại vị trí 2.
int index3 = day.indexOf(“Sun”);//chứa mục 0
• String toUpperCase( ): trả về chữ hoa của chuỗi.
String lower = new String(“good morning”);
System.out.println(“Uppercase: ”+lower.toUpperCase( ));
• String toLowerCase( ): trả về chữ thường của chuỗi.
String upper = new String(“JAVA”);
System.out.println(“Lowercase: “+upper.toLowerCase( ));
• String trim(): dùng để cắt bỏ khoảng trắng hai đầu chuỗi. Hãy thử đoạn mã sau
để thấy sự khác nhau trước và sau khi cắt bỏ khoảng trắng.
String space = new String(“ Spaces “);
System.out.println(space);
System.out.println(space.trim()); //Sau khi cắt bỏ khoảng trắng
• boolean equals(String s): so sánh nội dung của hai đối tượng chuỗi.
String name1 = “Java”, name2 = “JAVA”;
boolean flag = name1.equals(name2); //flag = false
• Các phương thức valueOf
Được nạp chồng để cho phép chuyển một giá trị thành xâu:
- static String valueOf(Object obj): chuyển một đối tượng thành xâu, bẳng cách
gọi đến phương thức toString của đối tượng obj
- static String valueOf(Char[] Characters): chuyển mảng các ký tự thành xâu.
- static String valueOf(boolean b): chuyển một giá trị logic thành xâu, xâu nhận
được là “true” hoặc “false” tương ứng với giá trị true hoặc false của b
- static String valueOf(Char c)//Chuyển kí tự thành xâu
- static String valueOf(int i) //chuyển một số nguyên thành xâu
- static String valueOf(long l) //Chuyển một giá trị long thành xâu
32
- static String valueOf(float f) //chuyển một giá trị float thành xâu
- static String valueOf(Double d) //chuyển một giá trị Double thành xâu
- Ví dụ:
class chuoi
{
{
String s, s1, s2 = new String();
s="1234567890";
for(int k=s.length()-1; k>=0; k--) {
s1 =s.substring(k, k+1);
s2 =s2+s1;
}
System.out.print(s2);
}
}
3.2. Lớp StringBuffer:
- Lớp StringBuffer cung cấp các phương thức khác nhau để thao tác một đối tượng
dạng chuỗi.
- Các phương thức của lớp StringBuffer:
• void append(): nối thêm một chuỗi hoặc một mảng ký tự vào cuối cùng của đối
tượng StringBuffer.
StringBuffer s1 = new StringBuffer(“Good”);
s1.append(“evening”); //s1= Goodevening
• void insert(int, char): phương thức này có hai tham số. Tham số đầu tiên là vị trí
chèn. Tham số thứ hai có thể là một chuỗi, một ký tự (Char), một giá trị nguyên
(int), hay một giá trị số thực (float) được chèn vào. Vị trí chèn sẽ lớn hơn hay
bằng 0, và nhỏ hơn hay bằng chiều dài của đối tượng StringBuffer. Bất kỳ đối số
nào, trừ ký tự hoặc chuỗi, được chuyển sang chuỗi và sau đó mới được chèn vào.
StringBuffer str = new StringBuffer(“Jva sion”);
str.insert(1,’a’); //str = Java sion
• Char CharAt(): trả về một giá trị ký tự trong đối tượng StringBuffer tại vị
trí được chỉ định.
StringBuffer str = new StringBuffer(“James Gosling”);
Char letter = str.CharAt(6); //letter = “G”
• void setCharAt(int index, Char value): sử dụng để thay thế ký tự trong một
StringBuffer bằng một ký tự khác tại một vị trí được chỉ định.
StringBuffer name = new StringBuffer(“Java”);
name.setCharAt(2,’v’); //name = Java
• void setLength(): thiết lập chiều dài của đối tượng StringBuffer. Nếu chiều
dài được chỉ định nhỏ hơn chiều dài dữ liệu hiện tại của nó, thì các ký tự thừa sẽ
bị cắt bớt. Nếu chiểu dài chỉ định nhiều hơn chiều dài dữ liệu thì các ký tự
null được thêm vào phần cuối của StringBuffer.
StringBuffer str = new StringBuffer(10);
str.setLength(str.length() +10);
• Char[] getChars(): được sử dụng để trích ra các ký tự từ đối tượng StringBuffer,
33
và sao chép chúng vào một mảng. Phương thức getChars() có bốn tham số sau:
o Chỉ số đầu: vị trí bắt đầu, từ nơi mà ký tự được lấy ra.
o Chỉ số kết thúc: vị trí kết thúc
o Mảng: Mảng đích, nơi mà các ký tự được sao chép.
o Vị trí bắt đầu trong mảng đích: Các ký tự được sao chép vào mảng đích từ
vị trí này.
StringBuffer str = new StringBuffer(“Leopard”);
Char ch[] = new Char[10]; str.getChars(3,6,ch,0); //ch = par
• void reverse(): Phương thức này đảo ngược nội dung của một đối tượng
StringBuffer, và trả về một đối tượng StringBuffer khác.
StringBuffer str = new StringBuffer(“devil”);
StringBuffer strrev = str.reverse(); //strrev = lived
4. Xử lý ngày tháng
- Date class
- SimpleDateFormat class
- Ví dụ 1:
import java.util.Date;
class thu
{
public static void main(String args[]) {
Date today=new Date();
if (today.getDay() == 0)
System.out.println("Hom nay la ngay chu nhat. ");
else
System.out.println("Hom nay khong phai ngay chu nhat. ");
}
}
- Ví dụ 2: Kiểm tra có phải năm nhuận hay không?
public static bookean isLeapYear(int year) {
if((year%100!=0) && (year%400==0)){
return true;
}
return false;
}
- Ví dụ 3: Đếm số ngày trong một tháng
public static void daysInMonth() {
TimeInJava tij = new TimeInJava();
Calendar c1 = Calendar.getInstance();
c1.set(2008, 6 , 20);
int year = c1.get(Calendar.YEAR);
int month = c1.get(Calendar.MONTH);
int [] daysInMonths = {31,28,31,30,31,30,31,31,30,31,30,31};
daysInMonths[1] += tij.isLeapYear(year) ?1:0;//phương thức kiểm tra năm nhuần
System.out.println("Số ngày trong tháng "+month+" năm "+year+" : "+
daysInMonths[c1.get(Calendar.MONTH)]);
}
34
5. Xử lý tập hợp nâng cao
5.1. Vector
- Vector là mảng không giới hạn số phần tử.
- Vector có cớ chế đồng bộ hóa dữ liệu vì thế chúng ta có thể cập nhật chúng tại nhiều
uồng khác nhau.
- Ứng dụng Vector : dữ liệu theo dạng tập hợp, làm nguồn dữ liệu cho List, ComboBox,
Table
- Khai báo Vector: Ve c t o r < t ê n _ v e c t o r > = n e w
• Vector: class Vector được cài đặt trong thư viện Java
• <tên_vector>: đặt theo quy tắc đặt tên biến
• new: từ khóa dùng để khai báo đối tượng
• Vector(): phương thức khởi tạo mặc định của Vector, có thể được thay thế bằng
Vector(int), Vector(int, int)
- Sử dụng Vector: < t ê n _ v e c t o r > . < p h ư ơ n g _ t h ứ c > ( t h a m s ố )
• <tên_vector>: được khai báo trước khi sử dụng
• <phương_thức>: được cài đặt trong thư viện java thuộc gói java.util.Vector
• Tham số: mỗi phương thức các tham số khác nhau
• Kiểu dữ liệu trả về : tùy thuộc vào kiểu dữ liệu trả về của phương thức để dùng
biến lưu trữ hay không.
- Phương thức cho Vector:
Khai báo: Vector v = new Vector();
• void v.add(tham_so): thêm phần tử vào Vector v
• int v.size(): số phần tử của Vector v
• Object v.get(int i): lấy giá trị phần tử thứ i trong Vector
• int v.indexOf(“XYZ”) : trả về vị trí phần tử “XYZ” trong Vector v, nếu không tìm
thấy trả về -1
• void v.remove(“XYZ”) : xóa phần tử “XYZ” ra khỏi Vector v
• void v.clear() : xóa tất cả các phần tử trong Vector v
• Collection.sort(v) : sắp xếp các phần tử trong Vector v
- Ví dụ 1: Tạo ngẫu nhiên n số phần tử cho Vector (0<n<20), giá trị của các phần tử
được sinh ngẫu nhiên trong khoảng [0 – 100]
Vector vso=new Vector();
int sopt = (int)(Math.random()*20)+1;
for(int i=0 ; i<sopt ; i++)
vso.add((int)(Math.random()*100));
lstSo.setListData(vso);
- Ví dụ 2: Trò chơi đoán số: nhập 1 số nguyên dương bất kỳ, sinh ngẫu nhiên 100
nguyên dương bất kỳ, nếu số vừa nhập trùng với số sinh ngẫu nhiên thì đoán đúng,
ngược lại thì đoán sai.
Vector vso=new Vector();
int sophantu = (int)(Math.random()*20)+1;
int n=Integer.parseInt(this.txtSo.getText());
35
for(int i=0;i<sophantu;i++)
vso.add((int)(Math.random()*100));
lstSo.setListData(vso);
for(int i=0;i<vso.size();i++)
if(n==vso.get(i)) {
JOptionPane.showMessageDialog(this,"BAN DA DOAN DUNG");
break;
}
- Ví dụ 3: Sắp xếp các phần tử trung Vector
Vector v = new Vector();
v.add("Nhut"); v.add("Vinatex"); v.add("123"); v.add("Xuan");
int l=v.size();
System.out.print("Tong so PT: "+ l);
for(int i=0;i<v.size();i++) {
System.out.print("\n"+ v.get(i));
}
System.out.println("\n Sau khi sap xep là:");
Collections.sort(v);
for(int i=0;i<v.size();i++) {
System.out.print("\n"+ v.get(i));
}
v.clear();
System.out.print("\nTong so PT sau khi xoa la: "+ v.size());
- Ví dụ 4: Đếm xem có bao nhiêu địa chỉ mail yahoo trong danh sách các địa chỉ mail.
String
mail="a@yahoo.com,b@yahoo.com,c@gmail.com,f@vnn.vn,c@yahoo.com";
String [] sa = mail.split(",");
for(int k=0;k<sa.length;k++) {
System.out.println(sa[k]);
}
System.out.println("Tong so : " + sa.length);
StringTokenizer st = new StringTokenizer(mail,",");
while( st.hasMoreTokens() ) {
v.add(st.nextToken());
}
System.out.println(v.toString());
int i=0,count=0;
while(i<v.size()) {
if(v.get(i).toString().indexOf("@yahoo.com") > 0 ) {
count ++;
}
i++;
}
System.out.println("Tong so mail Yahoo: " +count);
- Ví dụ 5: Duyệt các phần tử trong Vector
36
v.add("0");v.add("1");v.add("2");v.add("3");v.add("4");
v.add("5");v.add("6");v.add("7");v.add("8");v.add("9");
v.add("10");v.add("11");
System.out.println(v);
int i=0;
while(true) {
if(i>=v.size()) {
break;
}
v.remove(i);
i=i+1;
}
System.out.print(v);
}
5.2. ArrayList
- Vector và ArrayList là hai lớp kiểu mảng động (kích thước thay đổi được). Hiệu suất sử
dụng hai lớp này là tương đương nhau, tuy nhiên nếu xét theo nhiều khía cạnh khác thì
ArrayList là cấu trúc hiệu quả nhất để cài đặt cấu trúc danh sách List.
- Một số phương thức:
• Object get(int index): cho lại phần tử được xác định bởi index.
• Object set(int index, Object elem): thay thế phần tử được xác định bởi index bằng
elem.
• void add(int index, Object elem): chèn elem vào sau phần tử được xác định bởi index.
• Object remove(int index): bỏ đi phần tử được xác định bởi index.
• boolean addAll(int index, Collection c): chèn các phần tử của tập hợp c vào vị trí
được xác định bởi index.
• int indexOf(Object elem): cho biết vị trí lần xuất hiện đầu tiên của elem.
• int lastIndexOf(Object elem): cho biết vị trí lần xuất hiện cuối cùng của elem.
• List subList(int fromIndex, int toIndex): lấy ra một danh sách con từ vị trí fromIndex
đến toIndex .
• ListIterator listIterator(): cho lại các phần tử liên tiếp bắt đầu từ phần tử đầu tiên.
- Ví dụ: Hệ thống có một dãy N_DIGIT (5) chữ số bí mật. Hãy viết chương trình nhập
vào N_DIGIT chữ số để đoán xem có bao nhiêu chữ số trùng và có bao nhiêu vị trí các
chữ số trùng với dãy số cho trước.
import java.util.*;
public class NhapDoanSo {
final static int N_DIGIT = 5;
public static void main(String args[]){
if(args.length != N_DIGIT) {
System.err.println("Hay doan " + N_DIGIT + " chu so!");
return; }
List biMat = new ArrayList(); // Tạo danh sách biMat là rỗng
biMat.add("5"); // Bổ sung các số vào dãy biMat biMat.add("3");
37
biMat.add("2");
biMat.add("7");
biMat.add("2");
List doan = new ArrayList(); // Tạo danh sách doan là rỗng
for(int i = 0; i < N_DIGIT; i++)
doan.add(args[i]); // Đưa các số từ đối số chương trình vào doan
List lap = new ArrayList(biMat); // Lưu biMat sang lap
int nChua = 0;
// Đếm số các chữ số trùng nhau, nghĩa là thực hiện được phép bỏ đi
remove()
for(int i = 0; i < N_DIGIT; i++)
if (lap.remove(doan.get(i))) ++nChua;
int nViTri = 0;
ListIterator kiemTra = biMat.listIterator();
ListIterator thu = doan.listIterator();
// Tìm những vị trí đoán trúng trong hai dãy có lặp
while (kiemTra.hasNext()) // Khi còn phần tử tiếp theo
// Kiểm tra xem lần lượt các vị trí của hai dãy có trùng nhau hay không
if (kiemTra.next().equals(thu.next())) nViTri++;
// Thông báo kết quả ra màn hình
System.out.println(nChua + " chu so doan trung.");
System.out.println(nViTri + " vi tri doan trung.");
}
}
Dịch và thực hiện chương trình: java NhapDoanSo 3 2 2 2 7 sẽ cho kết quả:
4 chu so doan trung
1 vi tri doan trung
38
Chương 5
LẬP TRÌNH GIAO DIỆN
1. Các thành phần giao diện
- Là tập thư viên được xây dựng sẵn hỗ trợ người lập trình java tạo ra ứng dụng với các
chức năng phong phú một cách dễ dàng.
- Nghiên cứu class/interface trong các gói:
• java.lang : phổ dụng trong ngôn ngữ lập trình java
• java.util : tiện ích có tính năng mạnh
• java.awt : hỗ trợ lập trình GUI
• java.awt.event : xử lý sự kiện xảy ra trong GUI
• java.applet : giúp tạo dựng và quản lý Applet
• java.io : xử lý các luồng dữ liệu vào ra
• java.util.zip : nén và giải nén dữ liệu
• javax.swing.* : Ho tro GUI nang cao.
2. Java Gui Api

- Label: dùng để hiển thị dữ liệu, không hiệu chỉnh.
- Toggle Button: có giá trị on/off hoặc true/false
- Radio Button: chỉ cho phép chọn 1 từ 1 nhóm các lựa chọn
- Combo Box: giống như một drop down box – bạn có thể click vào mũi tên drop down và
chọn một lựa chọn từ một danh sác
- Text Field: cho phép chỉnh sửa/hiển thị một dòng text đơn, có thể được căn lề trái, phải
hoặc chính giữa hay đặt font cho text.
- Scroll Bar: thanh cuộn dữ liệu
- Progress Bar: thanh xử lý tiến trình
- Password Field: dùng để nhập / hiển thị dạng password
39
- Table: chứa các dòng và cột dạng bảng
- Button: Cho phép người dùng click vào để kích hoạt một hành động được chỉ định
- Check Box: Cho phép chọn nhiều lựa chọn cùng lúc
- Button Group: một nhóm các Buttons trong đó chỉ có một item được chọn
- Text Area: Cho phép hiển thị/ chỉnh sửa nhiều dòng text. Có thể được sử dụng kết hợp
với lớp JScrollPane để thực hiện việc cuộn ngang, dọc.
• getText() : Lấy nội dung của JTextArea
• setText(String text) : Đặt nội dung cho JTextArea
• append(String str) : Thêm chuỗi vào cuối nội dung của JTextArea
• setColumns(int columns) : Đặt số cột cho JTextArea
• setRows(int rows) : Đặt số dòng cho JTextArea
• setLineWrap(boolean wrap) : Đặt/Hủy line wrap
• setWrapStyleWord(boolean word): Đặt/ Hủy word wrap
• setDragEnabled(boolean b) : Enable / Disable thao tác kéo nội dung
• setCaretPosition(int position) : Đặt vị trí con trỏ nháy
• setCaretColor(Color c) : Đặt màu cho con trỏ nháy
Ví dụ 1: Sử dụng showInputDialog
String name;
name = JOptionPane.showInputDialog(null, "What is your name?");
JOptionPane.showMessageDialog(null, "Nice to meet you, " + name + ".");
Ví dụ 2: CheckBox
private void Checkbox_click(javax.swing.event.ChangeEvent evt) {

txtCheck.setText("");
txtCheck.append("Các CheckBox được chọn:");
if(this.chkVN.isSelected())
txtCheck.append("\r\n\t Checkbox[1] = "+chkVN.getText());
if(this.chkLao.isSelected())
txtCheck.append("\r\n\t Checkbox[2] = "+chkLao.getText());
if(this.chkUsa.isSelected())
txtCheck.append("\r\n\t Checkbox[3] = "+chkUsa.getText());
if(this.chkJapan.isSelected())
txtCheck.append("\r\n\t Checkbox[4] = "+chkJapan.getText());
}
Ví dụ 3: RadioButton
40
private void RadioButton_click(java.awt.event.MouseEvent evt) {
if(rdRed.isSelected())
txtColor.setBackground(Color.red);
else if(rdBlue.isSelected())
txtColor.setBackground(Color.BLUE);
else if(rdVolet.isSelected())
txtColor.setBackground(Color.MAGENTA);
else if(rdYellow.isSelected())
txtColor.setBackground(Color.yellow);
else if(rdGreen.isSelected())
txtColor.setBackground(Color.GREEN);
else
txtColor.setBackground(Color.pink);
}
//Đưa các RadioButton vào Group
this.buttonGroup1.add(this.rdRed);
this.buttonGroup1.add(this.rdBlue);
this.buttonGroup1.add(this.rdGreen);
this.buttonGroup1.add(this.rdYellow);
this.buttonGroup1.add(this.rdVolet);
this.buttonGroup1.add(this.rdPink);
3. Jframe
- Dùng làm khung chứa các Swing Controls
- Thực thi ứng dụng bằng giao diện
4. Layout Manager
41
- FlowLayout: cho phép add các control trên cùng một dòng, khi nào hết chỗ chứa nó sẽ
tự động xuống dòng, ta cũng có thể điều chỉnh hướng xuất hiện của control. Mặc định
khi một JPanel được khởi tạo thì bản thân lớp chứa này sẽ có kiểu Layout là FlowLayout.
- BoxLayout: cho phép add các control theo dòng hoặc cột, tại mỗi vị trí add nó chỉ chấp
nhận 1 control, do đó muốn xuất hiện nhiều control tại một vị trí thì bạn nên add vị trí
đó là 1 JPanel rồi sau đó add các control khác vào JPanel này.
- BorderLayout: giúp chúng ta hiển thị các control theo 5 vùng: North, South, West, East,
Center
- CardLayout: CardLayout cho phép chia sẻ vị trí hiển thị của các control, tức là ứng với
cùng 1 vị trí hiển thị đó thì ta có thể cho các control khác hiển thị tại những thời điểm
khác nhau, mặc định control được add đầu tiên sẽ hiển thị.
- Ngoài ra còn một số Layout được sử dụng trong thiết kế giao diện như: GridBagLayout,
GridLayout, GroupLayout, SpringLayout
5. Điều khiển sự kiện
- Inline anonymous listener:
JButton btn1=new JButton("Say Hello!");
btn1.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent arg0) {
JOptionPane.showMessageDialog(null, "Hello tèo");
42
}
});
- Listener in variable:
ActionListener btnClick=new ActionListener() {
JOptionPane.showMessageDialog(null, "Click!");
}
};
btn1.addActionListener(btnClick);
btn2.addActionListener(btnClick);
- Listener class:
private class MyClick implements ActionListener
{
@Override
}
}
- JOptionPane:
JOptionPane.showMessageDialog(null,"Hello Tèo");
int ret = JOptionPane.showConfirmDialog(null,"Thoát hả?",
"Thoát",JOptionPane.YES_NO_OPTION);
if(ret==JOptionPane.YES_OPTION) {
}
String s=JOptionPane.showInputDialog("Nhập :");
43
Chương 6
XÂY DỰNG ỨNG DỤNG JAVA
1. Các thành phần ứng dụng java
- Phần giao diện
- Phần cơ sở dữ liệu: Access, SQL Server, Oracle ...
2. Mô hình 2 lớp
- Mô hình 2 lớp hay còn gọi là mô hình MVC (Model-View-Controllor)
- Người thiết kế giao diện và người lập trình java có thể mang tính chất độc lập tương đối.
3. Cài đặt jdbc
- Đối với phần lớn những ứng dụng được xây dựng trên thực tế, việc lưu trữ thông tin
trong cơ sở dữ liệu là hết sức quan trọng. Với lượng dữ liệu khổng lồ mà các ứng dụng
này thường xuyên phải lưu trữ và xử lý trong quá trình hoạt động thì việc sử dụng một
hệ quản trị cơ sở dữ liệu (Database Management System - DBMS) là điều không thể
thiếu được khi triển khai ứng dụng.
- Một ứng dụng khi được xây dựng bằng 1 ngôn ngữ lập trình cụ thể (C sharp, Java, …)
thường bao gồm 2 phần tách biệt :
• Phần giao diện chương trình và chức năng của ứng dụng : giao tiếp với người sử dụng
thông qua các chức năng lệnh mô tả cho khả năng làm việc của chương trình như
: khả năng nhập dữ liệu,truy xuất thông tin, thống kê, tính toán số liệu để đáp ứng
cho nhu cầu làm việc của người dùng… (Trong bài viết này, chúng ta xem như
chương trình chính được viết bằng ngôn ngữ Java)
• Phần cơ sở dữ liệu cung cấp thông tin cho chương trình chính hoạt động, cho phép
lưu trữ thông tin mà người dùng nhập vào, cung cấp các khả năng cho phép chương
trình chính khai thác thông tin dựa trên dữ liệu đã có để đáp ứng cho những nhu cầu
cụ thể nào đó của người dùng … (Theo mô tả của bài viết này thì phần cơ sở dữ liệu
của chúng ta sẽ xây dựng bằng Microsoft SQL Server 2005)
- Do chương trình chính hoạt động phụ thuộc vào cơ sở dữ liệu đã được định nghĩa, chính
vì thế khi có các tác động của người dùng để thực hiện nhu cầu làm việc trong quá trình
sử dụng ứng dụng thì chương trình chính cần phải tạo ra 1 kết nối đến cơ sở dữ liệu ở
phía dưới để truy xuất thông tin hoặc thực hiện các lệnh cho nhu cầu lưu trữ,…. Để đáp
ứng nhu cầu này, Java cung cấp 1 giao diện lập trình (Java API – Application
Programming Interfaces) hỗ trợ cho các kết nối đến Database được gọi là JDBC – Java
Database Connectivity.
import java.sql.ResultSet;
import java.sql.SQLException.*;
import java.util.HashMap;
public class JDBC {
public static void main(String[] args) throws Exception {
//Tạo connection
SQLConnect connect=
new SQLConnect("localhost",1433,"sa","123","HOCSINHDB");
ResultSet result=connect.excuteQuery("Select * from HOCSINH");
//System.out.println(CountRow(result));
while(result.next()){
44
int m=result.getInt("maHS");
String t=result.getString("tenHS");
System.out.println(m+" "+t);
}
connect.Close();
}
protected static int CountRow(ResultSet result) throws Exception{
int count=0;
while(result.next()){
count++; //result.getObject("tenHS");
}
return count;
}
}
4. Một số class và interface của Jdbc Api
- JDBC API cung cấp 1 thành phần gọi là JDBC Drivers. JDBC Drivers có nhiệm vụ
chuyển đổi các yêu cầu truy xuất từ Client để DBMS có thể hiểu và thực thi những yêu
cầu này trên Database của chương trình, tương tự, khi nhận được kết quả hồi đáp từ
Database, JDBC Driver sẽ chuyển đổi ngược về dạng thức mà chương trình viết bởi Java
có thể hiểu và nhận dạng được. Có 4 kiểu kết nối đến Database bằng JDBC như mô tả
dưới đây
• ODBC – JDBC Bridge (Type I)
• Native API-Java/ Partly Java (Type II)
• JDBC Network – All Java (Type III)
• Native protocol – All Java (Type IV)
import com.microsoft.sqlserver.jdbc.SQLServerDataSource;
import java.sql.*;
public class SQLConnect {
String Host="";//Thông tin Host của DataBase Server muốn kết nối
String UserName ="";//Thông tin tên đăng nhập của Database Server
String Password="";//Thông tin mật khẩu của Database Server
String DataBase="";//Tên Database muốn connect tới.
int Port=0;
Connection connect =null;//Khởi tạo Connection bằng null;
Statement statement=null;//Khởi tạo Statement để thực thi
ResultSet result=null;//Khởi tạo ResultSet chứa dữ liệu;
//Hàm khởi tạo và truyền thông tin của Database Server
public SQLConnect(String Host, int Port,String UserName,String Password,String
Database){
this.DataBase=Database;
this.Host=Host;
this.Port=Port;
this.Password=Password;
this.UserName=UserName;
}
//Hàm kiểm tra xem Driver connect SQL đã sẵn sàng hay chưa.
protected void driverTest() throws Exception{
try{
//Kiểm tra Class Name
Class.forName("com.microsoft.sqlserver.jdbc.SQLServerDriver");
}
45
//Nếu chưa tồn tài thì ném lỗi ra ngoài
catch(java.lang.ClassCastException e){
throw new Exception("SQL JDBC Driver not found");
}
}
//Hàm lấy Connecttion
protected Connection getConnect() throws Exception{
//Nếu connection null thì khởi tạo mới.
if(this.connect==null){
//Kiểm tra Driver
driverTest();
//Tạo URL kết nối đến Database Server
try{
//Tạo kết nối thông qua Url
SQLServerDataSource ds=new SQLServerDataSource();
ds.setUser(this.UserName);
ds.setPassword(this.Password);
ds.setServerName(this.Host);
ds.setPortNumber(this.Port);
ds.setDatabaseName(this.DataBase);
this.connect=ds.getConnection();
}
//Nếu không thành công ném lỗi ra ngoài
catch( java.sql.SQLException e){throw new Exception("No connect to
Database Server" + e.getMessage());
}
}
//Trả connection ra ngoài
return this.connect;
}
protected Statement getStatement() throws Exception{
//Kiểm tra statement nếu = null hoắc đã đóng.
if(this.statement==null? true: this.statement.isClosed()){
this.statement=this.getConnect().createStatement();
}
//Trả statement ra ngoài
return this.statement;
}
//Hàm thực thi câu lệnh Select lấy dữ liệu từ CSDL
public ResultSet excuteQuery(String Query) throws Exception{
try{
//Thực thi câu lệnh.
this.result =getStatement().executeQuery(Query);
}
//Nếu không thành công ném lỗi ra ngoài.
catch(Exception e){
throw new Exception("Erro:"+e.getMessage()+" - "+ Query);
}
//Trả kết quả ra ngoài.
return this.result;
}
//Thực thi các câu lệnh Insert, Update, Delete
public int excuteUpdate(String Query) throws Exception{
int res=Integer.MIN_VALUE;
46
try{
//Thực thi câu lệnh.
res =getStatement().executeUpdate(Query);
}
//Nếu không thành công ném lỗi ra ngoài.
catch(Exception e){
throw new Exception("Erro:"+e.getMessage()+" - "+ Query);}
finally{
//Đóng kết nối.
this.Close();
}
//Trả kết quả ra ngoài.
return res;
}
//Hàm đóng kết nối
public void Close() throws SQLException{
//Nếu Result chưa đóng. Đóng result
if(this.result!=null && !this.result.isClosed()){
this.result.close();
this.result =null;
}
//Nếu Statement chưa đống. Đóng Statement
if(this.statement!=null && !this.statement.isClosed()){
this.statement.close();
this.statement=null;
}
//Nếu connection chưa đóng. Đóng connection.
if(this.connect!=null && !this.connect.isClosed()){
this.connect.close();
this.connect=null;
}
}
}
5. Một số kỹ thuật sử dụng Jdbc
- Đây là 1 thư viện chứa các lớp (Classes) và giao diện (Interfaces) cho phép lập trình viên
có thể thực hiện kết nối từ chương trình của mình đến cơ sở dữ liệu để lưu trữ thông tin
và hỗ trợ cho quá trình xử lý.
- JDBC cho phép 1 chương trình viết bằng Java có thể truy xuất đến bất kỳ kiểu dữ liệu
nào của Database cũng như có thể thực thi trên tất cả các môi trường có hỗ trợ máy ảo
Java (JVM – Java Vitural Marchine)
- Về khía cạnh phát triển ứng dụng thì JDBC cho phép xây dựng 1 ứng dụng Java có thể
tác động đến nhiều loại Database khác nhau như : SQL Server, Oracle, MySQL, DB2,
Access, … với cùng 1 hình thức. Có nghĩa là với các loại Database khác nhau thì các đối
tượng được tạo ra bởi JDBC trong chương trình vẫn có thể sử dụng các cấu trúc lệnh
phục vụ cho việc thao tác dữ liệu (Tạo, Ghi, Truy vấn, …) trên Database không hề thay
đổi dựa trên cấu trúc truy vấn dữ liệu dạng SQL(Structure Query Language).
- Điều này rất hữu ích trong tình huống: 1 ứng dụng ban đầu thiết kế sử dụng cơ sở dữ
liệu SQL Server nhưng sau đó vì 1 lý do đặc biệt mà phải chuyển sang sử
dụng MySQL thì phần mã lệnh của chương trình dùng cho việc truy xuất dữ liệu đến
47
Database vẫn không phải thay đổi gì nhiều, có chăng là điều chỉnh lại các thuộc tính cần
thiết cho việc kết nối Database loại khác mà thôi.
48
THỰC HÀNH 1: NGÔN NGỮ JAVA
Ví dụ Console Application:
Bài 1 - Hello world
public class Core {
System.out.println("Hello,Everybody in the World!");
System.out.println("This is JAVA!");
System.out.println("Welcome to language Java!");
}
}
Bài 2 – In ra chuỗi nhập vào
public class Hello {
System.out.print("Your name is: ");
String str;
str = in.nextLine();
System.out.println("Welcome " + str + " to Java");
}
}
Bài 3 – Biến trong Java

public class Hello {
System.out.print("Nhap a: ");
System.out.print("Nhap b: ");
int b = in.nextInt();
int tong = a+b;
System.out.println("a + b = “ + tong);
int hieu = a-b;
System.out.println("a - b = “ + hieu);
int tich = a*b;
System.out.println("a * b = “ + tich);
float thuong = (float)a/b;
System.out.println("a / b = “ + thuong);
int laydu = a%b;
System.out.println("a % b = “ + laydu);
}
}
Bài tập Console Application:
Nhập xuất cơ bản: System.out.println ();
Bài 1: Viết chương trình xuất ra màn hình một bài thơ.
Bài 2: Viết chương trình nhập họ tên và xuất họ tên đã nhập ra màn hình
49
Bài 3: Xây dựng chương trình nhập một số nguyên dương r, xuất ra chu vi và diện tích đường
tròn có bán kính r.
Các câu lệnh Cơ bản (if, switch)
Bài 4: Nhập hai số nguyên a, b. Viết hàm hoán vị hai số đã nhập. Viết theo dạng class
Bài 5: Nhập ba số nguyên a, b, c. Viết hàm tìm giá trị lớn nhất của ba số đó.
Bài 6: Nhập vào số ramdom trong khoảng [80 – 120]
Bài 7: Nhập ba số nguyên a, b, c. Viết hàm kiểm tra a, b, c có thể là ba cạnh của một tam giác
hay không. Nếu ba số đó là ba cạnh của một tam giác thì tính diện tích tam giác đó theo công
thức heron p = (a+b+c)/2 , S= p( p − a)( p − b)( p − c)
Bài 8: Nhập a, b, c. Viết hàm giải phương trình bậc hai: ax2 + bx + c = 0.
Bài 9: Nhập số nguyên n. Viết hàm kiểm tra n có phải là số hoàn hảo hay không.
Bài 10: Nhập số nguyên y. Viết hàm kiểm tra y là năm nhuận hay không là năm nhuận.
Bài 11: Nhập số nguyên m. Viết hàm kiểm tra tháng m có bao nhiêu ngày.
Bài 12: Nhập ba số nguyên d, m, y. Viết hàm kiểm tra xem thứ tự ba số đó có tạo thành một
ngày hợp lệ không.
Vòng lặp (while, do, for)
Bài 13: Nhập số nguyên n. Viết hàm kiểm tra n có phải là số nguyên tố hay không.
Bài 14: Nhập số nguyên n. Viết hàm đếm n có bao nhiêu chữ số.
Bài 15: Nhập số nguyên n. Viết hàm tìm chữ số có giá trị lớn nhất.
Bài 16: Trò chơi đoán số. Máy tính sẽ sinh ngẫu nhiên một số, rồi yêu cầu người chơi đoán số
đó. Mỗi lần người chơi đoán một số thì máy sẽ trả lời: Số người nhập lớn hay nhỏ hơn số của
máy. Viết chương trình trò chơi đoán số và khi người đoán đúng thì sẽ xuất hiện câu chúc
mừng và số lần người chơi đã đoán.
Random, Mảng, Vector, Hastable
Bài 17: Nhập vào một dãy số nguyên. Viết hai hàm tính tổng, tích dãy đó
Bài 18: Sinh ngẫu nhiên một dãy số nguyên n phần tử (n nhập từ bàn phím). Viết một hàm
tìm giá trị lớn nhất và nhỏ nhất của dãy.
Bài 19: Sinh ngẫu nhiên một dãy số nguyên a gồm n phần tử (n nhập từ bàn phím). Viết hàm
trả về một mảng các số nguyên tố trong dãy a.
Bài 20: Sinh ngẫu nhiên một dãy số nguyên a có n phần tử (n nhập từ bàn phím). Nhập số
nguyên k và số nguyên l. Viết hàm xóa l phần tử của dãy số a bắt đầu từ k.
Bài 21: Nhập mảng số nguyên 2 chiều nxm. Dòng vị trí chẵn sắp không giảm. Dòng vị trí lẻ
sắp không tăng.
Chuỗi (charAt[], String, StringTokenizer)
Bài 22: Nhập một chuỗi gồm nhiều từ hãy chuyển chuỗi đó sang ký tự thường, sang ký tự
hoa, đếm số từ trong chuỗi.
50
THỰC HÀNH 2: JAVA + NETBEANS
1. Xây dựng màn hình xuất câu chào
2. Xây dựng màn hình tính tổng 2 số nguyên
o Hướng dẫn:
- Hàm chuyển từ chuỗi sang số nguyên: Integer.parseInt(String)
3. Xây dựng màn hình tính tiền hàng theo công thức: Thành tiền = Số lượng * Đơn giá
4. Xây dựng màn hình tính chu vi, diện tích hình tròn
51
o Hướng dẫn
- Giá trị PI: Java cung cấp hằng số Math.PI
- Hàm chuyển từ chuỗi sang số thực: Float.parseFloat(String)
- Format chuỗi: String.format("%.2f", iChuVi);
5. Xây dựng màn hình tính tiền điện
- Tổng số điện = Chỉ số mới - chỉ số cũ
- 50 số đầu tiên: 500 vnđ/số
- Từ số 51 đến số 100: 1.000 vnđ/số
- Từ số 101 đến số 200: 2.000 vnđ/số
- Từ số 201 đến số 300: 2.500 vnđ/số
- Trên 300: 4.000 vnđ/số
o Hướng dẫn:
- Tính thành tiền: kiểm tra điều kiện tổng số điện lần lược theo các mức tiêu thụ
300, 200, 100, 50
private Float tinhTien(Float tongSoDien) {
float iTongSoDien = tongSoDien;
float iThanhTien = 0f;
if(iTongSoDien > 300){
iThanhTien += (iTongSoDien - 300) * 4000;
iTongSoDien = 300;
}
52
iTongSoDien = 200;
}
iTongSoDien = 100;
}
iTongSoDien = 50;
}
iThanhTien += iTongSoDien * 500;
return iThanhTien;
}
6. Xây dựng màn hình giải phương trình bậc nhất ax + b = 0 với a # 0
7. Xây dựng màn hình tính giai thừa một số

- Nhập vào x. Nhấn nút “Tính giai thừa” => Hiển thị kết quả
o Hướng dẫn:
- Tính giai thừa : 0! = 1; x! = 1 * 2 * 3 * ... * (x - 1) * x
- Hàm tính giai thừa:
private Long tinhGiaiThua(int x){
53
Long kq = 1l;
if(x < 0) {
return -1l;
}
for(int i = 1; i <= x; i++) {
kq = kq * i;
}
return kq;
}
8. Xây dựng màn hình tách họ tên trong chuỗi họ tên
- Nhập họ tên vào ô nhập liệu. Nhấn nút “Tính” => tách họ và tên và hiển thị ở ô “Họ” và
ô “Tên”
9. Xây dựng màn hình tìm kiếm chuỗi

- Nhập vào chuỗi thứ nhất và chuỗi thứ hai. Nhấn nút “Tìm kiếm” => Xuất ra kết
quả cho biết chuỗi thứ hai có nằm trong chuỗi thứ nhất hay không.
o Hướng dẫn:
- Dùng hàm contains của lớp String để xử lý.
10. Xây dựng màn hình tính số ngày trong tháng
- Nhập vào tháng và năm. Nhấn nút “Tính” => Hiển thị số ngày trong tháng
54
o Hướng dẫn:
- Ngày trong tháng: Tháng 1, 3, 5, 7, 8, 10, 12 có 31 ngày; Tháng 4, 6, 9, 11 có
30 ngày; Tháng 2 năm thường có 28 ngày, năm nhuận có 29 ngày; Năm nhuận
là năm chia hết cho 4 và không chia hết cho 100 hoặc là năm chia hết cho 400.
- Tính ngày trong tháng:
private int tinhNgayTrongThang(int thang, int nam){
switch (thang) {
case 1: case 3: case 5:
case 7: case 8: case 10: case 12:
return 31;
case 4: case 6: case 9: case 11:
return 30;
case 2:
if(laNamNhuan(nam)){
return 29;
}
return 28;
}
return 0;
}
- Kiểm tra năm nhuận:
private boolean laNamNhuan(int nam){
if((nam %4 ==0 && nam %100 !=0) || nam %400 ==0){
return true;
}
return false;
}
11. Xây dựng màn hình tính ngày sinh
- Nhập vào ngày, tháng, năm sinh. Nhấn nút “Tính” => hiển thị một trong các kết quả:
Còn n ngày nữa là đến ngày sinh của bạn” hoặc “Ngày sinh của bạn đã qua n ngày”
hoặc “Hôm nay là ngày sinh của bạn. Chúc mừng sinh nhật.”
55
o Hướng dẫn
- Dùng đối tượng Calendar để thao tác ngày.
- Lấy ngày hệ thống: Calendar now = Calendar.getInstance();
- Tính ra số ngày tính từ năm 1200.
int nowDays = (int)(now.getTimeInMillis() / (1000 * 60 * 60 * 24));
12. Thiết kế màn hình hiển thị thông tin liên hệ: Tên, ĐTDĐ, Hình ảnh
- Nhập vào các ô nhập liệu các thông tin: tên, điện thoại di động, hình ảnh. Nhấn nút
“Hiển thị” => Các thông tin vừa nhập sẽ được hiển thị.
o Hướng dẫn:
- Load hình ảnh: ImageIcon icon = new ImageIcon("đường dẫn đến image");
- lblHinhAnh.setIcon(icon);
13. (*) Thiết kế màn hình thêm mới thông tin liên hệ gồm: Họ tên, ĐTDĐ, Hình ảnh
- Nhập vào các ô nhập liệu các thông tin: tên, điện thoại di động, hình ảnh. Nhấn nút
“Thêm” => Các thông tin vừa nhập sẽ được lưu vào tập tin LienHe.txt.
56
o Hướng dẫn:
- Ghi nội dung vào file:
private void ghiVaoFile(String filePath,
String noiDung) throws IOException{
FileWriter fw = new FileWriter(filePath);
fw.write(noiDung);
fw.close();
}
- Hiển thị thông báo:
JOptionPane.showMessageDialog(null, "Thông tin Liên hệ đã được thêm vào tập
tin");
14. (*) Thiết kế màn hình cập nhật thông tin liên hệ gồm: : Họ tên, ĐTDĐ, Hình ảnh
- Cấu trúc file như sau: các phần tử Liên hệ sẽ được ghi vào tập tin có cấu trúc mảng
như sau:
• 1 phần tử là một chuỗi chứa 3 nội dung, mỗi nội dung cách nhau bằng một dấu “|”
• Các phần tử khi ghi vào tập tin sẽ cách nhau bằng dấu enter xuống dòng.
o Hướng dẫn
- Với mỗi thông tin nhập vào tạo thành một chuỗi (là 1 phần tử của mảng) có cấu
trúc như đã mô tả ở trên.
- Lưu chuỗi này vào tập tin chứa mảng các Liên Hệ.
- Hàm tạo chuỗi để thêm vào file
private String taoNoiDungGhiFile(String hoTen, String dtdd, String hinhAnh){
57
String content = "";
content += hoTen;
content += "|";
content += dtdd;
content += "|";
content += hinhAnh;
return content;
}
15. Xây dựng chương trình đếm số từ trong tập tin văn bản
- Nhập vào đường dẫn của một tập tin văn bản. Nhấn nút “Đọc tập tin” => Hiển thị nội
dung tập tin. Nhấn nút “Đếm số từ” => Hiển thị số từ của nội dung tập tin.
o Hướng dẫn:
- Đọc file dạng text:
private String docNoiDungFile(File file) throws IOException{
FileReader fr = new FileReader(file);
char[] cbuf = new char[(int)file.length()];
fr.read(cbuf);
String noiDung = String.valueOf(cbuf);
fr.close();
return noiDung;
}
- Dùng hàm split của String để cắt các từ trong một chuỗi
private int demSoTu(String text){
String[] ls =
text.split("[\\s\\.\\,\\:\\;\\/\\|\\\\]+");
if(ls != null){
return ls.length;
}
return 0;
}
16. Viết chương trình Tính tổng các phần tử trong mảng có n phần tử, mỗi phần tử có
giá trị ngẫu nhiên.
58
- Nhập vào số phần tử trong mảng n. Nhấn nút “Tính tổng” => Hiển thị mảng và tổng
các phần tử trong mảng.
o Hướng dẫn
- Dùng đối tượng Random để phát sinh số ngẫu nhiên.
private int[] phatSinhMangInt(int n){
int[] rs = new int[n];
Random random = new Random();
for(int i = 0; i < n; i++){
rs[i] = random.nextInt(100);
}
return rs;
}
- Xuất chuỗi của mảng
private String xuatMang(int[] mang){
String rs = "";
for (int i : mang) {
rs += i + " ";
}
return rs;
}
- Hàm tính tổng
private long tingTong(int[] mang){
long tong = 0;
for (int i : mang) {
tong += i;
}
return tong;
}
17. Viết chương trình Đọc và ghi mảng 1 chiều
- Cấu trúc file như sau: mảng được ghi vào tập tin, mỗi phần tử cách nhau bằng một
khoảng trắng.
- Chọn đường dẫn của tập tin chứa mảng đang có. Nhấn “Hiển thị” =>Mảng được tạo từ
tập tin sẽ hiển thị, kèm theo là thông báo “Mảng có … phần tử”
- Nhập một mảng mới. Chọn tập tin sẽ chứa mảng mới. Nhấn “Ghi”
59
o Hướng dẫn
- Đọc nội dung file, tách các phần tử trong nội dung theo khoảng trắng. Kiểm tra
tính hợp lệ của phần tử (là số nguyên)
- Dùng hàm split của String để cắt các phần tử
private int kiemTraPhanTu(String text){
String[] ls =
text.split("[\\s\\.\\,\\:\\;\\/\\|\\\\]+");
if(ls != null){
for (String string : ls) {
try{
Integer.parseInt(string);
}catch(Exception ex){ return -1; }
}
return ls.length;
}
return 0;
}
18. (*) Viết chương trình hiển thị danh sách các liên hệ lên trên lưới.
- Gồm các thông tin sau: hình ảnh, tên, điện thoại đi động, đằng sau mỗi liên hệ là
button xóa, cho phép xóa liên hệ khi chọn.
60
Thuật giải:
− Đọc nội dung file
− Phân tách các thành phần thành trong file
− Tạo nội dung hiển thị cho table, nội dung dưới dạng ma trận (Object[][]) mỗi
dòng là một liên hệ, các thành phần mỗi dòng lần lược là "Hình ảnh", "Họ tên",
"ĐTDĐ", "Hành động"
− Hiển thị hình ảnh bằng cách tạo TableCellRender cho cột "hình ảnh" và "hành
động"
o Hướng dẫn
− Tạo Render như sau:
public class ImageTableCellRenderer extends DefaultTableCellRenderer {
private static final long serialVersionUID = -7959113581100753271L;
private int imageWidth;
private int imageHeight;
public ImageTableCellRenderer(int imageWidth, int imageHeight) {
this.imageWidth = imageWidth;
this.imageHeight = imageHeight;
}
@Override
public Component getTableCellRendererComponent (JTable table,Object
value, boolean isSelected, boolean hasFocus, int row, int column)
{
super.getTableCellRendererComponent(table, value, isSelected,
hasFocus,row,column);
try {
BufferedImage image = null;
URL url = new URL("file:" + value);
image = getScaledImages (ImageIO.read(url), imageWidth,
imageHeight);
setIcon(new ImageIcon(image));
setHorizontalAlignment(JLabel.CENTER);
61
setText("");
} catch (Exception e) {
setText("[No image]");
e.printStackTrace();
}
return this;
}
....
private BufferedImage getScaledImages(BufferedImage in, int WIDTH, int HEIGHT)

{
BufferedImage out = new BufferedImage(WIDTH,
HEIGHT,BufferedImage.TYPE_INT_RGB);
Graphics2D g2 = out.createGraphics();
g2.setColor(Color.white);
g2.fillRect(0, 0, WIDTH, HEIGHT);
double width = in.getWidth();
double height = in.getHeight();
double xScale = WIDTH / width;
double yScale = HEIGHT / height;
double scale = 1.0;
scale = Math.min(xScale, yScale); // scale to fit
double x = (WIDTH - width * scale) / 2;
double y = (HEIGHT - height * scale) / 2;
AffineTransform at = AffineTransform.getTranslateInstance(x, y);
at.scale(scale, scale);
g2.drawRenderedImage(in, at);
g2.dispose();
return out;
}
}
19. (*) Viết chương trình Quản lý danh bạ điện thoại.
- Tương tự như bài trên như có thêm một menu “Danh bạ”, trong đó có các item: Thêm
một liên hệ, Xóa một liên hệ, Tìm kiếm liên hệ, Cập nhật liên hệ.
62
(*) Thuật giải:
− Đọc nội dung file
− Phân tách các thành phần thành trong file
− Tạo nội dung hiển thị cho table, nội dung dưới dạng ma trận (Object[][]) mỗi
dòng là một liên hệ, các thành phần mỗi dòng lần lược là "Hình ảnh", "Họ tên",
"ĐTDĐ", "Hành động"
− Hiển thị hình ảnh bằng cách tạo TableCellRender cho cột "hình ảnh" và "hành
động"
− Chọn menu Thêm, hiển thị màn hình thêm liên hệ
− Xử lý thêm liên hệ, cập nhật nội dung file
− Chọn menu Xóa, thực hiện xóa liên hệ, cập nhật nội dung file
− Chọn menu Cập nhật, hiển thị màn hình cập nhật liên hệ
− Xử lý cập nhật liên hệ, cập nhật nội dung file
− Chọn menu Tìm kiếm, hiển thị màn hình tìm kiếm
− Xử lý tìm kiếm liên hệ
20. (*) Xây dựng chương trình Tính toán hai phân số
- Phân số thứ nhất (tử số, mẫu số) và phân số thứ hai (tử số, mẫu số)
- Combobox 4 phép tính: +, -, *, / cho người dùng chọn
63
- Nhập vào phân số thứ nhất (tử số, mẫu số) và phân số thứ 2 (tử số, mẫu số), chọn 1
trong 4 phép tính. Nhấn nút “Tính” => Hiển thị kết quả lên phân số kết quả (tử số, mẫu
số)
o Hướng dẫn:
− Hàm tính toán 2 phân số theo phép tính
private PhanSotinh(String phepToan, PhanSo phanSo1, PhanSo phanSo2){
if("+".equals(phepToan)){
return tinhTong(phanSo1, phanSo2);
}else if("-".equals(phepToan)){
return tinhHieu(phanSo1, phanSo2);
}else if("*".equals(phepToan)){
return tinhTich(phanSo1, phanSo2);
}else if("/".equals(phepToan)){
return tinhThuong(phanSo1, phanSo2);
}
return null;
}
− Các Hàm tính toán 2 phân số
private PhanSo tinhTong(PhanSo phanSo1, PhanSo phanSo2){
int kqTuSo = phanSo1.getTuSo() * phanSo2.getMauSo() +
phanSo2.getTuSo() * phanSo1.getMauSo();
int kqMauSo = phanSo1.getMauSo() * phanSo2.getMauSo();
PhanSo kq = new PhanSo(kqTuSo, kqMauSo);
return kq;
}
private PhanSo tinhHieu(PhanSo phanSo1, PhanSo phanSo2){

int kqTuSo = phanSo1.getTuSo() * phanSo2.getMauSo()
- phanSo2.getTuSo() * phanSo1.getMauSo();
return kq;
}
64
private PhanSo tinhTich(PhanSo phanSo1, PhanSo phanSo2){
int kqTuSo = phanSo1.getTuSo() * phanSo2.getTuSo();
return kq;
}
private PhanSo tinhThuong(PhanSo phanSo1, PhanSo phanSo2){

int kqTuSo = phanSo1.getTuSo() * phanSo2.getMauSo();
int kqMauSo = phanSo1.getMauSo() * phanSo2.getTuSo();
return kq;
}
21. (*) Xây dựng chương trình nhập xuất thông tin hóa đơn bán hàng của một siêu thị.
- Thông tin hóa đơn gồm có: số hóa đơn, ngày lập hóa đơn, danh sách hàng hóa được
mua trong hóa đơn
- Thông tin hàng hóa gồm có: tên hàng hóa, đơn vị tính, đơn giá, số lượng mua
- Xây dựng chương trình có giao diện như sau, nhập thông tin hóa đơn và xuất thông tin
hóa đơn ra màn hình.
- Nhập thông tin hóa đơn và thông tin các hàng hóa trong hóa đơn. Nhấn nút “Xuất hóa
đơn” để xem thông tin của hóa đơn.
- Nhấn nút “Làm lại” để xóa các thông tin trên màn hình:
65
- Xây dựng class HoaDon và class HangHoa
- Xử lý class.
22. Xây dựng màn hình đăng nhập theo User Name, Password mặc định.
23. Tạo ứng dụng một máy tính:
24. Viết chương trình thực hiện công việc sau:

- Thiết kế giao diện và đặt tên cho các control trên Frame.
- Viết code cho button Add để đưa thông tin vào Jtable theo thứ tự các cột trong hình.
- Viết code cho button Clear dùng để xóa các thông tin trong các JTextField.
66
25. Thiết kế giao diện như hình bên dưới:
Lop ={“TH Quan Tri”, “TH Ung Dung”, “TH Mang” }
Loại Hoc Tap ={“Trung Binh”, “Kha”, “Gioi”}
Viết code xử lý các nút sau:

+ Them: Thêm các thông tin vào Jlist (Chú ý: Mức học bổng để trống sẽ mặc định là 0. SV
có học bổng khi chọn loại học tập là Gioi)
+ Tong So SV: Tổng số sinh viên trong Jlist
+ Tong So Tien HB: Tổng số tiền Học Bổng
+ HB Lop Quan Tri (btnHBQT): Tổng số tiền học bổng của lớp TH QuanTri
+ Xoa: Xóa một sinh viên trong Jlist
+ Xoa Het: Xóa hết các sinh viên trong Jlist (Chú ý: Khi đã xóa, xóa hết 1 đối tượng nào ra
khỏi JList thì các nút lệnh: Tong So SV, Tong So Tien HB, HB Lop Quan Tri phải cho giá
trị chính xác sau khi loại bỏ)
67
26. Thiết kế giao diện như hình bên dưới:
Yêu cầu: + Nhập vào một số > 0 (Ví dụ N =6).
+ Khi click nút Add tạo 6 số ngẫu nhiên đưa vào JList bên phải.
Viết code xử lý các nút sau:

+ Add: Nhập thông tin vào JList.
+ Clear: Xoá trắng JTextFiled và JList đưa focus vào JTextField
+ Sum NT: Hiển thị tổng số Nguyên Tố vừa tạo ngẫu nhiên
+ Sum not NT: Tổng số các số không phải là số nguyên tố
+ Chon So Xoa: Chọn số tùy ý trên JList để khỏi JList
+ Xoa So NT>20: Xóa tất cả các số nguyên tố ra khỏi Jlist
- Thiết kế giao diện và đặt tên cho các control trên Frame
- Button Nhập A hoặc Nhập B dùng để đưa thông tin vào txtHienthi.
- Button A-> B, B -> A dùng để chuyển số tiền từ khách hàng A sang B hoặc ngược lại.

Phần 1: Hướng đối tượng
• Xây dựng class nhanvien gồm các thông tin sau: HoTen, QueQuan, Lương
68
• Phương thức: tính Lương
• Cty có 2 phòng ban là NV_VP và NV_SX
- NV_VP : tính lương theo ngày công (Lương =(Số ngày công/22)*700000)
- NV_SX: tính luơng theo số sản phẩm (Lương =Số sản phẩm*20000)
Phần 2: Ứng dụng phần 1 trên giao diện sau
Yêu cầu:
- Thiết kế giao diện
- Quy trình tính lương cho nhân viên:
chọn loại nhân viên, nhập thông tin
(họ tên, địa chỉ, số ngày công hoặc số
sản phảm tùy theo loại nhân viên),
nhấn nút Thêm, tất cả thông tin vừa
nhập được đưa vào List bên cạnh,
công việc cứ tiếp tục cho những nhân
viên còn lại. Nếu nhấn nút Xóa bảng
lương, danh sách lương nhân viên sẽ
bị xóa.
69
BÀI TẬP TỔNG HỢP 1
Câu 1 :
− Giả sử SINHVIEN ngành công nghệ thông tin là một đối tượng tổng quát gồm các
thuộc tính: mã sinh viên, họ tên, các môn đăng ký. Trong đó có một phương thức tính
tiền học phí cho các môn học thuộc chuyên ngành hẹp.
− Các chuyên ngành hẹp như:
+ Tin học ứng dụng (THUD): (tổng số tín chỉ)*(học phí 1 tín chỉ)
+ Tin học quản lý (THQL): (tổng số tín chỉ + số môn học đăng ký) *(học phí 1 tín chỉ)
+ Học phí 1 tín chỉ đối với sinh viên THUD là 95000, THQL là 105000
Viết mã nguồn cài đặt đối tượng SINHVIEN và các lớp đối tượng cụ thể.
Câu 2 :
a) Thiết kế giao diện như hình trên

b) Sau khi nhập các thông tin: Mã sv, Họ tên, chọn chuyên ngành hẹp , chọn các môn học,
nhấn vào nút Đưa thông tin vào Table, các thông tin được đưa vào Table như hình trên.
Yêu cầu:
• Viết lệnh xử lý cho nút Đưa thông tin vào Table
− Mã SV, Họ tên, Các môn hoc lập trình (phải chọn ít nhất 1 môn), thông báo cho
người dùng nếu không điền đầy đủ thông tin.
− Sử dụng đối tượng SINHVIEN để chứa thông tin của sinh viên và tính học phí
trước khi đưa vào Table.
• Viết lệnh xử lý cho nút Thoát
70
Câu 1 :
− Giả sử KHACHHANG gửi tiền ngân hàng là 1 đối tượng gồm các thuộc tính: Mã
khách hàng, họ tên, loại tiền gửi, số tiền gửi. Có 3 phương thức tính tiền lãi theo 3
loại kỳ hạn.
− Có 2 loại khách hàng là VNĐ, USD, cách tính tiền lãi theo từng loại tiền gửi như sau:
Loại kỳ hạn: VNĐ USD
+ Kỳ hạn 3 tháng: (số tiền gửi)* 2% (số tiền gửi)* 1%
Viết mã nguồn cài đặt đối tượng KHACHHANG và các lớp đối tượng cụ thể.
Câu 2 :
a) Thiết kế giao diện như hình trên, trong đó Loại tiền gửi gồm: VNĐ, USD
b) Sau khi nhập các thông tin: mã khách hàng, họ tên, chọn loại tiền gửi , chọn kỳ hạn,
nhấn vào nút Lãi suất, các thông tin được đưa vào Table như hình trên.
Yêu cầu:
• Viết lệnh xử lý cho nút Lãi suất
− Mã khách hàng, họ tên, số tiền gửi phải thông báo nếu không nhập đầy đủ.
− Sử dụng đối tượng KHACHHANG để chứa thông tin của khách hàng và tính lãi
suất trước khi đưa vào Table.
− Chỉ tính tiền lãi cho kỳ hạn mà khách hàng đã chọn.
• Viết lệnh xử lý cho nút Thoát
71
Câu 1 :
− Giả sử NHANVIEN công ty ABC là một đối tượng tổng quát gồm các thuộc tính:
Mã nhân viên, họ tên, hệ số lương. Mỗi nhân viên có một phương thức tính lương
như sau:
+ Hợp đồng: (Lương CB) - (số ngày nghỉ)*80
+ Biên chế: (Lương CB) + (phụ cấp)
+ Thử việc: (Số ngày làm viêc) * 50
Trong đó: Lương CB = (hệ số lương) * 830
Viết mã nguồn cài đặt đối tượng NHANVIEN và các lớp đối tượng cụ thể.
Câu 2 :
a) Thiết kế giao diện như hình
bên, trong đó Combo Box Loại
NV (loại nhân viên) gồm: Hợp
đồng, Biên chế, Thử việc
b) Sau khi nhập các thông tin: mã
nhân viên, họ tên, chọn loại nhân
viên (trường hợp loại nhân viên
Thử việc thì phần RadioButton
mờ đi để không cho phép chọn) ,
chọn hệ số lương (có thể nhập
bằng cách chọn  Nhập hệ số
lương), Số ngày nghỉ / Phụ cấp /
Số ngày làm việc (tùy vào Loại
NV đã chọn), nhấn vào nút
Lương, các thông tin được đưa
vào Table như hình bên.
Yêu cầu:
Viết lệnh xử lý cho nút Lương
− Dựa vào các thông tin trong Table (cột Ghi chú chứa thông tin: Số ngày nghỉ hoặc
Phụ cấp hoặc Số ngày làm việc, tùy thuộc vào loại nhân viên đã chọn) , nếu nhập
thông tin không đầy đủ thì thông báo.
− Sử dụng đối tượng NHANVIEN để chứa thông tin của nhân viên và tính lương
trước khi đưa vào Table.
− Sinh viên xử lý thêm các thao tác cần thiết để hạn chế người dùng nhập liệu sai.
72
Câu 1 :
− Giả sử XE là một đối tượng tổng quát có phương thức tính tiền vận chuyển, có thuộc
tính số xe. Công ty có 3 loại xe: Taxi, Tải, Khách với cách tính tiền vân chuyển của
xe như sau:
+ Taxi: tính tiền km (Tiền vận chuyển = sokm * 11000)
+ Tải: tính tiền theo tải trọng (Tiền vận chuyển = tải trọng * số km *20000)
+ Khách: tính tiền theo số hành khách và tùy thuộc vào loại ghế
▪ Ghế ngồi: (Tiền vận chuyển = số khách *4000 * số km)
▪ Ghế nằm: (Tiền vận chuyển = số khách *8000 * số km)
Viết mã nguồn cài đặt đối tượng XE và các lớp đối tượng cụ thể.
Câu 2 :
a) Thiết kế giao diện như hình bên,
trong đó Combo Box Loại xe gồm:
Taxi, Tải, Khách
b) Sau khi nhập thông tin: Số xe, các
thông tin còn lại (Tải trọng, Số km,
Số khách tùy thuộc vào loại xe),
nhấn vào nút Tiền vận chuyển, các
thông tin lần lượt đưa vào Table như
hình bên.
Yêu cầu:
Viết lệnh xử lý cho nút Tiền vận
chuyển
− Sử dụng đối tượng XE để
chứa thông tin của đối tượng
xe và tính tiền vận chuyển.
Mỗi loại xe có các thuộc tính khác nhau, một số thuộc tính không có thì để trống khi
đưa vào Table.
− Khi chọn Loai xe thì chỉ cho phép các TextField thông tin của đối tượng đó sáng lên
để người dùng nhập vào, còn các TextField thông tin còn lại mờ đi.
− Sinh viên xử lý thêm các thao tác cần thiết để hạn chế người dùng nhập liệu sai.
Viết lệnh xử lý cho nút Xóa danh sách dùng để xóa tất cả thông tin trong Table
73
Câu 1 :
− Giả sử SANPHAM là một đối tượng tổng quát gồm có các thuộc tính: mã sản phẩm,
tên sản phẩm, đơn giá, quà tặng (nếu có). Công ty có 4 loại mặt hàng đang khuyến
mãi: Điện máy khuyến mãi 10%, Gia dụng khuyến mãi 20%, Điện thoại và Máy tính
khuyến mãi 30%.
− Phương thức tính tiền phải trả cho từng loại mặt hàng theo công thức:
Tiền phải trả = (đơn giá ) - (phần trăm khuyến mãi)*(đơn giá)
Viết mã nguồn cài đặt đối tượng SANPHAM và các lớp đối tượng cụ thể.
Câu 2 :
a) Thiết kế giao diện như hình bên, trong
đó Combo Box Loại sản phẩm gồm: Điện
máy, Gia dụng, Điện thoại, Máy tính.
RadioButton quà tặng sẽ mờ đi khi chưa
chọn CheckBox Kiểm tra quà tặng.
b) Sau khi nhập thông tin: Mã sp, Tên sp,
Đơn giá, chọn  Kiểm tra quà tặng (để
biết có được chọn quà tặng hay không)
nhấn vào nút Tiền trả, các thông tin lần
lượt đưa vào Table như hình bên.
Yêu cầu:
Viết lệnh xử lý cho nút Tiền trả
− Sử dụng đối tượng SANPHAM để
chứa thông tin của đối tượng và tính
tiền trả. Kiểm tra đầy đủ thông tin
trước khi đưa vào Table
− Khi chọn  Kiểm tra quà tặng (nếu
Đơn giá > 500000 thì các checkbox
quà tặng sáng lên để người dùng chọn,
ngược lại thông báo để người dùng
biết không được quà tặng).
− Sinh viên có thể xử lý thêm các thao tác cần thiết để hạn chế người dùng nhập liệu
sai.
Viết lệnh xử lý cho nút Xóa danh sách dùng để xóa tất cả thông tin trong Table
74
Câu 1:
− Giả sử TIEN là một đối tượng tổng quát có thuộc tính: số tiền cần đổi và phương
thức đổi tiền. Mỗi loại tiền có tỉ giá và đơn vị khác nhau, giả sử có 8 đối tượng tiền
các nước được kế thừa từ đối tượng TIEN, với phương thức đổi tiền theo như sau:
+ VIETNAM: (Số tiền cần đổi)*21000, đơn vị "vnđ"
+ LAOS: (Số tiền cần đổi)*316, đơn vị "kip"
+ CAMBODIA: (Số tiền cần đổi)* 1385, đơn vị "riel"
+ THAILAND: (Số tiền cần đổi)* 59060, đơn vị "baht"
+ SINGAPORE: (Số tiền cần đổi)* 13000, đơn vị "đô la sing"
+ MALAYSIA: (Số tiền cần đổi)* 82000, đơn vị "ringgit"
+ INDONESIA: (Số tiền cần đổi)* 43040, đơn vị "rupiah"
+ PHILIPPINES: (Số tiền cần đổi)* 22970, đơn vị "peso"
Viết mã nguồn cài đặt đối tượng TIEN và các lớp đối tượng cụ thể.
Câu 2 :
a) Thiết kế giao diện như
hình bên.
b) Sau khi nhập số tiền cần
đổi, chọn các checkBox
Loại tiền tệ cần đổi, thì
thông tin đổi tiền (của
những checkBox được
chọn) được đưa vào Table
như hình. Nếu chưa nhập
số tiền cần đổi thì không
chọn được các checkBox
Loại tiền cần đổi. Nút Xóa
danh sách dùng để xóa dữ
liệu trong Table và bỏ chọn
tất cả các checkBox Loại tiền cần đổi.
Yêu cầu: Viết lệnh xử lý cho các thao tác trên.
75
Câu 1: Viết chương trình đổi số nguyên hệ thập phân ra thập lục phân và ngược
lại.(Dùng giao diên để minh họa chương trình)
Câu 2: Viết chương trình ĐĂNG KÝ MÔN HỌC
Yêu cầu:
- Khi load Frame, thì đã có thông tin sinh viên như sau:
Mã SV Họ tên Chuyên Số tín tích Các học phần đã tích
ngành lũy lũy
001 Lê Văn Nam KHMT 2 IT09
002 Trần Thành HTTT 6 IT09, IT11, IT14
003 Lê Minh HTTT 2 IT09
004 Hồ Ngọc KHMT 0
005 Bá Chi HTTT 0
006 Lâm Hùng KHMT 4 IT09, IT11
007 Lê Tứ HTTT 8 IT09, IT14, IT10, IT12
- Tất cả các thông tin trên Frame mờ đi, chỉ được phép nhập Mã SV
- Nhập mã số sinh viên, nhấn Enter, thông tin sv sẽ hiện lên gồm: họ tên sv,
chuyên ngành, số tin chỉ đã tích lũy, bảng liệt kê các môn học (giả sử mỗi môn học
là 2 tín chỉ)
- Chọn nút Đăng ký thêm, Danh sách môn học được sáng lên, chỉ những môn đăng
ký đã đăng ký mờ đi, nút Cập nhật sáng lên. SV chọn các môn cần đăng ký thêm,
và click nút cập nhật, các thông tin sv sẽ được cập nhật (vì đây là dữ liệu tạm thời,
nên mỗi lần chạy lại Frame sẽ mất đi)
Câu 3: Hãy đề xuất một class để quản lý các thông tin lưu trữ trong câu 2
76
Tài liệu tham khảo
[1] java.sun.com
[2] Herbert Schil dt. Java 2. A Beginner’s Guide. Second Edition. McGraw-Hill -
2003.
[3] Dr. Harvey M. Dei tel - Paul J.Deitel . Java How to Program, 4thEd (Dei tel ).
Prenti ce Hall - 2002
[4] Simon Roberts – Philip Heller – Michael Ernest.Complete Java 2 Certification –
study guide. BPB Publications – 2000.
[5] Cay S.Horstmann – Gary Cornell. Core Java Volum 1 - Fundamentals.The Sun
Microsystems press. 1997
[6] Cay S.Horstmann – Gary Cornell . Core Java Volum 2 – Advanced Features.The
Sun Microsystems press. 1997
77

TLGD LapTrinhJava 2021

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

TLGD LapTrinhJava 2021

Uploaded by

Copyright:

Available Formats

TẬP ĐOÀN DỆT MAY VIỆT NAM

TRƯỜNG CAO ĐẲNG CÔNG NGHỆ TPHCM

…………, năm 2021

6.2. Vòng lặp while

• Hàm khởi tạo có đối số:

abstract class NHANVIEN

Exception Đây là lớp con trực tiếp của lớp Throwable, nó

2. Java Gui Api

private void Checkbox_click(javax.swing.event.ChangeEvent evt) {

Bài 3 – Biến trong Java

2. Xây dựng màn hình tính tổng 2 số nguyên

7. Xây dựng màn hình tính giai thừa một số

9. Xây dựng màn hình tìm kiếm chuỗi

private BufferedImage getScaledImages(BufferedImage in, int WIDTH, int HEIGHT)

private PhanSo tinhHieu(PhanSo phanSo1, PhanSo phanSo2){

private PhanSo tinhThuong(PhanSo phanSo1, PhanSo phanSo2){

23. Tạo ứng dụng một máy tính:

24. Viết chương trình thực hiện công việc sau:

Viết code xử lý các nút sau:

Viết code xử lý các nút sau:

28. Viết chương trình thực hiện công việc sau:

a) Thiết kế giao diện như hình trên

You might also like