[Héritage] [Polymorphisme] Question de débutant ?

Version imprimable

Bonjour,
J'ai une question stupide sur l'héritage et le polymorphisme. ça fait un bon moment que je fais du java mais là j'avoue que je ne comprends pas bien...

Voici un petit code :

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
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
 
package test ;
 
public class SurchargeTest {
 
	public static void main(String[] args) {
		new SurchargeTest().launchTest();
	}
 
	public void launchTest() {
		A a[] = new A[2];
		a[0] = new A1(5);
		a[1] = new A2(6);
 
		B b = new B1();
 
System.out.println(b.transform(a[0], " test "));
System.out.println(b.transform((A1) a[0], " test "));
System.out.println(b.transform(a[1], " test "));
 
}
 
	abstract class A {
		int value;
 
		A(int initValue) {
			value = initValue;
		}
 
		public String toString() {
			return "" + value;
		}
	}
 
	class A1 extends A {
		A1(int initValue) {
			super(initValue);
		}
	}
 
	class A2 extends A {
		A2(int initValue) {
			super(initValue);
		}
	}
 
	// class A3 A4 ...
 
	abstract class B {
		public abstract String transform(A a, Object c);
 
		public String transform(A1 a, Object c) {
			return "Cas special pour A1";
		}
	}
 
	class B1 extends B {
		public String transform(A a, Object c) {
			return "T1 " + a.toString() + c.toString();
		}
	}
 
	class B2 extends B {
		public String transform(A a, Object c) {
			return "T2 " + c.toString() + a.toString();
		}
	}
 
	// class B3, B4 ...
 
}

Et voici ce qui apparaît à l'écran lors de son exécution :

Code:

1
2
3
4
 
T1 5 test 
Cas special pour A1
T1 6 test

Ma question est simple, pourquoi lors du premier appel "b.transform(a[0], " test ")", le retour n'est pas "Cas spécial pour A1" comme pour l'appel b.transform((A1)a[0], " test ").

07/09/2006, 19h58
TSnarfK

Une piste peut être : j'utilise ici à la fois le polymorphisme fort (héritage) et le polymorphisme faible (surcharge de signature).

Citation:

Envoyé par TSnarfK

abstract class B {
public abstract String transform(A a, Object c);

public String transform(A1 a, Object c) {
return "Cas special pour A1";
}
}

Si quelqu'un a une explication, je suis preneur.
07/09/2006, 20h09
gronono

Bonjour,

Lorsque tu fais A a1 = new A1() la variable a1 est du type A. Donc la méthode appelée est transform(A, Object).

Par contre si tu déclares A1 a1 = new A1() la variable a1 est du type A1. Donc la méthode appelée est transform(A1, Object).

Si si tu déclares A a1 = new A1() et que tu appelle transform par transform(a1, "test") alors tu force le type de a1 en A1.

Dans le premier cas, la JVM considère que a1 est de type A
Dans le second, de type A1 (il est déclaré explicitement)
Dans le troisième de type A1 (c'est toi qui force)

L'important est le type de la déclaration et non le type de l'instance.

Il existe des exemples dans l'API standard:
soit une ArrayList l.
Si tu la déclare ArrayList l = new ArrayList(), tu peux utiliser la méthode add(int index, E element)
Par contre si tu la déclare Collection l = new ArrayList(), tu ne peux utiliser la méthode add(int index, E element) .

A+
Gronono
08/09/2006, 08h39
thibaut

Juste pour préciser le vocabulaire, dans ton cas ce n'est pas de la surcharge de méthodes, c'est de la réécriture.

La surcharge: c'est quand tu définis la même méthode avec une signature différente dans une classe fille ou dans la même classe.

La réécriture: c'est quand tu redéfinis une méthode avec la même signature dans une classe fille.

A+

Merci pour l'explication. Est-ce que cela veut dire que pour avoir le comportement que j'aurais souhaité, je suis obligé d'avoir une solution du type :
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 abstract class B { public abstract String transform(A a, Object c); public String specialCaseForA1(A a, Object c) { return "Cas special pour A1"; } } class B1 extends B { public String transform(A a, Object c) { if (a instanceof A1) return specialCaseForA1(a, c); return "T1 " + a.toString() + c.toString(); } } class B2 extends B { public String transform(A a, Object c) { if (a instanceof A1) return specialCaseForA1(a, c); return "T2 " + c.toString() + a.toString(); } }
ce qui duplique le bout de code

Code:

if (a instanceof A1) return specialCaseForA1(a, c);

pour chaque sous-classe B ?

Y aurait-il une meilleur façon de faire les choses ? Est-ce un problème de conception à la base ?

Autant pour moi, pas besoin de dupliquer le code.
Néanmoins, cette solution utilise toujours un "instanceof"...

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
 
abstract class B {
 
		public String transform(A a, Object c){
			if (a instanceof A){
				return specialCaseForA1(a, c) ;
			}			
			return normalTransform(a,c) ;			
		}
 
		protected abstract String normalTransform(A a, Object c);
 
		protected String specialCaseForA1(A a, Object c) {
			return "Cas special pour A1";
		}
	}
 
	class B1 extends B {
		protected String normalTransform(A a, Object c) {
			return "T1 " + a.toString() + c.toString();
		}
	}
 
	class B2 extends B {
		protected String normalTransform(A a, Object c) {
			return "T2 " + c.toString() + a.toString();
		}
	}

08/09/2006, 10h39
had35

Dans ton cas, tu aurais pu déclarer la méthode transform() dans la classe A, ce qui t'aurais permis de redéfinir son comportement pour A1.
12/09/2006, 14h15
TSnarfK

Oui, ce cas était simplifié pour la question. En fait dans le cas réel, j'ai besoin d'information contenue par les différents classes fils B1, B2, B3... pour faire la transformation en question (celle-ci étant donc fonction du type de A et fonction du type de B) d'où la présence de ces classes.

Je pense qu'il te faudrait quelque chose dans le genre :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
 
public abstract class A {
     public String getRepresentation();
     public void setRepresentation(String s);
}
 
public class B {
     public A transformRepresentation(A a, C obj) {
          a.setRepresentation( a.getRepresentation() + obj.toString() );
          return a;
     }
}

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
 
public interface A {
     public String getRepresentation();
     public void setRepresentation(String s);
}
 
public class B {
     public void transformRepresentation(C obj) {
          setRepresentation(getRepresentation() + obj.toString());
          return getRepresentation();
     }
}
 
public class B1 extends B implements A {
[..]
}
 
public class B2 extends B implements A {
[..]
}