TRƯỜNG ĐẠI HỌC CNTT&TT

KHOA CÔNG NGHỆ THÔNG TIN

GIÁO ÁN THỰC HÀNH

Môn học: LẬP TRÌNH HƯỚNG ĐỐI TƯỢNG VỚI JAVA

Hệ đào tạo: ĐẠI HỌC CHÍNH QUY

Ngành đào tạo: CÔNG NGHỆ THÔNG TIN

Khoa: CÔNG NGHỆ THÔNG TIN

Năm: 2022-2023.

Thái nguyên, 2023

Contents
LỜI NÓI ĐẦU..............................................................................................................................................5

LAB_01: MỞ ĐÂU......................................................................................................................................6

1.1 Mục đích.................................................................................................................................................6

1.2 Yêu cầu....................................................................................................................................................6

1.3 Nội dung thực hành...............................................................................................................................6

1.4 Bài giải mẫu............................................................................................................................................7

LAB_02: CÁC THÀNH PHẦN CƠ SỞ CỦA JAVA................................................................................8

2.1 Mục đích.................................................................................................................................................8

2.2 Yêu cầu....................................................................................................................................................8

2.3 Nội dung thực hành................................................................................................................................8

2.4 Bài tập mẫu.............................................................................................................................................9

LAB_03: LỚP VÀ CÁC THÀNH PHẦN CỦA LỚP.............................................................................10

3.1 Mục đích...............................................................................................................................................10

3.2 Yêu cầu..................................................................................................................................................10

3.3 Nội dung thực hành................................................................................................................................10

3.4 Bài giải mẫu...........................................................................................................................................11

LAB_04: LỚP, QUAN HỆ KẾ THỪA(Generization) VÀ QUAN HỆ PHỤ THUỘC, LIÊN HỢP

(Association) GIỮA CÁC LỚP.................................................................................................................14

4.1 Mục đích................................................................................................................................................14

4.2 Yêu cầu..................................................................................................................................................14

4.3 Nội dung thực hành.............................................................................................................................14

4.4 Bài tập mẫu...........................................................................................................................................15

LAB_05: MẢNG VÀ XÂU TRONG JAVA.............................................................................................18

5.1 Mục đích...............................................................................................................................................18

5.2 Yêu cầu..................................................................................................................................................18

5.3 Nội dung thực hành.............................................................................................................................18

5.4 Bài tập mẫu...........................................................................................................................................20

LAB_06:.....GIAO DIỆN, ĐA KẾ THỪA, CÁC LỚP TRỪU TƯỢNG VÀ QUAN HỆ HIỆN THỰC
HÓA (Realization) GIỮA GIAO DIỆN VÀ LỚP ĐỐI TƯỢNG..........................................................24

6.1. Mục đích..............................................................................................................................................24

6.2 Yêu cầu..................................................................................................................................................24

6.3 Nội dung thực hành.............................................................................................................................24

6.4 Hướng dẫn về giao diện.......................................................................................................................25

LAB_07: TỔNG HỢP................................................................................................................................28

7.1. Mục đích..............................................................................................................................................28

7.2 Yêu cầu..................................................................................................................................................28

7.3 Nội dung thực hành.............................................................................................................................28

7.4 Hướng dẫn chung.................................................................................................................................33

7.5. Mã nguồn mẫu......................................................................................................................................36

 LỜI NÓI ĐẦU

Giáo án này chúng tôi biên soạn dựa trên các kiến thức trong giáo án lý thuyết của môn
học. Các bài tập được biên soạn theo tuần tự các chương tương ứng với phần lý thuyết.
Mỗi chương đều được tổ chức thành các phần: mục đích, yêu cầu, nội dung các bài tập và
cuối cùng là bài tập mẫu tương ứng với phần kiến thức trong chương.
Mặc dù đã có sự cố gắng nhưng chắc chắn giáo án thực hành vẫn còn nhiều hạn
chế. Nhóm tả giả rất mong nhận được các ý kiến góp ý của các bạn sinh viên và bạn bè
đồng nghiệp để cuốn giáo án thực hành học phần “Lập trình Java” ngày càng hoàn thiện
hơn.
Xin trân thành cảm ơn!

Nhóm biên soạn

 LAB_01: MỞ ĐÂU
1.1 Mục đích
- Sinh viên làm quen với một trong các môi trường tích hợp phát triển ứng dụng
Java: Netbean IDE, Eclipse IDE, …
- Viết chương trình ứng dụng Java đơn giản, làm quen với các lệnh nhập/ xuất dữ
liệu qua các thiết bị vào/ra chuẩn (bàn phím/màn hình).
1.2 Yêu cầu
- Sinh viên cần trang bị đầy đủ các kiến thức phục vụ cho buổi thực hành.
- Cài đặt JDK và một trong các môi trường tích hợp phát triển (ví dụ: NetBean)
- Làm quen với IDE (ví dụ: Netbean)
- Làm quen với cấu trúc chương trình Java, dự án Java, cách biên dịch, đóng gói,
thực thi chương trình Java.
1.3 Nội dung thực hành
Tạo một dự án Java đơn giản với Tên: “LAB_01” gồm các lớp đối tượng sau:
1. Lớp “Hello” Xuất lên màn hình dòng chữ “Hello World!”
2. Lớp “NhapLieu” gồm các phương thức nhập dữ liệu kiểu nguyên (int, short, byte,
long), kiểu thực (float, double) và kiểu xâu ký tự
3. Lớp “TinhToan” gồm các phương thức sau:
a. Nhập một số nguyên n ở hệ 10, in ra số tương ứng ở hệ cơ số 2, 8 và 16.
b. Tính số Fibonacci thứ k (biết số Fibonacci thứ k được tính theo công thức
sau:
1. Fibonacci(k) = 1 nếu k=1 hoặc k=2;
2. Fibonacci(k)= Fibonacci(k-1) + Fibonacci(k-1) nếu n>2
c. Kiểm tra một số có là số chính phương không? (số chính phương là số =
tích 2 căn bậc II của chính nó)
d. Kiểm tra một số có là số hoàn hảo không? (số hoàn hảo là số tự nhiên > 1
và bằng tổng các ước thực sự của nó, các ước thực sự của n là các ước của
n, ngoại trừ n)
e. Giải hệ phương trình bậc nhất 2 ẩn
f. Giải hệ phương trình bậc 2
g. Kiểm tra một số có là số nguyên tố không (số nguyên tố là số tự nhiên, >1
và chỉ chia hết cho 1 và chính nó)
 h. Phương thức main(): nhập vào số n và thực hiện các yêu cầu tương ứng với
các phương thức từ a) đến g).
4. Viết chương trình C (lập trình hướng chức năng) giải hệ phương trình bậc nhất 1
ẩn. So sánh sự giống và khác biệt với chương trình tương ứng viết bằng Java (sử
dụng cách tiếp cận hướng đối tượng).
1.4 Bài giải mẫu
Viết chương trình nhập vào 2 số nguyên từ bàn phím. In ra tổng, hiệu của 2 số đó
Chương trình:
//Bai1.java
import java.ultil.Scanner;
public class Bai1{
public static void main(String args[]){
Scanner w = new Scanner(System.in);
int a=0, b=0;
System.out.println(“Nhập số a=”);
a=w.nextInt();
System.out.println(“Nhập số b=”);
b=w.nextInt();
System.out.println(“Tổng: a+b=”+(a+b)+ “; Hiệu: a-b=”+(a-b));
}
}
 LAB_02: CÁC THÀNH PHẦN CƠ SỞ CỦA JAVA

2.1 Mục đích

Sinh viên có thể lập trình giải các bài toán đơn giản sử dụng các cấu trúc điều
khiển của Java

2.2 Yêu cầu

- Sinh viên chuẩn bị trước các bài tập thực hành

- Trang bị đầy đủ lý thuyết để hoàn thành nội dung bài LAB

2.3 Nội dung thực hành

1. Đóng gói dự án đã tạo ở Lab 01 (dự án “LAB_01”)
2. Tạo dự án có tên “LAB_02” sử dụng lại (import) các lớp trong dự án “LAB_01”.
Xây dựng các lớp sau trong gói “LAB_02”:
a. Lớp ToanHoc gồm:
 Thuộc tính n (kiểu nguyên)
 Các phương thức của lớp gồm:
o Liệt kê tất cả các số nguyên tố <n
o Liệt kê tất cả các số chính phương <n
o Liệt kê tất cả các số hoàn hảo <n
o Liệt kê ra k số Fibonacci đầu tiên trong dãy số Fibonacci
o Tính n!
o Tính tổng dãy số S1, biết:

o Tính tổng dãy số S2:

o Tính tổng dãy số S3:

S3 = 1-2+3+……(-1)n+1.n

o Tính tổng dãy số S4:

S4 = 1!+2!+3!+……+n!
 o Tính tổng dãy số S5:

b. Lớp “Main”, chứa hàm main(): nhập vào một số nguyên n và thực hiện các yêu
cầu tương ứng với các phương thức của lớp “ToanHoc”.

2.4 Bài tập mẫu

Xây dựng lớp ToanHoc chứa phương thức tính tổng dãy và hiển thị kết quả

Chương trình

//ToanHoc.java
import java.util.Scanner;
public class ToanHoc{
public static double tinhTong(int n){
double S=0.0;
for(int i=1; i<n;i++){
S+=i/(i+1);
}
return S;
}
public static void main(String args[]){
int n=0;
Scanner w = new Scanner(System.in);
System.out.println(“Nhap n=”);
n=w.nextInt();
System.out.println(“Tong S=”+tinhTong(n));
}
}
 LAB_03: LỚP VÀ CÁC THÀNH PHẦN CỦA LỚP
3.1 Mục đích
- Sinh viên viết được các chương trình giải các bài toán theo cách tiếp cận hướng
đối tượng với Java.
- Biết cách viết các phương thức nạp chồng.
3.2 Yêu cầu
- Chuẩn bị trước các bài tập thực hành
- Trang bị đầy đủ kiến thức để hoàn thành nội dung bài LAB
3.3 Nội dung thực hành
- Tạo mới dự án Java với tên “LAB_03” sử dụng lại dự án “LAB_01”.

- Tạo các lớp sau trong dự án “LAB_03” gồm:

1. Lớp “Diem” gồm:

1. Các thuộc tính: double x, double y là hai giá trị hoành độ và tung độ tương
ứng của một điểm trên mặt phẳng tọa độ.

2. Nạp chồng các phương thức tạo lập: Diem(); Diem(x,y)

3. Các phương thức khác tương ứng với các yêu cầu sau:

i. Nhập thông tin của điểm

ii. Hiển thị thông tin điểm

iii. Tính khoảng cách giữa 2 điểm, biết rằng khoảng cách giữa 2 điểm
A(xA, yA), B(xB, yB) được tính theo công thức sau:

a. AB=
iv. Phương thức main(): nhập 2 điểm A, B. In ra thông tin 2 điểm vừa
nhập và khoảng cách giữa chúng (AB).
2. Lớp “DaGiac” gồm: (OK)

a. Các thuộc tính: số cạnh, mảng chứa độ dài từng cạnh

b. Nạp chồng các toán tử khởi tạo cho Lớp Đa giác

c. Các phương thức:

 i. Nhập vào số lượng cạnh và độ dài các cạnh của đa giác

ii. Tính chu vi đa giác

iii. Nhập vào 3 số a, b, c. Kiểm tra xem các số đó có là 3 cạnh của tam
giác hay không?

iv. Nếu đa giác là tam giác, kiểm tra xem đó có là 3 cạnh của tam giác
không? Nếu đúng thì tính diện tích của tam giác bằng công thức
Heron, biết diện tích S:

p là nửa chu vi tam giác.

v. Phương thức main() thực hiện các yêu cầu từ i) đến iv);

3. Xây dựng lớp “SoPhuc” gồm:

a. Các thuộc tính: phanThuc, phanAo kiểu double;
b. Các phương thức:
o Các toán tử tạo lập: SoPhuc(), SoPhuc(float pt, float pa)
o Phương thức nhập vào một số phức: void nhapSoPhuc()
o Phương thức hiển thị một số phức: void inSoPhuc()
o Phương thức cộng hai số phức: SoPhuc congSoPhuc(SoPhuc sp)
o Phương thức trừ hai số phức: SoPhuc truSoPhuc(SoPhuc sp)
o Phương thức nhân hai số phức: SoPhuc nhanSoPhuc(SoPhuc sp)
o Phương thức chia hai số phức: SoPhuc nhanSoPhuc(SoPhuc sp)
 Biết rằng:
- Tổng 2 số phức: (a + b.i) + (c + d.i) = (a + c) + (b + d).i
- Hiệu 2 số phức: (a + b.i) - (c + d.i) = (a - c) + (b - d).i
- Tích 2 số phức: (a + b.i)*(c + d.i) = (a.c - b.d) + (b.c + a.d).i
- Chia 2 số phức :
-

o Phương thức main: nhập vào 2 số phức, hiện thị 2 số phức vừa nhập và
in ra số phức là tổng, hiệu, tích, thương của 2 số phức vừa nhập.

3.4 Bài giải mẫu

Mã nguồn của Lớp “SoPhuc”:

public class SoPhuc {

double phanThuc, phanAo;
SoPhuc(){}

SoPhuc(float pt, float pa){

this.phanThuc=pt;
this.phanAo=pa;
}
void nhapSoPhuc(){
System.out.print("Nhập phần thực: ");
phanThuc=NhapLieu.nhapDouble();
System.out.print("Nhập phần ao: ");
phanAo=NhapLieu.nhapDouble();
}
void inSoPhuc(){
System.out.println("Phan thuc: "+this.phanThuc+", Phần ảo:" + this.phanAo);
}
SoPhuc congSoPhuc(SoPhuc sp){
SoPhuc tam=new SoPhuc();
tam.phanThuc=this.phanThuc+sp.phanThuc;
tam.phanAo=this.phanAo+sp.phanAo;
return tam;
}
SoPhuc truSoPhuc(SoPhuc sp){
SoPhuc tam=new SoPhuc();
tam.phanThuc=this.phanThuc-sp.phanThuc;
tam.phanAo=this.phanAo-sp.phanAo;
return tam;
}
SoPhuc nhanSoPhuc(SoPhuc sp){
SoPhuc tam=new SoPhuc();
tam.phanThuc=(this.phanThuc*sp.phanThuc)-(this.phanAo*sp.phanAo);
tam.phanAo=this.phanAo*sp.phanThuc+this.phanThuc*sp.phanAo;
return tam;
}

public static void main(String[] args) {

SoPhuc a=new SoPhuc();
System.out.println("Nhập số phức 1:");
a.nhapSoPhuc();
System.out.println("Số phức 1 là: ");
a.inSoPhuc();

System.out.println("Nhập số phức 2:");

SoPhuc a1=new SoPhuc();
a1.nhapSoPhuc();
System.out.println("Số phức 2 là: ");
 a1.inSoPhuc();

SoPhuc tong=new SoPhuc();

tong=a.congSoPhuc(a1);
System.out.println("Sô phức tổng là:");
tong.inSoPhuc();
}
}
LAB_04: LỚP, QUAN HỆ KẾ THỪA(Generization) VÀ QUAN HỆ PHỤ THUỘC,
LIÊN HỢP (Association) GIỮA CÁC LỚP (Chưa thực hành)
4.1 Mục đích
- Phân biệt giữa nạp chồng và viết đè phương thức
- Nạp chồng các toán tử tạo lập, không được phép viết đè các toán tử tạo lập
- Viết chương trình khai báo các lớp có quan hệ kế thừa, liên hợp, phụ thuộc.
4.2 Yêu cầu
- Chuẩn bị trước các bài tập thực hành
- Trang bị đầy đủ kiến thức lý thuyết để hoàn thành nội dung bài LAB
4.3 Nội dung thực hành
Tạo mới một dự án có tên “LAB_04” gồm các lớp đối tượng sau:
1. Xây dựng lớp “Nguoi” gồm;
 Các thuộc tính chung: hoTen, diaChi, namSinh
 Các phương thức:
o Nạp chồng các toán tử tạo lập: public Nguoi(), Nguoi(String ht,String
dc,int ns)
 Phương thức khác gồm
o Nhập thông tin cho một người.
o Hiển thị thông tin một người
2. Xây dựng lớp “GiaoVien” kế thừa từ lớp Nguoi:
+ Các thuộc tính bổ sung gồm: maGV, heSochucVu, heSoLuong, luongCoBan.
+ Nạp chồng các phương thức khởi tạo của lớp “GiaoVien”
+ Viết đè các phương thức được kế thừa từ lớp cha gồm:
o Nhập thông tin giáo viên
o Hiển thị thông tin giáo viên
+ Phương thức tính lương, biết rằng:
lương=(heSoLuong+heSoChucVu)*luongCoBan-heSoLuong*luongCoBan*5%
+ Phương thức main() tạo ra hai đối tượng thuộc lớp Nguoi, nhập và hiện thị
thông tin của 2 đối tượng này. tạo ra một đối tượng thuộc lớp “GiaoVien” nhập
thông tin, hiển thị thông tin và tính lương cho đối tượng vừa nhập.
3. Xây dựng lớp “SinhVien” kế thừa từ lớp “Nguoi”:
 + Các thuộc tính bổ sung gồm: maSV, tenLop, diem1,diem2,diem3, xếp loại học lực
Ghi chú:
- xử lý trôi lệnh khi nhập xâu ->số->xâu: sử dụng nextLine() để nhập string, rồi
chuyển string sang số => kết quả vẫn l nhập vào các String.
Ví dụ: nhập năm sinh như là 1 chuỗi sau đó chuyển nó sang kiểu int, khi đó lệnh
nhập mã SV sẽ không bị trôi nữa.
- Để tránh mảng sau khi nhập vẫn null, cần new mảng bên ngoài trước khi truyền
vào đối số
+ Các phương thức:
a) Nạp chồng các toán tử tạo lập.
b) Tính điểm TB: public float tinhDiemTrungBinh(){};
c) Viết đè hai phương thức: nhapTT(), inTT() được kế thừa từ lớp “Nguoi”
4. Xây dựng lớp “LopHoc” có quan hệ liên hợp phụ thuộc với lớp “GiaoVien” và
“SinhVien” như sau. Lớp này gồm:
+ Các thuộc tính: số lượng sinh viên, danh sách sinh viên, giáo viên chủ nhiệm
+ Nạp chồng các toán tử tạo lập của lớp “LopHoc”
+ Các phương thức:
a) Nhập danh sách các sinh viên trong lớp
b) Hiện thị danh sách vừa nhập
c) Thêm một sinh viên vào danh sách
d) Xóa sinh viên có mã số là x ra khỏi danh sách (x nhập vào từ bàn phím)
e) Tìm kiếm các sinh viên theo tên
f) Thống kê ra các sinh viên được học bổng (điểm trung bình >=9)
g) Sắp xếp danh sách sinh viên theo thứ tự điểm trung bình giảm dần
h) Xếp loại học lực cho sinh viên.
i) In ra thông tin của giáo viên chủ nhiệm lớp.
j) Phương thức main() thực hiện các yêu cầu tương ứng với các phương
thức từ a) đến i).
4.4 Bài tập mẫu
Viết chương trình xây dựng lớp KhachHang gồm:
+ Các thuộc tính: Họ tên, địa chỉ, số điện thoại, email
+ Các phương thức:
- Các toán tử tạo lập
- Nhập thông tin khách hàng
- Hiển thị thông tin khách hàng
- Phương thức main, nhập vào thông tin của một khách hàng và hiển thị lên màn
hình thông tin vừa nhập
Chương trình
// KhachHang.java
mport java.io.*;
public class KhachHang{
String hoTen;
String diaChi;
String sdt;
String email;
public KhachHang(){
//Toan tu tao lap mac dinh
}
public KhachHang(String ht,String dc,String sdthoai,String emailAdd){
hoTen=ht;
diaChi=dc;
sdt=sdthoai;
email=emailAdd;
}
public static String nhapString(){
String s;
DataInputStream stream=new DataInputStream(System.in);
try{
s=stream.readLine();
s=s.trim();
s=s.toLowerCase();
}catch(IOException e){
s="";
}
return s;
}
public void nhapKH(){
String str;
 System.out.print("-Ho ten : "); //nhap ho ten
str=nhapString();
this.hoTen=str;
System.out.print("-Dia chi : ");
str=nhapString();
this.diaChi=str;
System.out.print("-So dien thoai : ");
str=nhapString();
this.sdt=str;
System.out.print("-Dia chi Email : ");
str=nhapString();
this.email=str;
}
public void inKH(){
System.out.println("--Ho ten:"+this.hoTen);
System.out.println("--Dia chi:"+this.diaChi);
System.out.println("--So dien thoai:"+this.sdt);
System.out.println("--Email:"+this.email);
}
public static void main(String[] args){
KhachHang kh=new KhachHang();
kh.nhapKH();
kh.inKH();
KhachHang k1=new KhachHang("nam","k16", "822", "nam@google.com");
k1.inKH();
}
}
 LAB_05: MẢNG VÀ XÂU TRONG JAVA

5.1 Mục đích

- Làm quen với lớp mảng và xâu trong gói java.lang.

- Thực hành thành thạo các thao tác trên mảng và các thao tác trên xâu ký tự.

5.2 Yêu cầu

- Sinh viên chuẩn bị trước các bài tập

- Trang bị đầy đủ kiến thức để hoàn thành nội dung bài LAB.

5.3 Nội dung thực hành

Tạo dự án “LAB_05” gồm các lớp đối tượng sau:

1. Xây dựng lớp “DaySo” gồm:
 Các thuộc tính riêng (private) sau đây:
o private int n; //số phần tử của dãy
o private int m[] ; //lưu trữ các giá trị của dãy
 Các toán tử tạo lập: DaySo(int spt), DaySo(int m1[]), DaySo(){}
 Các phương thức:
o public void inDaySo() //in dãy ra màn hình
o public void nhapDaySo()//nhập dãy số từ bàn phím
o public void inSoNguyenTo(){} //in ra các số nguyên tố thuộc dãy số
o public void inSoHoanHao()
o public void sapXepTang() //sắp xếp dãy số theo thứ tự tăng dần
o public void sapXepGiam()//sắp xếp dãy theo chiều giảm
o public DaySo congDay(DaySo d1)// cộng 2 dãy số
2. Xây dựng lớp “MaTran” gồm:
 Các thuộc tính riêng(private):
o private int n,m;// số dòng và cột của ma trận
o private double M[][]; // lưu trữ các phần tử của ma trận
 Các phương thức tạo lập :
o public MaTran(){}
 o public MaTran(int dong,int cot)
o public MaTran(double M1[][])
 Các phương thức:
o public void inMaTran()// in ma trận hiện thời
o public void nhapMaTran()// nhập ma trận từ bàn phím
o public boolean kiemTraDoiXung()// kiểm tra tính đối xứng của mt qua
đường chéo chính.
o public MaTran congMaTran(MaTran M1)// cộng 2 ma trận
o public MaTran truMaTran(MaTran M1)// trừ 2 ma trận
o public MaTran nhanMaTran(MaTran M1) // nhân 2 ma trận
o public MaTran sapXepTheoHang() // Sắp xếp các hàng của ma trận theo
thứ tự tăng dần
o public MaTran sapXepTheoCot() // Sắp xếp các cột của ma trận theo thứ tự
tăng dần
3.Xây dựng lớp “Xau” gồm:
 Thuộc tính dữ liệu là pvivate String st
 Các phương thức:
 Nhập dữ liệu cho xâu: public void nhapXau()
 In xâu ra mang hình: public void inXau()
 Chuẩn hóa xâu: public String chuanHoa();
 Thay thế tất cả các xâu con st1 bằng xâu con st2:
o public void thayThe (String st1,String st2)
 Nhập vào danh sách các xâu, sắp xếp danh sách giảm dần theo thứ tự từ
điển:
o public static sapXepXauGiam(String mangXau[])
4.Xây dựng lớp “Main” có các thuộc tính là 3 đối tượng thuộc các lớp tương ứng là
“DaySo”, “MaTran” và “Xau”. Thực hiện các thao tác tương ứng với các phương thức
của từng đối tượng.
5.4 Bài tập mẫu

Xây dựng lớp QLKhachHang (mỗi khách hàng gồm các thông tin cần quản lý như bài
tập mẫu chương 3) gồm:

- Các thuộc tính: số lượng khách hàng, mảng các khách hàng
- Các phương thức:

o Khởi tạo

o Nhập danh sách các khách hàng

o Hiển thị lên màn hình danh sách khách hàng

o Tìm kiếm khách hàng theo họ hoặc theo tên

o Tìm kiếm khách hàng theo địa chỉ

Chương trình

import java.io.*;
public class QLKhachHang{
int soKH;
KhachHang[] mkh;
public QLKhachHang(){
//Tao lap mac dinh
}
public QLKhachHang(int so){
soKH=so;
mkh=new KhachHang[so];
}
public static int nhapInt(){
String s;int n;
/*
DataInputStream stream=new DataInputStream(System.in);
try{
s=stream.readLine();
}catch(IOException e){
s="";
}
*/
s=nhapString();
try{
n=Integer.parseInt(s);
//hoac n=Integer.valueOf(s).intValue();
}catch(NumberFormatException nfe){
n=0;
}
 return n;
}
public static String nhapString(){
String s;
DataInputStream stream=new DataInputStream(System.in);
try{
s=stream.readLine();
s=s.trim();
s=s.toLowerCase();
}catch(IOException e){
s="";
}
return s;
}
public void nhapMangKH(){
int n;
//KhachHang mang[];
System.out.print("Nhap vao so KHACH HANG : ");
n=nhapInt();
this.soKH=n;
this.mkh=new KhachHang[n];
for(int i=0;i<n;i++){
System.out.println("------------------------");
System.out.println(" * Khach hang thu "+i);
this.mkh[i]=new KhachHang();
this.mkh[i].nhapKH();
}
}
public void inMangKH(){
System.out.println("\n\nIN MANG KHACH HANG\n");

for(int i=0;i<this.soKH;i++){
System.out.println("------------------------");
System.out.println(" + Khach hang thu "+i);
this.mkh[i].inKH();
}
System.out.println("========================");
}
public void timTenHo(){
String ten;
int n=this.soKH;
 boolean danhDau[];
danhDau=new boolean[n];

//khong can thiet doan ma duoi.Co cung duoc khong co cung duoc
// for(int i=0;i<n;i++){
// danhDau[i]=false;
// }

System.out.print("\n\n -->>> Nhap Ten hoac Ho can tim : ");

ten=nhapString();
for(int i=0;i<n;i++){
if(this.mkh[i].hoTen.lastIndexOf(ten) >= 0){
danhDau[i]=true;
}
}
for(int i=0;i<n;i++){
if(danhDau[i]){
System.out.println();
this.mkh[i].inKH();
}
}
}
public void timDiaChi(){
String dchi;
int n=this.soKH;
boolean danhDau[];
danhDau=new boolean[n];
System.out.print("\n\n -->>> Nhap Dia Chi can tim : ");
dchi=nhapString();
for(int i=0;i<n;i++){
if(this.mkh[i].diaChi.lastIndexOf(dchi) >= 0){
danhDau[i]=true;
}
}
for(int i=0;i<n;i++){
if(danhDau[i]){
System.out.println();
this.mkh[i].inKH();
}
}
}
 public static void main(String[] args){
QLKhachHang ql=new QLKhachHang();
ql.nhapMangKH();
ql.inMangKH();
ql.timTenHo();
ql.timDiaChi();
//ql.inMangKH();
}
}
 LAB_06: GIAO DIỆN, ĐA KẾ THỪA, CÁC LỚP TRỪU TƯỢNG VÀ QUAN
HỆ HIỆN THỰC HÓA (Realization) GIỮA GIAO DIỆN VÀ LỚP ĐỐI TƯỢNG

6.1. Mục đích

- Làm quen với giao diện, các lớp trừu tượng, quan hệ kế thừa đa trong giao diện

- Cài đặt mối quan hệ triển khai (hiện thực hóa) giữa giao diện và lớp đối tượng.

6.2 Yêu cầu

- Sinh viên chuẩn bị trước các bài tập

- Trang bị đầy đủ kiến thức để hoàn thành nội dung bài thực hành.

6.3 Nội dung thực hành

Tạo mới dự án “LAB_06” cài đặt các lớp trong biểu đồ phân cấp UML sau:

Biết rằng: in nghiêng là các phương thức trừu tượng.

Sinh viên trả lời các câu hỏi sau:

- Lớp trừu tượng và giao diện có những điểm gì giống nhau?

- Lớp trừu tượng và giao diện có những điểm gì khác nhau?

- Tại sao trong lập trình ta thường viết đè phương thức equals thay vì nạp chồng nó?
6.4 Hướng dẫn về giao diện (interface)

Java interface là một cách khác để đạt được một sự trừu tượng trong Java. Giao diện là
một lớp trừu tượng (abstract class) đầy đủ được sử dụng để nhóm các phương thức trừu
tượng liên quan lại với nhau.

Ví dụ:

// interface
interface Animal {
public void animalSound(); // interface method (does not have a body)
public void run(); // interface method (does not have a body)
}

Để truy cập đến các phương thức của interface, interface phải được triển khai
(implemented - kinda like inherited) bởi lớp khác với từ khóa implements (instead of
extends). Thân của phương thức trong giao diện được cung cấp bởi lớp triển khai
("implement" class)

Ví dụ:

// Interface
interface Animal {
public void animalSound(); // interface method (does not have a body)
public void sleep(); // interface method (does not have a body)
}

// Pig "implements" the Animal interface

class Pig implements Animal {
public void animalSound() {
// The body of animalSound() is provided here
System.out.println("The pig says: wee wee");
}
public void sleep() {
// The body of sleep() is provided here
System.out.println("Zzz");
}
}

class MyMainClass {
public static void main(String[] args) {
Pig myPig = new Pig(); // Create a Pig object
myPig.animalSound();
myPig.sleep();
}
}

Các lưu ý với giao diện:

 Giống như lớp trừu tượng (abstract classes), giao diện không thể được sử dụng để
tạo ra các đối tượng
 Các phương thức của giao diện không có thân – thân sẽ được cung cấp bởi lớp
triển khai (implement class)
 Khi triển khai một giao diện, ta phải viết đè tất cả các phương thức của nó
 Các phương thức của giao diện mặc định có tính chất abstract và public
 Các thuộc tính của giao diện mặc định có tính chất là Interface public, static và
final
 Giao diện không chứa toán tử tạo lập (vì nó không thể được sử dụng để tạo ra đối
tượng).

Tại sao và khi nào nên sử dụng interfaces?

1) Để đạt được tính an nin - ẩn các chi tiết bên trong (các phương thức đều là public và
abstract) và chỉ hiển thị các thông tin quan trọng của một đối tượng (tên các phương thức
trừu tượng – không có nội dung, và các thuộc tính với tính chất public static final – công
khai, đại diện chung cho lớp và không được phép ghi đè).

2) Java không hỗ trợ "multiple inheritance" (một lớp chỉ được phép kế thừa từ một lớp
cha). Tuy nhiên, có thể đạt được quan hệ kế thừa với giao diện, vì một lớp có thể triển
khai (implement) nhiều interfaces.

Lưu ý: Để triển khai nhiều interface, chúng phải ngăn cách nhau bởi dấu phảy.

Ví dụ:

interface FirstInterface {
public void myMethod(); // interface method
}
interface SecondInterface {
public void myOtherMethod(); // interface method
}
class DemoClass implements FirstInterface, SecondInterface {
public void myMethod() {
System.out.println("Some text..");
}
public void myOtherMethod() {
 System.out.println("Some other text...");
}
}

class MyMainClass {
public static void main(String[] args) {
DemoClass myObj = new DemoClass();
myObj.myMethod();
myObj.myOtherMethod();
}
}
 LAB_07: TỔNG HỢP
7.1. Mục đích

Ôn tập tổng thể các kiến thức đã học qua thực hành gồm:

- Nạp chồng, viết đề phương thức, che bóng biến

- Các mối quan hệ kế thừa, phụ thuộc và và quan hệ composition giữa các lớp và
quan hệ triển khai giữa lớp và giao diện

- Hiểu về khái niệm đa hình, bao bọc và che dấu thông tin trong Java

- Phân biệt giữa giao diện và lớp trừu tượng

- Hiểu về luồng (thread) trong Java, đa luồng (multi-threads) và phương thức đồng
bộ hóa

7.2 Yêu cầu

- Sinh viên ôn lại toàn bộ kiến thức đã học để chuẩn bị cho nội dung thực hành

- Sinh viên phải có khả năng cài đặt chương trình Java với biểu đồ thiết kế lớp đối
tượng cho trước.

7.3 Nội dung thực hành

LAB_7A: Bao bọc & che dấu thông tin (Java Encapsulation&information hiding)
Viết chương trình cài đặt các lớp theo sơ đồ thiết kế sau:
LAB_7B: Lớp trừu tượng & lớp cụ thể (Abstract Superclass &Concrete Subclasses)
Viết chương trình cài đặt biểu đồ thiết kế lớp sau:

LAB_7C: Quan hệ Composition giữa các lớp

1.VIết chương trình cài đặt biểu đồ lớp với quan hệ Composition như sau:
2.Viết chương trình cài đặt biểu đồ lớp sau:

3.Viết chương trình cài đặt biểu đồ lớp sau:

LAB_7D: Đa hình thông qua kế thừa và viết đè (Java Polymorphism)

1. Viết chương trình cài đặt các lớp “HinhTron” – “Cycle” và lớp “HinhTru” –
“Cylinder” có quan hệ kế thừa như biểu đồ hình dưới đây. Viết đề các phương
thức getArea(), toString() trong lớp Hình trụ và minh họa cơ chế đa hình thể hiện
như thế nào?
 2. Viết chương trình cài đặt các lớp theo sơ đồ thiết kế sau. Minh họa cơ chế đa hình
thể hiện như thế nào?

Lưu ý: Đa hình rất tiềm lựa trong OOP trong việc phân tách giao diện (interface) và
việc triển khai (implementation) của nó. Điều này cho phép lập trình viên lập trình ở
mức giao diện khi thiết kế một hệ thống phức tạp.

LAB_7E: Luồng, đa luồng và đồng bộ hóa phương thức trong Java (Java Threads,
multi-threads and synchononized methods)
Viết chương trình Java minh họa cơ chế thực hiện đa luồng và minh họa tác dụng của
đồng bộ hóa của phương thức.

7.4 Hướng dẫn chung

 Bao bọc và che dấu thông tin (Java Encapsulation and information hiding)

Bao bọc là đóng gói các thuộc tính và các phương thức của các đối tượng cụ thể vào
trong một cấu trúc gọi là lớp đối tượng, sau đó với những dữ liệu "sensitive" ta cần
thiết lập với tính chất private để che dấu đi.

Để đạt được điều này, chúng ta cần:

- Khai báo các biến/thuộc tính của lớp với tính chất private

- Cung cấp các phương thức get và set để truy cập và cập nhật giá trị của các
biến private.

 Đa xạ/đa hình, kế thừa và viết đè.

Polymorphism có nghĩa là đa hình, ví dụ, trong ngành hóa học, carbon biểu hiện cho
tính đa hình vì nó có nhiều hơn một hình dạng: exhibits polymorphism because it can
be found in more than one form: than chì (graphite) và kim cương (diamond). Nhưng
mỗi hình dạng lại có những thuộc tính riêng biệt.

Đa hình xảy ra khi chúng ta có nhiều lớp liên quan với nhau bởi quan hệ kế thừa. Kế
thừa cho phép chúng ta sử dụng các thuộc tính và các phương thức từ lớp khác. Đa
hình sử dụng các phương thức để thực hiện một hành động với nhiều cách khác nhau.

Ví dụ: ta có lớp cha là Animal chứa phương thức animalSound(). Các lớp con của
Animals có thể là Pigs, Cats, Dogs, Birds – và mỗi lớp cài đặt phương thức
animalSound() theo cách riêng (ví dụ pig kêu ụt ịt, và mèo kêu meo, ...):

Ví dụ:

class Animal {
public void animalSound() {
System.out.println("The animal makes a sound");
}
}

class Pig extends Animal {

public void animalSound() {
System.out.println("The pig says: wee wee");
}
}

class Dog extends Animal {

public void animalSound() {
System.out.println("The dog says: bow wow");
}
}
class Cat extends Animal {
public void animalSound() {
System.out.println("The cat says: meo meo");
}
}

class MyMainClass {
public static void main(String[] args) {
Animal myAnimal = new Animal(); // Create a Animal object
Animal myPig = new Pig(); // Create a Pig object
Animal myDog = new Dog(); // Create a Dog object
Animal myCat = new Cat(); // Create a Cat object

myAnimal.animalSound();
myPig.animalSound(); // kêu ụt ịt
myDog.animalSound(); // kêu gâu gâu
myCat.animalSound(); // kêu meo meo
}
}

Khi nào nên sử dụng kế thừa (Inheritance) và đa hình (Polymorphism)?

- Truyền một thông điệp chung đến một đối tượng và mỗi đối tượng có các xử lý
riêng theo ngữ cảnh của mình. Cơ sở của đa hình chính là nạp chồng, viết đè và
kế thừa.
- Một đối tượng có nhiều hình dạng và đặc tính khác nhau tùy theo từng hình
dạng.

 Luồng, đa luồng và đồng bộ hóa phương thức trong Java (Java Threads,
multi-threads and synchononized methods)

Các luồng (Threads) cho phép chương trình vận hành một cách hiệu quả hơn bằng cách cho
phép nhiều thứ thực hiện một cách đồng thời.

Các luồng có thể được sử dụng để thực thi các nhiệm vụ phức tạp mà không cần phải ngắt
chương trình chính.
Tạo một Thread

Có 2 cách để tạo một luồng:

Cách 1: Tạo một luồng bằng cách kế thừa và mở rộng lớp Thread và viết đè phương thức
run() theo cú pháp:

public class MyClass extends Thread {

public void run() {
System.out.println("This code is running in a thread");
}
}

Cách 2: Tạo một luồng bằng cách implement giao diện Runnable theo cú pháp:

public class MyClass implements Runnable {

public void run() {
System.out.println("This code is running in a thread");
}
}
Chạy Threads

- Nếu lớp là mở rộng của lớp Thread, một luồng có thể chạy bằng cách tạo một đối
tượng luồng thuộc lớp này và gọi phương thức start()của nó:

Ví dụ:

public class MyClass extends Thread {

public static void main(String[] args) {
MyClass thread = new MyClass();
thread.start();
System.out.println("This code is outside of the thread");
}
public void run() {
System.out.println("This code is running in a thread");
}
}

- Nếu lớp implements giao diện Runnable, luồng có thể chạy bằng cách truyền thể
hiện của lớp cho phương thức khởi tạo của luồng, sau đó gọi phương thức
start()của luồng.

Ví dụ:

public class MyClass implements Runnable {

public static void main(String[] args) {
 MyClass obj = new MyClass();
Thread thread = new Thread(obj);
thread.start();
System.out.println("This code is outside of the thread");
}
public void run() {
System.out.println("This code is running in a thread");
}
}

Đa luồng và phương thức đồng bộ hóa (multi-threads and synchononized

methods)

- Đa luồng: cho phép nhiều luồng cùng thực hiện đồng thời

- Đồng bộ hóa: Chỉ cho phép một luồng triệu gọi phương thức đồng bộ hóa thực
hiện tại một thời điểm.

7.5. Mã nguồn mẫu

Viết chương trình cài đặt biểu đồ thiết kế UML sau:
 Gợi ý viết mã nguồn:

public interface Movable {//saved as "Movable.java"

public void moveUp();
......
}

public class MovablePoint implements Movable {//saved as "MovablePoint.java"

// instance variables
int x, y, xSpeed, ySpeed; // package access

// Constructor
public MovablePoint(int x, int y, int xSpeed, int ySpeed) {
this.x = x;
......
}
......

// Implement abstract methods declared in the interface Movable

@Override
public void moveUp() {
y -= ySpeed; // y-axis pointing down for 2D graphics
}
......
}

public class MovableCircle implements Movable{//saved as "MovableCircle.java"

// instance variables
private MovablePoint center; // can use center.x, center.y directly
// because they are package accessible
private int radius;

// Constructor
public MovableCircle(int x, int y, int xSpeed, int ySpeed, int radius) {
// Call the MovablePoint's constructor to allocate the center instance.
center = new MovablePoint(x, y, xSpeed, ySpeed);
......
}
......

// Implement abstract methods declared in the interface Movable

@Override
public void moveUp() {
center.y -= center.ySpeed;
}
......
 }

Viết lớp Test chứa hàm main với các lệnh như sau:

Movable m1 = new MovablePoint(5, 6, 10, 15); // upcast

System.out.println(m1);
m1.moveLeft();
System.out.println(m1);

Movable m2 = new MovableCircle(1, 2, 3, 4, 20); // upcast

System.out.println(m2);
m2.moveRight();
System.out.println(m2);

Viết lớp MovableRectangle, gồm 2 điểm MovablePoints (biểu diễn góc các góc top-
leftvà bottom-right) và implementing giao diện Movable (lưu ý rằng 2 điểm này phải có
cùng speed).
 MỘT SỐ BÀI TẬP LÀM THÊM

Bài 1
Một đơn vị sản xuất cần quản lý các cán bộ là công nhân, kỹ sư và nhân viên. Cụ thể:
+Mỗi cán bộ cần quản lý các thuộc tính: Họ tên, năm sinh, giới tính, địa chỉ
+ Các công nhân cần quản lý: Bậc (công nhân bậc 3/7, bậc 4/7 ...)
+ Các kỹ sư cần quản lý: Ngành đào tạo
+ Các nhân viên phục vụ cần quản lý thông tin: công việc
1. Xây dựng các lớp NhanVien, CongNhan, KySu kế thừa từ lớp CanBo. Trong
mỗi lớp xây dựng các hàm nhập và hiển thị thông tin về các thuộc tính của lớp.
2. Xây dựng lớp QuanLyCanBo cài đặt các phương thức thực hiện các chức năng
sau:
- Nhập thông tin mới cho n cán bộ
- Tìm kiếm theo họ tên
- Hiển thị thông tin về danh sách các cán bộ
- Thoát khỏi chương trình.
Bài 2
Một thư viện cần quản lý các tài liệu bao gồm, Sách, Tạp chí, Báo. Cụ thể:
+ Mỗi tài liệu có các thuộc tính: Mã tài liệu, Tên nhà xuất bản, Số bản phát hành.
+ Các loại sách cần quản lý: Tên tác giả, số trang
+ Các tạp chí cần quản lý: Số phát hành, tháng phát hành
+ Các báo cần quản lý: ngày phát hành.
1. Xây dựng các lớp để quản lý các loại tài liệu trên sao cho việc sử dụng lại được
nhiều nhất.
2. Xây dựng lớp QuanLySach cài đặt các phương thức thực hiện các công việc
sau:
- Nhập thông tin về các tài liệu
- Hiển thị thông tin về các tài liệu
- Tìm kiếm tài liệu theo loại
- Thoát khỏi chương trình
Bài 3
Các thí sinh dự thi đại học bao gồm các thí sinh thi khối A, thí sinh thi khối B, thí sinh thi
khối C. Cụ thể:
+ Các thí sinh cần quản lý các thuộc tính: Số báo danh, họ tên, địa chỉ, ưu tiên.
+ Thí sinh thi khối A thi các môn: Toán, lý, hoá
+ Thí sinh thi khối B thi các môn: Toán, Hoá, Sinh
+ Thí sinh thi khối C thi các môn: văn, Sử, Địa
1. Xây dựng các lớp tương ứng để quản lý các thí sinh sao cho sử dụng lại được
nhiều nhất có thể.
2. Xây dựng lớp TuyenSinh cài đặt các phương thức thực hiện các nhiệm vụ sau:
- Nhập thông tin về các thí sinh dự thi
- Hiển thị thông tin về một thí sinh
- Tìm kiếm theo số báo danh
- Kết thúc chương trình.
Bài 4
Để quản lý các hộ dân trong một khu phố, người ta quản lý các thông tin như sau:
- Với mỗi hộ dân, có các thuộc tính:
+ Số thành viên trong hộ (số người)
+ Số nhà của hộ dân đó (số nhà được gắn cho mỗi hộ dân)
+ Thông tin về mỗi cá nhân trong hộ gia đình.
- Với mỗi cá nhân, người ta quản lý các thông tin như: họ tên, năm sinh, nghề
nghiệp.
1. Hãy xây dựng lớp Nguoi để quản lý thông tin về mỗi cá nhân.
Viết các phương thức nhập, hiển thị thông tin cho mỗi cá nhân.
2. Xây dựng lớp Hộ dân để quản lý các thông tin của mỗi hộ dân
Viết các phương thức nhập, hiển thị thông tin cho mỗi hộ dân. Tìm kiếm cá nhân
trong hộ theo họ tên.
3. Xây dựng lớp KhuPho để quản lý thông tin về các hộ dân trong khu phố gồm
các phương thức:
i. Nhập vào một dãy gồm n hộ dân (n - nhập từ bàn phím).
 ii. Hiển thị ra màn hình thông tin về các hộ trong khu phố.
iii. Tìm và hiển thị thông tin các cá nhân trong khu phố có họ tên nhập vào từ
bàn phím.
Bài 5
Để quản lý khách hàng đến thuê phòng trọ của một khách sạn, người ta cần quản lý
những thông tin sau:
- Số ngày trọ, loại phòng trọ, giá phòng, và các thông tin cá nhân về mỗi khách trọ.
- Với mỗi cá nhân, người ta cần quản lý các thông tin: Họ và tên, năm sinh, số
chứng minh thư nhân dân.
1. Hãy xây dựng lớp Nguoi để quản lý thông tin cá nhân về mỗi cá nhân
2. Xây dựng lớp KhachSan để quản lý các thông tin về khách trọ.
- Viết các phương thức: nhập, hiển thị các thông tin về mỗi khách trọ
- Hàm main thực hiện các công việc sau:
o Nhập vào một dãy gồm n khách trọ (n - nhập từ bàn phím)
o Hiển thị ra màn hình thông tin về các cá nhân hiện đang trọ ở khách sạn đó.