Java Language Expressions constantes


Exemple

Une expression constante est une expression qui donne un type primitif ou une chaîne et dont la valeur peut être évaluée au moment de la compilation en un littéral. L'expression doit être évaluée sans lancer une exception et doit être composée uniquement des éléments suivants:

  • Littéraux primitifs et de chaînes.

  • Tapez sur les types primitifs ou sur String .

  • Les opérateurs unaires suivants: + , - , ~ et ! .

  • Les opérateurs binaires suivants: * , / , % , + , - , << , >> , >>> , < , <= , > , >= , == != , & , ^ , | , && et || .

  • L'opérateur conditionnel ternaire ? : .

  • Expressions constantes entre parenthèses.

  • Noms simples faisant référence à des variables constantes. (Une variable constante est une variable déclarée comme final lorsque l'expression d'initialisation est elle-même une expression constante.)

  • Noms qualifiés du formulaire <TypeName> . <Identifier> qui fait référence à des variables constantes.

Notez que la liste ci-dessus exclut ++ et -- , les opérateurs d'affectation, class et instanceof , les appels de méthodes et les références aux variables générales ou aux champs.

Les expressions constantes de type String résultat dans un « interné » String et opérations en virgule flottante dans les expressions constantes sont évaluées avec la sémantique FP stricte.

Utilisations pour les expressions constantes

Des expressions constantes peuvent être utilisées (à peu près) partout où une expression normale peut être utilisée. Cependant, ils ont une signification particulière dans les contextes suivants.

Les expressions constantes sont requises pour les étiquettes de cas dans les instructions switch. Par exemple:

switch (someValue) {
case 1 + 1:            // OK
case Math.min(2, 3):   // Error - not a constant expression
    doSomething();
}

Lorsque l'expression sur le côté droit d'une affectation est une expression constante, l'affectation peut effectuer une conversion restrictive primitive. Ceci est autorisé à condition que la valeur de l'expression constante se situe dans la plage du type sur le côté gauche. (Voir JLS 5.1.3 et 5.2 ) Par exemple:

byte b1 = 1 + 1;             // OK - primitive narrowing conversion.
byte b2 = 127 + 1;           // Error - out of range
byte b3 = b1 + 1;            // Error - not a constant expession
byte b4 = (byte) (b1 + 1);   // OK

Lorsqu'une expression constante est utilisée comme condition dans un do , while ou for , cela affecte l'analyse de lisibilité. Par exemple:

while (false) {
    doSomething();           // Error - statenent not reachable
}
boolean flag = false;
while (flag) {
    doSomething();           // OK
}

(Notez que ceci ne s'applique pas aux instructions if . Le compilateur Java permet que le bloc then ou else d'une instruction if soit inaccessible. Il s'agit de l'analogue Java de la compilation conditionnelle en C et C ++.)

Enfin, static final champs static final une classe ou d'une interface avec des initialiseurs d'expression constante sont initialisés avec impatience. Ainsi, il est garanti que ces constantes seront observées dans l'état initialisé, même s'il existe un cycle dans le graphe de dépendance d'initialisation de classe.

Pour plus d'informations, reportez-vous à JLS 15.28. Expressions constantes