Embed Size (px)
Citation preview
Java
Les Classes et les Objets Ahcène Bounceur
La Programmation Orientée Objet
Elle se fonde sur la programmation
structurée
Elle contribue à la fiabilité des logiciels
Elle facilite la réutilisation de code existant
Elle introduit de nouveaux concepts :
◦ Objets
◦ Encapsulation
◦ Classe
◦ Héritage
But de ce cours
Aborder la notion de classe dans toute sa généralité, telle qu'elle apparaît dans les concepts de P.O.O
Définir une classe et l’utiliser
◦ Utiliser une classe signifie instancier des objets du type correspondant
◦ Introduire la notion de référence d'un objet
Étudier l'importante notion de constructeur
◦ C'est une méthode appelée automatiquement lors de la création d'un objet
Examiner comment se présente l'affectation d'objets
◦ La comparer à celle des variables de type primitif
But de ce cours
Préciser les propriétés des méthodes (arguments, variables, etc.)
Aborder les possibilités de la surdéfinition (surcharge)
Présenter les modes de transmission (par valeur et par référence)
Étudier les champs (attributs) et les méthodes de classes
Présenter la notion de classe interne
Présenter la notion de paquetage (package)
La notion de classe
Définir une classe
◦ Prenons comme exemple d'objet un point
◦ Voici comment définir une classe Point
public class Point {
}
La notion de classe
Définir le contenu d'une classe :
◦ Les champs (ou les attributs)
◦ Les méthodes
La notion de classe
Définition des attributs :
◦ Pour le cas du point, les attributs sont son
absicsse et son ordonnée
public class Point {
private int x ; // abscisse
private int y ; // ordonnee
}
La notion de classe
Définition des méthodes :
◦ Supposons que nous souhaition disposer des
méthodes suivants :
initialiser : pour initialiser la position du point
deplacer : pour déplacer les point
afficher : pour afficher le point
La notion de classe
Définition des attributs :
◦ La méthode initialiser public class Point {
private int x ; // abscisse
private int y ; // ordonnee
public void initialiser(int abs, int ord) {
x = abs ;
y = ord ;
}
}
La notion de classe
Définition des attributs :
◦ Les méthodes deplacer et afficher
public class Point {
private int x ; // abscisse
private int y ; // ordonnee
public void initialiser(int abs, int ord) {
x = abs ;
y = ord ;
}
public void deplacer(int dx, int dy) {
x += dx ;
y += dy ;
}
public void afficher(int abs, int ord) {
System.out.println("Point ( "+x+", "+y+")" ) ;
}
}
La notion de classe
La classe Point va permettre d'instancier des
objets de type Point et leur appliquer à
vonlonter les méthode publiques
Instancier = création en mémoire
Remarque :
◦ Toutes les instructions java appartiennent à une
méthode
◦ Pour tester la classe Point, on créera une autre
classe contenant la méthode main
Utiliser la classe Point
Déclaration d'une variable de type Point
Point p ;
◦ à ce stade, p n'existe pas dans la mémoire. C'est
juste une déclaration, contrairement à int x; où x
est tout de suite créé en mémoire
Pour instancer un objet de type Point, on
utilisera le mot clé new
p = new Point() ;
Utiliser la classe Point
Cette situation peut être schématisée
comme suit :
?
? a
x
y
Utiliser la classe Point
p.initialiser(3, 5)
3
5 a
x
y
Utiliser la classe Point
Exemple
public class TestPoint {
public void main(String [] args) {
Point p ;
p = new Point() ;
p.initialiser(3, 5) ;
p.afficher() ;
p.deplacer(2, 0) ;
p.afficher() ;
Point b = new Point() ;
b.initialiser(6, 8) ;
b.afficher() ;
}
} Exécution : Point (3, 5)
Point (5, 5)
Point (6, 8)
Utiliser la classe Point
Attention !
public class TestPoint {
public void main(String [] args) {
Point p ;
p = new Point() ;
p.x = 4 ;
}
}
Erreur : car l’attribut x est privé (précédé par private)
Programme à plusieurs classes
Il faut créer un fichier java pour chaque
classe
L'extension d'un fichier java et .java
Le nom du fichier doit être le même que
celui de la classe
◦ Pour la classe Point, le nom du fichier
correspondant est : Point.java
◦ Sa compilation donner le fichier : Point.class
Programme à plusieurs classes
◦ Pour la classe TestPoint, le nom du fichier
correspondant est : TestPoint.java
◦ Sa compilation donner le fichier : TestPoint.class
L'execution de ce programme se fait comme
suit : javac Point.java
javac TestPoint.java
java TestPoint
javac : pour compiler
java : pour lancer l'application
Programme à plusieurs classes
Tout dans un même fichier c'est possible public class TestPoint {
public static void main(String [] args) {
Point p = new Point();
p.initialiser(10, 20);
p.afficher();
}
}
class Point {
private int x ;
private int y ;
public void initialiser(int abs, int ord) {
x = abs ;
y = ord ;
}
public void deplacer(int dx, int dy) {
x += dx ;
y += dy ;
}
public void afficher() {
System.out.println("Point ("+x+", "+y+")");
}
}
Attention ! Ne pas mettre public ici
La notion de constructeur
Un constructeur est une méthode qui n'a pas de valeur de retour et qui porte le même nom que la classe
Il peut être utilisé avec ou sans arguments
Permet d'initialiser automatiquement un objet au moment de sa création
L'initialisation ne se limite pas à la mise en place des valeurs initiales : on peut effectuer n'importe quelle action utile au bon fonctionnement de l'objet
La notion de constructeur
Exemple de la classe Point :
◦ Supposons que nous voulons initialiser le point au
moment de sa création. C'est-à-dire, appeler
automatiquement la méthode initialiser au
moment de l'instanciation d'un point
Solutions :
On crée un constructeur qui fait appel à la méthode initialiser
On remplace la méthode initialiser par un constructeur
La notion de constructeur
Constructeur faisant appel à une méthode public class Point {
private int x ; // abscisse
private int y ; // ordonnee
public Point(int a, int o) {
initialiser(a, o) ;
}
public void initialiser(int abs, int ord) {
x = abs ;
y = ord ;
}
public void deplacer(int dx, int dy) {
x += dx ;
y += dy ;
}
public void afficher(int abs, int ord) {
System.out.println("Point ( "+x+", "+y+")" ) ;
}
}
La notion de constructeur
Constructeur avec initialisation public class Point {
private int x ; // abscisse
private int y ; // ordonnee
public Point(int abs, int ord) {
x = abs ;
y = ord ;
}
public void deplacer(int dx, int dy) {
x += dx ;
y += dy ;
}
public void afficher(int abs, int ord) {
System.out.println("Point ( "+x+", "+y+")" ) ;
}
}
La notion de constructeur
Constructeur : Rappel
public class Point {
private int x ; // abscisse
private int y ; // ordonnee
public Point(int abs, int ord) {
x = abs ;
y = ord ;
}
public void deplacer(int dx, int dy) {
x += dx ;
y += dy ;
}
public void afficher(int abs, int ord) {
System.out.println("Point ( "+x+", "+y+")" ) ;
}
}
Un constructeur est une méthode qui n'a pas de valeur de retour
(il n’est précédé ni par void, ni int, float, …)
La notion de constructeur
Constructeur : Rappel
public class Point {
private int x ; // abscisse
private int y ; // ordonnee
public Point(int abs, int ord) {
x = abs ;
y = ord ;
}
public void deplacer(int dx, int dy) {
x += dx ;
y += dy ;
}
public void afficher(int abs, int ord) {
System.out.println("Point ( "+x+", "+y+")" ) ;
}
}
Un constructeur est une méthode qui porte le même nom que la
classe
Construction et initialisation d’un
objet
La création d'un objet entraîne, par ordre
chronologique, les oéprations suivantes :
◦ Initialisation par défaut de tous les attirbuts
◦ Initialisation explicite lors de la déclaration des
attributs
◦ Initialisation par exécution des instructions du
corps du constructeur
Construction et initialisation d’un
objet Initialisation par défaut de tous les attirbuts :
chaque déclaration d'un attribut entraine
automatiquement son initialisation par défaut. Les valeurs
initialisées par défauts sont données comme suit :
Type de l’attribut Valeur par défaut
booleen
char
entier (byte, short, int, long)
flottant (float, double)
objet
false
caractère code nul
0
0.f ou 0.
null
Construction et initialisation d’un
objet Initialisation explicite des attributs d'un objet :
public class A {
private int n = 10 ;
private int p ;
private int y = n+2 ;
public A(...) {...}
...
}
Construction et initialisation d’un
objet Initialisation par constructeur :
public class A { private int n = 10, p = 20 ;
private int y = n+2 ;
private int np ;
public A() {
np = n * p ;
n = 5 ;
}
...
} n = 5
p = 20
y =12
np = 200
Déclaration des constantes
Les attributs final :
◦ Déclarer une constante n initiélisée à 20 :
public class A {
private final int n = 20 ;
...
}
Déclaration des constantes
Une constante peut être initialisée dans un
constructeur : public class A {
private final int n;
public A() {
n = 20 ;
}
}
Déclaration des constantes
Attention 1 : une constante s’initialise une
seule fois uniquement : public class A {
private final int n;
public A() {
n = 20 ;
...
n = 30 ; // erreur de compilation
}
}
public class A {
private final int n = 20 ;
public A() {
n = 30 ; // erreur de compilation
}
}
Déclaration des constantes
Attention 2 : une constante doit être
obligatoirement initialisée : public class A {
private final int n;
public A() { //erreur de compilation
...
}
}
Éléments de conception des classes
Une conception orientée objet s'appuie sur la
notion de contrat (ce que fait une classe) et
d'implémentation (comment elle le fait) :
◦ Le Contrat : une classe est caractérisée par
Les en-têtes de ses méthodes publiques
Le comportement de ses méthodes publiques
◦ L’Implémentation : dans une classe,
Les attributs et les corps des méthodes publiques
doivents être privés
Éléments de conception des classes
L’ENCAPSULATION :
◦ des données privées (private) permet à
l'utilisateur de modifier le comportement d'une
classe sans à modifier le programme qui l'exploite.
◦ D'une autre manière :
Modifier les valeurs des attributs en passant par des
méthodes
Éléments de conception des classes
MESSAGE :
◦ Une classe peut modifier le comportement (ou un
attribut) d'une autre classe par l'intérmédiaire des
méthodes
◦ Une classe qui appelle une méthode d'une autre
classe s'appelle aussi une classe qui envoie un
message à une autre classe
Typologie des méthodes
Parmi les méthodes d'une classe, on
distingue :
◦ Les constructeurs
◦ Les accesseurs (accessors ou méthodes d'accès)
Elles fournissent des informations relatives d'un état
d'un objet, c'est-à-dire les attributs d'une classe
◦ Les mutateurs (mutators ou méthode
d'altération)
Ils modifient l'état d'un objet, c'est-à-dire les valeurs des
attributs
Typologie des méthodes
Exemple : cas de la classe Point public class Point {
private int x ; // abscisse
private int y ; // ordonnee
public int getX() {return x ;}
public int getY() {return y ;}
public void setX(int x) {this.x = x ;}
public void setY(int y) {this.y = y ;}
public void setPosition(int x, int y) {
this.x = x ;
this.y = y ;
}
...
}
Affectation et comparaison d’objets
Premier exemple :
Point a, b ;
...
a = new Point (3, 5) ;
b = new Point (2, 1) ;
2
1 b
x
y
3
5 a
x
y
Affectation et comparaison d’objets
Premier exemple :
Point a, b ;
...
a = new Point (3, 5) ;
b = new Point (2, 1) ;
a = b ;
2
1 b
x
y
3
5 a
x
y
Affectation et comparaison d’objets
Premier exemple :
Point a, b ;
...
a = new Point (3, 5) ;
b = new Point (2, 1) ;
a = b ;
2
1 b
x
y
3
5 a
x
y
Affectation et comparaison d’objets
Exemple 2 : exercice
Point a, b, c ;
...
a = new Point (1, 10) ;
b = new Point (2, 20) ;
c = b ;
a = b ;
b = c ;
2
20 c
x
y
1
10 a
x
y
b
Affectation et comparaison d’objets
Attention !
◦ Une variable de type classe (l'instanciation d'une
classe) est une référence et non pas une valeur
◦ Il peut y avoir des conséquences dans la
transmission d'un objet en argument d'une
méthode
Initialisation de référence
Point p ;
p.afficher() ; // erreur de compilation : p
n'est pas initilisé
Point p ;
if (p == null) … // juste : on compare p à
null
Point p = null ; // juste
p.afficher(); // erreur de compilation
Comparer deux objets
Point a, b ;
On peut écrire : (a == b) et (a != b)
(a == b) est vrai :
◦ Si a et b font référence à un seul et même objet
◦ Leurs attributs auront par conséquent les mêmes
valeurs
Comparer deux objets
Exercice :
Point a, b ;
...
a = new Point (1, 10) ;
b = new Point (1, 10) ;
if (a == b) ... // VRAI ou FAUX ?
Le ramasse miette
Garbage Collector
Ce point est supprimé automatiquement de
la mémoire après son affichage
Tous les objets non référencés seront
autmatiquement supprimée de la mémoire
(new Point (1, 10)).afficher() ;
Le ramasse miette
La méthode finalize est appelée par le
garbage collector avant qu'il supprime un
objet
On peut lancer cette méthode dans un
programme, ce qui peremttra de forcer
l'élimination des objets par le garbage
collector
Le grarbage collector ne se déclanche que si
la mémoire commence à se faire rare …
Méthodes fonctions
On ajoutera la méthode distance à la classe Point :
public class Point {
private int x ; // abscisse
private int y ; // ordonnee
...
public double distance() {
double d = Math.sqrt(x*x + y*y) ;
return d ;
}
...
}
Règles d’écriture des méthodes
distance calcule la distance du point P par rapport à l’origine.
Règles d’écriture des méthodes
Méthodes fonctions
Voici un exemple de l'utilisation de la méthode
distance de la classe Point
Point a = new Point() ;
double u, v ;
...
u = 2. * a.distance() ;
v = Math.sqrt(a.getX() * a.getX() + a.getY() * a.getY() ) ;
Les arguments d’une méthode
Arguments muets
◦ Lorsuqu'une méthode est déclarée, l'ensemble de ses arguments sont appelés arguments muets,
◦ Lorsqu'une méthode est appelée, l'ensemble des arguments spécifiés (ou utilisés) sont appelés arguments effectifs.
Exemple :
public void f (final int n, double x) {
n = 12 ; // erreur de compilation
x = 2.5 ;
}
Merci de votre attention
