Discussion :

[francky74]

Ah !?!
Les static final sont des variables ???? je pensais que c'était des constantes quand il y a le mot clé final !

[joel.drigo]

Non, je n'ai pas dit que les "static final" sont des variables ou pas. Je parlais des attributs de ta classes, qui sont seulement final et pas static.

Si tu préfères le choix entre le lowerCamelCase et le UPPER_CASE ne dépend que de la présence des modifiers combinés "static final" (UPPER_CASE).

Cette terminologie d'usage (constante ou variable, etc...) est une terminologie usuelle, dans laquelle :

• constante pour beaucoup correspond à static final (bien que certains considèrent que constante est plus adapté aux valeurs litéralles) ;
• et variable aux autres.

Si on prend la documentation (ou celle-là) de Java : tout est "variable".

Le mot-clef final rend juste une variable non-mutable (non-modifiable), non réellement constante (elle est constante pendant l'exécution du programme, mais ne l'est pas réellement, puisqu'elle peut prendre une autre valeur pour une autre exécution). Rigoureusement 42 est une constante, la constante de Planck est une constante, etc.

[thelvin]

Ouais, sauf que la notion de constante existe bel et bien en Java.

C'est une variable :

• final
• de type primitif ou String
• déclarée et initialisée dans la même instruction
• initialisée par une expression constante. Les expressions constantes étant composées :
  
  • de littéraux (1, 17, "Bonjour", false)
  • d'autres constantes (si var est une constante, alors l'appeler est une expression constante)
  • d'opérateurs sur des expressions constantes (si var est une constante, alors 2 + var + 8 est une expression constante)

Cette notion existe pour définir précisément les variables dont la valeur est connue du compilateur, donc à la compilation et avant l'exécution.
Elle annonce quand le compilateur va faire certaines optimisations comparé à d'autres cas.
Par exemple, si var est une constante et qu'on essaie de calculer 2 + var + 8, ce calcul sera fait à la compilation, et remplacé par son résultat dans le binaire compilé. À l'exécution ce calcul ne sera pas fait, parce que le résultat est déjà connu depuis la compilation.

Tout ça pour dire ce que c'est qu'une constante au sens Java.


Et malheureusement cela ne suit pas exactement les conventions de codage ALL_CAPS.
Normalement on applique le ALL_CAPS sur les variables :

• static final
• initialisées avec une valeur prédictible (qui ne dépend pas de l'heure qu'il est ou d'un effet de bord d'une autre partie du programme.) Cela n'est pas vérifiable par le compilateur, c'est jugé par le programmeur.
• immutables ou immutées. Cela n'est pas vérifiable par le compilateur, c'est jugé par le programmeur.

Exemple : public static final MonthDay NOEL = MonthDay.of(12, 25); .

Ces choses-là sont "grosso-modo des constantes pendant qu'on programme," mais pas forcément des constantes au sens Java.
Notamment, une constante Java n'est pas tenue d'être static.
Et aussi, une variable static final n'est pas forcément une constante Java.

Du coup, c'est une habitude à prendre, mais il y a une certaine confusion avec les constantes.

[francky74]

Je n'arrive pas à comprendre une chose au sujet de ces variables (prenons par exemple BORNE_MIN) :
Il me semble bien que si je mets BORNE_MIN en static, cette constante devient une constante de classe, et toutes les instances pointerons vers la même constante BORNE_MIN et le fait de modifier cette même constante depuis n'importe quelle autre instance devrait avoir pour effet de modifier la valeur de cette constante pour toute les instances. En d'autres termes, les instances ne se partagerons qu'une seule constante.
Or, ce qui est recherché est plutôt d'avoir la BORNE_MIN contenant une valeur différente pour chaque instance.

Donc, d'après ce que je comprends, ces constantes ne devraient pas être static.

D'ailleurs, lorsque je mets static final, eclipse me demande d'initialiser la constante dans la déclaration et me demande aussi de virer le mot clé final pour pouvoir l'initialiser dans le constructeur.


De plus, je ne comprends pas non plus l'utilité de la méthode hashCode (à laquelle j'ai rajouté les booléens) car je n'arrive pas à entrer dans le code de la méthode Objects.hash() lors de debug. En fait elle retourne un résultat que je ne parviens pas à analyser ni à anticiper.

Merci

[francky74]

Du coup, c'est une habitude à prendre, mais il y a une certaine confusion avec les constantes.

Bon, je pense me rapprocher de la vérité et j'espère que cela deviendra une habitude !

En fait, comme nous pouvons créer plusieurs instances de la classe Intervalle, il faut bien que les bornes de chaque instance puissent être personnalisées à la création de l'intervalle.
Dans le sens de cette réflexion, je dirais donc que les bornes ne sont pas des constantes de classes, mais plutôt des constantes d'instances -> donc pas de static final mais du final simplement -> donc du lowerCase !

Je vous remercie pour vos interventions qui transforment ce sujet en cours précis et d'un grand intérêt !

Donc, j'ai de nouveau transformé cette classe Intervalle comme ceci :

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
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
import java.util.Arrays;
import java.util.Objects;
 
public class Intervalle {
	//**************************DECLARATIONS
	private final int borneMin;
	private final int borneMax;
	private final boolean isMinIncluded, isMaxIncluded;
 
	//**************************CONSTRUCTEURS
	//constructeur dont les bornes sont toutes incluses par défaut
	public Intervalle(int borneMin, int borneMax){
		this(borneMin, true, borneMax, true);
	}
 
	//constructeur permettant d'inclure ou exclure les deux bornes en même temps
	public Intervalle(int borneMin, int borneMax, boolean isAllIncluded) {
		this(borneMin, isAllIncluded, borneMax, isAllIncluded);
	}
 
	//constructeur permettant d'inclure ou exclure chaque borne séparément
	public Intervalle(int borneMin, boolean isMinIncluded, int borneMax, boolean isMaxIncluded){
		if(borneMin > borneMax){throw new IllegalArgumentException(" borneMin > borneMax ");}
 
		this.borneMin = borneMin;
		this.borneMax = borneMax;
		this.isMinIncluded = isMinIncluded;
		this.isMaxIncluded = isMaxIncluded;
	}
 
	//**************************METHODES
	public int hashCode() {
	    return Objects.hash(borneMin, borneMax, isMinIncluded, isMaxIncluded);
	}
 
	public boolean equals(Object obj) {
	     if ( obj!=null && Intervalle.class.equals(obj.getClass()) ) {
	         return equals((Intervalle)obj);
	     }
	     else { 
	         return false;
	     }
	}
 
	protected final boolean equals(Intervalle intervalle) {
	      return intervalle.borneMin == this.borneMin && intervalle.borneMax == this.borneMax && intervalle.isMinIncluded == this.isMinIncluded && intervalle.isMaxIncluded == this.isMaxIncluded;
	}
 
	public int[] rangeTabInt(int[] tableau){
 
		int[] tab;
 
		//on définit la longueur du tableau selon si les bornes sont inclues ou exclues
		if(isMinIncluded == true && isMaxIncluded == true){
			tab = new int[(borneMax - borneMin)];
			tab = Arrays.copyOfRange(tableau, borneMin, borneMax);
		} else if (isMinIncluded == false && isMaxIncluded == false){
			tab = new int[(borneMax - borneMin - 2)];
			tab = Arrays.copyOfRange(tableau, borneMin + 1, borneMax - 1);
		} else if (isMinIncluded == false && isMaxIncluded == true){
			tab = new int[(borneMax - borneMin - 1)];
			tab = Arrays.copyOfRange(tableau, borneMin + 1, borneMax);
		} else if (isMinIncluded == true && isMaxIncluded == false){
			tab = new int[(borneMax - borneMin - 1)];
			tab = Arrays.copyOfRange(tableau, borneMin, borneMax - 1);
		} else {
			throw new IllegalArgumentException(" problème d'inclusion exclusion des bornes ");
		}
 
		return tab;
	}
 
	//**************************GETTERS
	public int getBorneMin() {return borneMin;}
	public int getBorneMax() {return borneMax;}
	public boolean isMinIncluded() {return isMinIncluded;}
	public boolean isMaxIncluded() {return isMaxIncluded;}
}

[thelvin]

[...]

Donc, d'après ce que je comprends, ces constantes ne devraient pas être static.

D'ailleurs, lorsque je mets static final, eclipse me demande d'initialiser la constante dans la déclaration et me demande aussi de virer le mot clé final pour pouvoir l'initialiser dans le constructeur.

Une classe ne peut pas modifier la valeur d'une constante, c'est un peu le principe.

Mais sinon, oui, en effet. Ces variables ne doivent absolument pas être static.
Et donc elles ne doivent pas être en ALL_CAPS et plutôt s'appeler borneMin.

De plus, je ne comprends pas non plus l'utilité de la méthode hashCode (à laquelle j'ai rajouté les booléens) car je n'arrive pas à entrer dans le code de la méthode Objects.hash() lors de debug. En fait elle retourne un résultat que je ne parviens pas à analyser ni à anticiper.

Ben, comme le dit son nom, elle renvoie un code de hashing.

La FAQ explique pourquoi et comment redéfinir la méthode hashCode()

En résumé, ça travaille de pair avec la méthode equals() si un jour tu utilises tes intervalles dans un HashMap, HashSet ou similaire. Un appel à hashCode() fournit un nombre qui sera forcément le même pour deux intervalles égaux. Ce nombre permet de situer l'objet dans une table de hachage. Une fois cela fait, equals() permet de vérifier si ce qu'on trouve à cet endroit est bien un intervalle égal.

[joel.drigo]

Ouais, sauf que la notion de constante existe bel et bien en Java.

Je ne dis pas le contraire, mais que cette désignation "constante", qu'on utilise dans le langage courant, porte à confusion. En particulier, si on dit que les constantes doivent par convention être en UPPER_CASE (ou ALL_CAPS comme tu dis), alors qu'une "final" non "static" ne doit pas l'être. La documentation parle d'ailleurs de "constant variable".