Slides IntroJava v1.2

Introduction au langage Java
INF1120 – Programmation I
Mélanie Lord
Université du Québec à Montréal
lord.melanie@uqam.ca
INF1120 - Programmation I : Introduction au langage Java
Exécution d’un programme Java

Machine virtuelle Java
2
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
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
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
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
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
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 : http://unicode-table.com/fr/

! lettres minuscules consécutives
! lettres majuscules consécutives
! caractères numériques de ‘0’ à ‘9’ consécutifs
8
Les booléens
Type Nbr d’octet(s) valeurs Constantes Java
boolean 4 true Boolean.TRUE (= true)
Sauf dans les tableaux de false Boolean.FALSE (= 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
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 = Clavier.lireCharLn(); // 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
À 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
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
À 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
System.out.println(9999999999l); // ok
long unEntierLong = 9999999999; // err. compilation
13
! 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
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
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
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
Float.NaN = NaN //valeur non calculable

Double.NaN = 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
Double.NEGATIVE _INFINITY = -Infinity //pour le type double
Par exemple :
! La division d’un réel par zéro = Infinity
! Infinity / -Infinity = NaN
! Math.sqrt(-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
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
Les opérateurs relationnels

> 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
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
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
= affectation
Exemple : int unEntier = 100;

22
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
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
Les opérateurs d’incrémentation et de décrémentation

++ 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
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'

System.out.println(i); System.out.println(c);
//affiche 3 //affiche 'f'

System.out.println(j); System.out.println(i);
26
L’opérateur de cast (conversion explicite)

(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
Récapitulation sur les opérateurs

Priorité des opérateurs
En ordre décroissant (des plus prioritaires aux moins prioritaires) :
() , ++, --
+ (unaire), - (unaire), !, cast
*, /, %
+, -
<, <=, >, >=
==, !=
&
^
|
&&
||
28
É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
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
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
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
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
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
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
Les instructions d’affichage (écran)
Instructions
System.out.print (…)
System.out.println (…) ou System.out.println ()
System.out.printf (…)
Les instructions de lecture (au clavier)

Nous utiliserons la classe Clavier.java (fournie sur le site du cours).
Instructions
void lireFinLigne()
String lireString()
byte lireByte()
byte lireByteLn()
36
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
Les structures de contrôle
Les instructions conditionnelles (sélections)
L’instruction if
if (condition) {
bloc_d’instructions_1
}

if (condition) {
} else {
bloc_d’instruction_2
}

38

if (condition1) {
} else if (condition2) {
} else if (condition3) {
} else {
}
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;
System.out.print ("Entrez le jour de la semaine (1 - 7) : ");

jourSemaine = Clavier.lireInt();
39
if (jourSemaine == 1) {
System.out.println("Dimanche");
} else if (jourSemaine == 2) {
System.out.println("Lundi");
System.out.println("Mardi");
System.out.println("Mercredi");
System.out.println("Jeudi");
System.out.println("Vendredi");
System.out.println("Samedi");
} else {
System.out.println ("Jour de la semaine invalide.");
}
40
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
Exemples :
switch (2) {
case 2 :
System.out.print(2);
case 3 :
default :
System.out.print("default");
}
//affiche 23default
byte nbr = 2;
switch (nbr) {
case 2 :
case 3 :
break;
default :
System.out.println("default");
}
//affiche 23
42
final String TOTO = "Toto";

String s = "Toto";
switch (s) {
case "Mimi" :
System.out.println("Mimi");
break;
case TOTO :
System.out.println(TOTO);
case "Momo" :
System.out.println("Momo");
break;
default :
}
//affiche Toto
Momo
43
final String TOTO = "Toto";

String s = "Momo";
switch (s) {
case "Mimi" :
System.out.println("Mimi");
break;
case TOTO :
System.out.println(TOTO);
case "Momo" :
System.out.println("Momo");
default :
}
//affiche Momo
default
44
Afficher le jour de la semaine correspondant à un entier de 1 à 7 où 1

représente le dimanche et 7, le samedi.
int jourSemaine;
System.out.print ("Entrez le jour de la semaine (1 - 7) : ");

jourSemaine = Clavier.lireInt();
switch (jourSemaine) {
case 1 :
System.out.println("Dimanche");
break;
case 2 :
System.out.println("Lundi");
break;
case 3 :
System.out.println("Mardi");
break;
case 4 :
System.out.println("Mercredi");
break;
case 5 :
System.out.println("Jeudi");
break;
45
case 6 :
System.out.println("Vendredi");
break;
case 7 :
System.out.println("Samedi");
break;
default :
System.out.println("Jour de la semaine invalide.");
}
Les instructions itératives (boucles)
boucle do... while

do {
bloc_d’instructions
} while (condition);
46
Exemples :
Boucle de validation d’un caractère entre ‘a’ et ‘d’ :
char lettre;
do {
System.out.print("Entrez une lettre (a, b, c ou d) : ");
lettre = Clavier.lireCharLn();
if (lettre < 'a' || lettre > 'd') {

System.out.println
("Erreur. La lettre doit etre a, b, c ou d.\n");
}
} while (lettre < 'a' || lettre > 'd');
47
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);
System.out.println(trouve);
Faire trace …
48
boucle while
while (condition) {
Exemples :
Boucle de validation d’un caractère entre ‘a’ et ‘d’
char lettre;

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

System.out.println
("Erreur. La lettre doit etre a, b, c ou d.\n");
}
49
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;
}
}
System.out.println(trouve);
Faire trace…
50
boucle for
for (initialisations; condition; modifications) {
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
Exemples :

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

System.out.print(i + " ");
}
//affiche : 3 4 5 6 7
Dans l'autre sens…
for (int i = 10000 ; i > 0 ; i = i / 10) {

System.out.print(i + " ");
}
//affiche : 10000 1000 100 10 1
Avec des caractères :
for (char c = 'a' ; c <= 'p' ; c = (char)(c + 2)) {

System.out.print(c);
}
//affiche : acegikmo
52
Boucles infinies
for ( ; ; ) {
System.out.println("infinie");
}
for (int i = 2 ; ; ) {
System.out.println(i);
}
N’entre pas dans la boucle :
for (int i = 0 ; i > 9 ; i = i + 3 ) {

System.out.print(i);
}
//n’affiche rien
53
Afficher les chiffres qui composent un nombre n
int n = 3456; //par exemple
for (int j = 1 ; n / j > 0 ; j = j * 10) {

System.out.print((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 ++;
}
System.out.println(nbrChif);
//affiche : 6
54
Exemples récapitulatifs
Voir les classes :
CalculerSalaire.java
o Traduction en Java de l'algorithme en pseudocode
CalculerSalaireAvecConstantesHorsMain.java
o Identique à CalculerSalaire.java, MAIS avec les constantes déclarées au
niveau de la classe plutôt que dans la méthode main.
ProgrammeAvecMenu.java
o Exemple générique d'un programme avec menu pouvant vous servir pour le TP1.
Calculateur.java
o Exemple concret d'un programme avec menu.
55
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
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

http://docs.oracle.com/javase/tutorial/java/nutsandbolts/index.html
57

Slides IntroJava v1.2

Transféré par

Informations du document

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Slides IntroJava v1.2

Transféré par

Droits d'auteur :

Formats disponibles

Introduction au langage Java

Exécution d’un programme Java

public class MonAppli {

public static void main (String [] args) {

//code de l'application ici...

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

//Ceci est un commentaire sur une ligne

Les types primitifs

Exemples déclaration de variables

byte unPetitEntier; int unGrandEntier;

Les flottants (réels)

double 8 - 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

Exemples déclaration de variables

float unPetitFlottant; double unGrandFlottant;

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

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

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

! apostrophe (représenté par \')

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

Table des caractères Unicode : http://unicode-table.com/fr/

Sauf dans les tableaux de false Boolean.FALSE (= false)

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

Déclaration et initialisation de variables

Style Java pour identificateurs de variables :

Exemples style 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 nombre; // déclaration d’un entier

char c1 = Clavier.lireCharLn(); // initialisation par saisie au clavier

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

Exemple calcul salaire : déclaration et initialisation des variables

public static void main(String[] params) {

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

Style Java pour identificateurs de constantes :

Exemples de déclarations et initialisations

final int AGE_MAJEUR = 18;

final double TAUX_HORAIRE;

final char C = '&';

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

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

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

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

public static void main(String[] params) {

Priorité relative (plus prioritaire au moins prioritaire) :

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

Float.NaN = NaN //valeur non calculable

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

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

2. Conversion d’ajustement de type

Soit les variables suivantes :

Les opérateurs relationnels

>= Plus grand ou égal à

< Plus petit que

<= Plus petit ou égal à

Priorité relative (plus prioritaire au moins prioritaire) :

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

Les opérateurs logiques

&& Et (avec court-circuit)

|| Ou inclusif (avec court-circuit)

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

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