Cours 3: Introduction
à Java
1
Java et la portabilité
• Un programmeur Java écrit son code source, sous la forme de
classes, dans des fichiers dont l’extension est « .java ».
• Ce code source est alors compilé par le compilateur javac en
un langage appelé « bytecode » et enregistre le résultat dans
un fichier dont l’extension est .class.
• Le bytecode ainsi obtenu n’est pas directement utilisable. Il
doit être interprété par la machine virtuelle Java qui
transforme alors le code compilé en code machine
compréhensible par le système d’exploitation.
• C’est la raison pour laquelle Java est un langage portable : le
bytecode reste le même quel que soit l’environnement
d’exécution.
2
Java et la programmation
événementielle
• Généralement, on distingue 2 grandes catégories de programme
selon la manière dont se font les échanges avec l’utilisateur:
Les programmes à interface console (ou en ligne de commande)
Les programmes à interface graphique (GUI)
• Les programmes à interface console sont les plus anciens. Ils
n’utilisent qu’une seule fenêtre et les informations sont fournies aux
programmes sous forme de lignes de texte.
• Dans les programmes à interface graphique, la communication avec
l’utilisateur se fait par l’intermédiaire de composants tels que les
menus déroulants, les boites de dialogues, … le programme répond
aux différentes demandes de l’utilisateur.
• On parle de programmation événementielle car le programme réagit
à des évènements provoqués par l’utilisateur.
3
Java et la programmation
événementielle
• La plupart des langages dispose d’instructions ou de
procédures standards qui permettent de réaliser les entrées-
sorties en mode console mais les interfaces graphiques ne sont
pas gérée en natif.
• Java intègre des outils de gestion des interfaces graphiques
sous forme de classes standards.
• Le même code source pourra être utilisé pour différents
environnements et s’exécuter sur différentes machines sans
être modifié
4
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
[Link] Classes graphiques et de gestion d’interfaces
[Link] Gestion des entrées/sorties
[Link] Classes de base (importé par défaut)
[Link] Classes utilitaires
[Link] Autres classes graphiques
• Une documentation en ligne pour l’API java est disponible à l’URL :
[Link]
• Toutes ces classes sont organisées en packages (ou bibliothèques) dédiés à un thème
précis.
5
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 [Link]
(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 [Link] ;
2. toutes les classes du package sont importées (même les
classes non utilisées) :
import [Link].* ;
6
Classe en Java
• Une classe regroupe un ensemble de données (qui peuvent être
des variables primitives ou des objets) et un ensemble de
méthodes de traitement de ces données et/ou de données
extérieures à la classe
• Pour écrire un programme avec Java, le programmeur écrit
uniquement des classes correspondant aux objets de son
système.
• 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 une classe, dite “exécutable”, dont une
méthode peut être appelée pour exécuter le programme.
7
Exemple
public class Point {
int x; //abscisse
int y; //ordonnées
public void deplace(int abs, int ord) {
x += abs;
y += ord;
}
}
8
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 classe doit définir une ou plusieurs méthodes
constructeurs
• Une méthode constructeur peut être vide ou contenir les
instructions nécessaires à l'initialisation d'un objet
• Chaque constructeur doit avoir le même nom que la classe où
il est défini et n'a aucune valeur de retour: c'est l'objet créé qui
est renvoyé
9
Exemple
public class Point {
…
Point (int abs, int ord) {
x = abs;
y = ord;
Instanciation
}
de l’objet p
…
Point p = new Point(24, 5);
}
10
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
est une une référence à cet objet (pointeur).
• 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.
11
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;
[Link](3, 12);
12
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é)
13
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.
14
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
15
Les types flottants
• Java prévoit deux types de flottants correspondant chacun à
des emplacements mémoire de différentes tailles : float et
double
• Les constantes flottantes 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 ;
16
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' ;
17
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.
18
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.
19
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
20
Opérateurs et expression
• Les opérateurs arithmétiques, relationnels 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
21
Opérateurs et expression
• 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)
22
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
23
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.
24
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... 25
Instruction de contrôle de Java
• Les instructions de contrôle sont proches du langage C (et du
Pascal). 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.
26
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.
Cette instruction sera par exemple rejetée par le compilateur :
int tab[5];
27
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)
0
Exemple :
0
int tab[] ; tab = new int[5] ; // tab fait 0
référence à un tableau de 5 entiers 0
• Les 5 éléments créés sont initialisés par défaut 0
(comme tous les champs d’un objet) à une valeur
« nulle » (0 par un int). On peut illustrer la
situation par ce schéma: tab
28
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 :
Cette notation n’est valable qu’au moment de la déclaration du
tableau
29
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] ;
[Link]("taille de t :"+[Link]);//affiche 5
30
Exemple de tableau d’objets
• Les éléments d’un tableau peuvent être de type quelconque.
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);
31
Utilisation de la boucle for …each
• La boucle for …each a été introduite dans la JDK 5.0
• Exemple: double t []; for (double v :t) [Link](v);
• Avec cette instruction : [Link](v);
• La variable v prendra les différentes valeurs de t ce qui équivaut à :
for (int i = 0; i<[Link] ; i++) [Link](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
32
Tableau et fonction
• 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;
}
33
Tableaux de tableaux (à plusieurs
indices)
• Java ne dispose pas de la notion de tableau multi
dimensionnels qui permettent de représenter une matrice
mathématique
• Il permet néanmoins de la simuler en créant des tableaux de
tableaux: des tableaux dont les éléments sont des tableaux.
• 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.
34
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. 0
• Ces 3 déclarations sont équivalentes : 0
int tab[][]; Après de telles 0
déclarations, le
int[][] tab; tableau n’est pas
créé
int []tab[];
Considérons maintenant la déclaration suivante :
0
int t[][] = {new int [3], new int [2]}; 0
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
35
Déclaration et initialisation
• Un tableau de tableaux peut également
être déclaré et initialisé comme suit si on
reprend le même exemple: 0
0
• int t[][] = new int [2][];
0
• 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. 0
0
• Puis on alloue une par une les lignes du tableau.
Les lignes ne doivent pas nécessairement avoir
toutes la même longueur.
t
36
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 [Link] vaut 2
• L’expression t[0].length vaut 3
• L’expression t[1].length vaut 2
37
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
38
Exemple
public static void main(String[] args) {
int i, j;
int tab[][] = new int [3][];
for(i=0; i<[Link];i++) {
tab[i] = new int[i+1];
for(j=0;j<tab[i].length;j++)
tab[i][j]=i+j;
}
}
39
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];
40
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.
41
Exemple tableau rectangulaire
public static void main(String[] args) {
int i, j;
int tab[][] = new int [2][3];
for(i=0; i<[Link];i++) {
for(j=0;j<tab[i].length;j++)
tab[i][j]=i+j;
}
42
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<[Link];i++) {
for(j=0;j<tab[i].length;j++)
tab[i][j]=i+j;
for(int v[] :tab) {
for(int w : v) {
[Link](w);
}
[Link]();
}
}
43
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 [Link].
• Les variables de type String ont les caractéristiques suivantes :
leurs valeurs ne peuvent pas être modifiées (non mutables)
on peut utiliser l’opérateur + pour concaténer deux chaînes de
caractères.
44
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 à l'objet String "hello"
hello
ch
45
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 copie de
ch2, contenant donc "hello"
46
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 = [Link](); // n contient 0
String ch1 = "bonjour";
n = [Link](); // n contient 7
• Remarque : contrairement aux tableaux où length désignait
un champ, pour les objets String length est une méthode, les
parenthèses sont donc indispensables
47
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";
[Link]([Link]("hello")); //affiche true
48
Quelques conventions
• En Java :
Une classe commence par une majuscule
Un attribut, une méthode ou une variable locale commence par une
minuscule
• On utilise la convention CamelCase
CeciEstUneClasse, ceciEstUnAttribut, ceciEstUneMethode,…
• On utilise _ uniquement pour les constantes :
CECI_EST_UNE_CONSTANTE
• Il faut essayer de respecter au maximum ces conventions
49
