Klasa abstrakcyjna to klasa, której nie można utworzyć. Klasa abstrakcyjna jest używana przez tworzenie dziedziczącej podklasy, którą można utworzyć. Klasa abstrakcyjna wykonuje kilka czynności dla dziedziczącej podklasy:
- Zdefiniuj metody, które mogą być używane przez dziedziczącą podklasę.
- Zdefiniuj metody abstrakcyjne, które musi wdrożyć dziedzicząca podklasa.
- Zapewnij wspólny interfejs, który umożliwia wymianę podklasy ze wszystkimi innymi podklasami.
Oto przykład:
abstract public class AbstractClass
{
abstract public void abstractMethod();
public void implementedMethod() { System.out.print("implementedMethod()"); }
final public void finalMethod() { System.out.print("finalMethod()"); }
}
Zauważ, że „abstractMethod ()” nie ma treści żadnej metody. Z tego powodu nie można wykonać następujących czynności:
public class ImplementingClass extends AbstractClass
{
// ERROR!
}
Nie ma metody, która implementuje abstractMethod()! Dlatego JVM nie może wiedzieć, co ma zrobić, gdy coś się stanie new ImplementingClass().abstractMethod().
Oto poprawne ImplementingClass.
public class ImplementingClass extends AbstractClass
{
public void abstractMethod() { System.out.print("abstractMethod()"); }
}
Zauważ, że nie musisz definiować implementedMethod()ani finalMethod(). Zostały już zdefiniowane przez AbstractClass.
Oto kolejna poprawna ImplementingClass.
public class ImplementingClass extends AbstractClass
{
public void abstractMethod() { System.out.print("abstractMethod()"); }
public void implementedMethod() { System.out.print("Overridden!"); }
}
W tym przypadku zostało zastąpione implementedMethod().
Jednak ze względu na finalsłowo kluczowe nie jest możliwe.
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!"); }
}
Nie możesz tego zrobić, ponieważ implementacja finalMethod()in AbstractClassjest oznaczona jako ostateczna implementacja finalMethod(): żadne inne implementacje nie będą dozwolone.
Teraz możesz także dwukrotnie zaimplementować klasę abstrakcyjną:
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()"); }
}
Teraz gdzieś możesz napisać inną metodę.
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()"
}
Należy zauważyć, że chociaż ogłosił bto AbstractClasstyp, wyświetla "Overriden!". Wynika to z faktu, że obiekt, który utworzyliśmy, był w rzeczywistości obiektem ImplementingClass, który implementedMethod()oczywiście jest przesłonięty. (Być może widzieliście to jako polimorfizm).
Jeśli chcemy uzyskać dostęp do członka określonego dla konkretnej podklasy, musimy najpierw przejść do tej podklasy:
// 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();
Wreszcie nie można wykonać następujących czynności:
public class ImplementingClass extends AbstractClass, SomeOtherAbstractClass
{
... // implementation
}
Jednorazowo można przedłużyć tylko jedną klasę. Jeśli chcesz rozszerzyć wiele klas, muszą to być interfejsy. Możesz to zrobić:
public class ImplementingClass extends AbstractClass implements InterfaceA, InterfaceB
{
... // implementation
}
Oto przykładowy interfejs:
interface InterfaceA
{
void interfaceMethod();
}
Jest to w zasadzie to samo, co:
abstract public class InterfaceA
{
abstract public void interfaceMethod();
}
Jedyną różnicą jest to, że drugi sposób nie pozwala kompilatorowi wiedzieć, że tak naprawdę jest interfejsem. Może to być przydatne, jeśli chcesz, aby ludzie implementowali tylko Twój interfejs, a nie innych. Jednak jako ogólna zasada dla początkujących, jeśli twoja klasa abstrakcyjna ma tylko metody abstrakcyjne, prawdopodobnie powinieneś uczynić ją interfejsem.
Następujące działania są nielegalne:
interface InterfaceB
{
void interfaceMethod() { System.out.print("ERROR!"); }
}
Nie można zaimplementować metod w interfejsie. Oznacza to, że jeśli zaimplementujesz dwa różne interfejsy, różne metody w tych interfejsach nie będą kolidować. Ponieważ wszystkie metody w interfejsie są abstrakcyjne, musisz zaimplementować metodę, a ponieważ twoja metoda jest jedyną implementacją w drzewie dziedziczenia, kompilator wie, że musi użyć twojej metody.
