Programmation Java/Héritage
L’héritage est la définition d’une classe par extension des caractéristiques d’une autre classe, exemple : on a créé une classe Vehicule. Ainsi les classes Automobile et Avion ont pu hériter des caractéristiques de Vehicule.
L'héritage, est l'un des mécanismes les plus puissants de la programmation orientée objet, permet de reprendre des membres d'une classe (appelée superclasse ou classe mère) dans une autre classe (appelée sous-classe, classe fille ou encore classe dérivée), qui en hérite. De cette façon, on peut par exemple construire une classe par héritage successif.
En Java, ce mécanisme est mis en œuvre au moyen du mot-clé extends
Exemple :
public class Vehicule
{
public int vitesse;
public int nombre_de_places;
}
public class Automobile extends Vehicule
{
public Automobile()
{
this.vitesse = 90;
this.nombre_de_places = 5;
}
}
Dans cet exemple, la classe Automobile hérite de la classe Vehicule, ce qui veut dire que les attributs vitesse et nombre_de_places, bien qu'étant définis dans la classe Vehicule, sont présents dans la classe Automobile. Le constructeur défini dans la classe Automobile permet d'ailleurs d'initialiser ces attributs.
En Java, le mécanisme d'héritage permet de définir une hiérarchie de classes comprenant toutes les classes. En l'absence d'héritage indiqué explicitement, une classe hérite implicitement de la classe Object. Cette classe Object est la racine de la hiérarchie de classe.
La classe Object
[modifier | modifier le wikicode]Au moment de l'instanciation, la classe fille reçoit les caractéristiques qui peuvent être héritées de sa super-classe, qui elle-même reçoit les caractéristiques qui peuvent être héritées de sa propre superclasse, et ce récursivement jusqu'à la classe Object.
Ce mécanisme permet de définir des classes génériques réutilisables, dont l'utilisateur précise le comportement dans des classes dérivées plus spécifiques.
Il faut préciser que, contrairement à C++, Java ne permet pas l'héritage multiple, ce qui veut dire qu'une classe dérive toujours d'une et d'une seule classe.
Héritage d'interface
[modifier | modifier le wikicode]L'héritage d'interface est aussi possible en Java. À la différence des classes, l'héritage multiple est autorisé, ce qui veut dire qu'une interface peut hériter d'autant d'autres interfaces que désiré.
L'héritage d'interface se fait avec le mot clé extends, puisque c'est une interface qui "étend" une interface existante. Les différentes interfaces héritées sont séparées par une virgule.
L'héritage « multiple » pour une classe (via les interfaces) se fait avec le mot-clé implements. Exemple :
public interface InterfaceA {
public void methodA();
}
public interface InterfaceB {
public void methodB();
}
public interface InterfaceAB extends InterfaceA, InterfaceB {
public void otherMethod();
}
public class ClassAB implements InterfaceAB{
public void methodA(){
System.out.println("A");
}
public void methodB(){
System.out.println("B");
}
public void otherMethod(){
System.out.println("blablah");
}
public static void main(String[] args) {
ClassAB classAb = new ClassAB();
classAb.methodA();
classAb.methodB();
classAb.otherMethod();
}
}
Le mot-clé super
[modifier | modifier le wikicode]Le mot-clé super permet d'accéder aux membres de la super-classe d'une classe, de la même manière que l'on accède aux attributs de la classe elle-même à l'aide du mot-clé this.
Exemple :
public class Avion extends Vehicule
{
public Avion()
{
super();
}
}
Dans cet exemple, le constructeur de la classe Avion fait appel au constructeur de la classe Vehicule.
Ce mot-clé permet également d'accéder explicitement aux membres de la classe de base, dans le cas, par exemple, où il existe déjà un membre portant ce nom dans la classe (surcharge de méthode, ...).
Exemple :
public class Vehicule
{
// ...
public void rouler() throws Exception
{
position += vitesse;
}
}
public class Avion extends Vehicule
{
// ...
public void rouler() throws Exception
{
if (altitude>0)
throw new Exception("L'avion en vol ne peut rouler");
else super.rouler();
}
}