Eine abstrakte Klasse ist eine Klasse, die nicht instanziiert werden kann. Eine abstrakte Klasse wird durch Erstellen einer Unterklasse erbt verwendet , die können instanziiert werden. Eine abstrakte Klasse erledigt einige Dinge für die erbende Unterklasse:
- Definieren Sie Methoden, die von der erbenden Unterklasse verwendet werden können.
- Definieren Sie abstrakte Methoden, die die erbende Unterklasse implementieren muss.
- Stellen Sie eine gemeinsame Schnittstelle bereit, über die die Unterklasse mit allen anderen Unterklassen ausgetauscht werden kann.
Hier ist ein Beispiel:
abstract public class AbstractClass
{
abstract public void abstractMethod();
public void implementedMethod() { System.out.print("implementedMethod()"); }
final public void finalMethod() { System.out.print("finalMethod()"); }
}
Beachten Sie, dass "abstractMethod ()" keinen Methodenkörper hat. Aus diesem Grund können Sie Folgendes nicht tun:
public class ImplementingClass extends AbstractClass
{
// ERROR!
}
Es gibt keine Methode, die implementiert abstractMethod()! Die JVM kann also nicht wissen, was sie tun soll, wenn sie so etwas bekommt new ImplementingClass().abstractMethod().
Hier ist eine korrekte ImplementingClass.
public class ImplementingClass extends AbstractClass
{
public void abstractMethod() { System.out.print("abstractMethod()"); }
}
Beachten Sie, dass Sie müssen nicht definieren implementedMethod()oder finalMethod(). Sie wurden bereits von definiert AbstractClass.
Hier ist noch eine richtige ImplementingClass.
public class ImplementingClass extends AbstractClass
{
public void abstractMethod() { System.out.print("abstractMethod()"); }
public void implementedMethod() { System.out.print("Overridden!"); }
}
In diesem Fall haben Sie überschrieben implementedMethod().
Aufgrund des finalSchlüsselworts ist Folgendes jedoch nicht möglich.
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!"); }
}
Sie können dies nicht tun, da die Implementierung von finalMethod()in AbstractClassals die endgültige Implementierung von markiert ist finalMethod(): Es werden niemals andere Implementierungen zugelassen.
Jetzt können Sie auch eine abstrakte Klasse implementieren zweimal:
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()"); }
}
Jetzt könnten Sie irgendwo eine andere Methode schreiben.
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()"
}
Beachten Sie, dass , obwohl wir erklären beine AbstractClassArt, zeigt es "Overriden!". Dies liegt daran, dass das von uns instanziierte Objekt tatsächlich ein Objekt war ImplementingClass, das implementedMethod()natürlich überschrieben wird. (Möglicherweise haben Sie dies als Polymorphismus bezeichnet gesehen.)
Wenn wir auf ein Mitglied zugreifen möchten, das für eine bestimmte Unterklasse spezifisch ist, müssen wir zuerst auf diese Unterklasse zurückgreifen:
// 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();
Schließlich können Sie Folgendes nicht tun:
public class ImplementingClass extends AbstractClass, SomeOtherAbstractClass
{
... // implementation
}
Es kann jeweils nur eine Klasse erweitert werden. Wenn Sie mehrere Klassen erweitern müssen, müssen diese Schnittstellen sein. Du kannst das:
public class ImplementingClass extends AbstractClass implements InterfaceA, InterfaceB
{
... // implementation
}
Hier ist eine Beispielschnittstelle:
interface InterfaceA
{
void interfaceMethod();
}
Dies ist im Grunde das gleiche wie:
abstract public class InterfaceA
{
abstract public void interfaceMethod();
}
Der einzige Unterschied besteht darin, dass der Compiler auf dem zweiten Weg nicht weiß, dass es sich tatsächlich um eine Schnittstelle handelt. Dies kann nützlich sein, wenn Sie möchten, dass Benutzer nur Ihre Schnittstelle und keine anderen implementieren. Als allgemeine Faustregel für Anfänger sollten Sie Ihre abstrakte Klasse jedoch wahrscheinlich zu einer Schnittstelle machen, wenn sie nur über abstrakte Methoden verfügt.
Folgendes ist illegal:
interface InterfaceB
{
void interfaceMethod() { System.out.print("ERROR!"); }
}
Sie können keine Methoden in einer Schnittstelle implementieren. Wenn Sie also zwei verschiedene Schnittstellen implementieren, können die verschiedenen Methoden in diesen Schnittstellen nicht kollidieren. Da alle Methoden in einer Schnittstelle abstrakt sind, müssen Sie die Methode implementieren. Da Ihre Methode die einzige Implementierung im Vererbungsbaum ist, weiß der Compiler, dass er Ihre Methode verwenden muss.
