Une somme d'entiers

     

Il s'agit d'abord d'écrire un programmme qui calcule la somme des 100 premiers entiers.

La boucle while

Voici un code source qui utilise "une boucle while", prenez le soin de lire les explications en utilisant les liens : 
public class SommeWhile {
    public static void main(String[] arg) {
        int i;
        int somme;

        somme = 0;
        i = 1;
        while (i <= 100) { 
	    somme = somme + i;
	    i = i + 1;
        }
        System.out.println("Voila la somme des 100 premiers entiers : " + somme);
    }
}
Le programme déclare deux variables de type int, la variable i et la variable somme.
Quand le flux d'exécution du programme arrive à la boucle while (au mot while), le programme compare la valeur de la variable i à 100 ; le double symbole "<=" signifie "inférieur ou égal". Comme au départ la variable i vaut 1, le programme entre dans la boucle, ce qui signifie qu'elle exécute les deux instructions contenues dans le bloc, puis le flux d'exécution remonte à la boucle while ; comme i vaut maintenant 2, le programme exécute à nouveau les deux instructions de la boucle, et ainsi de suite jusqu'à ce que i ait la valeur 101, alors le programme sort de la boucle et arrive à l'instruction qui suit, c'est-à-dire celle qui consiste à écrire le résultat à l'écran.

On obtient à l'exécution, avec notre programme : 

Voila la somme des 100 premiers entiers : 5050

Le programme

La boucle for

On change un peu l'objectif : on décide d'indiquer au programme, à l'exécution, un entier, par exemple 12, et que, dans ce cas, le programme calcule la somme des 12 premiers entiers.  De plus, on décide ici d'utiliser "une boucle for".

Cette boucle suit le schéma suivant :
for (instruction1; condition; instruction2) {
     suite d'instructions
}:

Les parenthèses autour "des trois champs" instruction1; condition; instruction2 sont obligatoires. Les trois champs, séparés par deux points-virgules, sont obligatoires aussi. S'il y a une seule instruction dans la suite des instructions, les accolades sont facultatives.

Losque le flux d'exécution du programme arrive sur la boucle for, il exécute instruction1, puis il teste condition ; si condition vaut vrai (true), il "passe dans la boucle", c'est-à-dire qu'il exécute la suite des instructions qui s'y trouvent. Après cela, il remonte à la boucle for, il effectue instruction2, puis il teste à nouveau condition et ainsi de suite jusqu'à ce que condition vale faux (false), alors le flux d'exécution continue avec ce qui suit la boucle.

public class SommeFor {
    public static void main(String[] arg) {
        int i, somme = 0;
        int plusGrand;

        plusGrand = Integer.parseInt(arg[0]);

        for (i = 1; i <= plusGrand; i = i + 1) somme = somme + i;
        System.out.println("Voila la somme des " + plusGrand + " premiers entiers : " + somme);
    }
}

On a fait une variante sur la déclaration des variables, qui consiste à en grouper qui sont d'un même type, et à initialiser à la déclaration certaines des variables.

La variable plusGrand doit servir à connaître le plus grand des entiers qu'on veut sommer.

À l'exécution, on enverra un argument au programme, par exemple 12 si on veut calculer la somme des 12 premiers entiers.

L'instruction :
    plusGrand = Integer.parseInt(arg[0]);
sert à traduire arg[0] en un int..

Quand le programme arrive sur la boucle for, elle commence par exécuter l'instruction qui se trouve dans le premier champ de la parenthèse qui suit le mot for, c'est-à-dire l'instruction : i = 1; . Puis, elle effectue le test correspondant au deuxième champ, en comparant la valeur de i à plusGrand ; ce test étant positif, le programme "passe dans la boucle" qui, ici, ne contient qu'une seule instruction somme = somme + i;. Après cela, le programme remonte à la boucle for pour exécuter l'instruction i = i + 1 contenue dans le troisième champ, puis il refait le test du deuxième champ, qui est positif, de nouveau la passage dans la boucle, puis l'instruction du troisième champ, puis le test du deuxième champ, et ainsi de suite jusqu'à ce que le test du deuxième champ soit négatif.

Une autre forme de la boucle for sera étudiée plus tard.

Pour la commande :
    java EssaiFor 12 (ou bien en faisant "Run" sur Eclipse après avoir indiqué un argument de 12),
on obtient à l'exécution, avec notre programme : 

Voila la somme des 12 premiers entiers : 78

Il existe un troisième type de boucle, "la boucle do-while" que nous n'illustrons pas pour l'instant.

Le programme

Nous vous conseillons de  faire cet exercice sur le calcul d'une factorielle

© Charon Irène Télécom ParisTech 2012