Bài 3: Inheritance (Kế thừa) trong Java

I. Định nghĩa và các loại kế thừa

Định nghĩa Inheritance:

Inheritance (Kế thừa) là một cơ chế trong lập trình hướng đối tượng cho phép một lớp (class) thừa hưởng các thuộc tính và phương thức từ một lớp khác. Lớp con (subclass) có thể mở rộng hoặc thay thế các phương thức của lớp cha (superclass).

Các loại kế thừa:

1. Single Inheritance (Kế thừa đơn):

   • Một lớp con thừa hưởng từ một lớp cha duy nhất.

   • Ví dụ: class Dog extends Animal { ... }

2. Multilevel Inheritance (Kế thừa đa cấp):

   • Một lớp con thừa hưởng từ một lớp cha, và lớp cha đó lại thừa hưởng từ một lớp khác.

   • Ví dụ: class Puppy extends Dog { ... } và class Dog extends Animal { ... }

3. Hierarchical Inheritance (Kế thừa phân cấp):

   • Nhiều lớp con thừa hưởng từ một lớp cha chung.

   • Ví dụ: class Dog extends Animal { ... } và class Cat extends Animal { ... }

II. Ưu điểm và nhược điểm của Inheritance

Ưu điểm:

• Tái sử dụng mã nguồn: Các lớp con có thể sử dụng lại mã nguồn của lớp cha, giảm thiểu việc viết lại mã.

• Tính linh hoạt: Cho phép mở rộng và thay đổi hành vi của lớp cha trong lớp con.

Nhược điểm:

• Tight coupling (Liên kết chặt chẽ): Lớp con phụ thuộc chặt chẽ vào lớp cha, có thể gây khó khăn khi thay đổi lớp cha.

• Khó khăn trong bảo trì: Khi có quá nhiều lớp kế thừa, hệ thống trở nên phức tạp và khó bảo trì.

III. Ví dụ minh họa về từng loại kế thừa

Single Inheritance (Kế thừa đơn):

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

class Dog extends Animal {
    void bark() {
        System.out.println("The dog barks.");
    }

    public static void main(String[] args) {
        Dog dog = new Dog();
        dog.eat();  // Sử dụng phương thức từ lớp cha
        dog.bark(); // Sử dụng phương thức từ lớp con
    }
}

Multilevel Inheritance (Kế thừa đa cấp):

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

class Dog extends Animal {
    void bark() {
        System.out.println("The dog barks.");
    }
}

class Puppy extends Dog {
    void weep() {
        System.out.println("The puppy weeps.");
    }

    public static void main(String[] args) {
        Puppy puppy = new Puppy();
        puppy.eat();   // Sử dụng phương thức từ lớp cha
        puppy.bark();  // Sử dụng phương thức từ lớp trung gian
        puppy.weep();  // Sử dụng phương thức từ lớp con
    }
}

Hierarchical Inheritance (Kế thừa phân cấp):

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

class Dog extends Animal {
    void bark() {
        System.out.println("The dog barks.");
    }
}

class Cat extends Animal {
    void meow() {
        System.out.println("The cat meows.");
    }

    public static void main(String[] args) {
        Dog dog = new Dog();
        Cat cat = new Cat();

        dog.eat();  // Sử dụng phương thức từ lớp cha
        dog.bark(); // Sử dụng phương thức từ lớp con

        cat.eat();  // Sử dụng phương thức từ lớp cha
        cat.meow(); // Sử dụng phương thức từ lớp con
    }
}

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

Bài tập: Tạo một hệ thống quản lý thư viện với các lớp kế thừa.

Yêu cầu:

1. Tạo lớp Item với các thuộc tính title, publisher, và year.

2. Tạo các lớp Book, Magazine, và DVD kế thừa từ lớp Item.

3. Thêm các thuộc tính và phương thức đặc trưng cho mỗi loại item.

4. Viết chương trình chính để tạo các đối tượng và hiển thị thông tin của chúng.

Mã nguồn mẫu:

class Item {
    private String title;
    private String publisher;
    private int year;

    public Item(String title, String publisher, int year) {
        this.title = title;
        this.publisher = publisher;
        this.year = year;
    }

    public String getTitle() {
        return title;
    }

    public String getPublisher() {
        return publisher;
    }

    public int getYear() {
        return year;
    }

    public void displayInfo() {
        System.out.println("Title: " + title);
        System.out.println("Publisher: " + publisher);
        System.out.println("Year: " + year);
    }
}

class Book extends Item {
    private String author;

    public Book(String title, String publisher, int year, String author) {
        super(title, publisher, year);
        this.author = author;
    }

    public String getAuthor() {
        return author;
    }

    @Override
    public void displayInfo() {
        super.displayInfo();
        System.out.println("Author: " + author);
    }
}

class Magazine extends Item {
    private int issueNumber;

    public Magazine(String title, String publisher, int year, int issueNumber) {
        super(title, publisher, year);
        this.issueNumber = issueNumber;
    }

    public int getIssueNumber() {
        return issueNumber;
    }

    @Override
    public void displayInfo() {
        super.displayInfo();
        System.out.println("Issue Number: " + issueNumber);
    }
}

class DVD extends Item {
    private int duration;

    public DVD(String title, String publisher, int year, int duration) {
        super(title, publisher, year);
        this.duration = duration;
    }

    public int getDuration() {
        return duration;
    }

    @Override
    public void displayInfo() {
        super.displayInfo();
        System.out.println("Duration: " + duration + " minutes");
    }
}

public class LibrarySystem {
    public static void main(String[] args) {
        Book book = new Book("Java Programming", "O'Reilly Media", 2020, "John Doe");
        Magazine magazine = new Magazine("Science Monthly", "Nature Publishing Group", 2021, 7);
        DVD dvd = new DVD("Inception", "Warner Bros.", 2010, 148);

        System.out.println("Book Info:");
        book.displayInfo();
        System.out.println();

        System.out.println("Magazine Info:");
        magazine.displayInfo();
        System.out.println();

        System.out.println("DVD Info:");
        dvd.displayInfo();
    }
}

Tổng kết

Bài học này cung cấp một cái nhìn chi tiết về Inheritance (Kế thừa) trong Java, bao gồm định nghĩa, các loại kế thừa, ưu điểm và nhược điểm, cũng như các ví dụ minh họa cụ thể. Việc nắm vững 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à tái sử dụng mã nguồn hiệu quả.