Абстрактний клас - це клас, який неможливо встановити. Абстрактний клас використовується шляхом створення спадкового підкласу, який можна інстанціювати. Абстрактний клас робить кілька речей для підзакладу, що спадкує:
- Визначте методи, які можуть бути використані спадковим підкласом.
- Визначте абстрактні методи, які повинен реалізувати спадковий підклас.
- Забезпечте загальний інтерфейс, який дозволяє взаємоклас підкласу з усіма іншими підкласами.
Ось приклад:
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()в 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()"
}
Зверніть увагу , що навіть якщо ми оголосили bв AbstractClassтип, він відображає "Overriden!". Це тому, що об'єкт, який ми створили ImplementingClass, був насправді тим , чийimplementedMethod() , безумовно, перекрито. (Можливо, ви бачили це як поліморфізм.)
Якщо ми хочемо отримати доступ до конкретного члена, який є певним підкласом, ми повинні спершу перейти до цього підкласу:
// 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!"); }
}
Ви не можете реалізувати методи в інтерфейсі. Це означає, що якщо ви реалізуєте два різних інтерфейси, різні методи в цих інтерфейсах не можуть зіткнутися. Оскільки всі методи в інтерфейсі абстрактні, ви повинні реалізувати метод, і оскільки ваш метод є єдиною реалізацією в дереві спадкування, компілятор знає, що він повинен використовувати ваш метод.
