Uma classe abstrata é uma classe que não pode ser instanciada. Uma classe abstrata é usada criando uma subclasse herdada que pode ser instanciada. Uma classe abstrata faz algumas coisas para a subclasse herdada:
- Defina métodos que podem ser usados pela subclasse de herança.
- Defina métodos abstratos que a subclasse herdada deve implementar.
- Forneça uma interface comum que permita que a subclasse seja intercambiada com todas as outras subclasses.
Aqui está um exemplo:
abstract public class AbstractClass
{
abstract public void abstractMethod();
public void implementedMethod() { System.out.print("implementedMethod()"); }
final public void finalMethod() { System.out.print("finalMethod()"); }
}
Observe que "abstractMethod ()" não possui nenhum corpo de método. Por esse motivo, você não pode fazer o seguinte:
public class ImplementingClass extends AbstractClass
{
// ERROR!
}
Não há método que implemente abstractMethod()! Portanto, não há como a JVM saber o que deve fazer quando obtém algo comonew ImplementingClass().abstractMethod() .
Aqui está um correto ImplementingClass.
public class ImplementingClass extends AbstractClass
{
public void abstractMethod() { System.out.print("abstractMethod()"); }
}
Observe que você não precisa definir implementedMethod()ou finalMethod(). Eles já foram definidos porAbstractClass .
Aqui está outro correto ImplementingClass.
public class ImplementingClass extends AbstractClass
{
public void abstractMethod() { System.out.print("abstractMethod()"); }
public void implementedMethod() { System.out.print("Overridden!"); }
}
Nesse caso, você substituiu implementedMethod() .
No entanto, devido à finalpalavra - chave, o seguinte não é possível.
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!"); }
}
Você não pode fazer isso porque a implementação de finalMethod()in AbstractClassestá marcada como a implementação final definalMethod() : nenhuma outra implementação será permitida, nunca.
Agora você também pode implementar uma classe abstrata duas vezes:
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()"); }
}
Agora em algum lugar você poderia escrever outro método.
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()"
}
Observe que, embora tenhamos declarado bum AbstractClasstipo, ele é exibido "Overriden!". Isso ocorre porque o objeto que instanciamos era, na verdade ImplementingClass, um , e implementedMethod()é claro que ele foi substituído. (Você pode ter visto isso conhecido como polimorfismo.)
Se desejamos acessar um membro específico para uma subclasse específica, devemos converter essa subclasse primeiro:
// 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();
Por fim, você não pode fazer o seguinte:
public class ImplementingClass extends AbstractClass, SomeOtherAbstractClass
{
... // implementation
}
Apenas uma classe pode ser estendida por vez. Se você precisar estender várias classes, elas deverão ser interfaces. Você consegue fazer isso:
public class ImplementingClass extends AbstractClass implements InterfaceA, InterfaceB
{
... // implementation
}
Aqui está um exemplo de interface:
interface InterfaceA
{
void interfaceMethod();
}
É basicamente o mesmo que:
abstract public class InterfaceA
{
abstract public void interfaceMethod();
}
A única diferença é que a segunda maneira não permite que o compilador saiba que na verdade é uma interface. Isso pode ser útil se você quiser que as pessoas implementem apenas sua interface e nenhuma outra. No entanto, como regra geral para iniciantes, se sua classe abstrata tiver apenas métodos abstratos, você provavelmente deve transformá-la em uma interface.
O seguinte é ilegal:
interface InterfaceB
{
void interfaceMethod() { System.out.print("ERROR!"); }
}
Você não pode implementar métodos em uma interface. Isso significa que, se você implementar duas interfaces diferentes, os métodos diferentes nessas interfaces não poderão colidir. Como todos os métodos em uma interface são abstratos, é necessário implementar o método e, como o método é a única implementação na árvore de herança, o compilador sabe que precisa usar o método.
