Kelas abstrak adalah kelas yang tidak bisa dipakai. Kelas abstrak digunakan dengan membuat subclass warisan yang bisa dipakai. Kelas abstrak melakukan beberapa hal untuk subclass yang diwarisi:
- Tentukan metode yang dapat digunakan oleh subclass yang diwarisi.
- Tetapkan metode abstrak yang harus diterapkan oleh subkelas turunan.
- Menyediakan antarmuka umum yang memungkinkan subclass untuk dipertukarkan dengan semua subclass lainnya.
Ini sebuah contoh:
abstract public class AbstractClass
{
abstract public void abstractMethod();
public void implementedMethod() { System.out.print("implementedMethod()"); }
final public void finalMethod() { System.out.print("finalMethod()"); }
}
Perhatikan bahwa "abstractMethod ()" tidak memiliki tubuh metode apa pun. Karena itu, Anda tidak dapat melakukan hal berikut:
public class ImplementingClass extends AbstractClass
{
// ERROR!
}
Tidak ada metode yang mengimplementasikan abstractMethod()! Jadi tidak ada cara bagi JVM untuk mengetahui apa yang seharusnya dilakukan ketika mendapat sesuatu new ImplementingClass().abstractMethod().
Ini benar ImplementingClass.
public class ImplementingClass extends AbstractClass
{
public void abstractMethod() { System.out.print("abstractMethod()"); }
}
Perhatikan bahwa Anda tidak perlu mendefinisikan implementedMethod()atau finalMethod(). Mereka sudah didefinisikan oleh AbstractClass.
Ini satu lagi yang benar ImplementingClass.
public class ImplementingClass extends AbstractClass
{
public void abstractMethod() { System.out.print("abstractMethod()"); }
public void implementedMethod() { System.out.print("Overridden!"); }
}
Dalam hal ini, Anda telah ditimpa implementedMethod().
Namun, karena finalkata kunci, yang berikut ini tidak mungkin.
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!"); }
}
Anda tidak dapat melakukan ini karena implementasi finalMethod()di AbstractClassditandai sebagai implementasi akhir dari finalMethod(): tidak ada implementasi lain yang akan diizinkan.
Sekarang Anda juga dapat menerapkan kelas abstrak dua kali:
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()"); }
}
Sekarang di suatu tempat Anda bisa menulis metode lain.
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()"
}
Perhatikan bahwa meskipun kita menyatakan bsebuah AbstractClassjenis, itu menampilkan"Overriden!" . Ini karena objek yang kita instantiasi sebenarnya adalah ImplementingClass, yang implementedMethod()tentu saja ditimpa. (Anda mungkin pernah melihat ini disebut sebagai polimorfisme.)
Jika kita ingin mengakses anggota yang spesifik untuk subkelas tertentu, kita harus memilih ke subkelas itu terlebih dahulu:
// 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();
Terakhir, Anda tidak dapat melakukan hal berikut:
public class ImplementingClass extends AbstractClass, SomeOtherAbstractClass
{
... // implementation
}
Hanya satu kelas yang dapat diperpanjang sekaligus. Jika Anda perlu memperluas beberapa kelas, mereka harus berupa antarmuka. Kamu bisa melakukan ini:
public class ImplementingClass extends AbstractClass implements InterfaceA, InterfaceB
{
... // implementation
}
Berikut ini contoh antarmuka:
interface InterfaceA
{
void interfaceMethod();
}
Ini pada dasarnya sama dengan:
abstract public class InterfaceA
{
abstract public void interfaceMethod();
}
Satu-satunya perbedaan adalah bahwa cara kedua tidak membuat kompiler tahu bahwa itu sebenarnya sebuah antarmuka. Ini bisa bermanfaat jika Anda ingin orang hanya mengimplementasikan antarmuka Anda dan tidak ada yang lain. Namun, sebagai aturan umum pemula, jika kelas abstrak Anda hanya memiliki metode abstrak, Anda mungkin harus membuatnya menjadi antarmuka.
Berikut ini adalah ilegal:
interface InterfaceB
{
void interfaceMethod() { System.out.print("ERROR!"); }
}
Anda tidak dapat menerapkan metode dalam suatu antarmuka. Ini berarti bahwa jika Anda menerapkan dua antarmuka yang berbeda, metode yang berbeda di antarmuka tersebut tidak dapat bertabrakan. Karena semua metode dalam antarmuka adalah abstrak, Anda harus mengimplementasikan metode tersebut, dan karena metode Anda adalah satu-satunya implementasi dalam pohon warisan, kompiler tahu bahwa ia harus menggunakan metode Anda.
