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 14 phútMã đã được kiểm chứng

Kế thừa: extends, super, và ghi đè phương thức

Kế thừa cho phép một lớp bắt đầu từ lớp khác và chỉ thay đổi những gì khác biệt. Bài hướng dẫn này nói về ba tên gọi cho hai lớp, extends thực sự truyền xuống những gì, lời gọi super mà mọi hàm tạo của lớp con đều thực hiện, và ghi đè khác nạp chồng ra sao. 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 tấm thẻ công thức gia đình#

Hãy hình dung công thức nấu chili của bà bạn trên một tấm thẻ. Bạn thích nó, nhưng bạn nấu với thịt gà tây và thêm bắp. Bạn không viết lại cả tấm thẻ. Bạn kẹp vào đó một ghi chú: “giống của bà, trừ: gà tây thay cho thịt bò, và thêm bắp ở cuối”.

Ghi chú đó là một lớp con (subclass). Tấm thẻ của bà là lớp cha (superclass). Kế thừa (inheritance) chỉ có nghĩa là một lớp mới bắt đầu với mọi thứ mà một lớp có sẵn có, rồi thêm hoặc đổi một vài thứ. Bạn chỉ viết những điểm khác biệt.

Môn học, sách giáo khoa và bài thi của bạn dùng ba cặp tên khác nhau cho cùng hai vai trò. Chúng có nghĩa hoàn toàn giống nhau:

Lớp bạn xuất phát từ nóLớp xuất phát từ lớp đó
base classderived class
parent classchild class
superclasssubclass

Phép thử xem kế thừa có phù hợp không chỉ là một câu: một đối tượng lớp con là một đối tượng lớp cha. Một con chó là một thú cưng. Một tài khoản tiết kiệm là một tài khoản ngân hàng. Nếu câu đó nghe lố bịch (“một động cơ là một chiếc xe”), kế thừa là công cụ sai. Bài hướng dẫn về đa hình sẽ quay lại phép thử này.

extends: những gì lớp con nhận miễn phí#

Từ khóa là extends. Viết nó sau tên lớp, theo sau là lớp cha:

class Pet {
    private String name;

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

    public String getName() {
        return name;
    }
}

class Dog extends Pet {
    public Dog(String name) {
        super(name);
    }

    public String fetch() {
        return getName() + " brings the ball back";
    }
}

public class Extends {
    public static void main(String[] args) {
        Dog rex = new Dog("Rex");
        System.out.println(rex.getName());
        System.out.println(rex.fetch());
    }
}
Rex
Rex brings the ball back

Dog chưa bao giờ viết getName, vậy mà rex.getName() vẫn chạy. Lớp con đã nhận các phương thức public của lớp cha. Nó cũng thêm một phương thức của riêng mình, fetch. Lớp cha không có fetch: kế thừa chỉ chảy xuống dưới, giống như ghi chú công thức mà tấm thẻ của bà không hề biết tới.

Để mỗi đoạn mã ngắn gọn, các lớp trong bài hướng dẫn này dùng chung một tệp, và chỉ lớp có main là public. Trong các dự án của riêng bạn, hãy cho mỗi lớp public một tệp .java riêng, đặt tên theo lớp.

Một lớp Java chỉ có thể mở rộng một lớp cha. class Dog extends Pet, Animal không biên dịch được. (Giao diện, hai bài hướng dẫn sau, là cách Java vượt qua giới hạn này.)

Trường private vẫn private, kể cả với lớp con#

Một đối tượng lớp con có chứa các trường private của lớp cha, nhưng mã của chính lớp con không được phép đụng tới chúng bằng tên. private nghĩa là “chỉ mã bên trong đúng một lớp này”, và lớp con là một lớp khác. Đó là lý do sách quy tắc Java, và nhiều câu hỏi thi, nói rằng các thành viên private không được kế thừa: dữ liệu có đó, nhưng lớp con không có quyền truy cập.

class Pet {
    private String name;

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

class Dog extends Pet {
    public Dog(String name) {
        super(name);
    }

    public String tag() {
        return "Tag: " + name;
    }
}

public class PrivateErr {
    public static void main(String[] args) {
        System.out.println(new Dog("Rex").tag());
    }
}
PrivateErr.java:15: error: name has private access in Pet
        return "Tag: " + name;
                         ^
1 error

Cách sửa là đi qua các phương thức public của lớp cha, ở đây là getName(). Nếu bạn muốn các lớp con (và chỉ lớp con) truy cập trực tiếp một thành viên, hãy đánh dấu nó protected. Hầu hết các môn học vẫn ưa trường private kèm getter, vì như vậy lớp cha kiểm soát được dữ liệu của chính nó.

Bổ từ truy cậpAi có thể dùng nó bằng tênKý hiệu UML
privatechỉ chính lớp đó-
protectedlớp đó, các lớp con của nó, và các lớp trong cùng gói#
publictất cả mọi người+

Hàm tạo và super(...)#

Hàm tạo không bao giờ được kế thừa. Một Dog cần hàm tạo riêng. Việc đầu tiên của nó là để lớp cha thiết lập phần của lớp cha, bằng cách gọi super(...) với các đối số của lớp cha. Lời gọi đó phải là dòng đầu tiên của hàm tạo lớp con. (Java 25 nới lỏng điều này một chút, cho phép các phép kiểm tra đơn giản trước lời gọi, nhưng quy tắc dòng đầu tiên là điều sách giáo khoa, IDE của bạn trên các phiên bản cũ hơn, và bài thi của bạn mong đợi.)

Nếu bạn bỏ lời gọi này, Java lặng lẽ viết super(); cho bạn, không có đối số. Điều đó chỉ chạy được khi lớp cha có một hàm tạo không nhận đối số. Khi không có, bạn nhận được lỗi này:

class Pet {
    private String name;

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

class Dog extends Pet {
    public Dog(String name) {
        System.out.println("Making a dog");
    }
}

public class NoSuper {
    public static void main(String[] args) {
        new Dog("Rex");
    }
}
NoSuper.java:10: error: constructor Pet in class Pet cannot be applied to given types;
    public Dog(String name) {
                            ^
  required: String
  found:    no arguments
  reason: actual and formal argument lists differ in length
1 error

Hãy đọc lỗi này là “bạn cố tạo một Pet mà không đưa gì, nhưng một Pet cần một String”. Cách sửa là lời gọi tường minh: super(name);.

Vì lớp cha luôn được thiết lập trước, các hàm tạo chạy từ đầu gia đình đi xuống. Hãy xem thứ tự:

class Animal {
    public Animal() {
        System.out.println("1. Animal part built");
    }
}

class Dog extends Animal {
    public Dog() {
        super();
        System.out.println("2. Dog part built");
    }
}

class Puppy extends Dog {
    public Puppy() {
        System.out.println("3. Puppy part built");
    }
}

public class Chain {
    public static void main(String[] args) {
        new Puppy();
    }
}
1. Animal part built
2. Dog part built
3. Puppy part built

Tạo một Puppy chạy ba hàm tạo, tổ tiên xa nhất trước. Một cách hữu ích để nhớ: bạn không thể thêm tầng hầm sau khi nhà đã xây xong. Phần của lớp cha là móng nhà, nên nó được đổ trước.

Ghi đè: thay thế một phương thức của lớp cha#

Ghi đè (overriding) nghĩa là lớp con viết phiên bản riêng của một phương thức mà lớp cha đã có, với cùng tên và cùng danh sách tham số. Khi phương thức đó được gọi trên một đối tượng của lớp con, phiên bản của lớp con chạy. Đây là dòng “gà tây thay cho thịt bò” trong ghi chú công thức.

class Pet {
    public String speak() {
        return "...";
    }
}

class Cat extends Pet {
    @Override
    public String speak() {
        return "Meow";
    }
}

class Parrot extends Pet {
    @Override
    public String speak() {
        return "Hello!";
    }
}

public class Overriding {
    public static void main(String[] args) {
        System.out.println(new Pet().speak());
        System.out.println(new Cat().speak());
        System.out.println(new Parrot().speak());
    }
}
...
Meow
Hello!

Con mèo và con vẹt đã thay thế speak. Thú cưng chung vẫn dùng phiên bản của lớp cha. Có hai quy tắc đi kèm với ghi đè: kiểu trả về phải khớp (hoặc là lớp con của nó), và lớp con không được làm phương thức kín hơn. Một phương thức public vẫn là public.

Hãy đặt @Override trên dòng phía trên mọi phương thức mà bạn định ghi đè. Nó là một chú thích (annotation), một ghi chú cho trình biên dịch, yêu cầu trình biên dịch kiểm tra rằng một phương thức khớp ở lớp cha thật sự tồn tại. Nếu không có nó, một lỗi gõ sẽ âm thầm tạo ra một phương thức hoàn toàn mới:

class Pet {
    public String speak() {
        return "...";
    }
}

class Cat extends Pet {
    @Override
    public String speek() {
        return "Meow";
    }
}

public class Typo {
    public static void main(String[] args) {
        System.out.println(new Cat().speak());
    }
}
Typo.java:8: error: method does not override or implement a method from a supertype
    @Override
    ^
1 error

Lỗi đó là một món quà. Nếu không có @Override, speek sẽ biên dịch được, con mèo vẫn nói câu chung chung, và bạn sẽ phải đi săn lỗi lúc chạy.

Ghi đè so với nạp chồng#

Hai từ này khác nhau ba chữ cái và người ra đề rất thích hoán đổi chúng. Điểm khác biệt là danh sách tham số.

Ghi đèNạp chồng
Têngiống nhaugiống nhau
Danh sách tham sốgiống nhaukhác nhau (số lượng, kiểu hoặc thứ tự)
Ở đâutrong một lớp con, thay thế phiên bản của lớp chathường trong cùng một lớp (một lớp con cũng có thể thêm)
Ai chọn phiên bảnđối tượng, trong khi chương trình chạytrình biên dịch, dựa trên kiểu của các đối số
class Animal {
    public String move() {
        return "moves";
    }
}

class Bird extends Animal {
    @Override
    public String move() {
        return "flies";
    }

    public String move(int metres) {
        return "flies " + metres + " m";
    }
}

public class Both {
    public static void main(String[] args) {
        Bird b = new Bird();
        System.out.println(new Animal().move());
        System.out.println(b.move());
        System.out.println(b.move(40));
    }
}
moves
flies
flies 40 m

Bird có ba phương thức move. move() không có đối số thay thế phương thức của lớp cha, đó là ghi đè. move(int) có danh sách tham số khác, đó là nạp chồng: nó nằm cạnh các phương thức khác chứ không thay thế gì. Câu để nhớ: ghi đè (override) là đi lại cùng một lộ trình; nạp chồng (overload) là nạp một bộ tham số khác.

Gọi phiên bản của lớp cha bằng super.#

Đôi khi bạn muốn bổ sung cho hành vi của lớp cha thay vì vứt nó đi. Bên trong một phương thức ghi đè, super.methodName() chạy phiên bản của lớp cha. Từ super ở đây nghĩa là “phần lớp cha của tôi”.

class Account {
    private String owner;
    private double balance;

    public Account(String owner, double balance) {
        this.owner = owner;
        this.balance = balance;
    }

    public String describe() {
        return owner + ": $" + balance;
    }
}

class Savings extends Account {
    private double rate;

    public Savings(String owner, double balance, double rate) {
        super(owner, balance);
        this.rate = rate;
    }

    @Override
    public String describe() {
        return super.describe() + " at " + rate + "%";
    }
}

public class SuperDot {
    public static void main(String[] args) {
        System.out.println(new Account("Ana", 120.0).describe());
        System.out.println(new Savings("Ben", 500.0, 2.5).describe());
    }
}
Ana: $120.0
Ben: $500.0 at 2.5%

Savings dùng lại mô tả của lớp cha và gắn lãi suất vào cuối. Nếu không có tiền tố super., describe() sẽ tự gọi chính nó, rồi lại tự gọi chính nó, cho đến khi ngăn xếp lời gọi hết chỗ và Java dừng với một StackOverflowError. Đó là cái bẫy kinh điển trong bài thi.

Vậy super có hai việc, và nên giữ chúng tách biệt:

Viết làỞ đâuTác dụng
super(...)dòng đầu tiên của một hàm tạochạy hàm tạo của lớp cha
super.method()bất kỳ phương thức thể hiện nàochạy phiên bản của lớp cha cho phương thức đó

Vẽ kế thừa bằng UML#

UML, Unified Modeling Language, là cách chuẩn để phác họa các lớp thành những chiếc hộp. Mỗi hộp có ba phần xếp từ trên xuống: tên lớp, các trường, rồi các phương thức. Dấu trừ nghĩa là private và dấu cộng nghĩa là public. Kế thừa được vẽ bằng một đường liền với đầu mũi tên là tam giác rỗng chỉ vào lớp cha.

        +-----------------------+
        |        Account        |
        +-----------------------+
        | - owner : String      |
        | - balance : double    |
        +-----------------------+
        | + deposit(amt:double) |
        | + describe() : String |
        +-----------------------+
                    ^   hollow triangle points at the parent
                    |
        +-----------------------+
        |        Savings        |
        +-----------------------+
        | - rate : double       |
        +-----------------------+
        | + describe() : String |
        +-----------------------+

Hộp của lớp con chỉ liệt kê những gì mới hoặc bị ghi đè. Savings hiện lại describe() vì nó ghi đè phương thức này; nó không lặp lại deposit, thứ mà nó chỉ đơn giản kế thừa. Nếu chỉ nhớ một điều: mũi tên chỉ từ lớp con tới lớp cha, vì lớp con biết cha của mình là ai, còn lớp cha không biết các con của nó.

Thêm một sự thật cho sau này: một lớp không có extends vẫn có một lớp cha. Java cho nó Object, lớp ở đỉnh mọi cây gia phả. Bài hướng dẫn tiếp theo nói về những gì bạn kế thừa từ đó.

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

Lớp con là ghi chú công thức, không phải một tấm thẻ mới: nó gọi super(...) trước tiên, kế thừa mọi thứ public, và chỉ ghi đè một phương thức khi tên và danh sách tham số đều khớp. Cùng tham số là ghi đè; khác tham số là nạp chồng.

Những chỗ dễ sai#

  • Với tay lấy trường private của lớp cha bằng tên. Nó có đó, nhưng bị khóa. Hãy dùng getter của lớp cha.
  • Đặt super(...) ở bất cứ đâu ngoài dòng đầu tiên. Trước Java 25, nó phải đứng đầu, nếu không hàm tạo không biên dịch được; viết nó ở đầu thì an toàn trên mọi phiên bản.
  • Quên super(...) khi lớp cha không có hàm tạo rỗng. Java chèn super() cho bạn, và nó thất bại.
  • Gọi một phương thức nạp chồng là ghi đè. Một danh sách tham số khác là một phương thức mới nằm cạnh cái cũ, không phải thay thế.
  • Bỏ @Override. Khi đó một tên viết sai sẽ biên dịch như một phương thức mới và phiên bản của lớp cha tiếp tục chạy.
  • Viết describe() thay vì super.describe() trong một phương thức ghi đè. Phương thức tự gọi chính nó cho đến khi chương trình sập với một StackOverflowError.
  • Vẽ mũi tên UML về phía lớp con. Tam giác rỗng chỉ vào lớp cha.
  • Cố mở rộng hai lớp. Java chỉ cho phép một lớp cha.

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. Trong class Truck extends Vehicle, hãy gọi tên lớp cha và lớp con, và cho hai tên gọi còn lại của mỗi lớp.
  2. Chương trình này in ra gì?
    class A {
        public A() { System.out.println("A"); }
        public void show() { System.out.println("A.show"); }
    }
    class B extends A {
        public B() { System.out.println("B"); }
        @Override
        public void show() {
            super.show();
            System.out.println("B.show");
        }
    }
    // in main:
    B b = new B();
    b.show();
  3. Một lớp Pet chỉ có hàm tạo Pet(String name). Lớp con của nó có public Dog() { }. Vì sao điều này không biên dịch được, và cách sửa nhỏ nhất là gì?
  4. Shape có double area(). Circle extends Shape khai báo double area() và cả double area(int decimals). Cái nào ghi đè và cái nào nạp chồng?
  5. Viết một lớp Square mở rộng lớp Rectangle(double width, double height). Một Square được tạo từ một độ dài cạnh và ghi đè describe() để nói “Square” thay vì “Rectangle”.
  6. @Override làm gì, và điều gì xảy ra nếu bạn bỏ nó khỏi một phương thức ghi đè viết đúng chính tả?

Lời giải#

  1. Vehicle là lớp cha (superclass), còn gọi là base class hay parent class. Truck là lớp con (subclass), còn gọi là derived class hay child class. Câu thử vẫn đúng: một chiếc xe tải là một phương tiện.
  2. Hàm tạo của lớp cha chạy trước (Java đã chèn super() ở đầu B()), rồi show chạy phiên bản của lớp cha trước khi thêm dòng riêng của nó:
    class A {
        public A() {
            System.out.println("A");
        }
    
        public void show() {
            System.out.println("A.show");
        }
    }
    
    class B extends A {
        public B() {
            System.out.println("B");
        }
    
        @Override
        public void show() {
            super.show();
            System.out.println("B.show");
        }
    }
    
    public class Q2 {
        public static void main(String[] args) {
            B b = new B();
            b.show();
        }
    }
    A
    B
    A.show
    B.show
  3. Vì Java chèn super(); làm dòng đầu tiên của Dog(), và Pet không có hàm tạo nào không nhận đối số. Trình biên dịch báo constructor Pet in class Pet cannot be applied to given types. Cách sửa: cho dòng đầu truyền một cái tên lên, ví dụ super("unnamed");, hoặc cho Dog một tham số String name và gọi super(name);.
  4. area() trong Circle có cùng tên và cùng danh sách tham số (rỗng) với của lớp cha, nên nó ghi đè. area(int decimals) có danh sách tham số khác, nên nó nạp chồng: nó thêm một phương thức mới và không thay thế gì.
  5. Hàm tạo truyền cạnh lên hai lần, và describe được ghi đè với cùng chữ ký:
    class Rectangle {
        private double width, height;
    
        public Rectangle(double width, double height) {
            this.width = width;
            this.height = height;
        }
    
        public double area() {
            return width * height;
        }
    
        public String describe() {
            return "Rectangle with area " + area();
        }
    }
    
    class Square extends Rectangle {
        public Square(double side) {
            super(side, side);
        }
    
        @Override
        public String describe() {
            return "Square with area " + area();
        }
    }
    
    public class Q5 {
        public static void main(String[] args) {
            System.out.println(new Rectangle(2, 5).describe());
            System.out.println(new Square(3).describe());
        }
    }
    Rectangle with area 10.0
    Square with area 9.0
    Square chưa bao giờ viết area(); nó đã kế thừa phương thức đó.
  6. Nó yêu cầu trình biên dịch xác nhận rằng phương thức thật sự ghi đè một phương thức của lớp cha, và dừng với method does not override or implement a method from a supertype nếu không. Bỏ nó khỏi một phương thức ghi đè viết đúng chính tả không đổi gì lúc chạy; phương thức vẫn ghi đè. Bạn chỉ mất phép kiểm tra an toàn chống lỗi gõ.

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ể giải thích kế thừa và nêu ba cặp tên gọi: base/derived, parent/child, super/sub class.
  • ☐  Tôi có thể viết một lớp con với extends và một hàm tạo gọi super(...) trước tiên.
  • ☐  Tôi có thể ghi đè một phương thức, và nói được ghi đè khác nạp chồng ra sao.
  • ☐  Tôi có thể gọi phiên bản của lớp cơ sở cho một phương thức bằng super.method().
  • ☐  Tôi có thể vẽ UML cho một lớp cha và lớp con, với mũi tên chỉ đúng hướng.

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

40 câu hỏi luyện tập về extends, super, chuỗi hàm tạo và ghi đè, 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 ngoại tuyến, không cần tài khoản.

Luyện tập kế thừa →

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

Lớp cha và lớp con trong Java khác nhau thế nào?

Lớp cha là lớp đã có sẵn; lớp con là lớp mới mở rộng nó bằng từ khóa extends. Lớp con kế thừa các thành viên public và protected của lớp cha, và chỉ thêm hoặc ghi đè những gì khác biệt. Superclass, base class và parent class đều có nghĩa như nhau, subclass, derived class và child class cũng vậy.

Lớp con có kế thừa các trường private không?

Một đối tượng của lớp con có chứa các trường private của lớp cha, nhưng mã của chính lớp con không thể dùng chúng bằng tên. Mã trong lớp con nhận "has private access" từ trình biên dịch. Nó phải đi qua các phương thức public của lớp cha như getter, hoặc trường đó phải được đổi thành protected.

Vì sao super() phải là dòng đầu tiên của một hàm tạo?

Vì phần của lớp cha trong đối tượng phải được thiết lập trước khi phần của lớp con có thể dựa vào nó. Java 25 nới lỏng quy tắc một chút để cho phép các câu lệnh đơn giản không dùng đối tượng trước lời gọi, nhưng ở các phiên bản trước, và trong hầu hết các môn học, super(...) phải đứng đầu. Nếu bạn không viết lời gọi super, Java chèn super() không có đối số, và điều đó không biên dịch được khi lớp cha không có hàm tạo nào không nhận đối số.

Ghi đè và nạp chồng khác nhau thế nào?

Ghi đè là một phương thức của lớp con có cùng tên và cùng danh sách tham số với một phương thức của lớp cha; nó thay thế phiên bản của lớp cha cho các đối tượng của lớp con, và phiên bản được chọn khi chương trình đang chạy. Nạp chồng là một phương thức cùng tên nhưng khác danh sách tham số; nó thêm một phương thức mới, và trình biên dịch chọn phương thức nào dựa trên kiểu của các đối số.

super.method() làm gì?

Bên trong một lớp con, super.method() chạy phiên bản của lớp cha cho một phương thức, thường là từ trong một phương thức ghi đè muốn bổ sung cho hành vi của lớp cha thay vì thay thế nó. Nếu không có tiền tố super., phương thức ghi đè sẽ tự gọi chính nó.

Một lớp Java có thể mở rộng nhiều hơn một lớp không?

Không. Một lớp Java có đúng một lớp cha trực tiếp. Nếu không viết mệnh đề extends, lớp cha là Object. Một lớp có thể implements nhiều giao diện, đó là cách Java cho một lớp đảm nhận nhiều vai trò.

Đề 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.