[debutant] question constructeur

Bonjour,

Juste une petite question sans doute bête : y a-t-il une différence (performances, mémoire....) entre :

Code:

---

1 2 3 4 5 6

public Class Personne { String nom=""; String prenom=""; Vector numTel=new Vector(); }

---

et

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13

public Class Personne{ String nom; String prenom; Vector numTel;   Personne(){ this.nom=""; this.prenom=""; this.numTel=new Vector(); }   }

---

A+ merci

Je ne sais pas s'il y a une différence de performance mais la première écriture me paraît plus judicieuse. En effet, prenons le cas

Code:

---

1 2 3 4 5 6 7 8 9 10 11

public class Personne { String nom; String prenom; Vector numTel;   Personne() { this.nom=""; this.prenom=""; this.numTel=new Vector(); } }

---

et maintenant imaginons que l'on etende la classe Personne :

Code:

---

1 2 3 4 5 6 7

public class Enfant extends Personne { String jouetPrefere;   Enfant() { jouetPrefere = ""; } }

---

Dans ce cas on vois bien que les attributs nom, prenom et numTel ne sont pas initialisés.
L'initialisation à la déclaration me paraît beaucoup plus sûre.

Salut,

On m'a toujours appris (peut-être que c'est faux), et j'ai pris ca comme une convention, à ne jamais initialiser les variables de classe lors de leur déclaration mais à toujours les initialiser dans els constructeurs.

le y@m's>
Prenons un exemple concret :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

import javax.swing.*;   public class MaFrame extends JFrame { MaFrame() { }   public static void main(String[] args) { MaFrame m=new MaFrame(); m.setVisible(true); } }

---

Aucun appel a super(), et pourtant ma frame est bien crée. L'appel à super() est implicite il me semble...
Mieux vaut faire la deuxième solution, pour moi c'est la plus propre/claire.

Fred

:oops: effectivement, j'avais oublié l'appel implicite à super() :oops:
mea culpa

Citation:

---

Envoyé par le y@m's

Dans ce cas on vois bien que les attributs nom, prenom et numTel ne sont pas initialisés.

---

Pourtant ils sont bien initialisé : lorsqu'on hérite le constructeur effectue un appel implicite au constructeur de la classe parente.

Et je rappelle que si vous ne déclarer aucun constructeur dans une classe, elle en aura automatiquement un sans paramètre.


Sinon la principale différence pour moi c'est l'ordre d'initialisation : les initialisation à la déclaration seront effectué avant l'appel du constructeur (mais après l'initialisation de la classe parent). Le code suivant le montre bien (la méthode value() sert uniquement à flagger l'initialisation) :

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

class A { String a = Main.value("A.a"); String b; A() { this.b = Main.value("A.b"); } }   class B extends A {   String c = Main.value("B.c"); String d; B() { this.b = Main.value("B.d"); } }     public final class Main {   public static String value(String s) { System.out.println(s); return s; }     public static void main(String[] args) { new B(); } }

---

Ce qui donne :

Code:

---

1 2 3 4

A.a A.b B.c B.d

---

Perso j'utilise l'initialisation en ligne pour des valeurs qui ne sont pas modifiés par le constructeur, et des initialisations dans le constructeur pour les autres (afin d'éviter de créer des objets temporaires inutiles), par exemple :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

public class Personne { String nom; String prenom; // on crée toujours le vecteur : Vector numTel = new Vector();   Personne(){ this("",""); }   Personne(String nom, String prenom) { this.nom = nom; this.prenom = prenom; } }

---

Mais l'initialisation en ligne peut également être utilisé pour des valeurs par défaut...

a++

une fois de plus , merci pour ces indications :-)
a+

(je mets Resolu)