L'héritage,les classes abstraites et interfaces

Alors, si vous reprenez ma classe Circle, j'ai écrit ceci :

Code : Java

public Circle()
{
centre = new Point (0, 0);
rayon = 0;
}

Je lui dis donc de créer un point (le centre) qui a pour coordonnée : (0,0)
Ce n'est pas que cette solution n'est pas bonne, mais il y a moyen de faire encore plus simple!
Autrement dis, un programmeur spécialisé en orienté objet ne fera pas ça.
Ici, on va voir un nouveau mot clé, le mot clé "super".

L'utilité du mot clef super.

Ce mot clé permet en fait, de pouvoir créer automatiquement un objet de la classe Point, dans le constructeur de votre classe Circle!

Démonstration :

Bah vous pouvez remplacer la première instruction du constructeur de votre classe Circle par ceci :

Code : Java

super (0, 0);

Que fait le mot clé super ?

Ce mot clé en fait invoque automatiquement le constructeur de votre superclasse Point lorsque vous instancier un objet de type Circle. (celui à 2 arguments)

Il faut qu'un constructeur identique soit définit dans votre superclasse.
C'est à dire un constructeur avec le même nombre d'argument que dans votre super.

Si vous écrivez "super ();", c'est le constructeur sans arguments de votre classe Point qui est appelé et s'il y en a pas, un constructeur par défaut est appelé (celui qui met toutes vos valeurs à null ou à zéro) dont je vous ai parler dans le chapitre consacré aux constructeurs!
Maintenant, on a donc plus besoin de déclarer une variable de type Point dans votre classe Circle, car le mot clef super le fait pour automatiquement pour vous!

Vous pouvez l'enlever, mais si vous recompiler, il y aura un soucis avec vos méthodes, se sera l'objet du point suivant!

L'instruction contenant le mot clé "super" doit être la première ligne de votre constructeur! Sinon vous aurez une erreur en compilation.

La redéfinition des méthodes

Reprenons maintenant nos méthodes de notre classe Circle :
Je vais commencer par la méthode move qui donne ceci :

Code : Java

centre.move (nvX, nvY);

Le problème c'est que ont a plus maintenant notre variable centre, car dans le constructeur je l'ai remplacé par : "super (0, 0);"

Bah là aussi il suffira remplacer notre centre par le mot clé super ce qui donne :

Code : Java

super.move (nvX, nvY);

Oui, mais, cela ne change rien par rapport à ce qu'on avait avant!

Patience, ça va venir, reprenons maintenant la méthode toString () qui renvoie donc les informations sur le cercle. C'est là que l'on va voir la vraie utilité de l'héritage.

Utilité de l'héritage

Si vous vous rappeler, avant j'ai écrit ceci :

Code : Java

return "La longeur du rayon du cercle est : "+rayon+"\n"
+"Le centre se trouve en : "+centre.getX()+";"+centre.getY()+")";

Franchement moi je trouves, je sais pas pour vous, mais c'est lourd car il faut ré écrire le code pour afficher les coordonnées du point qui représente le centre de notre cercle.
Alors que on a une méthode dans notre classe Point qui s'appelle toString aussi et qui renvoie les coordonnées d'un Point.

Bah on peux bien sur remplacer notre centre.getX () et tout le blablabla par ceci :

Code : Java

public String toString () {
return "La longeur du rayon du cercle est : "+rayon+"\n"
+"Le centre : "+super.toString();
}

Vous voyez donc que l'héritage nous permet donc d'éviter de devoir réécrire du code inutilement!!!

Remarque avec la méthode toString ()

Si vous ne définissez pas de méthode toString dans vos classe, et si vous l'invoquer sur un objet de cette classe, il va vous afficher l'adresse mémoire de votre objet, car, la méthode toString est présente dans une superClasse nommée Object dont je vous parlerai dans le tutoriel suivant.

Donc comme le compilateur ne trouvera pas de méthode toString() dans votre classe Circle, ni dans votre classe Point, il va utiliser celle de la classe Object dont hérite toute les classes et elle va afficher l'adresse mémoire des objets.
(Vous pouvez essayer et vous verrez normalement un truc du genre @1452365)

D'ailleurs mettez les méthodes toString en commentaire, et essayer de l'appeler sur un objet de type Circle, normalement il vous met l'adresse en mémoire de votre objet!

Remarque :

Code : Java

Circle c1 = new Circle ();
System.out.println (c1.toString ());
System.out.println (c1);

Ecrire juste le nom de l'objet dans un print ou un println revient au même que d'appeler la méthode toString sur l'objet lui même.

Un dernier petit mot sur les variables

On pourrait très bien vouloir rendre accessible les variables de notre superclasse Point dans notre sous classe Circle et écrire aussi ceci :

Code : Java

return "La longeur du rayon du cercle est : "+rayon+"\n"
+"Le centre se trouve en : "+centre.x+";"+centre.y+")";

Pour cela il faut remplacer le mot clé private qui se trouve dans votre classe Point (à la déclaration de vos variables) par le mot clé "protected" comme ceci :

Code : Java

protected int x, y;

Le mot clef protected

Il signifie que seul les classes qui sont dans le même package auront accès aux variables de celle-ci, et/ou aux méthodes. (Ceci revient au même que de ne pas mettre de modificateur d'accès devant le nom de la variable.)

Cette solution est déconseillée car elle ne respecte pas le principe de l'encapsulation dont je vous ai parler dans un des chapitres précédant, chaque classe est responsable de ses variables, et seul ses méthodes pourront modifier la valeur de ses variables de ses objets!

Ce mot clef n'est donc pas utile sauf si vous posséder des méthodes qui devront être utilisable que dans le package ou se trouve votre classe.
En c++, le mot clef protected est plus utile car il réduit l'accessibilité des variables de votre super classe à ses sous classes uniquement.

La redéfinition des méthodes et le polymorphisme

Une chose bien pratique : redéfinir les méthodes!

La redéfinition d'une méthode n'est rien d'autre qu'une méthode présente dans une classe mère, dont son en tête a été reprit tel quel dans les classes filles, mais, par contre le corps de la méthode à changé.

Donc seul le corps de la méthode change, on dit qu'elle a été redéfinie!

Ne pas confondre la redéfinition de méthodes et la surcharge des méthodes :
La surcharge des méthodes : toutes les méthodes sont dans la même classe et ont une signature différente. (même nom mais la liste des types de leurs arguments varie!)

La redéfinition de méthode : toutes les méthodes ont la même signature et le même type de retour, mais sont dans des classes différentes qui sont héritées. Seul le corps de la méthode change, car la méthode applique un comportement différent en fonction du type de l'objet bien précis! (Plus général ou plus spécifique.)

L'en tête d'une méthode redéfinie dans une sous classe est pareil à celui de la méthode présente dans votre superClasse! (même type de retour, même nom et même liste des types de ses arguments, etc...)

La super classe de toutes les classes!

Et oui, je ne vous l'ai pas dis, mais sachez que toutes vos classes qu'elles soit créées ou préexistantes héritent automatiquement de la classe Object!!

Celle-ci comporte déjà quelques méthodes :

Les méthodes de la classe Object

Une intéressante est la fameuse méthode equals, en effet, comme les pointeurs n'existent pas en Java, lorsqu'on compare deux objets entre eux à l'aide du ==, on compare des références donc si vous écrivez :

Code : Java

if(chaine1 == chaine2)

L'expression renvoiera faux même si vos deux chaînes de caractères sont identiques, car là vous comparer des références et ces 2 chaînes évidement ont pas la même adresse en mémoire!!

Comment peut-on comparer deux objets entre eux alors ?

Bah c'est là qu'intervient notre méthode equals.
Cette méthode ne se base pas sur les références des objets, mais sur des caractéristiques bien précises tel que par exemple, si les deux chaînes contiennent les mêmes caractères, la méthode equals renvoie vraie.

La surcharge des opérateurs comme en c++ n'existe pas en Java, pas la peine d'essayer d'écrire :

Code : Java

public operator== (String chaine2) {}

Comment faire pour comparer des autres objets que des String alors ?

Bah c'est là que va intervenir la redéfinition des méthodes, comme toutes les classes héritent de la classe Object, Toutes vos classes pourront redéfinir la méthode equals en fonction de vos critères, fin un exemple vaudra mieux qu'un discours.

Exemple de redéfinition de méthodes!

Bah je vais redéfinir la méthode equals dans ma classe Point, deux point seront identiques lorsqu'ils auront les mêmes coordonnées (évidement j'aurais pu rajouter un nom de type char à mes points, mais je vais pas le faire se sera plus simple)

Alors ça donne ceci ma méthode equals redéfinie dans la classe Point :

Code : Java

public boolean equals (Point p2) {
if (x == p2.x && y == p2.y)
return true;
else
return false;
}

On peut même faire encore plus simple!

Code : Java

public boolean equals (Point p2) {
return x == p2.x && y == p2.y;
}

Et maintenant je vous propose de redéfinir la méthode equals dans votre classe Circle mais là évidement il faudra faire une méthode qui renvoie le centre du Cercle.
Donc bah je suis obligé d'écrire ceci avant, on va dire que l'on va cloner notre Point qui représente le centre du Cercle.

Code : Java

public Point getCentre () {
return new point (super.getX(), super.getY());
}

On aurait très bien pu faire une méthode clone dans notre classe Point!

Maintenant plus qu'à faire notre méthode equals qui donne ceci :

Code : Java

public boolean equals (Circle c2) {
return (super.equals (c2.getCentre())) && (rayon == c2.rayon);
}

Je vous force à faire pour chacune de vos classe une méthode equals, une méthode toString et une méthode clone, vous voyez ici j'en ai eu besoin!

Maintenant on peux tester, essayer de créer deux objets de type Point, mettez leur les mêmes coordonnées puis appliquer la méthode equals sur l'un des deux, vous verrez ce que vous renvoie la méthode equals.
Normalement vous devriez voir une fenêtre et au milieu noté boolean true surligné en jaune, comme ceci :

Vous voyez que votre méthode vous renvoie bien vrai. (true)

Le polymorphisme

C'est une conséquence due à l'héritage, les objets instance de vos sous classes sont aussi instance de votre super classe puisque l'héritage me dis : un Cercle est un Point!

Donc si vous invoquer une méthode de la classe Point sur un objet de type Circle, cela ne pose pas de problème, le compilateur va rechercher votre méthode de votre super classe s'il ne la trouve pas dans votre sous classe!
Définition du polymorphisme :
Un objet expéditeur d'un message n'a pas besoin de connaître le type précis de l'objet destinataire pour réaliser un envoi de message dans le cas de l'héritag; c'est le compilateur lui même qui se chargera de naviguer dans la hiérarchie de vos classes afin de trouver la bonne méthode.
Et donc on peut faire appel à une méthode sur des objets de type différents! Le compilateur saura retrouver dans quel classe la méthode se trouves!

C'est ça qui fait vraiment la puissance de la POO!

Le contraire n'est pas autorisé et c'est logique, on ne vas pas changer le rayon d'un Point!

Donc retenez : une sous classe sait faire tout ce que votre super classe sait faire, mais votre super classe ne sait pas faire tout ce que votre sous classe peut faire.

La covariance des variables

Le casting implicite et le casting explicite

Le casting implicite :
Il s'agit de faire passer un objet de votre classe fille pour un objet de votre classe mère!
Exemple :

Code : Java

Point p1 = new Point ();
Circle c1 = new Circle ();
p1 = c1;

Le compilateur là ne bronchera pas, car un cercle est un point, par contre si vous écrivez ceci :

Code : Java

c1 = p1;

Bah vous dîtes de mettre un objet de type Point (plus général) dans un objet de type Circle, (qui est plus particulier) là votre compilateur va pas accepter!!
Le casting explicite
Bah là il faudra préciser au compilateur que vous savez ce que vous faîtes, on utilisera tout bêtement l'opération de cast comme ceci :

Code : Java

c1 = (Circle) p1;

Cela s'appelle le transtypage.
En gros il faut dire au compilateur, je suis sûr que p1 est un cercle.

Voilà j'ai fait le tour de ce qui concerne l'héritage même, nous pouvons attaquez le point suivant : les classes abstraite!

Ha oui, une dernière chose :

L'héritage multiple n'est pas géré par le Java, une sous classe ne peut hérité que d'une seule superclasse!
Donc votre classe ne sera héritée que de la classe Objet (ça d'office de toute façon) et éventuellement d'une et une seule autre classe!
Interdit d'écrire :

Code : Java

public class Voiture extends MoyenDeTransport, ObjetRoulant
{}

Par contre, en c++, l'héritage multiple est permis.

Les classes abstraites

Utilité

Elles sont très utiles lorsque des super classes ne peuvent pas instancier d'objets.
Une classe abstraite ne peut donc pas créer d'objets!!

Une classe doit être déclarée abstraite lorsque au moins une de ses méthodes est abstraite.

Les méthodes abstraites

Bah c'est des méthodes qui n'ont pas de corps, ce sont des méthodes qui ont donc juste une en tête!

Le contrat fixé par les classes abstraite lors de l'héritage!

Toutes les méthodes abstraites contenues dans la super classe devront être redéfinies dans leurs sous classes et si la sous classe contient encore des méthodes abstraites, elle sera abstraite également et ne pourra pas être instanciée!

On veut un exemple!
Bon d'accord, bah bonne appétit alors :

Nous allons ouvrir un nouveau projet blue J :
Project => open Project => people.
Ouvrez la classe Person : Vous voyez qu'elle est déclarée abstraite car il y a le mot clé abstract devant!

Là, je ne vois pas de méthodes abstraites, mais essayer de créer une personne, vous aller voir que vous ne pouvez pas!

Ouvrez maintenant la classe Student par exemple.
Elle hérite de personne, si vous remarquer bien il y a le mot clé super que l'on a vu qui permet de créer une personne qui sera ensuite Etudiant ou autre. Mais vous ne pouvez pas utilisez de new pour créer une personne car la classe Personne est abstraite!

Si vous regarder la classe Staff c'est pareil.
Ne vous occupez pas trop de la classe Database pour le moment, je vous en reparlerai quand je vous parlerai des listes!

Bon bah maintenant nous allons reprendre notre fameuse classe Point en supposant qu'on ne veut pas l'instanciée.

Je veux que ma méthode move soit abstraite aussi, et donc qu'on ne sache plus bouger le centre, sans bouger le cercle!

Bon, là je modifie donc ma méthode move en mettant après le mot clef public, le mot clef abstract comme ceci :

Code : Java

public abstract void move (int nvX, int nvY);

Je suis obligé de déclarer ma classe Point abstraite comme ceci :

Code : Java

public abstract class Point {}

Voilà, maintenant je suis obligé de redéfinir la méthode move dans la classe Circle. (bah je vois que là c'est déjà fait!)

Mais ça plante parce que la méthode n'a pas de corps dans votre super classe pour s'exécuter! On va donc devoir le préciser dans la sous classe!
Je vais pour cela rajouter des setters dans la classe Point comme ceci :

Code : Java

public void setX (int x) {
this.x = x;
}
public void setY (int y) {
this.y = y;
}

Et il reste plus qu'à redéfinir la méthode dans la classe Circle comme ceci :

Code : Java

public void move (int nvX, int nvY) {
super.setX (nvX);
super.setY (nvY);
}

Il y aura un autre problème à la méthode getCentre; car elle instancie un nouveau Point hors pas de new avec les classes abstraites, il faudra donc là, créer une méthode qui renverra le Point lui même, on va donc utiliser notre mot clef this ce qui donne donne :

Code : Java

public Point getPoint () {
return this;
}

il reste plus qu'à refaire la méthode getCentre dans la classe Circle :

Code : Java

public Point getCentre () {
return super.getPoint ();
}

Là normalement ça doit compiler sans problème.
Voilà maintenant vous ne pouvez plus que créer des Cercles!

Vous voyez donc c'est génial hein ?!

Bon je l'avoue, faudrait surcharger le constructeur de la classe Circle pour pouvoir mettre des autres coordonnées que (0,0) pour le centre, mais ça je vous laisse faire!

Les interfaces

C'est du 100% abstrait!

Comme l'héritage multiple n'est pas géré par le Java, il a fallut trouver une alternative au cas ou cela serait nécessaire.
De plus, cela va permettre de pouvoir utiliser le polymorphisme plus fort que jamais.
Les interfaces vont aussi nous permettre de nous fournir des informations sur nos classes.
(Par exemple, lorsque je vous parlerai de la séréalisation, on verra que toutes les classes qui n'héritent pas de l'interface séréalizable, ne pourront pas écrire des objets dans un fichier.)

Utilité des interfaces

Celle-ci servent surtout et le plus souvent à créer des nouvelles super classes qui pourront être implémentées dans des autres classes, mais ses classes (interfaces) sont 100% abstraites!
cela va nous permettre de créer des nouvelle super classe et réutiliser le polymorphisme.

Ça veut dire que les interfaces ne contiendront que des méthodes abstraites, donc une interface n'est rien d'autre qu'une classe contenant uniquement des en-têtes de méthodes. (Et éventuellement des constantes.)

Exemple d'interfaces

Il y en a déjà qui sont connues comme par exemple les interfaces ActionListener, MouseListener, etc...
Elles contiennent toutes les méthodes qui doivent être redéfinies lorsqu'on effectue un clic de souris, etc ...

Mais je ne vais pas expliquer la POO événementielle maintenant, on va donc reprendre notre classe Circle!

Supposons que l'on veuille maintenant faire une méthode qui fera tourner le cercle.

-On pourrait la faire dans la classe Point, mais là les Point tournerons aussi et je ne veux pas y toucher, le centre doit rester immobile, le Cercle dois donc tourner sur lui même autour du point comme une roue!

-Bah pas de problème, il suffit de rajouter la méthode dans la classe Circle.
On pourrait le faire, mais il y a des contraintes là :

-Vous devrez mettre en œuvre une convention de nommage entre vous et le programmeur utilisant vos classes, vous ne devrez pas utilisez une méthode tourner si un autre programmeur utilise rotation par exemple.

-Adieu le polymorphisme, vous ne pourrez pas appeler la méthode tourner sur des autres objet que ceux de la classe Circle!

Donc il faudrait pouvoir créer une super classe mais le problème c'est que comme l'héritage multiple est interdit en Java, vous ne pourrez donc pas faire héritée la classe Circle de votre classe qui fera tourner votre cercle car Circle hérite déjà de Point!

C'est là qu'on va utilisez les interfaces!

Création d'une interface

Vous cliquer sur new class, cocher la case Interface et donner lui un nom. (moi je l'ai appelée InterAction)

Effacez ce qui est écrit entre les crochets délimitant l'interface et écrivez l'en tête de la méthode tourner.

Vous pouvez aussi donner l'en tête de la méthode rotation, ainsi le programmeur utilisant vos objets pourra utiliser celle qu'il désire.

Voici le code de mon interface, franchement le code des interfaces, c'est vraiment le plus simple de tout! Et ça évite de faire des bêtises avec l'héritage multiple.

Code : Java

public interface InterAction
{
public void tourner ();
}

C'est super simple, il n'y a que des en têtes de méthodes!

Bon maintenant il faut implémenter notre interface dans la classe Circle, ceci se fait comme ça :

Implémentaton d'interfaces à une classe.

Code : Java

public class Circle extends Point implements InterAction

Votre classe peut aussi implémenter plusieurs interfaces à la fois comme ceci :

Code : Java

public class Circle extends Point implements interface1, interface2

Vos interfaces peuvent aussi implémenter des sous interfaces!

Code : Java

public interface InterAction implements sousInterface1

C'est utiliser en cas d'amélioration d'une classe par la suite.
Et les interfaces peuvent hériter d'une autre interface uniquement (cas plus particulier) mais pas d'une autre classe qu'une interface!

Code : Java

public interface InterAction extends interfaceMere

Attention l'ordre des mots est important! Vous ne pouvez par écrire ceci :

Code : Java

public class Circle implements InterAction extends Point

Donc l'ordre des mots est toujours comme ceci :
public class maClasse extends classeMere implements interfaces

Bon maintenant il ne reste plus qu'à redéfinir notre méthode tourner dans notre classe Circle!
Je vais faire un bête affichage.

Code : Java

public void tourner () {
System.out.println("Je tourne!");
}

Le contrat fixé entre les classes implémentant une interface :

Toutes les classes implémentant une interface devront obligatoirement redéfinir toutes les méthodes contenue dans cette interface!

On pourra ainsi redéfinir cette méthode dans toutes les classes implémentant cette interface! Cela permet le polymorphisme, la méthode tourner pourra être appelée via n'importe quel objet implémentant cette interface!

Donc vous pouvez refaire une classe Segment et redéfinir votre méthode tourner en implémentant l'interface InterAction dans votre classe Segment.
Essayez ça ne fait pas de mal!

Et pour vous donnez un dernière aperçu, on pourra utiliser notre interface InterAction comme on utilise une super classe, on pourra donc utiliser le polymorphisme et la covariance des variables!

Voici un exemple avec un main, je suppose que j'ai deux classes Circle et Triangle :

Code : Java

public class Test {
public static void main (String[] args) {
InterAction i1 = new Circle (); //Covariance des variable!
Interaction i2 = new Triangle ();
i1.tourne (); //Polymorphisme!
i2.tourne ();
}
}

Les interfaces nous permettent donc d'utiliser à nouveau le polymorphisme dans toute sa splendeur!

Sachez que l'on peut aussi définir des constantes dans une interfaces! Mais celles-ci seront d'office public static final!

Exemple de déclaration d'une constante dans une interface :

Code : Java

public interface Modele {
int MAX_VIES = 3;
int MIN_VIES = 0;
public void methode ();
}

Les mots public static et final sont facultatifs car dans les interfaces, on a d'office des constantes statiques et publiques. Faites attention donc à ce que vous pouvez mettre dans vos interfaces.

On voit donc que les interfaces permettent donc de faire quasiment de l'héritage multiple.
Java a utilisé cette façon de faire car l'héritage multiple pose beaucoup de difficultés si il est mal géré!
Ainsi, les interfaces sont des genres de super classe qui permettent de définir facilement ce que une classe sait faire à son utilisateur. Les interfaces contiennent donc des informations sur les classes!!
On utilise parfois des interfaces de définition avec juste un nom : exemple : seule les classes implémentant tel interfaces pourront faire tels chose!!

Exercices sur l'héritage

1)L'héritage : bon voilà alors je vais vous faire un exercice comme si on allait créer un mmorpg.

Alors je vais vous demander de faire une classe Personnage, qui devra être capable de :
Créer des personnages et ils divent avoir un pseudo, le niveau doit être initialisé à 1, leur niveau de compétences aussi, et leur vie à 100, et leur point de mana à 100 aussi!
Cette classe devra pouvoir ajouter de la vie à un de vos personnage
boirePotionDeVie (int quantite)
une méthode recevoir dégats qui enlèvera des point de vie à votre personnage.
Une méthode attaquer qui permettra d'attaquer un autre personnage.
Et une méthode qui renvoie vrai si le personnage est vivant
Et une méthode afficher pour afficher l'état actuel de tout vos personnages du mmorpg.

Attention, pas de point de vie négatif!

Ensuite je vais vous demander de faire une classe arme, qui créera des armes. (nom et l'attaque (le nombre de dégat qu'elle cause)
Et une méthode changer pour qu'un personnage puisse changer d'arme!

Ensuite je vous demanderai de faire une sous classe Magicien qui héritera de Personnage qui pourra en plus, lancer des sortilèges. Par contre il pourra équipé qu'un baton qui fera moins de dégat qu'une épée. (logique)

Et faîtes aussi une classe guerrier qui aura une méthode tapper à l'épée, une autre qui renveoiera vrai ou faux s'il est sur son cheval, enfin soit, rien ne vous empêche d'inventé de nouvelles fonctionnalité à vos classe, et oui, vous devriez avoir un esprit imaginatif!
2)Les classes abstraites.

Je veux que vous fassiez maintenant en sorte que l'on ne puisse plus instancier de personnages. (plus que des magiciens ou guerrier!)

Les armes équipées seront définie dans la classe contenant le main! (mais rien ne vous empêche de faire des sous classes de Arme qui crée des armes spécialisées)

Je veux aussi que vous créer une méthode abstraite dans la classe Personnage, il s'agit de la méthode attaquer et vous devrez la redéfinir dans vos sous classes magicien et guerrier!
Et pour les plus ardus, faîtes une classe Arme abstraite.

Il vous faudra faire une interface et l'implémenter dans ces deux classes (magicien et guerrier), et oui! Magicien et Guerrier hériteront déjà de Personnage et héritage multiples interdit en Java.

Je trouves que c'est vraiment un bonne exercice! (pour une fois j'ai vraiment trouvé quelquechose de bien je crois)
Faîtes aller votre imagination! Mais vous devez utiliser les notions d'héritage, classe abstraites et méthodes abstraites et interface.
Faîtes en jusqu'à que vous vous y sentez à l'aise car on va beaucoup les utiliser dans la partie III afin de ne pas réécrire du code qui existe déjà.

Solution des exercices.

Solution de l'exercice n° 1 :

Vous n'avez peut être pas fait la même chose que moi à 100%, mais je vais vous montrer ce que moi j'ai fait.

Alors je commence par ma classe Arme :

Code : Java

/**
Â * Write a description of class Arme here.
Â * 
Â * @author (your name) 
Â * @version (a version number or a date)
Â */
public class Arme
{
Â  Â  private String nom;
Â  Â  private int attaque;
Â  Â  public Arme (String nom, int attaque) {
Â  Â  Â  Â  this.nom = nom;
Â  Â  Â  Â  this.attaque = attaque;
Â  Â  }
Â  Â  public void changer (String nvNom, int nvAttaque) {
Â  Â  Â  Â  nom = nvNom;
Â  Â  Â  Â  attaque = nvAttaque;
Â  Â  }
Â  Â  public int getNbDegats () {
Â  Â  Â  Â  return attaque;
Â  Â  }
Â  Â  public String toString () {
Â  Â  Â  Â  return "Nom de l'arme : "+nom+" attaque : "+attaque+"\n";
Â  Â  }
}
Â

Ensuite voici ma classe Persnnage :

Code : Java

/**
Â * Write a description of class Personnage here.
Â * 
Â * @author (your name) 
Â * @version (a version number or a date)
Â */
public class Personnage
{
Â  Â  // instance variables - replace the example below with your own
Â  Â  private int vie;
Â  Â  private int mana;
Â  Â  private String pseudo;
Â  Â  private int niveau;
Â  Â  private Arme arme;
Â  Â  
Â  Â  /**
Â  Â  Â * Constructor for objects of class Personnage
Â  Â  Â */
Â  Â  public Personnage(String pseudo)
Â  Â  {
Â  Â  Â  Â  this.pseudo = pseudo;
Â  Â  Â  Â  vie = 100;
Â  Â  Â  Â  mana = 100;
Â  Â  Â  Â  niveau = 1;
Â  Â  Â  Â  arme = null;
Â  Â  }
Â  Â  public void upper () {
Â  Â  Â  Â  niveau++;
Â  Â  }
Â  Â  public void attaquer (Personnage p) {
Â  Â  Â  Â  int degats = arme.getNbDegats ();
Â  Â  Â  Â  p.recevoirDegats (degats);
Â  Â  }
Â  Â  public void recevoirDegats (int degats) {Â  Â  Â  Â  
Â  Â  Â  Â  vie -= degats;
Â  Â  Â  Â  if (vie < 0) vie = 0;
Â  Â  }
Â  Â  public boolean retirerMana (int quantite) {
Â  Â  Â  Â  mana -= quantite;
Â  Â  Â  Â  ifÂ  (mana < 0) {
Â  Â  Â  Â  Â  Â  System.out.println("Pas assez de poitn de mana pour lancer le skill!");
Â  Â  Â  Â  Â  Â  mana += quantite;
Â  Â  Â  Â  Â  Â  return false;
Â  Â  Â  Â  } else 
Â  Â  Â  Â  Â  Â  return true;
Â  Â  }
Â  Â  public void boirePotionDeVie (int quantite) {
Â  Â  Â  Â  vie += quantite;
Â  Â  Â  Â  if (vie > 100) vie = 100;Â  Â  Â  Â  
Â  Â  }
Â  Â  public void boirePotionMana (int quantite) {
Â  Â  Â  Â  mana += quantite;
Â  Â  Â  Â  if(mana > 100) mana = 100;
Â  Â  }
Â  Â  public boolean estVivant () {
Â  Â  Â  Â  return vie != 0;
Â  Â  }
Â  Â  public void changerArme (Arme nvArme) {
Â  Â  Â  Â  arme = nvArme;
Â  Â  }
Â  Â  public Arme getArme () {
Â  Â  Â  Â  return arme;
Â  Â  }
Â  Â  public int getVie () {
Â  Â  Â  Â  return vie;
Â  Â  }
Â  Â  public int getMana () {
Â  Â  Â  Â  return mana;
Â  Â  } 
Â  Â  public String toString () {
Â  Â  Â  Â  return "Vie : "+vie+" Mana = "+mana+" arme = \n"+arme.toString ();
Â  Â  }
}

Alors la classe magicien :

Code : Java

/**
Â * Write a description of class Magicien here.
Â * 
Â * @author (your name) 
Â * @version (a version number or a date)
Â */
public class Magicien extends Personnage
{Â  
Â  Â  boolean assezDeMana; 
Â  Â  private Arme arme;
Â  Â  // instance variables - replace the example below with your own
Â  Â public Magicien (String pseudo) {
Â  Â  Â  Â super(pseudo);Â  Â  Â  Â 
Â  Â }
Â  Â public void lancerUnSors (String nom, int degats, int nbMana, Personnage cible) {
Â  Â  Â  Â  assezDeMana = super.retirerMana (nbMana);
Â  Â  Â  Â  if (assezDeMana) {
Â  Â  Â  Â  Â  Â  cible.recevoirDegats (degats);
Â  Â  Â  Â  }Â  Â  Â  Â  
Â  Â }Â  Â 
}

et enfin la classe Guerrier

Code : Java

/**
Â * Write a description of class Guerrier here.
Â * 
Â * @author (your name) 
Â * @version (a version number or a date)
Â */
public class Guerrier extends Personnage
{
private boolean estSurSonCheval;
Â  Â  public Guerrier (String pseudo) {
Â  Â  Â  Â super(pseudo);
Â  Â  Â  Â estSurSonCheval = false;
Â  Â  }
Â  Â  public void monterSurLeCheval () {
Â  Â  Â  Â  estSurSonCheval = true;
Â  Â  }
Â  Â  public void descendreDuCheval () {
Â  Â  Â  Â  estSurSonCheval = false;
Â  Â  }
}

Et pour ceux qui veulent, voici ma casse pour tester.

Code : Java

/**
Â * Write a description of class Test here.
Â * 
Â * @author (your name) 
Â * @version (a version number or a date)
Â */
public class Test
{
Â  Â  // instance variables - replace the example below with your own
Â  Â  public static void main (String[] args) {
Â  Â  Â  Â  Magicien m = new Magicien ("white lord");
Â  Â  Â  Â  Guerrier g = new Guerrier ("Fenhim");
Â  Â  Â  Â  m.changerArme(new Arme ("Rod", 10));
Â  Â  Â  Â  g.changerArme (new Arme("Escalibur", 40));
Â  Â  Â  Â  g.attaquer (m);
Â  Â  Â  Â  m.lancerUnSors ("jupiter thunder", 30, 20, g);
Â  Â  Â  Â  g.boirePotionDeVie (10);
Â  Â  Â  Â  System.out.println(m.toString ());
Â  Â  Â  Â  System.out.println(g.toString ());
Â  Â  }
}

Voilà tout bête le première exercice, là ou les choses vous se corser, c'est à l'exercice suivant.

Aller je vous met le code de ce que j'ai fait, ainsi, ça vous donnera un exemple déjà sur l'utilisation de l'héritage, classes abstraites et interfaces.
Plus tard je vous parlerez des Design Pattern, qui utilisent toutes ces notions là.

La classe Personnage :

Code : Java

public abstract class Personnage implements ChangementArme 
{
    // instance variables - replace the example below with your own
    private int vie;
    private int mana;
    private String pseudo;
    private int niveau;   
    
    /**
     * Constructor for objects of class Personnage
     */
    public Personnage(String pseudo)
    {
        this.pseudo = pseudo;
        vie = 100;
        mana = 100;
        niveau = 1;                
    }
    public void upper () {
        niveau++;
    }
    public abstract  void attaquer (Personnage p);
        
    
    public void recevoirDegats (int degats) {        
        vie -= degats;
        if (vie < 0) vie = 0;
    }
    public boolean retirerMana (int quantite) {
        mana -= quantite;
        if  (mana < 0) {
            System.out.println("Pas assez de poitn de mana pour lancer le skill!");
            mana += quantite;
            return false;
        } else 
            return true;
    }
    public void boirePotionDeVie (int quantite) {
        vie += quantite;
        if (vie > 100) vie = 100;        
    }
    public void boirePotionMana (int quantite) {
        mana += quantite;
        if(mana > 100) mana = 100;
    }
    public boolean estVivant () {
        return vie != 0;
    }
    public int getVie () {
        return vie;
    }
    public int getMana () {
        return mana;
    }
    public abstract void changerArme (Arme arme);
    public String toString () {
        return "Vie : "+vie+" Mana = "+mana+" de niveau : "+niveau+"\n";
    }     
}

Les classes Magiciens et Guerriers.

Code : Java

/**
 * Write a description of class Guerrier here.
 * 
 * @author (your name) 
 * @version (a version number or a date)
 */
public class Guerrier extends Personnage 
{
    private boolean estSurSonCheval;
    protected Arme arme = new ArmeEpee("Escalibur", 30);
    protected Arme[] armesEpees;
        public Guerrier (String pseudo) {
           super(pseudo);
           estSurSonCheval = false;
           armesEpees = ArmeEpee.getArmesEpees ();
        }
        public void monterSurLeCheval () {
            estSurSonCheval = true;
        }
        public void descendreDuCheval () {
            estSurSonCheval = false;
        }
        public void changerArme (Arme arme) {
            if (arme instanceof ArmeEpee) 
                this.arme = arme;
            else
                System.out.println("Vous ne pouvez pas Ã©quipper cette arme!");
        }
        public void attaquer (Personnage cible) {
            int degats = arme.getNbDegats ();
            cible.recevoirDegats (degats);
        }
        public String toString () {
           return "Guerrier.\n"+super.toString ()+"\n"+arme.toString ();
        }
}

Code : Java

/**
 * Write a description of class Magicien here.
 * 
 * @author (your name) 
 * @version (a version number or a date)
 */
public class Magicien extends Personnage 
{  
    boolean assezDeMana;
    protected Arme arme = new ArmeBaton ("Rod", 15);
    protected Arme[] armesBatons;
    // instance variables - replace the example below with your own
   public Magicien (String pseudo) {
       super(pseudo); 
       armesBatons =  ArmeBaton.getArmesBatons ();       
   }
   public void lancerUnSors (String nom, int degats, int nbMana, Personnage cible) {
        assezDeMana = super.retirerMana (nbMana);
        if (assezDeMana) {
            cible.recevoirDegats (degats);
        }        
   } 
   public void attaquer (Personnage cible) {
       int degats = arme.getNbDegats ();
       cible.recevoirDegats (degats);
   }
   public void changerArme (Arme arme) {
          if (arme instanceof ArmeBaton)
                this.arme = arme;
          else
            System.out.println("Vous ne pouvez pas Ã©quipper cette arme!");
   }
   public String toString () {
       return "Magicien.\n"+super.toString ()+"\n"+arme.toString ();
   }
}

J'ai fait une interface ChangementArme; histoire de pouvoir faire des changements d'armes différents.

Code : Java

public interface ChangementArme
{
   public void changerArme (Arme arme);   
}

Interface ArmeType, toutes les armes de tout les type en héritent.

Code : Java

public interface ArmeType
{
     public Arme setDefautArme (Arme arme);     
}

La classe abstraite Arme.

Code : Java

/**
 * Write a description of class Arme here.
 * 
 * @author (your name) 
 * @version (a version number or a date)
 */
public abstract class Arme implements ArmeType
{
    // instance variables - replace the example below with your own
    private int attaque;
    private String nom;
    private static Arme defautArme;
    /**
     * Constructor for objects of class Arme
     */
    public Arme(String nom, int attaque)
    {
        this.nom = nom;
        this.attaque = attaque;
    }
 
    /**
     * An example of a method - replace this comment with your own
     * 
     * @param  y   a sample parameter for a method
     * @return     the sum of x and y 
     */
     public abstract Arme setDefautArme (Arme arme); 
     public String toString () {
         return "Nom de l'arme : "+nom+" attaque : "+attaque+"\n";
     }
     public int getNbDegats () {
         return attaque;
     }
}

Et enfin les deux classe, Epee et Baton.

Code : Java

public class ArmeEpee extends Arme
{
    // instance variables - replace the example below with your own
    private static Arme[] armesEpees = new ArmeEpee[100];
    
    
    /**
     * Constructor for objects of class ArmeBaton
     */
    public ArmeEpee(String nom, int

Plateforme de création de jeux vidéo (Le site est en cours de création / réorganisation)

Les Tutoriaux Les Forums Les Liens

L'héritage,les classes abstraites et interfaces

L'héritage

Notion d'héritage

L'héritage des constructeurs

L'utilité du mot clef super.

Démonstration :

La redéfinition des méthodes

Utilité de l'héritage

Remarque avec la méthode toString ()

Un dernier petit mot sur les variables

Le mot clef protected

La redéfinition des méthodes et le polymorphisme

Une chose bien pratique : redéfinir les méthodes!

La super classe de toutes les classes!

Les méthodes de la classe Object

Le polymorphisme

La covariance des variables

Le casting implicite et le casting explicite

Les classes abstraites

Utilité

Les méthodes abstraites

Le contrat fixé par les classes abstraite lors de l'héritage!

Les interfaces

C'est du 100% abstrait!

Utilité des interfaces

Création d'une interface

Implémentaton d'interfaces à une classe.

Le contrat fixé entre les classes implémentant une interface :

Exercices sur l'héritage

Solution des exercices.