Programmation Orientée Objet

Introduction à Java
Riadh BOUSLIMI

bouslimi.riadh@gmail.com
PRÉSENTATION GÉNÉRALE

2
 Programmation orientée objet

Ressources et références
 Programmer en Java, C. Delannoy, Ed. Eyrolles, 2014
 Thinking in Java, B. Eckel, Prentice Hall, 2006
Traduction française diponible en ligne
http://bruce-eckel.developpez.com/livres/java/traduction/tij2/
Les tutoriels Oracle
https://docs.oracle.com/javase/tutorial/
La documentation de l’API standard
https://docs.oracle.com/javase/8/docs/api/

3
 Programmation orientée objet

Plan du cours
Les bases
 Introduction
 Types primitifs et opérateurs
 Classes et objets
 Tableaux
Héritage et polymorphisme
Chaînes de caractères
Exceptions
Entrées-sorties
Généricité et collections
Compléments sur le langage
4
PRÉSENTATION

5
 Programmation orientée objet

Paradigmes de programmation
Un paradigme de programmation est un ensemble de concepts et de
méthodes de programmation autorisés ou interdits.
Tout programme peut s’écrire dans n’importe quel paradigme mais la
façon de l’exprimer change.
Un paradigme va guider la conception et l’implémentation d’un
algorithme.

6
 Programmation orientée objet

Exemples de paradigmes de programmation

Programmation fonctionnelle. Un programme est une fonction (au sens
mathématique du terme).
Programmation impérative. Un programme est une suite d'instructions
qui modifient l‘état du système.
Programmation structurée. Variante de la programmation impérative,
le flot d'exécution du programme est dicté par des structures de
contrôle.
Programmation orientée objet. Un programme est un ensemble de
briques logicielles qui interagissent entre elles.

7
 Programmation orientée objet

La Programmation Orientée Objet

 Les concepts mis en avant par la POO sont
 L’abstraction
 La modularité
 L’encapsulation
 Le polymorphisme
 Les outils qui supportent ces concepts sont :
 Les classes ou les prototypes En Java
 L’héritage (simple ou multiple)
 Le système de typage (statique ou dynamique, explicite ou inféré)
 Points forts (supposés)
 Du code plus proche du monde réel et donc plus facile à assimiler et à maintenir.
 Stabilité accrue : les modifications ne s’appliquent que localement à des sous-systèmes.

8
 Programmation orientée objet

Gestion des notes d’une université

Objets Fonctions (méthodes)
 Etudiant  Calculer la moyenne individuelle
 Statut, matières, notes  Calculer la moyenne générale
 Matière  Calculer la moyenne par matière
 Etudiants, ECTS
 Valider l’année
 Diplôme
 Déterminer les matières à rattraper
 Année, matières
 Calculer les taux de réussite
 Procès verbal
 Etudiants, diplôme
Des données Des comportements
Les objets s’échangent des messages en
fonction de leurs comportements associés.
10
 Programmation orientée objet

Historique
 Simula-67 : Dahl et Nygaard http://www.simula.no
 Smalltalk-71 : A. Kay http://www.smalltalk.org
 C++ 79-85 : Stroustrup
 Eiffel 85 : B. Meyer http://www.eiffel.com
 Java 94-95 : J. Gosling/Sun http://java.sun.com
 Ruby 95 : Y. "Matz" Matsumoto http://www.ruby-lang.org
 C# 2000 : Microsoft http://www.learn-c-sharp.com
 Scala 2003 : Martin Odersky http://www.scala-lang.org

 Turing Award 2001 à Dahl et Nygaard

 "For ideas fundamental to the emergence of object oriented programming, through their design
of the programming languages Simula I and Simula 67."

10
LES NOTIONS ESSENTIELLES

11
 Programmation orientée objet

Types de données
Réalise un Type Abstrait de données (au sens algorithmique)
Un type de données définit
 Un domaine de valeur
 Un ensemble d’opérations autorisées
En java, on distingue
 Les types primitifs (entiers, flottants, booléens, caractères)
 Les types référence, objets définis à partir des types primitifs et/ou d’autres
types références.
• Une couleur RGB est un triplet d’entiers
• Une image Bitmap est un ensemble de pixels de couleur

12
 Programmation orientée objet

Types primitifs
En java, il existe 8 types primitifs
 1 type booléen : boolean
 4 types entiers : byte, short, int, long
 2 types flottants : float, double
 1 type caractère : char
A la différence d’autres langages (comme C++), la taille en mémoire des
types primitifs est entièrement défini par le langage.
Type byte short int long float double boolean char
Taille (en octets) 1 2 4 8 4 8 1 2

13
 Programmation orientée objet

Variables
Pour déclarer une variable, on indique son type et son nom.
boolean isRunning;
double precision;

On peut affecter le résultat d’une expression à une variable déclarée.

Une variable qui a reçu au moins une affectation est dite initialisée.
isRunning = true;
precision = 1.0 / 1000;

Il est usuel de simultanément déclarer et initialiser une variable

boolean isRunning = true;
double precision = 1.0 / 1000;

Il est interdit de manipuler une variable non initialisée!

14
 Programmation orientée objet

Type primitif boolean

Valeurs : true, false
Opérations autorisées
 Comparaisons == !=
 Opérations booléennes ! & && | || ^
Exemples
 boolean estVrai = true && !false;
 boolean estFaux = estVrai ^ estVrai;

Opérations avec court-circuit

 boolean erreur = false & (1 / 0 == 0);
 boolean correct = false && (1 / 0 == 0);

15
 Programmation orientée objet

Les entiers relatifs

Quatre types primitifs (en fonction de leur taille)
 byte 8 bits [-128, 127]
 short 16 bits [-32768, 32767]
 int 32 bits [-231, 231 - 1]
 long 64 bits [-263, 263 - 1]
Opérations autorisées
 Comparaisons == != < <= > >=
 Opérations arithmétiques + - * / %
 Opérations binaires & | ~ << >> >>>
Exemples
13 / 6 -> 2 13 & 6 -> 4
13 % 6 -> 1 13 / 0 -> Erreur!

16
 Programmation orientée objet

Constantes entières
On peut affecter une constante entière à une variable.
byte val = 13; int val2 = 6;

La constante doit être dans l’intervalle autorisé par le type.

byte val = 128;

On peut écrire les constantes en hexadécimal (préfixe 0x) ou en octal

(préfixe 0).
31 == 0x1F && 31 == 037 // true
-1 == 0xFFFFFFFF && -1 == 037777777777 // true

Par défaut, les constantes entières sont de type int. On peut les forcer à
être de type long à l’aide du suffixe L.
long val = 0x100000000; long val = 0x100000000L;
-1 != 0xFFFFFFFFL && -1 != 037777777777L // true

17
 Programmation orientée objet

Les nombres flottants

Deux types primitifs (en fonction de leur taille)
Type Taille Valeur absolue minimale Valeur absolue Maximale
float 32 bits 1.40239846e-45 3.40282347e38
double 64 bits 4.9406564584124654e-324 1.797693134862316e308

Opérations autorisées
 Comparaisons == != < <= > >=
 Opérations arithmétiques + - * /
Exemples
 13.0 / 2.0 -> 6.5
 13.0 / 0.0 -> +∞
Les opérations arithmétiques ne produisent jamais d’erreur sur les
nombres flottants.
18
 Programmation orientée objet

Constantes flottantes
On peut affecter une constante flottante à une variable.
double val = 13.0; double val = 1.3e1;
La constante doit avoir un valeur absolue autorisée par le type.
double val = 10e308;
Par défaut, les constantes flottantes sont de type double. On peut les
forcer à être de type float à l’aide du suffixe f.
float val = 0.1; float val = 0.1f;
Le calcul sur les nombres flottants est sujet aux erreurs de précision.
0.8 == 0.4 + 0.4; // true
0.8 == 0.7 + 0.1; // false
Il existe des constantes spéciales pour les nombres flottants.
Float.POSITIVE_INFINITY Float.NEGATIVE_INFINITY Float.NaN
Double.POSITIVE_INFINITY Double.NEGATIVE_INFINITY Double.NaN

20
 Programmation orientée objet

Type primitif char

Représente les caractères. Le codage retenu est l’Unicode 16 bits.
Opérations autorisées
 Comparaisons == != < <= > >=
Exemples
 char c = 'c'; // code ASCII 99
 c = '\u00e9'; // code unicode 00e9 => é
 c = '\t'; // la tabulation, code unicode 0009
 c = '\n'; // le saut de ligne, code unicode 0010
 c = '\\'; // le slash
 c = '\''; // le quote

21
 Programmation orientée objet

Opérations et promotion
Exemple de l’addition
 int +(int, int)
 long +(long, long)
 float +(float, float)
 double +(double, double)

Promotion
 byte -> short -> int -> long -> float -> double
 char -> int -> long -> float -> double

Exemples
 1 + 2L; // 3L
 1 + 2.0; // 3.0
 'e' - 'a'; // 4

21
 Programmation orientée objet

Affectations combinées +=
Incrémente une variable
 <variable> += <expression>;

Attention
 Surchargée pour tous les types numériques
• byte, short, int, long, float, double
 Différent d’une addition
• byte b = 127;
• b = b + b; b += b;
int +(int, int) byte +=(int)
Variantes
 -= *= /= <<= >>= >>>= &= |=
 b++ ++b
 &&= et ||= n’existent pas!

22
 Programmation orientée objet

Cast
Par promotion, on peut écrire :
byte shortVar = 10;
int var = shortVar; // var = 10

Par contre, l’affectation suivante est interdite :

int var = 10;
byte shortVar = var; // un byte n’est pas assez grand pour contenir un int

Dans ce cas précis, la valeur est pourtant compatible, on peut forcer la

conversion à l’aide d’un cast :
int var = 10;
byte shortVar = (byte)var; // shortVar = 10

Il est possible de perdre de l’information lors d’une conversion.

byte b = (byte)257; // b = 1

23
 Programmation orientée objet

Structure de contrôle : if
La syntaxe du branchement conditionnelle est
if (condition) instruction_1
[else instruction_2]
Une instruction peut-être
 une expression terminée par un point virgule (une instruction simple)
 Un bloc d’instructions entre accolades
if (x % 2 == 0) x /= 2; // instruction simple if (x % 2 == 0) { // mieux
else { // bloc x /= 2;
x *= 3; } else {
x++; x *= 3;
x++;
}
}
Un bloc peut se limiter à une seule instruction.
On conseille de toujours utiliser un bloc pour les structures de contrôle.

24
 Programmation orientée objet

Structure de contrôle : switch

La structure switch permet de faire un branchement multiple.
switch (expression) {
case constante_1: [instructions_1]
case constante_2: [instructions_2]
...
case constante_k: [instructions_k]
[default: instructions]
}

Cherche la première constante égale à l’expression et exécute les

instructions qui suivent.
Si aucune constante ne correspond, réalise les instructions par défaut.
La structure est limitée aux valeurs entières.
25
 Programmation orientée objet

Structure de contrôle : switch

Exemple :
int x = 2;
switch (x % 2) {
case 0:
x /= 2;

case 1:
x *= 3;
x++;

default:
x = -1;
}
x == ?
26
 Programmation orientée objet

Structure de contrôle : switch

Exemple :
int x = 2;
switch (x % 2) { On branche ici.
case 0:
x /= 2;

case 1:
x *= 3; Donc toutes ces instructions sont exécutées
x++;

default:
On ajoute le mot clé break pour sortir d’un cas.
x = -1;
}
x == -1
27
 Programmation orientée objet

Structure de contrôle : switch

Exemple :
int x = 2;
switch (x % 2) { On branche ici.
case 0:
x /= 2;
break;
On sort ici.
case 1:
x *= 3;
x++;
break;
default:
On ajoute le mot clé break pour sortir d’un cas.
x = -1;
}
x == 1
28
 Programmation orientée objet

Structure de contrôle : while

La syntaxe de la boucle while est
while (condition)
instruction

Tant que la condition est vraie, on exécute le corps de la boucle.

Variante la boucle do while

do instruction
while (condition);

On exécute le corps de la boucle tant que la condition est vraie. Le corps
s’exécute au moins une fois.
Le point virgule fait partie de la syntaxe.
30
 Programmation orientée objet

Structure de contrôle : for

La syntaxe de la boucle for est
for ([initialisation]; [condition]; [incrémentation])
instruction

L’initialisation est une déclaration ou une suite d’expressions séparées

par des virgules.
L’incrémentation est une suite d’expressions séparées par des virgules.
La condition est une expression booléenne. Si aucune condition n’est
donnée, la boucle est infinie.
int somme = 0; for (int i = 1, j = 8; j >= 0; i *= 2, j--) {
for (int i = 0; i < 10; i++) { System.out.println("i = " + i);
somme += i; System.out.println("j = " + j);
} }

30
 Programmation orientée objet

Les instructions break et continue

On a déjà vu l’effet de break dans l’instruction switch.
Dans une boucle (for, while ou do while), break sort immédiatement
de la boucle.
Dans une boucle, continue retourne au début du corps. S’il s’agit d’une
boucle for, l’incrémentation a lieu.

Ces instructions sont à éviter dans la mesure du possible car elles

rendent le code moins lisible.

31
 Programmation orientée objet

Classe = Type composé

 Types primitifs normalisés par le langage
 boolean, char, byte, short, int, long, float, double

 Composition => champs (nom + type)

 Couleur : rouge (8 bits) + vert (8 bits) + bleu (8 bits)
 Image : ensemble de pixels de couleur
 Nom : séquence/chaîne de caractères
 Date : ?

 Compromis espace mémoire/temps de calcul

 Couleur : RGB vs. YUV
 Nombre complexe: c = re + i.im Complexe
ou reelle : double
c = z.ei.θ imaginaire : double

32
 Programmation orientée objet

Classe : encodage
Couleur Complexe
class CouleurRGB { class ComplexeCartesien {
byte rouge; double reelle;
byte vert; double imaginaire;
byte bleu; }
}

class CouleurYUV { class ComplexePolaire {

byte luminance; double module;
byte chrominanceRouge; double argument;
byte chrominanceBleue; }
}

33
 Programmation orientée objet

Objet = instance d’une classe

Type valeurs → variables
objets → références
→
Complexe
Classe reelle : double
imaginaire : double

→
Complexe c1; // référence Complexe c2; // référence
c1 = new Complexe(1, -1); c2 = new Complexe(2, 0);

c1 : Complexe c2 : Complexe
c1 c2

34
 Programmation orientée objet

Méthode = opération sur les objets

Norme d’un complexe
class ComplexeCartesien { class ComplexePolaire {
double re; double module;
double im; double argument;

double norme() { double norme() {

return re * re + im * im; return module * module;
} }

double argument() { double argument() {

return Math.atan2(im, re); return argument;
} }
} }

35
 Programmation orientée objet

Notation pointée
Pour accéder aux membres d’un objet
 Membre = champs + méthodes
Complexe
reelle : double
Exemple imaginaire : double
norme() : double
 Complexe c1 = new Complexe();
 c1.reelle désigne le champ reelle de c1
 c1.norme() désigne la méthode norme de c1

36
 Programmation orientée objet

Méthodes et paramètres
Données supplémentaires
 Le calcul de la norme nécessite seulement la valeur de ‘reelle’ et de ‘imaginaire’
 Certaines méthodes nécessitent des paramètres
• Signature
int addition(int, int);
• Corps
int addition(int x, int y) {
return x + y ;
}

37
 Programmation orientée objet

Classe Moyenne
class Moyenne { // bloc de déclaration de classe
/* Somme des notes obtenues */
int notes = 0;
/* Nombre de notes obtenues */
int nombreDeNotes = 0;
/* Ajoute une note à la moyenne */
void ajouteNote(int note) {
notes += note;
nombreDeNotes += 1;
}
/* Renvoie la moyenne des notes */
double calculMoyenne() {
return ((double) notes) / nombreDeNotes;
}
}

38
 Programmation orientée objet

Classe String
Classe qui représente une séquence de caractères
 Classe spéciale (utilisation très fréquente)
• Pas besoin d’utiliser new pour créer des instances
String str = "Un exemple!";
• Les objets sont immutables (on ne peut pas les modifier)
L’expression "rou" + "ge" fait intervenir 3 objets différents

 Concaténation
int x = 20, y = 40;

"Je place " + x + " euros." "Je place 20 euros."

x + y + " euros sont placés." "60 euros sont placés."
"Je place " + x + y "Je place 2040"

40
Programmation orientée objet

Vocabulaire

m1

12
0
01

41
ENVIRONNEMENT DE DÉVELOPPEMENT

41
 Programmation orientée objet

Compilateur
L’ordinateur (son processeur) ne comprend pas le code Java (code
source)
Un interpréteur interprète directement le code source (langage
interprété)
Le compilateur traduit (compile) le code source
 Vers du code binaire natif (langage compilé)
• Spécifique à un processeur donné
• Spécifique au système d’exploitation utilisé
 Vers un langage neutre (ex: bytecode)
• Ce langage neutre est alors interprété par la machine virtuelle java (Java Virtual Machine -
JVM)

42
 Programmation orientée objet

Processus de compilation en Java

Fichier source Test.java

Compilation javac Test.java

(JDK)
interprétation

bytecode Test.class java Test

API JRE 7.0

JRE
Write once, Run everywhere
OS Windows, Mac, Linux

Processeur Intel, AMD, ARM

43
 Programmation orientée objet

Méthode main – java Test

Test.java: Moyenne.java:

public class Test { class Moyenne {

int notes = 0 ;
int nombreDeNotes = 0 ;
Moyenne e = new Moyenne();
void ajouteNote (int note) {
e.ajouteNote(8); notes += note;
e.ajouteNote(18); nombreDeNotes += 1;
e.ajouteNote(12); }

double m = e.calculMoyenne(); double calculMoyenne() {

return ((double)notes) /
nombreDeNotes ;
}
} }

44
 Programmation orientée objet

Méthode main – java Test

Test.java:

public class Test {

public static void main(String[] args) {

Moyenne e = new Moyenne();

e.ajouteNote(8);
e.ajouteNote(18);
e.ajouteNote(12);

double m = e.calculMoyenne();

System.out.println("Moyenne=" + m);
}
}

45
 Programmation orientée objet

Méthode main – java Test

Test.java:

public class Test { > dir

Moyenne.java
public static void main(String[] args) {
Moyenne e = new Moyenne(); Test.java
> javac Test.java
e.ajouteNote(8); > dir
e.ajouteNote(18); Moyenne.class
e.ajouteNote(12);
Moyenne.java
double m = e.calculMoyenne(); Test.class
Test.java
System.out.println("Moyenne=" + m); > java Test
}
Moyenne = 12.666666666666666
}

46