Introduction au langage Java

INF1120 – Programmation I

Mélanie Lord
Université du Québec à Montréal

[Link]@[Link]
 INF1120 - Programmation I : Introduction au langage Java

Exécution d’un programme Java

Machine virtuelle Java

2
 INF1120 - Programmation I : Introduction au langage Java

Méthode main

public class MonAppli {

public static void main (String [] args) {

//code de l'application ici...

}
}

Les identificateurs
! Pour nommer les variables, constantes, méthodes, classes, objets, etc.
! Formés de lettres, chiffres (sauf au début), _ , $ (non recommandé)
! Lettres accentuées acceptées, mais non recommandées
! Ne doit pas être un mot réservé du langage
! Nbr de caractères illimité, mais le compilateur n’utilise que les 247 premiers.
! Sensibles à la casse : nbHeures est différent de nbheures
3
 INF1120 - Programmation I : Introduction au langage Java

Exemples :

public class MonProgramme {...} //nom d’une classe

int compteur1 = 10; //nom d’une variable
final double TAUX_TPS = 5.0; //nom d’une constante

Les commentaires

//Ceci est un commentaire sur une ligne

/*
Ceci est un commentaire
sur plusieurs
lignes
*/

/**
* Ceci est un commentaire de documentation (Javadoc)
* @author melanie lord
* @version septembre 2015
*/
4
 INF1120 - Programmation I : Introduction au langage Java

Les types primitifs

Les entiers
Type Nbr Intervalle des valeurs Constantes Java pour
d’octet(s) valeur maximum et
minimum
byte 1 -128 à 127 Byte.MIN_VALUE
Byte.MAX_VALUE
short 2 -32768 à 32767 Short.MIN_VALUE
Short.MAX_VALUE
int 4 -2147483648 à 2147483647 Integer.MIN_VALUE
Integer.MAX_VALUE
long 8 -9223372036854775808 à Long.MIN_VALUE
9223372036854775807 Long.MAX_VALUE

Exemples déclaration de variables

byte unPetitEntier; int unGrandEntier;

short unEntierMoyen; long unTresGrandEntier;

5
 INF1120 - Programmation I : Introduction au langage Java

Les flottants (réels)

Type Nbr Intervalle des valeurs Constantes Java des
d’octet(s) valeurs maximums et
minimums
float 4 - 3.4028235E38 à - Float.MAX_VALUE à
3.4028235E38 Float.MAX_VALUE

double 8 - 1.7976931348623157E308 à - Double.MAX_VALUE à

1.7976931348623157E308 Double.MAX_VALUE

Notation décimale : 24.56 -.43 -0.43 .27 2.

Notation exponentielle : 3.35e-5 3.35e+5 3.35E5 3.E5

3.0e5

Exemples déclaration de variables

float unPetitFlottant; double unGrandFlottant;

6
 INF1120 - Programmation I : Introduction au langage Java

Les caractères
Type Nbr Intervalle des valeurs Constante Java des
d’octet(s) valeurs maximum et
minimum
char 2 65536 caractères Unicode Character.MIN_VALUE
(Unicode = 0)
(contrairement à 256 ASCII/ANSI à
sur 1 octet) Character.MAX_VALUE
(Unicode = 65535)

Notation entre guillemets simples : 'g' 'U' '5' '&' 'à'

Notation avec l’Unicode (en hexadécimal) :

'\u0041' = caractère 'A'
'\u00A2' = caractère '¢'
'\u2764' = caractère '❤'

7
 INF1120 - Programmation I : Introduction au langage Java

Caractères d’échappement (barre oblique inversée)

! apostrophe (représenté par \')

! guillemet (représenté par \")
! barre oblique inversée (représentée par \\)
! nouvelle/saut ligne (représentée par \n)
! tabulation horizontale (représenté par \t)
! etc.

Exemple de déclaration d’une variable : char c;

Table des caractères Unicode : [Link]

! lettres minuscules consécutives
! lettres majuscules consécutives
! caractères numériques de ‘0’ à ‘9’ consécutifs

8
 INF1120 - Programmation I : Introduction au langage Java

Les booléens
Type Nbr d’octet(s) valeurs Constantes Java
boolean 4 true [Link] (= true)

Sauf dans les tableaux de false [Link] (= false)

booléens où chaque élément
est représenté sur 1 octet.

Exemple de déclaration d’une variable : boolean b;

Déclaration et initialisation de variables

<type nomVariable> [= valeur initialisation] <;>

Style Java pour identificateurs de variables :

Exemples style Java :

unEntier, nbrMinutes, salaire, tauxSalarialHoraire
9
 INF1120 - Programmation I : Introduction au langage Java

Exemples de déclarations et initialisations (où = est l’opérateur d’affectation)

// déclaration d’un entier et initialisation au même moment

int age = 32;

int nombre; // déclaration d’un entier

nombre = 12; // initialisation de cet entier

char c1 = [Link](); // initialisation par saisie au clavier

char c2 = '4'; // initialisation par une constante littérale

double d1; // déclaration d’un réel

double d2 = 45.6;
d1 = 1.5 * d2; // initialisation par une expression de type double

boolean b1 = true;
boolean b2 = !b1; // initialisation par une expression logique

10
 INF1120 - Programmation I : Introduction au langage Java

À ne pas faire…
int i;
int j = i; // Erreur de compilation, car i n’est pas initialisé

Exemple calcul salaire : déclaration et initialisation des variables

public class CalculerSalaire {

public static void main(String[] params) {

// ------------
// VARIABLES
// ------------
double nbrHeures; //le nombre d'heures travaillees
double tauxHoraire; //le taux salarial horaire
double salaireHebdo; //le salaire hebdomadaire

}
}

11
 INF1120 - Programmation I : Introduction au langage Java

Les constantes

< final type NOM_CONSTANTE > [= valeur initialisation] <;>

Style Java pour identificateurs de constantes :

Exemples style Java :
NBR_HEURES_MAX, TAUX_TPS

Exemples de déclarations et initialisations

final int AGE_MAJEUR = 18;

final double TAUX_HORAIRE;

...
TAUX_HORAIRE = 38.45; // initialisation différée
// non recommandé, si possible, pour la lisibilité du code

12
 INF1120 - Programmation I : Introduction au langage Java

À ne pas faire :

final char C = '&';

C = '\n'; // erreur de compilation, car C a déjà été initialisée

Différence entre une constante symbolique et une constante littérale :

final char C = 'A'; // C => const. symb., 'A'=> const. litt.

final int I = 10; // I => const. symb., 10 => const. litt.

final boolean B = true; // B => const. symb., true => const. litt.

! Par défaut, une constante littérale entière est de type int (ou long si la
valeur est trop grande pour un int). Si c’est un long, il faut utiliser L ou l à la
fin du nombre.
Exemples : int unEntier = 100;
long unEntierLong = 9999999999L; // ok
[Link](9999999999l); // ok
long unEntierLong = 9999999999; // err. compilation

13
 INF1120 - Programmation I : Introduction au langage Java

! Si une constante littérale entière dépasse la capacité d’un long, il y aura

erreur de compilation
Exemple :
long unEntierLong = 9223372036854775808L; // err. compilation

! Par défaut, une constante littérale réelle est de type double, mais on peut
la forcer à être un float en ajoutant f ou F.

Exemples :
float montant = 234.56; // ne compile pas
float montant = 234.56F; // ok
float montant = 234.56f; // ok

14
 INF1120 - Programmation I : Introduction au langage Java

Exemple calcul salaire (implémentation Java) : déclaration des constantes

public class CalculerSalaire {

public static void main(String[] params) {

// ------------
// CONSTANTES
// ------------
final double TAUX_MAX = 17.35;
final double TAUX_MIN = 8.55;
final double NBR_HR_MAX = 80;
final double NBR_HR_MIN = 0;
final double NBR_HR_NORMAL = 40;
final double TEMPS_SUP = 1.5;
final String MSG_SOL_TAUX_HORAIRE = "Entrez le taux horaire : ";
final String MSG_SOL_NBR_HEURES = "Entrez le nombre d’heures "
+ "travaillées : ";

// etc.

}
}

15
 INF1120 - Programmation I : Introduction au langage Java

Les opérateurs
Les opérateurs arithmétiques
Opérateurs Signification
- (op. unaire) L’opposée
+ (op. unaire) L’identité
* La multiplication
/ La division (réelle ou entière)
% Le modulo
+ L’addition
- La soustraction

! A priori pour des opérandes de type entier (int ou long) ou réel (float ou
double)
! A priori, les opérandes doivent être du même type.

16
 INF1120 - Programmation I : Introduction au langage Java

Priorité relative (plus prioritaire au moins prioritaire) :

1. + et - (unaires)
2. *, / et %
3. + et - (binaires)

Exemple :

a - c % d + -3 * b equivaut à a - (c % d) + ((-3) * b)

Pour les entiers : la division par zéro cause l’arrêt du programme

(ArithmeticException).

Dans le cas des réels, aucune opération ne provoque un arrêt de l’exécution. Il existe
des valeurs pour représenter l’infini (positif ou négatif) et une valeur non calculable
(NaN). Les constantes correspondantes sont :

17
 INF1120 - Programmation I : Introduction au langage Java

[Link] = NaN //valeur non calculable

[Link] = NaN //valeur non calculable
Float.POSITIVE_INFINITY = Infinity //pour le type float
Double.POSITIVE_INFINITY = Infinity //pour le type double
Float.NEGATIVE_INFINITY = -Infinity //pour le type float
[Link] _INFINITY = -Infinity //pour le type double

Par exemple :
! La division d’un réel par zéro = Infinity
! Infinity / -Infinity = NaN
! [Link](-34) = NaN

Conversion implicite

! Permet le calcul d’expressions dans lesquelles les opérandes sont de types

différents.
! La conversion est temporaire (pendant le calcul uniquement)

18
 INF1120 - Programmation I : Introduction au langage Java

Règles de la conversion implicite (évaluation d’expressions)

1. Promotion numérique
byte, short et char : convertis en int.

2. Conversion d’ajustement de type

int -> long -> float -> double

Exemple :

Soit les variables suivantes :

a de type short
b de type long
c de type byte
d de type double
e de type float
f de type char
De quel type sera le résultat de l’expression suivante ?
d – (a * b) / c – e + -f
19
 INF1120 - Programmation I : Introduction au langage Java

Les opérateurs relationnels

Opérateurs Signification
> Plus grand que

>= Plus grand ou égal à

< Plus petit que

<= Plus petit ou égal à

== Égal à

!= Différent de

Priorité relative (plus prioritaire au moins prioritaire) :

1. 1. >, >=, <, <=

2. 2. == et !=

20
 INF1120 - Programmation I : Introduction au langage Java

Exemples :
x - 9 > 7 * y est équivalent à (x - 9) > (7 * y)
a >= b != c < a est équivalent à (a >= b) != (c < a)

Note : les règles de conversion implicite pour les opérateurs arithmétiques s’appliquent aussi
dans le cas d’expressions mixtes contenant des opérateurs relationnels.

Les opérateurs logiques

Opérateur Signification
! Négation

& Et

^ Ou exclusif

| Ou (inclusif)

&& Et (avec court-circuit)

|| Ou inclusif (avec court-circuit)

21
 INF1120 - Programmation I : Introduction au langage Java

Les opérateurs de court-circuit (&& et ||)

Exemples :
(supposons que a, b, c et d sont des entiers)

a < b && c >= d Si a < b est faux, n’évalue pas le second opérande.

a < b || c >= d Si a < b est vrai, n’évalue pas le second opérande.

a != 0 && b / a > 3 Ne provoquera pas d’exception dans le cas où a est égal

à 0.

a != 0 & b / a > 3 Provoque une exception si a est égal à 0

L’opérateur d’affectation
Opérateur Signification
= affectation

Exemple : int unEntier = 100;

22
 INF1120 - Programmation I : Introduction au langage Java

Cet opérateur doit, a priori, avoir des opérandes de même type, mais il
existe des règles de conversion implicite très similaires à celles déjà
vues pour le calcul d'une expression.

Règles de la conversion implicite (affectations d’expressions)

En suivant l’une ou l’autre de ces hiérarchies :

byte -> short -> int -> long -> float -> double

ou

char -> int -> long -> float -> double

Exemple :

Soit l’expression suivante d - (a * b) / c - e + -f dont le résultat

est de type float.

int n = d - (a * b) / c - e + -f; //compile ?

23
 INF1120 - Programmation I : Introduction au langage Java

Affectation de constantes

On peut affecter n’importe quelle constante littérale (ou constante

symbolique) à une variable de type byte, short ou char pourvu que
sa valeur puisse être représentée dans le type voulu (sinon, erreur de
compilation).

short n;
n = 45; // Ceci est accepté bien que 45 soit une constante littérale de
// type int.

final int NOMBRE = 10;

byte b = NOMBRE; // ok
char c = NOMBRE; // ok
short s = NOMBRE; // ok

final int NOMBRE_2 = 999999;

char car = NOMBRE_2; //err. compil.

24
 INF1120 - Programmation I : Introduction au langage Java

Les opérateurs d’incrémentation et de décrémentation

Opérateurs Signification
++ Incrémentation (d’une unité)

-- Décrémentation (d’une unité)

Lorsqu’utilisé comme une instruction…

int i = 0;
i++; <=> i = i + 1
i--; <=> i = i - 1
++i; <=> i = i + 1
--i; <=> i = i - 1

Conversion implicite du résultat dans le type de la variable affectée par

cet opérateur.

Exemple : byte i = 0;
i++; //résultat de type byte

25
 INF1120 - Programmation I : Introduction au langage Java

Lorsqu’utilisé dans des expressions :

Si ( ++ / -- ) avant : on incrémente / décrémente la valeur avant de l’utiliser.

Si (++ / --)après : on utilise la valeur et on incrémente / décrémente

ensuite.

Exemples :

int i; char c;
int j; char i;

i = 3; c = 'e';
j = i++; i = ++c;

//affiche 4 //affiche 'f'

[Link](i); [Link](c);

//affiche 3 //affiche 'f'

[Link](j); [Link](i);

26
 INF1120 - Programmation I : Introduction au langage Java

L’opérateur de cast (conversion explicite)

Opérateur Signification
(type)expression Convertit temporairement le type de l’expression dans le type
donné

Opérateur de très haute priorité.

Exemples :
Supposons que a et b sont de type int :

(double) (10 / 3) // donne comme résultat 3 (type double)

(double) 10 / 3 // donne comme résultat 3.333333…

int n = 999;
byte b = (byte)n // ceci est légal, mais donnera un résultat bizarre. La
// variable b contiendra les 8 bits les moins significatifs
// de n (b contiendra -25, dans ce cas).

double d = 112.89;
int i = (int)d //i contient 112 (la partie décimale est tronquée)
27
 INF1120 - Programmation I : Introduction au langage Java

Récapitulation sur les opérateurs

Priorité des opérateurs
En ordre décroissant (des plus prioritaires aux moins prioritaires) :

() , ++, --
+ (unaire), - (unaire), !, cast
*, /, %
+, -
<, <=, >, >=
==, !=
&
^
|
&&
||

28
 INF1120 - Programmation I : Introduction au langage Java

Évaluation d’expressions mathématiques

Rappel conversion implicite :

1. Pour l'ajustement des opérandes dans une expression :

Promotion numérique
byte, short et char : convertis en int.

Ajustement de type
int -> long -> float -> double

2. Pour l'affectation (sauf pour les constantes)

byte -> short -> int -> long -> float -> double
ou
char -> int -> long -> float -> double

Peut-on mettre un byte dans un char ? Un short dans un char ?

29
 INF1120 - Programmation I : Introduction au langage Java

Exemples

Soit les initialisations suivantes :

long k = 3;
int e = 2;
float f = 2.5f;
double d = 5.2;
char c = 'e'; //l'Unicode de 'e' = 101
long g = 5;
boolean b = true;

QUESTIONS:

1. Donnez la valeur et le type résultants du calcul des expressions suivantes.

2. Dans quel type de variable pourrait-on stocker le résultat du calcul ?

30
 INF1120 - Programmation I : Introduction au langage Java

A) (byte)k + e * (short)(f - 1.0) + (byte)d;

B) c + 1;

C) (char)c + 1;

D) (char)(c + 1);

E) (g < 5) || b && (c != 'a') && true;

F) (char)g * ((int)(d + k));

31
 INF1120 - Programmation I : Introduction au langage Java

Les chaines de caractères

N’est pas un type primitif comme ceux vus précédemment.

Déclaration et initialisation

Exemples :
String s = "toto"; // déclaration et initialisation

String s; // déclaration
…
s = "234"; // initialisation

Note : remarquez que String s’écrit avec un 'S' majuscule contrairement aux
types primitifs.

32
 INF1120 - Programmation I : Introduction au langage Java

Opérateur de concaténation (+)

Le résultat d’un concaténation est une chaine de caractères.
Exemples :

String s1 = "allo";
String s2 = "toi";
String s3 = s1 + " " + s2; //s3 contient la chaine "allo toi"

int age = 15;

String s = "Toto a " + age + " ans"; // s contient la chaine
// "Toto a 15 ans"

String s = "Cinq est plus petit que deux: " + (5 < 2);

// s contient la chaine "Cinq est plus petit que deux: false"

33
 INF1120 - Programmation I : Introduction au langage Java

Autres exemples

Instructions Chaine résultante

"allo" + 5 + 5 "allo55"
5 + 5 + "allo" "10allo"
56 + "" "56"
"" + 5.3 "5.3"
true + "" "true"
'a' + "" "a"
3 * 2 + "coucou" "6coucou"
"coucou" + 3 * 2 + 7 "coucou67"
5 + "coucou" + 4 / 2 + 7 "5coucou27"
(5 < 3) + "ok" "falseok"
5 < 3 + "ok" NE COMPILE PAS
4 + "allo" + 2 - 7 NE COMPILE PAS

34
 INF1120 - Programmation I : Introduction au langage Java

Les instructions Java

Notions de base

La méthode main est le point d’entrée d’une application Java.

Les instructions simples se terminent toujours par un ;

Bloc d’instructions : { suite d’instructions entre accolades }

Note : En général, lorsqu'un bloc ne contient qu'une seule instruction, les
accolades du bloc sont optionnelles.

Visibilité des variables : Une variable est visible et existe seulement à l’intérieur
du bloc {…} dans lequel elle a été déclarée.

35
 INF1120 - Programmation I : Introduction au langage Java

Les instructions d’affichage (écran)

Instructions
[Link] (…)
[Link] (…) ou [Link] ()
[Link] (…)

Les instructions de lecture (au clavier)

Nous utiliserons la classe [Link] (fournie sur le site du cours).

Instructions
void lireFinLigne()
String lireString()
byte lireByte()
byte lireByteLn()

36
 INF1120 - Programmation I : Introduction au langage Java

short lireShort()
short lireShortLn()
int lireInt()
int lireIntLn()
long lireLong()

long lireLongLn()
float lireFloat()

float lireFloatLn()

double lireDouble()

double lireDoubleLn()

char lireChar()

char lireCharLn()

37
 INF1120 - Programmation I : Introduction au langage Java

Les structures de contrôle

Les instructions conditionnelles (sélections)

L’instruction if

if (condition) {
bloc_d’instructions_1
}

if (condition) {
bloc_d’instructions_1

} else {
bloc_d’instruction_2
}



38
 INF1120 - Programmation I : Introduction au langage Java

if (condition1) {
bloc_d’instructions_1

} else if (condition2) {
bloc_d’instruction_2

} else if (condition3) {
bloc_d’instruction_3

} else {
bloc_d’instruction_4
}

Exemple :
Afficher le jour de la semaine correspondant à un entier de 1 à 7 où 1
représente le dimanche et 7, le samedi.
int jourSemaine;

[Link] ("Entrez le jour de la semaine (1 - 7) : ");

jourSemaine = [Link]();
39
 INF1120 - Programmation I : Introduction au langage Java

if (jourSemaine == 1) {
[Link]("Dimanche");

} else if (jourSemaine == 2) {
[Link]("Lundi");

} else if (jourSemaine == 3) {
[Link]("Mardi");

} else if (jourSemaine == 4) {
[Link]("Mercredi");

} else if (jourSemaine == 5) {
[Link]("Jeudi");

} else if (jourSemaine == 6) {
[Link]("Vendredi");

} else if (jourSemaine == 7) {
[Link]("Samedi");

} else {
[Link] ("Jour de la semaine invalide.");
}
40
 INF1120 - Programmation I : Introduction au langage Java

L’instruction switch

switch (expression) { // expression : byte, short, int, char

// ou String (JDK7+)

case constante_1: // compatible par affectation avec expression

bloc_instruct_1
break; // provoque la sortie du switch

case constante_2:
bloc_instruct_2
//passe à travers

case constante_n:
bloc_instruct_n
break;

default: // default non obligatoire et généralement à la fin

bloc_instructions
}

41
 INF1120 - Programmation I : Introduction au langage Java

Exemples :

switch (2) {
case 2 :
[Link](2);
case 3 :
[Link](3);
default :
[Link]("default");
}
//affiche 23default

byte nbr = 2;
switch (nbr) {
case 2 :
[Link](2);
case 3 :
[Link](3);
break;
default :
[Link]("default");
}
//affiche 23
42
 INF1120 - Programmation I : Introduction au langage Java

final String TOTO = "Toto";

String s = "Toto";

switch (s) {
case "Mimi" :
[Link]("Mimi");
break;

case TOTO :
[Link](TOTO);

case "Momo" :
[Link]("Momo");
break;

default :
[Link]("default");
}

//affiche Toto
Momo

43
 INF1120 - Programmation I : Introduction au langage Java

final String TOTO = "Toto";

String s = "Momo";

switch (s) {
case "Mimi" :
[Link]("Mimi");
break;

case TOTO :
[Link](TOTO);

case "Momo" :
[Link]("Momo");

default :
[Link]("default");
}

//affiche Momo
default

44
 INF1120 - Programmation I : Introduction au langage Java

Afficher le jour de la semaine correspondant à un entier de 1 à 7 où 1

représente le dimanche et 7, le samedi.

int jourSemaine;

[Link] ("Entrez le jour de la semaine (1 - 7) : ");

jourSemaine = [Link]();

switch (jourSemaine) {
case 1 :
[Link]("Dimanche");
break;
case 2 :
[Link]("Lundi");
break;
case 3 :
[Link]("Mardi");
break;
case 4 :
[Link]("Mercredi");
break;
case 5 :
[Link]("Jeudi");
break;
45
 INF1120 - Programmation I : Introduction au langage Java

case 6 :
[Link]("Vendredi");
break;
case 7 :
[Link]("Samedi");
break;
default :
[Link]("Jour de la semaine invalide.");
}

Les instructions itératives (boucles)

boucle do... while

do {

bloc_d’instructions

} while (condition);

46
 INF1120 - Programmation I : Introduction au langage Java

Exemples :
Boucle de validation d’un caractère entre ‘a’ et ‘d’ :

char lettre;

do {
[Link]("Entrez une lettre (a, b, c ou d) : ");
lettre = [Link]();

if (lettre < 'a' || lettre > 'd') {

[Link]
("Erreur. La lettre doit etre a, b, c ou d.\n");
}

} while (lettre < 'a' || lettre > 'd');

47
 INF1120 - Programmation I : Introduction au langage Java

Déterminer si le chiffre 8 est dans un nombre nbr

int nbr = 945820; //par exemple

boolean trouve = false;

do {
if (nbr % 10 == 8) {
trouve = true;

} else {
nbr = nbr / 10;
}

} while (!trouve && nbr > 0);

[Link](trouve);

Faire trace …

48
 INF1120 - Programmation I : Introduction au langage Java

boucle while

while (condition) {

bloc_d’instructions

Exemples :
Boucle de validation d’un caractère entre ‘a’ et ‘d’
char lettre;

[Link]("Entrez une lettre (a, b, c ou d) : ");

lettre = [Link]();

while(lettre < 'a' || lettre > 'd') {

[Link]
("Erreur. La lettre doit etre a, b, c ou d.\n");
[Link]("Entrez une lettre (a, b, c ou d) : ");
lettre = [Link]();
}

49
 INF1120 - Programmation I : Introduction au langage Java

Déterminer si le chiffre 8 est dans un nombre nbr

int nbr = 945820; //par exemple

boolean trouve = false;

while (!trouve && nbr > 0) {

if (nbr % 10 == 8) {
trouve = true;
} else {
nbr = nbr / 10;
}
}

[Link](trouve);

Faire trace…

50
 INF1120 - Programmation I : Introduction au langage Java

boucle for

for (initialisations; condition; modifications) {

bloc_d’instructions

initialisations : initialisations des variables de contrôle, séparées par des

virgules.

condition : expression booléenne.

modifications : suites d’expressions (pour modifier les variables de

contrôle) séparées par des virgules.

Si condition est absente, elle est considérée comme vraie (boucle infinie).

initialisations, condition et modifications ne sont pas obligatoires.

51
 INF1120 - Programmation I : Introduction au langage Java

Exemples :

Cas typique :

for (int i = 3 ; i <= 7 ; i++) {

[Link](i + " ");
}

//affiche : 3 4 5 6 7

Dans l'autre sens…

for (int i = 10000 ; i > 0 ; i = i / 10) {

[Link](i + " ");
}

//affiche : 10000 1000 100 10 1

Avec des caractères :

for (char c = 'a' ; c <= 'p' ; c = (char)(c + 2)) {

[Link](c);
}
//affiche : acegikmo
52
 INF1120 - Programmation I : Introduction au langage Java

Boucles infinies

for ( ; ; ) {
[Link]("infinie");
}

for (int i = 2 ; ; ) {
[Link](i);
}

N’entre pas dans la boucle :

for (int i = 0 ; i > 9 ; i = i + 3 ) {

[Link](i);
}

//n’affiche rien

53
 INF1120 - Programmation I : Introduction au langage Java

Afficher les chiffres qui composent un nombre n

int n = 3456; //par exemple

for (int j = 1 ; n / j > 0 ; j = j * 10) {

[Link]((n / j % 10) + ", ");
}

//affiche : 6, 5, 4, 3,

Calculer le nombre de chiffres dans un nombre entier strictement positif.

int n = 234567; //par exemple

int nbrChif = 0;

for (int compt = 1 ; n / compt > 0 ; compt = compt * 10) {

nbrChif ++;
}
[Link](nbrChif);

//affiche : 6

54
 INF1120 - Programmation I : Introduction au langage Java

Exemples récapitulatifs

Voir les classes :

[Link]
o Traduction en Java de l'algorithme en pseudocode

[Link]
o Identique à [Link], MAIS avec les constantes déclarées au
niveau de la classe plutôt que dans la méthode main.

[Link]
o Exemple générique d'un programme avec menu pouvant vous servir pour le TP1.

[Link]
o Exemple concret d'un programme avec menu.

55
 INF1120 - Programmation I : Introduction au langage Java

Bonnes pratiques de programmation

! Utiliser des noms de variables / constantes significatifs

! Bien indenter / décaler le code source
! Commenter le code source de façon pertinente
! Déclarer les variables / constantes, une par ligne, au début de la
méthode main (pour les constantes, on peut aussi les déclarer au
début de la classe).
" facilite la compréhension du programme et donc le
débogage et la maintenance

! Toujours valider les entrées de l’utilisateur

" programmes plus robustes

! Utiliser des constantes autant que possible

" facilite la maintenance

56
 INF1120 - Programmation I : Introduction au langage Java

Exercices
Voir le fichier IntroJava_ExercicesEtSolutions.pdf

Références
VR DELANNOY, C. Programmer en Java - Java 5 et 6, 6e édition, Eyrolles, 2009.

The Java Tutorials : Lesson: Language Basics

[Link]

57