คลาสนามธรรมเป็นคลาสที่ไม่สามารถสร้างอินสแตนซ์ได้ คลาสนามธรรมถูกใช้โดยการสร้างคลาสย่อยที่สืบทอดซึ่งสามารถสร้างอินสแตนซ์ได้ คลาสนามธรรมทำบางสิ่งสำหรับคลาสย่อยที่รับค่า:
- กำหนดวิธีการที่สามารถใช้โดยคลาสย่อยที่สืบทอด
- กำหนดวิธีการนามธรรมซึ่ง subclass รับมรดกต้องดำเนินการ
- จัดให้มีอินเตอร์เฟสทั่วไปซึ่งอนุญาตให้คลาสย่อยสลับกับคลาสย่อยอื่นทั้งหมด
นี่คือตัวอย่าง:
abstract public class AbstractClass
{
abstract public void abstractMethod();
public void implementedMethod() { System.out.print("implementedMethod()"); }
final public void finalMethod() { System.out.print("finalMethod()"); }
}
โปรดสังเกตว่า "abstractMethod ()" ไม่มีเนื้อความของเมธอด ด้วยเหตุนี้คุณจึงไม่สามารถทำสิ่งต่อไปนี้:
public class ImplementingClass extends AbstractClass
{
// ERROR!
}
ไม่มีวิธีการที่ใช้abstractMethod()! ดังนั้นจึงมีทางสำหรับ JVM new ImplementingClass().abstractMethod()ที่จะรู้ว่าสิ่งที่มันควรจะทำอย่างไรเมื่อได้รับบางสิ่งบางอย่างที่ไม่เหมือนใคร
นี่ถูกต้องImplementingClassแล้ว
public class ImplementingClass extends AbstractClass
{
public void abstractMethod() { System.out.print("abstractMethod()"); }
}
ขอให้สังเกตว่าคุณไม่ได้มีการกำหนดหรือimplementedMethod() พวกเขาถูกกำหนดไว้แล้วโดยfinalMethod()AbstractClass
ImplementingClassนี่คือที่ถูกต้องอีก
public class ImplementingClass extends AbstractClass
{
public void abstractMethod() { System.out.print("abstractMethod()"); }
public void implementedMethod() { System.out.print("Overridden!"); }
}
implementedMethod()ในกรณีนี้คุณได้แทนที่
อย่างไรก็ตามเนื่องจากfinalคำหลักทำให้เป็นไปไม่ได้
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!"); }
}
คุณไม่สามารถทำสิ่งนี้ได้เนื่องจากการใช้งานของfinalMethod()in AbstractClassถูกทำเครื่องหมายว่าเป็นการใช้งานขั้นสุดท้ายของfinalMethod(): จะไม่มีการอนุญาตให้มีการใช้งานอื่น ๆ
ตอนนี้คุณยังสามารถใช้คลาสนามธรรมได้สองครั้ง:
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()"); }
}
คุณสามารถเขียนวิธีอื่นได้แล้ว
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()"
}
ขอให้สังเกตว่าแม้ว่าเราจะประกาศชนิดจะแสดง นี่เป็นเพราะวัตถุที่เราสร้างอินสแตนซ์นั้นแท้จริงแล้วเป็นของซึ่งถูกแทนที่แน่นอน (คุณอาจเคยเห็นสิ่งนี้เรียกว่า polymorphism)bAbstractClass"Overriden!"ImplementingClassimplementedMethod()
หากเราต้องการเข้าถึงสมาชิกที่เฉพาะเจาะจงสำหรับคลาสย่อยเฉพาะเราจะต้องส่งไปที่คลาสย่อยนั้นก่อน:
// 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();
สุดท้ายคุณไม่สามารถทำสิ่งต่อไปนี้:
public class ImplementingClass extends AbstractClass, SomeOtherAbstractClass
{
... // implementation
}
สามารถขยายได้ครั้งละหนึ่งคลาสเท่านั้น หากคุณต้องการขยายหลายคลาสพวกเขาจะต้องเป็นอินเทอร์เฟซ คุณสามารถทำได้:
public class ImplementingClass extends AbstractClass implements InterfaceA, InterfaceB
{
... // implementation
}
นี่คืออินเทอร์เฟซตัวอย่าง:
interface InterfaceA
{
void interfaceMethod();
}
นี่เป็นพื้นเหมือนกับ:
abstract public class InterfaceA
{
abstract public void interfaceMethod();
}
ความแตกต่างเพียงอย่างเดียวคือวิธีที่สองไม่ให้คอมไพเลอร์ทราบว่าเป็นอินเทอร์เฟซจริง สิ่งนี้มีประโยชน์หากคุณต้องการให้ผู้คนใช้งานอินเทอร์เฟซของคุณเท่านั้นและไม่มีผู้อื่น อย่างไรก็ตามตามกฎทั่วไปของหัวแม่มือเริ่มต้นหากระดับนามธรรมของคุณมีวิธีการแบบนามธรรมคุณควรทำให้มันเป็นอินเทอร์เฟซ
ต่อไปนี้ผิดกฎหมาย:
interface InterfaceB
{
void interfaceMethod() { System.out.print("ERROR!"); }
}
คุณไม่สามารถใช้วิธีการในส่วนต่อประสาน ซึ่งหมายความว่าถ้าคุณใช้อินเทอร์เฟซที่แตกต่างกันสองวิธีวิธีต่าง ๆ ในอินเทอร์เฟซเหล่านั้นไม่สามารถชนกัน เนื่องจากวิธีการทั้งหมดในส่วนต่อประสานเป็นนามธรรมคุณต้องใช้วิธีการและเนื่องจากวิธีการของคุณเป็นเพียงการนำไปใช้ในแผนผังการสืบทอดเท่านั้นคอมไพเลอร์จึงรู้ว่าต้องใช้วิธีการของคุณ
