Bài 10: LỚP TRỪU TƯỢNG VÀ INTERFACE – ĐỊNH NGHĨA HỢP ĐỒNG TRONG OOP

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 interface và 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 ClassInterface
Từ khóaabstract classinterface
Kế thừaextendsimplements
Đa kế thừaKhôngCó (một lớp implement nhiều interface)
Phương thứcCó thể có phương thức abstract và non-abstractTrước Java 8: chỉ abstract. Java 8+: có default, static
Thuộc tínhCó thể có thuộc tính thông thườngChỉ có hằng số (public static final)
ConstructorCóKhông
Mục đíchTạ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)

  1. Câu 1: Abstract class và interface khác nhau như thế nào? Cho ví dụ minh họa.
  2. 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?
  3. Câu 3: Khi nào nên dùng abstract class? Khi nào nên dùng interface?
  4. 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ì?
  5. 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ử

  1. Tạo abstract class ThietBiDienTu vớ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()
  2. Tạo interface CoTheKetNoiInternet với phương thức ketNoiWifi(), ngatKetNoi()
  3. Tạo interface CoTheCamUng với phương thức cham(), vuot()
  4. Tạo lớp DienThoaiThongMinh kế thừa ThietBiDienTu và implement cả 2 interface
  5. Tạo lớp MayTinhBang và Laptop với các chức năng phù hợp

Bài 2: Hệ thống nhân viên với interface

  1. Tạo interface CoTheTinhLuong với phương thức tinhLuong()
  2. Tạo interface CoTheXepLoai với phương thức xepLoai()
  3. Tạo abstract class NhanVien với thuộc tính cơ bản
  4. Tạo các lớp NhanVienVanPhong, NhanVienKinhDoanh, QuanLy implement các interface phù hợp
  5. 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

  1. Tạo interface CoTheQuay với phương thức quay(double goc)
  2. Tạo interface CoTheDiChuyen với phương thức diChuyen(double x, double y)
  3. Tạo abstract class HinhHoc như ví dụ trên
  4. Tạo các lớp HinhTron, HinhVuong, HinhTamGiac implement các interface phù hợp
  5. 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:

  1. Interface CoTheTanCong với phương thức tanCong(), tanCong(String kyNang)
  2. Interface CoThePhepHoat với phương thức suDungPhep(), hoiMana()
  3. Interface CoTheTrangBi với phương thức trangBiDo(), thaoDo()
  4. Abstract class NhanVat với thuộc tính cơ bản
  5. Các lớp ChienBinh, PhapSu, CungThu kế thừa và implement interface phù hợp
  6. 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:

  1. Abstract class TaiLieu với thuộc tính: maTL, tenTL, tacGia
  2. Interface CoTheMuon với phương thức muon(), tra(), kiemTraTrangThai()
  3. Interface CoTheGiaHan với phương thức giaHan()
  4. Các lớp Sach, Bao, TapChi kế thừa TaiLieu và implement interface phù hợp
  5. 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 / extends vs interface / 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!

Comments are closed.