CHAPITRE 3 :
Classe et Objet
1
Syntaxe de déclaration d’une classe
[Modificateurs] class NomDeClasse [extends classe_mere] [implements
interfaces]
{
//Attributs
[Modificateurs] type nomAttribut_1;
[Modificateurs] type nomAttribut_2;
...
//Méthodes
[Modificateurs] typeDeRetour nomDeMethode_1 (params)
{
// corps de la méthode;
}
[Modificateurs] typeDeRetour nomDeMethode_2 (params)
{
// corps de la méthode;
}
...
} 2
Syntaxe de déclaration d’une classe
❑[Modificateurs] class NomDeClasse [extends classe_mere]
[implements interfaces] {}
❑Une classe se compose de deux parties : un (1) en-tête et un (2)
corps.
❑L’en-tête :
❖Les modificateurs de classe (optionnel) sont : abstract, final, et la
visibilité (private, public);
❖Le mot clé class suivie du nom de la classe (obligatoire);
❖Le mot-clé extends suivie du nom de la superclasse (optionnel);
❖Le mot-clé implements suivie de la liste des noms desinterfaces
(optionnel);
❑Exemples :
public class Forme {…}
public class Rectangle extends Forme{…}
❑Le corps : entouré des accolades ouvrante et fermante ({…}), il
contient les déclarations des attributs et méthodes:
3
Syntaxe de déclaration d’une classe
Déclaration d'un attribut (dans l'ordre) :
[Modificateurs] type nomAttribut_1;
❑Modificateurs (optionnels) : static, final, et la visibilité
(private, protected, public);
❑Type : Le type est soit:
❖un type de base du langage, (boolean, byte, short, int,
long, float, double, char, void),
❖ou le nom d’une autre classe du programme.
❑Nom : nom de l’attribut
❑Exemples : déclaration d’attribut
private int x;
public static final PI=3.14;
4
Syntaxe de déclaration d’une classe
Déclaration d'une méthode :
[Modificateurs] typeDeRetour nomDeMethode_1 (params)
{// corps de la méthode;}
❑La déclaration d’une méthode est composée de la signature et du
corps :
❑La signature :
❖Modificateurs (optionnels): abstract, static, final, et la visibilité
(private, protected, public);
❖Le type de retour de la méthode;
❖Nom de la méthode;
❖Et Les paramètres de la méthode;
❑Le corps : suite d’instructions placées entre { }.
❑Exemple: déclaration d’une méthode
public double somme(double x, double y) {
double s=x+y;
return s;
}
5
Syntaxe de déclaration d’une classe
Exemple: Déclaration d’une classe Point
public class Point {
// attributs
private double x; // Abscisse
private double y; //Ordonnée
// methodes
public String toString(){
return "Point("+x+","+y+")";
}
}
6
Conventions de notation
❑Utilisation des noms significatifs pour les classes, les
attributs, les méthodes et les variables. Le nom doit être
suffisant pour comprendre ce que fait une méthode par
exemple, sans aller voir le détail du code.
❑Les noms de classes commencent par une Majuscule,
Exemples :
public class Rectangle {…}
public class Personne{…}
❑Les noms des attributs, des méthodes et des variables
commencent minuscule.
Exemples :
private double longueur; //attribut
public double surface() {…} //méthode 7
Conventions de notation
❑Lorsqu’un nom est constitué de plusieurs mots accolés, chacun
des noms successifs commence par une majuscule.
Exemples :
public class CompteEnBanque{…} //Classe
public int nombreRoues; //attribut
public double calculerSurface(){…}; //méthode
❑Le nom d’une constante est en MAJUSCULE. Lorsque le nom
d’une constante est constitué de plusieurs mots avec les mots
séparés par le caractère souligne
Exemples :
public static final double PI=3.14;
public static final int NOMBRE_MAX=100;
❑En général, le premier mot d’un nom de méthode est un verbe.
Exemple :
public double calculerSurface()
❑Il est fréquent que tous les noms soient en anglais.
8
Déclaration et création d’un objet
Déclaration d’un objet
❑La déclaration d’un objet est de la forme :
NomClasse nomObjet;
❑Exemple: Déclaration d’un objet de la classe Point
Point p;
❑La déclaration de l’objet (Point p) réserve un emplacement
mémoire pour une référence sur un objet de type Point.
❑À ce stade, la valeur de la variable p est null p null
9
Déclaration et création d’un objet
Création d’un objet
❑Pour que p référence effectivement un objet, il faut appeler un
constructeur.
❑Le constructeur est la méthode employée pour créer un objet
(allouer un espace mémoire à l’objet) d’une classe donnée et
éventuellement initialiser ses attributs.
❑Le constructeur porte le nom de la classe et ne mentionne pas de
type de retour.
❑Exemple : Constructeur de la classe Point
public class Point {
private double x;
private double y;
//CONSTRUCTEUR
public Point(double a, double b){
x=a;
y=b;
}
} 10
Déclaration et création d’un objet
Création d’un objet
❑Pour créer un objet on invoque un constructeur à l’aide de l’opérateur
new qui effectue la réservation de la mémoire et renvoie l’adresse de
la zone allouée.
❑Exemple
Point p; //Déclaration de l’objet p
p=new Point(5,3); // Création de l’objet p
❑Il est possible de réunir la déclaration et la création d’un objet.
❑Exemple
Point p = new Point(5,3);
Objet de type
p Point alloué
avec new
11
Déclaration et création d’un objet
Création d’un objet
❑Il est possible de déclarer plusieurs constructeur pour une
même classe (surcharger le constructeur).
❑Exemple:
On peut déclarer un autre constructeur pour la classe Point,
pour créer les objets dont les valeurs des attributs x et y sont
égaux.
public Point(double a) {
x=a;
y=a;
}
12
Déclaration et création d’un objet
Création d’un objet
❑Le Constructeur par défaut : Si l’on n’écrit aucun
constructeur pour une classe donnée, il est possible d’utiliser
le constructeur par défaut qui se contente d’allouer un
emplacement mémoire (il n’initialise pas les attributs).
❑Pour une la classe Point, le constructeur par défaut
correspond au code suivant :
public Point(){
x=7;
y=9;
}
❑Exemple
Si la classe Point n’a pas de constructeurs, on peut écrire :
Point p = new Point();
13
Déclaration et création d’un objet
Création d’un objet
Remarque :
❑Les attributs d'une classe, s'ils ne sont pas initialisés, se
voient affecter automatiquement une valeur par défaut.
❑Cette valeur vaut :
❖0 pour les attributs numériques (int, float, double,
etc.),
❖false pour les booléens, et
❖null pour les objets (Exemple: les attributs de type
String).
14
Déclaration et création d’un objet
Le mot clé this
❑Le mot-clé this sert à référencer dans une méthode
l'objet en cours d'utilisation.
❑Exemple:
//Constructeur de la classe Point
public Point(double a, double b){
this.x=a;
this.y=b;
}
❖L'instruction this.x=a; signifie que l'attribut x de l'objet
en cours (this) reçoit la valeur a.
15
Déclaration et création d’un objet
Le mot clé this
❑Lorsqu'une méthode d'un objet référence un attribut x de
cet objet, l'écriture this.x est implicite.
❑On doit utiliser le mot-clé this explicitement lorsqu'il y a
conflit d'identificateurs.
❑Exemple:
❖On doit utiliser le mot-clé this explicitement, lorsque les
même identificateurs sont utilisés pour les attributs et pour
les paramètres du constructeur
public Point(double x, double y){
this.x=x;
this.y=y;
}
16
Déclaration et création d’un objet
Création d'objets identiques
❑On peut avoir besoin de créer deux objets absolument identiques.
❑Examinons le code suivant :
Point p1 = new Point();
Point p2 = p1;
p1
Objet créé avec
Point p2 = p1; new
p2
❑p1 et p2 contiennent la même référence ⇒ p1 et p2 pointent le même
objet.
❑La modifications des valeurs des attributs de p1, modifie aussi les
valeurs des attributs de p2 puisque, en fait, c’est le même objet.
17
Déclaration et création d’un objet
Création d'objets identiques
Solution 1 : La méthode colone()
❑Pour créer une copie d'un objet, il est possible
d’utilisera la méthode clone();
❑La méthode clone() est héritée de la classe Object qui est
la classe mère de toutes les classes en Java;
❑La méthode clone() permet de créer un deuxième objet
indépendant mais identique à l'objet appelant.
18
Déclaration et création d’un objet
Création d'objets identiques
Solution 1 : La méthode colone()
❑Exemple :
Point p1 = new Point();
Point p2 = [Link]();
❖p1 et p2 ne contiennent plus la même référence et
pointent donc sur des objets différents.
Point p1 = new Objet créé
p1 avec
Point (); new
p2 Point p2 = Objet créé
[Link](); avec
clone 19
Déclaration et création d’un objet
Création d'objets identiques
Solution 2 : Constructeur de copies
❑Une autre solution pour créer des objets identiques consiste à définir
un constructeur de copie;
❑Exemple : Constructeur de copies de la classe Point
public class Point {
private double x;
private double y;
public Point(double x, double y) {//Constructeur
this.x=x; this.y=y;
}
public Point (Point p) {//CONSTRUCTEUR DE COPIES
this.x = p.x; this.y= p.y;
}
}
20
Déclaration et création d’un objet
Création d'objets identiques
Solution 2 : Constructeur de copies
❑Exemple : Création d’un objet de la classe Point en utilisant le
constructeur de copies
Point p1= new Point(4.0, 2.0);
Point p2= new Point(p1);
p1 Point p1= new
Point(4.0,2.0);
p2 Point p2= new
Point(p1); Objet créé avec le
constructeur de
copie
21
Déclaration et création d’un objet
Création d’un objet
❑Example
public class Pixel {
private int x;
private int y;
// Constructeur avec deux paramètres
public Pixel(int x, int y) {
this.x = x;
this.y = y;
}
22
Déclaration et création d’un objet
Création d’un objet
❑Example
// Constructeur par défaut
public Pixel() {
this.x=0;
this.y=0
}
// Constructeur de copie
public Pixel(Pixel p) {
this.x = p.x;
this.y = p.y;
}
}
23
Déclaration et création d’un objet
Création d’un objet
❑Example
public static void main(String[] args) {
// Utilisation du constructeur par défaut
Pixel p1 = new Pixel();
// Utilisation du constructeur avec deux paramètres
Pixel p2 = new Pixel(10, 20);
// Utilisation du constructeur de copie
Pixel p3 = new Pixel(p2);
}
}
24
Déclaration et création d’un objet
Suppression d’objets
❑Les objets ne sont pas des éléments statiques et leur durée
de vie ne correspond pas forcément à la durée d'exécution
du programme.
❑La durée de vie d'un objet passe par trois étapes :
1. La déclaration et la création de l’objet.
2. L'utilisation de l'objet en appelant ces méthodes.
3. La suppression de l'objet : elle est automatique en Java
grâce au récupérateur de mémoire (Garbage Collector :
GC).
❑Le GC permet de supprimer automatiquement les objets
qui ne sont plus référencés par le programme. En C++,
c’est le programmeur qui s’occupe de la suppression des
objets inutiles. 25
L’encapsulation
❑L’encapsulation est la possibilité de masquer une parties
des membres d’un objet (attributs et méthodes). c'est-à dire
en empêchant l'accès direct à ces membres depuis
l’extérieur.
❑L’encapsulation permet de ne montrer de l’objet que ce
qui est nécessaire à son utilisation.
❑La liste des méthodes et des attributs utilisables depuis
l’extérieur est appelée l’interface de la classe.
26
L’encapsulation
27
L’encapsulation
Contrôle d’accès aux attributs et méthodes
❑Pour réaliser l’encapsulation, on dispose d’un ensemble
de modificateurs de contrôle d’accès aux classes,
méthodes et attributs.
❑Pour les méthodes et attributs au sein des classes, le
programmeur en Java dispose de 3 niveaux de contrôle
d’accès, qu’il fixe à l’aide de 3 modificateurs de visibilité.
❑public : les éléments publics sont accessibles sans
aucune restriction.
❑protected : les éléments protégés ne sont accessibles
que depuis la classe et les sousclasses qui en héritent.
❑private : les éléments privés ne sont accessibles que
depuis la classe elle-même.
❑La visibilité par défaut, quand rien n’est spécifié est
équivalente à public.
28
L’encapsulation
Contrôle d’accès aux attributs et méthodes
Modificateur Rôle
public la méthode est accessible aux méthodes des
autres classes
private l'usage de la méthode est réservé aux autres
méthodes de la même classe
protected la méthode ne peut être invoquée que par des
méthodes de la classe ou de ses sous classes
final la méthode ne peut être modifiée
(redéfinition lors de l'héritage interdite)
29
L’encapsulation
Contrôle d’accès aux attributs et méthodes
Modificateur Rôle
static la méthode appartient simultanément à tous les
objets de la classe (comme une constante déclarée à
l'intérieur de la classe). Il est inutile d'instancier la
classe pour appeler la méthode mais la méthode ne
peut pas manipuler de variable d'instance. Elle ne
peut utiliser que des variables de classes.
synchronized la méthode fait partie d'un thread. Lorsqu'elle est
appelée, elle barre l'accès à son instance. L'instance
est à nouveau libérée à la fin de son exécution.
native le code source de la méthode est écrit dans un autre
langage.
30
L’encapsulation
Contrôle d’accès aux attributs et méthodes
❑En général :
❖ Les attributs d'une classe sont déclarées privés
(private) ou protégés (protected), ce qui signifie que
seuls des objets de la classe ou de ses sous-classes
peuvent les lire et les modifier;
❖ Les méthodes sont déclarées publiques (public), ce
qui signifie que n’importe qu’elle objet peut les
appeler;
31
L’encapsulation
Les accesseurs de lecture et de modification
❑Pour lire et modifier les attributs d’un objet, on ajoute à la
classe des méthodes spécialement conçues à cet effet, que l’on
appelle «Accesseurs».
❑Accesseurs de lecture
❖Les accesseurs de lecture sont des méthodes qui permettent
de lire les attributs des l’objets;
❖Les noms des accesseurs de lecture commencent
généralement par get suivi par le nom de l’attribut;
❖Exemple: public String getNom() {return nom;}
❑Accesseurs de modification
❖ Les accesseurs de modification sont des méthodes qui
permettent de de modifier les attributs des l’objets ;
❖ Les noms des accesseurs de modification (modificateurs)
commencent généralement par set suivi par le nom de
l’attribut.
❖ Exemple: public void setNom(String n) {nom=n;}
32
L’encapsulation
❑Exemple
public class Point {
//Attributs
private double x;
private double y;
//Accesseurs de lecture
public double getX(){return x;}
public double getY(){return y;}
//Accesseurs de modification
public void setX(double x){this.x=x;}
public void setY(double y){this.y=y;}
//La méthode toString
public String toString(){
return "Point("+ x +","+ y +")";
}
}
33
L’encapsulation
❑Exemple
public class MainClass{
public static void main(String[] args) {
Point p= new Point(); /*Création d’un objet Point par
utilisation du constructeur par défaut */
[Link](5.0); /* Utilisation de l'accesseur de modification
setX() pour initialiser l'attribut x */
[Link] (10.0); /* utilisation de l'accesseur de modification
setY() pour initialiser l'attribut y */
[Link]([Link]());/* utilisation de l'accesseur
de lecture getX() pour afficher la valeur de l'attribut x */
[Link]([Link] ());/* utilisation de l'accesseur
de lecture getY() pour afficher la valeur de l'attribut y*/
}
}
34
L’encapsulation
Intérêt des accesseurs
❑L’intérêt des accesseurs est de rendre indépendant tout le
reste du code de la représentation de l’objet:
❑Si on décide de modifier un attribut, il suffit de modifier
le code de l’accesseur lui-même, c’est-à-dire une seule
ligne du programme, alors qu’il aurait fallu modifier toutes
les lignes où l’attribut était utilisé si l’on n’avait pas
employé d’accesseur.
35
Les packages
Définition
❑Les classes Java sont regroupées en paquetages (packages
en anglais);
❑Le paquetage est un moyen de modularité qui permet de:
❖Découper une application volumineuse en packages
regroupant les classes qui couvrent un même domaine;
❖Protéger des attributs et des méthodes;
36
Les packages
Attribution d’un nom à un package
❑Chaque package porte un nom. Par convention, le nom
d’un package commence par une minuscule.
❑Toute classe appartenant à un package doit commencer
par déclarer son appartenance à ce package, à l’aide de
l’instruction :
package nomDuPackage;
37
Les packages
Attribution d’un nom à un package
❑Exemple
package vehicules;
public class Automobile{...}
package vehicules;
public class Cyclomoteur{...}
package vehicules;
Automobile
public class Utilitaire{...} Cyclomoteur
package vehicules;
Utilitaire Autobus
public class Autobus{...}
38
Les packages
Contrôle d’accès aux classes
Pour les classes, il n’y a que deux niveaux de visibilité :
❑Publique : La classe est visible par les classes de son
package, et à l’extérieur du package.
❖La syntaxe pour déclarer une classe publique consiste à
écrire :
public class UneClasse{...}
❖Exemple
public class Automobile{...}
❑Sans visibilité : La classe n’est visible que par les classes du
package dans lequel elle se trouve.
❖La syntaxe consiste à écrire :
class UneClasse{...}
❖Exemple
class Point {...}
39
Les packages
Utilisation d’un package
Pour désigner une classe qui est définie dans un autre
package, on a le choix entre :
❑Importer la classe :
import [Link];
❑Faire précéder chaque occurrence du nom de la classe par
le nom du package dans lequel elle est définie.
❑Exemple
//Declaration de la classe personne
package proprietaire;
public class Personne{...}
40
Les packages
❑Exemple
Pour désigner au sein du package vehicule la classe
Personne qui appartient au package proprietaire, on a le
choix entre le code suivant :
package vehicule;
import [Link];
public class Automobile{
...
Personne p;
p=new Personne(String prenom, String nom);
...
}
41
Les packages
❑Exemple
Ou bien le code suivant :
package vehicule;
public class Automobile{
...
[Link] p;
p=new [Link](String prenom, String
nom)
...
}
42
Les packages
❑Pour importer toutes les classes d’un package :
import nomPackage.*;
Exemple
❖On peut remplacer le code suivant:
import [Link]
import [Link]
import [Link]
import [Link]
❖Par le code suivant:
import vehicule.*
43
Example
❑Écrire une classe Rectangle disposant :
❖Deux données membres : privées réels largeur et hauteur.
❖De trois constructeurs : le premier sans paramètre créera un
rectangle dont les deux dimensions sont égales à 1 ; le second à
un paramètre sera utilisé à la fois pour les deux dimensions,
considérées comme égales ; le troisième à deux paramètres
correspondant aux deux dimensions du rectangle.
❖D’une méthode périmètre fournissant en résultat le périmètre
du rectangle ;
❖D’une méthode surface fournissant en résultat la surface du
rectangle ;
❖D’une méthode agrandit disposant d’un paramètre de type réel
correspondant à la valeur par laquelle il faut multiplier les
dimensions du rectangle. Écrire une petite application Java
d’utilisation.
❖D’une méthode affiche qui permet d’afficher les
caractéristiques d’un rectangle ;
❑Écrire une petite application Java d’utilisation.
44
Example
public class Rectangle {
// Données membres privées
private double largeur;
private double hauteur;
// Premier constructeur sans paramètre
public Rectangle() {
[Link] = 1;
[Link] = 1;
}
// Deuxième constructeur avec un seul paramètre
public Rectangle(double dimension) {
[Link] = dimension;
[Link] = dimension;
}
45
Example
// Troisième constructeur avec deux paramètres
public Rectangle(double largeur, double hauteur) {
[Link] = largeur;
[Link] = hauteur;
}
// Méthode pour calculer le périmètre
public double perimetre() {
return 2 * (largeur + hauteur);
}
// Méthode pour calculer la surface
public double surface() {
return largeur * hauteur;
}
46
Example
// Méthode pour agrandir les dimensions
public void agrandit(double facteur) {
[Link] *= facteur;
[Link] *= facteur;
}
// Méthode pour afficher les caractéristiques du rectangle
public void affiche() {
[Link]("Largeur : " + largeur);
[Link]("Hauteur : " + hauteur);
[Link]("Périmètre : " + perimetre());
[Link]("Surface : " + surface());
}}
47
Example
public class Main {
public static void main(String[] args) {
// Utilisation du premier constructeur (sans paramètre)
Rectangle rect1 = new Rectangle();
[Link]("Rectangle 1 :");
[Link]();
// Utilisation du deuxième constructeur (un seul
paramètre)
Rectangle rect2 = new Rectangle(5);
[Link]("\nRectangle 2 :");
[Link]();
48
Example
// Utilisation du troisième constructeur (deux paramètres)
Rectangle rect3 = new Rectangle(4, 7);
[Link]("\nRectangle 3 :");
[Link]();
// Agrandissement du rectangle 3
[Link](2);
[Link]("\nRectangle 3 après
agrandissement :");
[Link]();
}
}
49
Passage de paramètres
❑En Java, les paramètres sont toujours passés par valeur,
c'est à dire que la valeur du paramètre effectif est recopiée
dans le paramètre formel correspondant :
❖ A l'appel de chaque méthode, de l'espace mémoire local
est alloué pour chaque paramètre formel;
❖ Les valeurs des paramètres effectif sont copiées avant
l'appel de la méthode;
❖ Le calcul s'effectue sur les paramètres formels;
50
Passage de paramètres
❑Exemple
public class Test {
public void param(double x) {
x=5;
}
public static void main(String arg[]){
Test test=new Test();
double a = 10;
[Link]("Avant l'appel de param: a="+a);
[Link](a);
[Link]("Aprés l'appel de param: a="+a);
}
}
51
Passage de paramètres
❑Exemple
main() param()
a 10 x
Résultat affiché:
Avant l'appel de param: a=10.0
Aprés l'appel de param: a=10.0
52
Passage de paramètres
Cas du passage d'un objet
❑Quand on passe un objet en paramètres, c’est la
référence sur cet objet qui est passée et copiée
comme paramètre formel.
❑Donc si l’objet est modifié dans la méthode, les
modifications seront visibles de l’extérieur.
53
Passage de paramètres
public class Calcul {
public static void doublerValeurs(int[] tableauDeNombres) {
for (int i = 0; i < [Link]; i++) {
tableauDeNombres[i] = tableauDeNombres[i] * 2;
}
}
public static void main(String[] args) {
int[] mesNombres = {10, 20, 30, 40};
for (int nombre : mesNombres) {
[Link](nombre + " ");
}
54
Passage de paramètres
[Link]();
doublerValeurs(mesNombres);
for (var nombre : mesNombres) {
[Link](nombre + " ");
}
[Link]();
}
}
55
Passage de paramètres
public class Point{
private double x;
private double y;
public Point(double x, double y){this.x=x; this.y=y; }
public static void deplacer (Point pt, double dx, double dy){
pt.x=pt.x+dx;
pt.y=pt.y+dy;
}
public String toString(){ return "Point(" + x +","+ y +")";}
public static void main(String arg[]){
Point p= new Point(10.0,10.0);
[Link]("Avant l'appel de deplacer "+[Link]());
deplacer (p,5.0,5.0);
[Link]("Aprés l'appel de deplacer "+[Link]());
}
}
56
Passage de paramètres
public class Point{
private double x;
private double y;
public Point(double x, double y){this.x=x; this.y=y; }
public static void deplacer (Point pt, double dx, double dy){
pt.x=pt.x+dx;
pt.y=pt.y+dy;
}
public String toString(){ return "Point(" + x +","+ y +")";}
public static void main(String arg[]){
Point p= new Point(10.0,10.0);
[Link]("Avant l'appel de deplacer "+[Link]());
deplacer (p,5.0,5.0);
[Link]("Aprés l'appel de deplacer "+[Link]());
} Résultat affiché:
} Avant l'appel de deplacer Point(10.0,10.0)
Aprés l'appel de deplacer Point(15.0,15.0) 57
Passage de paramètres
main(…)
p= new Point(10.0,10.0);
p Point
x 10
y 10
58
Passage de paramètres
p= new Point(10.0,10.0);
p Point
x 15
y 15
deplacer (p,5.0,5.0);
pt public static void deplacer (Point pt,
dx 5 double dx, double dy){ pt.x=pt.x+dx;
pt.y=pt.y+dy;
dy 5
}
Résultat affiché
Avant l'appel de deplacer Point(10.0,10.0)
Aprés l'appel de deplacer Point(15.0,15.0)
59
Les éléments statiques
Les attributs statiques (les attributs de classes)
❑Les attributs statiques sont définis avec le mot clé static;
❑Il n’existe qu’une seule copie de l’attribut statique pour
tous les objets de la classe;
❑Si un seul objet modifie la valeur d’un attribut statique, sa
valeur sera modifiée pour tous les objets de la classe.
❑Pour accéder à un attribut statique, on utilise la notation :
[Link]
❑Exemple
public class Voiture {
static byte nbRoues = 4;
private double longueur;
private byte nbPassagers;
}
60
Les éléments statiques
Les attributs statiques (les attributs de classes)
❑Un usage classique de l’attribut statique est donné par
l’exemple suivant:
❑Exemple:
Nous voulions ajouter un attribut d’identification «id» à la
classe Personne, tel que chaque objet de la classe Personne
aura sa propre valeur pour cette attribut (deux objets ne
doivent pas avoir la même valeur pour l’attribut «id».
❑Solution:
❖Déclaration de l’attribut «id» et d’un attribut static
«nombre» initialisé à 0.
❖Dans le constructeur de la classe Voiture : Affectation de
la valeur de l’attribut «nombre» à l’attribut « id », et
incrémentation de la valeur de l’attribut « nombre » .
61
Les éléments statiques
Les attributs statiques (les attributs de classes)
❑Exemple
public class Personne{
//Attributs
private int id;
public static int nombre=0;
private String nom;
//Constructeur
public Personne(String nom){
id = nombre;
nombre++;
[Link]=nom;
}
//Methode toString()
public String toString(){
return "Id:"+ [Link]+", Nom:"+[Link];
}
}
62
Les éléments statiques
❑Exemple
public class MainClass{
public static void main(String arg[]){
Personne p1=new Personne("Ahmed");
Personne p2=new Personne ("Ali");
Personne p3=new Personne ("Aicha");
[Link](p1);
[Link](p2);
[Link](p3);
[Link]("Nombred'objets=
"+[Link]);
}
}
63
Les éléments statiques
❑Exemple
public class MainClass{
public static void main(String arg[]){
Personne p1=new Personne("Ahmed");
Personne p2=new Personne ("Ali");
Personne p3=new Personne ("Aicha");
[Link]([Link]());
[Link]([Link]());
[Link]([Link]()); Le résultat affiché est:
[Link]("Nombred'objets= Id:0, Nom:Ahmed
"+[Link]); Id:1, Nom:Ali
} Id:2, Nom:Aicha
} Nombre d'objets=3
64
Les éléments statiques
Les méthodes statiques
❑L’intérêt des méthodes statiques est de pouvoir être appelé alors
qu’on ne dispose pas d’un objet.
❑Une méthode statique ne peut utiliser que des attributs et des
méthodes statiques.
❑Pour appeler une méthode statique :
[Link]()
❑Exemple
public class Additionneur {
public static int somme(int a, int b) { return (a+b);}
}
❑Pour appeler la méthode somme, on aura pas besoin de créer un
objet de la classe Additionneur, il suffit d’écrire par exemple :
[Link](5,10); 65
Les éléments statiques
La méthode main(..)
❑ La méthode main est la première méthode exécutée par une
application Java lors de son lancement
❑ La méthode main() de la classe principale d'une application doit
être déclarée de la façon suivante :
public static void main (String args[ ]) { ... }
❑ Une application Java peut avoir des arguments. Ils seront introduits
après le nom de l’application.
❖ Pour les prendre en compte, la méthode main doit avoir comme
paramètres la chaîne " String [ ] args ".
❖ En effet, un tableau de string est nécessaire pour stocker les
arguments introduits. L’indice du nième argument est n-1.
66
Les éléments statiques
La méthode main(..)
❑"[Link]" permet de déterminer le nombre
d’arguments introduits après le nom de l’application
❑ Cette déclaration de la méthode main() est imposée par la
machine virtuelle pour reconnaître le point d'entrée d'une
application
❑ Si la déclaration de la méthode main() diffère, une
exception sera levée lors de la tentative d'exécution par la
machine virtuelle.
67
Les éléments statiques
Les méthodes statiques
❑Example
public class Personne{
//Attributs
...
//Méthodes
...
public static void main(String[] args) {
setName("Ali");//erreur, main() n’est executé par aucun
objet
Personne pers = new Personne();
[Link]("Ali");// correcte
}
}
68
La surcharge de méthodes (overloading)
❑La surcharge consiste à définir plusieurs méthodes qui
portent le même nom au sein de la même classe.
❑Les méthodes qui portent le même nom ont des
signatures différentes,
❑On appelle signature d’une méthode l’ensemble constitué
du nom de la méthode et des paramètres qui lui sont
passés.
❑Deux méthodes d’objets de la même classe qui portent le
même nom mais n’ont pas les mêmes paramètres, n’ont
pas la même signature et JAVA peut les distinguer.
❑Le compilateur choisi la méthode qui doit être appelée en
fonction du nombre et des types des paramètres.
❑La surcharge permet de simplifier l'interface des classes
vis à vis des autres classes.
69
La surcharge de méthodes (overloading)
❑Example
public class Additionneur{
public int somme(int a, int b) // 1
{return (a+b);}
public int somme(int a, int b, int c) // 2
{return (a+b+c);}
public float somme(float a, float b) // 3
{return (a+b);}
public float somme(int a, int b) //4
{return ((float)a+(float)b);} //erreur
}
❑La déclaration de la méthode 4 provoque une erreur, car, elle a la
même signature que la méthode 1.
70
Example
❑Créer une classe représentant un article d’un magasin de
vente par correspondance. Un article est caractérisé par sa
référence, sa désignation, son prix. Créer ensuite une
méthode main permettant de tester le bon fonctionnement
de la classe précédente.
71
Utilisation d’une classe
Initialisation d’une instance
❑Plusieurs possibilités sont disponibles pour initialiser les
champs d’une instance de classe. La première consiste à
initialiser les variables constituant les champs de la classe
au moment de leur déclaration.
public class Person {
private String lastName = "nouveauNom";
private String firstName = "nouveauPrenom";
private LocalDate birthDate = [Link]();
...
}
72
Utilisation d’une classe
❑Cette solution, bien que très simple, est relativement
limitée puisqu’il n’est pas possible d’utiliser des structures
de contrôle telles qu’une boucle à l’extérieur d’un bloc de
code. La solution qui nous vient immédiatement à l’esprit
est de placer le code d’initialisation à l’intérieur d’un
constructeur. C’est effectivement une très bonne idée et
c’est même l’objectif principal du constructeur que
d’initialiser les variables d’instance.
❑En revanche, un problème se pose avec les champs
statiques, car pour eux il n’est bien sûr pas nécessaire
d’avoir une instance de classe pour pouvoir les utiliser.
Donc si nous plaçons le code chargé de les initialiser dans
un constructeur, rien ne nous garantit que ce constructeur
ait été appelé au moins une fois avant l’utilisation des
champs statiques. 73
Utilisation d’une classe
❑Pour pallier ce problème, Java propose les blocs
d’initialisation statiques. Ce sont simplement des blocs de
code précédés du mot-clé static et délimités par les
caractères { et }. Ils peuvent apparaître n’importe où dans
le code de la classe et ils sont exécutés au chargement de la
classe par la machine virtuelle dans l’ordre dans lequel ils
apparaissent dans le code. Nous pouvons par exemple
utiliser le code suivant pour initialiser un champ statique
avec une valeur aléatoire inférieure à 1000.
74
Utilisation d’une classe
public class Person {
private String lastName = "nouveauNom";
private String firstName = "nouveauPrenom";
private LocalDate birthDate = [Link](1963, 11, 29);
private int number = 0;
private static int nbInstances;
static {
Random rd = new Random();
nbInstances = [Link](1000);
}
...
}
75
Utilisation d’une classe
❑Le même résultat peut être obtenu en créant une fonction privée
statique et en l’appelant pour initialiser la variable.
public class Person {
private String lastName = "nouveauNom";
private String firstName = "nouveauPrenom";
private LocalDate birthDate = [Link](1963, 11, 29);
private int number = 0;
private static int nbInstances = initCounter();
private static int initCounter() {
int counter = 0;
Random rd = new Random();
counter = nbInstances = [Link](1000);
return counter;
}
...
}
76
Utilisation d’une classe
❑Cette solution présente l’avantage de pouvoir utiliser la
fonction dans une autre partie du code de la classe.
❑Le même principe peut être appliqué à l’initialisation des
champs d’instance. Dans ce cas, le bloc d’initialisation ne
doit pas être précédé du mot-clé static. Ce bloc de code sera
automatiquement inséré au début de chaque constructeur
par le compilateur. L’initialisation d’un champ d’instance
peut également se faire par un appel de fonction, à
condition que la fonction ne puisse pas être redéfinie dans
une sous-classe, ce qui est assuré en la déclarant avec le
mot-clé final.
77
Utilisation d’une classe
Block statique ou initialiseur statique (Static Initializer)
❑Exécuté une seule fois lorsque le fichier .class est charge
par ClassLoader
❑Exécuté même avant main
❑N’est pas exécuté a chaque instanciation de la classe
❑N’a pas accès à this
Initialiseur d’instance (Instance Initializer)
❑Exécuté chaque fois qu’un constructeur de la classe est
appelé
❑A accès à this
❑A accès aux attributs statiques et non-statiques
78
Utilisation d’une classe
public class Personne {
// 1. Le bloc static est exécuté UNE SEULE FOIS, au
chargement de la classe.
static {
[Link]("Bloc initialiseur STATIQUE :
Chargement de la classe Personne.");
}
// 2. Le bloc d'instance est exécuté CHAQUE FOIS qu'un nouvel
objet est créé.
{
[Link]("Bloc initialiseur D'INSTANCE :
Creation d'un nouvel objet Personne.");
}
public static void main(String[] args) {
Personne p1 = new Personne();
Personne p2 = new Personne();
}
} 79
Utilisation d’une classe
80