2013-10-09

Les instructions de contrôle

Les instructions dans un langage informatique

Java est un langage artificiel, il partage avec une langue culturelle de posséder un dictionnaire, et de permettre la construction de termes et de textes. L'avantage d'un langage artificiel est d'être univoque, afin de produire un comportement déterministe à la lecture (ici, exécution d'instructions). L'écriture de programmes ne nécessite pas les ordinateurs, ni même des machines. Cette propriété est obtenue comme en mathématique par le formalisme, en restreignant le dictionnaire à quelques termes strictement définis.

On distinguera 3 couches de vocabulaire. Les [mots clés] réservés du langage (ex : int) ; l'API qui donne accès à des "fonctions" (ex : String) ; et vos programmes, où vous choisissez vos noms pour vos variables, vos méthodes, vos classes, vos paquets.

Relativement à un langage de script, comme Perl, une nouvelle fonction en Java ne demande pas d'écrire un programme dans un autre langage (ex : C). Toute l'API Java est écrite en Java. Ainsi par exemple, à la classe String correspond un fichier String.java, commençant par package java.lang et public final class String… http://hg.openjdk.java.net/jdk6/jdk6-gate/jdk/file/tip/src/share/classes/java/lang/String.java (ici en ligne dans l'implémentation OpenJDK, qui répond strictement à la même documentation spécifier par Sun maintenant racheté par Oracle http://docs.oracle.com/javase/6/docs/api/java/lang/String.html). Le champ essentiel de cette classe est un tableau de caractères (type primitif), char[], sur lequel s'articule les différentes méthodes (constructeur, charAt(), trim()…). Autrement dit, une chaîne de caractère en Java n'est pas un type primitif, mais un programme écrit à base de mots clés. Nos programmes utilisent l'API, avec des mots clés, pour pouvoir dans l'idéal, ajouter de nouvelles classes et fonctionnalités au langage.

Les [mots clés] du langage http://docs.oracle.com/javase/tutorial/java/nutsandbolts/_keywords.html peuvent être répartis en différentes catégories, par exemple, selon le niveau de structuration d'un programme. Ainsi on distingue les langages de type impératifs, procéduraux, et objets, auquel correspondent des niveaux hiérarchique dans le texte du programme : les expressions, qui s'écrivent dans des méthodes, qui sont dans des classes. Les mots clés relatifs au types primitifs sont de niveau expression ; les mots clés comme class, public, static relève de la construction objet. Les instructions de contrôles sont entre les deux, au niveau des méthodes. Ce sont des termes qui modifient l'ordre linéaire de déroulement du programme. On distinguera grossièrement deux types de ruptures, les embranchements qui séparent le déroulement en deux lignes selon le résultat d'une expression (tests), et les boucles permettant d'exécuter plusieurs fois un segment (selon le résultat d'une expression).

• tests : if, else ; switch, case, default
• boucles : while, do, for ; break, continue

L'usage depuis le C a établi un vocabulaire assez standard, il est indispensable de maîtriser les constructions if else if… et for ; while et surtout switch sont d'usage moins fréquent, on peut tolérer un retour à la documentation ou la recherche d'un copier/coller avant de les réutiliser. Il ne suffit pas de connaître la définition des mots pour parler une langue, passons au plus vite à un exercice pratique qui doit permettre d'utiliser des instructions de contrôle.

Les instructions en Java, syntaxe de type C

Tests

• if (condition) instruction;
• if (condition) instruction else instruction;
• if (condition) instruction else if (condition) instruction else instruction;
• l'instruction peut être remplacée par un bloc d'instruction ( {...} )
• switch (variable) { case expression1: instruction1; case expression2: instruction2; default: instruction3; }
  ** le mot clef '''break''' permet de quitter l'évaluation switch.
• expression conditionnelle : (condition) ? valeursivrai : valeursifaux

Boucles

while

Privilégié pour les boucles dont on ne connaît pas la longueur à priori, ex : lecture de fichier ligne à ligne
while (condition) instruction;
while (condition) { instruction; ( instruction; ) * }
do instruction while (condition);
do { instruction; ( instruction; ) * } while (condition);

for

Privilégié pour les boucles dont on connaît la longueur ou lorsque l'on a besoin d'un compteur
for (initialisation; test; incrément) instruction;
for (initialisation; test; incrément) { instruction; ( instruction; ) * }
et de collections (et de tableaux) :
* for (String s : liste) { }

Sauts

• break : termine la boucle (en cas de boucles imbriquées, ne clôt que la première boucle)
• continue : va au tour de boucle suivant

Lecture

Qu'est ce qu'affichent les instructions suivantes :

 for (int i=0; i<6; i++) {
    System.out.println(i);
 }

 for (int i=0; i<6; i++) {
   if (i == 2) {
      continue;
   }
   if (i > 4) {
      break;
   }
   System.out.println(i);
 }

À quoi peut servir une telle écriture ? Comparer avec if else if.

  do {
    // traitement
    // test
    if (condition1) break;
    // autre traitement
    // autre test
    if (condition2) break;
  } while (false)

Écriture

• Objectif : écrire un programme qui retire les accents d'un texte français.
• Exemple : en entrée "J'étais allé au marché", en sortie "J'etais alle au marche"
• Doit répondre à la ligne de commande >bin\run.(bat|sh) fr.crim.a2012.i18n.Fr "Texte accentué" (voir [skel]ette de projet Java)
• Respecter les [conventions de codage Java]
• penser à l'avenir de ce programme, autres traitements linguistiques, autres langues (comment rendre cette fonctionnalité facilement configurable ?)

Contrat à suivre (API des noms de packages, classes, méthodes avec précision de leur entrée/sortie)

/*
 * Version, date et copyright
 */
package fr.crim.a2012.i18n;
/**
 * Ici votre nom et vos explications
 */
public class Fr { // nom de classe imposé
    /**
     * Ici votre nom et vos explications
     */
    public static void main(String[] args) {
        // penser ici à l’utilisateur, le prévenir si la méthode manque d’arguments
        // une boucle sur les caractères de la chaîne en entrée, for ou while
        // {
        // des tests sur chaque caractère, if else if ou switch
        // }
    }

}