Cours 2: Introduction

à Java

1
Plan
• Opérateurs
• Instructions de contrôle
• Types primitifs en Java
• Types objets en Java
 Classes de l’API
 Classes définies par l’utilisateur
 Tableaux

• Chaines de caractères avec la classe String

• Conclusion

2
Opérateurs arithmétiques et
relationnels
• Les opérateurs arithmétiques et relationnels en Java sont les
mêmes qu’en langage C avec certaines différences dans le
fonctionnement
• Opérateurs arithmétiques :
 Les opérateurs arithmétiques sont : + - * / % ++ --
 Une différence est que l’opérateur ‘+’ sert en plus à concaténer des
chaînes de caractères.

• Opérateurs relationnels :
 Les opérateurs relationnels sont : < <= > >= == !=
 Les opérateurs == != peuvent aussi s’appliquer à des objets

• Comme on C, l’opérateur d’affectation est =

3
Exemple
• Considérons le bout de code suivant :
int i = 10;
int n = i++%5;
• Quelles sont les valeurs de i et n après l’exécution du code ?
• Quelles sont les valeurs finales de i et n si au lieu d’utiliser
l’opérateur d’incrémentation postfixé (i++), on utilisait la
version préfixée (++i))?

4
Opérateurs logiques
• Les opérateurs logiques en Java sont :

Opérateur Signification
! Négation
& et
^ Ou exclusif
| Ou inclusif
&& Et (avec court-circuit)
|| Ou inclusif (avec court-circuit)

5
Opérateurs && et ||
• & et && représentent tous deux le « et logique » tout comme le
| et || le « ou logique »
• Les deux opérateurs possèdent néanmoins une propriété
intéressante : leur second opérande (celui qui figure à droite de
l’opérateur) n’est évalué que si la connaissance de sa valeur est
nécessaire pour décider si l’expression est vraie ou fausse
• Exemple : a<b && c<d
• Dans cette expression on commence par évaluer a<b si le
résultat est faux pas la peine d’évaluer la seconde expression
c<d car dans tous les cas l’expression a<b && c<d sera fausse

6
Instruction de contrôle de Java
• Les instructions de contrôle sont proches du langage C. Ils
permettent de réaliser :
• des choix : instructions if…else et switch
• des boucles : do …while, while et for
• Enfin, il existe une autre écriture intéressante de boucle
appelée for each adaptée aux tableaux, chaînes de
caractères,… que nous allons voir par la suite.

7
Les variables en Java
• En Java, les termes "champ/attribut" et "variable" sont parfois
utilisés de façon interchangeable, ce qui peut prêter à confusion.
• Dans ce cours nous essayerons à chaque fois d’être le plus spécifique
possible pour distinguer entre ces deux notions.
• Par ailleurs qu’il s’agisse d’un attribut ou d’une variable, les mêmes
conventions de nommage s’appliquent :
 Les noms de variable commencent soit par une lettre ou $ ou _
(underscore) tout le reste est considéré comme faux (erreur de
compilation- analyse lexicale)
 Les noms choisis pour les variables doivent être significatifs.
Attention à ne pas choisir des mots clés ou des mots réservés
 Utiliser le « Camel casing » pour relier les mots qui forment le nom
d’une variable sauf pour le cas d’une constante (nous y reviendrons)

8
Types en Java
• Le langage de programmation Java est statiquement typé,
ce qui signifie que toutes les variables doivent d’abord être
déclarées avant de pouvoir être utilisées. Il s’agit d’indiquer le
type et le nom de la variable.
• Nous allons étudier dans ce qui suit les différents types en
Java
 Types primitifs
 Types objets
 Classes de l’API
 Classes utilisateur

9
Types primitifs en Java
• Java dispose d’un certain nombre de types de base appelés
« primitifs » permettant de manipuler des entiers, des flottants, des
caractères et des booléens.
• Java définit exactement les caractéristiques des types primitifs
concernant :
 La taille de l’emplacement mémoire
 Le comportement arithmétique associé

• Ainsi, quelle que soit la machine, une valeur de type float aura
exactement la même taille, les mêmes limites et la même précision.
• Java est ainsi le premier langage qui assure qu’un même
programme, exécuté dans des environnements différents fournira les
mêmes résultats.

10
Les différents types d’entiers
• Java dispose de quatre types d’entiers correspondant chacun à des
emplacements mémoire de différentes tailles et donc à des
limitations différentes :
Type Tailles (octets) min max
byte 1 -128 127
short 2 -32768 32767
int 4 Integer.MIN_VALUE Integer.MAX_VALUE

long 8 Long. MIN_VALUE Long. MAX_VALUE

• Constante entière:
 une constante entière est par défaut de type int.
 si on veut forcer une constante entière à être de type long il faudra
ajouter à la fin "l" ou "L" ex. 23L

11
Les types réels
• Java prévoit deux types de réels correspondant chacun à des
emplacements mémoire de différentes tailles : float et double
• Les constantes réelles sont par défaut de type double
• Si on veut forcer le compilateur à convertir un double en float
il faudra rajouter la lettre « F » ou « f »
• Exemple :
float x ;
x = 12.5f ;

12
Le type caractère
• Contrairement à d’autres langages, Java utilise 2 octets en
mémoire pour représenter les caractères.
• Java utilise le code universel Unicode, cela permet d’utiliser
par exemple les caractères avec accent en Java contrairement
au langage C.
• Les constantes de type caractère s’écrivent entre apostrophes.
• Ex :
char c = 'a' ;

13
Le type booléen
• Ce type sert à représenter une valeur logique de type
vrai/faux.
• En Java, on peut disposer de variables de ce type ce qui
permettra les affectations suivantes :
boolean exp ;
…
exp = n < p;
• Les 2 constantes booléennes sont notées true et false.

14
Constante et initialisation
• En Java, le mot-clé final précédant la déclaration d’une
variable signifie que la valeur de cette variable ne doit pas être
modifiée pendant l’exécution.
• On ne peut donc pas dire que final sert à déclarer des
constantes symboliques comme en C.
• final demande simplement que la valeur d’une variable
n’évolue plus après avoir été fixée.
• Si toutefois il est nécessaire de déclarer une expression
constante, il est d’usage de l’écrire en majuscules.

15
Exemples Expression 1 : n
sera initialisée
qu’une seule fois
Expression 1 :
final int n = 20;
Expression 2 :
Expression 2 est
final int n; correcte même si n
n’a pas encore reçu
...
de valeur
n = 5 * 4 ;
Expression 3 :
final int NOMBRE = 20; Expression 3:
déclaration d’une
constante
16
Conversion de types (opérateur de
cast)
• Les conversions implicites légales sont celles qui se font selon
l’une des deux hiérarchies suivantes :
byte → short →int→long→float→ double
char→ int→long→float→double
• Java étant un langage fortement typé il est parfois nécessaire
de recourir à une conversion de type explicite à l'aide du cast.
• En dehors des conversions numériques, on peut également
forcer la conversion d’un objet d’une classe de base en un objet
d’une classe dérivée.

17
Exemple
int a = 2 ;
// a = 2
double b = 2 ;
// b = 2.0 (conversion implicite)
int c = 18.7;
// erreur de type
int d = (int) 18.7;
// d = 18
double e = 2/3;
// e = 0.0
double f = (double) 2/3;
// f = 0.666... 18
 Valeurs par défaut
Des valeurs par défaut sont parfois attribuées aux attributs non initialisé d’un objet ou
aux cases d’un tableau.
De manière générale, cette valeur par défaut sera zéro ou nulle, selon le type de données

Data Type Default Value

byte 0
short 0
int 0
long 0L
float 0.0f
double 0.0d
char '\u0000'
String (or any object) null
boolean false 19
Types objets en Java
• En plus des types primitifs, Java définit des « types objets ».
• Ces types objets sont :
 Les classes de l’API, définies par les développeurs-concepteurs.
 Les classes définies par les développeurs-utilisateurs (ou classes
utilisateurs)
 Les tableaux

• Dans ce cours nous considérons que les variables de type objet

sont des objets
• Ils possèdent une même particularité à savoir qu’il s’agit de
références (nous y reviendrons en détails dans la suite).

20
Application Programming Interface
(API)
• Un grand nombre de classes, fournies par Java SE, implémentent des données et
traitements génériques utilisables par un grand nombre d’applications. Ces classes
forment l’API (Application Programmer Interface) du langage Java. Les API les plus
utilisée sont :
Package
java.awt Classes graphiques et de gestion d’interfaces
java.io Gestion des entrées/sorties
java.lang Classes de base (importé par défaut)
java.util Classes utilitaires
javax.swing Autres classes graphiques
• Une documentation en ligne pour l’API java est disponible à l’URL :
http://docs.oracle.com/javase/7/docs/api/

• Toutes ces classes sont organisées en packages (ou bibliothèques) dédiés à un thème
précis.
21
Application Programming Interface
(API)
• Pour accéder à une classe d’un package donné, il faut
préalablement importer cette classe ou son package.
• Par exemple, la classe Date appartenant au package java.util
(qui implémente un ensemble de méthodes de traitement sur
une date) peut être importée de deux (2) manières :
1. une seule classe du package est importée :
import java.util.Date ;
2. toutes les classes du package sont importées (même les
classes non utilisées) :
import java.util.* ;

22
« Classe utilisateur » en Java
• En POO, une classe regroupe un ensemble d’attributs (qui
peuvent être des variables de types primitifs ou des objets) et
un ensemble de méthodes de traitement sur ces données et/ou
sur des données extérieures à la classe
• Pour créer une classe en Java, on utilise le mot clé « class ».
• Les traitements à effectuer sont programmés dans les
méthodes de ces classes qui peuvent faire appel à des
méthodes d’autres classes.
• En général, on définit au moins une classe, dite “exécutable”,
contenant la méthode « main ».

23
Exemple de classe en Java
public class Point {
int x; //abscisse
int y; //ordonnées

public void deplace(int abs, int ord) {

x += abs;
y += ord;
}
}

24
Instanciation d’objets en Java
• L'instanciation d'un objet en Java se fait à l'aide d'une
méthode spéciale appelée « constructeur ».
• Une méthode constructeur doit avoir le même nom que la
classe où elle est définie et n'a aucune valeur de retour: c'est
une référence vers l’objet créé qui est renvoyée.

25
 Exemple d’instanciation
public class Point {
…
Point (int abs, int ord) {
x = abs;
y = ord;
Instanciation
}
de l’objet p
…
Point p = new Point(24, 5);
}

26
Référence d’objet en Java
• En Java, la notion de pointeur est transparente pour le
programmeur.
• Il faut néanmoins savoir que toute variable désignant un objet
(c’est-à-dire tout objet) est une référence (pointeur) à cet objet.
• Cela implique que le passage d’objets comme paramètres d’une
méthode est toujours un passage par référence.
• A l’inverse, le passage de variables primitives comme
paramètres est toujours un passage par valeur.

27
Exemple

int var = 45;

Point p = new Point(24, 5);

var 45
Zone mémoire dans le Heap

p @100 x 24
@100
y 5

28
Exemple

int var = 45;

Point p = new Point(24, 5);

var 45
Zone mémoire dans le Heap

p x 24

y 5

29
Accès aux attributs et aux méthodes
• Pour accéder à un attribut associé à un objet, il faut préciser
l’objet qui le contient.
• Le symbole ’.’ sert à séparer l’identificateur de l’objet de
l’identificateur de l'attribut.
• La même syntaxe est utilisée pour appeler une méthode d'un
objet
• Exemple:
p.x = 6;
p.deplace(3, 12);

30
Exemple
• Si on veut invoquer la méthode « lire » de l’objet « livre »,
quelle est la syntaxe la plus correcte :
(a) livre.lire()
(b) lire.livre()
(c) livre(lire)

31
Conditions d’accès aux attributs et
aux méthodes
• Pour pouvoir accéder à un attribut ou à une méthode, il faut
que trois conditions soient vérifiées :
1. L’attribut ou la méthode appelée existe !
2. L’objet visé existe (est instanciée).
3. L’objet, au sein duquel est fait cet appel, a le droit d’accéder
à la méthode ou à l’attribut (visibilité)

32
Tableaux : Déclaration
• En Java, un tableau est un objet.
• Un objet tableau est déclaré dès lors que des crochets sont présents
soit après son type (classe ou type primitif), soit après son
identificateur. Les deux syntaxes suivantes sont acceptées pour
déclarer un tableau d’entiers :
int[] tab;
int tab[];
Remarque : la déclaration d’un tableau vise simplement à préciser le
type de ses éléments et ne doit en aucun cas préciser de dimensions.
Exemple : Cette instruction sera rejetée par le compilateur :
int tab[5];

33
Tableaux : Création
• La création d’un tableau vise à lui allouer de l’espace en
mémoire. Java propose 2 façons de faire soit (1) à l’aide
de l’opérateur new ou (2) d’un initialiseur.
1. Création par l’opérateur new (comme pour les objets)
Exemple :
int tab[] ; tab = new int[5] ; // tab fait
référence à un tableau de 5 entiers
• Les 5 éléments créés sont initialisés par défaut
(comme tous les champs d’un objet) à une valeur
« nulle » (0 pour un int). On peut illustrer la
situation par ce schéma:
tab 0 0 0 0 0
34
Tableaux : Création
2. Utilisation d’un initialiseur :
Exemple :
int tab[] = {1, 2, 3, 5, 8};
• Cette instruction crée un tableau de 5 entiers dont les valeurs
sont mentionnées. Ces valeurs peuvent également être des
variables.
• Remarque :
Attention ! Cette notation n’est valable qu’au moment de la
déclaration du tableau

35
Dimension d’un tableau
• Lors de la création d’un tableau à l’aide de l’opérateur new, la valeur
du paramètre fournie n’est calculée qu’au moment de l’exécution.
• Néanmoins, lorsque le tableau est créé sa taille ne pourra pas être
modifiée
• La taille d’un tableau peut être obtenu à l’aide de l’attribut length
• Exemple:
int t[] ;
t = new int[5] ;
System.out.println("taille de t :"+t.length);//affiche 5

36
Exemple de tableau d’objets
• Les éléments d’un tableau peuvent être de type quelconque
(prédéfinis ou objet). Voici un exemple de tableau de type Point
:
Point t [];
t=new Point[3];
t[0] = new Point (1,3);
t[1] = new Point (5,2);
t[2] = new Point (11,-6);

37
 Utilisation de la boucle for …each
• La boucle for …each a été introduite dans la JDK 5.0
• Exemple: double t []={11,6,13,25};
for (double v :t) System.out.println(v);
Avec cette instruction : System.out.println(v); la variable v prendra les
différentes valeurs de t ce qui équivaut à :
for (int i = 0; i<t.length ; i++) System.out.println(t[i]) ;
• Remarque : La structure for…each ne s’applique qu’à des consultations de
valeurs et en aucun cas à des modifications
• Exemple :
Avec l’instruction for (double v : t) v=0; on laisse les valeurs de t
inchangées

38
Tableau et méthode
• Lorsqu’on transmet un nom de tableau en argument d’une
méthode, on transmet la référence au tableau. Ceci implique
que la méthode agit directement sur le tableau concerné et non
sur une copie.
• Ceci s’applique également à un tableau fourni en valeur de
retour. Par exemple:

public int[] modifier (int n) {

int [] res = new int[n];
for (int i=0;i<n;i++) res[i] = i*i; //for each pas applicable
return res;
}

39
Tableaux de tableaux (ou tableaux
multidimensionnels)
• En Java, un tableau multidimensionnel est un tableau dont les
composants sont eux-mêmes des tableaux. C’est différent des
tableaux en C.
• Une conséquence de cela est que les lignes peuvent varier en
longueur.
• Cette possibilité offre en réalité une plus grande richesse puisqu’elle
permet de créer des tableaux irréguliers dans lesquelles les
différentes lignes peuvent avoir des tailles différentes
• Bien entendu, on pourra toujours créer des tableaux dont les lignes
ont la même taille.

40
 Déclaration et initialisation
• Lors de la déclaration d'un tableau de tableaux le nombre de crochets indique le nombre de
dimensions du tableau.
• Ces 3 déclarations sont équivalentes :
int tab[][]; Après de telles
int[][] tab; déclarations, le
tableau n’est pas
int []tab[]; créé
Considérons maintenant la déclaration suivante :
int t[][] = {new int [3], new int [2]};
L’évaluation de cette expression permet de créer un tableau de trois entiers et un autre de 2 entiers,
comme l’illustre le schéma suivant :
t

0 0 0 0 0
41
Déclaration et initialisation
• Un tableau de tableaux peut également être déclaré et initialisé comme suit si
on reprend le même exemple:
• int t[][] = new int [2][];
• t[0] = new int [3];
• t[1] = new int [2];
• Dans les deux cas, on a alloué un tableau destiné à recevoir les références des lignes.
• Puis on alloue une par une les lignes du tableau. Les lignes ne doivent pas nécessairement
avoir toutes la même longueur.

0 0 0 0 0
42
Déclaration et initialisation
• t[0] désigne la référence au premier tableau de 3 entiers.
• t[0][1] désigne le 2ème élément de ce tableau.
• t[1] désigne la référence au second tableau de 2 entiers.
• t[1][i-1] désigne le ième élément du second tableau.
• L’expression t.length vaut 2
• L’expression t[0].length vaut 3
• L’expression t[1].length vaut 2

43
Exemple
• Ecrire un programme qui crée un tableau de 3 lignes et où le
nombre de colonnes correspond au numéro de la ligne :
 Ligne 1 → 1 colonne
 Ligne 2 → 2 colonnes
 Ligne 3 → 3 colonnes

• Les cases de ce tableau seront initialisées par la somme de

l’indice de ligne et de l’indice de colonne

44
Exemple
public static void main(String[] args) {
int i, j;
int tab[][] = new int [3][];

for(i=0; i<tab.length;i++) {
tab[i] = new int[i+1];
for(j=0;j<tab[i].length;j++)
tab[i][j]=i+j;
}
}

45
Cas des tableaux rectangulaires
• Si l'on souhaite obtenir un tableau où toutes les lignes ont la
même taille.
• Java permet cette écriture pour obtenir par exemple une
matrice d’entiers de nLig lignes et de nCol colonnes :
• int tab[][] = new int [nLig][nCol];

46
Exemple tableau rectangulaire
• Ecrire un programme qui crée une matrice de 2 lignes et de 3
colonnes et qui initialise chaque case par la somme de l’indice
de lignes et de l’indice de colonne.

47
Exemple tableau rectangulaire
public static void main(String[] args) {
int i, j;
int tab[][] = new int [2][3];
for(i=0; i<tab.length;i++)
for(j=0;j<tab[i].length;j++)
tab[i][j]=i+j;

48
for .. each et tableau de tableaux
• Que va afficher le programme de l’exemple précédent ?
public static void main(String[] args) {
int i, j;
int tab[][] = new int [2][3];
for(i=0; i<tab.length;i++)
for(j=0;j<tab[i].length;j++)
tab[i][j]=i+j;
for(int v[] :tab) {
for(int w : v) {
System.out.print(w);
}
System.out.println();
}
}

49
Chaînes de caractères
• Les chaînes de caractères ne sont pas considérées en Java
comme un type primitif ou comme un tableau.
• On utilise une classe particulière, nommée String, fournie dans
le package java.lang.
• Les objets de la classe String ont les caractéristiques suivantes :
 leurs valeurs ne peuvent pas être modifiées (non mutables) en
mémoire
 on peut utiliser l’opérateur + pour concaténer deux chaînes de
caractères.

50
Chaîne de caractères : déclaration et
initialisation
• Java offre plusieurs possibilités de déclarer et d’initialiser une
chaîne de caractères :
String ch = "hello"; // déclare un objet String
contenant la référence au String "hello"

"hello"

ch

51
Chaîne de caractères : déclaration et
initialisation
• La classe String dispose de deux constructeurs, l’un sans
argument créant une chaîne vide, l’autre avec argument de
type String qui en crée une copie.
• Exemple:

String ch1 = new String(); //contient une référence à une chaîne vide
String ch2 = new String("hello"); //contient une référence à une chaîne
contenant "hello"
String ch3 = new String(ch2);//contient la référence à une chaîne (ch2)
contenant "hello"

52
Longueur d’une chaîne
• La méthode length() permet d’obtenir la longueur d’une chaîne
i.e. le nombre de caractères qu’elles contient
• Exemples :
String ch = "";
int n = ch.length(); // n contient 0
String ch1 = "bonjour";
n = ch1.length(); // n contient 7

• Remarque : contrairement aux tableaux où length désignait

un attribut, pour les objets String length est une méthode, les
parenthèses sont donc indispensables

53
Comparaison de chaînes
• Comparer les chaînes de caractères en utilisant les opérateurs
== ou != permet de comparer uniquement les références à ces
chaînes.
• Deux chaînes de valeurs différentes ont toujours des
références différentes. En revanche, deux chaînes de même
valeur ne correspondent pas nécessairement à un seul et
même objet.
• La classe String fournit une méthode equals() qui compare le
contenu de deux chaînes.
• Exemple :
String ch = "hello";
System.out.println(ch.equals("hello")); //affiche true

54
Chaînes de caractères : objets non
mutables (immutables)
• Les objets chaînes de caractères sont dits « non mutables »
• Cela signifie qu’ils ne sont pas modifiables en mémoire
• Exemple :
str "old value"
String str = "old value";
Reference contenu non modifiable

str = "new value";

str "old value"

On ne peut pas éditer "old value" "new value"

on crée un autre objet "new value"
55
 Création de chaînes de caractères
sans « new »
Exemple 1 Avantages
String str1 = "value 1"; • Grace à la nature non mutable des
objet String ils peuvent référencer le
String str2 = str1; même contenu sans qu’il n’y ait des
problèmes de cohérence au cas où une
modification est opérée
Exemple 2 • Java utilise le Java Pool pour
assigner la même valeur pour tous les
String str1 = "value 1"; String créés sans l’opérateur new.
Cela permet un gain d’espace
String str2 = "value 1";
considérable

//str1 et str2 font référence à la même

chaîne grâce à l'utilisation du string pool

56
Java et la modularité
• La programmation modulaire consiste à décomposer un
problème en un ensemble de sous-problèmes ou modules.
• La programmation orientée objet est fortement modulaire car
chaque objet est un module.
• En Java, cette décomposition modulaire s'effectue sur
plusieurs niveaux imbriqués les uns dans les autres :
 Un paquetage (package) renferme les classes d'un même thème
 Une classe contient des attributs et des méthodes
 Une méthode a des paramètres et un bloc d'instruction
 Un bloc d'instruction contient des variables locales et d'autres
blocs...

57
Notion de paquetage (package)
• Cette notion correspond à un groupement logique d’un
ensemble de classes sous un identificateur commun.
• Cette notion est proche de celle des bibliothèques que l’on
retrouve dans d’autres langages.
• Cette notion facilite le développement de logiciels conséquents
en permettant de répartir les classes correspondantes dans
différents paquetages.
• Le risque de créer deux classes de même nom est limité
uniquement à l’intérieur d’un même paquetage.

58
Utilisation d’une classe d’un
paquetage
• Lorsque dans un programme on fait référence à une classe, le
compilateur la recherche dans le paquetage par défaut.
• Pour utiliser une classe appartenant à un autre paquetage, il
est nécessaire soit :
1. de citer le nom du paquetage avec le nom de la classe
2. d’utiliser l’instruction import en citant soit une classe
particulière d’un paquetage, soit tout le paquetage.

59
(1) En citant le nom de la classe
• Si la classe Rectangle fait partie du package FormeGeo, on peut
utiliser cette classe comme suit :
FormeGeo.Rectangle rec = new FormeGeo.Rectangle();

…
rec.affiche(); // ici le nom du paquetage n'est pas requis

• Evidemment cette démarche devient fastidieuse dès que le

nombre de classes concernées est grand.

60
(2) En important une classe
• L’instruction import permet de citer le nom complet d’une ou
plusieurs classes, par exemple :
import FormeGeo.Rectangle, ForGeo.Carre;
• A partir de cette instruction, on peut utiliser les classes
Rectangle et Carre sans avoir à mentionner leur nom de
package.
• Si un certain nombre de classes d’un même package est
concerné par l’import, il suffit d’utiliser l’instruction :
import FormeGeo.*
• Toutes les classes du package FormeGeo pourront être
utilisées.

61