Абстрактный класс - это класс, который не может быть создан. Абстрактный класс используется путем создания наследующего подкласса, который может быть создан. Абстрактный класс делает несколько вещей для наследующего подкласса:
- Определите методы, которые могут использоваться наследующим подклассом.
- Определите абстрактные методы, которые должен реализовывать наследующий подкласс.
- Обеспечить общий интерфейс, который позволяет подклассу обмениваться со всеми другими подклассами.
Вот пример:
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()"
}
Обратите внимание , что даже если мы объявили 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!"); }
}
Вы не можете реализовать методы в интерфейсе. Это означает, что если вы реализуете два разных интерфейса, разные методы в этих интерфейсах не могут конфликтовать. Поскольку все методы в интерфейсе являются абстрактными, вы должны реализовать метод, и поскольку ваш метод является единственной реализацией в дереве наследования, компилятор знает, что он должен использовать ваш метод.
