Cours 02poo

Programmation Orientée Objet
Les classes
Riadh BOUSLIMI
bouslimi.riadh@gmail.com
Programmation orientée objet
Plan
Méthode d’instance ou méthode de classe
 static
 final
Constructeurs
Types énumérés
Les modificateurs
Expressions booléennes et égalité
2
Calculatrice
 Calculatrice.java
class Calculatrice {
double add(double v1, double v2) {
return v1 + v2;
}
double mul(double v1, double v2) {
return v1 * v2;
}
double inv(double v) {
return 1 / v;
}
} État : ?
Usage: Calculatrice c = new Calculatrice();

c.add(12, 5);
3
Méthodes de classes : mot clé static

static double add(double v1, double v2) {
return v1 + v2;
}
static double mul(double v1, double v2) {
return v1 * v2;
}
static double inv(double v) {
return 1 / v;
}
} État : NON
Usage: Calculatrice.add(12, 5);
4
Champs de classes : mot clé static

return v1 + v2;
}
return v1 * v2;
}
return 1 / v;
}
static double PI = 3.14159; État : NON
}
Calculatrice.mul(Calculatrice.PI, 2);
5
Champs constants : mot clé final

return v1 + v2;
}
return v1 * v2;
}
return 1 / v;
}
static final double PI = 3.14159; État : NON
}
6

Le mot clé final impose que la variable ne puisse changer de valeur,
elle ne peut qu’être initialisée.
L’initialisation ne se fait pas obligatoirement au moment de la
déclaration.
final int i;
int j = 2;
j *= 3;
i = j; // valide, initialisation de la variable
Un champ qui est à la fois static et final correspond à une vraie
constante et doit être initialisé à la déclaration.
7

return v1 + v2;
}
return v1 * v2;
}
return 1 / v;
}
static final double PI = 3.14159; État : NON
Accumulateur ?
} Mémoire ?
8
Méthodes d’instance et état

double accumulateur;
void add(double v) {
accumulateur += v;
}
void mul(double v) {
accumulateur *= v;
}
double inv() {
accumulateur = 1 / accumulateur;
} État : OUI
static final double PI = 3.1415;
} Usage: Calculatrice c = new Calculatrice();
c.add(12);
c.mul(Calculatrice.PI);
9
Plan
Constructeurs
 Initialisation des champs
 Surcharge du constructeur
 Surcharge des paramètres
 Mots clés this. et this(
 Constructeur par défaut
10
Initialisation par défaut

class Complexe {
double reelle, imaginaire; // valeur initiale ?
double norme() {
return reelle * reelle + imaginaire * imaginaire;
}
}
Initialisation par défaut des champs
 Valeurs numériques (byte, short, int, long, float, double) : 0
 Booléens (boolean) : false
 Références : null
Usage
 Complexe c1 = new Complexe();
11
Constructeur
class Complexe {
Complexe(double re, double im) { // constructeur

reelle = re;
imaginaire = im;
}
}
Initialisation explicite des champs
 Lorsqu’il n’y a pas de « bonne » valeur par défaut
 Lorsque l’initialisation nécessite un calcul
Usage
 Complexe c1 = new Complexe(0, 1);
12
Mot clé this.

class Complexe {
Complexe(double reelle, double imaginaire) {

this.reelle = reelle;
this.imaginaire = imaginaire;
}
}
Surcharge des variables
 Lorsque le même nom désigne plusieurs variables différentes
 De manière générale, this désigne l’objet courant.
Usage
13
Constructeur : surcharge
class Complexe {
Complexe(double re, double im) {

reelle = re;
imaginaire = im;
}
Complexe(double re) {
reelle = re;
imaginaire = 0.0;
}
}
 Usage
 Complexe c2 = new Complexe(6.5);
14
Constructeur : this()
class Complexe {
Complexe(double re, double im) {

reelle = re;
imaginaire = im;
}
Complexe(double re) {
this(re, 0.0);
}
}
 Usage
 Complexe c2 = new Complexe(6.5);
 Complexe c3 = new Complexe();
15
Instantiation et constructeur
Si un ou plusieurs constructeurs explicites
 Il faut obligatoirement utiliser un de ces constructeurs
• Complexe c1 = new Complexe(0, 1);
• Complexe c2 = new Complexe(5);
• Complexe c3 = new Complexe(); // interdit
Le choix du constructeur dépend

 Du nombre de paramètres effectifs
 De leur type
16
Constructeur par défaut

Si un ou plusieurs constructeurs explicites
 Il faut obligatoirement utiliser un de ces constructeurs
• Complexe c1 = new Complexe(0, 1);
• Complexe c2 = new Complexe(5);
• Complexe c3 = new Complexe(); // interdit
Si aucun constructeur n’est défini

 Un constructeur « par défaut » est créé automatiquement
 Il n’a pas de paramètre
class Complexe{
double re, im;
}
Complexe c = new Complexe();
17
Plan
Constructeurs
18
Types énumérés
 Introduits par le JDK 5.0
 Les types énumérés ressemblent à des classes
 Leurs valeurs ressemblent à des champs statiques
 Le compilateur construit des helpers (constructeurs, affichage, …)
 Peut avoir des constructeurs, méthodes et champs
 Exemple
[Couleur.java] [Valeur.java]
enum Couleur { enum Valeur {
TREFLE, CARREAU, CŒUR, PIQUE; SEPT, HUIT, NEUF, DIX,
} VALET, DAME, ROI, AS;
}
[Test.java]
class Test {
static public void main(String[] args) {
Couleur c = Couleur.TREFLE;
Valeur v = Valeur.AS; > java Test
System.out.println(v + " " + c); AS TREFLE
}
}
19
Couleur de cartes
 Sans les énumérés
[Couleur.java]
class Couleur {
int valeur;
Couleur(int v) {
this.valeur = v;
}
static final Couleur TREFLE = new Couleur(1);
static final Couleur PIQUE = new Couleur(2);
static final Couleur CŒUR = new Couleur(3);
static final Couleur CARREAU = new Couleur(4);
}
[Test.java]
class Test {
static public void main(String[] args) {
System.out.println(c);
}
}
20
Couleur de cartes
 Sans les énumérés
[Couleur.java]
class Couleur {
int valeur;
Couleur(int v) {
this.valeur = v;
}
static final Couleur TREFLE = new Couleur(1),
PIQUE = new Couleur(2),
CŒUR = new Couleur(3),
CARREAU = new Couleur(4);
}
[Test.java]
class Test {
static public void main(String[] args) { > java Test
Couleur@740355a4
System.out.println(c);
}
}
21
Couleur de cartes
class Couleur { // [Couleur.java]
int valeur;
Couleur(int v) { this.valeur = v; }
static final Couleur TREFLE = new Couleur(1), PIQUE = new Couleur(2),
CŒUR = new Couleur(3), CARREAU = new Couleur(4);
String nom() {
if (valeur == 1) return "Trèfle";
if (valeur == 2) return "Pique";
if (valeur == 3) return "Coeur";
if (valeur == 4) return "Carreau";
return "Erreur!";
}
}
> java Test

System.out.println(Couleur.TREFLE.nom());
Trèfle
22
Méthode toString()
int valeur;
static final Couleur TREFLE = new Couleur(1), PIQUE = new Couleur(2),
public String toString() {

if (valeur == 1) return "Trèfle";
if (valeur == 2) return "Pique";
if (valeur == 3) return "Coeur";
if (valeur == 4) return "Carreau";
return "Erreur!";
}
}
> java Test

System.out.println(Couleur.TREFLE);
Trèfle
23
Méthode toString()
int valeur;
static final Couleur TREFLE = new Couleur(1), PIQUE = new
Couleur(2),
switch (valeur) {
case 1:
return "Trèfle";
case 2: Ici, on n’a pas besoin d’instruction break car
return
case 3:
"Pique";
return interrompt immédiatement la méthode
return "Coeur"; en renvoyant la valeur.
case 4:
return "Carreau";
default:
return "Erreur!";
}
}
24
Simplification: utilisation d’un constructeur

String nom;
Couleur(String nom) {
this.nom = nom;
}
static final Couleur TREFLE = new Couleur("Trèfle"), PIQUE = new Couleur("Pique"),
CŒUR = new Couleur("Coeur"), CARREAU = new Couleur("Carreau");

return nom;
}
}
25
switch/case
class Valeur { // [Valeur.java]
int valeur;
Valeur(int v) { valeur = v; }
static final Valeur SEPT = new Valeur(7), HUIT = new Valeur(8), NEUF = new Valeur(9),
DIX = new Valeur(10), VALET = new Valeur(11), DAME = new
Valeur(12),
ROI = new Valeur(13), AS = new Valeur(14);

switch (valeur) {
case 7: case 8: case 9: case 10: return valeur +
""; case 11: return "Valet";
case 12: return "Dame";
case 13: return "Roi";
case 14: return "As";
default: return "Erreur!";
}
}
}
26
switch/case
int valeur;
Valeur(12),
int maValeur() {
int v = 0;
switch (valeur) {
case 11: case 12: case 13:
v = valeur – 9;
case 14:
v = valeur – 3;
default:
}
return v;
}
}
27
switch/case
int valeur;
Valeur(12),
int maValeur() {
int v = 0;
switch (valeur) {
case 11: case 12: case 13:
v = valeur – 9;
break;
case 14:
v = valeur – 3;
break;
default:
}
return v;
}
} 28
Rappels : constructeurs
int ordre;
String nom;
Valeur(int o) {
this(o, o + "");
}
Valeur(int o, String nom) {
ordre = o;
this.nom = nom;
}
static final Valeur SEPT = new Valeur(7), HUIT = new Valeur(8), NEUF = new
Valeur(9), DIX = new Valeur(10), VALET = new Valeur(11, "Valet"),
DAME = new Valeur(12, "Dame"), ROI = new Valeur(13,
"Roi"), AS = new Valeur(14, "As");

return nom;
}
}
29
Rappels : final
class Valeur { // [Valeur.java] Valeur.AS = new Valeur(1);
int ordre;
Valeur.AS.ordre = 1;
String nom;
Valeur(int o) { Valeur.AS.estSupérieurA(Valeur.ROI);
this(o, o + ""); false!
}
ordre = o;
this.nom = nom;
}
boolean estSupérieureA(Valeur autre) {

return this.ordre > autre.ordre;
}
}
39
Le modificateur private
class Valeur { // [Valeur.java] Valeur.AS = new Valeur(1);
private int ordre;
private String nom; Valeur.AS.ordre = 1;
Valeur(int o) {
Valeur.AS.estSupérieurA(Valeur.ROI);
this(o, o + ""); true!
}
ordre = o;
this.nom = nom;
}

}
}
31
Le modificateur private
class Valeur { // [Valeur.java] class X {
private int ordre; static public void main(String[] args)
private String nom; { Valeur v1 = new Valeur(1);
Valeur v2 = Valeur.AS;
private Valeur(int o) {
}
this(o, o + ""); }
}
private Valeur(int o, String nom) {
ordre = o;
this.nom = nom;
}

}
}
32
Les modificateurs
Le modificateur public
 Membres (champ, méthode, constructeur) accessibles de n’importe où
Le modificateur private
 Membres accessibles seulement depuis le bloc de déclaration de classe
class MaClasse {
// bloc de déclaration de classe
}
Pas de modificateur
 Le plus souvent => package
• Membres accessibles depuis n’importe quel bloc d’une classe appartement au même
paquetage
 Parfois public ou private selon le contexte
33
Paquetage
 Un paquetage est un ensemble de classes regroupées en une unité logique,
c’est l’équivalent d’une bibliothèque de classes.
 On peut déclarer un paquetage en début de fichier, les paquetages sont
hiérarchisés.
package monPaquetage.monSousPaquetage;
class MaClasse { ... }
 Une classe dans un paquetage a accès aux classes, méthodes et champs avec
droit de paquetage du même paquetage.
 Depuis un autre paquetage, seuls les classes, méthodes et champs public sont
accessibles.
package monPaquetage.monSousPaquetage;
class A { ... } // seulement accessible depuis le même paquetage
public class B { ... } // accessible depuis n’importe quel paquetage
34
Paquetage: mot clé import

Pour utiliser une classe d’un autre paquetage, on peut utiliser son nom
qualifié.
java.util.ArrayList list;
On peut importer la définition d’une classe.
package test;
import java.util.ArrayList;
class Test {
ArrayList list;
}
On peut également importer toutes les classes d’un paquetage.
import java.util.*;
Deux paquetages sont importés par défaut, java.lang et le paquetage
par défaut.
35
Paquetage: organisation et compilation

Dans le système de fichiers, un paquetage correspond à un dossier.
Les sous-paquetages sont des sous-dossiers et les classes sont dans des
fichiers qui portent leur nom.
Le compilateur a besoin de cette structure pour pouvoir effectuer les
liens entre classes au moment de la compilation.
Les environnements de développement intégrés (Eclipse, Netbeans, …)
gèrent automatiquement cet aspect du langage.
Si vous compilez en ligne de commande avec javac, vous aurez
probablement à utiliser les options -sourcepath et –classpath du
compilateur.
36
Bilan sur les énumérés

Avec les énumérés Sans les énumérés (avant le JDK1.5)
enum Couleur { class Couleur {
TREFLE, private String nom;
CARREAU, private Couleur(String nom) {
CŒUR, this.nom = nom;
PIQUE; }
} Couleur static final Couleur
TREFLE = new Couleur("TREFLE"),
-nom : String
TREFLE : Couleur PIQUE = new Couleur("PIQUE"),
PIQUE : Couleur COEUR = new Couleur("COEUR"),
COEUR : Couleur CARREAU = new Couleur("CARREAU");
CARREAU : Couleur
- Couleur(String) public String toString() {
+ toString() : String return nom;
}
+ : public - : private rien : package
} 37
Compléments sur les énumérés

On peut ajouter des champs et des méthodes
enum Couleur {
TREFLE(true), PIQUE(true), CARREAU(false), CŒUR(false);
private boolean estNoire;
Couleur(boolean b) { estNoire = b; } // constructeur private!
boolean estNoire() { return estNoire; }

boolean estRouge() { return !estNoire; }
}
Test
System.out.println(c + " " + (c.estNoire() ? "noir" : "rouge"));
38
Compléments sur les énumérés

Les types énumérés sont compatibles avec l’instruction switch
enum Couleur {
TREFLE, PIQUE, CARREAU, CŒUR;
boolean estNoire() {
switch (this) {
case TREFLE:
case PIQUE:
return true;
default:
return false;
}
}
}
Dans un switch, il n’est pas nécessaire de préfixer les membres de
l’énumération avec son nom.
39
Plan
Constructeurs
40
Conditions booléennes
6 opérateurs de comparaison (int, long, float, double)
 < inférieur
 <= inférieur ou égal
 > supérieur
 >= supérieur ou égal
 != différent
 == égal
4 opérateurs logiques (boolean)
 && et logique (différent de &)
 || ou logique (différent de |)
 ^ ou exclusif logique
 ! non logique
41
Egalité de littéraux
Entiers, booléens, caractères
 if (x == y – 2) …
Nombres approchés (float, double)

 0.1+0.1+0.1+0.1+ 0.1+0.1+0.1 == 0.7 true
 0.1+0.1+0.1+0.1+ 0.1+0.1+0.1+0.1 == 0.8 false
 if (x == 0.8) … NON !
 if (Math.abs(x – 0.8) < 1e-6) … OUI !
Enumérés (préfixer le littéral par le nom de l’enum !)

 c == Couleur.TREFLE
42
Egalité de références
Le test d’égalité entre références ne compare pas les objets !
 Couleur c1 = new Couleur(1);
 Couleur c2 = new Couleur(1); Couleur
c1 == c2 ? valeur : int
c1 != c2
c1 c2
: Couleur : Couleur
valeur = 1 valeur = 1
43
Egalité de références
Le test d’égalité entre références ne compare pas les objets !
 Couleur c3 = new Couleur(1);
 Couleur c4 = c3; Couleur
c3 == c4 valeur : int
c3 c4
: Couleur
valeur = 1
44
Comparaison en profondeur
Créer une méthode qui compare
class Couleur {
int valeur;
Couleur(int v) { valeur = v; }
boolean estLaMemeCouleurQue(Couleur c) {
if (this.valeur == c.valeur)
return true;
else
return false;
}
}
Usage
if (c1.estLaMemeCouleurQue(c2)) ...
45
class Couleur {
int valeur;
return (this.valeur == c.valeur);
}
}
Usage
46
class Couleur {
private int valeur;
return (this.valeur == c.valeur);
}
}
Usage
47
Egalité de chaînes de caractères

Les chaînes de caractères sont des références
 String s1 = "rouge";
 String s2 = "ro" + "uge";
s1 == s2 ?
s1.equals(s2) ?
s1 s2
: String : String
= "rouge" = "rouge"
48

Cours 02poo

Transféré par

Informations du document

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Cours 02poo

Transféré par

Droits d'auteur :

Formats disponibles

Programmation Orientée Objet

Usage: Calculatrice c = new Calculatrice();

Méthodes de classes : mot clé static

Usage: Calculatrice.add(12, 5);

Champs de classes : mot clé static

Champs constants : mot clé final

Champs constants : mot clé final

Champs constants : mot clé final

Méthodes d’instance et état

Initialisation par défaut

Complexe(double re, double im) { // constructeur

Mot clé this.

Complexe(double reelle, double imaginaire) {

Complexe(double re, double im) {

Complexe(double re, double im) {

Le choix du constructeur dépend

Constructeur par défaut

Si aucun constructeur n’est défini

> java Test

public String toString() {

> java Test

Simplification: utilisation d’un constructeur

public String toString() {

public String toString() {

public String toString() {

boolean estSupérieureA(Valeur autre) {

boolean estSupérieureA(Valeur autre) {

boolean estSupérieureA(Valeur autre) {

Paquetage: mot clé import

Paquetage: organisation et compilation

Bilan sur les énumérés

Compléments sur les énumérés

private boolean estNoire;

Couleur(boolean b) { estNoire = b; } // constructeur private!

boolean estNoire() { return estNoire; }

Compléments sur les énumérés

Nombres approchés (float, double)

Enumérés (préfixer le littéral par le nom de l’enum !)

Egalité de chaînes de caractères

Vous aimerez peut-être aussi