Discussion :

[Amnael]

Bonjour, j'essaie de faire un petit retour en arrière sur ces notions que sont l'héritage et le polymorphisme.

PS: Quand je dis polymorphisme, je ne confonds pas avec la surcharge d'une méthode.


Voici les classes suivantes des plus simples

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
class A
{
	int f(A a)
	{
		return 1;
	}
}

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
class B extends A
{
	int f(A a)
	{
		return 2;
	}
 
	int f(B b)
	{
		return 3;
	}
}

Ma première question se situe au niveau du main

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
A a = new A();
A ab = new B(); 
B b = new B();

Pourquoi cette instanciation est elle valide ?

Pour moi puisque B est un A on devrait plutôt pouvoir faire: B ab=new A(); or ceci est faux bien sûr...mais je n'arrive pas à comprendre la logique de compilateur sur ce détail là...pouvez vous m'expliquer ?




Ensuite, pour compliquer un peu les choses^^

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
 
	System.out.println( a.f(a) );
	System.out.println( a.f(ab) );
	System.out.println( a.f(b) );
 
	System.out.println( ab.f(a) );
	System.out.println( ab.f(ab) );
	System.out.println( ab.f(b) );
 
	System.out.println( b.f(a) );
	System.out.println( b.f(ab) );
	System.out.println( b.f(b) );

A l'affichage on va obtenir

1
1
1

2
2
2

2
2
3

Alors maintenant, si j'essaie d'analyser et de comprendre.
Pour le cas ab, je ne comprends pas pourquoi ça passe au compilateur, du coup je n'essaierais pas d'expliquer...mais je pense qu'une fois que j'aurais compris pourquoi ça passe au compilo, je comprendrais un peu mieux le résultat à l'exécution !

Dans l'ordre:

a.f(a)
a est de type A ==> J'appelle sur a la fonction typé f(A a) ==> je retourne 1 pas de soucis

a.f(b)
a est de type A ==> J'appelle sur a la fonction typé f(A a) ==> Or b est de type B ==> B hérite de A ==> On peut utiliser f(A a) sur tous les fils de la classe A ce qui est le cas ici ==> je retourne 1.

b.f(a)
b est de type B ==> a est de type A ==> Je regarde si je peux appeler sur B une méthode f(A a) ==> Oui je retourne donc 2

b.f(b)
b est de type B ==> je regarde si B possède une méthode f(B b) ==> Oui, donc j'applique et je retourne 3



Sur ces points là je n'ai aucun problème.

Pour la suite, je ne comprends pas l'instanciation de ab...donc forcement le reste est assez obscur pour moi...




Merci du temps que vous accorderez à mes modestes questions

[adiGuba]

Salut,

PS: Quand je dis polymorphisme, je ne confonds pas avec la surcharge d'une méthode.

Attention car ton exemple contient de la surcharge...

Pour moi puisque B est un A on devrait plutôt pouvoir faire: B ab=new A(); or ceci est faux bien sûr...mais je n'arrive pas à comprendre la logique de compilateur sur ce détail là...pouvez vous m'expliquer ?

La classe B étend la classe A. Donc on y retrouvera toute les caractéristiques de la classe A, alors que l'inverse n'est pas vrai.

Remplace A et B respectivement par "Animal" et "Biche".

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
Animal a = new Biche(); // OK : il est correct de dire qu'une Biche est un Animal.
Biche b = new Animal(); // ERREUR : un Animal n'est pas forcément une Biche.

Ensuite, pour compliquer un peu les choses^^

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
 
	System.out.println( a.f(a) );
	System.out.println( a.f(ab) );
	System.out.println( a.f(b) );
 
	System.out.println( ab.f(a) );
	System.out.println( ab.f(ab) );
	System.out.println( ab.f(b) );
 
	System.out.println( b.f(a) );
	System.out.println( b.f(ab) );
	System.out.println( b.f(b) );

Attention car là tu mélanges héritage et surcharge...

Alors maintenant, si j'essaie d'analyser et de comprendre.
Pour le cas ab, je ne comprends pas pourquoi ça passe au compilateur, du coup je n'essaierais pas d'expliquer...mais je pense qu'une fois que j'aurais compris pourquoi ça passe au compilo, je comprendrais un peu mieux le résultat à l'exécution !

"a" ou "ab" c'est la même chose : c'est une variable de type A.
Donc la logique est exactement la même : tu appelles la méthode f(A).



a++

[Amnael]

Ok, j'ai fini par comprendre, en fait c'est juste que pour moi "dans ma logique

Biche b=new Animal() devrait se lire Une biche est un animal

et

Animal b=new Biche() devrait se lire un animal est une biche

Mais en fait non...on le lit dans l'autre sens...je trouve pas ça logique, mais puisque c'est comme ça c'est bon pour moi !




En revanche...je suis pas d'accord, je ne vois pas où se situe la surcharge ici !

surcharger une méthode pour moi c'est le fait de réutiliser un même nom de méthode, mais avec des arguments différents.

Pour moi je fais une redéfinition de f(A a) et non une surcharge.

Je me tromperais à nouveau ?

Merci !

[adiGuba]

Dans la classe B tu as à la fois une redéfinition (avec f(A)) et une surcharge (avec f(B)).


a++