Annexe E Aide-mémoire de programmation

En complément de la progression du cours, où ces différentes constructions sont introduites, et de la table des mots clés donnée à l'annexe D, nous vous proposons une illustration par l'exemple des principales constructions de Java. Ces exemples n'ont aucune prétention d'exhaustivité, ni même d'utilité pratique, mais pourraient être utiles lorsque vous avez besoin de vous rafraîchir la mémoire sur la manière de réaliser telle ou telle construction.

Dans la même logique d'exemples, je ne donne que très peu de commentaires et d'explications complémentaires, et vous invite à vous reporter aux pages correspondantes (cf. table des mots clés par exemple), le cas échéant.

E.1 Constructions conditionnelles

La construction habituelle (cf. § 2.7.1) s'écrit :

    if (<condition>) {
        <bloc-1>
    }
    else {
        <bloc-2>
    }

la partie else étant facultative. Voici un exemple :

    if (monnaie < prix) {
        System.out.println("Paiement insuffisant - veuillez ajouter des pièces");
    }
    else {
        System.out.println("Voici votre café");
        livraisonCafé();
        double rendu = prix - monnaie;
        if (rendu > 0) {
            System.out.println("Rendu = " + rendu);
        }
    }

Une autre construction, moins souvent utilisée, permet de représenter un aiguillage par cas (cf. p. ??) :

    switch(<expression>) {
    case <label-1>:
        <instructions>
        break;
    case <label-2>:
        <instructions>
        break;
    ...
    default:
        <instructions>
    }

Voici un exemple :

    switch(sélection) {
    case 'c':
        System.out.println("Café");
        break;
    case 't':
        System.out.println("Thé");
        break;
    case 'b':
        System.out.println("Bière");
        break;
    case 'w':
        System.out.println("Whisky");
        break;
    default:
        System.out.println("Choix invalide");
    }

E.2 Constructions itératives

La construction itérative la plus simple est la construction "tant-que", qui s'écrit (voir § 2.7.2):

    while (<condition>) {
        <bloc>
    }

Une variante -- la seule différence est que le bloc s'exécute au moins une fois avant le test -- s'écrit :

    do {
        <bloc>
    } while (<condition>);

Voici des exemples de ces deux constructions :

    boolean faim = true;
    while (faim) {
        manger();
        faim = getEtatEstomac();
    }

    int x = Utils.lireEntier("Donnez un nombre");
    do {
        x += 3;
    }
    while (x < 100);

L'autre construction itérative, bien adaptée aux énumérations ou aux parcours de tableaux, est la suivante :

    for (<initialisation> ; <condition de poursuite> ; <passage au suivant>) {
        <bloc>
    }

Et voici un exemple :

    int[] tab = new int[30];

    // ...

    int somme = 0;
    for (int i = 0 ; i < 30 ; i++) {
        somme += tab[i];
    }

E.3 Définition et appel d'une fonction

Quand on définit une fonction, on donne son type, son nom, et le type de ses paramètres, puis son corps, et on n'oublie pas de retourner un résultat :

    [public] [static] <type> <fonction> (<type-1> <param-1>, ..., <type-n> <param-n>) {
        <corps>
        return <résultat à retourner>;
    }

Voici un exemple :

    public static double consommation(double nbKilomètres, double nbLitres) {
        return nbLitres * 100.0 / nbKilomètres;
    }

La fonction s'utilise ensuite de la manière suivante :

    double km = 458;
    double l = Utils.lireDouble("Litres consommés ?");
    double c = consommation(km, l);
    System.out.println("Consommation = " + c + "litres aux 100 km");

E.4 Définition et appel d'une procédure

Une procédure est définie quasiment de la même manière ; la différence est dans le fait qu'elle ne "retourne" rien, ce qui est indiqué par le mot clé void:

    public static void imprimerLaCommande(String[] articlesCommandés) {
        for (int i = 0 ; i < articlesCommandés.length ; i ++) {
            System.out.println(articlesCommandés[i]);
        }
    }

Voici un exemple d'appel de procédure :

    String[] commande = new String[3];
    commande[0] = "Ordinateur";
    commande[1] = "Imprimante";
    commande[2] = "Scanner";
    imprimerLaCommande(commande);

E.5 Définition d'une classe

public class Point {
    // variables d'instance
    protected double x;
    protected double y;

    // constructeur
    Point(double unX, double unY) {
        x = unX;
        y = unY;
    }

    // méthodes d'accès en lecture
    public double getX() {
        return x;
    }
    public double getY() {
        return y;
    }

    // méthodes d'accès en écriture
    public void setX(double unX) {
        x = unX;
    }
    public void setY(double unY) {
        y = unY;
    }

    // autres méthodes
    public double getRho() {
        return Math.sqrt(x * x + y * y);
    }
    // etc.
}

E.6 Instanciation d'une classe et accès aux méthodes

    double x1 = 3.4;
    double y1 = 2.6;
    double x2 = Utils.lireRéel("Abscisse = ");
    double y2 = Utils.lireRéel("Ordonnée = ");
    Point p1 = new Point(x1, y1);
    Point p2 = new Point(x2, y2);

    System.out.println("P1 : (" + p1.getX() + "," + p1.getY() + ")");
    p1.setX(5.6);
    p1.setY(p2.getX());
    double rho = p1.getRho();

    // etc.

E.7 Récupération d'une exception

    PileEntiers maPile = new PileEntiers();

    // ...

    try {
        System.out.println("Je dépile " + maPile.depiler());
    } 
    catch(EmptyStackException ese) {
        System.out.println("Attention, la pile est vide");
    }