Biểu tượng chim cắt của Kestrel Exams KESTREL EXAMSLUYỆN TẬP ĐỂ ĐẠT
Bản dịch này do AI thực hiện và chưa được người bản ngữ kiểm duyệt. Nếu có khác biệt, bản tiếng Anh là bản chính. Mã nguồn được giữ nguyên bằng tiếng Anh. Ứng dụng luyện tập và tài liệu cho các kỳ thi chứng chỉ của Hoa Kỳ chỉ có bằng tiếng Anh. Read in English
JavaĐọc trong 12 phútMã đã được kiểm chứng

Lớp trừu tượng và giao diện: khi nào dùng loại nào

Lớp trừu tượng và giao diện đều cho phép bạn viết mã dựa trên một ý tưởng chung và để phần chi tiết cho các lớp khác. Bài hướng dẫn này bao quát phương thức trừu tượng, trình biên dịch nói gì khi một lời hứa không được giữ, cách giao diện cho một lớp đảm nhận nhiều vai trò, bảng so sánh song song, khi nào chọn cái nào, và cách vẽ mỗi loại trong UML. Mọi đoạn mã đều đã được biên dịch và chạy trên OpenJDK 21.

Luyện tập chủ đề này trong ứng dụng miễn phí →Tất cả bài hướng dẫn Java

Một biểu mẫu làm dở#

Hãy nghĩ đến một biểu mẫu xin việc. Công ty đã in sẵn phần lớn: tên, địa chỉ, dòng chữ ký. Nhưng có một ô ghi “Hãy mô tả vì sao bạn muốn công việc này” và nó để trống. Biểu mẫu vô dụng cho đến khi mỗi ứng viên điền ô đó, và không ai nộp bản mẫu trống làm hồ sơ của mình.

Một lớp trừu tượng chính là biểu mẫu đó. Phần lớn lớp đã được viết, nhưng một số phương thức được để trống có chủ ý, và mọi lớp con phải điền vào. Những phương thức trống đó là phương thức trừu tượng: một phần đầu không có thân, kết thúc bằng dấu chấm phẩy. Và cũng như không ai nộp bản mẫu trống, Java không cho bạn tạo một đối tượng của lớp trừu tượng.

Phương thức trừu tượng và lớp trừu tượng#

abstract class Shape {
    private String name;

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

    public abstract double area();

    public String describe() {
        return name + " with area " + area();
    }
}

class Circle extends Shape {
    private double r;

    public Circle(double r) {
        super("circle");
        this.r = r;
    }

    @Override
    public double area() {
        return Math.round(Math.PI * r * r * 100) / 100.0;
    }
}

class Rect extends Shape {
    private double w, h;

    public Rect(double w, double h) {
        super("rectangle");
        this.w = w;
        this.h = h;
    }

    @Override
    public double area() {
        return w * h;
    }
}

public class Shapes {
    public static void main(String[] args) {
        Shape[] shapes = { new Circle(2), new Rect(3, 4) };
        for (Shape s : shapes) {
            System.out.println(s.describe());
        }
    }
}
circle with area 12.57
rectangle with area 12.0

Ba điều cần để ý:

  • area() trong Shape không có thân, chỉ có dấu chấm phẩy, và được đánh dấu abstract. Bất kỳ lớp nào chứa một phương thức trừu tượng cũng phải được đánh dấu abstract.
  • describe() là một phương thức bình thường, đã hoàn chỉnh trong cùng lớp trừu tượng. Nó còn gọi area(), tin rằng mọi hình thật sẽ cung cấp một phương thức như vậy. Một lớp trừu tượng cũng có thể có trường và hàm tạo, và Shape dùng hàm tạo của nó để lưu tên.
  • Mảng được khai báo là Shape[], và đa hình làm phần còn lại: mỗi đối tượng chạy area() của riêng nó.

Thử tạo bản mẫu trống và trình biên dịch dừng bạn:

abstract class Shape {
    public abstract double area();
}

public class NoNew {
    public static void main(String[] args) {
        Shape s = new Shape();
    }
}
NoNew.java:7: error: Shape is abstract; cannot be instantiated
        Shape s = new Shape();
                  ^
1 error

Và một lớp con quên điền vào chỗ trống sẽ nhận một lời phàn nàn chính xác. Thông báo cho bạn biết chính xác phương thức nào bị thiếu:

abstract class Shape {
    public abstract double area();
}

class Triangle extends Shape {
    private double base, height;
}

public class Forgot {
    public static void main(String[] args) {
        System.out.println("never gets here");
    }
}
Forgot.java:5: error: Triangle is not abstract and does not override abstract method area() in Shape
class Triangle extends Shape {
^
1 error

Lối thoát duy nhất là viết area() còn thiếu, hoặc đánh dấu Triangle cũng là abstract, như vậy công việc được chuyển tiếp xuống dưới trong họ lớp.

Khi nào nên làm một lớp trừu tượng#

Hãy làm một lớp trừu tượng khi cả hai điều sau đều đúng:

  1. Nó đặt tên cho một loại, không phải một vật có thật. Bạn có thể vẽ một hình tròn hay một hình vuông, nhưng bạn không thể vẽ “một hình” mà không phải hình cụ thể nào. Tương tự, “một nhân viên” không thuộc loại nhân viên cụ thể nào, hay “một tài khoản” không thuộc loại tài khoản cụ thể nào.
  2. Mọi lớp con phải cung cấp một hành vi nào đó, nhưng mỗi lớp làm khác nhau. Hình nào cũng có diện tích; mỗi hình tính theo cách riêng.

Nếu lớp cha có thể đưa ra mặc định hợp lý cho phương thức, nó không cần là abstract: hãy viết mặc định và để các lớp con ghi đè. Dùng abstract khi không có mặc định trung thực nào, và việc quên ghi đè sẽ là một lỗi.

Giao diện: một lời hứa mà lớp nào cũng có thể đưa ra#

Điện thoại, tai nghe và bàn chải đánh răng điện không có gì khác chung, nhưng tất cả đều có thể hứa vừa với một bộ sạc USB-C. Lời hứa đó là một chuẩn. Thiết bị nào cũng có thể đáp ứng, bất kể thiết bị thuộc họ nào.

Một giao diện là chuẩn đó trong Java: một danh sách có tên các phần đầu phương thức. Một lớp đăng ký bằng từ khóa implements, và khi đó phải viết mọi phương thức trong danh sách.

interface Chargeable {
    int batteryLevel();
    void charge(int minutes);
}

class Device {
    private String model;

    public Device(String model) {
        this.model = model;
    }

    public String getModel() {
        return model;
    }
}

class Phone extends Device implements Chargeable {
    private int battery = 20;

    public Phone(String model) {
        super(model);
    }

    public int batteryLevel() {
        return battery;
    }

    public void charge(int minutes) {
        battery = Math.min(100, battery + minutes);
    }
}

class Toothbrush implements Chargeable {
    private int battery = 50;

    public int batteryLevel() {
        return battery;
    }

    public void charge(int minutes) {
        battery = Math.min(100, battery + minutes / 2);
    }
}

public class Iface {
    public static void main(String[] args) {
        Phone p = new Phone("Pixel");
        Chargeable[] plugs = { p, new Toothbrush() };
        for (Chargeable c : plugs) {
            c.charge(60);
            System.out.println(c.batteryLevel() + "%");
        }
        System.out.println(p.getModel() + " is at " + p.batteryLevel() + "%");
    }
}
80%
80%
Pixel is at 80%

Các quy tắc làm giao diện khác với lớp:

  • Phương thức trong giao diện tự động là public và abstract; bạn không viết những từ đó. (Từ Java 8 một giao diện cũng có thể chứa các phương thức default và static có thân, và từ Java 9 là các phương thức private hỗ trợ, nhưng cốt lõi của giao diện là danh sách các lời hứa.)
  • Mọi trường trong giao diện tự động là public static final: một hằng chung, không phải dữ liệu theo từng đối tượng.
  • Bạn không thể tạo đối tượng của một giao diện, nhưng bạn có thể dùng nó làm kiểu của biến hoặc mảng, như Chargeable[] ở trên. Đó lại là đa hình.
  • Một lớp kế thừa một lớp nhưng có thể triển khai nhiều giao diện, ngăn cách bằng dấu phẩy. Phone kế thừa Device và cũng là Chargeable.

Phương thức của lớp triển khai phải là public. Bỏ từ đó đi và bạn nhận cùng lỗi “weaker access privileges” như trong bài hướng dẫn về Object.

Một giao diện thật bạn sẽ dùng: Comparable#

Thư viện Java đầy giao diện. Giao diện đầu tiên môn học của bạn gặp là Comparable, hứa một phương thức, compareTo. Nó theo cùng quy tắc với compareTo của String: số âm nghĩa là “tôi đứng trước”, số 0 nghĩa là bằng nhau, số dương nghĩa là “tôi đứng sau”. Giữ lời hứa đó và Arrays.sort có thể sắp xếp các đối tượng của bạn:

import java.util.Arrays;

class Student implements Comparable<Student> {
    private String name;
    private double gpa;

    public Student(String name, double gpa) {
        this.name = name;
        this.gpa = gpa;
    }

    public int compareTo(Student other) {
        return Double.compare(other.gpa, gpa);
    }

    @Override
    public String toString() {
        return name + " " + gpa;
    }
}

public class Sort {
    public static void main(String[] args) {
        Student[] cls = {
            new Student("Ana", 3.2),
            new Student("Ben", 3.9),
            new Student("Cy", 3.5)
        };
        Arrays.sort(cls);
        System.out.println(Arrays.toString(cls));
    }
}
[Ben 3.9, Cy 3.5, Ana 3.2]

Double.compare(x, y) thực hiện phép so sánh kiểu phép trừ cho hai giá trị double. Truyền other.gpa trước sẽ đảo thứ tự, đó là lý do GPA cao nhất ra trước; đổi chỗ các đối số để thấp nhất ra trước. Arrays.sort được viết nhiều năm trước khi Student tồn tại. Nó hoạt động vì nó chỉ dựa vào lời hứa: bất cứ thứ gì Comparable đều có compareTo. Phần <Student> sau tên giao diện là generic, được đề cập sau trong loạt bài này; nó nói “có thể so sánh với các Student khác”.

Lớp trừu tượng hay giao diện?#

Lớp trừu tượngGiao diện
Từ khóa để dùng nóextendsimplements
Bao nhiêu cho mỗi lớpmộtbao nhiêu tùy thích
Bạn có thể tạo đối tượng của nó không?khôngkhông
Hàm tạocókhông
Trườngmọi loại, kể cả dữ liệu private theo từng đối tượngchỉ các hằng public static final
Phương thức có thâncó, bao nhiêu tùy thíchchỉ các phương thức default, static và private
Quan hệ nó biểu đạtlà-một (hình tròn là một hình)có thể làm (điện thoại có thể được sạc)

Khi nào dùng giao diện: khi các lớp không liên quan cần chia sẻ một khả năng, hoặc khi một lớp cần nhiều hơn một vai trò. Điện thoại và bàn chải đánh răng không có lớp cha chung nhưng cả hai đều có thể là Chargeable.

Khi nào dùng lớp trừu tượng: khi các lớp có liên quan chặt chẽ chia sẻ mã và dữ liệu thật, như trường tên, hàm tạo hoặc phương thức describe() đã hoàn chỉnh, và bạn chỉ muốn để trống một vài phương thức.

Một phép thử nhanh cho bài thi: nếu câu là “X là một loại Y”, Y có lẽ là một lớp (abstract nếu Y chỉ là một loại). Nếu câu là “X có thể làm Z”, Z có lẽ là một giao diện, và tên của nó thường kết thúc bằng -able.

Vẽ chúng trong UML#

UML đánh dấu những thứ trừu tượng bằng chữ nghiêng. Vì chữ nghiêng khó viết tay, bạn cũng có thể thấy {abstract} sau tên. Một giao diện có nhãn «interface» phía trên tên. Các mũi tên:

  • extends (lớp tới lớp): đường nét liền, tam giác rỗng ở phía lớp cha.
  • implements (lớp tới giao diện): đường nét đứt, tam giác rỗng ở phía giao diện.
+------------------------------+      +------------------------------+
|      Shape  {abstract}       |      |        «interface»           |
+------------------------------+      |         Chargeable           |
| - name : String              |      +------------------------------+
+------------------------------+      | + batteryLevel() : int       |
| + area() : double {abstract} |      | + charge(minutes : int)      |
| + describe() : String        |      +------------------------------+
+------------------------------+      
               ^                                     ^
               |                                     :
               |  solid line                         :  dashed line
+------------------------------+      +------------------------------+
|           Circle             |      |            Phone             |
+------------------------------+      +------------------------------+
| - radius : double            |      | - battery : int              |
+------------------------------+      +------------------------------+
| + area() : double            |      | + batteryLevel() : int       |
+------------------------------+      | + charge(minutes : int)      |
                                      +------------------------------+

Hãy để ý Circle liệt kê area() bằng chữ thường: nó là phiên bản đã hoàn chỉnh. Phần đầu trừu tượng chỉ xuất hiện ở lớp cha.

Một câu để mang vào phòng thi

Một lớp trừu tượng là một lớp cha làm dở mà bạn kế thừa (chỉ một, là-một); một giao diện là danh sách các lời hứa bạn triển khai (bao nhiêu tùy thích, có-thể-làm). Bạn không thể tạo đối tượng của loại nào trong hai loại này, và mọi phương thức trừu tượng phải được viết bởi lớp không trừu tượng đầu tiên bên dưới nó.

Những chỗ dễ sai#

  • Cho phương thức trừu tượng một thân, hoặc cho phương thức thường không có thân. Phương thức trừu tượng kết thúc bằng dấu chấm phẩy; mọi phương thức khác cần ngoặc nhọn.
  • Viết new Shape() cho một lớp trừu tượng hoặc new Chargeable() cho một giao diện. Cả hai đều không thể tạo thể hiện. Hãy tạo một lớp con cụ thể hoặc lớp triển khai thay vào đó.
  • Quên một phương thức trừu tượng trong lớp con. Lớp phải được đánh dấu abstract nếu không trình biên dịch sẽ nêu tên phương thức bị thiếu.
  • Bỏ public ở phương thức giao diện được triển khai. Phương thức của giao diện là public, và phần triển khai không được yếu hơn.
  • Viết extends cho giao diện hoặc implements cho lớp. Lớp được kế thừa; giao diện được triển khai. (Một giao diện có thể kế thừa một giao diện khác.)
  • Mong đợi trường theo từng đối tượng trong giao diện. Mọi trường giao diện là một hằng public static final.
  • Lẫn các mũi tên UML. Đường nét liền cho extends, đường nét đứt cho implements, cả hai đều có tam giác rỗng ở đầu tổng quát hơn.

Luyện tập#

Hãy trả lời từng câu trên giấy trước khi xem lời giải. Mọi đáp án có chạy mã đều đã được kiểm tra bằng cách biên dịch và chạy mã đó.

  1. Những dòng nào biên dịch được, cho abstract class Animal và class Cow extends Animal (viết mọi phương thức trừu tượng)? Animal a = new Animal();   Animal b = new Cow();   Animal[] herd = new Animal[10];
  2. Animal khai báo public abstract String sound(); và một speak() đã hoàn chỉnh trả về "The animal says " + sound(). Hãy viết lớp Cow nhỏ nhất biên dịch được, và nói new Cow().speak() trả về gì.
  3. Một lớp Robot đã kế thừa Machine. Nó cũng cần là Rechargeable và Programmable. Hai cái đó nên là lớp trừu tượng hay giao diện? Vì sao?
  4. Viết một giao diện Playable với một phương thức String play(), hai lớp triển khai nó, và một vòng lặp qua Playable[] gọi play() trên từng phần tử.
  5. Nêu ba điểm khác nhau giữa lớp trừu tượng và giao diện.
  6. Trong UML, làm sao phân biệt lớp trừu tượng với lớp thường, và vẽ “Phone implements Chargeable” như thế nào?

Lời giải#

  1. Dòng thứ hai và thứ ba. Bạn không thể tạo một đối tượng Animal (Animal is abstract; cannot be instantiated), nhưng bạn có thể khai báo biến và mảng Animal, đó chính là mục đích. new Animal[10] tạo một mảng mười ô trống, không phải mười con vật, nên được phép.
  2. Cow chỉ phải điền vào chỗ trống; nó thừa hưởng speak():
    abstract class Animal {
        public abstract String sound();
    
        public String speak() {
            return "The animal says " + sound();
        }
    }
    
    class Cow extends Animal {
        @Override
        public String sound() {
            return "moo";
        }
    }
    
    public class QFix {
        public static void main(String[] args) {
            Animal a = new Cow();
            System.out.println(a.speak());
        }
    }
    The animal says moo
  3. Giao diện. Một lớp chỉ có thể kế thừa một lớp, và Robot đã dùng lượt duy nhất cho Machine. Nó có thể triển khai bao nhiêu giao diện tùy ý: class Robot extends Machine implements Rechargeable, Programmable. Chúng cũng mô tả các khả năng (có-thể-làm), đúng là việc giao diện dành cho.
  4. Kiểu mảng là giao diện, và mỗi đối tượng chạy play() của riêng nó:
    interface Playable {
        String play();
    }
    
    class Song implements Playable {
        public String play() {
            return "playing a song";
        }
    }
    
    class Podcast implements Playable {
        public String play() {
            return "playing a podcast";
        }
    }
    
    public class QPlay {
        public static void main(String[] args) {
            Playable[] queue = { new Song(), new Podcast() };
            for (Playable p : queue) {
                System.out.println(p.play());
            }
        }
    }
    playing a song
    playing a podcast
  5. Ba điểm bất kỳ trong số: một lớp kế thừa một lớp trừu tượng nhưng triển khai được nhiều giao diện; lớp trừu tượng có thể có hàm tạo còn giao diện thì không; lớp trừu tượng có thể có trường thông thường theo từng đối tượng, còn trường giao diện đều là hằng public static final; lớp trừu tượng có thể có bất kỳ số phương thức hoàn chỉnh nào, còn giao diện chỉ cho phép thân ở các phương thức default, static và private; lớp trừu tượng biểu đạt là-một, giao diện biểu đạt có-thể-làm.
  6. Tên lớp trừu tượng (và mọi phương thức trừu tượng) được viết bằng chữ nghiêng, hoặc đánh dấu {abstract}. “Implements” là một đường nét đứt từ Phone tới Chargeable với tam giác rỗng ở phía Chargeable, và khung của Chargeable được gắn nhãn «interface».

Danh sách kiểm tra trước khi thi#

Đây là các mục trong danh sách chủ đề Bài thi 2 của môn học mà bài hướng dẫn này đề cập. Chỉ đánh dấu mỗi mục khi bạn làm được mà không cần nhìn.

  • ☐  Tôi có thể viết một lớp trừu tượng với các phương thức trừu tượng và giải thích vì sao nó không thể tạo thể hiện.
  • ☐  Tôi có thể nói khi nào nên làm một lớp trừu tượng.
  • ☐  Tôi có thể viết và triển khai một giao diện, và giải thích khi nào dùng giao diện thay vì lớp trừu tượng.
  • ☐  Tôi có thể vẽ UML cho lớp và phương thức trừu tượng và cho giao diện, với mũi tên đúng cho từng loại.

Tự kiểm tra trong ứng dụng Kestrel Exams miễn phí

40 câu hỏi luyện tập về lớp trừu tượng, giao diện và phương thức default, mọi đáp án mã đều được kiểm tra bằng cách biên dịch và chạy. Miễn phí, dùng được khi không có mạng, không cần tài khoản.

Luyện tập lớp trừu tượng và giao diện →

Câu hỏi thường gặp#

Lớp trừu tượng trong Java là gì?

Một lớp được đánh dấu abstract và không thể tạo thể hiện. Nó có thể chứa trường, hàm tạo và các phương thức đã hoàn chỉnh như mọi lớp, cộng với các phương thức trừu tượng: phần đầu không có thân mà mọi lớp con cụ thể phải ghi đè. Nó được dùng cho một loại chung mà các lớp con chia sẻ mã nhưng mỗi lớp cung cấp một số hành vi theo cách khác nhau.

Phương thức trừu tượng là gì?

Một phương thức được khai báo bằng từ khóa abstract và không có thân, kết thúc bằng dấu chấm phẩy, như public abstract double area();. Bất kỳ lớp nào chứa một phương thức như vậy phải là abstract, và lớp con không trừu tượng đầu tiên phải ghi đè nó nếu không mã sẽ không biên dịch.

Giao diện (interface) trong Java là gì?

Một tập các phần đầu phương thức có tên mà một lớp hứa cung cấp bằng cách viết implements. Phương thức của giao diện là public và abstract trừ khi chúng có thân (phương thức default và static, và từ Java 9 là phương thức private hỗ trợ), và trường của giao diện là hằng public static final. Một lớp có thể triển khai nhiều giao diện, và một giao diện có thể được dùng làm kiểu của biến.

Sự khác nhau giữa lớp trừu tượng và giao diện là gì?

Một lớp chỉ có thể kế thừa một lớp trừu tượng nhưng triển khai được nhiều giao diện. Lớp trừu tượng có thể có hàm tạo, trường thông thường và bất kỳ số phương thức hoàn chỉnh nào; giao diện không có hàm tạo, chỉ có trường hằng, và chỉ có thân ở các phương thức default, static hoặc private. Lớp trừu tượng mô hình hóa quan hệ là-một giữa các lớp có liên quan chặt chẽ; giao diện mô hình hóa các khả năng mà các lớp không liên quan có thể chia sẻ.

Khi nào nên dùng giao diện thay vì lớp trừu tượng?

Dùng giao diện khi các lớp không liên quan cần chia sẻ một khả năng, hoặc khi một lớp cần nhiều hơn một vai trò, vì Java chỉ cho phép một lớp cha. Dùng lớp trừu tượng khi các lớp có liên quan chặt chẽ chia sẻ mã hoặc dữ liệu thật và chỉ một vài phương thức khác nhau.

Lớp trừu tượng và giao diện được thể hiện thế nào trong UML?

Lớp trừu tượng và phương thức trừu tượng được viết bằng chữ nghiêng hoặc đánh dấu {abstract}. Giao diện được gắn nhãn bằng stereotype <<interface>>. Kế thừa từ một lớp là đường nét liền với tam giác rỗng ở phía lớp cha; triển khai một giao diện là đường nét đứt với tam giác rỗng ở phía giao diện.

Đề xuất chỉnh sửa

Có chỗ nào chưa rõ? Có chủ đề nào bạn muốn chúng tôi viết? Hãy cho chúng tôi biết. Chúng tôi đọc mọi tin nhắn, và một lời đề nghị là cách nhanh nhất để có bài hướng dẫn mới: một số bài ở đây ra đời vì có người hỏi.