II. Chapitre 3▲
II-A. Création de la classe Voiture▲
Ceux qui n'en peuvent plus d'attendre peuvent directement atteindre la section "Code complet de la classe Voiture" et éventuellement, revenir sur les explications suivantes plus tard.
II-A-1. Création de la classe sans les trois méthodes demandées▲
On commence par créer une nouvelle classe Voiture depuis Eclipse. Remarquez que l'ajout d'une méthode main() n'est pas requis puisque ce n'est pas elle qui lance l'application. C'est le rôle de la classe ProprietaireVoiture, que l'on va réaliser en deuxième question. On ne coche donc pas la case "public static void main(String [] args)".
On obtient donc :
public
class
Voiture {
// Methodes et variables d'instance vont ici.
}
II-A-2. Petite parenthèse : les commentaires▲
La ligne " //Methodes et variables d'instance vont ici " est un commentaire. Mais pas de panique : les commentaires sont introduits dans un chapitre ultérieur du livre. Les commentaires sont libres :
- d'être insérés où on le désire ;
- de contenir ce que l'on veut : du français, de l'anglais… même du texte insignifiant.
Pourquoi ? Tout simplement parce que le compilateur les ignorera.
Vous vous demandez alors à quoi cela peut-il bien servir : tout simplement, à apporter des précisions sur le code sans pour autant que la compilation de celui-ci soit entravée.
Ne vous inquiétez pas pour l'instant de savoir comment composer un commentaire, un chapitre ultérieur du livre vous le précisera.
II-A-3. Ajout des méthodes demarrer() et arreter() dans la classe▲
Le plus difficile, consiste à passer de la signature des trois méthodes (fonctions de la classe) à leur codage complet : du moins à leur structure prêts à accueillir du code.
Étant donné une signature telle que :
public
void
demarrer
(
)
Il nous suffit alors de :
1) Recopier la signature telle quelle entre les accolades destinées à recevoir le code de la classe :
public
class
Voiture {
// On ajoute la methode ici-même
public
void
demarrer
(
)
}
2) Ajouter alors le corps de la méthode : c'est-à-dire l'endroit où sera codé l'ensemble des instructions de la méthode. On ajoute donc une paire d'accolades à la suite de la signature de la méthode :
public
class
Voiture {
public
void
demarrer
(
) {
// c'est la paire d'accolades qui definit le corps de la methode
}
}
3) Enfin, on peut coder les instructions de la méthode :
public
class
Voiture {
public
void
demarrer
(
) {
// Ici les instructions que la methode demarrer() doit executer
System.out.println
(
"Je demarre !!!"
);
}
}
Vous remarquerez également que je n'ai pas mis d'accents ni dans les commentaires, ni dans le code : c'est un choix délibéré. En effet, en passant d'un éditeur à un autre (de Eclipse à Netbeans par exemple), ou d'un système d'exploitation à un autre (de Windows à Ubuntu Linux par exemple), il se peut que l'on se retrouve confronté au problème de conversion des caractères accentués. En fait, tout dépend de "l'encodage de caractères" choisi par les systèmes ou les éditeurs.
Je ne souhaite pas rentrer dans les détails, car je serais alors vraiment hors sujet, mais sachez tout de même que ne pas mettre d'accents dans les codes, est la meilleure manière de ne pas être ennuyé.
On peut coder la méthode arreter() de la même manière :
public
class
Voiture {
public
void
demarrer
(
) {
System.out.println
(
"Je demarre !!!"
) ;
}
public
void
arreter
(
) {
System.out.println
(
"Je m'arrete !!!"
) ;
}
}
II-A-4. Ajout de la méthode rouler() dans la classe▲
La signature de la méthode rouler() rend la chose un peu plus difficile qu'elle n'était pour les méthodes demarrer() et arreter() :
*) elle retourne un int au lieu de renvoyer simplement void . Par conséquent, la dernière instruction de la méthode rouler sera :
return
valeurDirecte_Ou_VariableDeTypeInt;
*) elle attend obligatoirement un paramètre duree de type int. On se dit aussitôt qu'il faudra éventuellement, si le besoin se fait ressentir, se reposer sur cette valeur pour adapter le traitement de la méthode rouler. Alors doit-on, ne doit-on pas ? Eh bien oui, on doit, car l'énoncé nous précise que c'est cette durée - passée par le code qui utilise la voiture - qui permettra et de calculer et d'afficher la distance parcourue :
distance = duree * 60
On peut après se poser la question des unités à employer : distance en km ? Durée en h ? Pour ma part, l' énoncé ne demandant pas de traiter les unités et en plus comme cela me compliquerait plus les choses qu'elles ne les arrangeraient, j'ai décidé de ne pas en utiliser.
Que peut-on conclure des deux points précédents ? Tout simplement qu'il suffira de :
- calculer la distance en fonction de la durée passée ;
- de simuler un traitement avec un affichage écran (System.out.println()) ;
- de retourner la distance calculée .
Voici donc un exemple de codage pour la méthode rouler() :
public
int
rouler
(
int
duree){
int
distance =
duree *
60
;
System.out.println
(
"Je roule sur une distance de "
+
distance+
" ."
);
return
distance;
}
II-A-5. Code complet de la classe Voiture▲
II-B. Création de la classe ProprietaireVoiture▲
Dans cette classe, on se contentera de créer une méthode main(), afin de tester la classe Voiture.
Il faudra donc l'instancier, de manière à disposer d'une variable de type Voiture, que l'on testera.
En outre, je crée une variable distanceTotale, de type int, qui servira -comme son nom l'indique- à garder une trace de la distance globale parcourue : ainsi je pourrais l'afficher avant de quitter l'application. Pour ce faire, il suffit juste d'exploiter les différents retours aux appels à la méthode rouler() de la Voiture pour mettre à jour la distance globale :
II-C. Création de la classe VoitureJamesBond▲
La classe VoitureJamesBond doit sous-classer la classe Voiture : donc il faudra utiliser le mot-clé "extends ".
public
class
VoitureJamesBond extends
Voiture {
// Inutile de recoder les methodes de la classe Voiture.
}
Pour rappel, si on laissait le code tel quel, on pourrait se contenter de remplacer toutes les créations et exploitations d'instances de Voiture par des instances de VoitureJamesBond sans que le résultat de l'application en soit changé.
Dans la classe ProprietaireVoiture, rien ne nous empêche alors d'écrire :
public
class
ProprietaireVoiture {
public
static
void
main
(
String[] args) {
int
distanceTotale =
0
;
// La seule ligne qui modifiee
VoitureJamesBond maVoiture =
new
VoitureJamesBond
(
);
maVoiture.demarrer
(
);
distanceTotale =
distanceTotale +
maVoiture.rouler
(
10
);
distanceTotale =
distanceTotale +
maVoiture.rouler
(
30
);
maVoiture.arreter
(
);
System.out.println
(
"Distance totale parcourue : "
+
distanceTotale +
" ."
);
}
}
Rien n'aurait changé pour autant au niveau du résultat.
Mais on souhaite dans l'énoncé que la classe VoitureJamesBond permette de rouler beaucoup plus vite qu'une simple instance de Voiture : on nous demande donc de surcharger la méthode rouler(), pour ne plus simplement dépendre du code définit pour rouler() dans la classe Voiture.
On procède donc comme on l'a fait pour la méthode rouler() de Voiture, mais en changeant la formule (j'ai aussi changé le texte pour être plus fantaisiste) :
public
class
VoitureJamesBond extends
Voiture {
public
int
rouler
(
int
duree) {
int
distance =
duree *
180
;
System.out.println
(
":=D YAOUHHHHH !!! Je FONCE sur une distance de "
+
distance+
" ."
);
return
distance;
}
}
Maintenant, si l'on relance la méthode main() de la classe ProprietaireVoiture en changeant la création d'une instance de Voiture par une création d'instance de VoitureJamesBond, les distances sont rallongées et le chauffeur semble plus réjoui.
II-D. Synthèse▲
Ainsi dans ce corrigé nous avons appris à :
- créer une classe Voiture personnelle. Mais aussi à créer nos propres méthodes dans cette même classe ;
- utiliser cette classe dans une méthode main() ;
- à construire une classe fille (VoitureJamesBond) de la classe Voiture ;
- à personnaliser l'une des méthodes de la classe mère (Voiture) dans la classe fille . La méthode rouler() a été surchargée dans la classe VoitureJamesBond.