Discussion :

[nakhon]

bonjour à tous je suis débutant en Java et c'est la première fois que j 'ai posé le message sur ce forum.
je suis en train de lire le tutorial "Penser en Java v2 " chapitre 4 page 1, et il y a un morceau de programme que je n'ai pas compris.


Voici le programme

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
//: c04:SimpleConstrutor.java
// Démonstration d'un constructeur.
 
class Rock {
  Rock() { // Ceci est un constructeur
    System.out.println("Creating Rock");
  }
}
 
public class SimpleConstructor {
  public static void main(String[] args) {
    for(int i = 0; i < 10; i++)
      new Rock();
  }
} ///:~

Le prblème c'est quand on fait "new Rock();" pour moi ça signifique que on crée un nouvel objet à partir de la "clsse Rock" mais dans mon esprit si je veux créer un objet, je fera plustôt:

Rock nouvelobjet = new Rock();

Pourriez - vous me dépanner? S'il vous plaît.

[tchize_]

non

new Rock() -> crée le nouvel objet
Rock nouvelObject -> Défini une variable de type référence à Rock
= -> stocke la référence au nouvel objet dans la variable.


Ainsi, tous ces codes créent un nouvel objet, mais en font quelque chose de différent

list.add(new Rock()) <- stocke un Rock dans une liste
new Rock().unMethode() <- crée un objet rock et appelle un méthode dessus
Rock[] tableau = new Rock[] {new Rock(); new Rock()} <- crée un tableau de 2 Rock

Bien que dans ton code d'exemple l'intéret est assez limité de faire des new Rock() pour les oublier juste après, ca démontre bien le fonctionnement des constructeurs.

[bricecol]

explication simpliste :

on fait un new Rock() pour te montrer simplement qu'on rentre bien dans le constructeur qui affiche "Creating Rock".

Rock r = new Rock(); donnera exactement le même résultat. la différence ici est que l'on a plus besoin de garder l'objet r (il ne nous sert plus après sa construction)

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
 
public class MaClasse
{
  public MaClasse()
  {
    System.out.println("Ceci est un exemple");
  }
}
 
public class Exemple
{
  public static void main(String[] args)
  {
    // objet anonyme
    new MaClasse();
 
    // résultat => "Ceci est un exemple"
    // même résultat avec MaClasse m = new MaClasse();
  }
}

[nakhon]

Bonjour et merci pour vos réponses.
Pouvez-vous me dire si j'ai bien compris.


Quand on fait "new Rock();" C'est just pour pouvoir rentrer dans le constructeur puis afficher "Creating Rock".
Mais après avoir affiché "Creating Rock", objet qu'on crée, il est gardé en mémoire.


Par contre quand on fait "Rock r = new Rock();" après avoir affiché "Creating Rock", l'objet r n'est pas gardé en mémoire.

merci d'avance

[bricecol]

tout dépend de l'utilisation de l'objet.

Code :

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

1
2
3
4
5
6
 
new Object();
 
/* quand le constructeur de la classe Object est terminé,
le garbage collector supprime l'objet de la mémoire car plus
rien ne l'utilise ensuite.*/

Code :

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

1
2
3
4
5
6
 
Object o = new Object();
 
/* la variable 'o' pointe désormais sur un objet de type Object.
arrivé à cette ligne, l'objet sera supprimé car la référence 'o'
n'est plus utilisée ensuite.*/

Code :

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

1
2
3
4
5
6
7
8
9
10
 
Object o = new Object();
 
/* ici, l'objet n'est pas supprimé car la référence
à l'objet nommée 'o' est utilisée ci-dessous.*/
 
// affichage de l'objet o
System.out.println(o);
 
// ici l'objet et la référence sont supprimés car plus utilisés.

[nakhon]

Merci bricecol de m'avoir répondu aussi vite.Je comprends mieux maintenant. Merci encore

[slim_java]

salut voila une explication simple . si tu fait Rock r = new Rock() alors tu as un nom pour cette objet crée qui est r et tu peut utiliser ses méthodes s'ils existent plusieurs fois et n'importe quand .
par contre avec new Rock(),tu n'as pas associer un nom a l'objet qui a été crée ,donc tu peut plus l'appeler , voir l'utiliser .
si je résume ,pour un objet crée ,si on va l'utiliser par la suite(modification des attributs,appel des méthodes...) alors en lui associe un nom qui est sa référence (Rock r = new Rock() ) ,sinon on fait juste new nomClasse() comme new Rock()