[Règle du langage] 3 cas pratiques à justifier
Bonjour,
Je suis tombé sur 3 questions Java avec une petite classe d'exemple à la clé dont j'ai du mal à justifier théoriquement le pourquoi. J'aimerais avoir l'éclairage de quelques experts ! MERCI !
Exemple 1
Code:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
| public class TestHeritage {
public static void main(String[] args) {
Base2 b = new Derived2();
System.out.println(b.getValue());
}
}
class Base2 {
int value = 0;
Base2() {
addValue();
}
void addValue() {
value += 10;
}
int getValue() {
return value;
}
}
class Derived2 extends Base2 {
Derived2() {
addValue();
}
void addValue() {
value += 20;
}
} |
Le "System.out.println(b.getValue());" affiche 40. J'ai du mal à m'expliquer pourquoi. Je pensais avoir 30. Je connais la règle de l'overridding, mais je pensais que dans le constructeur Base2, c'était le addValue de Base2 qui serait appelé vu que l'objet Derived2 n'est pas encore construit...
Exemple 2
L'exemple est le même avec les méthodes addValue en static :
Code:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
| public class TestHeritage2 {
public static void main(String[] args) {
Base3 b = new Derived3();
System.out.println(b.getValue());
}
}
class Base3 {
static int value = 0;
Base3() {
addValue();
}
static void addValue() {
value += 10;
}
int getValue() {
return value;
}
}
class Derived3 extends Base3 {
Derived3() {
addValue();
}
static void addValue() {
value += 20;
}
} |
Ici, le System.out.println(b.getValue()); affiche 30. Ce que je comprends mieux. La justification est-elle qu'il n'y a pas de polymorphisme avec des méthodes statiques ?
Exemple 3
Code:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
| public class TestHeritage3 {
void print(Base4 b) {
System.out.println(b.show());
}
void print(Derived4 d) {
System.out.println(d.show());
}
public static void main(String[] args) {
TestHeritage3 t = new TestHeritage3();
Base4 b = new Derived4();
t.print(b);
}
}
class Base4 {
String s = "Base";
String show() {
return s;
}
}
class Derived4 extends Base4 {
String s = "Derived";
} |
Le t.print(b); affiche Base, bien que l'objet soit un Derived4. La méthode appelée est print(Base4), puisque la règle de l'overloading dit que la résolution de la méthode se fait à la compilation. La référence de b étant Base4, c'est cette méthode qui est appelée. Par contre, le comportement des attributs est apparemment différent du comportement des méthodes. Il n'y a pas de polymorphisme est c'est l'attribut s de Base4 qui est affiché et non l'attribut s de Derived4 (pourtant l'objet est Derived4). Je cherche une explication claire à ce phénomène.
Voilà, un grand merci à ceux qui s'auront m'apporter une réponse claire à ces propriétés du langage Java !
