Chào các nhà kiến trúc phần mềm tương lai! Hôm nay chúng ta sẽ khám phá hai khái niệm quan trọng nhất để thiết kế hệ thống linh hoạt và mở rộng – Abstract Class (Lớp trừu tượng) và Interface (Giao diện). Đây là công cụ để định nghĩa “hợp đồng” trong lập trình OOP!
I. PHẦN LÝ THUYẾT
1. Vấn đề với kế thừa thông thường
Khi sử dụng kế thừa thông thường, chúng ta gặp vấn đề:
- Lớp cha có phương thức không cần thiết cho lớp con
- Không thể ép buộc lớp con phải triển khai phương thức cụ thể
- Java chỉ cho phép đơn kế thừa (1 lớp con ← 1 lớp cha)
2. Lớp trừu tượng (Abstract Class) – “Bán thành phẩm”
Abstract Class là lớp:
- Không thể tạo đối tượng trực tiếp (
new AbstractClass()sẽ lỗi) - Có thể chứa phương thức trừu tượng (abstract method) – chỉ khai báo, không có thân
- Cũng có thể chứa phương thức thông thường (có thân)
- Dùng từ khóa
abstractđể định nghĩa
abstract class DongVat {
// Thuộc tính bình thường
String ten;
// Phương thức thông thường
void ngu() {
System.out.println("Đang ngủ...");
}
// Phương thức TRỪU TƯỢNG - không có thân
abstract void keu();
}3. Interface – “Bản hợp đồng thuần túy”
Interface là một “hợp đồng” thuần túy:
- Chỉ chứa hằng số (constants) và phương thức trừu tượng
- Từ Java 8: có thể có phương thức mặc định (default) và phương thức static
- Lớp triển khai interface phải implement tất cả phương thức
- Một lớp có thể implement NHIỀU interface (đa kế thừa)
- Dùng từ khóa
interfacevàimplements
interface CoTheBoi {
// Hằng số (mặc định là public static final)
int SO_CHAN = 2;
// Phương thức trừu tượng (mặc định là public abstract)
void boi();
// Phương thức mặc định (Java 8+)
default void thoNuoc() {
System.out.println("Đang thở dưới nước...");
}
}4. So sánh Abstract Class vs Interface
| Tiêu chí | Abstract Class | Interface |
|---|---|---|
| Từ khóa | abstract class | interface |
| Kế thừa | extends | implements |
| Đa kế thừa | Không | Có (một lớp implement nhiều interface) |
| Phương thức | Có thể có phương thức abstract và non-abstract | Trước Java 8: chỉ abstract. Java 8+: có default, static |
| Thuộc tính | Có thể có thuộc tính thông thường | Chỉ có hằng số (public static final) |
| Constructor | Có | Không |
| Mục đích | Tạo lớp cơ sở có sẵn một phần cài đặt | Định nghĩa hợp đồng/chức năng |
5. Khi nào dùng cái nào?
Dùng Abstract Class khi:
- Các lớp con có chung trạng thái/hành vi cần kế thừa
- Muốn cung cấp cài đặt mặc định
- Làm lớp cơ sở trong hệ thống phân cấp “IS-A”
Dùng Interface khi:
- Định nghĩa hợp đồng mà nhiều lớp không liên quan phải tuân theo
- Cần đa kế thừa
- Muốn định nghĩa chức năng (CAN-DO) thay vì bản chất (IS-A)
II. PHẦN THỰC HÀNH
Ví dụ 1: Hệ thống hình học với Abstract Class
// Abstract Class: Hình học
abstract class HinhHoc {
protected String mauSac;
// Constructor trong abstract class
public HinhHoc(String mauSac) {
this.mauSac = mauSac;
}
// Phương thức thông thường
public String getMauSac() {
return mauSac;
}
public void setMauSac(String mauSac) {
this.mauSac = mauSac;
}
// Phương thức trừu tượng - lớp con PHẢI implement
public abstract double tinhDienTich();
public abstract double tinhChuVi();
// Phương thức trừu tượng có tham số
public abstract void phongTo(double tyLe);
// Phương thức có sẵn implementation
public void hienThiThongTin() {
System.out.println("Màu sắc: " + mauSac);
System.out.println("Diện tích: " + tinhDienTich());
System.out.println("Chu vi: " + tinhChuVi());
}
}// Lớp con: Hình tròn
class HinhTron extends HinhHoc {
private double banKinh;
public HinhTron(String mauSac, double banKinh) {
super(mauSac); // Gọi constructor của lớp cha
this.banKinh = banKinh;
}
@Override
public double tinhDienTich() {
return Math.PI * banKinh * banKinh;
}
@Override
public double tinhChuVi() {
return 2 * Math.PI * banKinh;
}
@Override
public void phongTo(double tyLe) {
this.banKinh *= tyLe;
System.out.println("Phóng to hình tròn lên " + tyLe + " lần");
}
// Phương thức riêng
public double tinhDuongKinh() {
return banKinh * 2;
}
}// Lớp con: Hình vuông
class HinhVuong extends HinhHoc {
private double canh;
public HinhVuong(String mauSac, double canh) {
super(mauSac);
this.canh = canh;
}
@Override
public double tinhDienTich() {
return canh * canh;
}
@Override
public double tinhChuVi() {
return canh * 4;
}
@Override
public void phongTo(double tyLe) {
this.canh *= tyLe;
System.out.println("Phóng to hình vuông lên " + tyLe + " lần");
}
// Phương thức riêng
public double tinhDuongCheo() {
return canh * Math.sqrt(2);
}
}Ví dụ 2: Hệ thống với Interface
// Interface 1: Có thể bay
interface CoTheBay {
// Hằng số
int SO_CANH = 2;
// Phương thức trừu tượng
void bay();
// Phương thức mặc định (Java 8+)
default void haCanh() {
System.out.println("Đang hạ cánh...");
}
// Phương thức static (Java 8+)
static void thongTinVeBay() {
System.out.println("Bay là di chuyển trong không trung");
}
}// Interface 2: Có thể bơi
interface CoTheBoi {
void boi();
default void lapLai() {
System.out.println("Lặp lại động tác bơi...");
}
}// Interface 3: Có thể chạy
interface CoTheChay {
void chay();
// Overloading trong interface
void chay(double tocDo);
default void nghiNgoi() {
System.out.println("Nghỉ ngơi sau khi chạy");
}
}// Abstract class: Động vật
abstract class DongVat {
protected String ten;
protected int tuoi;
public DongVat(String ten, int tuoi) {
this.ten = ten;
this.tuoi = tuoi;
}
// Phương thức trừu tượng
public abstract void an();
// Phương thức thông thường
public void ngu() {
System.out.println(ten + " đang ngủ...");
}
public void hienThiThongTin() {
System.out.println("Tên: " + ten);
System.out.println("Tuổi: " + tuoi);
}
}// Lớp Chim cánh cụt: Kế thừa abstract class + implement interface
class ChimCanhCut extends DongVat implements CoTheBoi {
public ChimCanhCut(String ten, int tuoi) {
super(ten, tuoi);
}
@Override
public void an() {
System.out.println(ten + " đang ăn cá...");
}
@Override
public void boi() {
System.out.println(ten + " đang bơi dưới nước rất giỏi!");
}
// Override phương thức mặc định
@Override
public void lapLai() {
System.out.println(ten + " lặp lại động tác bơi rất dễ thương!");
}
}// Lớp Vịt: Kế thừa abstract class + implement NHIỀU interface
class Vit extends DongVat implements CoTheBay, CoTheBoi, CoTheChay {
public Vit(String ten, int tuoi) {
super(ten, tuoi);
}
@Override
public void an() {
System.out.println(ten + " đang mổ thóc...");
}
@Override
public void bay() {
System.out.println(ten + " đang bay thấp...");
}
@Override
public void boi() {
System.out.println(ten + " đang bơi trên mặt nước...");
}
@Override
public void chay() {
System.out.println(ten + " đang chạy lạch bạch...");
}
@Override
public void chay(double tocDo) {
System.out.println(ten + " đang chạy với tốc độ " + tocDo + " km/h");
}
// Có thể sử dụng phương thức mặc định từ interface
public void hienThiTatCaKhNang() {
System.out.println("\n" + ten + " có thể:");
bay();
boi();
chay();
haCanh(); // Từ CoTheBay interface
nghiNgoi(); // Từ CoTheChay interface
}
}// Lớp Máy bay: KHÔNG kế thừa DongVat, chỉ implement interface
class MayBay implements CoTheBay {
private String ten;
private String hangSanXuat;
public MayBay(String ten, String hangSanXuat) {
this.ten = ten;
this.hangSanXuat = hangSanXuat;
}
@Override
public void bay() {
System.out.println(ten + " đang bay trên bầu trời!");
}
// Có thể override phương thức mặc định
@Override
public void haCanh() {
System.out.println(ten + " đang hạ cánh tại sân bay...");
}
public void hienThiThongTin() {
System.out.println("Tên máy bay: " + ten);
System.out.println("Hãng sản xuất: " + hangSanXuat);
System.out.println("Số cánh: " + CoTheBay.SO_CANH); // Truy cập hằng số
}
}// Chương trình chính
public class MainAbstractInterface {
public static void main(String[] args) {
System.out.println("=== ABSTRACT CLASS VÀ INTERFACE ===\n");
// Sử dụng abstract class
System.out.println("=== HÌNH HỌC ===");
HinhHoc hinh1 = new HinhTron("Đỏ", 5.0);
HinhHoc hinh2 = new HinhVuong("Xanh", 4.0);
hinh1.hienThiThongTin();
hinh1.phongTo(1.5);
System.out.println("Diện tích mới: " + hinh1.tinhDienTich());
System.out.println("\n---\n");
hinh2.hienThiThongTin();
System.out.println("Đường chéo: " + ((HinhVuong)hinh2).tinhDuongCheo());
System.out.println("\n=== ĐỘNG VẬT VÀ INTERFACE ===");
// Chim cánh cụt
ChimCanhCut chim = new ChimCanhCut("Pingu", 2);
chim.hienThiThongTin();
chim.an();
chim.boi();
chim.lapLai(); // Phương thức đã override
System.out.println("\n---\n");
// Vịt - implement nhiều interface
Vit vit = new Vit("Donald", 3);
vit.hienThiThongTin();
vit.hienThiTatCaKhNang();
System.out.println("\n---\n");
// Máy bay - chỉ implement interface
MayBay mayBay = new MayBay("Boeing 747", "Boeing");
mayBay.hienThiThongTin();
mayBay.bay();
mayBay.haCanh();
// Gọi phương thức static từ interface
CoTheBay.thongTinVeBay();
System.out.println("\n=== SỬ DỤNG ĐA HÌNH VỚI INTERFACE ===");
// Mảng chứa các đối tượng có thể bay
CoTheBay[] nhungThuCoTheBay = new CoTheBay[3];
nhungThuCoTheBay[0] = vit; // Vịt
nhungThuCoTheBay[1] = mayBay; // Máy bay
// nhungThuCoTheBay[2] = chim; // Lỗi! Chim cánh cụt không implement CoTheBay
System.out.println("\nNhững thứ có thể bay:");
for (CoTheBay bay : nhungThuCoTheBay) {
if (bay != null) {
bay.bay();
}
} Ví dụ 3: Interface thực tế – Comparable và Comparator
import java.util.Arrays;
import java.util.Comparator;
// Lớp SinhVien implement Comparable để có thể so sánh
class SinhVien implements Comparable<SinhVien> {
private String maSV;
private String hoTen;
private double diemTB;
public SinhVien(String maSV, String hoTen, double diemTB) {
this.maSV = maSV;
this.hoTen = hoTen;
this.diemTB = diemTB;
}
// Implement phương thức compareTo từ Comparable interface
@Override
public int compareTo(SinhVien other) {
// So sánh theo điểm TB (giảm dần)
return Double.compare(other.diemTB, this.diemTB);
}
@Override
public String toString() {
return maSV + " - " + hoTen + " - " + diemTB;
}
// Getter
public String getMaSV() { return maSV; }
public String getHoTen() { return hoTen; }
public double getDiemTB() { return diemTB; }
}// Comparator để so sánh theo mã SV
class SoSanhTheoMaSV implements Comparator<SinhVien> {
@Override
public int compare(SinhVien sv1, SinhVien sv2) {
return sv1.getMaSV().compareTo(sv2.getMaSV());
}
}// Comparator để so sánh theo tên
class SoSanhTheoTen implements Comparator<SinhVien> {
@Override
public int compare(SinhVien sv1, SinhVien sv2) {
return sv1.getHoTen().compareTo(sv2.getHoTen());
}
}// Chương trình chính
public class MainComparableComparator {
public static void main(String[] args) {
System.out.println("=== INTERFACE THỰC TẾ: COMPARABLE VÀ COMPARATOR ===\n");
SinhVien[] danhSachSV = {
new SinhVien("SV003", "Nguyễn Văn A", 7.5),
new SinhVien("SV001", "Trần Thị B", 8.2),
new SinhVien("SV002", "Lê Văn C", 6.8),
new SinhVien("SV004", "Phạm Thị D", 9.1)
};
System.out.println("Danh sách sinh viên ban đầu:");
for (SinhVien sv : danhSachSV) {
System.out.println(sv);
}
// Sắp xếp theo Comparable (điểm TB giảm dần)
Arrays.sort(danhSachSV);
System.out.println("\nSắp xếp theo điểm TB (giảm dần):");
for (SinhVien sv : danhSachSV) {
System.out.println(sv);
}
// Sắp xếp theo Comparator (mã SV)
Arrays.sort(danhSachSV, new SoSanhTheoMaSV());
System.out.println("\nSắp xếp theo mã SV:");
for (SinhVien sv : danhSachSV) {
System.out.println(sv);
}
// Sắp xếp theo Comparator (tên)
Arrays.sort(danhSachSV, new SoSanhTheoTen());
System.out.println("\nSắp xếp theo tên:");
for (SinhVien sv : danhSachSV) {
System.out.println(sv);
}
// Sử dụng Lambda Expression với Comparator (Java 8+)
System.out.println("\nSắp xếp theo điểm TB (tăng dần) dùng Lambda:");
Arrays.sort(danhSachSV, (sv1, sv2) -> Double.compare(sv1.getDiemTB(), sv2.getDiemTB()));
for (SinhVien sv : danhSachSV) {
System.out.println(sv);
}
}
}III. CÂU HỎI VÀ BÀI TẬP
Phần A: Câu hỏi lý thuyết (5 phút)
- Câu 1: Abstract class và interface khác nhau như thế nào? Cho ví dụ minh họa.
- Câu 2: Tại sao Java không cho phép đa kế thừa class nhưng cho phép đa kế thừa interface?
- Câu 3: Khi nào nên dùng abstract class? Khi nào nên dùng interface?
- Câu 4: Phương thức mặc định (default method) trong interface có từ phiên bản Java nào? Nó giải quyết vấn đề gì?
- Câu 5: Có thể tạo đối tượng từ abstract class không? Tại sao?
Phần B: Bài tập thực hành (25 phút)
Bài 1: Hệ thống thiết bị điện tử
- Tạo abstract class
ThietBiDienTuvới:- Thuộc tính:
ten,gia,hangSanXuat - Phương thức trừu tượng:
bat(),tat() - Phương thức thường:
hienThiThongTin()
- Thuộc tính:
- Tạo interface
CoTheKetNoiInternetvới phương thứcketNoiWifi(),ngatKetNoi() - Tạo interface
CoTheCamUngvới phương thứccham(),vuot() - Tạo lớp
DienThoaiThongMinhkế thừaThietBiDienTuvà implement cả 2 interface - Tạo lớp
MayTinhBangvàLaptopvới các chức năng phù hợp
Bài 2: Hệ thống nhân viên với interface
- Tạo interface
CoTheTinhLuongvới phương thứctinhLuong() - Tạo interface
CoTheXepLoaivới phương thứcxepLoai() - Tạo abstract class
NhanVienvới thuộc tính cơ bản - Tạo các lớp
NhanVienVanPhong,NhanVienKinhDoanh,QuanLyimplement các interface phù hợp - Tạo phương thức tính thưởng với cách tính khác nhau cho từng loại nhân viên
Bài 3: Hệ thống hình học nâng cao
- Tạo interface
CoTheQuayvới phương thứcquay(double goc) - Tạo interface
CoTheDiChuyenvới phương thứcdiChuyen(double x, double y) - Tạo abstract class
HinhHocnhư ví dụ trên - Tạo các lớp
HinhTron,HinhVuong,HinhTamGiacimplement các interface phù hợp - Tạo chương trình minh họa các hình có thể di chuyển và quay
Phần C: Thử thách nâng cao (20 phút)
Bài 4: Game nhập vai với interface
Tạo hệ thống game với:
- Interface
CoTheTanCongvới phương thứctanCong(),tanCong(String kyNang) - Interface
CoThePhepHoatvới phương thứcsuDungPhep(),hoiMana() - Interface
CoTheTrangBivới phương thứctrangBiDo(),thaoDo() - Abstract class
NhanVatvới thuộc tính cơ bản - Các lớp
ChienBinh,PhapSu,CungThukế thừa và implement interface phù hợp - Tạo hệ thống tính damage với công thức khác nhau cho từng lớp
Bài 5: Hệ thống quản lý thư viện với abstract và interface
Xây dựng hệ thống:
- Abstract class
TaiLieuvới thuộc tính:maTL,tenTL,tacGia - Interface
CoTheMuonvới phương thứcmuon(),tra(),kiemTraTrangThai() - Interface
CoTheGiaHanvới phương thứcgiaHan() - Các lớp
Sach,Bao,TapChikế thừaTaiLieuvà implement interface phù hợp - Tạo hệ thống tính phí mượn với cách tính khác nhau cho từng loại tài liệu
IV. TÓM TẮT BÀI HỌC
- Abstract Class: Lớp “bán thành phẩm”, có thể chứa phương thức abstract và non-abstract
- Interface: “Hợp đồng” thuần túy, định nghĩa chức năng (CAN-DO)
- Từ khóa:
abstract class/extendsvsinterface/implements - Đa kế thừa: Class không, Interface có
- Phương thức mặc định: Từ Java 8, cho phép thêm phương thức có implementation vào interface
- Ứng dụng thực tế: Comparable, Comparator, và nhiều interface trong Java API
P.S.: Thử thách đặc biệt: Hãy thiết kế một hệ thống đơn hàng (Order Management) sử dụng cả abstract class và interface, trong đó có các loại đơn hàng khác nhau (OnlineOrder, StoreOrder, PhoneOrder) với các phương thức xử lý và tính phí khác nhau!
