Je suis dans une école d'informatique depuis cette année. On va bientot voir les interfaces, donc je peux pas trop t'expliquer, mais tu peux le faire autrement en faisant hériter B de A. C'est clair que c'est moins puissant, mais du moment que C hérite de B il aura attributs et méthodes de A et de B. Je te re-répondrais quand j'aurai appris à utiliser les interfaces.

Bon ben j'ai vu les interfaces :P Donc je peux te répondre en connaissance de cause.
Alors en fait au lieu de créer une classe B, tu crées un interface:

interface B {
// un interface contient uniquement des attributs final ou des méthode abstraites et il n'a pas de constructeur
}

les interfaces ont été introduit par les créateurs de java pour enlever un problème du C++ lié à l'héritage multiple. En fait quand tu hérites d'une classe, tu hérite de 2 choses:
1. Les attributs et méthodes
2. Le type

1. Imaginons que tu puisses hérité de plusieurs classes, par exemple C hérite A et B. A et B contiennent peut-être des attributs du même nom, ou des méthodes du même nom => ambiguïté
Quel méthode/attribut choisir? C'est pour éviter ce problème existant en C++ que les créateurs de java ont interdit l'héritage multiple.
2. Parfois il est utile de posséder plusieurs types. Par exemple, si C hérite de A, alors C est de type C et aussi de type A, mais des fois il est utile d'avoir encore plue de types, prenons un exemple concret.
On a 4 classes:

1 - Reptile terrestre
2 - Reptile aquatique
3 - Mammifère terrestre
4 - Mammifère aquatique

Toutes ces classes héritent de la classe animaux (qui est abstraite) et 1 et 2 hérite de la classe reptile et 3 et 4 de la classe mammifère.

On crée ensuite un tableau de type Animal

Animal[] an = new Animal[4];
an[0] = new ReptileTerrestre();
an[1] = new MammifereTerrestre();
an[2] = new MammifereAquatique();
an[3] = new ReptileAquatique();

/* Aucun problème jusque là.
on veut ensuite savoir combien de mammifère possède le tableau*/

int nbMammifere = 0;
for(int i = 0; i < an.length; i++) {
if(an[i] instanceof Mammifere) { // on peut faire ça, car les sous-classes héritent aussi du type de la (des)
nbMammifere++; //classe-mère(s)

}
}

/*Toujours aucun problème
Maintenant on veut savoir le nombre d'animaux aquatiques.
Héhé, là ça pose problème, il existe aucune classe aquatique ou terrestre, on ne peut donc pas faire un seul instanceof */

int nbAquatique = 0;
for(int i = 0; i < an.length; i++) {
if(an[i] instanceof MammifereAquatique || an[i] instanceof ReptileAquatique) {
nbAquatique++;

}
}

/*Pour des programmes plus long, c'est encore plus embêtant, ça rajoute énormément de lignes. Alors pour éviter les ambiguïtés qui peuvent exister avec l'héritage multiple, mais pour pouvoir hériter de plus de types, il existe les interfaces.*/
//Si je crée maintenant un interface aquatique et un terrestre:

interface Aquatique {
//mon interface est vide, car j'ai rien besoin d'y mettre
}

interface Terrestre {
//mon interface est vide, car j'ai rien besoin d'y mettre
}

/*je rajoute ensuite dans la déclaration des classes implements Aquatique si elle est aquatique, implements Terrestre si elle est terrestre, Exemple: */
class MammifereAquatique extends Mammifere implements Aquatique {
//Attributs
//méthodes (dont constructeur)
}

/*je fais pareil pour les 3 autres classes et je peux maintenant réecrire mon code pour compter le nombre d'animaux aquatiques de manière plus simple et plus claire*/

int nbAquatique = 0;
for(int i = 0; i < an.length; i++) {
if(an[i] instanceof Aquatique) {
nbAquatique++;

}
}


Voila, j'ai essayé de faire le plus clair et simple possible, sans pour autant ommettre quelque chose. Si jamais tu as encore des questions, je serai ravis d'y répondre sur le forum, ou tu peux meme me contacter par mail (claquettes@hotmail.com).

Bonne soirée,
Phortitou "Software is like sex, it's better when it's free." - Linus Torvalds

Salut,


Il suffit de faire 2 interfaces :

public interface A {
Méthodes_A1(); // pas de code
Méthodes_A2(); // pas de code
}

public interface B {
Méthodes_B1(); // pas de code
Méthodes_B2(); // pas de code
}

Deux classes abstraites :
public class AbstractA implements A {
Attribut_A1;
Attribut_A2;

Méthodes_A1() { ... code ... }
Méthodes_A2() { ... code ... }
}

public class AbstractB implements B {
Attribut_B1;
Attribut_B2;

Méthodes_B1() { ... code ... }
Méthodes_B2() { ... code ... }
}

et enfin une classe concrète :
public class C implements A, B {
protected A a = new AbstractA();
protected B b = new AbstractB();

Méthodes_A1() { a.Méthodes_A1(); }
Méthodes_A2() { a.Méthodes_A2(); }

Méthodes_B1() { b.Méthodes_B1(); }
Méthodes_B2() { b.Méthodes_B2(); }
}

Et voilà comment faire de l'héritage multiple en Java tout en limitant la duplication de code.

Merci Phortitou ... j'ai trouvé la réponse.