Une classe abstraite est une classe qui ne peut pas être instanciée. Une classe abstraite est utilisée en créant une sous-classe héritée qui peut être instanciée. Une classe abstraite fait quelques choses pour la sous-classe héritée:
- Définissez les méthodes pouvant être utilisées par la sous-classe héritée.
- Définissez les méthodes abstraites que la sous-classe héritée doit implémenter.
- Fournit une interface commune qui permet à la sous-classe d'être échangée avec toutes les autres sous-classes.
Voici un exemple:
abstract public class AbstractClass
{
abstract public void abstractMethod();
public void implementedMethod() { System.out.print("implementedMethod()"); }
final public void finalMethod() { System.out.print("finalMethod()"); }
}
Notez que "abstractMethod ()" n'a pas de corps de méthode. Pour cette raison, vous ne pouvez pas effectuer les opérations suivantes:
public class ImplementingClass extends AbstractClass
{
// ERROR!
}
Il n'y a aucune méthode qui implémente abstractMethod()! Il n'y a donc aucun moyen pour la JVM de savoir ce qu'elle est censée faire lorsqu'elle obtient quelque chose new ImplementingClass().abstractMethod().
Voici une bonne réponse ImplementingClass.
public class ImplementingClass extends AbstractClass
{
public void abstractMethod() { System.out.print("abstractMethod()"); }
}
Notez que vous n'avez pas besoin de définir implementedMethod()ou finalMethod(). Ils étaient déjà définis par AbstractClass.
Voici un autre correct ImplementingClass.
public class ImplementingClass extends AbstractClass
{
public void abstractMethod() { System.out.print("abstractMethod()"); }
public void implementedMethod() { System.out.print("Overridden!"); }
}
Dans ce cas, vous avez remplacé implementedMethod().
Cependant, en raison du finalmot - clé, ce qui suit n'est pas possible.
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!"); }
}
Vous ne pouvez pas faire cela car l'implémentation de finalMethod()in AbstractClassest marquée comme implémentation finale de finalMethod(): aucune autre implémentation ne sera autorisée, jamais.
Maintenant, vous pouvez également implémenter une classe abstraite deux fois:
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()"); }
}
Maintenant, quelque part, vous pourriez écrire une autre méthode.
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()"
}
Notez que même si nous avons déclaré bun AbstractClasstype, il s'affiche "Overriden!". C'est parce que l'objet que nous avons instancié était en fait un ImplementingClass, dont il implementedMethod()est bien sûr remplacé. (Vous avez peut-être vu ce phénomène sous le nom de polymorphisme.)
Si nous souhaitons accéder à un membre spécifique à une sous-classe particulière, nous devons d'abord effectuer une descente dans cette sous-classe:
// 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();
Enfin, vous ne pouvez pas effectuer les opérations suivantes:
public class ImplementingClass extends AbstractClass, SomeOtherAbstractClass
{
... // implementation
}
Une seule classe peut être prolongée à la fois. Si vous devez étendre plusieurs classes, elles doivent être des interfaces. Tu peux le faire:
public class ImplementingClass extends AbstractClass implements InterfaceA, InterfaceB
{
... // implementation
}
Voici un exemple d'interface:
interface InterfaceA
{
void interfaceMethod();
}
C'est essentiellement la même chose que:
abstract public class InterfaceA
{
abstract public void interfaceMethod();
}
La seule différence est que la deuxième façon ne permet pas au compilateur de savoir qu'il s'agit en fait d'une interface. Cela peut être utile si vous voulez que les gens implémentent uniquement votre interface et aucune autre. Cependant, en règle générale, si votre classe abstraite n'a que des méthodes abstraites, vous devriez probablement en faire une interface.
Ce qui suit est illégal:
interface InterfaceB
{
void interfaceMethod() { System.out.print("ERROR!"); }
}
Vous ne pouvez pas implémenter de méthodes dans une interface. Cela signifie que si vous implémentez deux interfaces différentes, les différentes méthodes de ces interfaces ne peuvent pas entrer en collision. Comme toutes les méthodes d'une interface sont abstraites, vous devez implémenter la méthode, et puisque votre méthode est la seule implémentation dans l'arbre d'héritage, le compilateur sait qu'il doit utiliser votre méthode.
