façon correcte d'initialiser les variables

Question

ok c'est juste un tir dans l'obscurité mais cela peut être la cause de la plupart des erreurs que j'ai eus.

lors de l'initialisation de quelque chose. disons un petit programme de swing. serait-il aller comme ça

variables here 
{ 
    private Jlist contactList; 
    String [] contactArray; 
    ArrayList <String> contactArrayList; 
    ResultSet namesList 


// constructor here 

public whatever() 
{ 
    GridLayout aGrid = new GridLayout(2,2,10,10); 

    contact1 = new String(); 
    contact2 = new String(); 
    contact3 = new String(); 

    contactArrayList = new ArrayList<String>(); 

// is something supposed too go in the() of this JList? 
    contactList = new JList(); 

    contactArray = new String[5]; 

    from1 =new JLabel ("From: " + contactArray[1]); 



gridlayout.add(components)// theres too many components to write onto SO. 

} 


// methods here 

public void fillContactsGui() 
{ 
    createConnection(); 
ArrayList<String> contactsArrayList = new ArrayList<String>(); 

    while (namesList.next()) 
    { 
     contactArrayList.add(namesList.getString(1)); 
     ContactArray[1] = namesList[1]; 
    } 
} 

Je sais que c'est probablement une énorme question débutant, mais c'est le code utilisé ive obtenu aussi. Im initialiser thigns trois et quatre fois sans signification aussi parce que je ne sais pas où ils gp. Quelqu'un peut-il nous éclairer là-dessus?

p.s. désolé pour le code d'échantillon désordonné. J'ai fait de mon mieux.

---

ok un peu plus clair ici alors.

la disposition générale du code est ce que je demande à propos de.

mon code est formaté comme ceci.

variables; constructeur; méthodes;

Serais-je raison de dire qu'il devrait ressembler à ceci

public class test 
{ 
    int i; 

    public test() 
    { 
    i = 0; 
} 

    public void addi() 
    { 
    i = i +1; 
    } 
} 

et non comme ce

public class test 
{ 
    int i = 0; 

    public test() 
    { 
    int i = 0; 
    } 


    public void addi() 
    { 
    int i = i +1; 
    } 
} 

im essayant de trouver la bonne façon d'initialiser les variables. parce que je les définis chaque fois que je les utilise

Answer 1

Vous devriez généralement initialiser les variables dès que possible - chaque fois que la valeur initiale est connue. Au lieu de

ArrayList<String> contactArrayList; 

considèrent cette

static final int INITIAL_LIST_SIZE = 100; 
List<String> contactArrayList = new ArrayList<String>(INITIAL_LIST_SIZE); 

Voici une liste des default values pour les variables de classe, les variables d'instance ou des composants du tableau.

Addendum: Il est généralement mal vu de dupliquer les initialisations par défaut. Dans votre exemple ultérieur, l'initialisation par défaut définit i sur zéro.

Erratum: Note corrigée commentaire concernant int i = 0 dans le constructeur test, qui cache champ i.

public class test { 

    int i = 0; // superfluous, "int i;" is enough 

    public test() { 
     int i = 0; // hides field i 
    } 

    public void addi() { 
     int i = i + 1; // hides field i; won't increment field i 
    } 
} 

Answer 2

le seul problème de ne pas initialiser les choses est que vous vous laissez ouvert aux exceptions de pointeur nul. idéalement, vous devez initialiser tout ce dont vous avez besoin dans votre constructeur, ainsi vous pouvez être sûr que chaque autre méthode a quelque chose à travailler avec. l'alternative est de vérifier si les choses sont nulles avant d'appeler des méthodes (par exemple if (list != null && list.size() > 0))

Answer 3

Les variables peuvent être initialisées à différents emplacements pour différentes raisons. Par exemple, dans votre exemple de code, vous initialisez toujours votre liste de contacts dans un nouveau JList. Cela pourrait être fait dans la section "variables ici" comme private JList contactList = new JList().Votre contactArrayList semble être normalement basé sur des paramètres passés dans le constructeur, donc les éléments doivent être ajoutés dans le constructeur. Si vous deviez adopter cette approche, le contactArrayList devrait être déclaré final. Cela obligerait tous les constructeurs à initialiser la liste. (Si vous ne voulez pas le déclarer final, vous voudrez l'initialiser à l'heure de la déclaration de la même manière que la liste de contacts.)

Parfois, un champ ne peut pas (ou ne devrait pas) être initialisé avant un instance de la classe a été construite. Dans ces cas, vous devez être très prudent dans la façon dont vous accédez et utilisez le champ pour vous assurer qu'il n'est pas utilisé dans un état non initialisé.

Answer 4

Vous trouverez la réponse à la plupart de vos questions dans ce tutoriel sur Object Initialization in Java.

Vous apprendrez les variables d'instance sont initialisés aux valeurs par défaut en fonction de leur type, quand utiliser initialiseurs statiques, quand utiliser le constructeur, l'initialisation par rapport à l'héritage, etc.

Voici quelques autres ressources dignes :

• Sun's Initialization tutorial
• Initialization chapter of Java in a Nutshell
• Mindprod's Initialization page

Answer 5

Votre dernier exemple - celui avec "public test() {int i = 0; En "redéclarant" la variable "int" dans test et addi, vous avez maintenant trois variables nommées "i": la variable membre définie en haut, une variable locale en test et une autre variable locale La valeur de membre n'est changée par aucune des fonctions

J'éviterais définitivement d'initialiser des variables avec des valeurs factices, comme votre "contact1 = new String()" Oui, cela vous évite d'avoir une erreur de compilation Si vous obtenez une erreur sans cela, cela signifie que vous n'avez pas réussi à placer une valeur réelle dans la variable. C'est comme mettre de la bande sur un voyant lumineux dans votre tableau de bord: Oui, vous ne voyez plus d'avertissement, mais ce n'est pas parce que le problème est résolu, c'est juste parce que vous l'avez couvert en haut

Il y a vraiment des cas où il est logique de définir une valeur par défaut et peut-être que vous la remplacerez par une autre valeur et peut-être que vous ne le ferez pas. Je ne dis pas que c'est une mauvaise pratique. Je dis que si vous obtenez des erreurs pour les variables unitialisées, ne les initialisez pas aveuglément à quelque chose de dénué de sens. Déterminez pourquoi ils n'ont pas de valeur et corrigez le vrai problème. Au-delà, je ne sais pas trop quoi dire de votre exemple. Je ne suis pas sûr de ce que vous essayez d'accomplir. Vous avez des variables nommées contact1, contact2 et contact3 qui ne semblent jamais être utilisées. contactArray est apparemment censé être rempli par fillContactsGui, mais je ne vois pas où il est appelé. Je ne suis pas sûr si ce sont des failles dans votre logique ou si ce n'est qu'un exemple incomplet.

Quant à la bonne façon générale pour initialiser et utiliser les données:

Si une variable peut être locale, faire local. Dans ce cas, idéalement, l'initialiser au moment où vous le déclarez.Comme:

public void foobar() 
{ 
    ... do some stuff ... 
    int i=0; 
    ... do other stuff ... 
    i=i+j; 
    ... etc ... 
} 

il faut éviter le définir puis initialiser plus tard, si possible, car cela crée la possibilité que vous ne parvenez pas à initialiser. Bien sûr, s'il peut être initialisé de deux manières différentes, cela est difficile à éviter. Comme:

public void foobar() 
{ 
    int i; 
    if (plugh>0) 
    i=plugh; 
    ... bunch more logic ... 
    // Inside some IF so we won't even get here if i was set earlier 
    if (zork==true) 
    i=shambar; 
    ... etc ... 
} 

Encore, plus vous pouvez garder ensemble, mieux c'est.