Áp dụng các thuật toán trong trí tuệ nhân tạo xây dựng các chương trình trò chơi bằng ngôn ngữ lập trình java

MỤC LỤC
MỤC LỤC ..........................................................................................................0
Lời nói đầu ..........................................................................................................2
Lời cảm ơn ......................................................... Error! Bookmark not defined.
Lời cam đoan...................................................... Error! Bookmark not defined.
CHƯƠNG 1 ........................................................................................................3
LÝ DO CHỌN ĐỀ TÀI.......................................................................................3
1.1. GIỚI THIỆU VỀ CÔNG NGHỆ TRI THỨC ...........................................3
1.1.1. Giới thiệu về tri thức...........................................................................3
1.1.2. Giới thiệu về lý thuyết trò chơi ...........................................................4
1.2. GIỚI THIỆU VỀ GAME ..........................................................................5
1.2.1. Lịch sử cờ vây ....................................................................................5
1.2.2. Lịch sử trò chơi xếp hình ....................................................................5
1.2.3. Lý do chọn đề tài ................................................................................6
CHƯƠNG 2: .......................................................................................................8
CƠ SỞ LÝ THUYẾT ..........................................................................................8
2.1. GIỚI THIỆU VỀ JAVA [2] ......................................................................8
2.1.1. Lịch sử phát triển................................................................................8
2.1.2. Các đặc điểm của Java........................................................................8
2.1.3. JDK – Java Development Kit - Bộ công cụ phát triển Java ...............10
2.1.4. Các đặc điểm cơ bản của các thành phần AWT.................................11
2.1.5. Các thành phần của AWT được sử dụng...........................................12
2.1.6. Đối tượng đồ hoạ..............................................................................16
2.1.7. Xử lý sự kiện ....................................................................................20
2.1.8. WindowListener ...............................................................................23
2.1.9. Phân tuyến và đa tuyến .....................................................................24
2.1.10. Interface .........................................................................................25
2.2. GIỚI THIỆU VỀ TRÍ TUỆ NHÂN TẠO [1]...........................................26
2.2.1. Lịch sử hình thành và phát triển của trí tuệ nhân tạo .........................26
2.2.2. Định nghĩa trí tuệ nhân tạo................................................................28

2.2.3. Thử nghiệm Turing...........................................................................28
2.2.4. Khái quát các lĩnh vực ứng dụng của trí tuệ nhân tạo ........................29
2.2.5. Không gian trạng thái .......................................................................32
2.2.6. Chiến lược tìm kiếm tối ưu ...............................................................33
2.2.7. Tìm kiếm có đối thủ..........................................................................35
CHƯƠNG 3: .....................................................................................................40
XÂY DỰNG CÁC CHƯƠNG TRÌNH TRÒ CHƠI...........................................40
3.1. XÂY DỰNG CHƯƠNG TRÌNH TRÒ CHƠI CỜ VÂY..........................40
3.1.1. Ý tưởng ............................................................................................40
3.1.2. Thiết kế chương trình .......................................................................45
3.1.3. Đánh giá chương trình ......................................................................53
3.2. XÂY DỰNG TRÒ CHƠI XẾP HÌNH.....................................................54
3.2.1. Ý tưởng ............................................................................................54
3.2.2. Thiết kế chương trình .......................................................................56
3.2.3. Đánh giá chương trình ......................................................................60
KẾT LUẬN.......................................................................................................61
TÀI LIỆU THAM KHẢO .................................................................................62

1


Lời nói đầu
Ngày nay với sự phát triển không ngừng của khoa học kỹ thuật đặc biệt
công nghệ thông tin là lĩnh vực luôn được đưa lên hàng đầu thúc đẩy sự tăng
trưởng phát triển nền kinh tế của mỗi quốc gia. Công nghệ thông tin dần khẳng
định được vai trò của mình trong các lĩnh vực khoa học, kỹ thuật và giải trí. Xuất
khẩu phần mềm trò chơi giải trí luôn mang lại lợi nhuận cao cho các quốc gia có
ngành tin học phát triển mạnh.
Khi chiếc máy tính cá nhân đã trở thành một phần của đời sống con người,

thì những sản phẩm giải trí trên máy ngày càng có cơ hội để phát triển, đặc biệt là
những game mini như những game chơi cờ. Tuy nhiên yêu cầu đối với một game
hay cũng rất cao, đồ họa, xử lý sự kiện…Do đó viết game vừa là cơ hội vừa là
thách thức đối với người lập trình và đó cũng là một phương pháp tốt để hoàn
thiện kĩ năng lập trình của lập trình viên.
Hiện nay, có rất nhiều ngôn ngữ lập trình có thể dùng để viết game, Java
cũng là một trong những ngôn ngữ ấy, với kĩ thuật xử lí hình ảnh, âm thanh đã
được hỗ trợ sẵn, Java có đầy đủ sức mạnh để xây dựng một game hoàn hảo, đó
cũng chính là lí do để Java được chọn làm ngôn ngữ viết lên game được trình
bày trong đề tài này.
Game viết trong báo cáo cũng chỉ dừng ở mức tìm hiểu, chưa thể trở
thành một game thương mại, nhưng cũng giúp người đọc hiểu được những điều
cơ bản khi viết một game, và những hỗ trợ của Java đối với game.
Tuy rằng, lĩnh vực xây dựng trò chơi game không còn mới mẻ, nhưng
qua 9 kỳ học tập, nghiên cứu với mong muốn vận dụng kiến thức đã học vào
triển khai một đề tài thiết kế một trò chơi game; em đã lựa chọn đề tài tốt
nghiệp là: Áp dụng trí tuệ nhân tạo xây dựng các chương trình trò chơi bằng
ngôn ngữ lậ trình Java.

2


CHƯƠNG 1:
LÝ DO CHỌN ĐỀ TÀI
1.1. GIỚI THIỆU VỀ CÔNG NGHỆ TRI THỨC
1.1.1. Giới thiệu về tri thức
Tri thức là những hiểu biết được kiểm nghiệm. Tri thức là sức mạnh, tài
nguyên nó trở thành tiềm lực cạnh tranh. Hiện nay, trí tuệ nhân tạo đang trên đà phát
triển và đã đạt được những thành tựu rực rỡ đóng góp vào nền tảng của công nghệ
thông tin cũng như tạo ra các sản phẩm liên quan đến việc sử dụng công nghệ tri

thức trên máy tính. Trí tuệ nhân tạo và tạo dụng tri thức có mối quan hệ gắn bó mật
thiết với nhau hình thành lên một lĩnh vực mới đó là khoa học tri thức.
Tạo dụng tri thức là một tập hợp quá trình điều hành sự sáng tạo, phổ
biến và sử dụng tri thức để đạt được mục tiêu của mình.
Khoa học tri thức được chọn là một trong ba khoa học (cùng với khoa
học thông tin và khoa học vật liệu) được thiết lập và phát triển tại viện Khoa
Học và Công nghệ tiên tiến Nhật Bản viết tắt là JAIST. Mục tiêu chính của nó
là thúc đẩy sự phát triển của tạo dụng tri thức và tiến hành nghiên cứu liên qua
đến nền tảng cho một xã hội tri thức dựa trên sự kết hợp của khoa học quản lý,
khoa học hệ thống và khoa học thông tin.
Trong nhiều tình huống, sẽ không có sẵn tri thức do vậy: Kỹ sư tri thức
cần thu thập tri thức từ các chuyên gia lĩnh vực, cần hiểu biết các luật mô tả
lĩnh vực cụ thể.
Các hệ thống học được mô hình dưới dạng số liên quan đến các kỹ thuật
nhằm tối ưu các tham số. Học theo dạng số bao gồm mạng Neural nhân tạo, giải
thuật di truyền, bài toán tối ưu truyền thống. Các kỹ thuật học theo số không tạo
ra cơ sở tri thức tường minh.
Trí tuệ nhân tạo là một nhánh của khoa học và công nghệ liên quan đến
việc làm cho máy tính có năng lực của trí tuệ con người, tiêu biểu như các khả
năng “suy nghĩ”, “hiểu ngôn ngữ” và biết “học tập” của máy. Máy tính sinh ra
chủ yếu thực hiện việc tính toán, trí tuệ nhân tạo nhằm cho máy biết lập luận,
có “trí thông minh”.

3


Một thí dụ về sự đóng góp của trí tuệ nhân tạo trong các sản phẩm của
công nghệ thông tin là cuộc đọ trí của Deep Junior và Gary Karparov đầu năm
2003 sau chiến thắng của Deep Blue trước nhà vô địch cờ vua giữa năm 1997.
Bản chất của trí tuệ nhân tạo là làm sao đưa được tri thức con người vào

để máy hiểu được và cung cấp cho máy khả năng suy diễn khai thác tri thức
này.
Tạo ra và sử dụng tri thức là cốt tử trong mọi hoạt động kinh tế xã hội,
khoa học, quản lý… và liên quan chặt chẽ đến tiến bộ của khoa học công nghệ
đặc biệt là tiến bộ của công nghệ thông tin. Tạo dụng tri thức cần được tìm hiểu
một cách sâu rộng hơn.
1.1.2. Giới thiệu về lý thuyết trò chơi
John von Newmann là người đầu tiên hình thức ra lý thuyết trò chơi cho
đến đầu những năm 1970, lý thuyết trò chơi bắt đầu được áp dụng cho nghiên
cứu trong các ngành khoa học, từ Sinh học tới Triết học. Cuối cùng, lý thuyết trò
chơi gần đây đã thu hút được sự chú ý của các nhà Khoa học máy tính do ứng
dụng của nó trong trí tuệ nhân tạo và Điều khiển học.
Lý thuyết trò chơi là một nhánh của toán học ứng dụng, nghiên cứu các
tình huống chiến thuật trong đó các đối thủ lựa chọn các hành động khác nhau để
cố gắng làm tối đa các kết quả nhận được. Trong lý thuyết trò chơi có năm yếu tố
cơ sở: Người chơi (players), giá trị gia tăng (Added values), Quy tắc (Rules),
chiến thuật (Tacties), phạm vi (Scope). Năm yếu tố hợp thành PARTS như các
thành phần của cuộc chơi.
Các trò chơi game giải trí cũng áp dụng những chiến thuật cơ bản trong lý
thuyết trò chơi ví dụ các trò chơi đối kháng, một chương trình máy tính có thể
chơi các trò chơi đấu trí như các trò chơi cờ Vua, cờ Tướng, cờ Vây, go,
checker… các trò chơi này là các trò chơi đối kháng, diễn ra giữa hai đấu thủ
người chơi luôn mong muốn tới đích trước dành chiến thắng trong cuộc chơi
(ván chơi). Đặc điểm của trò chơi này là:
* Có hai đấu thủ, mỗi người chỉ đi một nước khi tới lượt.
* Các đấu thủ đều biết về tình trạng trận đấu.

4

* Trận đấu không kéo dài vô tận, phải diễn ra hoà, hoặc một bên thắng và
bên kia thua.
Thông thường ta hay gọi các trò chơi này là các loại cờ. Đôi khi ta còn
gọi là trò chơi MiniMax (dựa trên tên các thuật toán tìm kiếm cơ bản áp dụng cho
chúng)
1.2. GIỚI THIỆU VỀ GAME
1.2.1. Lịch sử cờ vây
Cờ vây là loại cờ cổ, được chơi cách đây khoảng 4000 năm bắt nguồn từ
nước Trung Hoa. Cờ vây ngày nay rất phổ biến ở vùng Đông Á. Nhật hiện nay là
nước có số người chơi cờ rất cao. Cờ vây đã tới Nhật từ thế kỷ thứ 7 và đến đầu
thế kỷ 13, nó được chơi rộng rãi khắp mọi nơi trên đất nước này. Sự phát triển
của Internet cũng đã làm cho nó phổ biến hơn trên khắp thế giới và đến nay đã có
36 triệu người yêu thích môn cờ này (thống kê của hiệp hội cờ Vây nghiệp dư thế
giới năm 1999).
Môn cờ vây cũng đã được người Việt Nam biết tới từ lâu, nhưng qua thời
gian, chiến tranh nên đã hầu như không còn ai biết cách chơi. Nó được phổ biến
lại tại Việt Nam vào năm 1993 nhân dịp có một giảng viên không chuyên từ
Trung Quốc sang giảng dạy giúp cho ngành thể dục thể thao Hà Nội.
Cờ vây có từ xa xưa, nhưng không hề bị biến đổi theo thời gian như các
trò chơi cổ khác. Lý do là luật chơi của cờ vây hết sức đơn giản, người nào cũng
có thể chơi được, không cần đến trí thông minh ưu việt. Trong cờ vây quân nào
cũng như quân nào, giá trị y hệt nhau, không quân nào có tên tuổi, không có vua,
có tướng. Cờ vây muốn biết chơi thì quá dễ, nhưng để chơi tới được thành “cao
cờ” thì rất khó.
1.2.2. Lịch sử trò chơi xếp hình
Nguồn gốc của trò chơi xếp hình (Jigsaw puzzle) phải quay về những năm
1790 khi các nhà làm bản đồ châu Âu dán các bản đồ trên gỗ và cắt chúng thành
những mảnh nhỏ (Dissected map) là một loại đồ chơi mang tính giáo dục thành
công nhất từng có. Trẻ em các nước vẫn còn học địa lý thông qua việc chơi với
bản đồ xếp hình của Hoa Kỳ hay thế giới. Các nghệ nhân sáng tạo trò chơi xếp

5


hình ở thế kỳ 17 hẳn sẽ vô cùng sửng sốt trước những biến đổi qua hơn 230 năm
qua. Các bộ xếp hình dành cho trẻ em từ các bài học đến giải trí, thể hiện nhiều
loại sự vật khác nhau như các con thú, thơ ca mẫu giáo (nursery ryhmes), các câu
truyện với những siêu anh hùng và Disney. Nhưng bất ngờ lớn nhất là sự ra đời
của bộ xếp hình dành cho cả người lớn vào những năm đầu thế kỷ 20.
Các mảnh ghép càng ngày càng được cắt chính xác trên những đường kẻ
màu không có các mảnh chuyển tiếp có hai màu đỏ ra đen, ví dụ như vùng màu
nâu (mái nhà) xếp gần những mảnh màu xanh (bầu trời) những năm tiếp theo
mang đến hai sự cách tân đáng kể chúng được cải tiến từ nguyên liệu ban đầu là
gỗ giá thành tương đối đắt sang nguyên liệu là bìa cứng cùng với đó là số lượng
các mảnh ghép ngày càng tăng.
Ngày nay, sự phát triển của internet góp phần làm cho trò chơi này được
phổ biến rộng rãi hơn và thu hút sự chú ý của mọi giới và mọi lứa tuổi.
Trò chơi xếp hình đòi hỏi sự kiên nhẫn, ráp nhanh hay chậm tuỳ thuộc vào
khả năng nhạy bén của mỗi người nhưng có một vài nguyên tắc chung giúp cho
việc ghép hình thuận lợi hơn là ráp các mảnh ngoài bìa trước, tìm chỗ nối tiếp
thông qua màu sắc, hình thái gom các mảnh cùng màu vào một chỗ.
1.2.3. Lý do chọn đề tài
Như chúng ta đã biết lý thuyết xây dựng game đặc biệt là các game chơi
cờ, xếp hình cần sử dụng nhiều thuật toán có độ khó cao, các kỹ thuật lập trình
game, lập trình giao diện, các chức năng đồ hoạ sử dụng trong game… Đề tài em
thực hiện áp dụng lý thuyết trò chơi, các thuật toán tìm kiếm có đối thủ, tìm kiếm
tối ưu: Thuật toán MiniMax, phương pháp cắt cụt alpha-beta, thuật toán A* trong
trí tuệ nhân tạo và các kỹ thuật lập trình game bằng ngôn ngữ lập trình Java.
Trong thời gian tìm hiểu và nghiên cứu, tiến hành xây dựng hoàn chỉnh game cờ
mini, trò chơi xếp hình em đã củng cố và bổ sung được nhiều kiến thức về trí tuệ

nhân tạo, công nghệ tri thức và lập trình hướng đối tượng với Java.
Những phân tích trên chính là lý do để em chọn đề tài này vì rất muốn sử
dụng khả năng đồ hoạ của Java để xây dựng chương trình game, muốn áp dụng
lý thuyết trò chơi, các thuật toán tìm kiếm trong trí tuệ nhân tạo để xây dựng

6


chương trình game chơi cờ, xếp hình. Các game này được đón nhận trong mọi
giới nó không mất quá nhiều thời gian và phù hợp với thời lượng làm đồ án.
Chương trình của em gồm ba chức năng cơ bản sau: Tạo một ván cờ mới.
Người chơi với máy ở các cấp độ khác nhau dễ, trung bình, khó. Hai người chơi
với nhau.
Chương trình xếp hình của em gồm có chức năng chọn hình, tự động xếp hình
Chương trình được thiết kế với bàn cờ là một ma trận n*n có hai loại
quân, mỗi loại quân lần lượt được chọn nước đi của mình và trạng thái trên bàn
cờ tương ứng với một nút trên cây trò chơi. Như vậy, tại mỗi lượt đi bạn phải tìm
một trạng thái tốt nhất. Cái tốt ở đây chính là do hàm đánh giá chỉ ra mà số lượng
trạng thái trên bàn cờ rất nhiều vậy không thể đi tất cả các nút được phải có cách
giảm đi số lượng các nút và thuật toán alpha-beta là câu trả lời.
Trò chơi xếp hình dựa trên cơ sở bài toán 8 số (bài toán Ta canh) sử dụng
thuật toán tối ưu trong trí tuệ nhân tạo để giải trong đó A* là lựa chọn tốt nhất
cho ta một kết quả như mong đợi với thời gian thực hiện chấp nhận được.

7


CHƯƠNG 2:
CƠ SỞ LÝ THUYẾT
2.1. GIỚI THIỆU VỀ JAVA [2]

2.1.1. Lịch sử phát triển
Java ra đời vào những năm 90 của thế kỉ 20, đầu tiên xuất hiện với cái tên
Oak trong một dự án nhằm xây dựng một phần mềm lập trình cho các mặt hàng
điện dân dụng với mục tiêu là nhỏ gọn và tương thích với nhiều thiết bị phần
cứng khác nhau. Lúc đầu sự xuất hiện của Java không gây được nhiều sự chú ý,
song đến năm 1993 khi hệ thống web thế giới ra đời, Java lúc đó đã khẳng định
là một công cụ lập trình hoàn hảo trên web. Từ đó đến nay Java không ngừng
phát triển và trở thành một công cụ lập trình đầy sức mạnh, đặc biệt là trong lĩnh
vực phát triển các ứng dụng internet, mà không hề thua kém bất cứ một ngôn ngữ
lập trình nào khác.
2.1.2. Các đặc điểm của Java
2.1.2.1. Đơn giản
Một trong những mục tiêu khi xây dựng Java là nhỏ gọn và đơn giản, Java
không cần một sự hướng dẫn đặc biệt hay kéo dài. Mặc dù để đi hết được các ngõ
ngách của Java cũng là một vấn đề khó với lập trình viên. Khá dễ viết, dễ biên
dịch. Mặt khác kích thước của Java nhìn chung là nhỏ gọn hơn hẳn VB hay
Visual C.
2.1.2.2. Hướng đối tượng
Java được thiết kế trên những ngôn ngữ hướng đối tượng mạnh, mọi ứng
dụng viết trên Java đều phải được xây dựng trên các đối tượng, và thông qua các
đối tượng, chúng ta không thể tạo ra hàm phổ dụng với Java như với C++.
Java không hỗ trợ đa kế thừa.
Một lớp trong Java bao gồm các vùng hay là các trạng thái của đối tượng,
các phương thức (method) là các chức năng của đối tượng dùng để trả lời các tác
động của các đối tượng khác.

8


Lớp trong Java có thể là lớp trừu tượng, là những lớp tập hợp những trạng

thái chung và các thông tin về ứng xử. Tuy vậy lớp dẫn xuất của nó hoàn toàn có
thể là những đối tượng thật.
2.1.2.3. Phân tán
Java được thiết kế để hỗ trợ các ứng dụng phân tán bằng các lớp mạng
thuộc gói java.net. Ngoài ra các lớp còn được chuẩn bị để thiết lập các kết nối ở
mức ổ cắm, nghĩa là chỉ cần cắm vào hay kết nối được là có thể chạy như trên
cùng một máy.
2.1.2.4. Thông dịch
Java là một ngôn ngữ thông dịch, Các ứng dụng Java có thể chạy trên các
nền phần cứng khác nhau, miễn là có bộ thông dịch, bộ gỡ rối, và thư viện thời
gian động. Khi đó các lập trình viên chỉ cần chú ý đến các thư viện module dùng
chung mà không còn cần lệ thuộc vào ngôn ngữ máy.
2.1.2.5. Mạnh mẽ
Có thể dùng Java để tạo nên các chương trình mạnh mẽ không mắc nhiều
lỗi khi chạy. Biến trong Java luôn phải khai báo một cách tường minh.
2.1.2.6. Bảo mật
Java được viết để chạy trên môi trường mạng phân tán, do đó nó phải có
tính bảo mật. Kĩ thuật xác minh của Java dựa trên cách mã hóa theo khóa công
khai.
Java không hỗ trợ biến con trỏ.
2.1.2.7. Kiến trúc trung tính
Khả năng thông dịch với nguồn mã lệnh đã được biên dịch dưới dạng
bytecode cho phép tạo ra các máy Java ảo (JVM- Java virtual machine) trên mỗi
hệ thống, các ứng dụng của Java sẽ chạy trên nền trung tính máy ảo đó.
2.1.2.8. Khả chuyển
Do có JVM như trên đã giới thiệu cho nên chỉ cần cài đặt để chương trình
chạy tốt trên máy ảo là có thể cài đặt và chạy trên mọi hệ thống.
Các kiểu dữ liệu của Java được định nghĩa không phụ thuộc vào bộ xử lý
hay vào hệ điều hành mà các ứng dụng được cài đặt.

9


2.1.2.9. Hiệu quả cao
Với tính năng giao diện đồ họa, sự đơn giản, nhỏ gọn, tính khả chuyển có
thể nói Java có tính hiệu quả hơn hẳn C/C++.
Chỉ có điều Java tương đối chậm so với những ngôn ngữ khác.
2.1.2.10. Đa tuyến
Java hỗ trợ tính năng đa tuyến, cho phép thực hiện nhiều tiến trình song
song, và tương hỗ với nhau tránh được tính tuần tự nhàm chán và những thời
gian chết trong khi chờ đợi.
2.1.2.11. Linh động
Vì dùng trình thông dịch nên Java là ngôn ngữ rất năng động. Trong khi
chạy môi trường Java có thể tự mở rộng để liên kết với các lớp mới có thể ở một
máy chủ ở xa trên mạng.
2.1.3. JDK – Java Development Kit - Bộ công cụ phát triển Java
Java được xây dựng chủ yếu trong bộ công cụ phát triển Java JDK như là
thư viện chuẩn. Trong đó chứa các trình thông dịch, biên dịch, giúp đỡ, soạn tài
liệu…Đó chính là cái nền phát triển các ứng dụng của Java.
JDK có các hàm giao diện AWT, thư viện dùng lại độc lập JavaBeans,
JFC…Java ngày càng phát triển làm cho kích thước của Java phình to hơn, tuy
nhiên tốc độ cũng được cải thiện hơn hẳn.
Có thể download bộ JDK từ trang web của nhóm JavaTeam:
/>Java cho phép người lập trình tạo ra các ứng dụng windows không thua
bất cứ một ngôn ngữ lập trình nào. Java cung cấp cho chúng ta thư viện AWT với
đầy đủ các đối tượng cần thiết như: nút nhấn, danh sách, ô văn bản, thanh
trượt…để lắp ghép và tạo nên một ứng dụng windows thường có. AWT được các
nhà thiết kế trừu tượng hóa ở mức cao, nó không phụ thuộc vào bất cứ hệ điều
hành nào sử dụng giao diện windows. Do đó, ta không cần phải lo lắng về cách
thức sử dụng các hàm API nữa, với AWT ta có thể thiết kế được giao diện với

các thành phần sau:

10


Nút nhấn

Button

Ô văn bản

TextField

Nhãn

Label

Vùng văn bản

TextArea

Trình đơn

Menu

Nút chọn

RadioButton

Ô đánh dấu

CheckBox

Khung vẽ

Canvas

Danh sách

List

Thanh trượt

ScrollBars

Lựa chọn

Choice

Khung cửa sổ

Frame

Sơ đồ kế thừa của các thành phần trong thư viện AWT
Component

Button

TextField

TextComponent

TextArea

Container

Panel

MenuComponent
nt

Windows

Applet

MenuBar

Menu

Frame

Checkbox

MenuItem

Dialog

2.1.4. Các đặc điểm cơ bản của các thành phần AWT
Để có thể sử dụng được các thành phần trong thư viện AWT cần phải:
- Khởi tạo nó bằng các phương thức khởi tạo, vd: public Button(String label).

11


- Gắn nó vào một đối tượng khung chứa cụ thể nào đó, có thể là một
Applet, Panel hay một Frame, bằng phương thức public void add(component cp).
- Gắn máy nghe sự kiện tương ứng cho nó, để tiếp nhận các tác động từ
người dùng và trả lời cho các tác động ấy.
2.1.5. Các thành phần của AWT được sử dụng
2.1.5.1. Khung chứa – Frame
Các khung chứa có thể đưa các đối tượng vào hoặc loại các đối tượng ra
bằng các phương thức:
- Public void add(component cp), public synchronized Component
add(Component cp).
- Public synchronized void remove(component cp), public synchronized
void removeAll().
Khung chứa quản lí việc lưu giữ các đối tượng, nó dùng để cất nhiều đối
tượng khác nhau, giống như ta lưu giữ các đối tượng trong một mảng, hay trong
một đối tượng vector. Mỗi đối tượng mà ta đưa vào khung chứa đều được cấp
một chỉ số index.
Frame là một trong những thành phần mạnh mẽ nhất của thư viện AWT.
Nó giúp tạo ra một cửa sổ hẳn hoi như các ứng dụng windows thường gặp. Có
thể nói một ứng dụng windows chỉ là một cửa sổ, trong đó chứa các thành phần
con khác như nút bấm, hình ảnh…Một cửa sổ như vậy được Java thể hiện qua
khung chứa Frame. Các ứng dụng windows độc lập thường lấy Frame làm nền.
a. Tạo đối tượng khung chứa Frame
Tạo đối tượng khung chứa Frame đơn giản bằng cách gọi phương thức
khởi dựng của nó: public Frame(), hoặc public Frame(String FrameTitle).
Thường các ứng dụng windows được xây dựng là các dẫn xuất của các
khung chứa để tiện cho việc quản lí các đối tượng và thực hiện các thao tác đồ

họa, xử lí ảnh…trên đó thông qua phương thức: public void paint(Graphics g) có
sẵn của các khung chứa.
Chương trình chơi cờ đặt tên là LPGAME là dẫn xuất của đối tượng
khung chứa Frame:

12


//tạo lớp chính là lớp dẫn xuất (lớp con) của Frame
Public class LPGAME extends Frame implements
ActionListener,MouseListener,Runnable,ItemListener{…}.
Lớp LPGAME là lớp chính cho nên ta tạo ra đối tượng Frame từ chính
hàm main() của lớp LPGAME:
//tạo Frame (cửa sổ) là đối tượng có tên là lp
LPGAME lp=new LPGAME();
b. Các đặc điểm của khung chứa Frame
Muốn cho một Frame hiện hữu ta phải định lại kích thước cho cửa sổ bằng
phương thức setSize(Dimension), trong đó đối tượng Dimension là một đối
tượng xác định kích thước về chiều rộng và chiều cao của đối tượng.
//xác định kích thước cho cửa sổ:
lp.setSize(new Dimension(500,600) );
Sau đó đưa cửa sổ ra màn hình.
//đưa cửa sổ ra màn hình
lp.setVisible(true);
Nếu muốn cho một Frame được phép thay đổi hoặc không thay đổi kích
cỡ ta dùng hàm: public void setResizable(boolean allow) .
//không cho phép thay đổi kích cỡ cửa sổ
lp.setResizable(false);
Có thể thay đổi biểu tượng nhỏ bên góc trái của cửa sổ bằng phương thức:
Public setImage(Image ig).

Thực ra khi cửa sổ được tạo ra Java không cung cấp sẵn cho nó khả năng
đóng lại mà chỉ có thể làm được điều ấy khi gắn bộ WindowListener vào nó, sẽ
được đề cập ở mục sau trong phần xử lí sự kiện.
Như các khung chứa khác ta có thể đưa các đối tượng cần sử dụng vào
trong Frame. Trong chương trình không sử dụng phương thức khởi tạo mà tạo
một hàm khởi tạo cho cửa sổ để có thể tạo một ván cờ mới nếu muốn. Trong hàm
khởi tạo các thành phần khác được đưa vào khung chứa.

13


Frame không chỉ có thể giữ các đối tượng khác, mà còn có thể cho phép
vẽ trên đó thông qua hàm: public void paint(Graphics g). Chi tiết về phần đồ họa
sẽ được đề cập trong phần sau.
Frame cũng cần được gắn các bộ lắng nghe sự kiện để tiếp nhận và trả lời
cho các tác động từ phía người dùng.
2.1.5.2. Trình đơn menu
a. Các thành phần của trình đơn
Trình đơn mà Java cung cấp sẽ gồm các đối tượng sau:
Thành phần

đối tượng Java

Thanh trình đơn

MenuBar

Trình đơn xổ xuống

Menu

Các mục chọn

MenuItem

Trình đơn con

Menu

Mục chọn có khả năng đánh dấu

CheckboxMenuItem

Dùng đối tượng MenuBar ta có thể tạo một thanh trình đơn và gắn nó vào
một cửa sổ ứng dụng bằng cách:
- Tạo một thanh trình đơn: MenuBar mb=new MenuBar();
- Gắn thanh trình đơn vào cửa sổ bằng phương thức
setMenuBar(MenuBar mb)
//Tạo và gắn MenuBar trong chương trình
MenuBar mb;
mb=new MenuBar();
setMenuBar(mb); //do MenuBar được gắn ngay trong hàm khởi tạo
Sau đó ta tạo ra các trình đơn và gắn nó vào trong thanh trình đơn.
//Tạo Menu file và gắn nó vào Menubar mb
Menu m,m1;
m=new Menu("file");
mb.add(m);

14

Sau khi có menu ta cần phải gắn các mục chọn (item) vào đó, một menu
phải có mục chọn thì mới có ý nghĩa. Ta có thể đưa mục chọn trực tiếp vào menu
hay tạo riêng rồi mới chọn:
- m.add(new MenuItem(“itemname”));
- MenuItem name=new MenuItem(“itemname”);
Mỗi mục chọn có thể ở trạng thái được chọn hoặc không.
//Tạo mục chọn và gắn vào menu
MenuItem it1;
it1=new MenuItem("* human");
m1=new Menu("* computer");
m.add(it1);
…
// đặt trạng thái được chọn hay không được chọn
it1.disable();
it2.enable();
Ta có thể thêm đường phân cách: m.addSeparator();
Tạo Menu con, và đưa Menu con vào Menu chính
//Tạo Menu con computer tạo các mục chọn cho nó và đưa vào Menu
chính
Menu m,m1;
MenuItem it2;
m1=new Menu("* computer");
m1.enable(true);
it2=new MenuItem("* easy");
m1.add(it2);
m.add(m1);
Tạo mục chọn có khả năng đánh dấu cũng tương tự như cách tạo mục
chọn, tuy nhiên mục chọn có khả nămg đánh dấu cho phép ta xác định trạng thái
được đánh dấu hay không của nó.

//Tạo mục chọn guider có khả năng đánh dấu

15


CheckboxMenuItem it3;
it3=new CheckboxMenuItem("* guider");
m.add(it3);
//Xác định trạng thái được chọn hay không
it3.getState() trả về giá trị boolean
b. Sử dụng trình đơn Menu
Để mỗi mục chọn tương tác và nhận được tình huống khi người dùng chọn
nó ta cần cài đặt giao tiếp ActionListener và gắn nó cho từng mục chọn.
//Cài đặt giao tiếp Actionlistener
public class LPGAME extends Frame implements
ActionListener,MouseListener,Runnable,ItemListener{..
public void actionPerformed(ActionEvent ev){…}
…}
2.1.6. Đối tượng đồ hoạ
2.1.6.1 Khái quát
Khi lập trình ứng dụng windows vấn đề nan giải là ta phải làm quen với
các hàm đồ họa API riêng của mỗi hệ. Trong khi đó môi trường internet là môi
trường toàn cầu, cần có những chương trình có thể chạy trên nhiều môi trường
khác nhau. Java ra đời giúp các nhà lập trình giải quyết vấn đề đó, với khả năng
viết một lần chạy khắp nơi.
Các hàm API mà JVM sẽ cung cấp cho chúng ta những chức năng đồ họa
thông thường nhất mà bất cứ hệ windows nào cũng phải có, mà không cần quan
tâm đến các hàm API riêng của mỗi hệ. Lớp thư viện AWT mà ta đã nghiên cứu
ở chương trước sẽ cung cấp các chức năng đồ họa ở mức độ thấp hơn: vẽ từng
đường thẳng, từng điểm ảnh…Tất cả các chức năng này được tập trung vào đối

tượng đồ họa Graphics và được thể hiện thông qua phương thức paint(Graphics
g).
2.1.6.2. Các phương thức paint(), repaint() và update()
Muốn vẽ một cái gì đó lên khung vẽ hay lên khung chứa thì cần phải cài
đặt phương thức: public void paint(Graphics g) {…}

16


Tất cả các hình ảnh được vẽ lên đều phải dùng đến đối tượng Graphics g, g
ở đây giống như một cây bút vẽ, nếu không có nó ta sẽ không thể vẽ được bất cứ
thứ gì.
Nhưng không nhất thiết phải gọi lại phương thức paint vì nó rất chậm, giải
pháp mỗi khi cần vẽ lại là dùng phương thức repaint() để vẽ lại toàn bộ, nếu chỉ
muốn vẽ lại một phần thì dùng phương thức:
Public void repaint(int x, int y, int width, int height): cho phép ta vẽ lại
một vùng có tọa độ góc trái là (x,y) và có chiều rộng là width, chiều cao là
height.
Phương thức repaint sẽ gọi phương thức update(), phương thức này sẽ
thực hiện một số thao tác như xóa sạch vùng cần vẽ lại, đặt mầu nền…Sau đó
chuyển giao đối tượng Graphics này cho hàm paint.
Thường phương thức repaint gây ra hiệu ứng giật màn hình do phải gọi lại
hàm update, do đó người ta có một cách để hạn chế việc màn hình bị giật là viết
đè hàm update trong đó gọi lại hàm paint:
//Chống giật màn hình
public void update(Graphics g){
paint(g);
}
2.1.6.3. Lớp Graphics
Lớp Graphics cung cấp cho ta một số phương thức để vẽ những hình đồ

họa cơ bản sau:
Đường thẳng

Lines

Vòng tròn, elip

Circle, Ellipes

Hình chữ nhật, đa giác

Rectangle, Polygon

Hình ảnh

Image

Văn bản với các font chữ khác nhau

Text và Font

17


Chú ý rằng hệ tọa độ ở đây ngược với hệ tọa độ thông thường, nếu vectơ
(x,y) bình thường gồm có x: hoành độ, y: tung độ. Thì hệ tọa độ khi ta vẽ là ngược
lại.
2.1.6.4. Một số phương thức vẽ được sử dụng trong chương trình
- Public void drawLine(int x1, int y1, int x2, int y2): cho phép ta vẽ một
đường thẳng nối hai điểm có tọa độ (x1,y1), (x2,y2).

Trong chương trình phương thức này dùng để vẽ bàn cờ:
//vẽ bàn cờ bằng phương thức drawLine
for(i=1;i<=9;i++)
{
g.setColor(Color.blue);
g.drawLine(50,i*50,450,i*50);
g.drawLine(i*50,50,i*50,450);
}
- Public void drawOval(int x, int y, int width, int height): vẽ hình elip nằm
trọn trong một hình chữ nhật có tọa độ góc trái trên cùng là (x,y), và có chiều dài,
rộng lần lượt là height và width.

- Public void filloval(int x, int y, int width, int height): tương tự cũng để
vẽ một hình elip, nhưng hàm bên trên để vẽ “đường”, còn hàm này dùng để tô
màu cho hình elip.
Trong chương trình các hàm fillOval dùng để vẽ các ô được phép đi nhằm
trợ giúp người chơi.
//vẽ các ô được phép đi
if(sp&&b[i][j]==6&&b[x][y]==1)
{g.setColor(Color.yellow);g.fillOval(i*50+15,j*50+15,20,20); }

18


else
if(sp&&b[i][j]==7&&b[x][y]==2)
{g.setColor(Color.blue);g.fillOval(i*50+15,j*50+15,20,20);}
- Public void draw3Drect(int x, int y, int width, int height, boolean raised):
vẽ hình chữ nhật 3D, các thông số x, y, width, height tương tự. còn raised là giá
trị kiểu boolean cho phép đối tượng nổi lên.

Hình chữ nhật được dùng trong chương trình để vẽ khung ghi nhận điểm:
//khung điểm
g.setColor(Color.black);
g.fillRect(0,0,500,600);
- Public void drawString(String t,int x, int y): vẽ ra dòng văn bản t bắt đầu
từ tọa độ (x,y).
2.1.6.5. Nạp và vẽ ảnh
Người ta dùng phương thức: public void drawImage(Image ig, int x, int y,
ImageObserver ob), hoặc: public void drawImage(Image ig, int x, int y, int
width, int heigth, ImageObserver ob)… Để vẽ ảnh vào trong ứng dụng.
Tuy nhiên, để vẽ được ảnh cần phải chỉ ra được đường dẫn tới file ảnh cần
vẽ. Do đó để vẽ ảnh trong một ứng dụng độc lập ta có cách nạp ảnh là sử dụng
phương thức getImage của đối tượng Toolkit.
Toolkit là một đối tượng dùng để lấy hay xử lí tài nguyên ở máy cục bộ,
vd:
Image ig;
ig= getToolkit().getImage(“tên file ảnh”);
//nạp ảnh
Image ig1;
Image ig2;
ig1=getToolkit().getImage("egg1.jpg");
ig2=getToolkit().getImage("egg2.jpg");
//dùng hàm vẽ ảnh để vẽ các quân cờ
for(i=1;i<=8;i++)

19


for(j=1;j<=8;j++)
if(b[i][j]==1) {g.drawImage(ig1,i*50+5,j*50+5,40,40,this);}

else
if(b[i][j]==2) {g.drawImage(ig2,i*50+5,j*50+5,40,40,this);}
Đối tượng ImageObserver là đối tượng theo dõi quá trình nạp ảnh, theo
dõi quá trình nạp ảnh vào bộ nhớ. Khi ta nạp ảnh đều cần phải có đối tượng này.
Mọi thành phần của AWT đều được cài đặt giao tiếp ImageObserver nên ta có
thể coi các thành phần AWT là các đối tượng ImageObserver để sử dụng cho
phương thức drawImage.
2.1.7. Xử lý sự kiện
2.1.7.1. Khái quát
Đối tượng nào sản sinh ra sự kiện gọi là nơi phát sinh sự kiện, đối tượng
nào tiếp nhận và xử lý các sự kiện được phát sinh ra được gọi là đối tượng
listener.
Ví dụ như khi ta nhấn một nút nhấn là ta đã sinh ra một sự kiện, việc còn
lại sau đó là phải “trả lời” các sự kiện đó như thế nào?
Khi tạo một ứng dụng cửa sổ thì các thành phần của cửa sổ phải có khả
năng tiếp nhận sự kiện do người dùng tác động và sau đó chương trình sẽ có
những hành động để trả lời cho những tác động đó. Vì vậy các thành phần AWT
cần được gắn với các Listener tương ứng. Java đã thiết kế sẵn các đối tượng
listener như sau:

20


ComponentListener

Nhận biết các sự kiện khi đối tượng bị
thay đổi kích thước, di chuyển, hiện
ra, dấu đi.

FocusListener

Nhận biết sự kiện Focus (luôn dành
được nhiều quyền ưu tiên nhất)

KeyListener

Sự kiện xuất hiện từ bàn phím

MouseListener

Nhận biết các sự kiện nhấn, kích
chuột

MouseMotionListener

Nhận biết các sự kiện di chuyển chuột

WindowListener

Nhận biết sự kiện một cửa sổ được
đóng lại, mở ra, thu nhỏ…

ActionListener

Nhận biết sự kiện mà đối tượng phải
thực thi một tác vụ nào đó

AdjustmentListener

Nhận biết sự kiện mà đối tượng thay

đổi giá trị

ItemListener

Nhận biết một sự kiện mà một đối
tượng thay đổi trạng thái

Có hai cách để tạo đối tượng listener để có thể tiếp nhận sự kiện mà hệ
thống đem đến:
- Tạo một đối tượng listener riêng biệt, sau đó các thành phần sẽ đăng ký
với hệ thống đối tượng listener này.
- Chính bản thân các lớp chứa các thành phần sẽ cài đặt cho các giao tiếp
listener này và đăng kí với hệ thống thông qua biến this.
Ví dụ cách 1:
Public class vd extends Panel{
addMouseListener(new myListener);
}
Class myListener implements MouseListener{

21


Public void mouseClicked(MouseEvent ev) {} …}
Ví dụ cách 2:
Public class vd extends Panel implements MouseListener{
Public void mouseClicked(MouseEvent ev) {}
…}
2.7.1.2. MouseListener
MouseListener là listener nhận biết sự kiện nhấn hay kích chuột. Bất cứ
một listener nào cũng là một interface (giao tiếp) do đó muốn cài đặt nó thì bắt

buộc phải hiện thực hóa cho nó.
Lớp MouseListener có các hàm như sau:

Public void mouseClicked(MouseEvent ev)

Xử lý sự kiện kích chuột

Public voidmousePressed(MouseEvent ev)

Xử lý sự kiện nhấn chuột

Public void mouseExited(MouseEvent ev)

Xử lý sự kiện con trỏ thoát khỏi
cửa sổ

Public void mouseEntered(MouseEvent ev)

Xử lý sự kiện con trỏ di chuyển
vào cửa sổ

Public void mouseReleased(MouseEvent ev)

Xử lý sự kiện người dùng thôi
không kích hay nhấn chuột nữa

//Xử lý sự kiện nhấn chuột
public void mousePressed(MouseEvent ev){
sp=true;
repaint();

}
//Xử lý sự kiện thôi không nhấn chuột nữa
public void mouseReleased(MouseEvent ev){
sp=false;
repaint();
}

22


Vì MouseListener là một giao tiếp do đó ta bắt buộc phải cài hết các hàm
của nó mặc dù không dùng khi tiến hành hiện thực hóa cho nó. Trong chương
trình sự kiện kích chuột dùng để nắm bắt và xử lý các tọa độ mà người chơi chọn
nước đi trên bàn cờ, đó cũng là tình huống để kiểm tra và xử lý tính hợp lệ của
nước đi.
Sự kiện nhấn chuột là để dành cho việc trợ giúp người chơi nhận biết được
các nước đi có thể có của mình. Khi biến sp=true, hàm paint() sẽ vẽ ra các hình
tròn có màu tương ứng tại các ô có thể đi của người chơi. Khi người chơi thôi
không nhấn chuột nữa thì hàm paint() cũng sẽ thôi không vẽ những chỉ dẫn đó
nữa.
2.7.1.3. ActionListener
Là Listener nhận biết các sự kiện mà đối tượng sẽ phải thực thi một số tác
vụ nào đó. ActionListener được gắn cho các đối tượng như nút bấm, mục chọn, ô
văn bản…Listener này có phương thức:
public void actionPerformed(ActionEvent ev){}: để xử lý các sự kiện.
Cài đặt giao tiếp ActionListener trong chương trình nhằm xử lý các tình
huống khi người chơi chọn các mục chọn trong menu:
//Xử lý các sự kiện liên quan đến ActionListener
public void actionPerformed(ActionEvent ev){
if(ev.getSource()==it1) {

choose=true;
m1.disable();
…}
2.1.8. WindowListener
Là listener nhận biết các sự kiện cửa sổ bị đóng lại, thu nhỏ…Nó có một
lớp trừu tượng hiện thực hóa nó là lớp WindowAdapter, thường các Listener vẫn
có các lớp Adapter với mục đích là khi ta chỉ cần cài đặt một vài phương thức
của giao tiếp ta không cần cài đặt các phương thức còn lại.
WindowListener cho phép ta nhận biết tình huống khi ta nhấn vào nút
đóng cửa sổ, thu nhỏ…Thường được dùng để đóng cửa sổ lại:

23


LPGAME lp=new LPGAME();
lp.addWindowListener(new WindowAdapter(){
public void windowClosing(WindowEvent ev){
System.exit(0);
}
}
);
2.1.9. Phân tuyến và đa tuyến
2.1.9.1. Khái quát
Một trong những đặc điểm của Java là tích hợp khả năng đa tuyến.
Thread là một đơn vị hành động của hệ điều hành, một chương trình có thể
bị chia nhỏ thành nhiều Thread. Khi thực hiện đa nhiệm hệ điều hành cho mỗi
chương trình một tiến trình, trên đó lại chia thành các Thread. Các Thread trong
mỗi tiến trình sẽ được thực hiện một cách tuần tự, nhưng là luân phiên giữa các
chương trình.
Khái niệm về Thread trong Java là tương tự như trong hệ điều hành.

Trong một chương trình có nhiều Thread các Thread hoạt động gần như đồng
thời với nhau và giao tiếp với nhau qua các interface hay đồng bộ hóa.
2.1.9.2. Tạo và sử dụng Thread
Có hai cách tạo Thread:
-

Tạo lớp con từ lớp Thread của Java

-

Cài đặt giao tiếp Runnable

Khi cài đặt giao tiếp Runnable ta phải cài đặt phương thức run() là phương
thức mà thực hiện tất cả các việc phải làm của từng Thread.
Sau đó ta khai báo Thread như một vùng dữ liệu của lớp.
Khởi tạo đối tượng Thread và cho thực hiện bằng phương thức start().
Chấm dứt một Thread bằng phương thức stop().
//Hiện thực hóa giao tiếp runnable
Public class LPGAME extends Frame implements
ActionListener,MouseListener,Runnable,ItemListener{}

24