Discussion :

[denebe]

Bonjour,

Voici un petit exemple (les questions viennent après):

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
class Test{

// variable d'instance
private StringBuffer strB = new StringBuffer();

// méthode d'instance 'abc'
public void abc(){
strB.append("a");
strB.append("b");
strB.append("c");
}

// méthode d'instance 'getteur'
public StringBuffer getStrB(){
return strb;
}

// méthode d'instance 'initialisation'
public initStrB(){
strB.delete( 0,strB.length() )
}
}

+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

class Main{

public static void main(String[] args){

Test monObjet = new Test();

//... une suite d'instructions... par xemple
monObjet.abc();

// initialisation de monObjet.strB (Méthode 1)
monObjet.getStrB().delete( 0,monObjet.getStrB().length() )

// ou bien (Méthode 2)
monObjet.initStrB();

}

}

Dans les deux méthodes ci-dessus, la variable d'instance 'strB' de 'monObjet' est sur la fin initialisée, elle ne contient donc plus de valeurs, sa longueur est nulle.

Questions:

1) est-ce vrai ?
la méthode 2 est mieux car on a pas d'accès direct à la variable, l'initialisation se déroule au sein de la méthode 'initStrB()' de l'objet 'monObjet'.


2) est-ce vrai ?
dans la méthode 1, vu que la référence de l'objet 'monObjet.strB' de type StringBuffer est "divulguée", définir un 'guetteur' n'a aucun intérêt ? (autant accéder directement à la variable d'instance en la déclarant public)

Merci à vous.

[tchize_]

la méthode 2 est mieux car on a pas d'accès direct à la variable, l'initialisation se déroule au sein de la méthode 'initStrB()' de l'objet 'monObjet'.

Elle est surtout mieux car l'appelant n'a pas besoin de savoir comment il doit réinitialiser le buffer. Si demain la règle deviens plus compliquée, l'appelant n'en sera pas affecté

dans la méthode 1, vu que la référence de l'objet 'monObjet.strB' de type StringBuffer est "divulguée", définir un 'guetteur' n'a aucun intérêt

Si tu regarde ton code, bien que l'appelant puisse tripatouiller le Stringbuilder, il ne peux pas le changer pour un nouveau StringBuilder. Donc ta classe Test peut garantir que tous les appelant partageront le même StringBuilder, ce que tu ne peut pas faire avec un champ public.

Bon en pratique ce code serait quand même plus logique:

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
class Test{
 
// variable d'instance
  private StringBuffer strB = new StringBuffer();
 
// méthode d'instance 'abc'
  public void abc(){
    strB.append("a");
    strB.append("b");
    strB.append("c");
  }
 
// méthode d'instance 'getteur'
  public String getStrB(){
    return strB.toString();
  }
 
// méthode d'instance 'initialisation'
  public initStrB(){
    strB = new StringBuffer();
  }
}

[andry.aime]

Bonjour,

Code :

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

1
2
3
4
5
 
// méthode d'instance 'initialisation'
public initStrB(){
strB.delete( 0,strB.length() )
}

Code :

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

1
2
3
4
5
6
7
8
public void initStrB(){  // tu dois spécifier le retour parce que ce n'est pas un constructeur
 // strB.delete( 0,strB.length() ); j'opterai pour d'autres façons
// première façon
strB = new StringBuffer();
// deuxième façon
strB.setLength(0);
strB.trimToSize(); 
}

A+.