INF111 – Programmation Orientée Objet

Service des enseignements généraux.

Francis Bourdeau, copyright 2022
Cours 1 – Notion 5 : Les instructions conditionnelles
1.5.1 Définition
Les instructions conditionnelles sont des instructions qui permettent de contrôler le flot d'exécutions d'un programme. Elles
permettent, entre autres, de :
- Détecter des valeurs qui pourraient créer des erreurs d'exécution.
- Choisir le prochain bloc d'instructions à exécuter parmi deux séquences possibles.
- Choisir le prochain bloc d'instructions à exécuter parmi plusieurs séquences possibles.

1.5.2 Expression booléenne et opérateur de comparaison.

Une condition est représentée par une expression booléenne. Généralement, dans ce genre d'expression deux valeurs sont
comparées l'une par rapport à l'autre à l'aide d'un opérateur de comparaison.

Nom opérateur Opérateur Exemple Explication

Test d'égalité == res = (x == y); Est-ce que x est égal à y?
Test de différence != res = (x != 0); Est-ce que x est différent de 0?
Plus petit < res = (age < 18); Est-ce que age est inférieur à 18?
Est-ce que solde est inférieure ou
Plus petit ou égal <= res = (solde<=dette);
égale à dette?
Est-ce que taille est supérieur ou
Plus grand > res = (taille >200);
égale à 200?
Est-ce que note est supérieur ou
Plus grand ou égal >= res = (note >= 60);
égale à 60?

Lorsque le résultat de l'expression booléenne est faux, elle prend la valeur 0. Lorsque le résultat de l'expression booléenne est
vrai, il prend n'importe quelle valeur différente de 0. Habituellement, la valeur 1 est utilisée, mais ce n'est pas obligatoire.

INF111 – Programmation Orientée Objet 1

1.5.3 Cas 1 : Protection d'une instruction sensible
Mise en situation : Un programmeur tente de calculer la pente d'un segment de droite. Celui-ci peut utiliser la formule suivante
pour y arriver : 𝑝𝑒𝑛𝑡𝑒 = 𝑑𝑦/𝑑𝑥.
import java.util.Scanner;

public class Exemple

{
public static void main(String[] args)
{
int x1, y1;
int x2, y2;

Scanner clavier = new Scanner(System.in);

System.out.println("Entrez le premier point du segment de droite (x y) :");

Scanner point1 = new Scanner(clavier.nextLine());
x1 = point1.nextInt();
y1 = point1.nextInt();

System.out.println("Entrez le second point du segment de droite (x y) :");

Scanner point2 = new Scanner(clavier.nextLine());
x2 = point2.nextInt();
y2 = point2.nextInt();

double pente = (y2-y1)/(x2-x1);

System.out.println("La pente du segment est de : " + pente);
}
}

Toutefois, si l'utilisateur n'est pas prudent, il peut facilement causer une erreur d'exécution.

Syntaxe : Une condition ou on ne fait rien

Il est possible de vérifier le respect d'une condition avant d'exécuter une instruction.
if (condition)
{
/* Code exécuté si la condition est vraie */
}
Pour que le bloc de code inclus dans le corps de cette structure soit exécuté, la condition doit être vraie. Lorsque la condition
est fausse, le curseur d'exécution saute par-dessus le corps de la structure conditionnelle et l'exécution se poursuit.

Solution au problème précédent

Pour s'assurer que le calcul de la pente ne provoque pas une erreur d'exécution, le programmeur doit protéger ce calcul par
l'entremise d'une condition.
if ( (x2-x1) != 0)
{
double pente = (y2-y1)/(x2-x1);
}

La pente est calculée seulement si la valeur du dénominateur est différente de 0.

INF111 – Programmation Orientée Objet 2

1.5.4 Cas 2 : Choix entre deux séquences d'instructions possibles.
Mise en situation : Un programmeur tente de calculer le salaire d'un employé en fonction du nombre d'heures que celui-ci
travaille ainsi qu'en fonction de son salaire horaire. L'employé travaille 40 heures et moins est rémunéré à taux simple, alors
que les heures supplémentaires sont rémunérées à temps et demi.

nb_heures : 10 ou 50 oui salaire = 10 x 25 = 250$

nb_heure ;s : ;s :
;s :
taux_horaire : 25 <= 40? salaire = 40 x 25 + 10 * 37.5
;s : non
salaire = 1375
;s :

En fonction du nombre d'heures entrés par l'employés (par ex : soit 10h ou 50h), le programme devra utiliser la bonne méthone
de calcul afin de rémunérer correctement l'employé. Pour faire ce choix, il est possible d'adapter l'instruction conditionnelle
de la manière suivante.
if (condition)
{
/* Code exécuté si la condition est vraie */
}
else
{
/* Code exécuté si la condition est fausse */
}

Pour que le bloc de code inclus dans le corps d'instructions du if soit exécuté, la condition doit être vraie. Lorsque la condition
est fausse, le curseur d'exécution saute par-dessus le corps d'instructions associées au if et exécute le corps d'instructions
associées au else.
import java.util.Scanner;

public class Exemple1

{
final static int LIMITE_TEMPS_SIMPLE = 40;

public static void main(String[] args)

{
double nbHeures;
double salaireHoraire;
double salaireVerser;

Scanner clavier = new Scanner(System.in);

System.out.println("Entrez le salaire horaire : ");

salaireHoraire = new Scanner(clavier.nextLine()).nextDouble();

System.out.println("Entrez le nombre d'heures travaillees :");

nbHeures = new Scanner(clavier.nextLine()).nextDouble();

if (nbHeures <= LIMITE_TEMPS_SIMPLE)

{
salaireVerser = nbHeures * salaireHoraire;
}
else
{
salaireVerser = LIMITE_TEMPS_SIMPLE * salaireHoraire +
(nbHeures - LIMITE_TEMPS_SIMPLE) * salaireHoraire * 1.5;
}

String msg = String.format("L'employe doit recevoir %1.2f $.", salaireVerser);

System.out.println(message);
}
}

INF111 – Programmation Orientée Objet 3

1.5.5 Cas 3 : Choix entre plusieurs séquences d'instructions possibles.
Mise en situation : Un programmeur tente d'afficher une fraction proprement après avoir saisi son numérateur et son
dénominateur. Ce problème est facile à résoudre, dans le cas général (numérateur / dénominateur), mais il existe une panoplie
d'exceptions à gérer. Voici une série de tests que le programme devrait respecter.

Jeu de tests
Numérateur Dénominateur Fraction affichée
3 0 impossible
3 1 3
0 5 0
2 -3 -2/3
1 2 1/2

En fonction des cas d'exception à gérer, la fraction est affichée dans un des formats énumérés par le jeu de tests . Pour faire
ce choix de format, il est possible d'adapter l'instruction conditionnelle de la manière suivante.
if (condition1)
{
/* Code exécuté si la condition1 est vraie. */
}
else if (condition2)
{
/* Code exécuté si la condition1 est fausse et si la condition2 est vraie. */
}
else if (condition3)
{
/* Code exécuté si la condition1 et condition2 sont fausses et si la condition3
est vraie. */
}
else
{
/* Code exécuté si toutes les conditions de la structure sont fausses. */
}

Le programme exécute les instructions associées à la première rencontre d'une condition qui est vraie. Il est important de
noter que la condition1 est donc plus prioritaire que la condition2, qui possède elle-même une priorité plus élevée que la
condition3.

INF111 – Programmation Orientée Objet 4

import java.util.Scanner;

public class Exemple1

{
public static void main(String[] args)
{
int numerateur;
int denominateur;
String fraction;

Scanner clavier = new Scanner(System.in);

System.out.println("Entrez le numerateur svp : ");

numerateur = new Scanner(clavier.nextLine()).nextInt();

System.out.println("Entrez le denominateur svp : ");

denominateur = new Scanner(clavier.nextLine()).nextInt();

// Une numérateur ne peut être divisé par 0.

if (denominateur == 0)
{
fraction = "impossible";
}

//On n'affiche pas un dénominateur qui vaut 1

else if(denominateur == 1 )
{
fraction = String.valueOf(numerateur);
}

//On affiche 0 pour un numérateur nul

else if(numerateur == 0)
{
fraction = String.valueOf(numerateur);
}

//Les dénominaeur négatif ne sont pas esthétique.

//On change le signe des deux valeurs pour appliquer le négatif au numérateur.
else if(denominateur < 0)
{
fraction = -numerateur + "/" + -denominateur;
}

//La fraction est légale, on l'affiche tel quel.

else
{
fraction = numerateur + "/" + denominateur;
}

System.out.println(fraction);
}
}

INF111 – Programmation Orientée Objet 5

1.5.6 Imbrication de structures conditionnelles
Sachez qu'à l'intérieur du corps d'une structure conditionnelle, vous pouvez y insérer n'importe quel type d'instruction (calcul,
affichage, saisie, etc.). Si le type d'instruction que vous insérez est également une structure conditionnelle, ont dit que la
deuxième structure est imbriquée dans la première.
if (condition)
{
/* Premier niveau d'imbrication*/
if (condition)
{
/* Deuxième niveau d'imbrication*/
}
}
else
{
/* Premier niveau d'imbrication*/
if (condition)
{
/* Deuxième niveau d'imbrication*/
if (condition)
{
/* Troisième niveau d'imbrication*/
}
}
}

INF111 – Programmation Orientée Objet 6