Tính Trừu Tượng (Abstraction)

"Trong lập trình hướng đối tượng, tính trừu tượng (Abstraction) là một nguyên lý quan trọng giúp ẩn đi những chi tiết phức tạp và chỉ hiển thị những thông tin cần thiết của đối tượng. Điều này không chỉ làm cho chương trình dễ sử dụng hơn mà còn cải thiện khả năng bảo trì và mở rộng. Dưới đây là những điều cơ bản bạn cần biết về tính trừu tượng trong Java."

Ⅰ. Trừu tượng (Abstraction) là gì?

Trừu tượng (Abstraction) là quá trình ẩn đi chi tiết triển khai và chỉ hiển thị chức năng cho người dùng. Nói cách khác, nó chỉ cho người dùng thấy những phần quan trọng và giấu đi các chi tiết bên trong. Trừu tượng giúp bạn tập trung vào những gì đối tượng làm thay vì cách nó làm.

Hiểu đơn giản về tính trừu tượng (Abstraction)

Hãy tưởng tượng bạn đang sử dụng một chiếc xe hơi. Bạn biết cách lái xe, bạn biết cách đổ xăng, nhưng bạn không cần biết chi tiết về cách động cơ hoạt động, hệ thống phanh hoạt động như thế nào. Đó chính là tính trừu tượng. Bạn chỉ cần biết cách sử dụng chiếc xe mà không cần quan tâm đến cấu tạo bên trong của nó.

Trong Java, tính trừu tượng trong Java chủ yếu được áp dụng cho các phương thức. đặc biệt được thực hiện thông qua các lớp trừu tượng (abstract class) và giao diện (interface).

Các thuật ngữ quan trọng trong tính trừu tượng (Abstraction)

↳ Lớp trừu tượng (Abstract Class): Một lớp không thể được khởi tạo trực tiếp. Nó có thể chứa các phương thức trừu tượng (không có phần thân) và phương thức không trừu tượng (có phần thân).

↳ Phương thức trừu tượng (Abstract Method): Một phương thức không có phần thân trong lớp trừu tượng. Các lớp con bắt buộc phải triển khai phương thức này.

↳ Giao diện (Interface): Một cấu trúc hoàn toàn trừu tượng, chỉ chứa các phương thức trừu tượng (trước Java 8) hoặc có thể chứa phương thức mặc định, tĩnh và riêng tư (từ Java 8 trở đi).

↳ Phương thức mặc định (Default Method): Một phương thức trong giao diện có phần thân và được gắn từ khóa default.

↳ Phương thức tĩnh (Static Method): Một phương thức có thể được gọi mà không cần khởi tạo đối tượng của lớp hoặc giao diện.

↳ Phương thức riêng tư (Private Method):Một phương thức trong giao diện không thể truy cập từ bên ngoài giao diện, chỉ có thể được sử dụng bên trong giao diện đó.

↳ Kế thừa (Inheritance): Một cơ chế cho phép một lớp con kế thừa các thuộc tính và phương thức từ một lớp cha.

↳ Ghi đè phương thức (Method Overriding): Quá trình mà một lớp con cung cấp phần thân cụ thể cho một phương thức đã được khai báo trong lớp cha.

↳ Nạp chồng phương thức (Method Overloading): Quá trình định nghĩa nhiều phương thức có cùng tên nhưng khác nhau về danh sách tham số trong cùng một lớp.

Tại sao cần tính trừu tượng (Abstraction)?

↳ Đơn giản hóa sự phức tạp: Tính trừu tượng giúp ẩn đi các chi tiết cài đặt phức tạp, chỉ hiển thị các khía cạnh cần thiết. Điều này giúp lập trình viên tập trung vào cách sử dụng một lớp hoặc đối tượng mà không cần biết chi tiết nội bộ của nó.

↳ Tăng tính bảo trì: Khi các chi tiết cài đặt được ẩn đi, việc thay đổi các chi tiết này sẽ không ảnh hưởng đến các phần khác của chương trình. Điều này giúp cho việc bảo trì và nâng cấp hệ thống trở nên dễ dàng hơn.

↳ Tái sử dụng và mở rộng: Các lớp trừu tượng và giao diện định nghĩa các hành vi chung mà các lớp con có thể triển khai lại. Điều này giúp tái sử dụng mã nguồn và dễ dàng mở rộng chức năng của hệ thống mà không cần viết lại mã.

↳ Mô-đun hóa: Tính trừu tượng hỗ trợ việc phát triển phần mềm theo mô-đun, nơi các mô-đun hoặc thành phần của phần mềm có thể được phát triển, kiểm tra và bảo trì độc lập với nhau.

Ⅱ. Lớp trừu tượng (Abstract Class)

Lớp trừu tượng (abstract class) là một lớp đặc biệt trong Java được đánh dấu bằng từ khóa abstract. Nó không thể được khởi tạo trực tiếp và thường được sử dụng để biểu diễn các khái niệm trừu tượng trong mô hình đối tượng. Lớp này có thể chứa cả phương thức trừu tượng (abstract methods) và phương thức không trừu tượng (non-abstract methods) cụ thể mà các lớp con có thể kế thừa hoặc ghi đè.

Những điểm cần phải lưu ý khi sử dụng lớp trừu tượng:

↳ Được khai báo bằng từ khóa abstract.

↳ Không thể khởi tạo đối tượng: Mặc dù lớp trừu tượng có constructor nhưng bạn không thể tạo đối tượng trực tiếp từ lớp trừu tượng. Thay vào đó, lớp con phải kế thừa lớp trừu tượng và có thể sử dụng constructor của lớp trừu tượng thông qua từ khóa super.

↳ Có thể chứa phương thức trừu tượng và phương thức cụ thể: Một lớp trừu tượng có thể chứa cả phương thức trừu tượng (không có thân phương thức) và phương thức cụ thể (có thân phương thức).

↳ Kế thừa: Các lớp con kế thừa từ lớp trừu tượng phải triển khai tất cả các phương thức trừu tượng của lớp cha, trừ khi lớp con cũng là lớp trừu tượng.

↳ Có thể có phương thức final, điều này có nghĩa là lớp con không thể ghi đè (override) phương thức này.

↳ Các lớp trừu tượng (abstract class) có thể có các công cụ sửa đổi truy cập (Access Modifiers), các biến và constructors giống như các lớp thông thường.

↳ Một lớp trừu tượng cũng có thể chứa các trường static (static field) và phương thức static (static method). Bạn có thể sử dụng các thành phần static này bằng cách tham chiếu đến tên lớp (ví dụ: TenLopTruuTuong.phuongThucStatic()) giống như với bất kỳ lớp nào khác.

Cú pháp của lớp trừu tượng trong Java

abstract class Tên_Lớp_Trừu_Tượng {
    // Các thuộc tính
    // Các phương thức thông thường
    // Các phương thức trừu tượng
}

Giải thích từng phần:

↳ abstract class: Từ khóa abstract dùng để khai báo một lớp là trừu tượng.

↳ Tên_Lớp_Trừu_Tượng: Đây là tên bạn đặt cho lớp trừu tượng của mình.

↳ Các thuộc tính: Giống như các lớp thông thường, lớp trừu tượng có thể có các thuộc tính (biến).

↳ Các phương thức thông thường: Đây là những phương thức có đầy đủ thân hàm, chúng cung cấp hành vi cụ thể.

↳ Các phương thức trừu tượng: Được khai báo bằng từ khóa abstract và không có thân hàm. Các lớp con phải ghi đè các phương thức này.

Phương thức trừu tượng trong Java

Phương thức trừu tượng (abstract method) là một phương thức mà chỉ có khai báo mà không có phần thực thi (body). Phương thức trừu tượng được khai báo bằng cách sử dụng từ khóa abstract và nó chỉ có thể tồn tại trong các lớp trừu tượng (abstract class) hoặc trong các interface.

Đặc điểm của phương thức trừu tượng

↳ Phương thức trừu tượng được khai báo bằng từ khóa abstract mà không cần triển khai (không có dấu ngoặc nhọn và theo sau là dấu chấm phẩy).

↳ Phần triển khai (implementation) của phương thức trừu tượng phải nằm ở các lớp con, giúp cụ thể hóa các hành vi trừu tượng đã được định nghĩa trong lớp cha.

↳ Bắt buộc ghi đè: Nếu một lớp con kế thừa từ một lớp trừu tượng mà không ghi đè tất cả các phương thức trừu tượng đó, thì chính lớp con đó cũng sẽ tự động trở thành một lớp trừu tượng.

Phương thức cụ thể trong lớp trừu tượng

↳ Những phương thức có đầy đủ phần thân trong lớp trừu tượng không cần phải bắt buộc ghi đè lại.

↳ Những phương thức trong một lớp trừu tượng mà đã có phần thân (body) cụ thể không cần phải được ghi đè lại trong các lớp con. Điều này có nghĩa rằng các lớp con có thể sử dụng trực tiếp phần thân đã được cung cấp trong lớp trừu tượng mà không cần triển khai lại.

Cú pháp phương thức trừu tượng trong Java

abstract return_type tên_phương_thức(danh_sách_tham_số);

Giải thích từng phần:

↳ abstract: Từ khóa này dùng để chỉ rõ rằng phương thức này là trừu tượng.

↳ return_type: Kiểu dữ liệu mà phương thức trả về.

↳ tên_phương_thức: Tên bạn đặt cho phương thức.

↳ danh_sách_tham_số: Danh sách các tham số truyền vào phương thức.

So sánh phương thức và phương thức trừu tượng

Dưới đây là một ví dụ về lớp trừu tượng và phương thức trừu tượng, cùng với phương thức không trừu tượng trong đơn kế thừa trong Java:

abstract class Hinh {
    private String color;  // Màu sắc của hình

    // Constructor của lớp Hình
    public Hinh(String color) {
        this.color = color;
    }

    // Phương thức cụ thể với phần thân đã được định nghĩa
    public void displayColor() {
        System.out.println("Màu của hình: " + color);  // Hiển thị màu của hình
    }

    // Phương thức trừu tượng để tính diện tích, sẽ được triển khai ở lớp con
    public abstract double DienTich();
}

// Lớp Hình Tròn kế thừa từ lớp Hình
class HinhTron extends Hinh {
    private double radius;  // Bán kính của hình tròn

    // Constructor của lớp Hình Tròn
    public HinhTron(String color, double radius) {
        super(color);  // Gọi constructor của lớp cha để khởi tạo màu sắc
        this.radius = radius;  // Khởi tạo bán kính
    }

    // Override phương thức trừu tượng để tính diện tích của hình tròn
    @Override
    public double DienTich() {
        return Math.PI * radius * radius;  // Diện tích hình tròn
    }
}

// Lớp Example để thử nghiệm các lớp trên
public class Example {
    public static void main(String[] args) {
        // Tạo một đối tượng Hình Tròn
        HinhTron hinhtron = new HinhTron("Xanh Dương", 10);

        // Gọi phương thức hiển thị màu sắc từ lớp Hình
        hinhtron.displayColor();

        // Gọi phương thức tính diện tích từ lớp Hình Tròn
        System.out.println("Diện tích Hình Tròn: " + hinhtron.DienTich());
    }
}

Trong ví dụ này, lớp HinhTron kế thừa từ Hinh và triển khai phương thức DienTich(). Tuy nhiên, nó không cần triển khai lại phương thức displayColor() vì phương thức này đã có phần thân cụ thể trong lớp Hinh. Do đó, những phương thức trong lớp trừu tượng mà đã có phần thân cụ thể không bắt buộc các lớp con phải ghi đè lại, chúng có thể được sử dụng trực tiếp từ lớp trừu tượng.

Dưới đây là một ví dụ về lớp trừu tượng và phương thức trừu tượng, cùng với phương thức không trừu tượng trong kế thừa nhiều cấp trong Java:

abstract class Hinh {
    private String color;  // Màu sắc của hình

    // Constructor của lớp Hình
    public Hinh(String color) {
        this.color = color;
    }

    // Phương thức cụ thể với phần thân đã được định nghĩa
    public void displayColor() {
        System.out.println("Màu của hình: " + color);  // Hiển thị màu của hình
    }

    // Phương thức trừu tượng để tính diện tích, sẽ được triển khai ở lớp con
    public abstract double DienTich();
}

// Lớp Hình Tròn kế thừa từ lớp Hình
class HinhTron extends Hinh {
    private double radius;  // Bán kính của hình tròn

    // Constructor của lớp Hình Tròn
    public HinhTron(String color, double radius) {
        super(color);  // Gọi constructor của lớp cha để khởi tạo màu sắc
        this.radius = radius;  // Khởi tạo bán kính
    }

    // Override phương thức trừu tượng để tính diện tích của hình tròn
    @Override
    public double DienTich() {
        return Math.PI * radius * radius;  // Diện tích hình tròn
    }
}
// Lớp hình chữ nhật kế thừa từ lớp Hinh và triển khai phương thức DienTich()
class HinhChuNhat extends Hinh {
    private double width;  // Chiều rộng của hình chữ nhật
    private double height;  // Chiều cao của hình chữ nhật

    public HinhChuNhat(String color, double width, double height) {
        super(color);
        this.width = width;
        this.height = height;
    }
    // Override phương thức trừu tượng để tính diện tích của hình chữ nhật
    @Override
    public double DienTich() {
        return width * height; // Diện tích hình chữ nhật
    }
}

// Lớp Example để thử nghiệm các lớp trên
public class Example {
    public static void main(String[] args) {
        // Tạo một đối tượng Hình Tròn
        HinhTron hinhtron = new HinhTron("Xanh Dương", 10);
        // Gọi phương thức hiển thị màu sắc từ lớp Hình
        hinhtron.displayColor();
        // Gọi phương thức tính diện tích từ lớp Hình Tròn
        System.out.println("Diện tích Hình Tròn: " + hinhtron.DienTich());

        System.out.println();
        // Tạo một đối tượng Hình chữ nhật
        HinhChuNhat hinhChuNhat = new HinhChuNhat("Xanh Dương", 10,20);
        // Gọi phương thức hiển thị màu sắc từ lớp Hình
        hinhChuNhat.displayColor();
        // Gọi phương thức tính diện tích từ lớp Hình chữ nhật
        System.out.println("Diện tích Hình Chữ Nhật: " + hinhChuNhat.DienTich());

    }
}

Trong ví dụ này, mỗi lớp con (HinhTrong, HinhChuNhat) kế thừa và triển khai phương thức trừu tượng DienTich() theo cách riêng biệt tùy thuộc vào loại hình học tương ứng. Lớp Hinh cung cấp tính năng chung như là tính diện tích và hiển thị màu sắc, đó là một ví dụ rõ ràng về tính trừu tượng và kế thừa nhiều cấp trong Java.

Dưới đây là một ví dụ về lớp trừu tượng và phương thức trừu tượng, cùng với phương thức không trừu tượng trong kế thừa thứ bậc trong Java:

// Lớp trừu tượng Animal đại diện cho động vật
abstract class Animal {
    protected String name;

    public Animal(String name) {
        this.name = name;
    }

    // Phương thức trừu tượng để phát ra tiếng kêu của động vật
    public abstract void makeSound();

    // Phương thức không trừu tượng để hiển thị thông tin chung của động vật
    public void displayInfo() {
        System.out.println("Động vật: " + name);
    }
}

// Lớp con Dog kế thừa từ lớp Animal và triển khai phương thức makeSound()
class Dog extends Animal {
    public Dog(String name) {
        super(name);
    }

    @Override
    public void makeSound() {
        System.out.println(name + " kêu: Gâu gâu");
    }
}

// Lớp con Cat kế thừa từ lớp Animal và triển khai phương thức makeSound()
class Cat extends Animal {
    public Cat(String name) {
        super(name);
    }

    @Override
    public void makeSound() {
        System.out.println(name + " kêu: Meo meo");
    }
}

// Lớp con Cow kế thừa từ lớp Animal và triển khai phương thức makeSound()
class Cow extends Animal {
    public Cow(String name) {
        super(name);
    }

    @Override
    public void makeSound() {
        System.out.println(name + " kêu: Moo moo");
    }
}

// Lớp Example để kiểm tra các lớp trên
public class Example {
    public static void main(String[] args) {
        Dog dog = new Dog("Bobby");
        Cat cat = new Cat("Kitty");
        Cow cow = new Cow("Mooey");

        dog.displayInfo();
        dog.makeSound();

        cat.displayInfo();
        cat.makeSound();

        cow.displayInfo();
        cow.makeSound();
    }
}

Trong ví dụ trên, mỗi lớp con (Dog, Cat, Cow) kế thừa và triển khai phương thức trừu tượng makeSound() để cung cấp âm thanh phát ra của từng loại động vật. Lớp Animal cung cấp tính năng chung như hiển thị thông tin và yêu cầu các lớp con cung cấp cách thức cụ thể cho việc phát ra tiếng kêu.

Dưới đây là một ví dụ khi một lớp trừu tượng triển khai một giao diện (interface) trong Java:

Thông thường, một lớp sử dụng giao diện (interface) thì phải triển khai tất cả phương thức của giao diện đó.

Trường hợp ngoại lệ: một lớp trừu tượng (Abstract class) có thể không triển khai hết các phương thức của giao diện, nhưng các lớp con của nó phải chịu trách nhiệm triển khai đầy đủ.

interface VeHinh {
    void Ve(); // Phương thức trừu tượng
}

abstract class Hinh implements VeHinh {
    private String color;

    public Hinh(String color) {
        this.color = color;
    }

    public String getColor() {
        return color;
    }

    // Phương thức cụ thể
    public void displayColor() {
        System.out.println("Màu: " + color);
    }
    // Lớp trừu tượng không cần triển khai phương thức Ve() ở đây
}

class HinhTron extends Hinh {
    private double BanKinh;

    public HinhTron(String color, double BanKinh) {
        super(color);
        this.BanKinh = BanKinh;
    }

    @Override
    public void Ve() {
        System.out.println("Vẽ đường tròn có bán kính: " + BanKinh);
    }
}

public class Example {
    public static void main(String[] args) {
        HinhTron hinhtron = new HinhTron("Xanh", 5.0);
        hinhtron.displayColor();
        hinhtron.Ve();
    }
}

Trong ví dụ này khi chạy mã, Lớp HinhTron kế thừa từ lớp trừu tượng Hinh và triển khai phương thức Ve(). bạn sẽ thấy rằng phương thức Ve() được gọi cho cả đối tượng HinhTron mà không gặp lỗi biên dịch.

Ⅲ. Lớp trừu tượng lồng nhau (Abstract nested class)

Bạn có thể có các lớp trừu tượng lồng nhau, tức là một lớp trừu tượng chứa một lớp trừu tượng khác bên trong nó. Kế thừa trong các lớp trừu tượng lồng nhau hoạt động tương tự như trong các lớp thông thường. Bạn có thể kế thừa một lớp trừu tượng lồng bên trong từ một lớp khác, để sử dụng đầy đủ các phương thức và lớp trừu tượng bên trong, lớp con bắt buộc phải triển khai tất cả các phương thức trừu tượng của lớp trừu tượng lồng bên trong.

Đây là một ví dụ về cách sử dụng lớp trừu tượng lồng nhau:

abstract class Animal {
    private String name;

    public Animal(String name) {
        this.name = name;
    }

    public void display() {
        System.out.println("Tên Động Vật: " + name);
    }

    public abstract void sound();

    // Lớp trừu tượng lồng bên trong
    abstract class Leg {
        public abstract void walk();
    }
}
class Dog extends Animal {
    public Dog(String name) {
        super(name);
    }

    @Override
    public void sound() {
        System.out.println("Chú Chó Sủa Gâu Gâu");
    }

    // Triển khai lớp trừu tượng lồng bên trong
    class DogLeg extends Leg {
        @Override
        public void walk() {
            System.out.println("Chó đi bằng bốn chân");
        }
    }
}

public class Example {
    public static void main(String[] args) {
        Dog dog = new Dog("Buddy");
        dog.display();
        dog.sound();

        // Tạo một đối tượng của lớp lồng bên trong Dog
        Dog.DogLeg dogLeg = dog.new DogLeg();
        dogLeg.walk();
    }
}

Đây là một ví dụ nếu bạn cố gắng tạo một đối tượng hoặc sử dụng phương thức của lớp trừu tượng lồng bên trong mà không triển khai nó, sẽ gặp lỗi:

abstract class Animal {
    private String name;

    public Animal(String name) {
        this.name = name;
    }

    public void display() {
        System.out.println("Tên Động Vật: " + name);
    }

    public abstract void sound();

    // Lớp trừu tượng lồng bên trong
    abstract class Leg {
        public abstract void walk();
    }
}
class Dog extends Animal {
    public Dog(String name) {
        super(name);
    }

    @Override
    public void sound() {
        System.out.println("Chú Chó Sủa Gâu Gâu");
    }

    // Nếu không triển khai lớp trừu tượng lồng bên trong, sẽ không có lỗi biên dịch
    // Nhưng nếu bạn cố gắng tạo một đối tượng hoặc sử dụng phương thức của lớp trừu tượng lồng bên trong mà không triển khai nó, sẽ gặp lỗi
    /*
    class DogLeg extends Leg {
        @Override
        public void walk() {
            System.out.println("Dog walks on four legs");
        }
    }
    */
}

public class Example {
    public static void main(String[] args) {
        Dog dog = new Dog("Buddy");
        dog.display();
        dog.sound();

        // Tạo một đối tượng của lớp lồng bên trong Dog
        Dog.DogLeg dogLeg = dog.new DogLeg();
        dogLeg.walk();
    }
}

Như Vậy, nếu lớp con kế thừa từ một lớp trừu tượng bên ngoài và muốn sử dụng lớp trừu tượng lồng bên trong thì bắt buộc phải triển khai tất cả các phương thức trừu tượng của lớp trừu tượng lồng bên trong. Nếu không, lớp con đó cũng phải được khai báo là lớp trừu tượng.

Dưới đây là một ví dụ khi một lớp trừu tượng kế thừa từ một lớp trừu tượng khác

Khi một lớp trừu tượng kế thừa từ một lớp trừu tượng khác, nó kế thừa tất cả các phương thức và biến thành viên từ lớp cha. Lớp con trừu tượng có thể ghi đè các phương thức trừu tượng của lớp cha hoặc để các lớp con kế thừa từ nó triển khai các phương thức này.

// Lớp trừu tượng cơ bản
abstract class Animal {
    private String name;

    public Animal(String name) {
        this.name = name;
    }

    // Phương thức trừu tượng
    public abstract void sound();

    // Phương thức cụ thể
    public void sleep() {
        System.out.println(name + " đang ngủ.");
    }
}

// Lớp trừu tượng kế thừa từ lớp Animal
abstract class Mammal extends Animal {
    public Mammal(String name) {
        super(name);
    }

    // Phương thức trừu tượng mới
    public abstract void walk();
}

// Lớp cụ thể kế thừa từ lớp Mammal
class Dog extends Mammal {
    public Dog(String name) {
        super(name);
    }

    @Override
    public void sound() {
        System.out.println("Chú chó đang sủa");
    }

    @Override
    public void walk() {
        System.out.println("chú chó đang đi");
    }
}

public class Example {
    public static void main(String[] args) {
        Dog dog = new Dog("Buddy");
        dog.sound(); // Gọi phương thức ghi đè từ lớp Dog
        dog.walk();  // Gọi phương thức ghi đè từ lớp Dog
        dog.sleep(); // Gọi phương thức cụ thể từ lớp Animal
    }
}

Trong ví dụ này, lớp Dog phải triển khai tất cả các phương thức trừu tượng từ cả lớp Animal và Mammal. Tuy nhiên, nếu lớp Mammal không triển khai các phương thức trừu tượng của lớp Animal, lớp Dog phải triển khai tất cả các phương thức trừu tượng từ cả hai lớp cha trừu tượng.

Mối quan hệ giữa class và Abstract class trong Java

↳ Lớp con của lớp trừu tượng phải triển khai tất cả các phương thức trừu tượng của lớp trừu tượng cha hoặc trở thành lớp trừu tượng.

↳ Lớp trừu tượng không thể được khởi tạo trực tiếp; chỉ có các lớp con cụ thể của lớp trừu tượng mới có thể được khởi tạo.

↳ Lớp trừu tượng thường được sử dụng để định nghĩa một cấu trúc cơ bản và các lớp con cụ thể sẽ kế thừa(extends) cấu trúc đó và thực hiện các hành vi cụ thể.

So sánh chi tiết giữa class và abstract class

Khi nào nên sử dụng Abstract Class?

↳ Khi muốn tạo một lớp cha chung: Để định nghĩa các thuộc tính và phương thức chung cho một nhóm các lớp con.

↳ Khi có một số phương thức mà các lớp con phải cài đặt: Phương thức trừu tượng đảm bảo rằng các lớp con phải cung cấp triển khai cụ thể.

↳ Khi muốn tạo ra một hệ thống phân cấp lớp rõ ràng: Abstract class giúp tổ chức code một cách hợp lý và dễ hiểu.