Bài 8: Interface và Abstract Class trong Java

I. Sự khác biệt giữa Interface và Abstract Class

Interface:

1. Định nghĩa:

   • Interface là một bản thiết kế cho các lớp, định nghĩa các phương thức nhưng không có thân hàm (cho đến Java 8, từ Java 8 trở đi, interface có thể có các phương thức mặc định và phương thức tĩnh có thân hàm).

   • Sử dụng từ khóa interface để khai báo một interface.

2. Khi nào sử dụng:

   • Sử dụng khi bạn muốn định nghĩa một bộ hợp đồng cho các lớp thực hiện mà không quan tâm đến cài đặt cụ thể.

   • Một lớp có thể thực hiện nhiều interface.

Ví dụ về Interface:

interface Animal {
    void makeSound();
    void eat();
}

class Dog implements Animal {
    @Override
    public void makeSound() {
        System.out.println("Bark");
    }

    @Override
    public void eat() {
        System.out.println("The dog eats food.");
    }
}

public class Main {
    public static void main(String[] args) {
        Dog dog = new Dog();
        dog.makeSound();
        dog.eat();
    }
}

Abstract Class:

1. Định nghĩa:

   • Abstract class là một lớp không thể tạo đối tượng trực tiếp từ nó, mà phải được kế thừa bởi các lớp con. Nó có thể chứa các phương thức trừu tượng (không có thân hàm) và các phương thức thông thường (có thân hàm).

   • Sử dụng từ khóa abstract để khai báo một lớp trừu tượng.

2. Khi nào sử dụng:

   • Sử dụng khi bạn muốn định nghĩa một lớp cơ sở với một số phương thức mặc định hoặc phương thức với thân hàm.

   • Một lớp chỉ có thể kế thừa từ một abstract class.

Ví dụ về Abstract Class:

abstract class Animal {
    abstract void makeSound();

    void eat() {
        System.out.println("This animal eats food.");
    }
}

class Dog extends Animal {
    @Override
    void makeSound() {
        System.out.println("Bark");
    }
}

public class Main {
    public static void main(String[] args) {
        Dog dog = new Dog();
        dog.makeSound();
        dog.eat();
    }
}

Sự khác biệt chính:

• Interface chỉ định nghĩa phương thức mà không có thân hàm (trừ phương thức mặc định và tĩnh), còn abstract class có thể có cả phương thức trừu tượng và phương thức thông thường.

• Một lớp có thể thực hiện nhiều interface nhưng chỉ có thể kế thừa từ một abstract class.

II. Ví dụ cụ thể

Tạo Interface và Abstract Class:

interface Drivable {
    void drive();
}

abstract class Vehicle {
    private String make;
    private String model;

    public Vehicle(String make, String model) {
        this.make = make;
        this.model = model;
    }

    public String getMake() {
        return make;
    }

    public String getModel() {
        return model;
    }

    abstract void start();

    void stop() {
        System.out.println("The vehicle has stopped.");
    }
}

class Car extends Vehicle implements Drivable {
    public Car(String make, String model) {
        super(make, model);
    }

    @Override
    void start() {
        System.out.println("The car is starting.");
    }

    @Override
    public void drive() {
        System.out.println("The car is being driven.");
    }
}

public class Main {
    public static void main(String[] args) {
        Car car = new Car("Toyota", "Corolla");
        car.start();
        car.drive();
        car.stop();
    }
}

III. Bài tập thực hành

Bài tập: Tạo một hệ thống quản lý nhân sự sử dụng interface và abstract class.

Yêu cầu:

1. Tạo interface Payable với phương thức calculatePay().

2. Tạo abstract class Employee với các thuộc tính id, name, và phương thức trừu tượng work().

3. Tạo các lớp con FullTimeEmployee và PartTimeEmployee kế thừa từ Employee và thực hiện interface Payable.

4. Viết chương trình chính để tạo các đối tượng và gọi các phương thức.

Mã nguồn mẫu:

interface Payable {
    double calculatePay();
}

abstract class Employee {
    private int id;
    private String name;

    public Employee(int id, String name) {
        this.id = id;
        this.name = name;
    }

    public int getId() {
        return id;
    }

    public String getName() {
        return name;
    }

    abstract void work();
}

class FullTimeEmployee extends Employee implements Payable {
    private double salary;

    public FullTimeEmployee(int id, String name, double salary) {
        super(id, name);
        this.salary = salary;
    }

    @Override
    void work() {
        System.out.println(getName() + " is working full time.");
    }

    @Override
    public double calculatePay() {
        return salary;
    }
}

class PartTimeEmployee extends Employee implements Payable {
    private double hourlyRate;
    private int hoursWorked;

    public PartTimeEmployee(int id, String name, double hourlyRate, int hoursWorked) {
        super(id, name);
        this.hourlyRate = hourlyRate;
        this.hoursWorked = hoursWorked;
    }

    @Override
    void work() {
        System.out.println(getName() + " is working part time.");
    }

    @Override
    public double calculatePay() {
        return hourlyRate * hoursWorked;
    }
}

public class Main {
    public static void main(String[] args) {
        FullTimeEmployee fullTimeEmployee = new FullTimeEmployee(1, "Alice", 60000);
        PartTimeEmployee partTimeEmployee = new PartTimeEmployee(2, "Bob", 20, 100);

        fullTimeEmployee.work();
        System.out.println("Full-time employee pay: " + fullTimeEmployee.calculatePay());

        partTimeEmployee.work();
        System.out.println("Part-time employee pay: " + partTimeEmployee.calculatePay());
    }
}

Tổng kết

Bài học này cung cấp một cái nhìn chi tiết về sự khác biệt giữa interface và abstract class trong Java, bao gồm định nghĩa, lợi ích, cách sử dụng và các ví dụ minh họa cụ thể. Việc nắm vững các khái niệm này sẽ giúp bạn xây dựng các hệ thống phần mềm linh hoạt và mạnh mẽ, cải thiện hiệu quả phát triển phần mềm.