Cours apprentissage du langage JAVA

Introduction

Ce document est un support de cours : ce n'est pas un cours complet. Des approfondissements nécessitent l'aide d'un enseignant.

L'étudiant y trouvera cependant une grande quantité d'informations lui permettant la plupart du temps de travailler seul. Ce document comporte probablement des erreurs : toute suggestion constructive est la bienvenue à l'adresse . 

Il existe d'excellents livres sur Java. Parmi ceux-ci :

1. Programmer en Java de Claude Delannoy aux éditions Eyrolles
2. Java client-serveur de Cédric Nicolas, Christophe Avare, Frédéric Najman chez Eyrolles.

Le premier livre est un excellent ouvrage d'introduction pédagogique au langage Java. Une fois acquis son contenu, on pourra passer au second ouvrage qui présente des aspects plus avancés de Java (Java Beans, JDBC, Corba/Rmi). Il présente une vue industrielle de Java intéressante. Pour approfondir Java dans différents domaines, on pourra se référer à la collection "Java series" chez O'Reilly. Pour une utilisation professionnelle de Java au sein d'une plate-forme J2EE on pourra lire :

… … …

1. Les bases du langage Java

Nous traitons Java d'abord comme un langage de programmation classique. Nous aborderons les objets ultérieurement.

Dans un programme on trouve deux choses 

-         des données

-         les instructions qui les manipulent

On s'efforce généralement de séparer les données des instructions :

               +--------------------+

               ¦      DONNEES       ¦

               +--------------------¦

               ¦                    ¦

               ¦      INSTRUCTIONS  ¦

               ¦                    ¦

               +--------------------+

1.2 Les données de Java

Java utilise les types de données suivants:

• •  les nombres entiers 
• •  les nombres réels
• •  les caractères et chaînes de caractères
• •  les booléens
• •  les objets

1.2.1 Les types de données prédéfinis

Type

char                                 2 octets                                 caractère Unicode

int                                  4 octets                                 [-2^31,  2³¹-1]

long 8 octets [-2^63,  2⁶³ -1] byte 1 octet [-2⁷ , 2⁷ -1]

short                                2 octets                                 [-2^15,  2¹⁵-1]

float                                4 octets                                 [3.4 10^-38,  3.4 10⁺³⁸] en valeur absolue

double                               8 octets                                 [1.7 10^-308 , 1.7 10⁺³⁰⁸] en valeur absolue

boolean                              1 bit                                       true, false

String                               référence d'objet                  chaîne de caractères

Date                                référence d'objet                  date

Character        référence d'objet   char Integer              référence d'objet         int Long référence d'objet   long

Byte                                référence d'objet                  byte

Float                                référence d'objet                  float

Double                              référence d'objet                  double

Boolean          référence d'objet   boolean 

1.2.2 Notation des données littérales

1.2.3 Déclaration des données

1.2.3.1 Rôle des déclarations

Un programme manipule des données caractérisées par un nom et un type. Ces données sont stockées en mémoire. Au moment de la traduction du programme, le compilateur affecte à chaque donnée un emplacement en mémoire caractérisé par une adresse et une taille. Il le fait en s'aidant des déclarations faites par le programmeur.

Par ailleurs celles-ci permettent au compilateur de détecter des erreurs de programmation. Ainsi l'opération    x=x*2;  sera déclarée erronée si x est une chaîne de caractères par exemple.

1.2.3.2 Déclaration des constantes

La syntaxe de déclaration d'une constante est la suivante :

final type nom=valeur;    //définit constante nom=valeur

ex : final float PI=3.141592F; 

Remarque

Pourquoi déclarer des constantes ? 

1. La lecture du programme sera plus aisée si l'on a donné à la constante un nom significatif :

 ex : final float taux_tva=0.186F;

2. La modification du programme sera plus aisée si la "constante" vient à changer. Ainsi dans le cas précédent, si le taux de tva passe à 33%, la seule modification à faire sera de modifier l'instruction définissant sa valeur :

final float taux_tva=0.33F;

 Si l'on avait utilisé 0.186 explicitement dans le programme, ce serait alors de nombreuses instructions qu'il faudrait modifier.

1.2.3.3 Déclaration des variables

Une variable est identifiée par un nom et se rapporte à un type de données. Le nom d'une variable Java a n caractères, le premier alphabétique, les autres alphabétiques ou numériques. Java fait la différence entre majuscules et minuscules. Ainsi les variables FIN et fin sont différentes.

Les variables peuvent être initialisées lors de leur déclaration. La syntaxe de déclaration d'une ou plusieurs variables est :

identificateur_de_type variable1,variable2, ,variablen;

où identificateur_de_type est un type prédéfini ou bien un type objet défini par le programmeur. 

1.2.4 Les conversions entre nombres et chaînes de caractères

nombre -> chaîne        "" + nombre

chaine -> int    Integer.parseInt(chaine)

chaîne -> long Long.parseLong(chaine)

chaîne -> double         Double.valueOf(chaine).doubleValue()

chaîne -> float            Float.valueOf(chaine).floatValue()

Voici un programme présentant les principales techniques de conversion entre nombres et chaînes de caractères. La conversion d'une chaîne vers un nombre peut échouer si la chaîne ne représente pas un nombre valide. Il y a alors génération d'une erreur fatale appelée exception en Java. Cette erreur peut être gérée par la clause try/catch suivante :

try{

 appel de la fonction susceptible de générer l'exception

} catch (Exception e){  traiter l'exception e

}

instruction suivante

Si la fonction ne génère pas d'exception, on passe alors à instruction suivante, sinon on passe dans le corps de la clause catch puis à instruction suivante. Nous reviendrons ultérieurement sur la gestion des exceptions.

import .*;

public class conv1{

  public static void main(String arg[]){     String S;     final int i=10;     final long l=100000;     final float f=(float)45.78;     double d=-14.98;

    // nombre --> chaîne     S=""+i;     affiche(S);     S=""+l;     affiche(S);     S=""+f;     affiche(S);     S=""+d;     affiche(S);

    //boolean --> chaîne     final boolean b=false;     S=""+new Boolean(b);     affiche(S);

    // chaîne --> int     int i1;

    i1=Integer.parseInt("10");     affiche(""+i1);     try{

      i1=Integer.parseInt("10.67");       affiche(""+i1);     } catch (Exception e){       affiche("Erreur "+e);

    }

    // chaîne --> long     long l1;

    l1=Long.parseLong("100");     affiche(""+l1);     try{

      l1=Long.parseLong("10.675");       affiche(""+l1);     } catch (Exception e){       affiche("Erreur "+e);

    }

    // chaîne --> double     double d1;

    d1=Double.valueOf("100.87").doubleValue();     affiche(""+d1);     try{

      d1=Double.valueOf("abcd").doubleValue();       affiche(""+d1);     } catch (Exception e){       affiche("Erreur "+e);

    }

    // chaîne --> float     float f1;

    f1=Float.valueOf("100.87").floatValue();     affiche(""+f1);     try{

      d1=Float.valueOf("abcd").floatValue();       affiche(""+f1);

    } catch (Exception e){       affiche("Erreur "+e);

    }

}// fin main

  public static void affiche(String S){

    .println("S="+S);

  }

}// fin classe

Les résultats obtenus sont les suivants :

S=10

S=100000

S=45.78

S=-14.98

S=false

S=10

S=Erreur .NumberFormatException: 10.67

S=100

S=Erreur .NumberFormatException: 10.675

S=100.87

S=Erreur .NumberFormatException: abcd S=100.87

S=Erreur .NumberFormatException: abcd

1.2.5 Les tableaux de données

Un tableau Java est un objet permettant de rassembler sous un même identificateur des données de même type. Sa déclaration est la suivante :

Type Tableau[]=new Type[n] ou Type[] Tableau=new Type[n]

Les deux syntaxes sont légales. n est le nombre de données que peut contenir le tableau. La syntaxe Tableau[i] désigne la donnée n° i où i appartient à l'intervalle [0,n-1]. Toute référence à la donnée Tableau[i] où i n'appartient pas à l'intervalle [0,n1]provoquera une exception.

Un tableau à deux dimensions pourra être déclaré comme suit :

Type Tableau[][]=new Type[n][p] ou Type[][] Tableau=new Type[n][p]

La syntaxe Tableau[i]désigne la donnée n° i de Tableau où i appartient à l'intervalle [0,n-1]. Tableau[i] est lui-même un tableau : Tableau[i][j]désigne la donnée n° j de Tableau[i] où j appartient à l'intervalle [0,p-1]. Toute référence à une donnée de Tableau avec des index incorrects génère une erreur fatale.

Voici un exemple :

public class test1{

  public static void main(String arg[]){     float[][] taux=new float[2][2];     taux[1][0]=0.24F;     taux[1][1]=0.33F;

    .println(taux[1].length);

    .println(taux[1][1]);

  } }

et les résultats de l'exécution :

2

0.33

Un tableau est un objet possédant l'attribut length : c'est la taille du tableau.

1.3 Les instructions élémentaires de Java

On distingue

1      les instructions élémentaires exécutées par l'ordinateur.

2      les instructions de contrôle du déroulement du programme.

Les instructions élémentaires apparaissent clairement lorsqu'on considère la structure d'un micro-ordinateur et de ses périphériques.  

1. C      MEMOIRE          ECRAN   

                          +-------------------+      +-------+ 

                          ¦   2  <-+-->       ¦  3   ¦       ¦

  +-----------+    1      ¦        ¦      ----+------+->     ¦

  ¦ CLAVIER   +-----------+--------+-->       ¦      ¦       ¦

  +-----------+           +-------------------+      +-------+

                                            4^                

                                              \         

                                               \ 5     +-------+ 

                                                \ ---->¦       ¦

                                                       ¦ DISQUE¦

                                                        +-------+

1. lecture d'informations provenant du clavier
2. traitement d'informations
3. écriture d'informations à l'écran
4. lecture d'informations provenant d'un fichier disque
5. écriture d'informations dans un fichier disque

1.3.1 Ecriture sur écran

La syntaxe de l'instruction d'écriture sur l'écran est la suivante :

.println(expression) ou .println(expression)

où expression est tout type de donnée qui puisse être converti en chaîne de caractères pour être affiché à l'écran. Dans l'exemple précédent, nous avons vu deux instructions d'écriture :

.println(taux[1].length);

.println(taux[1][1]);

écrit dans un fichier texte qui est par défaut l'écran. Il en est de même pour . Ces fichiers portent un numéro (ou descripteur) respectivement 1 et 2. Le flux d'entrée du clavier () est également considéré comme un fichier texte, de descripteur 0. Dos comme Unix supportent le tubage (pipe) de commandes :

 commande1 | commande2

Tout ce que commande1 écrit avec est tubé (redirigé) vers l'entrée de commande2. Dit autrement, commande2 lit avec , les données produites par commande2 avec  qui ne sont donc plus affichées à l'écran. Ce système est très utilisé sous Unix. Dans ce tubage, le flux n'est lui pas redirigé : il écrit sur l'écran. C'est pourquoi il est utilisé pour écrire les messages d'erreurs (d'où son nom err) : on est assuré que lors d'un tubage de commandes, les messages d'erreur continueront à s'afficher à l'écran. On prendra donc l'habitude d'écrire les messages d'erreur à l'écran avec le flux plutôt qu'avec le flux .

1.3.2 Lecture de données tapées au clavier

Le flux de données provenant du clavier est désigné par l'objet de type InputStream. Ce type d'objets permet de lire des données caractère par caractère. C'est au programmeur de retrouver ensuite dans ce flux de caractères les informations qui l'intéressent. Le type InputStream ne permet pas de lire d'un seul coup une ligne de texte. Le type BufferedReader le permet avec la méthode readLine.

Afin de pouvoir lire des lignes de texte tapées au clavier, on crée à partir du flux d'entrée de type InputStream, un autre flux d'entrée de type BufferedReader cette fois :

BufferedReader IN=new BufferedReader(new InputStreamReader());

Nous n'expliquerons pas ici les détails de cette instruction qui fait intervenir la notion de constructions d'objets. Nous l'utiliserons telle-quelle.

La construction d'un flux peut échouer : une erreur fatale, appelée exception en Java, est alors générée. A chaque fois qu'une méthode est susceptible de générer une exception, le compilateur Java exige qu'elle soit gérée par le programmeur. Aussi, pour créer le flux d'entrée précédent, il faudra en réalité écrire :

BufferedReader IN=null; try{

IN=new BufferedReader(new InputStreamReader());

} catch (Exception e){

  .println("Erreur " +e);

  (1);

}

De nouveau, on ne cherchera pas à expliquer ici la gestion des exceptions. Une fois le flux IN précédent construit, on peut lire une ligne de texte par l'instruction :

 String ligne;  ligne=IN.readLine();

La ligne tapée au clavier est rangée dans la variable ligne et peut ensuite être exploitée par le programme.

1.3.3 Exemple d'entrées-sorties

Voici un programme d'illustration des opérations d'entrées-sorties clavier/écran :

import .*;  // nécessaire pour l'utilisation de flux d'E/S

public class io1{

  public static void main (String[] arg){

    // écriture sur le flux

    Object obj=new Object();

    .println(""+obj);

    .println(obj.getClass().getName());

    // écriture sur le flux      int i=10;

    .println("i="+i);

    // lecture d'une ligne saisie au clavier

    String ligne;

    BufferedReader IN=null;     try{

      IN=new BufferedReader(new InputStreamReader());

    } catch (Exception e){       affiche(e);       (1);

    }

    .print("Tapez une ligne : ");     try{

      ligne=IN.readLine();

      .println("ligne="+ligne);

    } catch (Exception e){       affiche(e);       (2);

    }

  }//fin main

  public static void affiche(Exception e){

    .println("Erreur : "+e);

  }

}//fin classe

et les résultats de l'exécution : 

C:\Serge\java\bases\iostream>java io1 .Object@1ee78b .Object i=10

Tapez une ligne : je suis là ligne=je suis là

Les instructions 

Object obj=new Object();

.println(""+obj);

.println(obj.getClass().getName());

ont pour but de montrer que n'importe quel objet peut faire l'objet d'un affichage. Nous ne chercherons pas ici à expliquer la signification de ce qui est affiché. Nous avons également l'affichage de la valeur d'un objet dans le bloc :

try{

      IN=new BufferedReader(new InputStreamReader());

    } catch (Exception e){       affiche(e);       (1);

    }

La variable e est un objet de type Exception qu'on affiche ici avec l'appel affiche(e). Nous avions rencontré, sans en parler, cet affichage de la valeur d'une exception dans le programme de conversion vu plus haut.

1.3.4 Affectation de la valeur d'une expression à une variable

On s'intéresse ici à l'opération  variable=expression;

 L'expression peut être de type :  arithmétique, relationnelle, booléenne, caractères

1.3.4.1 Interprétation de l'opération d'affectation

L'opération  variable=expression; est elle-même une expression dont l'évaluation se déroule de la façon suivante :

• •    La partie droite de l'affectation est évaluée : le résultat est une valeur V.
• •    la valeur V est affectée à la variable
• •    la valeur V est aussi la valeur de l'affectation vue cette fois en tant qu'expression.

C'est ainsi que l'opération V1=V2=expression est légale. A cause de la priorité, c'est l'opérateur = le plus à droite qui va être évalué.  On a donc V1=(V2=expression). L'expression V2=expression est évaluée et a pour valeur V. L'évaluation de cette expression a provoqué l'affectation de V à V2. L'opérateur = suivant est alors évalué sous la forme  V1=V. La valeur de cette expression est encore V. Son évaluation provoque l'affectation de V à V1. Ainsi donc, l'opération  V1=V2=expression est une expression dont l'évaluation

1              provoque l'affectation de la valeur de expression aux variables V1 et V2 2                 rend comme résultat la valeur de expression.

On peut généraliser à une expresion du type :  V1=V2= .=Vn=expression

1.3.4.2 Expression arithmétique

Les opérateurs des expressions arithmétiques sont les suivants :

+             addition

-              soustraction

*              multiplication

/ division : le résultat est le quotient exact si l'un au moins des opérandes est réel. Si les deux opérandes sont entiers le résultat est le quotient entier. Ainsi 5/2 -> 2 et 5.0/2 ->2.5.

%            division : le résultat est le reste quelque soit la nature des opérandes, le quotient étant lui entier. C'est donc l'opération modulo.

Il existe diverses fonctions mathématiques :

double sqrt(double x) racine carrée

double cos(double x)  Cosinus

double sin(double x)  Sinus

double tan(double x)  Tangente

double pow(double x,double y)        x à la puissance y (x>0)

double exp(double x) Exponentielle

double log(double x)  Logarithme népérien

double abs(double x)  valeur absolue

etc

Toutes ces fonctions sont définies dans une classe Java appelée Math. Lorsqu'on les utilise, il faut les préfixer avec le nom de la classe où elles sont définies. Ainsi on écrira :

La définition de la classe Math est la suivante :  

public  final  class       extends  .Object  (I-§1.12)

{

        // Fields

    public final static double E; §1.10.1     public final static double PI; §1.10.2

        // Methods

    public static double abs(double  a); §1.10.3     public static float abs(float  a); §1.10.4     public static int abs(int  a); §1.10.5     public static long abs(long  a); §1.10.6     public static double acos(double  a); §1.10.7     public static double asin(double  a); §1.10.8     public static double atan(double  a); §1.10.9

    public static double atan2(double  a, double  b); §1.10.10     public static double ceil(double  a); §1.10.11     public static double cos(double  a); §1.10.12     public static double exp(double  a); §1.10.13     public static double floor(double  a); §1.10.14     public static double                        §1.10.15         IEEEremainder(double  f1, double  f2);     public static double log(double  a); §1.10.16

    public static double max(double  a, double  b); §1.10.17     public static float max(float  a, float  b); §1.10.18     public static int max(int  a, int  b); §1.10.19     public static long max(long  a, long  b); §1.10.20     public static double min(double  a, double  b);  §1.10.21     public static float min(float  a, float  b); §1.10.22     public static int min(int  a, int  b); §1.10.23     public static long min(long  a, long  b); §1.10.24     public static double pow(double  a, double  b); §1.10.25     public static double random(); §1.10.26     public static double rint(double  a); §1.10.27     public static long round(double  a); §1.10.28     public static int round(float  a); §1.10.29     public static double sin(double  a); §1.10.30     public static double sqrt(double  a); §1.10.31     public static double tan(double  a); §1.10.32 }

1.3.4.3 Priorités dans l'évaluation des expressions arithmétiques

La priorité des opérateurs lors de l'évaluation d'une expression arithmétique est la suivante (du plus prioritaire au moins prioritaire) :

[fonctions], [ ( )],[ *, /, %], [+, -]

Les opérateurs d'un même bloc [ ] ont même priorité.  

1.3.4.4 Expressions relationnelles

Les opérateurs sont les suivants :  <, <=, ==, !=, >, >=

ordre de priorité            >, >=, <, <=

           ==, !=

Le résultat d'une expression relationnelle est le booléen false  si expression est faussetrue sinon.

Exemple :

      boolean fin;       int x;       fin=x>4;

Comparaison de deux caractères

Soient deux caractères C1 et C2. Il est possible de les comparer avec les opérateurs 

 <, <=, ==, !=, >, >=

Ce sont alors leurs codes ASCII, qui sont des nombres, qui sont alors comparés. On rappelle que selon l'ordre ASCII on a les relations suivantes : espace < .. < '0' < '1' < .. < '9' < .. < 'A' < 'B' < .. < 'Z' < .. < 'a' < 'b' < .. <'z'

Comparaison de deux chaînes de caractères

Elles sont comparées caractère par caractère. La première inégalité rencontrée entre deux caractères induit une inégalité de même sens sur les chaînes.

Exemples :

Soit à comparer les chaînes "Chat" et "Chien"

 "Chat" "Chien"

 -----------------------

 'C' = 'C'

 'h' = 'h'

 'a' < 'i'

Cette dernière inégalité permet de dire que "Chat" < "Chien".

Soit à comparer les chaînes "Chat" et "Chaton". Il y a égalité tout le temps jusqu'à épuisement de la chaîne "Chat". Dans ce cas, la chaîne épuisée est déclarée la plus "petite". On a donc la relation   "Chat" < "Chaton".

Fonctions de comparaisons de deux chaînes

On ne peut utiliser ici les opérateurs relationnels <, <=, ==, !=, >, >= . Il faut utiliser des méthodes de la classe String :

String chaine1, chaine2; chaine1=…; chaine2=…;

int i=chaine1.compareTo(chaine2); boolean egal=chaine1.equals(chaine2)

Ci-dessus, la variable i aura la valeur :

0   si les deux chaînes sont égales

1   si chaîne n°1 > chaîne n°2                -1 si chaîne n°1 < chaîne n°2

La variable egal aura la valeur true si les deux chaînes sont égales.

1.3.4.5 Expressions booléennes

Les opérateurs   sont & (and)||(or) et ! (not). Le résultat d'une expression booléenne est un booléen.

ordre de priorité   ! ,  &&, ||

exemple :

int fin; int x; fin= x>2 && x<4;

Les opérateurs relationnels ont priorité sur les opérateurs && et ||.

1.3.4.6 Traitement de bits

Les opérateurs

Soient i et j deux entiers.

i< décale i de n bits sur la gauche. Les bits entrants sont des zéros.

i>>n décale i de n bits sur la droite. Si i est un entier signé (signed char, int, long) le bit de signe est préservé.

i & j        fait le ET logique de i et j bit à bit. i | j                 fait le OU logique de i et j bit à bit.

~i            complémente i à 1

i^j            fait le OU EXCLUSIF de i et j

Soit 

opération

i< 0x23F0 i>>4         0x0123  le bit de signe est préservé.

k>>4               0xFF12  le bit de signe est préservé. i&j        0x1023

i|j             0xF33F

~i 0xEDC0          

1.3.4.7 Combinaison d'opérateurs

       a=a+b peut s'écrire a+=b

       a=a-b peut s'écrire a-=b

Il en est de même avec les opérateurs /, %,* ,<<, >>, &, |, ^

 Ainsi  a=a+2; peut s'écrire a+=2;

1.3.4.8 Opérateurs d'incrémentation et de décrémentation

La notation variable++ signifie variable=variable+1 ou encore variable+=1 La notation variable-- signifie variable=variable-1 ou encore variable-=1.

1.3.4.9 L'opérateur ?

L'expression expr_cond ? expr1:expr2 est évaluée de la façon suivante :

1              l'expression expr_cond est évaluée. C'est une expression conditionnelle à valeur vrai ou faux  2                 Si elle est vraie, la valeur de l'expression est celle de expr1. expr2 n'est pas évaluée.

3              Si elle est fausse, c'est l'inverse qui se produit : la valeur de l'expression est celle de expr2. expr1 n'est pas évaluée.

Exemple

 i=(j>4 ? j+1:j-1);

affectera à la variable i :

j+1 si j>4, j-1 sinon

C'est la même chose que d'écrire if(j>4) i=j+1; else i=j-1; mais c'est plus concis.

1.3.4.10 Priorité générale des opérateurs

… …

gd indique qu'a priorité égale, c'est la priorité gauche-droite qui est observée. Cela signifie que lorsque dans une expression, l'on a des opérateurs de même priorité, c'est l'opérateur le plus à gauche dans l'expression qui est évalué en premier. dg indique une priorité droite-gauche.

1.3.4.11 Les changements de type

Il est possible, dans une expression, de changer momentanément le codage d'une valeur. On appelle cela changer le type d'une donnée ou en anglais type casting. La syntaxe du changement du type d'une valeur dans une expression est  la suivante (type) valeur. La valeur prend alors le type indiqué. Cela entraîne un changement de codage de la valeur.

exemple :

Ici il est nécessaire de changer le type de i ou j en réel sinon la division donnera le quotient entier et non réel.

i est une valeur codée de façon exacte sur 2 octets

(float) i est la même valeur codée de façon approchée en réel sur 4 octets

Il y a donc transcodage de la valeur de i. Ce transcodage n'a lieu que le temps d'un calcul, la variable i conservant toujours son type int.

1.4 Les instructions de contrôle du déroulement du programme

1.4.1 Arrêt

La méthode exit définie dans la classe System permet d'arrêter l'exécution d'un programme.

syntaxe void exit(int status) action arrête le processus en cours et rend la valeur status au processus père

exit provoque la fin du processus en cours et rend la main au processus appelant. La valeur de status peut être utilisée par celui-ci. Sous DOS, cette variable status est rendue à DOS dans la variable système ERRORLEVEL dont la valeur peut être testée dans un fichier batch. Sous Unix, c'est la variable $? qui récupère la valeur de status si l'interpréteur de commandes est le Bourne Shell (/bin/sh).

Exemple :

pour arrêter le programme avec une valeur d'état à 0.

1.4.2 Structure de choix simple

 syntaxe :  if (condition) {actions_condition_vraie;} else {actions_condition_fausse;}

notes:

• •    la condition est entourée de parenthèses.
• •    chaque action est terminée par point-virgule.
• •    les accolades ne sont pas terminées par point-virgule.
• •    les accolades ne sont nécessaires que s'il y a plus d'une action.
• •    la clause else peut être absente.
• •    Il n'y a pas de then.

L'équivalent algorithmique de cette structure est la structure si .. alors … sinon :

si condition   alors actions_condition_vraie   sinon actions_condition_fausse finsi