Programmation Orientée Objet Introduction à Javaprovilla/poo/resources/pdf/cours_01.pdf · A la différene dautres langages (omme C++), la taille en mémoire des ... Programmation

Programmation Orientée Objet

Introduction à Java

Julien Provillard

http://www.i3s.unice.fr/~provilla/poo/[email protected]

http://www.i3s.unice.fr/~provilla/poo/

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


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

http://bruce-eckel.developpez.com/livres/java/traduction/tij2/

https://docs.oracle.com/javase/tutorial/

https://docs.oracle.com/javase/8/docs/api/


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


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


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


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


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


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

http://www.simula.no/

http://www.smalltalk.org/

http://www.eiffel.com/

http://java.sun.com/

http://www.ruby-lang.org/

http://www.learn-c-sharp.com/

http://www.scala-lang.org/

LES NOTIONS ESSENTIELLES

12


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


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


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


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


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


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


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


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


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


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


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!


int +(int, int) byte +=(int)


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


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

}


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



Exemple :int x = 2;

switch (x % 2) {

case 0:

x /= 2;

case 1:

x *= 3;

x++;

default:

x = -1;

}

27

x == ?



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.



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.


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


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


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


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.θ


Complexe

reelle : doubleimaginaire : double


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;

}



Objet = instance d’une classe

Type → valeurs → variables

Classe → objets → références


Complexe


Complexe c1; // référencec1 = new Complexe(1, -1);

c1

Complexe c2; // référencec2 = new Complexe(2, 0);

c1 : Complexe

c2

c2 : Complexe


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;

}

}



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


Complexe


norme() : double


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 ;

}



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;

}

}



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"



Vocabulaire


00

121

m1

ENVIRONNEMENT DE DÉVELOPPEMENT

42


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)



Processus de compilation en Java


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


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



public class Test {

public static void main(String[] args) {Moyenne e = new Moyenne();



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

}

46



public class Test {

public static void main(String[] args) {Moyenne e = new Moyenne();



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

Documents

Programmation Orientée Objet Introduction à Javaprovilla/poo/resources/pdf/cours_01.pdf · A la différene dautres langages (omme C++), la taille en mémoire des ... Programmation