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()trongShapekhông có thân, chỉ có dấu chấm phẩy, và được đánh dấuabstract. 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ấuabstract.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ọiarea(), 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àShapedù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ạyarea()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:
- 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.
- 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à
publicvà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ứcdefaultvàstaticcó thân, và từ Java 9 là các phương thứcprivatehỗ 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.
Phonekế thừaDevicevà 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ượng | Giao diện | |
|---|---|---|
| Từ khóa để dùng nó | extends | implements |
| Bao nhiêu cho mỗi lớp | một | bao nhiêu tùy thích |
| Bạn có thể tạo đối tượng của nó không? | không | không |
| Hàm tạo | có | không |
| Trường | mọi loại, kể cả dữ liệu private theo từng đối tượng | chỉ các hằng public static final |
| Phương thức có thân | có, bao nhiêu tùy thích | chỉ các phương thức default, static và private |
| Quan hệ nó biểu đạt | là-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 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ặcnew 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
extendscho giao diện hoặcimplementscho 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ã đó.
- Những dòng nào biên dịch được, cho
abstract class Animalvà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]; Animalkhai báopublic abstract String sound();và mộtspeak()đã hoàn chỉnh trả về"The animal says " + sound(). Hãy viết lớpCownhỏ nhất biên dịch được, và nóinew Cow().speak()trả về gì.- Một lớp
Robotđã kế thừaMachine. Nó cũng cần làRechargeablevàProgrammable. Hai cái đó nên là lớp trừu tượng hay giao diện? Vì sao? - Viết một giao diện
Playablevới một phương thứcString play(), hai lớp triển khai nó, và một vòng lặp quaPlayable[]gọiplay()trên từng phần tử. - Nêu ba điểm khác nhau giữa lớp trừu tượng và giao diện.
- Trong UML, làm sao phân biệt lớp trừu tượng với lớp thường, và vẽ “
PhoneimplementsChargeable” như thế nào?
Lời giải#
- 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ảngAnimal, đó 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. Cowchỉ phải điền vào chỗ trống; nó thừa hưởngspeak():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- 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 choMachine. 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. - 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 - 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ứcdefault,staticvàprivate; lớp trừu tượng biểu đạt là-một, giao diện biểu đạt có-thể-làm. - 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ừPhonetớiChargeablevới tam giác rỗng ở phíaChargeable, và khung củaChargeableđượ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.
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.