Upload
doanhanh
View
249
Download
0
Embed Size (px)
Citation preview
Programmation Orientée Objet
Introduction à Java
Julien Provillard
http://www.i3s.unice.fr/~provilla/poo/[email protected]
PRÉSENTATION GÉNÉRALE
2
Programmation orientée objet
Organisation du cours
Volume Horaire
12 séances de 1h30 de cours magistral
12 séances de 1h30 de TP sur machine
Evaluation
Contrôle terminal en fin de semestre: 60%
Contrôle continu en TP: 20% + 20%
3
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/
4
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
5
PRÉSENTATION
6
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.
7
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.
8
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
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.
9
En Java
Programmation orientée objet
Gestion des notes d’une université
Objets
Etudiant Statut, matières, notes
Matière Etudiants, ECTS
Diplôme Année, matières
Procès verbal Etudiants, diplôme
Fonctions (méthodes)
Calculer la moyenne individuelle
Calculer la moyenne générale
Calculer la moyenne par matière
Valider l’année
Déterminer les matières à rattraper
Calculer les taux de réussite
10
Les objets s’échangent des messages enfonction de leurs comportements associés.
Des données Des comportements
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."
11
LES NOTIONS ESSENTIELLES
12
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
13
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.
14
Type byte short int long float double boolean char
Taille (en octets) 1 2 4 8 4 8 1 2
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 variableboolean isRunning = true;
double precision = 1.0 / 1000;
Il est interdit de manipuler une variable non initialisée!
15
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);
16
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 & | ~ << >> >>>
Exemples13 / 6 -> 2 13 & 6 -> 4
13 % 6 -> 1 13 / 0 -> Erreur!
17
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
18
Programmation orientée objet
Les nombres flottants
Deux types primitifs (en fonction de leur taille)
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.
19
Type Taille Valeur absolue minimale Valeur absolue Maximale
float 32 bits 1.40239846e-45 3.40282347e38
double 64 bits 4.9406564584124654e-324 1.797693134862316e308
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
2014-2015 J. Provillard - POO 22
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;
Variantes -= *= /= <<= >>= >>>= &= |= b++ ++b &&= et ||= n’existent pas!
2014-2015 J. Provillard - POO 23
int +(int, int) byte +=(int)
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
24
Programmation orientée objet
Structure de contrôle : if
La syntaxe du branchement conditionnelle estif (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 accoladesif (x % 2 == 0) x /= 2; // instruction simple
else { // bloc
x *= 3;
x++;
}
Un bloc peut se limiter à une seule instruction.
On conseille de toujours utiliser un bloc pour les structures de contrôle.
25
if (x % 2 == 0) { // mieuxx /= 2;
} else { x *= 3;x++;
}
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.
26
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;
}
27
x == ?
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;
}
28
x == -1
On branche ici.
Donc toutes ces instructions sont exécutées
On ajoute le mot clé break pour sortir d’un cas.
Programmation orientée objet
Structure de contrôle : switch
Exemple :int x = 2;
switch (x % 2) {
case 0:
x /= 2;
break;
case 1:
x *= 3;
x++;
break;
default:
x = -1;
}
29
x == 1
On branche ici.
On ajoute le mot clé break pour sortir d’un cas.
On sort ici.
Programmation orientée objet
Structure de contrôle : while
La syntaxe de la boucle while estwhile (condition)
instruction
Tant que la condition est vraie, on exécute le corps de la boucle.
Variante la boucle do whiledo 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 estfor ([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);
} }
31
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.
32
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
ou c = z.ei.θ
2014-2015 J. Provillard - POO 33
Complexe
reelle : doubleimaginaire : double
Programmation orientée objet
Classe : encodage
Couleurclass CouleurRGB {
byte rouge;
byte vert;
byte bleu;
}
class CouleurYUV {
byte luminance;
byte chrominanceRouge;
byte chrominanceBleue;
}
Complexeclass ComplexeCartesien {
double reelle;
double imaginaire;
}
class ComplexePolaire {
double module;
double argument;
}
2014-2015 J. Provillard - POO 34
Programmation orientée objet
Objet = instance d’une classe
Type → valeurs → variables
Classe → objets → références
2014-2015 J. Provillard - POO 35
Complexe
reelle : doubleimaginaire : double
Complexe c1; // référencec1 = new Complexe(1, -1);
c1
Complexe c2; // référencec2 = new Complexe(2, 0);
c1 : Complexe
c2
c2 : Complexe
Programmation orientée objet
Méthode = opération sur les objets
Norme d’un complexeclass ComplexeCartesien {
double re;
double im;
double norme() {
return re * re + im * im;
}
double argument() {
return Math.atan2(im, re);
}
}
class ComplexePolaire {
double module;
double argument;
double norme() {
return module * module;
}
double argument() {
return argument;
}
}
2014-2015 J. Provillard - POO 36
Programmation orientée objet
Notation pointée
Pour accéder aux membres d’un objet
Membre = champs + méthodes
Exemple Complexe c1 = new Complexe();
c1.reelle désigne le champ reelle de c1
c1.norme() désigne la méthode norme de c1
2014-2015 J. Provillard - POO 37
Complexe
reelle : doubleimaginaire : double
norme() : double
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 ;
}
2014-2015 J. Provillard - POO 38
Programmation orientée objet
Classe Moyenneclass 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;
}
}
2014-2015 J. Provillard - POO 39
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énationint 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"
2014-2015 J. Provillard - POO 40
Programmation orientée objet
Vocabulaire
2014-2015 J. Provillard - POO 41
00
121
m1
ENVIRONNEMENT DE DÉVELOPPEMENT
42
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)
2014-2015 J. Provillard - POO 43
Programmation orientée objet
Processus de compilation en Java
2014-2015 J. Provillard - POO 44
Processeur
OS
JREAPI
Test.javaFichier source
javac Test.javaCompilation(JDK)
Test.classbytecode java Test
interprétation
JRE 7.0
Windows, Mac, Linux
Intel, AMD, ARM
Write once, Run everywhere
Programmation orientée objet
Méthode main – java TestTest.java:
public class Test {
Moyenne e = new Moyenne();
e.ajouteNote(8);e.ajouteNote(18);e.ajouteNote(12);
double m = e.calculMoyenne();
}
Moyenne.java:
class Moyenne {int notes = 0 ; int nombreDeNotes = 0 ;
void ajouteNote (int note) {notes += note;nombreDeNotes += 1;
}
double calculMoyenne() {return ((double)notes) /
nombreDeNotes ;}
}
45
Programmation orientée objet
Méthode main – java TestTest.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);}
}
46
Programmation orientée objet
Méthode main – java TestTest.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);}
}
47
> dir
Moyenne.java
Test.java
> javac Test.java
> dir
Moyenne.class
Moyenne.java
Test.class
Test.java
> java Test
Moyenne = 12.666666666666666