Một lớp trừu tượng là một lớp không thể khởi tạo được. Một lớp trừu tượng được sử dụng bằng cách tạo một lớp con kế thừa có thể được khởi tạo. Một lớp trừu tượng thực hiện một số điều cho lớp con kế thừa:
- Xác định các phương thức có thể được sử dụng bởi lớp con kế thừa.
- Xác định các phương thức trừu tượng mà lớp con kế thừa phải thực hiện.
- Cung cấp một giao diện chung cho phép lớp con được hoán đổi với tất cả các lớp con khác.
Đây là một ví dụ:
abstract public class AbstractClass
{
abstract public void abstractMethod();
public void implementedMethod() { System.out.print("implementedMethod()"); }
final public void finalMethod() { System.out.print("finalMethod()"); }
}
Lưu ý rằng "trừu tượng hóa ()" không có bất kỳ thân phương thức nào. Vì điều này, bạn không thể làm như sau:
public class ImplementingClass extends AbstractClass
{
// ERROR!
}
Không có phương pháp nào thực hiện abstractMethod()! Vì vậy, không có cách nào để JVM biết nó phải làm gì khi có được thứ gì đó như thế nào new ImplementingClass().abstractMethod().
Đây là một chính xác ImplementingClass.
public class ImplementingClass extends AbstractClass
{
public void abstractMethod() { System.out.print("abstractMethod()"); }
}
Lưu ý rằng bạn không phải xác định implementedMethod()hoặc finalMethod(). Họ đã được xác định bởi AbstractClass.
Đây là một chính xác ImplementingClass.
public class ImplementingClass extends AbstractClass
{
public void abstractMethod() { System.out.print("abstractMethod()"); }
public void implementedMethod() { System.out.print("Overridden!"); }
}
Trong trường hợp này, bạn đã ghi đè implementedMethod().
Tuy nhiên, vì finaltừ khóa, sau đây là không thể.
public class ImplementingClass extends AbstractClass
{
public void abstractMethod() { System.out.print("abstractMethod()"); }
public void implementedMethod() { System.out.print("Overridden!"); }
public void finalMethod() { System.out.print("ERROR!"); }
}
Bạn không thể làm điều này bởi vì việc triển khai finalMethod()trong AbstractClassđược đánh dấu là triển khai cuối cùng của finalMethod(): không bao giờ thực hiện việc nào khác được cho phép.
Bây giờ bạn cũng có thể thực hiện một lớp trừu tượng hai lần:
public class ImplementingClass extends AbstractClass
{
public void abstractMethod() { System.out.print("abstractMethod()"); }
public void implementedMethod() { System.out.print("Overridden!"); }
}
// In a separate file.
public class SecondImplementingClass extends AbstractClass
{
public void abstractMethod() { System.out.print("second abstractMethod()"); }
}
Bây giờ ở đâu đó bạn có thể viết một phương pháp khác.
public tryItOut()
{
ImplementingClass a = new ImplementingClass();
AbstractClass b = new ImplementingClass();
a.abstractMethod(); // prints "abstractMethod()"
a.implementedMethod(); // prints "Overridden!" <-- same
a.finalMethod(); // prints "finalMethod()"
b.abstractMethod(); // prints "abstractMethod()"
b.implementedMethod(); // prints "Overridden!" <-- same
b.finalMethod(); // prints "finalMethod()"
SecondImplementingClass c = new SecondImplementingClass();
AbstractClass d = new SecondImplementingClass();
c.abstractMethod(); // prints "second abstractMethod()"
c.implementedMethod(); // prints "implementedMethod()"
c.finalMethod(); // prints "finalMethod()"
d.abstractMethod(); // prints "second abstractMethod()"
d.implementedMethod(); // prints "implementedMethod()"
d.finalMethod(); // prints "finalMethod()"
}
Lưu ý rằng mặc dù chúng tôi đã khai báo bmột AbstractClassloại, nó sẽ hiển thị "Overriden!". Điều này là do đối tượng chúng ta khởi tạo thực sự là một ImplementingClass, implementedMethod()tất nhiên là bị ghi đè. (Bạn có thể đã thấy điều này được gọi là đa hình.)
Nếu chúng ta muốn truy cập một thành viên cụ thể vào một lớp con cụ thể, trước tiên chúng ta phải bỏ xuống lớp con đó:
// Say ImplementingClass also contains uniqueMethod()
// To access it, we use a cast to tell the runtime which type the object is
AbstractClass b = new ImplementingClass();
((ImplementingClass)b).uniqueMethod();
Cuối cùng, bạn không thể làm như sau:
public class ImplementingClass extends AbstractClass, SomeOtherAbstractClass
{
... // implementation
}
Mỗi lần chỉ có thể mở rộng một lớp. Nếu bạn cần mở rộng nhiều lớp, chúng phải là các giao diện. Bạn có thể làm được việc này:
public class ImplementingClass extends AbstractClass implements InterfaceA, InterfaceB
{
... // implementation
}
Đây là một giao diện ví dụ:
interface InterfaceA
{
void interfaceMethod();
}
Điều này về cơ bản giống như:
abstract public class InterfaceA
{
abstract public void interfaceMethod();
}
Sự khác biệt duy nhất là cách thứ hai không cho trình biên dịch biết rằng đó thực sự là một giao diện. Điều này có thể hữu ích nếu bạn muốn mọi người chỉ thực hiện giao diện của bạn và không có ai khác. Tuy nhiên, như một quy tắc chung cho người mới bắt đầu, nếu lớp trừu tượng của bạn chỉ có các phương thức trừu tượng, có lẽ bạn nên biến nó thành một giao diện.
Sau đây là bất hợp pháp:
interface InterfaceB
{
void interfaceMethod() { System.out.print("ERROR!"); }
}
Bạn không thể thực hiện các phương thức trong một giao diện. Điều này có nghĩa là nếu bạn triển khai hai giao diện khác nhau, các phương thức khác nhau trong các giao diện đó không thể va chạm. Vì tất cả các phương thức trong một giao diện là trừu tượng, bạn phải thực hiện phương thức và vì phương thức của bạn là triển khai duy nhất trong cây thừa kế, trình biên dịch biết rằng nó phải sử dụng phương thức của bạn.
