TRƯỜNG ĐẠI HỌC KIÊN GIANG

KHOA THÔNG TIN & TRUYỀN THÔNG

--------------------------------

BÁO CÁO
Lập trình hướng đối tượng (OOP)

Đề tài:
Bài 04 Ngân hàng ACB
lưu trữ thông tin của tài khoản.

Sinh viên : Ngô Phước Thành

MSSV : 2006206075
Sinh viên : Lê Quốc Thịnh
MSSV : 2006206080
Lớp : B20TT2
Nhóm HP : 02
GVHD : Nguyễn Minh Đức

Tháng 11 năm 2021.

1
 Lời Cảm Ơn
Trước tiên với tình cảm sâu sắc và chân thành nhất, cho phép em được bày tỏ lòng biết
ơn đến tất cả các cá nhân và tổ chức đã tạo điều kiện hỗ trợ, giúp đỡ em trong suốt quá trình
học tập và làm bài báo cáo. Trong suốt thời gian từ khi bắt đầu học tập tại trường đến nay,
em đã nhận được rất nhiều sự quan tâm, giúp đỡ của quý Thầy Cô và bạn bè.

Để hoàn thành bài báo cáo lần này, em xin tỏ lòng biết ơn sâu sắc đến thầy Nguyễn
Minh Đức thuộc khoa Thông Tin và Truyền Thông – Trường Đại học Kiên Giang. Thầy đã
cố gắng truyền đạt lại kiến thức một cách chi tiết và thiết thực nhất nhất trong suốt quá trình
giảng dạy để chúng em để làm tốt được bài báo cáo.

Ngoài ra chúng em cũng cảm ơn đến Thầy, Cô trong Khoa Thông Tin và Truyền Thông
đã tạo điều kiện cho chúng em làm một bài báo cáo để có thể tạo tiền đề tốt cho các bài khóa
luận sau này.

Bên cạnh đó, em cũng gủi một lời cảm ơn trân trọng đến các bạn, đã giúp đỡ, cung
cấp, đưa ra hướng giải quyết thực tế nhất.

Đồng thời, trong quá trình báo cáo không thể tránh được những thiếu xót, rất mong
được sự góp ý, hướng dẫn của quý thầy cô để có thể làm tốt hơn sau này.

Một lần nữa chúng em xin cảm ơn đến thầy cô, bạn bè lời cảm ơn trân trọng nhất.

Kiên Giang, ngày tháng 11 năm 2021

Sinh viên thực hiện 1 Sinh viên thực hiện 2

Ngô Phước Thành Lê Quốc Thịnh

2
 MỤC LỤC
CHƯƠNG 1: GIỚI THIỆU CHUNG..................................................................4

1.1. Giới thiệu đề tài .......................................................................................... 4

CHƯƠNG 2: KHẢO SÁT PHÂN TÍCH.............................................................5

2.1. Tóm tắt lý thuyết ........................................................................................ 5

2.1.1 Tính trừu tượng (abstraction) ................................................................ 5
2.1.1.1 Lớp interface ......................................................................................... 5
2.1.2 Tính đóng gói (encapsulation) ................................................................ 5
2.1.3 Tính đa hình (polymorphism) ................................................................. 6
2.1.4 Tính kế thừa (inheritance) ...................................................................... 6
2.1.5 ArrayList................................................................................................... 7
2.1.6 Cơ chế xử lí ngoại lệ (Khối try .. catch) ................................................. 7
2.1.7 Class(lớp) .................................................................................................. 7
CHƯƠNG 3: HƯỚNG GIẢI QUYẾT BÀI TOÁN...........................................8

3.1 Tạo Class iCV (interface) ........................................................................... 8

3.2 Tạo Class Account kế thừa lớp iCV .......................................................... 8
3.3 Tạo Class main ............................................................................................ 9
CHƯƠNG 4: SOURCE CODE..........................................................................12

4.1 Class iCV .................................................................................................... 12

4.2 Class Account ............................................................................................ 12
4.3 Class main .................................................................................................. 15
Tài liệu tham khảo...............................................................................................21

3
 CHƯƠNG 1: GIỚI THIỆU CHUNG
1.1. Giới thiệu đề tài
Bài 04. Ngân hàng ABC muốn lưu trữ thông tin của mỗi tài khoản như sau:
• Số tài khoản (kiểu long).
• Tên tài khoản (kiểu chuỗi).
• Số tiền trong tài khoản (kiểu double).
(a) Thiết kế lớp Account để lưu trữ thông tin, lớp bao gồm các phương thức sau:
• Constructor: có 02 constructors (mặc định và đầy đủ tham số).
• Các phương thức get, set cho từng thuộc tính.
• Phương thức toString để trả về chuỗi chứa toàn bộ thông tin tài khoản, yêu cầu định
dạng tiền tệ.
(b) Thêm các thông tin sau vào lớp Account.
• Hằng số lãi suất có giá trị khởi tạo 0.035
• Constructor có 02 đối số: số tài khoản, tên tài khoản. Constructor này sẽ khởi tạo số
tiền mặc định là 50.
• Phương thức nạp tiền vào tài khoản: lấy số tiền hiện tại trong tài khoản + số tiền nạp
vào.
• Phương thức rút tiền: lấy số tiền hiện tại trong tài khoản – (số tiền muốn rút + phí rút
tiền).
• Phương thức đáo hạn: mỗi lần đến kỳ đáo hạn thì số tiền trong tài khoản = số tiền
trong tài khoản + số tiền trong tài khoản * LAISUAT.
• Phương thức chuyển khoản từ tài khoản này sang tài khoản khác.
Chú ý: mỗi thao tác phải kiểm tra số tiền nạp, rút, chuyển có hợp lệ hay không ? (Ví dụ:
tiền nhập vào <0, tiền rút > tiền trong tài khoản thì yêu cầu nhập lại).

4
 CHƯƠNG 2: KHẢO SÁT PHÂN TÍCH
2.1. Tóm tắt lý thuyết
2.1.1 Tính trừu tượng (abstraction)
Một lớp cha không bao giờ được dùng để tạo đối tượng được gọi là lớp cơ sở trừu
tượng, hay ngắn gọn là lớp trừu tượng (abstract class). Với những lớp thuộc diện này, trình
biên dịch sẽ báo lỗi bất cứ đoạn mã nào định tạo thực thể của lớp đó. Tất nhiên, ta vẫn có
thể dùng tham chiếu thuộc kiểu lớp trừu tượng. Thực ra đây là mục đích quan trọng nhất
của việc sử dụng lớp trừu tượng - để có đa hình cho đối số, kiểu trả về, và mảng. Bên cạnh
đó là mục đích sử dụng lớp trừu tượng làm nơi đặt các phương thức dùng chung để các lớp
con thừa kế.
2.1.1.1 Lớp interface
Với từ khóa interface, chúng ta có thể trừu tượng hoàn toàn giao diện của lớp khỏi
hiện thực của nó. Nghĩa là có thể đặc tả một lớp phải làm gì, nhưng không cần biết làm như
thế nào. Giao diện là tập hợp các khai báo phương thức, hằng mà lớp con kế thừa. Giao diện
có cú pháp tương tự lớp, nhưng không có biến thành viên, chỉ có khai báo hằng và những
phương thức mà chúng khai báo không có thân. Số lượng lớp hiện thực một giao diện là tùy
ý. Một lớp cũng có thể hiện thực số lượng tùy ý giao diện.
2.1.2 Tính đóng gói (encapsulation)
Là cơ chế dùng một vỏ bọc kết hợp phần dữ liệu và các thao tác trên dữ liệu đó thành
một thể thống nhất, tạo nên sự an toàn, tránh việc sử dụng không đúng thiết kế, bảo vệ mã
lệnh và dữ liệu bằng cách chống truy xuất từ những đoạn mã bên ngoài.
Tính chất này sẽ không cho phép người sử dụng đối tượng thay đổi trạng thái nội tại của
một đối tượng trong các chiều hướng không định trước được. Chỉ các phương thức nội tại
của đối tượng mới cho phép thay đổi trạng thái của nó. Cho phép môi trường bên ngoài tác
động lên các dữ liệu nội tại của một đối tượng theo cách nào, hoàn toàn tùy thuộc vào người
viết mã. Đây là tính chất an toàn của đối tượng.
Các tham số và giá trị trả về được sử dụng đắc lực nhất trong các phương thức có
nhiệm vụ truy nhập dữ liệu của đối tượng. Có hai loại phương thức truy nhập:

5
 • Các phương thức đọc dữ liệu của đối tượng và trả về dữ liệu đọc được. Chúng thường
được đặt tên là getDữLiệuGìĐó, nên còn được gọi là các phương thức get.
• Các phương thức ghi dữ liệu vào các biến thực thể của đối tượng, chúng nhận dữ liệu
mới qua các tham số rồi ghi vào các biến liên quan. Chúng thường được đặt tên là
setDữLiệuGìĐó, nên còn được gọi là các phương thức set.
Nửa công việc còn lại, cần làm gì để che giấu dữ liệu, không cho phép các đoạn mã
khác dùng tham chiếu trực tiếp sửa biến thực thể? Làm cách nào để che giấu dữ liệu? Quy
tắc khởi đầu cho việc thực hiện đóng gói là: đánh dấu các biến thực thể với từ khóa private
và cung cấp các phương thức public set và get cho biến đó. Các từ khóa private và public
quy định quyền truy nhập của biến thực thể, phương thức, hay lớp được khai báo với từ
khóa đó. (Ta đã quen với từ khóa public, nó đi kèm khai báo của tất cả các phương thức
main.) Từ khóa private có nghĩa là riêng tư, cá nhân. Trong một lớp, biến thực thể / phương
thức nào được khai báo với từ khóa private thì chỉ có mã chương trình ở bên trong lớp đó
mới có quyền truy nhập biến / phương thức đó. Từ nay ta sẽ gọi các biến / phương thức
được khai báo với từ khóa private là biến private / phương thức private. Còn public có nghĩa
là mã ở bất cứ đâu đều có thể truy nhập biến / phương thức đó.
2.1.3 Tính đa hình (polymorphism)
Thể hiện thông qua việc gởi các thông điệp, có thể so sánh như là việc gọi các hàm
bên trong một đối tượng. Phương thức trả lời một thông điệp sẽ tùy theo đối tượng được gởi
tới mà có phản ứng khác nhau. Người lập trình có thể định nghĩa một đặc tính (chẳng hạn
thông qua tên phương thức) cho một loạt các đối tượng gần nhau. Khi thi hành thì cùng một
tên gọi nhưng sự thực thi của mỗi đối tượng sẽ tự động xảy ra tương ứng theo đặc tính của
từng đối tượng mà không bị nhầm lẫn. Như vậy, với đa hình, ta có thể viết những đoạn mã
không phải sửa đối khi ta bổ sung lớp con mới vào chương trình.
Để thực hiện tính đa hình ta có nhiều cách:
• Nạp chồng phương thức (Overload)
• Ghi đè (Override)
• Sử dụng cơ chế upcasting và downcasting
2.1.4 Tính kế thừa (inheritance)
Là khả năng xây dựng các lớp mới từ những lớp đã có. Tính đóng gói cũng tác động
đến tính kế thừa. Khi lớp đóng gói một số dữ liệu và phương thức, lớp mới sẽ kế thừa mọi

6
cấu trúc dữ liệu và các phương thức của lớp mà nó kế thừa. Ngoài ra lớp mới có thể bổ sung
các dữ liệu và phương thức cho riêng mình.
2.1.5 ArrayList
Cũng như mảng của nhiều ngôn ngữ khác, mảng của Java có những hạn chế chẳng
hạn như ta phải biết kích thước khi tạo mảng; việc xóa một phần tử ở giữa mảng không đơn
giản; mảng không thể lưu nhiều phần tử hơn kích thước đã khai báo. Lớp ArrayList là một
cấu trúc dạng mảng khắc phục được các nhược điểm của cấu trúc mảng. Ta không cần biết
một ArrayList cần có kích thước bao nhiêu khi tạo nó, nó sẽ tự giãn ra hoặc co vào khi các
đối tượng được đưa vào hoặc lấy ra.
2.1.6 Cơ chế xử lí ngoại lệ (Khối try .. catch)
Để xử lý các ngoại lệ có thể được ném ra từ một đoạn mã, ta bọc đoạn mã đó trong
một khối try/catch. Khối try/catch gồm một khối try chứa phần mã có thể phát sinh ngoại lệ
và ngay sau đó là một khối catch với nhiệm vụ 'bắt' ngoại lệ được ném từ trong khối try và
xử lí sự cố đó (có thể có vài khối catch theo sau một khối try, ta sẽ nói đến vấn đề này sau).
Nội dung của khối catch tùy vào việc ta muốn làm gì khi loại sự cố cụ thể đó xảy ra.
Các phương thức Java dùng các ngoại lệ để báo với phần mã gọi chúng rằng "Một tình
huống không mong đợi đã xảy ra. Tôi gặp sự cố." Cơ chế xử lý ngoại lệ của Java cho phép
xử lý những tình huống bất thường xảy ra khi chương trình đang chạy, nó cho phép ta đặt
tất cả những đoạn mã xử lý lỗi vào một nơi dễ đọc dễ hiểu. Cơ chế này dựa trên nguyên tắc
rằng nếu ta biết ta có thể gặp một ngoại lệ nào đó ta sẽ có thể chuẩn bị để đối phó với tình
huống phát sinh ngoại lệ đó.
2.1.7 Class(Lớp)
Lớp là một bản thiết kế cho các đối tượng có các thuộc tính chung
- Lớp là một kiểu do người dùng định nghĩa mô tả kiểu đối tượng sẽ như thế nào.
- Một lớp bao gồm:
+ Các thuộc tính (Attributes) + Các hàm dựng (Constructor)

7
 CHƯƠNG 3: HƯỚNG GIẢI QUYẾT BÀI TOÁN
3.1. Tạo Class iCV (interface)
Lớp này sẽ chứa tất cả các phương thức cần làm theo yêu cầu bài toán.
• Phương thức nạp tiền vào tài khoản.
Cashin(double Cash);
• Phương thức rút tiền.
Cashout(double Cash);
• Phương thức đáo hạn.
maturity();
• Phương thức chuyển khoản từ tài khoản này sang tài khoản khác.
Trade(double Cash,Account B);
3.2 Tạo Class Account kế thừa lớp iCV
Class Account để lưu trữ thông tin, lớp bao gồm các phương thức, thuộc tính theo
các bước sau:
1. Số tài khoản (kiểu long).
2. Tên tài khoản (kiểu chuỗi).
3. Số tiền trong tài khoản (kiểu double)
4. Constructor: có 02 constructors (mặc định và đầy đủ tham số).
5. Constructor có 02 đối số: số tài khoản, tên tài khoản. Constructor này sẽ khởi tạo số
tiền mặc định là 50.
6. Các phương thức get, set cho từng thuộc tính.
7. Phương thức toString để trả về chuỗi chứa toàn bộ thông tin tài khoản, yêu cầu định
dạng tiền tệ.
8. @Override Các phương thức kế thừa của lớp iCV
• Cashin(double Cash);
this.TK += Cash;
• Cashout(double Cash);
this.TK = TK - Cash ;

8
 • maturity();
this.TK = TK + TK * getLai() * SolanDH();
• Trade(double Cash,Account B);
if (Cash <= TK && Cash >0) {
Cashout(Cash);
B.Cashin(Cash); }
9. Hằng số lãi suất có giá trị khởi tạo 0.035 -> getLai()
10. Tạo phương thức SolanDH() trả về số lần đáo hạn trong 1 khoảng thời gian.(1 tháng
đáo hạn 1 lần)
11. Phương thức để hiển thị thông tin. -> display()
12. Phương thức dùng để tạo tài khoản mới -> Taotaikhoan()
Trong phương thức này chứa 1 phương thức kiểm tra tài khoản đã tồn tại hay chưa
được viết trong class main. Nếu đã tồn tại thì trả về null, ngược lại tạo tài khoản mới nhập
từ bàn phím.
3.3. Tạo Class main chứa phần còn lại để giải quyết bài toán (chứa
hàm main)
a)Khởi tạo 1 ArrayList --accList
Để lưu trữ thông tin của tài khoản được tạo ra.
b)Khởi tạo phương thức hiển thị menu lựa chọn --showMenu()
In ra lựa chọn công việc:
1.Tạo tài khoản 5.Chuyển tiền
2. Hiển thị tất cả thông tin, 6.Đáo hạn
3.Rút tiền, 7.Tra cứu số dư
4.Nạp tiền 0.Thoát.
c) Khởi tạo phương thức --Taotaikhoan()
Mục đích dùng để tạo tài khoản mới. Gọi lại phương thức Taotaikhoan() của lớp
Account, kiểm tra tài khoản mới khác null hay không ,nếu khác tạo tài khoản mới sau đó
thêm vào accList.
d) Khởi tạo phương thức checktk(long STK)

9
 Mục đích là kiểm tra số tài khoản này đã được tạo và đưa vào acclist hay chưa, nếu đã
tồn tại trả về false.
e)Khởi tạo phương thức displayAcc()
Để hiện thị tất cả thông tin của tài khoản đã được đưa vào accList bằng cách gọi lại
phương thức display() của lớp Account.
f) Khởi tạo phương thức findSTK() dùng để tra cứu số dư.
Sẽ yêu cầu người dùng nhập số tài khoản cần tìm, sau đó trả về thông tin ứng với số
tài khoản đó.
g) Khởi tạo phương thức Cashout() phương thức rút tiền.
Tạo thuộc tính : double Cash, nhận Cash là tham số
Bước 1: Cho người dùng nhập số tài khoản cần rút tiền.
Sau đó gọi phương thức checktk() ->nếu trả về true -> in ra “Tài khoản không tồn
tại!” -> sang bước 3.
Ngược lại sang bước 2.
Bước 2 : Người dùng nhập số tiền(Cash) ->kiểm tra điều kiện > hợp lệ -> sang bước 4.
Ngược lại In ra thông báo “Số tiền không hợp lệ” -> sang bước 3.
Bước 3 In ra "Bạn có rút tiền tiếp không ? Y/N : "
Người dùng nhập “n” thì sẽ dừng hành động , ngược lại nhập chữ khác thì quay lại
bước 1.
Bước 4 Gọi phương thức Cashout(double Cash) của lớp Account.
h) Khởi tạo phương thức Cashin() phương thức nạp tiền.
Giống với phương thức rút tiền nhưng ngược lại là gọi phương thức Cashin(double
Cash) của lớp Account .
j) Khởi tạo phương thức Trade() phương thức chuyển khoản.
Tạo thuộc tính : double Cash, nhận Cash là tham số
Cho người dùng nhập số tài khoản chuyển tiền(1) -> gọi phương thức checktk()-> true
thì dừng hành động -> ngược lại , nhập tiếp số tài khoản nhận tiền (2)-> gọi phương thức
checktk()-> true thì dừng hành động > ngược lại , nhập số tiền cần giao dịch(Cash)
Gọi lại phương thức Trade(double Cash, Account B) của lớp Account để thực hiện
giao dịch.

10
k) Khởi tạo phương thức maturity() phương thức đáo hạn
Người dùng nhập vào số tài khoản cần đáo hạn-> gọi phương thức checktk()-> true thì
dừng hành động, ngược lại gọi phương thức maturity() của lớp Account để thực hiện giao
dịch.
l) Khởi tạo phương thức public static void main(String[] args)
Đầu tiên tạo 1 ArrayList là accList và tạo Scanner scan;
Gọi lại phương thức showMenu().
Tạo biến choose nhận một số nguyên từ bàn phím.
Dùng do... while để thực hiện chương trình .
do { in ra "Nhập lựa chọn của bạn : " ->nhập lựa chọn từ bàn phím.
Gọi Scanner để nhập lựa chọn (choose) do chương trình dùng switch(choose) case :
Case 1 : gọi phương thức Taotaikhoan(); Case 5 : gọi phương thức Trade();
Case 2 : gọi phương thức displayAcc(); Case 6 : gọi phương thức maturity();
Case 3 : gọi phương thức Cashout(); Case 7 : gọi phương thức findSTK();
Case 4 : gọi phương thức Cashin(); Case 0 : gán choose =0;
while (choose != 0) thì dừng chương trình.
Cả đoạn do....while được đặt trong khối try... catch để bắt lỗi nhập sai dữ liệu.

11
 CHƯƠNG 4: SOURCE CODE
4.1 Class iCV

4.2 Class Account

Khai báo các package cần dùng

• Các thuộc tính cần dùng.

• Constructor: có 02 constructors (mặc định và đầy đủ tham số).
• Constructor có 02 đối số: số tài khoản, tên tài khoản. Constructor này sẽ khởi
tạo số tiền mặc định là 50.

12
• Các phương thức get, set cho từng thuộc tính.

• Phương thức toString để trả về chuỗi chứa toàn bộ thông tin tài khoản, yêu cầu
định dạng tiền tệ.

• Phương thức nạp tiền vào tài khoản: lấy số tiền hiện tại trong tài khoản + số
tiền nạp vào.
• Phương thức rút tiền: lấy số tiền hiện tại trong tài khoản – (số tiền muốn rút ).

13
• Hằng số lãi suất có giá trị khởi tạo 0.035->getLai()
• Phương thức đáo hạn: mỗi lần đến kỳ đáo hạn thì số tiền trong tài khoản = số
tiền trong tài khoản + số tiền trong tài khoản * getLai()* SolanDH()

• Phương thức chuyển khoản từ tài khoản này sang tài khoản khác.

• Phương thức hiển thị thông tin.

14
 • Phương thức tạo tài khoản mới

4.3 Class main

Khai báo các package cần dùng
Tạo danh sách lưu trữ

15
• Chương trình chính

16
• Phương thức tạo menu

• Phương thức tạo tài khoản mới

• Phương thức kiểm tra sự tồn tại của số tài khoản

• Phương thức xem thông tin danh sách

17
• Phương thức kiểm tra thông theo số tài khoản

s
• Phương thức rút tiền

18
• Phương thức nạp tiền

19
• Phương thức chuyển tiền

• Phương thức đáo hạn.

20
Tài liệu tham khảo
BÀI GIẢNG LẬP TRÌNH HƯỚNG ĐỐI TƯỢNG (với Java) - ThS Nguyễn Minh Đức.

21