Xây dựng giao diện máy rút tiền ATM - Niên luận cơ sở môn Công nghệ thông tin | Trường Đại học Kiên Giang

lOMoAR cPSD| 58736390
TRƯỜNG ĐẠI HỌC KIÊN GIANG
KHOA THÔNG TIN & TRUYỀN THÔNG
( cỡ chữ 14) NGUYỀN PHẠM HOÀNG HUY
MÃ SỐ SINH VIÊN: 241020062065
( cỡ chữ 14)
XÂY DỰNG GIAO DIỆN MÁY RÚT TIỀN ATM CỠ CHỮ 22-24) NIÊN LUẬN CƠ SỞ
( cỡ chữ 16)
NGÀNH: CÔNG NGHỆ THÔNG TIN (MÃ SỐ: 7480201)
GIẢNG VIÊN HƯỚNG DẪN: ThS. Nguyễn Nhựt Quỳnh
( cỡ chữ 14, in đậm )
Kiên Giang – tháng …. năm 2024 LỜI CẢM ƠN
Em xin chân thành cảm ơn Ban Giám hiệu trường Đại học Kiên Giang cùng quý thầy cô
Khoa Thông tin và Truyền thông đã tạo điều kiện thuận lợi về cơ sở vật chất cũng như môi
trường học tập để em có thể hoàn thành tốt bài báo. Đặc biệt, em xin bày tỏ lòng biết ơn
sâu sắc đến cô Nguyễn Nhựt Quỳnh, người đã tận tình chỉ dẫn, góp ý, định hướng cho em
trong suốt quá trình thực hiện đề tài, giúp em hoàn thiện kiến thức chuyên môn cũng như
rèn luyện kỹ năng thực hành. Bên cạnh đó, em cũng xin gửi lời cảm ơn chân thành đến gia
đình và bạn bè đã luôn động viên, hỗ trợ tinh thần và tạo điều kiện tốt nhất để em tập trung
học tập và nghiên cứu. Mặc dù đã rất cố gắng, nhưng do kiến thức và kinh nghiệm còn hạn
chế, bài niên luận không tránh khỏi những thiếu sót. Em rất mong nhận được sự góp ý của
quý thầy cô để em có thể hoàn thiện bản thân hơn trong tương lai. Một lần nữa, em xin chân thành cảm ơn.
Kiên Giang, ngày.....tháng.....năm 2024
Sinh viên thực hiện
(Ký và ghi rõ họ tên) LỜI CAM ĐOAN
Tôi cam đoan rằng đề tài này là do chính tôi thực hiện, các số liệu thu thập và kết
quả phân tích trong đề tài là trung thực, không sao chép hay đánh cắp ý tưởng từ một ai.
Kiên Giang, ngày.....tháng.....năm 2024
Sinh viên thực hiện
(Ký và ghi rõ họ tên)
NHẬN XÉT CỦA GIẢNG VIÊN HƯỚNG DẪN
........................................................................................................................................................................................
........................................................................................................................................................................................
........................................................................................................................................................................................
........................................................................................................................................................................................
........................................................................................................................................................................................
........................................................................................................................................................................................
........................................................................................................................................................................................
........................................................................................................................................................................................
........................................................................................................................................................................................
........................................................................................................................................................................................
........................................................................................................................................................................................
........................................................................................................................................................................................
........................................................................................................................................................................................
........................................................................................................................................................................................
........................................................................................................................................................................................
........................................................................................................................................................................................
...................., ngày….. tháng.…. năm......
GIẢNG VIÊN HƯỚNG DẪN MỤC LỤC
CHƯƠNG 1. TỔNG QUAN ĐỀ TÀI
1.1 Lý do chọn đề tài.......................................................................................1
1.2 Mục tiêu thiết kế........................................................................................1
1.3 Đối tượng và phạm vi nghiên cứu.............................................................2
1.4 Phương pháp nghiên cứu...........................................................................2
CHƯƠNG 2. CƠ SỞ LÝ THUYẾT
2.1 Ngôn ngữ lập trình Java............................................................................3
2.2 Lập trình hướng đối tượng........................................................................3 2.3 Thư
viện.....................................................................................................4
.........................................................................................................................
2.3.1 Thư viện AWT...................................................................................4
2.3.2 Thư viện Java Swing..........................................................................4
2.3.3 Layout Manager.................................................................................4
CHƯƠNG 3. PHÂN TÍCH VÀ THIẾT KẾ HỆ THỐNG
3.1 Mục tiêu cần phân tích và thiết kế hệ thống..............................................5
3.2 Sơ đồ hệ thống...........................................................................................5
CHƯƠNG 4. CHƯƠNG TRÌNH ỨNG DỤNG
4.1 Thiết kế khung (Frame) và giao diện đăng nhập........................................7
4.1.1 Thiết kế khung.....................................................................................7
4.1.2 Thiết kế giao diện đăng nhập...............................................................8
4.1.2.1 Tạo màn hình hiển thị..................................................................8
4.1.2.2 Thiết kế bàn phím số....................................................................9
4.1.2.3 Thiết kế chỗ nhập ID card...........................................................10
4.1.2.4 Thiết kế các nút thao tác..............................................................12
4.1.2.5 Tổng kết của class log.................................................................17
4.2 Thiết kế class home...................................................................................17
4.2.1 Thiết kế nút và hành động các nút......................................................17
4.2.1.1 Thiết kế các nút...........................................................................17
4.2.1.2 Thêm hành động cho các nút.......................................................18
4.2.1.3 Tổng kết giao diện có được.........................................................20
4.3 Thiết kế các chức năng..............................................................................21
4.3.1 Chức năng rút tiền..............................................................................21
4.3.1.1 Thiết kế giao diện hiển thị...........................................................21
4.3.1.2 Thiết lập hành động cho giao diện..............................................21
4.3.1.3 Thêm ảnh tờ tiền vào trong giao diện..........................................25
4.3.1.4 Tổng kết giao diện thực hiện rút tiền...........................................25
4.3.2 Thiết kế giao diện chuyển tiền (class GDChuyen).............................26
4.3.2.1 Thiết kế giao diện........................................................................27
4.3.2.2 Thiết lập hành động cho giao diện..............................................28
4.3.2.3 Tổng kết giao diện chuyển..........................................................30
4.4 Các chức năng khác...................................................................................30
4.5 Thiết kế giao diện trở nên bắt mắt.............................................................31
CHƯƠNG 5. KẾT LUẬN VÀ HƯỚNG PHÁT TRIỂN
5.1 Kết luận.....................................................................................................31 Chương 1. TỔNG QUAN ĐỀ TÀI
1.1 Lý do chọn đề tài: “Thiết kế giao diện máy rút tiền ATM”.
Trong thời đại công nghệ phát triển mạnh mẽ, các hệ thống tự động ngày càng trở
nên phổ biến và đóng vai trò quan trọng trong đời sống hiện đại. Trong đó, máy rút tiền
ATM là một công cụ không thể thiếu, giúp người dùng thực hiện các giao dịch tài chính
một cách nhanh chóng và thuận tiện. Với các chức năng như rút tiền, chuyển khoản, đổi
mã PIN,... máy ATM ngày càng trở nên gần gũi và thiết yếu với mọi người.
Đối với sinh viên ngành Công nghệ Thông tin, việc xây dựng giao diện cho máy
ATM bằng ngôn ngữ lập trình Java không chỉ giúp củng cố kiến thức lập trình hướng đối
tượng và xử lý giao diện đồ họa, mà còn rèn luyện tư duy thiết kế phần mềm thân thiện
với người dùng. Đồng thời, đề tài còn tạo cơ hội để tìm hiểu về xử lý dữ liệu, mô phỏng
thực tế và các vấn đề như bảo mật, lưu trữ thông tin, quản lý tài khoản – những kỹ năng
quan trọng trong phát triển phần mềm tài chính.
Vì những lý do trên, em quyết định chọn đề tài “Xây dựng giao diện máy rút tiền
ATM” bằng ngôn ngữ lập trình Java để thực hiện bài báo cáo, với mong muốn vận dụng
kiến thức đã học vào một sản phẩm thực tiễn, có tính ứng dụng và sát với nhu cầu xã hội hiện nay.
1.2 Mục tiêu thiết kế. -
Xây dựng một mô hình giao diện phần mềm mô phỏng hoạt động cơ bản củamáy rút tiền ATM. -
Thiết kế giao diện thân thiện với người dùng, dễ thao tác, mô phỏng các chức
năng cơ bản như: đăng nhập, hiển thị số dư, rút tiền, chuyển tiền, nạp tiền, đổi mã PIN. -
Áp dụng kiến thức lập trình Java, đặc biệt là Java Swing, để thiết kế giao
diện đồ họa và xử lý các sự kiện người dùng. -
Rèn luyện kỹ năng thiết kế phần mềm mô phỏng, tổ chức dữ liệu và tư duy hệthống.
1.3 Đối tượng và phạm vi nghiên cứu. -
Đối tượng nghiên cứu: Giao diện người dùng và quy trình xử lý các chức
năng cơ bản của máy rút tiền ATM trong môi trường phần mềm. - Phạm vi nghiên cứu:
+ Tập trung thiết kế và xây dựng giao diện người dùng bằng ngôn ngữ Java, sử
dụng thư viện Java Swing để tạo các cửa sổ và thành phần giao diện.
+ Mô phỏng các chức năng chính của máy ATM bao gồm: đăng nhập, rút tiền,
nạp tiền, chuyển tiền, đổi mã PIN, xem số dư.
+ Dữ liệu tài khoản, giao dịch được xử lý và lưu trữ tạm thời trong bộ nhớ chương
trình (thông qua biến, đối tượng Java), không sử dụng file hoặc cơ sở dữ liệu.
+ Không đi sâu vào các yếu tố bảo mật nâng cao, kết nối mạng, hoặc tích hợp với hệ thống thực tế.
1.4 Phương pháp nghiên cứu.
Phân tích – tổng hợp: Thu thập, phân tích, tham khảo các tài liệu liên quan đến
giao diện ATM, từ đó tổng hợp yêu cầu và chức năng cần thiết để xây dựng mô hình phần mềm phù hợp.
Phương pháp mô phỏng và thiết kế : Sử dụng các công cụ, ứng dụng vẽ để tạo ra
một giao diện cơ bản mô phỏng, từ đó làm cơ sở cho sau này cho việc triển khai.
Phương pháp thực hành – thử nghiệm: Triển khai trực tiếp bằng ngôn ngữ Java,
sử dụng thư viện Java Swing để thiết kế giao diện người dùng, đồng thời kiểm tra, chạy
thử để đánh giá tính đúng đắn và thân thiện của chương trình.
Chương 2 CƠ SỞ LÝ THUYẾT
2.1 Ngôn ngữ lập trình Java
Java Virtual Machine Java là ngôn ngữ lập tình hướng đối tượng (tựa C++) do Sun
Microsystem đưa ra vào giữa thập niên 90. Java có khả năng chạy đa nền tảng nhờ vào
máy ảo Java. Java hỗ trợ mạnh mẽ cho lập trình hướng đối tượng thông qua các thư viện như AWT và Swing.
Trong bài thiết kế giao diện máy rút tiền ATM sử dụng hình thức ứng dụng: Desktop
Application - J2SE hỗ trợ phát triển những ứng dụng đơn, ứng dụng client server do Java cung cấp.
2.2 Hướng đối tượng
Lập trình hướng đối tượng là một phương pháp tổ chức chương trình bằng cách mô
hình hóa các thực thể trong thế giới thực dưới dạng đối tượng. Mỗi đối tượng bao gồm
thuộc tính (dữ liệu) và phương thức (hành vi). OOP giúp chương trình trở nên linh hoạt,
dễ bảo trì và mở rộng.
- Một số đặc điểm chính của OOP gồm:
+ Tính đóng gói (Encapsulation):
Dữ liệu và các phương thức xử lý dữ liệu được gói gọn bên trong lớp. Việc sử dụng các
tiền tố như private để giới hạn quyền truy cập và public để cho phép truy cập thông qua
các phương thức là một phần của tính đóng gói. Điều này giúp bảo vệ dữ liệu, ngăn can
thiệp trái phép từ bên ngoài.
+ Tính kế thừa (Inheritance):
Cho phép tạo ra lớp con kế thừa các thuộc tính và phương thức của lớp cha, thông qua từ
khóa “extends”, giúp tái sử dụng mã nguồn và mở rộng chương trình.
+ Tính đa hình (Polymorphism):
Cho phép các đối tượng có thể xử lý các tác vụ giống nhau theo những cách khác nhau,
nhờ việc ghi đè phương thức (@Override).
+ Tính trừu tượng (Abstraction):
Che giấu chi tiết cài đặt nội bộ, chỉ cung cấp cho người dùng những gì cần thiết để sử dụng
lớp hoặc đối tượng như xử lí khi rút tiền, chuyển tiền… 2.3 Thư viện 2.3.1 Thư viện AWT -
Thư viện AWT cung cấp cho người lập trình các thành phần như
Frame,Button, TextField, Label…giống như thư viện Swing. Tuy nhiên, so với Swing,
AWT có giao diện đơn giản hơn, khả năng tùy biến thấp hơn và phụ thuộc vào hệ điều
hành, do đó hiện nay AWT thường ít được sử dụng. Trong đề tài này, thư viện Swing được
ưu tiên vì tính hiện đại và linh hoạt hơn AWT. -
Ngoài ra, thư viện AWT còn hỗ trợ xử lí sự kiện thông qua các thành phầnnhư
ActionListener, ActionEvent, KeyListener, KeyEvent,…và hỗ trợ chèn ảnh vào giao diện thông qua lớp Image.
2.3.2 Thư viện Java Swing
- So với AWT, thư viện Swing cung cấp nhiều giao diện phong phú hơn, tùy cơ ứng
biến linh hoạt trong nhiều trường hợp khác nhau và hoạt động nhất quán trong mọi hệ điều
hành. Cung cấp các thành phần đồ họa (GUI) giúp người lập trình dễ dàng triển khai và
thực hiện ý tưởng, một số thành phần như:
+ JFame: tạo ra một của sổ giao diện chính của ứng dụng.
+ JButton: Tạo ra một nút bấm ứng dụng, thực hiện các thao tác.
+ JTextField: Cung cấp cho lập trình viên một vùng nhập và lấy dữ liệu từ bàn phím trong phạm vi một dòng.
+ JLabel: Tạo ra một nhãn, hiển thị cho người dùng thông tin và nhãn này không thể thay đổi nội dung.
+ JPanel: Tạo ra một bảng trong JFame, có thể thêm các thành phần khác.
+ Còn một số thành phần khác như JTable, JTextArea,…. 2.3.3 Layout Manager
Layout Manager là khung chứa container nhận các đối tượng và tổ chức sắp xếp
cho các đối tượng tham gia. Trong bài thiết kế giao diện máy rút tiền ATM sử dụng kiểu
Layout Manager là Null Layout giúp cho người lập trình tự do trình bày, tự định kích
thước, xác định vị trí xuất hiện trên màng hình của các thành phần.
Chương 3 PHÂN TÍCH VÀ THIẾT KẾ HỆ THỐNG
3.1 Mục tiêu cần phân tích và thiết kế hệ thống
Tạo ra cái nhìn trực quan hơn về cách thức tổ chức của các lớp và các thành phần
cũng như các phần tử tham gia vào một lớp, giúp việc viết chương trình dễ nhìn, dễ quản
lí hơn, cũng như dễ sửa chữa khi gặp sự cố.
3.2 Sơ đồ hệ thống:
- Ý nghĩa sơ đồ hệ thống:
+ Thư mục Src là nơi chứa toàn bộ mã nguồn của chương trình. Bên trong
src, file App.java là nơi khởi động chính (có hàm main) và chịu trách nhiệm gọi đến
Khung.java – lớp khung nền chính cho toàn bộ giao diện của ứng dụng.
+ Lớp Khung.java kế thừa từ JFrame và chỉ sử dụng một cửa sổ giao diện duy
nhất trong suốt quá trình hoạt động của chương trình. Thay vì tạo nhiều JFrame, lớp
này thực hiện việc xóa và thêm lại các thành phần giao diện (JPanel, Component)
để thay đổi nội dung hiển thị, giúp giao diện thống nhất và dễ quản lý.
+ Từ lớp khung, chương trình gọi đến lớp log.java – giao diện đăng nhập
người dùng. Để xử lý đăng nhập, lớp Log cần sử dụng lớp TaiKhoan.java, nơi lưu
trữ thông tin tài khoản (tên đăng nhập, mật khẩu) và thực hiện các kiểm tra xác thực.
Ngoài ra, TaiKhoan.java cũng được sử dụng bởi các lớp khác để hỗ trợ xử lý logic
như truy vấn số dư, cập nhật giao dịch,…
+ Sau khi đăng nhập thành công, chương trình chuyển đến giao diện
home.java, nơi hiển thị các lựa chọn chức năng chính. Trong lớp Home, các JButton
đại diện cho các chức năng như: rút tiền (GDRutTien.java), nạp tiền
(GDNap.java), chuyển tiền (GDChuyen.java), xem thông tin (ThongTin.java). Các
nút này được gắn sự kiện và khi người dùng tương tác, chương trình sẽ gọi đến giao
diện tương ứng để xử lý.
+ Mỗi một giao diện chức năng khác nhau sẽ được thiết kế trong một class
khác nhau, mỗi class đều có một cấu trúc riêng nhưng chủ yếu bao gồm 1 phương
thức khởi tạo giao diện, một phương thức thêm hành động cho giao diện đó và một
contructor gọi các phương thức để hoạt động.
Chương 4 CHƯƠNG TRÌNH ỨNG DỤNG
4.1 Thiết kế khung (Frame) và giao diện đăng nhập.
4.1.1 Thiết kế khung:
- Trong file “khung.java” được thiết kế :
+ File class khung được kế thừa từ lớp cha là JFrame và thêm một số điều chỉnh
như tiêu đề là “Thiết kế giao diện máy rút tiền ATM”, kích thước của khung có chiều cao
là 700 cùng với chiều rộng là 800, khung được căn giữa màng hình khi chạy thông qua
dòng lệnh “setLocationRelativeTo(null)”, và
“setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE)” có nghĩa là khi người dùng nhấn
nút [X] để đóng cửa sổ, chương trình sẽ thoát hoàn toàn. Song song đó file class App.java
được triển khai như sau :
+ Điều này có nghĩa là trong quá
trình chạy trương trình thì Frame chính
luôn giữ nguyên không thêm một Frame
nào khác, sau khi chạy chương trình thì ta
được một cửa sổ (hình bên).
+ Ở dòng thứ 10 của class khung ta đã
thêm đối tượng log.java thông qua dòng
lệnh “add(new log())”, đây sẽ là nơi chứa giao diện đăng nhập.
4.1.2 Thiết kế giao diện đăng nhập.
- File class log.java được kế thừa từ lớp cha là JPanel chứa giao diện đăng nhập được thiết kế gồm:
+ Màng hình hiển thị số vừa nhập. + Bàn phím số. + Nơi nhập ID card.
+ Bảng điều khiển gồm các phím xóa tất cả (clear), xóa một kí tự (Delete), và tiến hành đăng nhập (enter).
4.1.2.1 Tạo màng hình hiển thị
- Trong file class được kế thừa từ lớp cha là JPanel ta khai báo một biến thành
viên “private JTextField display” với phạm vi là private, và khai báo phương thức
initDisplay để thiết lập một bảng hiển thị:
+ Trong giao diện, ô hiển thị mật khẩu (display) được khai báo với kiểu JTextField
— là một thành phần của thư viện Swing hỗ trợ nhập liệu trên một dòng. Vị trí và kích
thước của nó được thiết lập trực tiếp trên giao diện với tọa độ x = 100, y = 200, chiều rộng
bằng 260 và chiều cao bằng 50.
+ Do ứng dụng sử dụng bàn phím số ảo được tạo bằng các nút JButton, nên dòng
lệnh display.setEditable(false) được sử dụng để ngăn người dùng sử dụng bàn phím vật lý,
chỉ cho phép nhập thông qua các nút bấm.
+ Để đảm bảo hiển thị các ký tự từ phải sang trái, mô phỏng cách nhập mã PIN
trên máy ATM, dòng display.setHorizontalAlignment(JTextField.RIGHT) được dùng để
căn lề phải cho nội dung bên trong JTextField.
+ Cuối cùng, để hiển thị phần
này trên giao diện chính, phương thức
initDisplay() được gọi trong
constructor của lớp log.
4.1.2.2 Thiết kế bàn phím số
- Tạo phương thức định nghĩa addNumberButton:
+ Trong giao diện, các nút số (0–9) được tạo tự động bằng phương thức
addNumberButton(String number, int x, int y). Phương thức này nhận vào giá trị số sẽ hiển
thị trên nút (ví dụ "1", "2",...) cùng với tọa độ xuất hiện trên giao diện.
+ Bên trong phương thức, mỗi nút được khởi tạo bằng JButton, thiết lập nhãn bằng
tham số number. Kích thước nút được cố định là 60x60 pixel, đặt tại vị trí (x, y) tương ứng
trên giao diện. Màu nền của nút được đặt là trắng (Color.WHITE) để tạo sự rõ ràng và nổi bật.
+ Quan trọng nhất, mỗi nút số được gán một hành động khi người dùng nhấn vào
thông qua ActionListener. Khi người dùng nhấn nút, giá trị số tương ứng sẽ được nối vào
nội dung hiện tại trong ô display (kiểu JTextField), giúp mô phỏng hành vi nhập số PIN như trên máy ATM.
+ Cuối cùng, nút vừa tạo được thêm vào giao diện bằng phương thức add(button),
đảm bảo hiển thị đúng vị trí và sẵn sàng cho tương tác người dùng.
- Khởi tạo bàn phím số
+ Phương thức initNumberButtons() có nhiệm vụ khởi tạo toàn bộ bàn phím số ảo
từ 0 đến 9 trong giao diện người dùng. Thay vì tạo thủ công từng nút một, phương thức
này tận dụng addNumberButton(...) để tạo từng nút số và đặt đúng vị trí tương ứng trên màn hình.
+ Các nút được bố trí theo dạng
lưới 3 cột, 4 hàng. Số “0” được đặt ở
dưới cùng. Bàn phím số được hiển thị
trực quan, dễ thao tác và hoàn toàn
tương thích với hành vi nhập mã PIN qua giao diện đồ họa.
4.1.2.3 Thiết kế chỗ nhập ID card:
Phương thức initRightPanel() có nhiệm vụ tạo bảng bên phải của giao diện – nơi
người dùng có thể nhập ID thẻ (ID CARD). Đây là phần quan trọng trong việc mô phỏng
quá trình xác thực thẻ ATM.
Trên thực tế, thẻ ATM được nhận diện bằng cách đưa vào máy đọc thẻ, tuy nhiên
do việc tích hợp phần cứng là bất khả thi trong mô hình này, hệ thống giả lập thao tác quét
thẻ bằng cách cho phép người dùng nhập ID thủ công vào ô văn bản .
- Phương thức initRightPanel được thiết kế:
+ Trước tiên, một JPanel tên là right được khởi tạo với kích thước 400x700 pixel,
đặt tại tọa độ (500, 130), làm nền cho toàn bộ phần bên phải. Màu nền được chọn là xám
sáng (RGB: 245, 245, 245), giúp phân biệt với phần nền tổng thể.
+ Bên trong right, một JPanel con tên nhapcard được tạo ra với đường viền tiêu
đề "ID CARD" – dùng để mô phỏng ô nhập thẻ. Bảng này có màu nền xám
(Color.GRAY) và được đặt tại tọa độ (0, 200) với kích thước 400x100 pixel.
+ Thành phần chính trong nhapcard là id – một JTextField, cho phép người dùng
nhập ID. Ô nhập được định dạng font lớn (24pt) để dễ nhìn và dễ thao tác. Đặc biệt, id
được gắn một KeyListener để chỉ cho phép nhập ký tự số. Mỗi khi người dùng gõ phím,
chương trình sẽ kiểm tra xem đó có phải là chữ số hay không. Nếu không phải, sự kiện
nhập sẽ bị loại bỏ (e.consume()), đảm bảo tính hợp lệ cho dữ liệu đầu vào.
+ Cuối cùng, bảng nhập thẻ nhapcard được thêm vào bảng right, và right được thêm vào giao diện chính.
4.1.2.4Thiết kế các nút thao tác: xóa tất cả (clear), xóa 1 số (Delete), tiến hành đăng nhập (Enter).
Để nhìn bắt mắt, dễ dàng thiết kế hơn, trong phương thức initFunctionButtons ta
tạo một JPanel là panelnew sử dụng Layout manager là GridLayout nhằm tạo khung lưới với các ô bằng nhau:
Phương thức initFunctionButtons() có nhiệm vụ tạo bảng chứa các nút chức năng
bên phải giao diện – nơi người dùng có thể thực hiện các thao tác như xóa, nhập và xóa ký
tự. Đây là một phần quan trọng trong việc mô phỏng các chức năng của máy ATM, giúp
người dùng thao tác dễ dàng và trực quan.
Trước tiên, một JPanel tên là panelnew được khởi tạo. Bảng này được thiết lập với
layout GridLayout, với 3 hàng và 1 cột, đồng thời có khoảng cách giữa các phần tử là 10
pixel theo cả chiều ngang và chiều dọc. Kích thước bảng này được đặt tại tọa độ (390,
340), với chiều rộng 90 pixel và chiều cao 150 pixel.
Sau khi tạo ra bảng, một đường viền tiêu đề với dòng chữ "Thao tác" được gán cho
panelnew, giúp phân biệt rõ ràng khu vực chức năng này với các phần khác trên giao diện.
Bên trong bảng panelnew, ba nút chức năng được thêm vào: "Clear" để xóa toàn bộ
nội dung, "Enter" để thực hiện hành động đăng nhập và "Delete" để xóa ký tự cuối cùng.
Mỗi nút này được gán một hành động riêng biệt, giúp người dùng thao tác thuận tiện hơn
khi sử dụng hệ thống. Cuối cùng, panelnew được thêm vào giao diện chính, hiển thị các
nút chức năng cho người dùng.
- Nút Clear (xóa tất cả)
Tạo một JButton ngay bên trong initFunctionButtons() lấy tên là “clear”, nút JButton
được thêm vào một khối lệnh hành động của thư viện AWT, trong khối này ta gọi là display
thay thay đổi dữ liệu thông qua setText(“”) giúp người dùng nhập lại từ đầu.
Và ta tiến hành thêm nút clear vào trong panelnew được tạo ở trên - Nút Delete (xóa một kí tự):
Cũng giống như nút "Clear", nút "delete" cũng được tạo bên trong phương thức
initFunctionButtons(). Sau khi nút được khởi tạo, nó sẽ được gắn một ActionListener để
xử lý sự kiện khi người dùng nhấn nút.
Trong khối lệnh hành động của ActionListener, một biến kiểu String tên là
GiaTriHT được tạo ra, và giá trị hiện tại trong ô văn bản display được lấy thông qua phương
thức getText(). Tiếp theo, chương trình tiến hành kiểm tra xem giá trị của GiaTriHT có
rỗng hay không. Điều này có nghĩa là người dùng phải nhập ít nhất một ký tự (hoặc số)
vào ô văn bản thì mới có thể xóa được. Nếu GiaTriHT không rỗng, chương trình sẽ tiếp
tục thực hiện thao tác xóa. Cụ thể, hàm substring() được sử dụng để cắt chuỗi. Đoạn mã
GiaTriHT.substring(0, GiaTriHT.length() - 1) sẽ lấy tất cả các ký tự trong GiaTriHT, bắt
đầu từ chỉ số 0 và kết thúc ở vị trí độ dài của chuỗi trừ đi 1, tức là loại bỏ ký tự cuối cùng
và dùng setText() để cập nhật dữ liệu.
- Nút Enter(Tiến hành đăng nhập):
Khi người dùng nhấn nút "enter", một ActionListener sẽ được kích hoạt để xử lý
sự kiện này. Đặc biệt, nút "Enter" sẽ không chỉ thực hiện các thao tác trên giao diện người
dùng mà còn tương tác với lớp TaiKhoan.java để kiểm tra tính hợp lệ của thông tin nhập
vào. Cụ thể, chương trình sẽ lấy giá trị từ ô display, nơi người dùng đã nhập mã PIN và
ID card qua biến id , sau đó so sánh với các dữ liệu có sẵn trong lớp TaiKhoan. Lớp
TaiKhoan sẽ chứa thông tin tài khoản, bao gồm mã PIN và ID thẻ mà người dùng đã nhập
trước đó. Quá trình kiểm tra sẽ được thực hiện thông qua một phương thức trong lớp
TaiKhoan. Nếu thông tin nhập vào khớp với dữ liệu trong hệ thống, người dùng sẽ được
phép tiếp tục các thao khác.
+ File class hỗ trợ đăng nhập được thiết kế như sau:
Trong lớp, ta cần khai báo hai thuộc tính id và matKhau với phạm vi truy cập là
private, đồng thời truyền hai thuộc tính này vào constructor TaiKhoan để khởi tạo giá trị
ban đầu cho từng đối tượng tài khoản. Ngoài ra, cần tạo thêm các phương thức getter để
có thể truy xuất giá trị của id và matKhau.
Tiếp theo, một biến tĩnh taiKhoanDangNhap được khai báo nhằm lưu lại thông tin
của tài khoản đã đăng nhập thành công. Biến này sẽ đóng vai trò như một đối tượng dùng
chung trong toàn bộ chương trình để biết ai là người đang sử dụng hệ thống.
Kế đến, ta tạo một danh sách ArrayList có kiểu là TaiKhoan và đặt tên là
danhSachTK. Danh sách này sẽ chứa tất cả các tài khoản có thể sử dụng để đăng nhập
vào hệ thống, tức là nó như một cơ sở dữ liệu tạm thời gồm các ID và mật khẩu.
Tiếp theo, khối lệnh từ dòng 21 đến dòng 29 là phần quan trọng hỗ trợ quá trình
đăng nhập vào hệ thống. Cụ thể, phương thức kiemTraDangNhap nhận vào hai tham số là
id và matKhau, đều có kiểu String, nhằm kiểm tra xem thông tin đăng nhập người dùng
nhập vào có hợp lệ hay không.