Đồ án tìm hiểu java và một số bài tập ứng dụng

Trang i
SỞ GIÁO DỤC VÀ ĐÀO TẠO ĐẮK LẮK
TRƯỜNG TRUNG CẤP TÂY NGUYÊN

JAVA VÀ ỨNG DỤNG
ĐỒ ÁN TÌM HIỂU ỨNG DỤNG NHẬP
THÔNG TIN NHÂN VIÊN
Học sinh thực hiện: Trịnh Văn Long
Giáo viên: TRẦN THỊ LAN
Lớp: CNTT7A
Năm học: 2014– 2015

Trang ii
NHẬN XÉT CỦA GIÁO VIÊN
  
...................................................................................................................................................
...................................................................................................................................................
...................................................................................................................................................
...................................................................................................................................................
...................................................................................................................................................
...................................................................................................................................................
...................................................................................................................................................
...................................................................................................................................................
...................................................................................................................................................
...................................................................................................................................................
...................................................................................................................................................
...................................................................................................................................................
...................................................................................................................................................
...................................................................................................................................................
...................................................................................................................................................
...................................................................................................................................................
Đăk Lăk, ngày tháng năm 2015
Giáo viên
Trần Thị Lan

Trang iii
LỜI CẢM ƠN
Em xin chân thành cảm ơn sự giúp đỡ nhiệt tình của cô giáo Trần Thị Lan, người
đã cung cấp cho em những kiến thức cơ bản về lập trình java cũng như định hướng cho em
những phương pháp lập trình và cung cấp tài liệu tham khảo, để em có thể hoàn thành tốt
đồ án này.
Em cũng xin gửi lời cảm ơn tới các thầy cô giáo, giảng viên trong Khoa Công Nghệ
Thông Tin – Trường Trung Cấp Tây Nguyên và các thầy cô đã giảng dạy em trong suốt
quá trình học tập tại trường.
Em cũng xin gửi lời cảm ơn đến gia đình, bạn bè luôn động viên giúp đỡ em trong
suốt thời gian học tập và nghiên cứu, đóng góp những kinh nghiệm quý báu trong thời gian
thực hiện đề tài này.
Kính chúc thầy cô mạnh khỏe, công tác tốt, tiếp tục giảng dạy và đào tạo thế hệ trẻ
thành công.
Buôn Ma Thuột, ngày…tháng…năm 2015
Trịnh Văn Long014
G
V
H
D
:
N
g
u
y
ễ
n

Trang iv
MỤC LỤC
CHƯƠNG 1: GIỚI THIỆU NGÔN NGỮ LẬP TRÌNH JAVA .......................................1
I. Đặc điểm ngôn ngữ lập trình Java............................................................................................1
II. Các kiểu ứng dụng trong Java .................................................................................................4
III. Lập trình căn bản với ngôn ngữ lập trình Java ....................................................................5
1. Các kiểu dữ liệu.........................................................................................................................5
2. Các toán tử..................................................................................................................................8
3. Các cấu trúc điều khiển.......................................................................................................... 14
CHƯƠNG 2: LẬP TRÌNH HƯỚNG ĐỐI TƯỢNG VỚI JAVA ………………........19
I. Lớp và đối tượng..................................................................................................................... 19
II. Kế thừa lớp ............................................................................................................................. 20
III. Giao diện (interface) ............................................................................................................ 21
IV. Gói (Package) ....................................................................................................................... 21
CHƯƠNG 3: LẬP TRÌNH GIAO DIỆN VỚI AWT/SWING........................................22
I. Giới thiệu chung về AWT/SWING ...................................................................................... 22
II. Các lớp vật chứa (Container) ............................................................................................... 22
III. Các lớp quản lý quản lý Layout.......................................................................................... 22
IV. Các thành phần giao diện cơ bản ....................................................................................... 23
1. JTextField................................................................................................................................ 23
2. JTextField................................................................................................................................ 24
3. JTextArea ................................................................................................................................ 24
4. JButton ..................................................................................................................................... 25
5. JCheckBox............................................................................................................................... 26

Trang v
6. JRadioButton........................................................................................................................... 26
CHƯƠNG 4: LẬP TRÌNH CƠ SỞ DỮ LIỆU ...................................................................27
I.Giới thiệu JDBC ....................................................................................................................... 27
II.Kiến trúc JDBC....................................................................................................................... 27
III.Kết nối đến CSDL ................................................................................................................. 29
IV.Các thao tác cơ bản trên CSDL ........................................................................................... 29
CHƯƠNG 5: BÀI TẬP MINH HỌA ...................................................................................32
I. Lập trình căn bản..................................................................................................................... 32
Bài 1: ............................................................................................................................................ 32
Bài 2: ............................................................................................................................................ 32
Bài 3: ............................................................................................................................................ 32
Bài 4: ............................................................................................................................................ 33
Bài 5: ............................................................................................................................................ 33
II. Lập trình hướng đối tượng.................................................................................................... 35
1. Xây dựng lớp........................................................................................................................... 35
Bài 1: ............................................................................................................................................ 35
Bài 2: ............................................................................................................................................ 36
Bài 3: ............................................................................................................................................ 36
2. Kế thừa..................................................................................................................................... 41
Bài 1.............................................................................................................................................. 41
Bài2: ............................................................................................................................................. 43
Bài3: ............................................................................................................................................. 46
III. Lập trình giao diện ............................................................................................................... 49

Trang vi
Bài 1: ............................................................................................................................................ 49
Bài 2: ............................................................................................................................................ 50
Bài 3: ............................................................................................................................................ 53
Bài 4: ............................................................................................................................................ 58
Bài 5: ............................................................................................................................................ 63
Bài 6: ............................................................................................................................................ 65
Bài 7: ............................................................................................................................................ 68
Bài 8: ............................................................................................................................................ 74
Bài 9: ............................................................................................................................................ 77
TÀI LIỆU THAM KHẢO....................................................................................................... 88

Trang vii
DANH MỤC CÁC BẢNG, SƠ ĐỒ, HÌNH
HÌNH 1.1 Mô hình compiler của java 3 ................................................................................ 24
HÌNH 4.1 Kiến trúc của JDBC................................................................................................ 28
HÌNH 4.2 Các lớp và các giao diện cơ bản trong JDBC API.............................................. 28
BẢNG 1.1 Dữ liệu kiểu nguyên thuỷ..................................................................................... 7
BẢNG 1.2 Dữ liệu kiểu tham chiếu ...................................................................................... 7
BẢNG 1.3 Các toán tử số học ................................................................................................ 9
BẢNG 1.4 Các toán tử Bit...................................................................................................... 10
BẢNG 1.5 Các toán tử quan hệ ............................................................................................. 11
BẢNG 1.6 Các toán tử logic................................................................................................... 12
BẢNG 1.7 Trật tự ưu tiên ....................................................................................................... 14

CHƯƠNG 1: GIỚI THIỆU NGÔN NGỮ LẬP TRÌNH
JAVA
I. Đặc điểm ngôn ngữ lập trình Java
1.Lịch sử ra đời và phát triển của ngôn ngữ Java
Java là một ngôn ngữ lập trình được Sun Microsystems giới thiệu vào tháng 6 năm
1995. Từ đó, nó đã trở thành một công cụ lập trình của các lập trình viên chuyên nghiệp.
Java được xây dựng trên nền tảng của C và C++. Do vậy nó sử dụng các cú pháp của C và
các đặc trưng hướng đối tượng của C++.
Vào năm 1991, một nhóm các kỹ sư của Sun Microsystems có ý định thiết kế một ngôn
ngữ lập trình để điều khiển các thiết bị điện tử như Tivi, máy giặt, lò nướng, … Mặc dù C
và C++ có khả năng làm việc này nhưng trình biên dịch lại phụ thuộc vào từng loại CPU.
Trình biên dịch thường phải tốn nhiều thời gian để xây dựng nên rất đắt. Vì vậy để mỗi
loại CPU có một trình biên dịch riêng là rất tốn kém. Do đó nhu cầu thực tế đòi hỏi một
ngôn ngữ chạy nhanh, gọn, hiệu quả và độc lập thiết bị tức là có thể chạy trên nhiều loại
CPU khác nhau, dưới các môi trường khác nhau. “Oak” đã ra đời và vào năm 1995 được
đổi tên thành Java. Mặc dù mục tiêu ban đầu không phải cho Internet nhưng do đặc trưng
không phụ thuộc thiết bị nên Java đã trở thành ngôn ngữ lập trình cho Internet.
2.Java là gì ?
Java là ngôn ngữ lập trình hướng đối tượng, do vậy không thể dùng Java để viết một
chương trình hướng chức năng. Java có thể giải quyết hầu hết các công việc mà các ngôn
ngữ khác có thể làm được.
Java là ngôn ngữ vừa biên dịch vừa thông dịch. Đầu tiên mã nguồn được biên dịch
bằng công cụ JAVAC để chuyển thành dạng ByteCode. Sau đó được thực thi trên từng
loại máy cụ thể nhờ chương trình thông dịch.
3. Các đặc trưng của Java
 Đơn giản

 Hướng đối tượng
 Độc lập phần cứng và hệ điều hành
 Mạnh
 Bảo mật
 Phân tán
 Đa luồng
 Động
3.1 Đơn giản
Những người thiết kế mong muốn phát triển một ngôn ngữ dễ học và quen thuộc với
đa số người lập trình. Do vậy Java được loại bỏ các đặc trưng phức tạp của C và C++ như
thao tác con trỏ, thao tác nạp đè (overload),… 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.
3.2 Hướng đối tượng
Java được thiết kế xoay quanh mô hình hướng đối tượng. Vì vậy trong Java, tiêu điểm
là dữ liệu và các phương pháp thao tác lên dữ liệu đó. Dữ liệu và các phương pháp mô tả
trạng thái và cách ứng xử của một đối tượng trong Java.
3.3 Độ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. Chúng được thể hiện ở mức mã nguồn và mức nhị phân.
Ở mức mã nguồn, người lập trình cần mô tả kiểu cho mỗi biến. Kiểu dữ liệu trong
Java nhất quán cho tất cả các hệ điều hành và phần cứng khác nhau. Java có riêng một
thư viện các lớp cơ sở. Vì vậy chương trình Java được viết trên một máy có thể dịch và
chạy trơn tru trên các loại máy khác mà không cần viết lại.

HÌNH 1.1 Mô hình compiler của java
Ở mức nhị phân, một chương trình đã biên dịch có thể chạy trên nền khác mà không
cần dịch lại mã nguồn. Tuy vậy cần có phần mềm máy ảo Java (sẽ đề cập đến ở phần sau)
hoạt động như một trình thông dịch tại máy thực thi.
3.4 Mạnh mẽ
Java yêu cầu chặt chẽ về kiểu dữ liệu và phải mô tả rõ ràng khi viết chương trình.
Chúng sẽ 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ỏ các
kiểu dữ liệu dễ gây ra lỗi.
3.5 Bảo mật
Java cung cấp một số lớp để kiểm tra bảo mật.
Ở lớp đầu tiên, dữ liệu và các phương pháp được đóng gói bên trong lớp. Chúng chỉ
được truy xuất thông qua các giao diện mà lớp cung cấp. Java không hỗ trợ con trỏ vì vậy
không cho phép truy xuất bộ nhớ trực tiếp. Nó cũng ngăn chặn không cho truy xuất thông
tin bên ngoài của mảng bằng kỹ thuật tràn và cũng cung cấp kỹ thuật dọn rác trong bộ nhớ.
Các đặc trưng này tạo cho Java an toàn và có khả năng cơ động cao.
Trong lớp thứ hai, trình biên dịch kiểm soát để đảm bảo mã an toàn. Lớp thứ ba được
đảm bảo bởi trình thông dịch. Chúng kiểm tra xem bytecode có đảm bảo các qui tắc an toàn
trước khi thực thi. Lớp thứ tư kiểm soát việc nạp các lớp lên bộ nhớ để giám sát việc vi
phạm giới hạn truy xuất trước khi nạp vào hệ thống.
compiler
compiler
compiler

3.6 Phân tán
Java có thể dùng để xây dựng các ứng dụng có thể làm việc trên nhiều phần cứng, hệ
điều hành và giao diện đồ họa. Java được thiết kế cho các ứng dụng chạy trên mạng. Vì vậy
chúng được sử dụng rộng rãi trên Internet, nơi sử dụng nhiều nền tảng khác nhau.
3.7 Đa luồng
Chương trình Java sử dụng kỹ thuật đa tiến trình (Multithread) để thực thi các công
việc đồng thời. Chúng cũng cung cấp giải pháp đồng bộ giữa các tiến trình. Đặc tính hỗ trợ
đa tiến trình này cho phép xây dựng các ứng dụng trên mạng chạy uyển chuyển.
3.8 Động
Java được thiết kế như một ngôn ngữ động để đáp ứng cho những môi trường mở. Các
chương trình Java bổ xung các thông tin cho các đối tượng tại thời gian thực thi. Điều này
cho phép khả năng liên kết động các mã.
II. Các kiểu ứng dụng trong Java
1. Console:
Ứng dụng Console là ứng dụng nhập xuất ở chế độ văn bản tương tự như màn hình
Console của hệ điều hành MS-DOS. Lọai chương trình ứng dụng này thích hợp với những
ai bước đầu làm quen với ngôn ngữ lập trình java. Các ứng dụng kiểu Console thường được
dùng để minh họa các ví dụ cơ bản liên quan đến cú pháp ngôn ngữ, các thuật toán, và các
chương trình ứng dụng không cần thiết đến giao diện người dùng đồ họa.
2. Applet:
Java Applet là loại ứng dụng có thể nhúng và chạy trong trang web của một trình duyệt
web. Từ khi internet mới ra đời, Java Applet cung cấp một khả năng lập trình mạnh mẽ cho
các trang web. Nhưng gần đây khi các chương trình duyệt web đã phát triển với khả năng
lập trình bằng VB Script, Java Script, HTML, DHTML, XML, … cùng với sự canh tranh
khốc liệt của Microsoft và Sun đã làm cho Java Applet lu mờ. Và cho đến bây giờ gần như
các lập trình viên đều không còn “mặn mà” với Java Applet nữa. (trình duyệt IE đi kèm

trong phiên bản Windows 2000 đã không còn mặc nhiên hỗ trợ thực thi một ứng dụng Java
Applet)
3. Desktop bằng AWT và JFC:
Việc phát triển các chương trình ứng dụng có giao diện người dùng đồ họa trực quan
giống như những chương trình được viết dùng ngôn ngữ lập trình VC++ hay Visual Basic
đã được java giải quyết bằng thư viện AWT và JFC. JFC là thư viện rất phong phú và hỗ
trợ mạnh mẽ hơn nhiều so với AWT. JFC giúp cho người lập trình có thể tạo ra một giao
diện trực quan của bất kỳ ứng dụng nào.
4. Ứng dụng web:
Java hỗ trợ mạnh mẽ đối với việc phát triển các ứng dụng Web thông qua công nghệ
J2EE (Java 2 Enterprise Edition). Công nghệ J2EE hoàn toàn có thể tạo ra các ứng dụng
Web một cách hiệu quả không thua kém công nghệ .NET mà Microsft đang quảng cáo.
Hiện nay có rất nhiều trang Web nổi tiếng ở Việt Nam cũng như khắp nơi trênthế giới được
xây dựng và phát triển dựa trên nền công nghệ Java. Số ứng dụng Web được xây dựng dùng
công nghệ Java chắc chắn không ai có thể biết được con số chính xác là bao nhiêu, nhưng
chúng tôi đưa ra đây vài ví dụ để thấy rằng công nghệ Java của Sun là một “đối thủ đáng
gờm” của Microsoft.
5. Ứng dụng nhúng Java:
Sun đưa ra công nghệ J2ME (The Java 2 Platform, Micro Edition J2ME) hỗ trợ phát
triển các chương trình, phần mềm nhúng. J2ME cung cấp một môi trường cho những
chương trình ứng dụng có thể chạy được trên các thiết bị cá nhân như: điện thọai di động,
máy tính bỏ túi PDA hay Palm, cũng như các thiết bị nhúng khác.
III. Lập trình căn bản với ngôn ngữ lập trình Java
1. Các kiểu dữ liệu
Java cung cấp một vài kiểu dữ liệu. Chúng được hỗ trợ trên tất cả các nền.
Trong Java kiểu dữ liệu được chia thành hai loại:

 Các kiểu dữ liệu nguyên thủy (primitive)
 Các kiểu dữ liệu tham chiếu (reference)
1.1Dữ liệu kiểu nguyên thuỷ
Java cung cấp tám kiểu dữ liệu nguyên thuỷ
Kiểu
dữ liệu
Độ dài
theo số
bit
Phạm vi Mô tả
byte 8 -128 đến 127 Số liệu kiểu byte là một loại điển
hình dùng để lưu trữ một giá tri
bằng một byte. Chúng được sử
dụng rộng rãi khi xử lý một file
văn bản
Char 16 ‘uoooo’ to ’uffff ’ Kiểu Char sử dụng để lưu tên
hoặc các dữ liệu ký tự .Ví dụ tên
ngườI lao động
Boolean 1 “True” hoặc “False” Dữ liệu boolean dùng để lưu các
giá trị “Đúng” hoặc “sai” Ví dụ :
Người lao đông có đáp ứng được
yêu cầu của công ty hay không ?
short 16 -32768 đến 32767 Kiểu short dùng để lưu các số có
giá trị nhỏ dưới 32767.Ví dụ số
lượng người lao động.
Int 32 -2,147,483,648 đến
+2,147,483,648
Kiểu int dùng để lưu một số có
giá trị lớn đến 2,147,483,648.Ví
dụ tổng lương mà công ty phải
trả cho nhân viên.

Long 64 -9,223,372,036’854,775,808
đến
+9,223,372,036’854,775,80
8
Kiểu long được sử dụng để lưu
một số cố giá trị rất lớn đến
9,223,372,036’854,775,808 .Ví
dụ dân số của một nước
Float 32 -3.40292347E+38 đến
+3.40292347E+38
Kiểu float dùng để lưu các số
thập phân đến 3.40292347E+38
Ví dụ : giá thành sản phẩm
double 64 -
1,79769313486231570E+30
8 đến
+1,79769313486231570E+
308
Kiểu double dùng để lưu các số
thập phân có giá trị lớn đến
1,79769313486231570E+308Ví
dụ giá trị tín dụng của ngân hàng
nhà nước.
BẢNG 1.1 Dữ liệu kiểu nguyên thuỷ
1.2Kiểu dữ liệu tham chiếu (reference)
Trong Java có 3 kiểu dữ liệu tham chiếu
Kiểu dữ liệu Mô tả
Mảng (Array) Tập hợp các dữ liệu cùng loại.Ví dụ : tên sinh viên
Lớp (Class) Tập hợp các biến và các phương thức.Ví dụ : lớp “Sinhviên”
chứa toàn bộ các chi tiết của một sinh viên và các phương
thức thực thi trên các chi tiết đó.
Giao diện (Inter-
face)
Là một lớp trừu tượng được tạo ra đểbổ sung cho các kế thừa
đa lớp trong Java.
BẢNG 1.2 Dữ liệu kiểu tham chiếu

2. Các toán tử
2.1 Các toán tử
Java cung cấp nhiều dạng toán tử.Chúng bao gồm:
 Toán tử số học
 Toán tử dạng bit
 Toán tử quan hệ
 Toán tử luận lý
 Toán tử điều kiện
 Toán tử gán
2.1.1 Các toán tử số học
Các toán hạng của các toán tử số học phải ở dạng số. Các toán hạng kiểu Boolean
không sử dụng được, song các toán hạng ký tự cho phép sử dụng loại toán tử này. Một vài
kiểu toán tử được liệt kê trong bảng dưới đây.
Toán tử Mô tả
+ Cộng.Trả về giá trị tổng hai toán hạng
Ví dụ 5+3 trả về kết quả là 8
- Trừ
Trả về giá trị khác nhau giữa hai toán hạng hoặc giá trị phủ định của
toán hạng. Ví dụ 5-3 kết quả là 2 và –10 trả về giá trị âm của 10
* Nhân
Trả về giá trị là tích hai toán hạng. Ví dụ 5*3 kết quả là 15
/ Chia
Trả về giá trị là thương của phép chia

Ví dụ 6/3 kết quả là 2
% Phép lấy modulo
Giá trị trả về là phần dư của toán tử chia
Ví dụ 10%3 giá trị trả về là 1
++ Tăng dần
Tăng giá trị của biến lên 1. Ví dụ a++ tương đương với a= a+1
-- Giảm dần
Giảm giá trị của biến 1 đơn vị. Ví dụ a-- tương đương với a=a-1
+= Cộng và gán giá trị
Cộng các giá trị của toán hạng bên trái vào toán hạng bên phải và gán
giá trị trả về vào toán hạng bên trái.
Ví dụ c+=a tương đương c=c+a
-= Trừ và gán giá trị
Trừ các giá trị của toán hạng bên trái vào toán toán hạng bên phải và
gán giá trị trả về vào toán hạng bên trái.
Ví dụ c-= a tương đương vớI c=c-a
*= Nhân và gán
Nhân các giá trị của toánhạng bên trái với toán toán hạng bên phải và
gán giá trị trả về vào toán hạng bên trái.
Ví dụ c *= a tương đương với c=c*a
/= Chia và gán
Chia giá trị của toán hạng bên trái cho toán toán hạng bên phải và gán
giá trị trả về vào toán hạng bên trái.
Ví dụ c /= a tương đương với c=c/a

%= Lấy số dư và gán
Chia giá trị của toán hạng bên trái cho toán toán hạng bên phải và gán
giá trị số dư vào toán hạng bên trái.
Ví dụ c%=a tương đương với c=c%a
BẢNG 1.3 Các toán tử số học
2.1.2 Toán tử Bit
Các toán tử dang Bit cho phép tatạo những Bit riêng biệt trong cáckiểu dữ liệunguyên
thuỷ. Toán tử Bit dựa trên cơ sở đại số Boolean. Nó thực hiện phép tính trên hai đối số là
các bit để tạo ra một kết qủa mới. Một vài dạng toán tử kiểu này được liệt kê dưới đây
Toán tử Mô tả
~ Phủ định (NOT)
Trả về giá trị phủ định của một số. Ví dụ a=10 thì ~a=-10
& Toán tử AND
Trả về giá trị là 1 nếu các toán hạng là 1 và 0 trong các trường hợp
khác. Ví dụ nếu a=1và b=0 thì a&b trả về giá trị 0
I Toán tử OR
Trả về giá trị là 1 nếu một trong các toán hạng là 1 và 0 trong các
trường hợp khác. Ví dụ nếu a=1và b=0 thì aIb trả về giá trị 1
^ Exclusive OR
Trả về giá trị là 1 nếu chỉ một trong các toán hạng là 1 và trả về 0
trong các trường hợp khác. Ví dụ nếu a=1và b=1 thì a^b trả về giá
trị 0
>> Dịch sang phải

Chuyển toàn bộ các bít cuả một số sang phải một vị trí, giữ nguyên
dấu của số âm. Toán hạng bên trái là số bị dịch còn số bên phải chỉ
số vị trí mà các bít cần dịch.
Ví dụ x=37 tức là 00011111 vậy x>>2 sẽ là 00000111.
<< Dịch sang trái
Chuyển toàn bộ các bít cuả một số sang trái một vị trí, giữ nguyên
dấu cuả số âm. Toán hạng bên trái là số bị dịch còn số bên phải chỉ
số vị trí mà các bít cần dịch.
BẢNG 1.4 Các toán tử Bit
2.1.3 Các toán tử quan hệ
Các toántử quan hệ kiểm tra mối quan hệ giữa hai toánhạng. Kết quả của một biểu thức
có dùng các toán tử quan hệ là những giá trị Boolean (logic “đúng” hoặc “sai”). Các toán
tử quan hệ được sử dụng trong các cấu trúc điều khiển.
Toán tử Mô tả
= = So sánh bằng
Toán tử này kiểm tra sự tương đương của hai toán hạng
Ví dụ if (a= =b) trả về giá tri “True” nếu giá trị của a và b như nhau
!= So sánh khác
Kiểm tra sự khác nhau của hai toán hạng
Ví dụ if(a!=b) Trả về giá trị “true” nếu a khác b
> Lớn hơn
Kiểm tra giá trị của toán hạng bên phải lớn hơn toán hạng bên trái
hay không

Ví du if(a>b) . Trả về giá trị “true” nếu a lớn hơn b,ngựơc lai (nhỏ
hơn hoặc bằng ), trả về ‘False’
< Nhỏ hơn
Kiểm tra giá trị của toán hạng bên phải có nhỏ hơn toán hạng bên trái
hay không
Ví du if(a<b) . Trả về giá trị “true” nếu a nhỏ hơn b , ngựơc lại (lớn
hơn hoặc bằng trả về ‘False’
>= Lớn hơn hoặc bằng
Kiểm tra giá trị của toán hạng bên phải có lớn hơn hoặc bằng toán
hạng bên trái hay không
Ví du if(a>=b) . Trả về giá trị “true” nếu a lớn hơn hoặc bằng b ,
ngựơc lại (nhỏ hơn trả về ‘False’
<= Nhỏ hơn hoặc bằng
Kiểm tra giá trị của toán hạng bên phải có nhỏ hơn hoặc bằng toán
hạng bên trái hay không
Ví du if(a<=b) . Trả về giá trị “true” nếu a nhỏ hơn hoặc bằng b ,
ngựơc lại (lớn hơn trả về ‘False’
BẢNG 1.5 Các toán tử quan hệ
2.1.4 Các toán tử logic
Các toán tử logic làm việc với các toánhạng Boolean. Một vài toántử kiểu này được chỉ ra
dưới đây
Toán tử Mô tả
& Và (AND)
Trả về một giá trị “Đúng” (True) nếu chỉ khi cả hai toán tử có giá trị
“True”

Ví dụ: if(sciencemarks>90) AND (mathmarks>75) thì gán “Y” cho
biến “được nhận học bổng”
I Hoặc (OR)
Trả về giá trị “True” nếu một giá trị là True hoặc cả hai đều là True
Ví dụ Nếu age_category is ‘Senior_citizen’ OR special_category is
‘handicapped’ thì giảm giá tua lữ hành. Giá cũng sẽ được giảm nếu
cả hai điều kiện đều được thỏa mãn
^ XOR
Trả về giá trị True nếu chỉ một trong các giá trị là True, các trường
hợp còn lại cho giá trị False (sai)
! Toán hạng đơn tử NOT. Chuyển giá trị từ True sang False và ngược
lại.
Ví dụ: Quá trình thực thi các dòng lệnh tiếp tục cho đến khi kết thúc
chương trình.
BẢNG 1.6 Các toán tử logic
2.1.5 Các toán tử điều kiện
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
Cú pháp :
biểu thức 1?biểu thức 2: biểu thức 3;
biểu thức 1
Điều kiện luận lý (Boolean) mà nó trả về giá trị True hoặc False
biểu thức 2
Giá trị trả về nếu biểu thức 1 xác định là True

biểu thức 3
Giá trị trả về nếu biểu thức 1 xác định là False
2.1.6 Toán tử gán
Toán tử gán (=) dùng để gán một giá trị vào một biến. Bạn nên gán nhiều giá trị đến nhiều
biến cùng một lúc.
2.1.7 Thứ tự ưu tiên của các toán tử
Các biểu thức được viết ra nói chung gồm nhiều toán tử. Thứ tự ưu tiên quyết định trật tự
thực hiện các toán tử trên các biểu thức. Bảng dưới đây liệt kê thứ tự thực hiện các toán tử
trong Java
Thứ tự Toán tử
1. Các toán tử đơn như +,-,++,--
2. Các toán tử số học và các toán tử dịch như *,/,+,-,<<,>>
3. Các toán tử quan hệ như >,<,>=,<=,= =,!=
4. Các toán tử logic và Bit như &&,II,&,I,^
5. Các toán tử gán như =,*=,/=,+=,-=
BẢNG 1.7 Trật tự ưu tiên
2.1.8 Thay đổi thứ tự ưu tiên
Để thay đổi thứ tự ưu tiên trên một biểu thức, bạn có thể sử dụng dấu ngoặc đơn ().
Từng phần của biểu thức được giới hạn trong ngoặc đơn được thực hiện trước tiên. Nếu
bạn sử dùng nhiều ngoặc đơn lồng nhau thì toán tử nằm trong ngoặc đơn phía trong sẽ thực
thi trước, sau đó đến các vòng phía ngoài. Nhưng trong phạm vi một ngoặc đơn thì quy tắc
thứ tự ưu tiên vẫn giữ nguyên tác dụng.
3. Các cấu trúc điều khiển
Tất cả các môi trường phát triển ứng dụng đều cung cấp một quy trình ra quyết định
(decision-making) được gọi là điều khiển luồng, nó trực tíếp thực thi các ứng dụng. Điều

khiển luồng cho phép người phát triển phần mềm tạo một ứng dụng dùng để kiểm tra sự
tồn tại của một điều kiện nào đó và ra quyết định phù hợp với điều kiện đó.
Vòng lặp là một cấu trúc chương trình giúp bạn có thể dùng để thực hiện việc lặp lại
các hành động khi thực thi chương trình mà không cần viết lại các đoạn chương trình nhiều
lần.
Điều khiển rẽ nhánh
 Mệnh đề if-else
 Mệnh đề swich-case
Vòng lặp (Loops)
 Vòng lặp while
 Vòng lặp do-while
 Vòng lặp for
3.1Câu lệnh if-else
Câu lệnh if-else kiểm tra kết quả của một điều kiện và thực thi một thao tác phù hợp trên
cơ sở kết quả đó. Dạng của câu lệnh if-elsse rất đơn giản
Cú pháp
If (conditon)
{ action 1 statements; }
else
{ action 2 statements; }
Condition: Biểu thức Boolean như toántử so sánh. Biểu thức này trả về giá trị True
hoặc False
action 1: Các dòng lệnh được thực thi khi giá trị trả về là True

else: Từ khoá xác định các câu lệnh tiếp sau được thực hiện nếu điều kiện trả về giá
trị False
action 2: Các câu lệnh được thực thi nếu điều kiện trả về giá trị False
3.2 Câu lệnh switch-case
Phát biểu switch-case có thể được sử dụng tại câu lệnh if-else. Nó được sử dụng trong
tình huống một biểu thức cho ra nhiều kết quả. Việc sử dụng câu lệnh switch-case cho phép
việc lập trình dễ dàng và đơn giản hơn.
Cú pháp
swich (expression)
{
case ‘value’:action 1 statement;
break;
case ‘value’:action 2 statement;
break;
:
:
case ‘valueN’: actionN statement (s);
}
expession - Biến chứa một giá trị xác định
value1,value 2,….valueN: Các giá trị hằng số phù hợp với giá trị trên biến expres-
sion .
action1,action2…actionN: Các phát biểu được thực thi khi một trường hợp tương
ứng có giá trị True

break: Từ khoá được sử dụng để bỏ qua tất cả các câu lệnh sau đó và giành quyền
điều khiển cho cấu trúc bên ngoài switch
default: Từ khóa tuỳ chọn được sử dụng để chỉ rõ các câu lệnh nào được thực hiện
chỉ khi tất cả các trường hợp nhận giá trị False
default - action: Các câu lệnh được thực hiện chỉ khi tất cả các trường hợp nhận
giá trị False
3.3 Vòng lặp While
Vòng lặp while được sử dụng khi vòng lặp được thực hiện mãi cho đến khi điều kiện
thực thi vẫn là True. Số lượng vòng lặp không đựơc xác định trước song nó sẽ phụ thuộc
vào từng điều kiện.
Cú pháp
while(condition)
{
action statement;
:
:
}
condition: Biểu thức Boolean, nó trả về giá trị True hoặc False. Vòng lặp sẽ tiếp tục
cho đến khi nào giá trị True được trả về.
action statement: Các câu lệnh được thực hiện nếu condition nhận giá trị True
3.4 Vòng lặp do-while:
Gần như giống hệt vòng lặp while, ngoại trừ việc nó kiểm tra biểu thức logic sau khi
thực thi khối lệnh lặp. Với vòng lặp while, chuyện gì sẽ xảy ra nếu biểu thức cho giá trị
false ngay lần đầu tiên kiểm tra? Vòng lặp sẽ không thực hiện dù chỉ một lần. Còn với

vòng lặp do, bạn sẽ được đảm bảo là vòng lặp sẽ thực hiện ít nhất 1 lần. Sự khác biệt này
có thể có ích vào nhiều lúc.
3.5 Vòng lặp for:
Vòng lặp for được sử dụng tương tự như vòng lặp while nhưng bạn có thể kiểm soát
được số lần lặp.Vòng lặp for thường được sử dụng khi cần lặp một khối lệnh mà lập trình
viên biết trước sẽ cần lặp bao nhiêu lần
Cú pháp
for (init-stmt; condition; next-stmt) {
body
}
condition: Biểu thức Boolean, nó trả về giá trị True hoặc False. Vòng lặp sẽ tiếp tục cho
đến khi nào giá trị True được trả về
init-stmt: Con số hay biến khởi tạo cho số lần lặp.
next-stmt: con số hay biến tiếp theo của vòng lặp sau khi thân vòng lặp đã được thực hiện

CHƯƠNG 2: LẬP TRÌNH HƯỚNG ĐỐI TƯỢNG VỚI
JAVA
I. Lớp và đối tượng
Khái niệm
Chúng ta có thể xem lớp như một khuôn mẫu (template) của đối tượng (Object). Trong
đó bao gồm dữ liệu của đối tượng (fields hay properties) và các phương thức(methods) tác
động lên thành phần dữ liệu đó gọi là các phương thức của lớp. Các đối tượng được xây
dựng bởi các lớp nên được gọi là các thể hiện của lớp (class instance).
Khai báo/định nghĩa lớp
class <ClassName>
{
<kiểu dữ liệu> <field_1>;
<kiểu dữ liệu> <field_2>;
constructor
method_1
method_2
}
class: là từ khóa của java
ClassName: là tên chúng ta đặt cho lớp
field_1, field_2: các thuộc tính, các biến, hay các thành phần dữ
liệu của lớp.
constructor: là sự xây dựng, khởi tạo đối tượng lớp.
method_1, method_2: là các phương thức/hàm thể hiện các thao
tác xử lý, tác động lên các thành phần dữ liệu của lớp.

II. Kế thừa lớp
Một lớp con (subclass) có thể kế thừa tất cả những vùng dữ liệu và phương thức của
một lớp khác (siêu lớp - superclass). Như vậy việc tạo một lớp mới từ một lớp đã biết sao
cho các thành phần (fields và methods) của lớp cũ cũng sẽ thành các thành phần (fields và
methods) của lớp mới. Khi đó ta gọi lớp mới là lớp dẫn xuất (derived class) từ lớp cũ
(superclass). Có thể lớp cũ cũng là lớp được dẫn xuất từ một lớp nào đấy, nhưng đối với
lớp mới vừa tạo thì lớp cũ đó là một lớp siêu lớp trực tiếp (immediate supperclass).
Dùng từ khóa extends để chỉ lớp dẫn xuất.
Khai báo
class A extends B
{
// …
}
Ví dụ:
Class Nguoi () {
String ten;
Int tuoi;
}
Class SinhVien kế thừa từ lớp Nguoi
Class SinhVien () extends Nguoi
{
String lop;
}

III. Giao diện (interface)
Khái niệm
Như chúng ta đã biết một lớp trong java chỉ có một siêu lớp trực tiếp hay một cha duy
nhất (đơn thừa kế). Để tránh đi tính phức tạp của đa thừa kế (multi-inheritance) trong lập
trình hướng đối tượng, Java thay thế bằng giao tiếp (interface). Một lớp có thể có nhiều
giao tiếp (interface) với các lớp khác để
Khai báo
Interface được khai báo như một lớp. Nhưng các thuộc tính của interface là các hằng
(khai báo dùng từ khóa final) và các phương thức của giao tiếp là trừu tượng (mặc dù không
có từ khóa abstract). Trong các lớp có cài đặt các interface ta phải tiến hành cài đặt cụ thể
các phương thức này.
Ví dụ:
public interface sanpham {
static final String nhasx = “Honda VN”;
static final String dienthoai = “08-8123456”;
public int gia(String s_model);
}
IV. Gói (Package)
Khái niệm
Việc đóng gói các lớp lại tạo thành một thư viện dùng chung gọi là package.
Một package có thể chứa một hay nhiều lớp bên trong, đồng thời cũng có thể chứa một
package khác bên trong.
Để khai báo một lớp thuộc một gói nào đấy ta phải dùng từ khóa package.Dòng khai báo
gói phải là dòng đầu tiên trong tập tin khai báo lớp.Các tập tin khai báo lớp trong cùng một
gói phải được lưu trong cùng một thư mục.

CHƯƠNG 3: LẬP TRÌNH GIAO DIỆN VỚI AWT/SWING
I. Giới thiệu chung về AWT/SWING
II. Các lớp vật chứa (Container)
Container là đối tượng vật chứa hay những đối tượng có khả năng quản lý và nhóm các
đối tượng khác lại. Những đối tượng con thuộc thành phần awt như: button, checkbox, radio
button, scrollbar, list,… chỉ sử dụng được khi ta đưa nó vào khung chứa (container).
Một số đối tượng container trong Java:
 Panel: Đối tượng khung chứa đơn giản nhất, dùng để nhóm các đối tượng, thành
phần con lại. Một Panel có thể chứa bên trong một Panel khác.
 Frame: khung chứa Frame là một cửa số window hẳn hoi ở mức trên cùng bao gồm
một tiêu đều và một đường biên (border) như các ứng dụng windows thông thường
khác. Khung chứa Frame thường được sử dụng để tạo ra cửa sổ chính của các ứng
dụng.
 Dialogs: đâylà một cửa sổ dạng hộp hội thoại (cửa sổ dạng này cònđược gọi là pop-
up window), cửa sổ dạng này thường được dùng để đưa ra thông báo, hay dùng để
lấy dữ liệu nhập từ ngoài vào thông qua các đối tượng, thành phần trên dialog như
TextField chẳng hạn. Dialog cũng là một cửa sổ nhưng không đầy đủ chức năng như
đối tượng khung chứa Frame.
 ScrollPanes: là một khung chứa tương tự khung chứa Panel, nhưng có thêm 2 thanh
trượt giúp ta tổ chức và xem được các đối tượng lớn choán nhiều chỗ trên màn hình
như những hình ảnh hay văn bản nhiều dòng.
III. Các lớp quản lý quản lý Layout
Khung chứa container nhận các đối tượng từ bên ngoài đưa vào và nó phải biết làm thế
nào để tổ chức sắp xếp “chỗ ở” cho các đối tượng đó. Mỗi đối tượng khung chứa đều có
một bộ quản lý chịu tráchnhiệm thực hiện công việc đấy đó là bộ quản lý trình bày (Layout
Manager). Các bộ quản lý trình bày mà thư viện cung cấp cho ta bao gồm:

 FlowLayout: Sắp xếp các đối tượng từ trái qua phải và từ trên xuống dưới. Các đối
tượng đều giữ nguyên kích thước của mình.
 BorderLayout: Các đối tượng được đặt theo các đường viền của khung chứa theo
các cạnh West, East, South, North và Center tức Đông, Tây, Nam, Bắc và Trung tâm
hay Trái, Phải, Trên, Dưới và Giữa tùy theo cách nhìn của chúng ta.
 GridLayout: Tạo một khung lưới vô hình với các ô bằng nhau. Các đối tượng sẽ
đặt vừa kích thước với từng ô đó. Thứ tự sắp xếp cũng từ trái qua phải và từ
 trên xuống dưới.
 GridBagLayout: Tương tự như GridLayout, các đối tượng khung chứa cũng được
đưa vào một lưới vô hình. Tuy nhiên kích thước các đối tượng không nhất thiết phải
vừa với 1 ô mà có thể là 2, 3 ô hay nhiều hơn tùy theo các ràng buộc mà ta chỉ định
thông qua đối tượng
 GridBagConstraint. Null Layout: Cách trình bày tự do. Đối với cách trình bày này
người lập trình phải tự động làm tất cả từ việc định kích thước của các đối tượng,
cũng như xác định vị trí của nó trên màn hình. Ta không phụ thuộc vào những ràng
buộc đông, tây , nam, bắc gì cả.
IV. Các thành phần giao diện cơ bản
Yêu cầu:
- Trình bày công dụng của thành phần giao diện cơ bản
- Trình bày các hàm tạo, công dụng
- Trình bày các phương thức, công dụng
1. JTextField
Công dụng: Tạo một ô cho phép người dùng nhập văn bản
Các hàm tạo:
 TextField(): Tạo một textfield mới.
 TextField(int columns): Tạo một textfield mới với số cột được cho.
 TextField(String s): Tạo một textfield mới với chuỗi văn bản được cho.

 TextField(String s, int columns): Tạo một textfieldmới với nhãn và số cột được cho.
Các phương thức:
 setEchoChar(char) Thiết lập các kí tự được trình bày trong dạng của một kí tự
được cho.
 setText(String s) Thiết lập nhãn cho TextField.
 getText() Trả về nhãn của TextField.
 setEditable(boolean) Xác định trường có thể được soạn thảo hay không. Trường
chỉ được soạn thảo khi giá trị này được đặt là True.
 isEditable() Xác định xem trường có đang trong mode soạn thảo hay không. Giá trị
trả về kiểu Boolean.
2. JTextField
Công dụng: Hiển thị chuỗi chỉ đọc
Các hàm tạo:
 Label() Tạo một Label trống.
 Label(String labeltext) Tạo một Label với văn bản được cho.
 Label(String labeltext, int alignment) Tạo một Label với một chế độ canh lề align-
ment được cho, alignment có thể là Label.LEFT, Label.RIGHT hay Label.CENTER.
 setFont(Font f) Thay đổi phông chữ đang được chọn của Label
 setText(String s) Thiết lập nhãn cho Label
 getText() Lấy nội dung hiện hành của Label
3. JTextArea
Công dụng: Cho phép người dùng nhập văn bản trên nhiều dòng
Các hàm tạo:
 TextArea(): Tạo một TextArea mới.

 TextArea(int rows, int cols): Tạo một TextArea mới với số lượng cột và dòng được
cho.
 TextArea(String text): Tạo một TextArea mới với nhãn được cho.
 TextArea(String text, int rows, int cols): Tạo một TextArea mới với nhãn, số dòng
và số cột được cho.
 setText(String) Thiết lập nhãn cho TextArea.
 getText() Trả về nhãn của TextArea.
 setEdiable(boolean) Xác định xem trường có thể được soạn thảo hay không. Trường
có thể được soạn thảo khi giá trị này là True.
 isEdiable() Xác định xem trường có đang trong mode soạn thảo được không. Trả về
giá trị là kiểu Boolean.
 insertText(String, int) Chèn String được cho vào vị trí index được cho.
 replaceText(String, int, int) Thay thế văn bản nằm giữa vị trí int, int được cho.
4. JButton
Công dụng: Là một nút nhấn cho phép người dùng tác động vào chương trình
Các hàm tạo:
 Button() Tạo một button mới
 Button(String text) Tạo button mới với tên
 setText(String) Thiết lập nhãn cho button
 getText() Trả về nhãn của button
 isEdiable() Xác định xem trường có đang trong mode soạn thảo được không. Trả về
giá trị là kiểu Boolean.

5. JCheckBox
Công dụng: Checkbox được sử dụng khi người dùng tiến hành chọn một hay nhiều tùy
chọn
Các hàm tạo:
 Checkbox(): Tạo một checkbox trống.
 Checkbox(String text): Tạo một checkbox với nhãn được cho.
5. JRadioButton
Công dụng: được sử dụng khi người dùng tiến hành chọn một hay nhiều tùy
Các hàm tạo:
 Checkbox(): Tạo một checkbox trống.
 Checkbox(String text): Tạo một checkbox với nhãn được cho.

CHƯƠNG 4: LẬP TRÌNH CƠ SỞ DỮ LIỆU
I.Giới thiệu JDBC
Hầu hết các chương trình máy tính hiện này đếu ít nhiều liên quan đến việc truy xuất
thông tin trong các cơ sở dữ liệu. Chính vì thế nên các thao tác hỗ trợ lập trình cơ sở dữ
liệu là chức năng không thể thiếu của các ngôn ngữ lập trình hiện đại, trong đó có Java.
JDBC API là thư viện chứa các lớp và giao diện hỗ trợ lập trình viên Java kết nối và truy
cập đến các hệ cơ sở dữ liệu. Phiên bản JDBC API mới nhất hiện nay là 3.0, là một thành
phần trong J2SE, nằm trong 2 gói thư viện: § java.sql: chứa các lớp và giao diên cơ sở của
JDBC API. § javax.sql: chứa các lớp và giao diện mở rộng. JDBC API cung cấp cơ chế
cho phép một chương trình viết bằng Java có khả năng độc lập với các hệ cơ sở dữ liệu,
có khả năng truy cập đến các hệ cơ sở dữ liệu khác nhau mà không cần viết lại chương
trình. JDBC đơn giản hóa việc tạo và thi hành các câu truy vấn SQL trong chương trình.
II.Kiến trúc JDBC
Kiến trúc của của JDBC tương tự như kiến trúc ODBC do Microsoft xây dựng. Theo kiến
trúc này các thao tác liên quan đến cơ sở dữ liệu trong chương trình được thực hiện thông
qua các JDBC API. Sau đó các JDBC API sẽ truyền các yêu cầu của chương trình đến bộ
quản lý trình điều khiển JDBC, là bộ phận có nhiệm vụ lựa chọn trình điều khiển thích
hợp để có thể làm việc với cơ sở dữ liệu cụ thể mà chương trình muốn kết nối. Như vậy
kiến trúc của JDBC gồm 2 tầng: tầng đầu tiên là các JDBC API, có nhiệm vụ chuyển các
câu lệnh SQL cho bộ quản lý trình điều khiển JDBC; tầng thứ 2 là các JDBC Driver API,
hiện nhiệm vụ liện hệ vớ trình điều khiển của hệ quản trỉ cơ sở dữ liệu cụ thể.

HÌNH 4.1 Kiến trúc của JDBC
Hình bên dưới minh họa các lớp và giao diện cơ bản trong JDBC API
HÌNH 4.2 Các lớp và các giao diện cơ bản trong JDBC API

III.Kết nối đến CSDL
Việc kết nối với CSDL bằng JDBC được thực hiện qua hai bước: đăng ký trình điều khiển
JDBC; tiếp theo thực thi phương thức getConnection() của lớp DriverManager.
1.Đăng ký trình điều khiển
Trình điều khiển JDBC được nạp khi mã bytecode của nó được nạp vào JVM. Một cách
đơn giản để thực hiện công việc này là thực thi phương thức Class.forName(“<JDBC
Driver>”).
Ví dụ: để nạp trình điều khiển sử dụng cầu nối ODBC do Sun cung cấp, chúng ta sử dụng
câu lệnh sau
Class.forName(“sun.jdbc.odbc.JdbcOdbcDriver”).
2.Thực hiện kết nối
Sau khi đã nạp trình điều khiển JDBC, việc kết nối với CSDL được thực hiện với một
trong các phương thức sau trong lớp DriverManager:
 public static Connection getConnection(String url) throws SQLException: thực
hiện kết nối với CSDL được yêu cầu. Bộ quản lý trình điều khiển sẽ tự động lựa
chọn trình điều khiển phù hợp trong số các trình điều khiển đã được nạp.
 public static Connection getConnection(String url, String user, String pass) throws
SQLException: tiến hành kết nối tới CSDL với tài khoản user và mật mã pass.
 public static Connection getConnection(String url, Properties info) throws SQLEx-
ception: tương tự hai phương thức trên ngoài ra cung cấp thêm các thông tin qui
định thuộc tính kết nối thông qua đối tượng của lớp Properties.Kết quả trả về của
các phương thức trên là một đối tượng của lớp java.sql.Connection được dùng để
đại diện cho kết nối đến CSDL.
IV.Các thao tác cơ bản trên CSDL
Các thao tác truy vấn CSDL chỉ có thể được thực hiện sau khi đã có đối tượng Con-
nection, được tạo ra từ quá trình kết nối vào CSDL. Chúng ta sử dụng đối tượng của lớp

Connection để tạo ra các thể hiện của lớp java.sql.Statement. Sau khi tạo ra các đối tượng
của lớp Statement chúng ta có thể thực hiện các thao tác trong các đối tượng statement
trên connection tương ứng. Nội dung trong một statement chính là các câu SQL. Câu lệnh
SQL trong các statement chỉ được thực hiện khi chúng ta gửi chúng đến CSDL. Nếu câu
lện SQL là một câu truy vấn nội dung thì kết quả trả về sẽ là một thể hiện của lớp
java.sql.ResultSet, ngược lại (các câu lệnh thay đổi nội dung CSDL) sẽ trả về kết quả là
mộ số nguyên. Các đối tượng của lớp ResultSet cho phép chúng ta truy cập đến kết quả
trả về của các câu truy vấn.
Các lớp cơ bản
 java.sql.Statement Statement là một trong 3 lớp JDBC cơ bản dùng để thể hiện
một câu lệnh SQL. Mọi thao tác trên CSDL được thực hiện thông qua 3
phương thức của lớp Statement. Phương thức executeQuery() nhận vào 1 tham
số là chuỗi nội dung câu lện SQL và trả về 1 đối tượng kiểu ResultSet. Phương
thức này được sử dụng trong các trường hợp câu lệnh SQL có trả về các kết
quả trong CSDL.
Phương thức executeUpdate() cũng nhận vào 1 tham số là chuỗi nội dung câu
lệnh SQL. Tuy nhiện phương thức này chỉ sử dụng được đối với các cây lệnh
cập nhật nội dung CSDL. Kết quả trả về là số dòng bị tác động bỡi câu lệnh
SQL. Phương thức execute() là trường hợp tổng quát của 2 phương thức trên.
Phương thức nhận vào chuỗi nội dung câu lệnh SQL.
Câu lệnh SQL có thể là câu lệnh truy vấn hoặc cập nhật. Nếu kết quả của câu
lệnh là các dòng trong CSDL thì phương thức trả về giá trị true, ngược lại trả
về giá trị false. Trong trường hợp giá trị true, sau đó chúng ta có thể dùng
phương thức getResultSet() để lấy các dòng kết quả trả về.
 java.sql.ResultSet Đối tượng resultset là các dòng dữ liệu trả về của câu lệnh
truy vấn CSDL. Lớp này cung cấp các phương thức để rút trích các cột trong
từng dòng kết quả trả về.

Tất cả các phương thức này đều có dạng: type getType(int | String) Trong đó
tham số có thể là số thứ tự của cột hoặc tên cột cần lấy nội dung. Tại 1 thời
điểm chúng ta chỉ có thể thao tác trên 1 dòng của resultset.
Để thao tác trên dòng tiếp theo chúng ta sử dụng phương thức next(). Phương
thức trả về giá trị true trong trường hợp có dòng tiếp theo, ngược lại trả về giá
trị false.

CHƯƠNG 5: BÀI TẬP MINH HỌA
I. Lập trình căn bản
Bài 1:
Yêu cầu: Viết chương trình in một nội dung ra màn hình
Chương trình: Bai1.java
public class Bai1 {
public static void main(String[] args) {
System.out.println("Hello World!");
}
}
Bài 2:
Yêu cầu: Viết chương trình nhập tên và xuất ra màn hình
Bài 3:
Yêu cầu: Nhập hai số từ bàn phím và tính tổng
public class bai2 {
public static void main(String[] args) throws Exception {
System.out.println("nhap ten cua ban :");
BufferedReader in = new BufferedReader(new InputStreamReader(Sys-
tem.in));
String string = in.readLine();
System.out.print("xin chao "+ string);
}
}

Bài 4:
Yêu cầu: Viết chương trình nhập tên, địa chỉ, lớp, xuất thông tin vừa nhập và màn hình
Bài 5:
Yêu cầu: Viết chương trình giải phương trình bậc hai
public class bai3 {
int a, b,ketQua;
tem.in));
System.out.println("nhap a :");
a = Integer.parseInt(in.readLine());
System.out.println("nhap b :");
b = Integer.parseInt(in.readLine());
ketQua = a+b;
System.out.print("Ket qua a+b : "+ ketQua );
}
}
public class bai4 {
// TODO Auto-generated method stub
String ten, diaChi, lop;
tem.in));
System.out.println("Nhập tên :");
ten = in.readLine();
System.out.println("Nhập địa chỉ :");
diaChi = in.readLine();
System.out.println("Nhập lớp :");
lop = in.readLine();
System.out.print("Chào bạn " + ten + "," + diaChi + "," + lop);
}
}

public class phuongtrinhbac2 {
private static Scanner input;
input = new Scanner(System.in);
boolean lamLai = true;
PhuongTrinh giaiPhuongTrinh = new PhuongTrinh();
while (lamLai == true) {
giaiPhuongTrinh.nhap();
giaiPhuongTrinh.kiemTra();
System.out.println("Ban co muon lam lai khong ? 1 : co 2 :
khong ");
if (input.nextInt() == 2) {
lamLai = false;
System.out.println("Ket thuc chuong trinh ");
}
}
}
}
class PhuongTrinh {
public float a, b, c;
double x1, x2;
double delta;
Scanner input = new Scanner(System.in);
public void nhap() {
System.out.print("nhap a: ");
this.a = input.nextFloat();
System.out.print("nhap b: ");
this.b = input.nextFloat();
System.out.print("nhap c: ");
this.c = input.nextFloat();
}
public void kiemTra() {
if (a == 0) {
if (b == 0) {
System.out.print("phuong trinh vo so nghiem");
} else {
System.out.print("phuong trinh co nghiem duy nhat: "
+ nghiemDuyNhat());
}
} else {
if (tinhDelta() < 0) {
System.out.print("phuong trinh vo nghiem");
}
else {
if (tinhDelta() == 0) {
System.out.print("phuong trinhg co nghiem kep: "
+ nghiemKep());
} else {
System.out.println("phuong trinh co 2 nghiem phan
biet: ");

II. Lập trình hướng đối tượng
1. Xây dựng lớp
Bài 1:
Yêu cầu: Xây dựng lớp nhân viên bao gồm Mã nhân viên, họ tên nhân viên, địa chỉ,
CBQL
}
}
}
}
public double tinhDelta() {
delta = ((Math.pow(b, 2)) - 4 * a * c);
return delta;
}
public double nghiemDuyNhat() {
x1 = -c / b;
return x1;
}
public double nghiemKep() {
x1 = -b / (2 * a);
return x1;
}
public void nghiemPhanBiet() {
x1 = ((-b + Math.sqrt(delta)) / (2 * a));
x2 = ((-b - Math.sqrt(delta)) / (2 * a));
System.out.println("x1= " + x1);
System.out.println("x2= " + x2);
}
}

Chương trình: NhanVien.java
Bài 2:
Yêu cầu: Xây dựng lớp Sinh viên với các thuộc tính của sinh viên là mã sinh viên, họ tên,
điểm lý thuyết, điểm thực hành. Viết hàm main cho phép thực hiện:
1. Nhập thông tin cho một sinh viên
2. Tính điêm trung bình của sinh viên (điểm trung bình bằng (dlt+dth)/2)
3. Xuất thông tin của sinh viên và kết quả học tập của sinh viên (Đậu khi điểm trung
bình >= 5 ngược lại thì Rớt)
public class NhanVien {
int maNV;
String hoTen;
String diaChi;
Boolean CBQl;
public NhanVien(int maNV, String hoTen, String diaChi, Boolean cBQl) {
super();
this.maNV = maNV;
this.hoTen = hoTen;
this.diaChi = diaChi;
CBQl = cBQl;
}
NhanVien mNhanVien = new NhanVien(1, "Trinh Van Long", "Dak Lak",
true);
if (mNhanVien.CBQl) {
System.out.println("Ma nhan vien :" + mNhanVien.maNV);
System.out.println("Ho ten :" + mNhanVien.hoTen);
}
}
}

Chương trình: SinhVien.java
public class SinhVien {
int maSinhVien;
String hoTen;
float diemLyThuyet;
float diemThucHanh;
float diemTrungBinh;
public SinhVien() {
}
public SinhVien(int maSinhVien, String hoTen, float diemLyThuyet,
float diemThucHanh) {
super();
this.maSinhVien = maSinhVien;
this.hoTen = hoTen;
this.diemLyThuyet = diemLyThuyet;
this.diemThucHanh = diemThucHanh;
}
public static void main(String[] args) throws NumberFormatException,
IOException {
SinhVien mSinhVien = new SinhVien();
mSinhVien.Nhap(mSinhVien);
System.out.println("Diem trung binh : " + mSinhVien.diemTrungBinh);
System.out.println(mSinhVien.toString());
}
public void Nhap(SinhVien mSinhVien) throws NumberFormatException,
IOException {
BufferedReader input = new BufferedReader(new InputStreamReader(
System.in));
System.out.println("Nhap ma sinh vien : ");
mSinhVien.maSinhVien = Integer.parseInt(input.readLine());
System.out.println("Nhap ho ten : ");
mSinhVien.hoTen = input.readLine();
System.out.println("Nhap diem ly thuyet : ");
mSinhVien.diemLyThuyet = Float.parseFloat(input.readLine());
System.out.println("Nhap ma thuc hanh : ");
mSinhVien.diemThucHanh = Float.parseFloat(input.readLine());
// Tinh diem trung binh
mSinhVien.diemTrungBinh = mSinhVien.diemTrungBinh(mSinhVien);
}
public float diemTrungBinh(SinhVien sinhVien) {
return (sinhVien.diemThucHanh + sinhVien.diemLyThuyet) / 2;
}

Bài 3:
Yêu cầu:
1. Xây dựng lớp NhanVien như sau:
Tên
lớp
NhanVien
Các
thuộc
tính
- maNV : String
- soSP : int
Các
phươn
g thức
+ NhanVien()
+ NhanVien (ma: String, sp : int)
+ getMaNV() : String
+ setMaNV(ma : String) : void
+ getSoSP() : int
+ setSoSP(sp : int) : void
+ coVuotChuan() : boolean
+ getTongKet() : String
+ getLuong(): double
+ XuatTieuDe() : static void
+ toString() : String
Trong các hàm khởi tạo và các hàm setSoSP, khi gán giá trị cho thuộc tính soSP thì cần
kiểm tra giá trị đó có phải là số dương không, nếu là số dương thì mới gán giá trị cho thuộc
tính, ngược lại thì gán bằng 0.
Hàm coVuotChuan() : trả về true nếu soSP > 500, ngược lại trả về false.
Giải thích: hàm này dùng để kiểm tra xem số lượng sản phẩm của nhân viên có vượt quá số
lượng chuẩn hay không.
Hàm getTongKet() : trả về chữ "Vượt" khi soSP > 500, ngược lại để trống (có thể sử dụng
@Override
public String toString() {
String a = "SinhVien maSV : " + maSinhVien + ", ho ten : " + hoTen
+ ", diemLyThuyet=" + diemLyThuyet + ", diemThucHanh="
+ diemThucHanh + "n Ket Qua : ";
if (diemTrungBinh >= 5)
a += "Ket qua : Dau";
else
a += "Ket qua : Rot";
return a;
}
}

hàm coVuotChuan() để kiểm tra).
Hàm getLuong() : trả về lương của một nhân viên, lương ăn theo sản phẩm với đơn giá cơ
bản cho 1 sản phẩm là 20000, và nếu số sản phẩm của nhân viên vượt chuẩn thì phần vượt
chuẩn được tính đơn giá là 30000.
Hàm XuatTieuDe() : xuất tiêu đề gồm các cột : mã nhân viên, số sản phẩm, lương, tổng kết.
Hàm toString() : trả về chuỗi chứa thông tin của nhân viên gồm các cột: Mã nhân viên
(maNV), Số sản phẩm (soSP), Lương và Tổng kết.
2. Viết hàm main để kiểm tra lớp NhanVien theo yêu cầu sau:
Tạo 2 nhân viên với các thuộc tính cho người dùng nhập vào. Xuất ra các thông tin của họ,
gồm mã, số sản phẩm, lương, tổng kết.
Chương trình: NhanVien.java
public class NhanVien {
String maNhanVien;
static String phanXuong;
int soSanPham;
public NhanVien() {
}
public NhanVien(String maNhanVien, String phanXuong, int soSanPham) {
super();
this.maNhanVien = maNhanVien;
this.phanXuong = phanXuong;
this.soSanPham = soSanPham;
}
public String getMaNhanVien() {
return maNhanVien;
}
public void setMaNhanVien(String maNhanVien) {
this.maNhanVien = maNhanVien;
}
public static String getPhanXuong() {
return phanXuong;
}
public void setPhanXuong(String phanXuong) {
this.phanXuong = phanXuong;
}
public int getSoSanPham() {
return soSanPham;
}
public void setSoSanPham(int soSanPham) {
}
public static int getChuan() {
if (phanXuong.equals("A"))
return 300;
else

public void setSoSanPham(int soSanPham) {
}
public static int getChuan() {
if (phanXuong.equals("A"))
return 300;
else
return 500;
}
public static int getChuan(String px) {
if (px.equals("A"))
return 300;
else
return 500;
}
public boolean vuotChuan() {
if (phanXuong.equals("A")) {
if (soSanPham > 300)
return true;
else
return false;
} else {
if (soSanPham > 500)
return true;
else
return false;
}
}
public int tinhLuong() {
int luong;
if (vuotChuan())
luong = soSanPham * 30000;
else
luong = soSanPham * 20000;
return luong;
}
return maNhanVien;
}
public String[] getNhanVien() {
if (vuotChuan()) {
String[] temp = { maNhanVien, phanXuong, String.valueOf(so-
SanPham),
"x" };
return temp;
} else {
String[] temp = { maNhanVien, phanXuong, String.valueOf(so-
SanPham),
"" };
return temp;
}
}
}

2. Kế thừa
Bài 1
Yêu cầu: Cho các lớp sau:
// Vehicle.java
public class Vehicle{
private int numOfWheels;
public Vehicle(int x){
numOfWheels = x;
}
public void drive() {
System.out.println("Driving a vehicle");
}}
//Car.java
public class Car extends Vehicle{
private int numOfDoors; public Car(int d, int w) {
super(w);
numOfDoors = d;
}
System.out.println("Driving a car");
}
}
Viết hàm main() sử dụng lớp Car như sau, hãy co biết kết quả chương trình là gì khi viết theo
2 trường hợp sau sau:

TH1:
Car audi = new Car();
Car.drive();
TH2:
Car p = new Car(2, 4);
p.drive();
Chương trình: Main.java, Vehicle.java, Car.java
public class Main {
Car audi = new Car();
Car.drive();
}
}
class Vehicle {
private int numOfWheels;
public Vehicle(int x) {
numOfWheels = x;
}
System.out.println("Driving a vehicle");
}
}
// Car.java
class Car extends Vehicle {
private int numOfDoors;
public Car(int d, int w) {
super(w);
numOfDoors = d;
}
System.out.println("Driving a car");
}
}

Bài 2:
Yêu cầu:
- Cài đặt các lớp (Class) cho lược đồ sau:
Trong đó:
+ Point, Circle, CircleTest là các class
+ toString(): xuất giá trị x, y, radius của Point hoặc Circle tương ứng (x, y xuất kiểu
tọa độ[x,y])
+ setRadius(): kiểm tra giá trị đưa vào.
+ getDiameter(): tính đường kính hình tròn. + getCircumference(): tính chu vi hình
tròn. + getArea(): tính diện tích hình tròn.
+ Hàm main() yêu cầu nhập một mảng n đối tượng Circle, xuất ra đường kính, chu vi,
diện tích của chúng, kết quả hiển thị 2 số lẻ.

Chương trình: Circle.java
public class Circle extends Point {
double radius;
public Circle() {
}
public Circle(int x, int y, double radius) {
super(x, y);
this.radius = radius;
}
public double getRadius() {
return radius;
}
public void setRadius(double radius) {
if (radius >= 0)
this.radius = radius;
}
/**
* @return trả về đường kính hình tròn
*/
public double getDiameter() {
return radius * 2;
}
/**
* @return trả về chu vi hình tròn
*/
public double getCircumference() {
return getDiameter() * 3.14;
}
public double getArea() {
return (radius * radius) * 3.14;
}
@Override
return "[" + x + "," + y + "],"+radius;
}
}

Point.java
public class Point {
int x, y;
public Point() {
}
public Point(int x, int y) {
super();
this.x = x;
this.y = y;
}
/**
* @return the x
*/
public int getX() {
return x;
}
/**
* @param x
* the x to set
*/
public void setX(int x) {
this.x = x;
}
/**
* @return the y
*/
public int getY() {
return y;
}
/**
* @param y
* the y to set
*/
public void setY(int y) {
this.y = y;
}
/*
* (non-Javadoc)
*
* @see java.lang.Object#toString()
*/
@Override
return "Point [x=" + x + ", y=" + y + "]";
}
}

Bài3:
Yêu cầu:
a. Xây dựng lớp hình chữ nhật với các thuộc tính là chiều dài, chiều rộng, viết các hàm tính
chu vi, diện tích của nó.
public class CircleTest {
private static ArrayList<Circle> circles;
nhap();
xuat();
}
public static void nhap() {
circles = new ArrayList<Circle>();
int soPhanTu;
int x, y, radius;
System.out.println("Mang cua ban co bao nhieu hinh tron ? ");
soPhanTu = input.nextInt();
for (int i = 0; i < soPhanTu; i++) {
System.out.println("Hinh tron " + (i + 1));
System.out.println("Nhap x ");
x = input.nextInt();
System.out.println("Nhap y ");
y = input.nextInt();
System.out.println("Nhap ban kinh : ");
radius = input.nextInt();
circles.add(new Circle(x, y, radius));
}
}
public static void xuat() {
for (int i = 0; i < circles.size(); i++) {
System.out.println("Hinh tron " + (i + 1) + ": " + "Duong
kinh : "
+ circles.get(i).getDiameter() + ", Chu vi : "
+ circles.get(i).getCircum-
ference() + ", Dien tich : "
+ circles.get(i).getArea());
}
}
}

b. Xây dựng lớp hình vuông thừa kế lớp hình chữ nhật.
c. Viết chương trình tính chu vi, diện tích hình vuông với độ dài nhập vào
Chương trình: HinhChuNhat.java
public class HinhChuNhat {
int chieuDai;
int chieuRong;
public HinhChuNhat() {
}
public HinhChuNhat(int chieuDai, int chieuRong) {
this.chieuDai = chieuDai;
this.chieuRong = chieuRong;
}
/**
* @return the chieuDai
*/
public int getChieuDai() {
return chieuDai;
}
/**
* @param chieuDai
* the chieuDai to set
*/
public void setChieuDai(int chieuDai) {
this.chieuDai = chieuDai;
}
/**
* @return the chieuRong
*/
public int getChieuRong() {
return chieuRong;
}
/**
* @param chieuRong
* the chieuRong to set
*/
public void setChieuRong(int chieuRong) {
this.chieuRong = chieuRong;
}
public int dienTich() {
return chieuDai * chieuRong;
}
public int chuVi() {
return (chieuDai + chieuRong) * 2;
}
}

HinhVuong.java
Main.java
public class HinhVuong extends HinhChuNhat {
public HinhVuong() {
super();
}
public HinhVuong(int chieuDai, int chieuRong) {
super(chieuDai, chieuRong);
}
}
public class Main {
HinhVuong mHinhVuong = new HinhVuong();
nhap(mHinhVuong);
xuat(mHinhVuong);
}
public static void nhap(HinhVuong hv) {
System.out.println("Nhap chieu dai : ");
hv.setChieuDai(input.nextInt());
System.out.println("Nhap chieu rong : ");
hv.setChieuRong(input.nextInt());
}
public static void xuat(HinhVuong hv) {
System.out.println("Dien tich : " + hv.dienTich() + ", Chu vi : "
+ hv.chuVi());
}}
public int dienTich() {
return chieuDai * chieuRong;
}
public int chuVi() {
return (chieuDai + chieuRong) * 2;
}
}

III. Lập trình giao diện
Bài 1:
Yêu cầu:
Chương trình:
public class Bai1 extends JFrame {
Bai1 frame = new Bai1();
}
public Bai1() {
setTitle("JCheckBox Test");
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
setResizable(false);
setBounds(100, 100, 418, 111);
add(jPanel1());
setVisible(true);
}
public JPanel jPanel1() {
JPanel contentPane = new JPanel();
contentPane.setBorder(new EmptyBorder(5, 5, 5, 5));
contentPane.setLayout(new FlowLayout(FlowLayout.CENTER, 5, 5));
final JTextField textField = new JTextField();
contentPane.add(textField);
textField.setColumns(32);
final JCheckBox chckbxBold = new JCheckBox("Bold");
chckbxBold.addActionListener(new ActionListener() {
@Override
public void actionPerformed(ActionEvent arg0) {
if (textField.getFont().isBold())
textField.setFont(new Font(null, Font.PLAIN,
textField.getFont().getSize()));
else
textField.setFont(new Font(null, Font.BOLD, text-
Field
.getFont().getSize()));
}
});

Kết quả:
Bài2:
Yêu cầu :
contentPane.add(chckbxBold);
JCheckBox chckbxItalic = new JCheckBox("Italic");
chckbxItalic.addActionListener(new ActionListener() {
@Override
if (textField.getFont().isItalic())
textField
else
textField.setFont(new Font(null, Font.ITALIC,
textField
}
});
contentPane.add(chckbxItalic);
return contentPane;
}
}

Chương trình :
public class MyRadioButton extends JFrame {
JTextField textField;
MyRadioButton frame = new MyRadioButton();
}
public MyRadioButton() {
setTitle("RadioButton Test");
setResizable(false);
setBounds(100, 100, 418, 111);
add(jPanel1());
setVisible(true);
}
public JPanel jPanel1() {
JPanel mJPanel = new JPanel();
mJPanel.setBorder(new EmptyBorder(5, 5, 5, 5));
mJPanel.setLayout(new FlowLayout(FlowLayout.CENTER, 5, 5));
textField = new JTextField();
mJPanel.add(textField);
final JCheckBox chckbxPlain = new JCheckBox("Plain");
chckbxPlain.addActionListener(new ButtonClickListener());
mJPanel.add(chckbxPlain);
final JCheckBox chckbxBold = new JCheckBox("Bold");
chckbxBold.addActionListener(new ButtonClickListener());
mJPanel.add(chckbxBold);
JCheckBox chckbxItalic = new JCheckBox("Italic");
chckbxItalic.addActionListener(new ButtonClickListener());
mJPanel.add(chckbxItalic);
final JCheckBox chckbxBoldItalic = new JCheckBox("Bold/Italic");
chckbxBoldItalic.addActionListener(new ButtonClickListener());
mJPanel.add(chckbxBoldItalic);
return mJPanel;
}

Kết quả:
private class ButtonClickListener implements ActionListener {
public void actionPerformed(ActionEvent e) {
String command = e.getActionCommand();
switch (command) {
case "Plain":
textField.setFont(new Font(null, Font.PLAIN, textField
break;
case "Bold":
if (textField.getFont().isBold())
textField
else
textField.setFont(new Font(null, Font.BOLD, text-
Field
break;
case "Italic":
if (textField.getFont().isItalic())
textField.setFont(new Font(null,
Font.PLAIN, textField
else
textField.setFont(new Font(null, Font.ITALIC,
textField
break;
case "Bold/Italic":
textField.setFont(new Font(null, Font.BOLD + Font.ITALIC,
textField.getFont().getSize()));
break;
default:
break;
}
}
}
}

Bài 3:
Yêu cầu:
Chương trình:
GiaiPhuongTrinh.java
public class GiaiPhuongTrinhBac2 {
public float a, b, c;
double delta;
double x1, x2;
String ketQua;
static int bienStatic = 0;
public GiaiPhuongTrinhBac2() {
}

public GiaiPhuongTrinhBac2(float a, float b, float c) {
this.a = a;
this.b = b;
this.c = c;
}
public float getA() {
return a;
}
public float getB() {
return b;
}
public float getC() {
return c;
}
public double getDelta() {
return delta;
}
public double getX1() {
return x1;
}
public double getX2() {
return x2;
}
public void giai() {
kiemTra();
}
private void kiemTra() {
if (a == 0) {
if (b == 0) { ketQua = "Phương trình vô nghiệm";
} else { ketQua = "x1 = " + String.format("%.2f", x1); }
} else {
if (tinhDelta() < 0) {
ketQua = "Phương trình vô nghiệm";
}
else {
if (tinhDelta() == 0) {
ketQua = "x1 = " + String.format("%.2f", x1);
} else {
ketQua = "x1 = " + String.format("%.2f",
x1) + " , x2 = "
+ String.format("%.2f", x2);
}}}}
public double nghiemDuyNhat() {
x1 = -c / b;
return x1;
}
public double nghiemKep() {
x1 = -b / (2 * a);
return x1;
}

Main.java
public String nghiemPhanBiet() {
x1 = ((-b + Math.sqrt(delta)) / (2 * a));
x2 = ((-b - Math.sqrt(delta)) / (2 * a));
return x1 + " , " + x2;
}
public void setA(float a) {
this.a = a;
}
public void setB(float b) {
this.b = b;
}
public void setC(float c) {
this.c = c;
}
public double tinhDelta() {
delta = ((Math.pow(b, 2)) - 4 * a * c);
return delta;
}
public String getKetQua() {
return ketQua;
}
}
public class Main extends JFrame {
JTextField txtSoA, txtSoB, txtSoC, txtKetQua;
JButton btnGiai, btnXoaTrang, btnThoat;
GiaiPhuongTrinhBac2 giaiPT;
JLabel lblTieuDe;
Main main = new Main();
GiaiPhuongTrinhBac2.bienStatic = 3;
System.out.println("Gia tri cua bien static "
+ GiaiPhuongTrinhBac2.bienStatic);
}
public Main() {
setTitle("Giải phương trình");
setSize(400, 300);
add(pannelBorder());
setLocationRelativeTo(null);
setVisible(true);
}

public JPanel nhap() {
mJPanel.setLayout(new BoxLayout(mJPanel, BoxLayout.Y_AXIS));
Border centerborder = BorderFactory.createLineBorder(Color.RED);
TitledBorder centerTitleBorder = new TitledBorder(centerborder,
"nhập a – b- c:");
mJPanel.setBorder(centerTitleBorder);
JPanel pA = new JPanel();
pA.add(new JLabel("a"));
txtSoA = new JTextField(15);
pA.add(txtSoA);
mJPanel.add(pA);
JPanel pB = new JPanel();
pB.add(new JLabel("b"));
txtSoB = new JTextField(15);
pB.add(txtSoB);
mJPanel.add(pB);
JPanel pC = new JPanel();
pC.add(new JLabel("c"));
txtSoC = new JTextField(15);
pC.add(txtSoC);
mJPanel.add(pC);
JPanel pKQ = new JPanel();
pKQ.add(new JLabel("Kết quả"));
txtKetQua = new JTextField(15);
txtKetQua.setEditable(false);
pKQ.add(txtKetQua);
mJPanel.add(pKQ);
return mJPanel;
}
public JPanel nut() {
mJPanel.setBorder(BorderFactory.createTitledBorder("Chọn tác vụ"));
mJPanel.setBackground(Color.LIGHT_GRAY);
Border centerborder = BorderFactory.createLineBorder(Color.RED);
TitledBorder centerTitleBorder = new TitledBorder(centerborder,
"Chọn thao tác:");
mJPanel.setBorder(centerTitleBorder);
btnGiai = new JButton("Giải");
btnGiai.addActionListener(new ButtonClickListener());
mJPanel.add(btnGiai);
btnXoaTrang = new JButton("Xóa trắng");
btnXoaTrang.addActionListener(new ButtonClickListener());
mJPanel.add(btnXoaTrang);
btnThoat = new JButton("Thoát");
btnThoat.addActionListener(new ButtonClickListener());
mJPanel.add(btnThoat);
return mJPanel;
}

public JPanel tieuDe() {
lblTieuDe = new JLabel("GIẢI PHƯƠNG TRÌNH BẬC HAI");
Font mFont = new Font(null, Font.BOLD, 21);
lblTieuDe.setFont(mFont);
lblTieuDe.setForeground(Color.BLUE);
mJPanel.add(lblTieuDe);
return mJPanel;
}
public JPanel pannelBorder() {
JPanel mJPanel = new JPanel(new BorderLayout());
mJPanel.add(tieuDe(), BorderLayout.NORTH);
mJPanel.add(nhap(), BorderLayout.CENTER);
mJPanel.add(nut(), BorderLayout.SOUTH);
return mJPanel;
}
private class ButtonClickListener implements ActionListener {
if (command.equals("Giải")) {
giaiPT = new GiaiPhuongTrinhBac2();
try {
giaiPT.setA(Float.parseFloat(txtSoA.getText()));
giaiPT.setB(Float.parseFloat(txtSoB.getText()));
giaiPT.setC(Float.parseFloat(txtSoC.getText()));
giaiPT.giai();
txtKetQua.setText(giaiPT.getKetQua());
} catch (Exception ex) {
JOptionPane.showMessageDialog(null, "Sai định
dạng !");
}
} else if (command.equals("Xóa trắng")) {
txtSoA.setText(null);
txtSoB.setText(null);
txtSoC.setText(null);
txtKetQua.setText(null);
} else {
int ret = JOptionPane.showConfirmDialog(null,
"Bạn có muốn thoát không ?", null,
JOptionPane.YES_NO_OPTION);
if (ret == JOptionPane.YES_OPTION)
System.exit(0);
}
}
}
}

Kết quả :
Bài 4:
Chương trình : CongTruNhanChia.java
public class CongTruNhanChia extends JFrame {
private JTextField txta;
private JTextField txtb;
private JRadioButton rdbtnCong;
private JRadioButton rdbtnTru;
private JRadioButton rdbtnNhan;
private JRadioButton rdbtnChia;

private ButtonGroup mButtonGroup;
private JTextField txtKetQua;
/**
* Launch the application.
*/
CongTruNhanChia frame = new CongTruNhanChia();
}
/**
* Create the frame.
*/
public CongTruNhanChia() {
setTitle("Cộng trừ nhân chia");
setBounds(100, 100, 396, 307);
getContentPane().add(pNoiDung());
setVisible(true);
}
public JPanel pNoiDung() {
JPanel mJPanel = new JPanel(new BorderLayout());
mJPanel.add(pTieuDe(), BorderLayout.NORTH);
mJPanel.add(pNoiDungBenPhai(), BorderLayout.CENTER);
mJPanel.add(pNoiDungBenTrai(), BorderLayout.WEST);
mJPanel.add(pChan(), BorderLayout.SOUTH);
return mJPanel;
}
public JPanel pTieuDe() {
JLabel lblCngTrNhn = new JLabel("Cộng Trừ Nhân Chia");
lblCngTrNhn.setForeground(Color.BLUE);
lblCngTrNhn.setFont(new Font(null, Font.BOLD, 24));
mJPanel.add(lblCngTrNhn);
return mJPanel;
}
public JPanel pNoiDungBenTrai() {
Border mBorder = BorderFactory.createLineBorder(Color.RED);
mJPanel.setBorder(new TitledBorder(mBorder, "Chọn tác vụ"));
JButton btnGiai = new JButton("Giải");
btnGiai.addActionListener(mActionListener);
mJPanel.add(btnGiai);

JButton btnXoa = new JButton("Xóa");
btnXoa.addActionListener(mActionListener);
mJPanel.add(btnXoa);
JButton btnThoat = new JButton("Thoát ");
btnThoat.addActionListener(mActionListener);
mJPanel.add(btnThoat);
btnXoa.setPreferredSize(btnThoat.getPreferredSize());
btnGiai.setPreferredSize(btnThoat.getPreferredSize());
return mJPanel;
}
*/
public JPanel pNoiDungBenPhai() {
mJPanel.setBorder(new EmptyBorder(5, 5, 5, 5));
mJPanel.setLayout(null);
mJPanel.setBorder(new TitledBorder(mBorder, "Nhập 2 số a và b :"));
JLabel lblNhpA = new JLabel("Nhập a : ");
lblNhpA.setBounds(15, 20, 52, 14);
mJPanel.add(lblNhpA);
txta = new JTextField();
txta.setBounds(71, 17, 205, 20);
mJPanel.add(txta);
txta.setColumns(10);
JLabel lblNhpB = new JLabel("Nhập b :");
lblNhpB.setBounds(15, 45, 52, 14);
mJPanel.add(lblNhpB);
txtb = new JTextField();
txtb.setBounds(71, 48, 205, 20);
mJPanel.add(txtb);
txtb.setColumns(10);
JPanel pPhepToan = chonPhepToan();
pPhepToan.setBounds(71, 79, 154, 88);
mJPanel.add(pPhepToan);
JLabel lblKetQua = new JLabel("Kết quả : ");
lblKetQua.setBounds(15, 181, 52, 14);
mJPanel.add(lblKetQua);
txtKetQua = new JTextField();
txtKetQua.setBounds(71, 178, 205, 20);
mJPanel.add(txtKetQua);
txta.setColumns(10);
return mJPanel;
}

public JPanel pChan() {
mJPanel.setBackground(new Color(255, 182, 193));
JPanel p1 = new JPanel();
p1.setBackground(Color.BLUE);
mJPanel.add(p1);
p2.setBackground(Color.RED);
p1.setBackground(Color.RED);
mJPanel.add(p2);
p3.setBackground(Color.BLUE);
p1.setBackground(Color.YELLOW);
mJPanel.add(p3);
return mJPanel;
}
/**
*
*/
public JPanel chonPhepToan() {
JPanel panel = new JPanel(new GridLayout(2, 2));
panel.setLayout(new GridLayout(2, 2));
panel.setBorder(BorderFactory.createTitledBorder("Chọn phép toán:"));
mButtonGroup = new ButtonGroup();
rdbtnCong = new JRadioButton("Cộng ");
mButtonGroup.add(rdbtnCong);
panel.add(rdbtnCong);
rdbtnTru = new JRadioButton("Trừ");
mButtonGroup.add(rdbtnTru);
panel.add(rdbtnTru);
rdbtnNhan = new JRadioButton("Nhân");
mButtonGroup.add(rdbtnNhan);
panel.add(rdbtnNhan);
rdbtnChia = new JRadioButton("Chia");
mButtonGroup.add(rdbtnChia);
panel.add(rdbtnChia);
return panel;
}
ActionListener mActionListener = new ActionListener() {
@Override
switch (command) {
case "Giải":

int cong = 0;
int tru = 0;
int nhan = 0;
float chia = 0;
try {
cong = Integer.parseInt(txta.getText())
+ Integer.parseInt(txtb.getText());
tru = Integer.parseInt(txta.getText())
- Integer.parseInt(txtb.getText());
nhan = Integer.parseInt(txta.getText())
* Integer.parseInt(txtb.getText());
chia = Float.parseFloat(txta.getText())
/ Float.parseFloat(txtb.getText());
} catch (NumberFormatException e1) {
JOptionPane.showMessageDialog(null, "Sai định
dạng !");
break;
}
if (rdbtnCong.isSelected())
txtKetQua.setText(String.valueOf(cong));
else if (rdbtnTru.isSelected())
txtKetQua.setText(String.valueOf(tru));
else if (rdbtnNhan.isSelected())
txtKetQua.setText(String.valueOf(nhan));
else if (rdbtnChia.isSelected())
txtKetQua.setText(String.valueOf(chia));
break;
case "Xóa":
txta.setText("");
txtb.setText("");
txtKetQua.setText("");
mButtonGroup.clearSelection();
break;
case "Thoát":
"Bạn có muốn thoát không ?", null,
System.exit(0);
break;
default:
break;
}
}
};
}

Kết quả :
Bài 5:
Chương trình :
public class JListDemo extends JFrame {
JListDemo mDemo = new JListDemo();
}
public JListDemo() {
setTitle("JList Demo");
setSize(150, 200);
add(panel());

Kết quả
setVisible(true);
}
public JPanel panel() {
String[] s = { "Monday", "Tuesday", "Wednesday", "Thursdday", "Fri-
day",
"Satuday", "Sunday" };
JPanel mJPanel2 = new JPanel();
mJPanel2.setBackground(new Color(00, 0, 100));
mJPanel2.setBorder(BorderFactory.createLineBorder(new Color(100, 0,
0)));
final JLabel mJLabel = new JLabel(s[0]);
mJLabel.setForeground(new Color(255, 255, 255));
mJLabel.setBackground(Color.BLUE);
mJPanel2.add(mJLabel);
mJPanel.add(mJPanel2, BorderLayout.CENTER);
final JList list = new JList(s);
list.setSelectedIndex(0);
list.addListSelectionListener(new ListSelectionListener() {
@Override
public void valueChanged(ListSelectionEvent arg0) {
mJLabel.setText(list.getSelectedValue().toString());
}
});
JScrollPane scrollPane1 = new JScrollPane(list);
mJPanel.add(scrollPane1, BorderLayout.CENTER);
return mJPanel;
}
}

Bài 6:
Chương trình ListEditDemo.java
public class ListEditDemo extends JFrame {
private JTextField textField;
private DefaultListModel<String> mStrings;
private JList list;
/**
*/
ListEditDemo frame = new ListEditDemo();
}
/**
* Create the frame.
*/
public ListEditDemo() {
setTitle("List Edit Demo");
setBounds(100, 100, 507, 300);
jPanel();
setVisible(true);
}

public JPanel jPanel() {
JPanel panel = new JPanel();
getContentPane().add(panel, BorderLayout.CENTER);
panel.setLayout(null);
JScrollPane scrollPane = new JScrollPane();
scrollPane.setBounds(10, 11, 134, 240);
panel.add(scrollPane);
mStrings = new DefaultListModel<String>();
list = new JList(mStrings);
list.addListSelectionListener(mListener);
scrollPane.setViewportView(list);
JPanel panel_1 = new JPanel();
panel_1.setBounds(154, 11, 327, 240);
panel.add(panel_1);
panel_1.setLayout(null);
JLabel lblInputName = new JLabel("Input name");
lblInputName.setBounds(10, 11, 70, 22);
panel_1.add(lblInputName);
textField = new JTextField();
textField.setBounds(75, 12, 235, 20);
panel_1.add(textField);
JButton btnNewButton = new JButton("Add Item");
btnNewButton.addActionListener(mActionListener);
btnNewButton.setBounds(10, 44, 89, 23);
panel_1.add(btnNewButton);
JButton btnRemoveItem = new JButton("Remove Item");
btnRemoveItem.addActionListener(mActionListener);
btnRemoveItem.setBounds(109, 44, 102, 23);
panel_1.add(btnRemoveItem);
JButton btnEditItem = new JButton("Edit Item");
btnEditItem.addActionListener(mActionListener);
btnEditItem.setBounds(221, 43, 89, 23);
panel_1.add(btnEditItem);
return panel;
}
private boolean isTextEmpty() {
if (textField.getText().equals(""))
return true;
else
return false;
}

@Override
String command = arg0.getActionCommand();
switch (command) {
case "Add Item":
if (!isTextEmpty()) {
if (mStrings.contains(textField.getText()))
JOptionPane.showMessageDialog(null, "Đã có
!");
else
mStrings.addElement(textField.getText());
}
break;
case "Remove Item":
if (list.getSelectedValue() != null) {
"Xoá " + list.getSelectedValue(),
"Thông báo",
mStrings.removeElementAt(list.getSelecte-
dIndex());
}
break;
case "Edit Item":
try {
if (!isTextEmpty())
mStrings.setElementAt(textField.getText(),
list.getSelectedIndex());
} catch (Exception e) {
e.printStackTrace();
}
break;
default:
break;
}
}
};
ListSelectionListener mListener = new ListSelectionListener() {
@Override
public void valueChanged(ListSelectionEvent e) {
textField.setText((String) list.getSelectedValue());
}
};
}

Chương trình: ThaoTacJlist.java
public class ThaoTacJlist extends JFrame {
private JPanel contentPane;
private JTextField txtNhap;
private JList list;
private DefaultListModel<Integer> model;
private JCheckBox chckbxNhapAm;
/**
*/
EventQueue.invokeLater(new Runnable() {
public void run() {
try {
ThaoTacJlist frame = new ThaoTacJlist();
frame.setVisible(true);
} catch (Exception e) {
}
}
});
}
public ThaoTacJlist() {
setTitle("Thao tác trên Jlist");
setBounds(100, 100, 631, 374);
contentPane = new JPanel();
contentPane.setBorder(new EmptyBorder(5, 5, 5, 5));
setContentPane(contentPane);
contentPane.setLayout(new BorderLayout(0, 0));
JPanel pNorth = new JPanel();
JLabel lblThaoTcTrn = new JLabel("Thao tác trên Jlis - CheckBox");
lblThaoTcTrn.setForeground(Color.BLUE);
lblThaoTcTrn.setFont(new Font("Tahoma", Font.PLAIN, 24));
pNorth.add(lblThaoTcTrn);
contentPane.add(pNorth, BorderLayout.NORTH);

JPanel pCenter = new JPanel();
contentPane.add(pCenter);
JPanel panel = new JPanel(new FlowLayout(FlowLayout.LEFT));
panel.setBounds(0, 11, 211, 230);
pCenter.setLayout(null);
panel.setBorder(BorderFactory.createTitledBorder(mBorder,
"Chọn tác vụ "));
pCenter.add(panel);
JButton btnToDenSoChan = new JButton("Tô đen số chẵn");
btnToDenSoChan.addActionListener(mActionListener);
panel.add(btnToDenSoChan);
JButton btnToDenSoLe = new JButton("Tô đen số lẻ");
btnToDenSoLe.addActionListener(mActionListener);
panel.add(btnToDenSoLe);
JButton btnTenSoNguyenTo = new JButton("Tô đen số nguyên tố");
btnTenSoNguyenTo.addActionListener(mActionListener);
panel.add(btnTenSoNguyenTo);
JButton btnBoToDen = new JButton("Bỏ tô đen");
btnBoToDen.addActionListener(mActionListener);
panel.add(btnBoToDen);
JButton btnXoa = new JButton("Xóa các giá trị đang tô đen");
btnXoa.addActionListener(mActionListener);
panel.add(btnXoa);
JButton btnTongGiaTri = new JButton("Tổng các giá trị trong list");
btnTongGiaTri.addActionListener(mActionListener);
panel.add(btnTongGiaTri);
panel_1.setBounds(221, 11, 384, 230);
pCenter.add(panel_1);
panel_1.setBorder(BorderFactory.createTitledBorder(mBorder,
"Nhập thông tin"));
panel_1.setLayout(null);
panel_2.setBounds(10, 19, 363, 33);
panel_1.add(panel_2);
JButton btnNhap = new JButton("Nhập");
btnNhap.addActionListener(mActionListener);
btnNhap.addKeyListener(new KeyAdapter() {
@Override
public void keyPressed(KeyEvent arg0) {
int key = arg0.getKeyCode();
if (key == KeyEvent.VK_ENTER)
nhap();
}
});

panel_2.add(btnNhap);
txtNhap = new JTextField();
panel_2.add(txtNhap);
txtNhap.setColumns(10);
chckbxNhapAm = new JCheckBox("Cho nhập giá trị âm");
panel_2.add(chckbxNhapAm);
model = new DefaultListModel<Integer>();
list = new JList();
list.setModel(model);
list.setBounds(0, 0, 110, 111);
JScrollPane mJScrollPane = new JScrollPane();
mJScrollPane.setViewportView(list);
mJScrollPane.setBounds(10, 54, 363, 165);
panel_1.add(mJScrollPane);
contentPane.add(panel_3, BorderLayout.SOUTH);
panel_3.setBorder(mBorder);
JButton btnDong = new JButton("Đóng chương trình");
btnDong.addActionListener(mActionListener);
panel_3.add(btnDong);
}
@Override
String commamd = e.getActionCommand();
list.setSelectionMode(ListSelectionModel.MULTI-
PLE_INTERVAL_SELECTION);
ArrayList<Integer> a = new ArrayList<Integer>();
int[] mSelected;
switch (commamd) {
case "Tô đen số chẵn":
for (int i = 0; i < model.getSize(); i++) {
if ((model.getElementAt(i) % 2) == 0)
a.add(i);
}
mSelected = convertIntegers(a);
list.setSelectedIndices(mSelected);
break;
case "Tô đen số lẻ":
if ((model.getElementAt(i) % 2) != 0)
a.add(i);
}
break;

case "Tô đen số nguyên tố":
if (isSoNguyenTo(i))
a.add(i);
}
break;
case "Bỏ tô đen":
list.clearSelection();
break;
case "Xóa các giá trị đang tô đen":
if (list.getSelectedIndices().length > 0) {
int[] selectedIndices = list.getSelectedIn-
dices();
for (int i = selectedIndices.length - 1; i >= 0;
i--) {
model.removeElementAt(selectedIndices[i]);
}
}
break;
case "Tổng các giá trị trong list":
list.getSelectedIndices();
int tong = 0;
for (int j = 0; j < model.size(); j++) {
tong += model.getElementAt(j);
}
JOptionPane.showMessageDialog(null, "Tổng :" + tong);
break;
case "Nhập":
nhap();
break;
case "Đóng chương trình":
int dong = JOptionPane.showConfirmDialog(null,
"Đóng chương trình", "Thông báo",
JOptionPane.OK_CANCEL_OPTION);
if (dong == JOptionPane.OK_OPTION)
System.exit(1);
break;
default:
break;
}
}
};

public void nhap() {
try {
if (chckbxNhapAm.isSelected())
model.addElement(Integer.parseInt(txtNhap.getText()));
else {
if (Integer.parseInt(txtNhap.getText()) >= 0)
model.addElement(Integer.par-
seInt(txtNhap.getText()));
else
JOptionPane.showMessageDialog(null, "Không thể
nhập số âm !");
}
} catch (NumberFormatException e) {
JOptionPane.showMessageDialog(null, "Sai định dạng !");
} catch (HeadlessException e) {
// TODO Auto-generated catch block
}
}
/**
* @param i
*/
public boolean isSoNguyenTo(int i) {
int dem = 0;
for (int j = 1; j < model.getElementAt(i) / 2; j++) {
if (model.getElementAt(i) % j == 0)
dem++;
}
if (dem > 0)
return false;
else
return true;
}
public static int[] convertIntegers(ArrayList<Integer> integers) {
int[] ret = new int[integers.size()];
for (int i = 0; i < ret.length; i++) {
ret[i] = integers.get(i).intValue();
}
return ret;
}
}

Kết quả :
Bài 8:
Thiết kế giao diện

Đồ án tìm hiểu java và một số bài tập ứng dụng

Đồ án tìm hiểu java và một số bài tập ứng dụng

Empfohlen

Empfohlen

Weitere ähnliche Inhalte

Was ist angesagt?

Was ist angesagt? (20)

Andere mochten auch

Andere mochten auch (20)

Ähnlich wie Đồ án tìm hiểu java và một số bài tập ứng dụng

Ähnlich wie Đồ án tìm hiểu java và một số bài tập ứng dụng (20)

Kürzlich hochgeladen

Kürzlich hochgeladen (20)

Đồ án tìm hiểu java và một số bài tập ứng dụng