Programmation Orientée Objet en Java

(cid:1) délimités par { } (cid:1) qui peuvent être imbriqués

(cid:1) Les commentaires :

(cid:1) Sur une seule ligne : // mon commentaire (cid:1) Sur plusieurs lignes : /* */

(cid:1) Les constantes sont définies avec le mot clé final : leur valeur ne peut pas être modifiée: final double pi=3.14 ;

(cid:1) Types primitifs: int, long, float, double, char, String,

boolean,..

35

Types Primitifs de Java

36

Initialisation

37

Types de données primitifs

(cid:1) Explication:

(cid:1) byte : codé sur 8 bits (cid:1) 28 valeurs (cid:1) (–27) to (27–1) = -128 à 127 (cid:1) int : codé sur 32 bits (cid:1) 232 valeurs (cid:1) (–231) to (231–1)

(cid:1) Déclaration et initialisation :

int x=12; short x= 32; (short x=33000; // Hors limite)

(cid:1) int (cid:1) short (cid:1) long long x= 200L; // Nombre accolé à un L (cid:1) long long x= 200L; // Nombre accolé à un L (cid:1) byte (cid:1) double (cid:1) float (cid:1) char (cid:1) boolean

byte x=012; // Nombre commençant avec un 0 double x=23.2323; float x= 23.233F; // Nombre accolé à un F char c=‘a’; char c=‘\u0061’; char c=(char)97; boolean b=true;

38

Conversion (cid:1) Vérification de typage utilise toujours le type apparent

(cid:1) cast

(cid:1) (nom d’une classe) expression

(cid:1) Conversion implicite des valeurs d’un type en un autre

(cid:1) Seulement pour les types primitifs (cid:1) Seulement pour les types primitifs

(cid:1) Ordre croissant de généralité

(cid:1) byte -> short -> int -> long -> float -> double

(cid:1) i = l (cid:1) l = i (cid:1) int = char (cid:1) char = int

illegal legal legal illegal

39

Conversions de types

40

Conversions de types

41

Opérateurs

42

Opérateurs

43

Condition et test (cid:1) Une condition correspond à vrai ou faux (cid:1) E.g. (age < 50) (cid:1) Tester une condition: if condition A; else B;

(cid:1) si condition est satisfaite, alors on fait A; (cid:1) si condition est satisfaite, alors on fait A; (cid:1) sinon, on fait B (cid:1) E.g. if (age < 65)

System.out.println("jeune");

else

System.out.println("vieux");

44

Attention: un ; après le for( ), itère sur la condition, et ‘somme’ ne sera incrémentée qu’une seule fois

Attention: ‘i’ n’est déclarée ici qu’à l’intérieur de la boucle for

Boucle

(cid:1) Pour traiter beaucoup de données en série (cid:1) Schémas

(cid:1) Boucle for

int somme = 0; for (int i = 0; i<10; i++) somme = somme + i;

(cid:1) Boucle while

int somme = 0; int somme = 0; int i = 0; while (i<10) { somme = somme + i; i++;

(cid:1) Que font ces deux boucles?

}

Schéma d’exécution

somme=0;

i=0;

i<10? i<10? oui

non

somme=somme+i; i++;

i:

0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10

somme: 0

0, 1, 3, 6, 10, 15, 21, 28, 36, 45, sortie

45

Boucle (cid:1) do A while (condition)

(cid:1) Faire A au moins une fois (cid:1) Tester la condition pour savoir s’il faut refaire A

int somme = 0; int i = 15; while (i<10) { somme = somme + i; i++; } }

somme = 0

int somme = 0; int i = 15; do { somme = somme + i;

i++;

}

while (i<10)

Schéma d’exécution somme=0;

i=15;

i<10? oui

non

somme=somme+i; i++;

Schéma d’exécution somme=0;

i=15;

somme=somme+i; i++;

somme = 15

46

i<10?

oui

non

Les tableaux en Java

47

Les tableaux (cid:1) On peut définir un tableau sur tous les types java ( types

primitifs, classes, interfaces, tableaux ).

(cid:1) Syntaxe de définition d'un tableau :

type [ ] nom;

(cid:1) Un tableau est un objet qui contient un attribut indiquant sa taille

: « length »

int [ ] tab = new int[50]; System.out.println("Taille du tableau " + tab.length );

48

Tableau

Attention: Array Array list String

a.length a.size() a.length()

(cid:1) Pour stocker une série de données de même nature (cid:1) Déclaration

int [] nombre; // une série de valeurs int dans le tableau nommé nombre String [][] etiquette; // un tableau à deux dimensions de valeurs String

(cid:1) Création

nombre = new int[10]; // crée les cases nombre[0] à nombre[9] nombre = new int[10]; // crée les cases nombre[0] à nombre[9] etiquette = new String[3][5]; // crée etiquette[0][0] à etiquette[2][4] int[] primes = {1, 2, 3, 5, 7, 7+4}; // déclare, crée de la bonne taille et initialise

(cid:1) Utilisation

nombre[0] = 4; for (int i=1; i<nombre.length; i++) nombre[i]=nombre[i]+1; etiquette[2][3] = "un texte"; String texte = etiquette[2][3];

49

Tableaux : Déclaration

50

Tableaux : Dimensionnement

51

Tableaux : Initialisation

52

Tableaux en Java : Synthèse

53

Tableaux multidimensionnel

54

Précision sur « system.out. »

55

Mise en forme

56

Les classes en Java

Architecture générale d’un programme Java

(cid:1) Programme source Java = ensemble de fichiers « .java » (cid:1) Chaque fichier « .java » contient une ou plusieurs

définitions de classes définitions de classes

(cid:1) Au plus une définition de classe public par fichier « .java » avec nom du fichier = nom de la classe publique

public class NomDeClasse

(cid:1) Si plus d’une classe dans un fichier .java, javac génère des fichiers .class séparés pour chaque classe

58

2 classes dans 2 fichiers

/* Modélise un point de coordonnées x, y */ public class Point { private int x, y;

public Point(int x1, int y1) { x = x1; y = y1; }

public int getx(){return x;}

public double distance(Point p) { return Math.sqrt((x-p.x)*(x-p.x) + (y-p.y)*(y-p.y)); }

Fichier TestPoint.java

}

/* Pour tester la classe Point */ public class TestPoint {

public static void main(String[] args) {

Point p1 = new Point(1, 2);

int abs = p1.getx( );

Fichier Point.java

● C'est la méthode interprétée lors de l'exécution, l'entrée. ● Elle est static : ne nécessite pas de création d'objet pour être invoquable

Point p2 = new Point(5, 1); System.out.println("Distance : " + p1.distance(p2));//Afficher sur la sortie standard

}

}

59

Classes en Java

On appelle classe la structure d'un objet, c'est-à-dire la déclaration de l'ensemble des entités qui composeront un objet.

Un objet est donc « issu » d'une classe, c'est le produit qui sort d'un moule. En réalité on dit qu'un objet est une instanciation d'une classe

objet = instance

Une classe est composée de deux parties :

•Les attributs (parfois appelés données membres) : il s'agit des données représentant l'état de l'objet

•Les méthodes (parfois appelées fonctions membres): il s'agit des opérations applicables aux objets

60

Structure d'une classe

• Chaque classe peut avoir :

– des attributs : ce sont des variables déclarées dans le corps de la

classe

– des méthodes : c'est le comportement de la classe, les

fonctionnalités qu'elle propose

• La méthode comporte une signature :

– visibilité (public, protected, private ou defaut) – type de retour (void pour indiquer qu'il n'y a pas de retour) – nom de méthode – arguments public class Employe{ – Levée possible d'exception (throws) int age = 23 ; //Attribut ou membre de classe

public void poserConge(String dateDebut, String dateFin){

//Traitements réalisés par la fonctionnalité poser congé

}

}

61

Déclaration de la classe

public class Chemise {

/*Déclaration des attributs*/

/*Déclaration des méthodes*/ /*Déclaration des méthodes*/

//commentaire sur une seule ligne

/*commentaires sur plusieurs lignes*/

}

• Le fichier .java doit avoir le même nom que la classe (Chemise.java)

• Le nom de la classe doit commencer par une majiscule

62

Notation Camel Case. Exemple: CompteBancaire, AgenceVoyage

Les constructeurs

Pour créer un objet à partir d'une classe, on utilise l'opérateur new.

public class Test{

public static void main(String[] args){

L’opérateur new fait appel au constructeur de la classe

Chemise maChemise; Chemise maChemise;

class Chemise{ class Chemise{

maChemise=new Chemise();

Chemise () {}

}

}

}

(cid:2)un constructeur porte le même nom que la classe dans laquelle il est défini (cid:2)un constructeur n'a pas de type de retour (même pas void)

63

Les constructeurs

(cid:3) Constructeur par défaut

Chemise(){}

Chemise(){

Le constructeur par défaut initialise les variables de la classe aux valeurs par défaut.

id=0; id=0; couleur=‘B’ prix=10.2f;

}

(cid:3) Constructeur surchargé

Chemise(int id, char couleur, float prix){

this.id=id; this.couleur=couleur; this.prix=prix;

64

}

Les constructeurs (cid:1) L'appel de new pour créer un nouvel objet déclenche, dans

l'ordre : (cid:1) L'allocation mémoire nécessaire au stockage de ce nouvel

objet et l'initialisation par défaut de ces attributs, (cid:1) L'initialisation explicite des attributs, s'il y a lieu, (cid:1) L'exécution d'un constructeur. (cid:1) L'exécution d'un constructeur.

(cid:1) Un constructeur est une méthode d'initialisation.

public class Application {

public static void main(String args[]) {

Personne jean = new Personne() jean.setNom("Jean") ;

} }

65

Le constructeur est ici celui par défaut (pas de constructeur défini dans la classe Personne)

Les constructeurs

• Si vous ne créez pas un constructeur dans votre classe, le compilateur va automatiquement vous créer un constructeur par défaut implicite

• Si le constructeur surchargé est créé, le constructeur par défaut implicite ne sera plus créer par le compilateur

• La plateforme java différencie entre les différents constructeurs déclarés au • La plateforme java différencie entre les différents constructeurs déclarés au sein d’une même classe en se basant sur le nombre des paramètres et leurs types.

On ne peut pas créer deux constructeurs ayant le même nombre et types des paramètres.

Chemise(int id) {

this.id=id

} Chemise(int id) {

this.id=id*2

}

Erreur de compilation

66

Les constructeurs

Personne.java

public class Personne {

public String nom; public String prenom; public int age; public int age; public Personne(String unNom,

String unPrenom, int unAge)

{

nom=unNom; prenom=unPrenom; age = unAge;

} } Va donner une erreur à la compilation

Définition d’un Constructeur. Le constructeur par défaut (Personne() )n’existe plus. Le code précédent occasionnera une erreur une erreur

public class Application {

public static void main(String

args[])

{

Personne jean = new Personne() jean.setNom("Jean") ;

} }

67

Les constructeurs

Quel constructeur va choisir Java lorsque vous allez créer votre objet ?

class Chemise{ int id; char couleur; float prix; String description; int quantite; int quantite;

Chemise () {}

Chemise(int id) {

this.id=id;

}

Utilisation: Utilisation:

Chemise ch1=new Chemise();

Chemise ch1=new Chemise(122);

Chemise(int id, char couleur) {

Chemise ch1=new Chemise(122, ‘B’);

this.couleur=couleur;

}

} 68

Destructeur

le programmeur java n’a pas à s’occuper lui-même de libérer la mémoire en supprimant les objets devenus inutiles, c’est le rôle du Garbage Collector

Le Garbage Collector est exécuté automatiquement dès que la mémoire disponible devient inférieure à un certain seuil. disponible devient inférieure à un certain seuil.

Le destructeur est une méthode spéciale qui sera appelée lorsque l'objet sera nettoyé de la mémoire par le Garbage Collector.

Java Destructor finalize()

69

Déclaration des variables

Syntaxe:

type nom_variable [=value];

int id = 0;

Quel nom choisir pour notre variable? Quel nom choisir pour notre variable?

Les noms des variables sont case-sensitive

Les white space ne sont pas permis

Évitez les mots réservés de java

• Le nom de la variable doit commencer par une lettre minuscule.

Notation Camel Case. Exemple: age, quantiteStock

70

Déclaration des variables

Constante

•On déclare une constante avec le mot final

Exemple:

final int MAX_STOCK=100;

•Le nom de la constante doit être en majuscule. •Si le nom est composé de plusieurs mots, on utilise _ pour la séparation des mots

Exemple:

final int TAILLE; final int MAX_STOCK; final int CAPACITE_DANS_STOCK;

71

Déclaration des variables

Les types entiers

byte

short short

int

long

Valeur minimale

Valeur maximale

Codé sur

- 128

- 32 768 - 32 768

127

32767 32767

- 2147 483 648

2 147 483 647

- 922337203685477 5808

922337203685477 5807

8 bits

16 bits 16 bits

32 bits

64 bits

72

Déclaration des variables

Les types réels

Valeur minimale

Valeur maximale

Codé sur

float

double double

1.4E45

4.9E3 4.9E3

3.4028235E38

1.7976931348623 1.7976931348623 157E308

4 octets

8 octets 8 octets

Exemple:

float f=1.2f double d=34.8d

73

Déclaration des variables

Le type caractère char

char sexe=‘M’;

Le type boolean

boolean abonne=true; boolean abonne=true;

Le type chaine de caractère String

String message = ‘’Bonjour les amis’’;

74

Déclaration des variables

Le tableaux

1er indice

int[] tab; tab = new int[5]; tab[0] = 10; // initialiser le premier élément tab[0] = 10; // initialiser le premier élément tab[1] = 20; // initialiser le second élément

0 1 2 3 4

indices

10 20

tab.length=5 tab.length=5

int[] tab = { 10, 20, 30, 40, 50}; //déclaration + initialisation

75

Déclaration des variables

Les valeurs par défaut des variables

Type

byte

short short

int

long

float

double

char

boolean

76

Valeur par défaut

0

0 0

0

0L

0.0f

0.0d

'\u0000'

false

Catégories des variables

Il existe deux sortes de variables :

•Une variable primitive contient des bits qui représentent sa valeur.

Exemple : int, foat , boolean.

•Une variable référence contient des bits qui indiquent comment accéder à l'objet.

Exemple : String, Chien, Joueur,...

77

Catégories des variables

Les variables primitives

78

Catégories des variables

Les variables primitives

•Déclaration d’une variable primitive réservation de l’espace mémoire.

int age; boolean abonne; boolean abonne; char sexe;

age

abonne

sexe

•La valeur affectée à la variable sera stockée dans l’espace mémoire réservé.

age=18; abonne=false; sexe=‘M’;

79

age

abonne

sexe

1818

false false

MM

Catégories des variable

Les variables références

80

Catégories des variables

Les variables références: String

•on crée une référence sur une String •Lorsqu’on déclare une variable objet , on est en fait entrain de faire la réservation de l’espace mémoire pour la référence

String message;

message=‘’Bonjour’’; //équivalent à message=new String(‘’Bonjour’’);

message=‘’Hello’’;

81

message

refref refref

message

refref

message

refref

objet null

null null

objet String

Bonjour

objet String

Bonjour

Hello

Catégories des variables

Les variables références: Les tableaux

•Un tableau contenant des éléments de type primitif

int[] notes={10,12,15};

notes

reference

•Un tableau contenant des éléments de type objet

String[] animaux={‘’chat’’,’’poisson’’};

objet int [ ]

1010

int int

1212

int int

1515

int int

objet String

objet String

chat

poisson

animaux

reference

refref

refref

82

Catégories des variables

Récapitulation sur les types objets et les types primitifs

83

Déclaration des méthodes

Syntaxe:

Type_retour nom_method([arguments]) {

}

Exemple: Exemple:

void afficherInfoChemise (){

}

Le nom de la méthode doit commencer par un verbe

84

Classe chemise

public class Chemise{

int id; char couleur; float prix; String description; int quantite; void ajouterChemise (int nombre) { quantite += nombre;

} }

void dimunierChemise (int nombre) {

quantite - = nombre;

}

void afficherInfoChemise() {

System.out.println(id+ info);

}

}

85

Le mot-clé this

Le mot-clé this permet de désigner l’objet courant,

this permet d'accéder aux attributs et méthodes de l’objet courant

(cid:3) Pour manipuler un attribut de l’objet courant:

this.couleur this.couleur

(cid:3) Pour manipuler une méthode de la super-classe :

this.ajouterChemise (100)

(cid:3) Pour faire appel au constructeur de l’objet courant:

this()

86

La classe Montre, un peu de syntaxe

class UnNomdeClasse { /* le corps */ }

• class indique la définition d'une classe nommée

Montre.

• Un nom de classe commence par une majuscule

• Le mot-clé public indique que la classe est utilisable

public class Montre {

/*Définissons les attributs*/ private int heure , minute ; private int heure , minute ;

de « l'extérieur ».

• Les attributs sont typés (int) : • Les attributs sont typés (int) :

/* Définissons les méthodes*/ public int getHeure() { return heure;

} public int getMinute() { return minute;

} public void setMinute(int m) {

minute = m;

} public void setHeure(int h) {

heure = h;

} } 87

<Type> nomAttribut = valeurInit;

• La syntaxe générale pour définir une méthode :

<Type retour> nomMethode (<listeparamètres>)

• Les noms de méthodes et attributs commencent par une minuscule, la frontière des mot est marquée par une majuscule.

• Tout ce qui est entre /* et */ est un commentaire

(pouvant aller sur plusieurs lignes).

• // commentaire jusqu'à la fin de la ligne

Surcharge (cid:1) Deux méthodes membres qui

(cid:1) appartiennent à la même classe (cid:1) portent un identificateur identique (même nom de

fonction)

(cid:1) possèdent des paramètres différents (cid:1) possèdent des paramètres différents

sont des méthodes surchargées

88

Surcharge (cid:1) Exemple:

Un point géométrique peut être défini par:

(cid:1) ses coordonnées données explicitement (cid:1) ses coordonnées données explicitement

Point (int i, int j) {

x=i;

y=j;

}

(cid:1) un autre Point

Point (Point p) {

x=p.x; y=p.y;

}

89

Surcharge (cid:1) Exemple (suite):

(cid:1) des coordonnées par défaut

Point () { x=0; x=0; y=0;

}

Soit:

Point (int i, int j) Point (Point p) Point ()

90

3 méthodes portant des signatures différentes

Surcharge (cid:1) Attention:

Pas de différenciation sur le type de retour

Exemple:

(cid:1) int f (int v)

et

(cid:1) double f (int v)

ne sont pas différentiable

91

Les attributs static

Variable d’instance:

Chaque instance de la classe possède ses propres valeurs des variables.

Class Etudiant{

String nom; String nom;

Etudiant [class]

Etudiant(String nom){

this.nom=nom;

}

}

Etudiant [instance]

Etudiant [instance]

nom

Ahmed

nom

Marwa

Etudiant etud1 = new Etudiant (“Ahmed"); Etudiant etud2 = new Etudiant (“Marwa");

92

Les attibuts static

Variable d’instance:

Utilisation

On invoque les variables d’instance avec le nom de l’instance

Class Etudiant{

String nom; String nom;

class Test{

public static void main(String[] args){ public static void main(String[] args){

Etudiant(String nom){

this.nom=nom;

}

}

}

}

Etudiant etudiant=new Etudiant();

System.out.println(etudiant.nom);

93

Les attibuts static

Variable de classe:

•n'appartient pas à une instance particulière, elle appartient à la classe. •est partagée par toutes les instances de la classe

Etudiant [class]

nbrEtudiants

123 0

Etudiant [instance] nom Ahmed

Etudiant [instance] nom Fatma

Etudiant [instance] nom Marwa

Class Etudiant{

String nom; String nom; static int nbrEtudiants;

Etudiant(String nom){

this.nom=nom; nbrEtudiants++;

}

}

Etudiant etud1 = new Etudiant (“Ahmed"); Etudiant etud2 = new Etudiant (“Marwa"); Etudiant etud3 = new Etudiant (“Fatma");

94

Les attibuts static

Variable de classe:

Utilisation

On invoque les variables static avec le nom de la classe

class Etudiant{

String nom; String nom; static int nbrEtudiants;

class Test{

public static void main(String[] args){

Etudiant(String nom){

this.nom=nom; nbrEtudiants++;

}

}

}

System.out.println(Etudiant.nbrEtudiants);

}

95

Les méthodes static

Le comportement d’une méthode statique ne dépend pas de la valeur des variables d'instance

class MaClassMath{

static int min(int a , int b){ static int min(int a , int b){

Utilisation: L'appel à une méthode statique se fait en utilisant le nom de la classe. utilisant le nom de la classe.

if(a<b){

return a;

}else{

return b;

}

}

}

96

class Test { public static void main ( String [] args ){

int x = MaClassMath .min (21 ,4);

} }

Les méthodes static

Puisque les méthodes static appartiennent à la classe, elles ne peuvent en aucun cas accéder aux variables d'instances qui appartiennent aux instances de la classe.

•Les méthodes d’instances accèdent aux variables d’instance et méthodes d’instances •Les méthodes d’instances accèdent aux variables de classe (static) et méthodes de classe (static) • Les méthodes de classe (static) accèdent aux variables de classe (static) et méthodes de classe (static) • Les méthodes de classe (static) n’accèdent pas aux variables de d’instance et méthodes d’instance • Dans une méthode static on ne peut pas utiliser this

97

Un peu de syntaxe : construction et communication avec un objet

(cid:1) Construction

Point

p1 =

new

Point(1, 2);

Type

réf

allocation

dynamique

Constructeur, renvoie l’adresse.

• Communication

p1.distance(p2 );

réf de la cible message

type du message/

params. du

commande/requête

int abs = p1.getx( );

l’objet peut répondre au message

98

pas de params.

Exemple

public class Personne { public String nom; public int anneeNaissance; public int age() {return 2008 - anneeNaissance; }

} class Utilisation {

public static void main(String[] args) { public static void main(String[] args) {

Déclaration de référence Déclaration de référence

Personne qui; qui = new Personne(); qui.nom = "Pierre"; qui.anneeNaissance = 1980; System.out.println(qui.age());

Création d’une instance

Manipulation de l’instance référée par la référence

}

}

99

qui

nom: "Pierre"

anneeNaissance: 1980

Personne:

age()

Manipulation des références

class Circle {

public double x, y; // coordonnées du centre private double r; // rayon du cercle public Circle(double r) { this.r = r;

} public Circle(double a, double b, double c) {

x = a; y = b; r = c;

}

} // Dans une méthode, par exemple, main: Circle c1, c2; Circle c1, c2; c1 = new Circle(2.0, 3.0, 4.0); c2 = c1; // c2 et c1 pointent vers le même objet c2.r = c2.r – 1; // l’objet a le rayon réduit c1 = new Circle(2.0); // c1 point vers un autre objet, mais c2 ne change pas c1.x = 2.0; // on modifie le deuxième objet c2 = c1; // maintenant, c2 pointe vers le 2ième objet aussi

(cid:1) Que faire du premier objet?

(cid:1) Aucune référence ne pointe vers lui (cid:1) L’objet est perdu et inutilisable (cid:1) Ramasse miette (garbage collector) va récupérer l’espace occupé par l’objet

(cid:1) Comparaison des références

(cid:1) (c1 == c2): est-ce que c1 et c2 pointent vers le même objet?

100

Illustration

1. Cercle c1, c2;

1

c1

c2

null

2. c1 = new Cercle(2.0, 3.0, 4.0);

2

3. c2 = c1;

3

c1

c2

x: 2.0 y: 3.0 r: 4.0

null

4. c2.r = c2.r – 1;

4

5. c1 = new Cercle(2.0);

5

6. c1.x = 2.0;

6

c1

c2

x: 2.0 y: 3.0 r: 3.0

x: 2.0 y: 0.0 r: 2.0

101

c1

c2

x: 2.0 y: 3.0 r: 4.0

null

c1 c1

c2

x: 2.0 y: 3.0 y: 3.0 r: 3.0

null

c1

c2

7. c2 = c1;

7

c1

c2

x: 2.0 y: 3.0 r: 3.0

x: 0.0 y: 0.0 r: 2.0

x: 2.0 y: 3.0 r: 3.0

x: 2.0 y: 0.0 r: 2.0

Manipulation des références (cid:1) Soit l'objet suivant:

Point

x

y

Programme

Espace des variables

Espace mémoire

Point p1, p2, p3; Point p1, p2, p3;

p1 = new Point (1,2);

p2 = new Point (3,4);

p3 = p2;

p2 = p1;

p1 p1

p2

p3

Point Point 1

Point 3

2

4

102

Création des objets

Plan de construction

17, Rue Carthage 17, Rue Carthage

9, Rue Hannibal

23, Rue des anges

Classe « Chemise