Vous êtes sur la page 1sur 8

DEFINITION D’UNE CLASSE EN JAVA Page 1 /1

Généralisation/spécialisation
et héritage

1.1. Définition et utilisation d’une classe de base

Vehicule

numImmatr
poids
producteur
annee

VehiculeAttele VehiculeAmoteur

nombreRoue numMoteur
attelage typeCarburant

Implémentation de la classe de base Vehicule


public class Vehicule
{
// Les champs
private String numImmatr ;
private double poids ;
private String producteur ;
private int annee ;
// Un constructeur
public Vehicule(String nIm, double pd, String prod, int an)
{
setImmatriculation(nIm);
setPoids(pd);
setProducteur(prod);

Th. K. DAGBA, Ph.D Ing. ENEAM/UAC


DEFINITION D’UNE CLASSE EN JAVA Page 2 /2

setAnnee(an);
}
// Méthodes d’altération
public void setImmatriculation(String nIm)
{numImmatr = nIm;}
public void setPoids(double pd)
{poids = pd;}
public void setProducteur(String prod)
{producteur = prod;}
public void setAnnee(int an)
{annee = an;}
// Méthodes d’accès
public String getImmatriculation()
{return numImmatr;}
public double getPoids()
{return poids;}
public String getProducteur()
{return producteur;}
public int getAnnee()
{return annee;}
}

Implémentation de la classe dérivée VehiculeAmoteur


.

public class VehiculeAmoteur extends Vehicule // VehiculeAmoteur est dérivée de Vehicule


{
// Champs propres à la classe VehiculeAmoteur
private String numMoteur ;
private String typeCarburant ;
// Constructeur
public VehiculeAmoteur(String nIm, double pd, String prod, int an,
String unNumMoteur, String unCarb)
{
// Appel au constructeur de la classe de base, pour altérer les champs hérités
super(nIm, pd, prod, an);
// Altération des champs propres à la classe dérivée
setNumMoteur(unNumMoteur) ;
setTypeCarburant(unCarb) ;
}
// Les méthodes d’altération de la classe dérivée
public void setNumMoteur(String unNumMoteur)
{numMoteur = unNumMoteur;}
public void setTypeCarburant(String unCarb)
{typeCarburant = unCarb;}
// Méthodes d’accès de la classe dérivée
public String getNumMoteur()
{return numMoteur ; }

Th. K. DAGBA, Ph.D Ing. ENEAM/UAC


DEFINITION D’UNE CLASSE EN JAVA Page 3 /3

public String getTypeCarburant()


{return typeCarburant ;}
}

Le mot-clé super est utilisé pour se référer au constructeur de la classe de base.

Remarque :
Si le constructeur de la classe de base n’est pas explicitement appelé par la classe dérivée,
c’est le constructeur à défaut de la classe de base qui est appelé. L’appel du constructeur de la
classe de base devrait être la première instruction du constructeur de la classe dérivée. Cette
instruction doit utiliser le mot-clé super comme un nom de méthode, avec des arguments
passés entre parenthèses à la classe de base.

Utilisation de la classe VehiculeAmoteur

public class TestClassDerivee


{
public static void main(String[] args)
{
String immatr;
double pds;
String prod;
int ann;
String nrMot;
String carbur;
// Créer une instance de VehiculeAmoteur
VehiculeAmoteur unVehiculeAmoteur = new VehiculeAmoteur(
"AB 4713 RB", 870, "VOLKSWAGEN",
1984, "EZ-056560","ESSENCE");
// Utilisation des méthodes d’accès
immatr = unVehiculeAmoteur.getImmatriculation();
pds = unVehiculeAmoteur.getPoids() ;
prod = unVehiculeAmoteur.getProducteur();
ann = unVehiculeAmoteur.getAnnee();
nrMot = unVehiculeAmoteur.getNumMoteur();
carbur = unVehiculeAmoteur.getTypeCarburant();
// Affichage des informations comme une concaténation de chaînes de caractères
System.out.println("C’EST UN "+ unVehiculeAmoteur.toString() + "\n"
+ "IMMATRICULATION: " + "\t" + immatr + "\n"
+ "POIDS: " + "\t" + pds + " KG" + "\n"
+ "PRODUCTEUR: " + "\t" + prod + "\n"
+ "ANNEE DE PRODUCTION: " + "\t" + ann + "\n"
+ "NUMERO DU MOTEUR: " + "\t" + nrMot + "\n"
+ "TYPE DE CARBURANT: " + "\t" + carbur + "\n") ;
// Pour accéder aux champs, on peut se passer
// de variables intermédiaires, comme ci-après illustré
System.out.println("C’EST UN "+ unVehiculeAmoteur.toString() + "\n"
+ "IMMATRICULATION: " + "\t"

Th. K. DAGBA, Ph.D Ing. ENEAM/UAC


DEFINITION D’UNE CLASSE EN JAVA Page 4 /4

+ unVehiculeAmoteur.getImmatriculation() + "\n"
+ "POIDS: " + "\t"
+ unVehiculeAmoteur.getPoids() + " KG" + "\n"
+ "PRODUCTEUR: " + "\t"
+ unVehiculeAmoteur.getProducteur() + "\n"
+ "ANNEE DE PRODUCTION: " + "\t"
+ unVehiculeAmoteur.getAnnee() + "\n"
+ "NUMERO DU MOTEUR: " + "\t"
+ unVehiculeAmoteur.getNumMoteur() + "\n"
+ "TYPE DE CARBURANT: " + "\t"
+ unVehiculeAmoteur.getTypeCarburant() +"\n") ;
}
}

Remarque :
La méthode toString(), telle qu’elle est utilisée ici, permet de retourner le nom de la classe de
l’instance.

2. Classes abstraites et finales

2.1. Utilisation des classes abstraites (“abstract”)


Il peut se présenter des situations où il n’y aura aucun besoin d’instancier une classe. Cette
classe sera uniquement destinée à être dérivée. Une classe du genre est appelée classe
abstraite.

Pour déclarer une classe abstraite, on utilise le mot-clé abstract dans son en-tête.
Pour rendre la classe Vehicule abstraite, son en-tête devrait donc se présenter comme suit :

public abstract class Vehicule


{
--------
}

Remarque :
- Toute tentative d’instancier une classe abstraite, entraîne l’exception de nom
InstanciationError.
- Il faut plutôt dériver la classe abstraite et ensuite instancier la classe dérivée.
- L’avantage d’avoir une classe abstraite comme la classe Vehicule est que d’autres
classes peuvent dériver d’elle, alors on n’aura pas besoin de réécrire les instructions
communes à toutes les classes dérivées.

2.2.2. Utilisation des classes finales (“final”)


Il existe des situations où une classe ne devrait pas être dérivée (raison de sécurité et de
performance).
Le mot-clé final est utilisé pour déclarer une classe finale (c’est-à-dire qui ne peut pas être
dérivée).

Th. K. DAGBA, Ph.D Ing. ENEAM/UAC


DEFINITION D’UNE CLASSE EN JAVA Page 5 /5

Plusieurs classes standard de Java sont finales et ne peuvent pas être dérivées. C’est le cas des
classes enveloppes (Integer, Byte, Double, …). La classe String est aussi finale.

Remarque :
Les méthodes aussi peuvent être déclarées finales. Dans ce cas, elles ne pourront pas être
« redéfinies » par des classes dérivées.

2.1. Redéfinition de méthodes d’une classe de base


La redéfinition de méthode a lieu quand une méthode de la classe dérivée est appelée à la
place d’une méthode de la classe de base si les deux méthodes ont la même signature.

La méthode getInfo() pour la classe Vehicule


public String getInfo()
{
// Retourner les champs comme une seule chaîne de caractères
String details ;
details = ‘’ ‘’
+ numImmatr + ‘’ ‘’
+ poids + ‘’ ‘’
+ producteur + ‘’ ‘’
+ annee ;
return details ;
}

Redéfinition de la méthode getInfo() pour la classe dérivée VehiculeAmoteur


public String getInfo()
{
// Appel à 4 méthodes d’accès de la classe de base Vehicule
String details ;
details = ‘’Ceci est un véhicule à moteur ‘’
+ getImmatriculation() + ‘’ ‘’ // Appel à une méthode de la classe Vehicule
+ getPoids() + ‘’ ‘’ // Appel à une méthode de la classe Vehicule
+ getProducteur() + ‘’ ‘’ // Appel à une méthode de la classe Vehicule
+ getAnnee() + ‘’ ‘’ // Appel à une méthode de la classe Vehicule
+ numMoteur + ‘’ ‘’
+ typeCarburant ;
return details ;
}

Redéfinition et appel d’une méthode de la classe de base

public String getInfo()


{
String details ;

Th. K. DAGBA, Ph.D Ing. ENEAM/UAC


DEFINITION D’UNE CLASSE EN JAVA Page 6 /6

details = ‘’Ceci est un véhicule à moteur ‘’


+ super.getInfo() + ‘’ ‘’
+ numMoteur + ‘’ ‘’
+ typeCarburant ;
return details ;
}

2.2. L’utilisation de « private » et de « protected »


L’attribut « private » interdit aussi l’accès direct aux champs d’une classe de base par les
classes dérivées.
Si l’on veut avoir un accès direct aux champs de la classe de base à partir des classes dérivées,
il faut déclarer ces champs comme « protected » :

// Les champs de la classe Vehicule déclarés comme « protected »


protected String numImmatr ;
protected double poids ;
protected String producteur ;
protected int annee ;

Si les champs de la classe de base sont déclarés comme « protected », alors la redéfinition de
la méthode getInfo() pourrait se présenter comme suit:

public String getInfo()


{
String details ;
details = ‘’Ceci est un véhicule à moteur ‘’
+ numImmatr + ‘’ ‘’ // Accès direct au champ de la classe de base Vehicule
+ poids + ‘’ ‘’ // Accès direct au champ de la classe de base Vehicule
+ producteur + ‘’ ‘’ // Accès direct au champ de la classe de base Vehicule
+ annee + ‘’ ‘’ // Accès direct au champ de la classe de base Vehicule
+ numMoteur + ‘’ ‘’
+ typeCarburant ;
return details ;
}

On peut bien évidemment déclarer les champs comme « public » pour permettre à n’importe
quel objet d’y accéder. Mais il faut éviter cette technique car cela viole le principe
d’encapsulation. Vous pouvez néanmoins déclarer les constantes comme public.

2.3. Méthodes abstraites

Il existe des situations, où une méthode déterminée doit exister dans toutes les classes
dérivées d’une classe de base. Dans ce cas, ce sont les classes dérivées qui sont chargées,
selon le cas, d’implémenter la méthode. Cela est donc nécessaire au polymorphisme.

Th. K. DAGBA, Ph.D Ing. ENEAM/UAC


DEFINITION D’UNE CLASSE EN JAVA Page 7 /7

Une technique pour imposer à toutes les classes dérivées d’inclure ou d’implémenter une
méthode est de la déclarer abstraite dans la classe de base.
- Une méthode abstraite est une méthode qui n’a pas de corps (il n’y que la déclaration).
- Une méthode est déclarée abstraite avec le mot-clé abstract. On parle généralement de
méthode différée ou retardée.
- Une méthode abstraite est donc une méthode qui est faite pour être implémentée dans une
classe dérivée ;
- Une classe qui contient une méthode abstraite devient elle-même automatiquement abstraite.

Bail

montant
dateDebut
dateFin

calculFrais()

BailAnnuel BailJournalier

estMensuel nombreJours
resteApayer

calculFrais() calculFrais()

2.4. Notion d’interfaces en Java


Une classe abstraite pourrait permettre de définir dans une classe de base des fonctionnalités
communes à toutes ses descendantes (classes dérivées), tout en leur imposant de redéfinir
certaines méthodes.
Une autre possibilité permettant d’imposer la redéfinition des méthodes dans les classes
dérivées, c’est l’utilisation d’interface.
Une interface définit les en-têtes d’un certain nombre de méthodes, ainsi que des constantes.
La différence fondamentale entre classe abstraite et interface est la suivante: Une classe
pourra implémenter plusieurs interfaces, alors qu’une classe ne peut dériver que d’une
classe abstraite.
Les interfaces Java sont souvent expliquées dans le contexte de l’héritage, où les classes qui
implémentent une interface sont dites d’ ‘’hériter’’ les méthodes.

Th. K. DAGBA, Ph.D Ing. ENEAM/UAC


DEFINITION D’UNE CLASSE EN JAVA Page 8 /8

Définition d’interface en Java


La définition d’une interface en Java se présente comme celle d’une classe. On y utilise
simplement le mot-clé interface à la place du mot-clé class.

Exemple :
public interface IntCompagnie
{
//Constantes dont les classes dérivées pourraient avoir besoin
public static final String NOM_COMPAGNIE = "JAVA CORP.";
public static final String ADRESSE_COMPAGNIE = "03 BP 1073, Cotonou";
public static final String PHONE_COMPAGNIE = "(229) 21 30 75 10";
// Méthode abstraite à redéfinir dans les classes dérivées
public abstract String getInfo();
//N'oubliez pas le point virgule à la fin de la déclaration
}

Exemple : Une classe B hérite d’une classe A et implémente les interfaces C, D, E

public class A
{…. }

public interface C
{….}

public interface D
{…. }

public interface E
{…. }

public class B extends A implements C, D, E


{…. }

Th. K. DAGBA, Ph.D Ing. ENEAM/UAC