Discussion :

[Roulenv]

Bonjour, j'ai un petit exercice à résoudre. Je fais du Java depuis quelques mois et je me pose quelques questions. J'aurais besoins de confirmations si possible .
L'exercice est le suivant :
On nous donne:

Code :

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

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
class Object{
    public void say() {
           System.out.println("Nothing");
    }
}
 
class Cube extends Object{
}
 
class Wood extends Cube{
    public void say() {
           super.say();
           System.out.println("WOODY");
    }
}
 
class BigWood extends Wood{
}
 
class RedWood extends BigWood{
    public void say() {
           System.out.println("BIG RED WOOD");
    }
}
 
class Perforated extends RedWood{
    public void say() {
           super.say;
           System.out.println("BIG RED WOOD & HOLE");
    }
}
 
class GreenWood extends BigWood{
    public void say() {
           System.out.println("BIG GREEN WOOD");
    }
}

-----------------------------------------------------------------------------
Soit la méthode main suivante:

Code :

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

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 static void main(String argv[ ]) {
 
  Cube [ ] ta;
  ta = new Cube[5];
 
  Object o1 = new Object();
  Object o2 = new RedWood();
  Cube o3 = new Wood();
  BigWood o4 = new BigWood();
  Perforated o5 = new Perforated();
  BigWood o6 = new RedWood();
  Cube o7 = new CreenWood();
 
  o1.say();
  o2.say();
  o3.say();
  o4.say();
  o5.say();
  o6.say();
  o7.say();
 
ta[0] = (Cube) o2;
ta[1] = (Cube) o3;
ta[2] = (Wood) o4;
ta[3] = (Cube) o5;
ta[4] = o7
 
  for(int i = 0; i<5; i++)
          ta[i].say();
 
}

Questions: -Hormis les chaines, combien d'objets sont réellement créés en mémoire? (Je dirais 8)
-Qu'affichera la méthode main() ? (ce dont j'ai le plus de doutes)


Si quelqu'un peut prendre 5 minutes pour m'aider à m'éclaircir les idées...

[kolodz]

Si on ignore les problèmes "bête" de compilation de l'exemple.
Il y a bien 8 objets crée par le main.

Pour savoir ce que fait l'exemple, le mieux est de le faire fonctionné.

Je suppose que votre professeur a volontairement ajouter des petites erreurs de syntaxe, pour que vous ayez à toucher au code si vous avoir le résultat sans penser à la logique Objet. Il est même vicieux, en redéfinissant sa propre classe objet...

Cordialement,
Patrick Kolodziejczyk.

[Roulenv]

Oui c est ce que j ai fait, mes doutes se sont confirmés...
On ne peut donc pas faire de Cast vers une super-classe n'est-ce pas?
Ce que je veux dire c'est qu'à l'exécution, la méthode say() sera celle définie par la classe qu'on a instanciée?
En fait, la difficulté de l'exercice est que tout ne doit se faire qu'à l'écrit sur une feuille..
Je vous remercie beaucoup en tout cas!

[thelvin]

On ne peut donc pas faire de Cast vers une super-classe n'est-ce pas?

Ah si si, on peut : ça compile et aucune erreur n'est remontée.
Seulement, un cast sur un objet ne change rien à ce qu'est cet objet, et donc à ce qu'il fait.

Un cast d'objet vers objet peut avoir deux effets :
- aucun effet si le cast est valide.
- lancer une ClassCastException si le cast n'est pas valide.

Autrement dit, un cast objet vers objet n'est qu'une vérification du fait que l'objet est bien d'un type compatible pour le type vers lequel on le cast.

Ça consiste essentiellement à dire à Java : "Java, moi, tout puissant programmeur, je t'affirme que cet objet, là, de type A, se trouve être aussi de type B, et désormais je veux le manipuler à travers une variable de type B."

Ce sur quoi Java vérifie si le programmeur a raison. Si oui, il fait ce que le programmeur demande. Sinon, ClassCastException.

Ce que je veux dire c'est qu'à l'exécution, la méthode say() sera celle définie par la classe qu'on a instanciée?

Oui, c'est le concept de polymorphisme.

En fait, la difficulté de l'exercice est que tout ne doit se faire qu'à l'écrit sur une feuille..

Il y a bien trop de classes et d'objets. C'est un problème de mémoire, pas de compréhension de Java. C'est le genre d'exercices faits par des gens qui servent à rien.

[Roulenv]

Vraiment, merci beaucoup!! Ces réponses m'ont vraiment aidées à avancer!!
C'est vraiment très gentil à vous d'avoir pris quelques minutes pour mon problème.

[tchize_]

-Hormis les chaines, combien d'objets sont réellement créés en mémoire? (Je dirais 8)

Question relativement idiote quand on connait java. La réponse étant... Impossible à déterminer, Bien qu'on puisse tenter un calcul pour démontrer que la valeur réelle dépend de a quel point on va dans le détail.


J'ai annoté le code pour t'aider à comprendre.

Code :

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

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
class Object{ // Ignorons le fait qu'on ne peux créer aucune une classe appelé "Object" car conflit avec java.lang.Object
    /*  New Object() crée au moins les objets suivant:
     * 1 fois: Class<Object>
     * 1 fois la String "Nothing"
     * N fois l'instance d'Object, N étant le nombre d'Object
     */
    public void say() {
           System.out.println("Nothing"); //La string est un objet
    }
}
 
class Cube extends Object{
    /* Même reflexion sur le Class<Cube> et l'instance de Cube
     */
}
 
class Wood extends Cube{
    /* Même reflexion sur le Class<Wood> et l'instance de Cube
     * Plus une fois "WOODY"
     */
    public void say() {
           super.say();
           System.out.println("WOODY");
    }
}
 
class BigWood extends Wood{
    /* Même reflexion sur le Class<BigWood> et l'instance de Wood
     */
}
 
class RedWood extends BigWood{
    /* Même reflexion sur le Class<BigWood> et l'instance de BigWood
     * Plus l'instance de BIG RED WOOD
     */
    public void say() {
           System.out.println("BIG RED WOOD");
    }
}
/*ETC :)*/
class Perforated extends RedWood{
    public void say() {
           super.say;
           System.out.println("BIG RED WOOD & HOLE");
    }
}
 
class GreenWood extends BigWood{
    public void say() {
           System.out.println("BIG GREEN WOOD");
    }
}

Le point important à comprendre c'est que, en java, tout classe (je n'ai pas dit instance) est associée à une instance de la classe java.lang.Class, que tu peux récupérer par exemple en faisant

Code :

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

System.out.println(RedWood.class);

Et chaque Class<Enfant> est associé à une instance de Class<Parent>, sauf pour Class<java.lang.Object> qui n'a pas de parent.

Ca donne ce calcul dans le Main

Code :

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

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
 
/*Une instance de Class<TonMain>*/
public class TonMain {
public static void main(String argv[ ]) { // une instance de String[]
 
  Cube [ ] ta; /*Trois objets: Class<Cube>, Class<Object>, la String de Object  (cf commentaire plus haut)*/ 
  ta = new Cube[5]; /*Deux objets: Class<[LCube;> et l'instance Cube[5]*/
 
  Object o1 = new Object(); /* un objet, l'instance*/
  Object o2 = new RedWood(); /*septs Objets: l'instance RedWood + Class<RedWood> + les Class ancètres + Les Strings*/
  Cube o3 = new Wood(); /*1 objet: l'instance (les Class<?> sont déjà créés, cf le RedWood*/
  BigWood o4 = new BigWood(); /*1 objet: l'instance (idem)*/
  Perforated o5 = new Perforated(); /*3 objets: instance + Class<Perforated> + la String*/
  BigWood o6 = new RedWood(); /*1 objet: l'instance*/
  Cube o7 = new GreenWood(); /*3 objets: instance + Class<GreenWood> + la String*/
 
  o1.say(); /* au mois 8 objets: le Class<System> (cf appel à System.out), les 3 instances de System.out/err/in initialisé eavec System + les classes Class<InputStream> + Class<PrintStream> + Class<FilterOutputStream> + Class<OutputStream> */
  o2.say(); // rien de plus
  o3.say();// rien de plus
  o4.say();// rien de plus
  o5.say();// rien de plus
  o6.say();// rien de plus
  o7.say();// rien de plus
 
ta[0] = (Cube) o2; // Pas d'instance créée
ta[1] = (Cube) o3; // Pas d'instance créée
ta[2] = (Wood) o4; // Pas d'instance créée
ta[3] = (Cube) o5; // Pas d'instance créée
ta[4] = o7; // Pas d'instance créée
 
  for(int i = 0; i<5; i++)
          ta[i].say(); // rien de plus
 
}
}

Et n'oublions pas l'indispensable ClassLoader: 1 instance plus un Class<ClassLoader> => 2 Et l'inévitable à la racine de tout, une instance de Class<Class<?>>. Et enfin aussi l'instance de Class<Object>, de Class<String> et de Class<[String;>

Si je fais le total, je compte donc, de mon coté, un minimum de 37 objets en mémoire. En réalité tu en as beaucoup plus que ça avec toute l'initialisation de la JVM et les objets temporaires du Classloader (les File/FileInputStream pour lire tes classes), le security manager, le garbage collector, ....

Maintenant, on peut évidement refaire le calcul en ignorant les Class<?> et en ignorant ce qui se passe dans les classes Système. Ton compte deviens alors: le tableau (1 instance) + chaque String existante (5) + Chaque instance que tu crée (7) + le tableau String[] (supposé vide) passé à ton main (1). => 13 objets en ignorant les rouages de la JVM.

Mais là, c'est une question de savoir ce qu'on entends dans l'exercice par 'nombre d'objets créés' :p

Questions:
-Qu'affichera la méthode main() ? (ce dont j'ai le plus de doutes)

La je vais d'abord de laisser faire une proposition car c'est à la portée d'un débutant. Dis toi que, aucune de tes méthodes "say" n'étant statique, ce qui compte ce n'est pas la déclaration du type de variable qui compte

Code :

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

Object o2 =

Mais son type concret:

Code :

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

o2 = new RedWood();

Avec la subtilité que certains appellent le say() du parent


PS: j'ai fait le total avec les chaines, à toi de faire le total sans ^^

[Roulenv]

Aah je l'avais pas forcément vu comme ça oui
En effet, le "Object" n'est qu'un exemple de classe pour illustrer, englober le tout...
Je vous remercie beaucoup, vraiment!!