L'instruction conditionnelle if
La boucle for
L'instruction while
L'instruction do...while
L'instruction switch

Instruction conditionnelle if
L'instruction if prend pour paramètre une expression booléenne placée obligatoirement entre parenthèses.

if (expression) instruction;
ou
if (expression) {
    instruction 1;
    instruction 2;
    ...
    instruction n;
}

Si l'expression renvoie true, le bloc d'instructions suivant est exécuté. Si elle renvoie false, le bloc d'instruction suivant est ignoré.

Instruction conditionnelle else
L'instruction else permet de compléter une instruction if lorsque la valeur retournée par l'expression est false.

if (expression) {
    bloc d'instructions 1;
}
else {
    bloc d'instructions 2;
}

Les instructions conditionnelles imbriquées
Il est possible d'écrire plus simplement des imbrications successives d'instructions if else.

if (expression1) {
    bloc1;
}
else if (expression 2) {
    bloc2;
}
else if (expression3) {
    bloc3;
}
else {
    bloc4;
}

Il aurait peut être été plus judicieux d'utiliser une autre instruction plutôt que de combiner les deux instructions if et else, un peu comme le font les autres langages (elseif).

La boucle for
La boucle for est utilisée pour répéter un traitement sous forme de bloc d'instructions un certain nombre de fois en principe connu à l'avance. La syntaxe est la suivante.

for (initialisation; test; incrémentation) {
    bloc;
}

Par exemple :

int i = 0;
for (i = 2; i < 10; i++) {
    System.out.println("Coucou");
}

On peut bien évidemment imbriquer plusieurs boucles for entre elles :

for (int i = 0; i < 10; i++) {
    for (int j = 0; j < 10; j++) {
        tableau[i][j] = i*j;
    }
}

A noter la possibilité offerte par Java de déclarer la variable en même temps que son initialisation dans la boucle for.
Pour sortir de façon anticipée d'une boucle for, il faut utiliser l'instruction break.

int x = 5;
for (int i = 0; i < 10; i++) {
    if (i == x) {
        System.out.println(i);
        break;
    }
}

L'instruction continue quant à elle, permet de stopper l'itération en cours et de reprendre à celle d'après.

L'instruction while
L'instruction while permet d'itérer un bloc d'instructions tant qu'une condition est vérifiée. Elle présente de plus l'avantage de tester la condition avant la première exécution. La syntaxe est la suivante :

while (expression) {
    instruction1;
    instruction2;
    ...
    instructionn;
}

Par exemple :

int x = 0;
while (x < 10) {
    System.out.println(x);
    i++;
}

Les instructions break et continue peuvent aussi être utilisées dans les boucles while.

L'instruction do...while
L'instruction do...while correspond au "repeat" des autres langages. Il correspond au cas ou le traitement doit s'éffectuer au moins une fois et lorsque c'est lui qui détermine l'état de la condition. La syntaxe est la suivante :

do {
    instruction1;
    instruction2;
    ...
     instructionn;
}
while (expression);

L'instruction switch
L'instruction switch permet de s'affranchir des branchements else if vu précédemment, dans le cas ou les conditions sont toujours des tests d'égalité sur la même variable. Une grosse contrainte porte sur le paramètre de l'instruction switch : il doit être obligatoirement de type entier. On peut donc uniquement utiliser le switch pour comparer des valeurs entières entre elles.
Par exemple :

if (x == 1) {
    bloc1;
}
else if (x == 2) {
    bloc2;
}
else if (x == 3) {
    bloc3;
}
else {
    bloc 4;
}

pourra être avantageusement remplacé par :

switch (x) {
    case 1: bloc1;
    case 2: bloc2;
    case 3: bloc3;
    default: bloc4;
}

Le fonctionnement est le suivant. Toutes les conditions sont testées, et toutes celles qui sont vraies voient leur bloc d'instructions exécuté. Si on souhaite, que seul le bloc correpondant à la condition vérifiée ou à la première condition vérifiée soit exécuté, il faut terminer chaque bloc par l'instruction break comme ceci :

case 1: {
    bloc1;
    break;
}