Blocs, portée des noms

images/whitebelt.png

Une instruction se termine par un point-vigule ( ; ) :

instructions. 

   int total = ix + iy + ix ;
   total = im + in + ij
      + ik + il + ip + iq ; // idem mais sur 2 lignes

Les blocs sont des listes d’instructions (et de blocs inclus dans le bloc courant); il sont délimités par des accolades { }.

Des variables locales sont associées à un bloc (elles sont soit définies dans le bloc, soit associée au bloc par un dispositif syntaxique approprié -par exemple par la définition d’un paramètre-). Elles sont en portée syntaxique dans le bloc: elle n’ont aucun sens en dehors du bloc correspondant (Il y a une exception: les blocs de définition d’un type -blocs de "premier niveau"- définissent des variables et des méthodes qui ne sont pas locales).

Portée dans les blocs. 

{ // bloc englobant à l'intérieur d'un code
   int nombre ;
   // du code
   { // bloc interne
      int autreNombre ;
      nombre = 10 ; // correct : "nombre" est en portée syntaxique
      // du code
   } // fin du bloc interne

   autreNombre = 7 /* _compiler_error_ */
   // autreNombre  n'est pas en portée syntaxique

} // fin bloc englobant

Portée définie par un autre dispositif syntaxique. 

   //  les paramètres des méthodes sont en portée dans le bloc associé
   void service(int parm_) {
      int x = parm_ ; // OK
   }

   void autreService( int autreParm_) {
      int x = parm_ ; /* _compiler_error_ */
      // parm_ est hors de portée
   }

Les membres et les constructeurs ont des règles de portée différentes et, dans ce cas, il existe des modificateurs de portée: public private protected (ce point sera revu ultérieurement).

--exercices--

Typage implicite de variables locales

Normalement java a pour principe fondateur de typer explicitement les variables. Au cours des évolutions du langage il y a eu toutefois des exceptions qui ont été introduites.

  • Nous verrons ultérieurement le cas des typages implicites avec les fermetures
  • A partir de java 10 il est possible de laisser le compilateur déduire le type d’une variable locale (pas d’une variable membre!). Une déclaration de variable avec var suivie d’une initialisation permet au compilateur de créer un symbole (association nom-type).
   public void methode(int arg) {
      //facile!
     var valeurParDéfaut = 666 ;
   }

L’exemple ci-dessus ne présente bien entendu aucun intérêt mais nous verrons ultérieurement des types plus complexes (types paramétrés par ex. ou types anomymes sans représentation - dits "non denotables" - ) pour lesquels cette facilité a l’avantage de simplifier l'écriture (et l’inconvénient de parfois troubler le programmeur pour qui une incompatibilité ne sera évidente de prime abord!).