MODÉLISATION &
PROGRAMMATION
OBJET
[email protected]
1
CLASSES EN JAVA (POO)
35
PRINCIPE DE BASE DE LA POO
• La Programmation Orientée Objets (POO) s’agit de regrouper ensemble les données et toutes le procédures qui
permettent la gestion de ces données. La structure ainsi obtenue est appelée : Objet.
• Un objet est composé de deux partie :
Une partie statique composée de la liste des données de l’objet. On les appelle : Attributs ou Propriétés, ou encore
Données Membres.
Une partie dynamique qui décrit le comportement ou les fonctionnalités de l’objet. Elle est constituée de l’ensemble
des procédures et des fonctions qui permettent à l’utilisateur de manipuler l’objet. Ainsi les données ne sont
généralement pas accessibles directement mais à travers les procédures et les fonctions de l’objet. Celles-ci sont
appelées : Méthodes ou Fonctions Membres.
Attributs ou Propriétés
Méthodes ou Fonctions Membres
36
ENCAPSULATION
• La définition des propriétés et des méthodes d’objet est réalisée dans une structure de données
appelée classe.
• Une classe est donc le support de l’encapsulation : c’est un ensemble de données (propriétés) et de
fonctions (méthodes) regroupées dans une même entité.
• Créer un objet depuis une classe est une opération qui s’appelle l’instanciation.
• L’objet ainsi créé pourra être appelé aussi : instance.
• Entre classe et objet il y a, en quelque sorte, le même rapport qu’entre type de données et variable.
• Pour utiliser une classe il faut en déclarer une instance (objet) de cette classe.
37
SYNTAXE DE DÉCLARATION D’UNE
CLASSE
• Voici une syntaxe simple pour définir un exemple de classe.:
public class MaClasse {
// Les propriétés de la classe
// les constructeurs de la classe
// les méthodes de la classe
}
• Public est un modificateur d'accès qui définit la visibilité de la classe.
Public signifie que tout autre programme du projet Java peut utiliser la classe, c'est-à-dire créer des instances ou
appeler des méthodes.
• Cette classe contiendra des attributs, des constructeurs et des méthodes. Ceux-ci peuvent être placés
dans n'importe quel ordre.
38
SYNTAXE DE DÉCLARATION D’UNE
CLASSE
public class Etudiant {
Exemple: //attribut
private String id_etudiant;
private String nom;
Classe UML Private double note;
Etudiant //méthodes
public String getNom() {
Return this.nom;
Code Java
-Id_etudiant : String }
-Nom : String public int getNote() {
-note: float Return this.note;
}
+getNom(): String public void setNote(double note) {
+getNote(): float this.note=note;
+setNom(String nom): void }
+setNote(int note): void public void setNom(String nom) {
this.nom=nom;
}
39
}
INSTANCIATION
• Il est nécessaire de déclarer un objet avant son instanciation. La déclaration est réalisée de la manière
suivante : NomDeClasse NomDeVariable;
• L’instanciation et réalisée ensuite à l’aide de l’opérateur new qui se charge de créer une instance (ou un
objet) de la classe et de l’associer à la variable: NomDeVariable = new NomDeClasse("ABC");
• Il est possible de réunir les 2 instructions en une seule :
NomDeClasse NomDeVariable = new NomDeClasse("ABC");
• L’opérateur new est un opérateur de haute priorité qui permet d’instancier des objets et d’appeler une
méthode particulière de cet objet : le constructeur.
• Le constructeur est une méthode de classe (sans type de retour) qui port le même nom que celui de
la classe et dans laquelle sont réalisées toutes les initialisation de l’objet en cours. Il est invoqué
automatiquement lors de l’instanciation de la classe.
40
MODIFICATEURS ET VISIBILITÉ
• Il existe 5 types de modificateurs très utilisés qui peuvent être associées à une données ou une
fonction membre : modificateurs de synchronisation, de visibilité, de permanence, de constance et
d’abstraction.
1. Modificateur synchronized : public synchronized void maMethode() {
// code critique
}
Une méthode synchronisée est une méthode qui ne peut être exécutée que par un seul thread à
la fois. Cela garantit que les ressources partagées sont accédées de manière contrôlée et évite
les conflits et les conditions de concurrence.
• Remarque : le modificateur de synchronisation est associé seulement aux méthodes.
41
MODIFICATEURS ET VISIBILITÉ
• Il existe 5 types de modificateurs très utilisés qui peuvent être associées à une données ou une
fonction membre : modificateurs de synchronisation, de visibilité, de permanence, de constance et
d’abstraction.
2. Modificateurs de visibilité :
private : Les attributs et les opérations (marqués avec – en UML) ne sont accessibles qu'à partir de l'intérieur
de la classe.
private double d;
public : Les attributs et les opérations (marqués avec + en UML) sont accessibles à partir de l'extérieur de la
classe, ainsi qu'à partir de l'intérieur.
public int n;
portected : Les attributs et les opérations (marqués avec # en UML) sont accessibles à partir de l'intérieur de
la classe et de ses sous-classes.
protected String s;
• Remarque : les modificateurs de visibilité sont associés aux classes et aux méthodes 42
MODIFICATEURS ET VISIBILITÉ
• Il existe 5 types de modificateurs très utilisés qui peuvent être associées à une données ou une
fonction membre : modificateurs de synchronisation, de visibilité, de permanence, de constance et
d’abstraction.
3. Modificateur static : permet de définir une donnée ou une méthode commune à toutes les
instances de la classe.
• Les membres static peuvent être appelés directement par l’intermédiaire du nom de la classe
(sans avoir besoin d’instancier la classe).
• Les données static sont appelées variable de classe et les méthodes static sont également
appelées méthodes de classe.
• une méthode static ne peut pas accéder à une donnée non-static ou une autre
méthode non-static.
43
MODIFICATEURS ET VISIBILITÉ
• Il existe 5 types de modificateurs très utilisés qui peuvent être associées à une données ou une
fonction membre : modificateurs de synchronisation, de visibilité, de permanence, de constance et
d’abstraction.
3. Modificateur static : permet de définir class Class1 {
static int x = 20;
une donnée ou une méthode commune
int y = 30;
à toutes les instances de la classe. static void p1() {
x = x + 1 ; // correcte
y = y * 2 ; // incorrecte
p2() ; // incorrecte
}
void p2() { // méthode non-static
x ++ ; // correcte
y ++ ; // correcte
p1() ; // correcte
}
} 44
MODIFICATEURS ET VISIBILITÉ
• Il existe 5 types de modificateurs très utilisés qui peuvent être associées à une données ou une
fonction membre : modificateurs de synchronisation, de visibilité, de permanence, de constance et
d’abstraction.
4. Modificateur final : Les données final sont des constantes. Ces données sont généralement
définies en plus public et static afin d’être accessibles depuis l’extérieur de la classe et
directement par l’intermédiaire du nom de celle-ci sans avoir besoin de créer une instance de la
classe.
• Exemple :
public static final int CONST1 = 20
public static final double PI = 3.14;
Remarque : lorsqu’une méthode porte le modificateur final, elle ne peut pas être redéfinie dans
une classe fille.
45
MODIFICATEURS ET VISIBILITÉ
• Il existe 5 types de modificateurs très utilisés qui peuvent être associées à une données ou une
fonction membre : modificateurs de synchronisation, de visibilité, de permanence, de constance et
d’abstraction.
5. Modificateur abstract : Ce modificateur permet de définir une méthode abstraite. Càd une
méthode dont le corps n’est pas défini. Une classe qui comporte une méthode abstraite doit, elle
aussi, être définie abstraite.
• Exemple :
abstract class ClassAbstraite {
…
abstract typeretour methodeAbstraite(parametres) ;
}
46
DURÉE DE VIE D’UN OBJET
• Les objets en java sont tous dynamiques. La durée de vie d’un objet passe par trois étapes :
a. la déclaration de l’objet et son instanciation à l’aide de l’opérateur new
b. l’utilisation de l’objet en appelant ces méthodes
c. la suppression de l’objet : elle est réalisée automatiquement à l’aide de la ramasse-miette
(Garbage Collector) qui libère l’espace mémoire associé à l’objet ne référence plus cet espace
mémoire (par exemple affectation de null à l’objet) et lorsque cet espace mémoire n’est plus
référencée par aucune autre variable).
47
AFFECTATION D’OBJETS
• L'affectation d'objet en Java est un processus qui permet de lier une variable à une instance d'une classe
ou d'un objet.
• L'affectation d'objet en Java ne copie pas l'objet lui-même. Elle crée une nouvelle référence à l'objet
existant.
Exemple:
NomDeClasse objet1 = new NomDeClasse ();
NomDeClasse objet2 = objet1;
objet1 et objet2 contiennent la même référence et pointent tous les deux sur le même
espace mémoire : les modifications faites à partir de l’une des deux variables modifient le
contenu aussi bien pour l’une que pour l’autre des 2 variables.
48
COMPARAISON D’OBJETS
• En Java, il existe deux manières de comparer des objets : la comparaison par référence et la comparaison par
valeur.
La comparaison par référence compare si deux variables référencent le même objet en mémoire. Cette
comparaison est effectuée à l'aide de l'opérateur ==.
La comparaison par valeur compare les attributs des objets pour voir s'ils sont égaux. Pour cela, il est
nécessaire de surcharger la méthode equals() dans la classe de l'objet.
Exemple :
Rectangle r1 = new Rectangle(100,50);
Rectangle r2 = new Rectangle(100,50);
Rectangle r3 = r1;
if (r1 == r2) { ... } // Faux
if (r1 == r3) { ... } // Vrai
if (r1.equals(r2)) { ... } // Vrai
Remarque : on utilise l'opérateur double signe égal (==) pour comparer les valeurs des primitives.
49
LE MOT CLÉ THIS
• En Java, le mot clé ‘this’ est utilisé pour faire référence à l'instance courante d'une classe. Il peut être
utilisé dans plusieurs contextes :
Référencer des variables d'instance : this.nomVariable
Lorsque des variables locales ou des paramètres de méthode ont le même nom que des variables
d'instance, this est utilisé pour faire référence à la variable d'instance.
Exemple :
public class Personne {
private String nom;
public Personne(String nom) {
this.nom = nom;
}
}
50
LE MOT CLÉ THIS
• En Java, le mot clé ‘this’ est utilisé pour faire référence à l'instance courante d'une classe. Il peut être
utilisé dans plusieurs contextes :
Appeler des constructeurs : this(...)
Dans un constructeur, ‘this’ peut être utilisé pour appeler un autre constructeur de la même
classe. Cette technique est appelée "appel de constructeur" ou "constructeur par défaut".
Exemple :
public class Personne {
private String nom;
private int age;
public Personne(String nom) {
this(nom, 0);
}
public Personne(String nom, int age) {
this.nom = nom;
this.age = age;
}
51
}
LE MOT CLÉ THIS
• En Java, le mot clé ‘this’ est utilisé pour faire référence à l'instance courante d'une classe. Il peut être
utilisé dans plusieurs contextes :
Retourner l'instance courante : this
Dans une méthode,‘this’ peut être utilisé pour retourner l'instance courante de la classe.
Exemple:
public class Personne {
private String nom;
public Personne setNom(String nom) {
this.nom = nom;
return this;
}
}
52
L’OPÉRATEUR instanceof
public class Main {
• En Java, l'opérateur instanceof est utilisé pour
vérifier si un objet est une instance d'une classe public static void main(String[] args) {
Object obj = "Bonjour";
ou d'une interface spécifique.
if (obj instanceof String) {
System.out.println("L'objet est une
• L'opérateur instanceof renvoie true si l'objet chaîne de caractères : " + obj);
} else {
est une instance de la classe ou de l'interface System.out.println("L'objet n'est pas une
spécifiée, ou si l'objet est une instance d'une chaîne de caractères.");
sous-classe ou d'une implémentation de }
l'interface spécifiée. }
}
53
SURCHARGE DES MÉTHODES
public class Calculatrice {
• La surcharge d’une méthode permet de définir public int additionner(int a, int b) {
plusieurs fois une même méthode avec des return a + b;
}
arguments différents. public double additionner(double a, double b)
{
• Une méthode est surchargée lorsqu’elle exécute return a + b;
}
des actions différentes selon le type et le nombre public int additionner(int a, int b, int c) {
de paramètres transmis. return a + b + c;
}
}
• Lors de l’appel à la méthode, le compilateur choisi
la méthode qui doit être appelée en fonction du
nombre et du type des arguments. Calculatrice calc = new Calculatrice();
int resultat = calc.additionner(5, 10,2);
double resultat = calc.additionner(2.5, 3.5);
54
LES ACCESSEURS
• L’encapsulation permet de sécuriser l’accès aux public class Number {
données privées d’une classe. private int value;
• Un accesseur est une méthode publique qui public Number(int value) {
donne l’accès à une propriété privée d’une classe. This.value = value;
}
• L’accès peut être réalisé en lecture ou en écriture.
public void setValue(int value) {
• Par convention, les accesseurs en lecture this.value = value;
commencent par le mot get (ou is si le type }
de la propriété est boolean) et sont appelés public int getValue() {
des getters et et les accesseurs en écriture return value;
commencent par le mot set et sont appelés }
des setters. }
55
DÉFINITION D’UN PACKAGE
• En java, un package est un moyen de regrouper des classe voisines ou qui couvrent un même domaine
dans une même structure appelée.
• Un package est essentiellement un répertoire qui contient les fichiers sources des classes et des
interfaces.
• Les packages permettent d'éviter les conflits de noms, de faciliter la réutilisation de code et de
maintenir la lisibilité et l'organisation du code.
• Les packages sont déclarés en haut des fichiers sources Java à l'aide de l'instruction package, qui est
suivie du nom du package.
• Exemple : package com.example;
public class Personne {
// code de la classe Personne
}
56
UTILISATION D’UN PACKAGE
• Les packages peuvent être importés à l'aide de l'instruction import dans les fichiers sources Java.
• L'importation permet d'utiliser les classes et interfaces d'un package sans avoir à spécifier le nom
complet à chaque fois.
Exemple : import com.example.Personne;
import java.util.*;
public class Main {
public static void main(String[] args) {
Personne personne = new Personne();
// code utilisant la classe Personne
}
}
Remarque : L’utilisation du symbole * donne l’accès à toutes les classes du package mais pas aux sous
packages de celui-ci. 57
RELATIONS EN JAVA (POO)
58
ASSOCIATION
• Décomposition / association (Rappel)
• L'association indique une relation libre entre deux objets, qui peuvent interagir l'un avec l'autre pendant
un certain temps. Ils ne sont pas dépendants l'un de l'autre.
• En java, une relation d’association est représentée comme suivant:
Personne Public class Personne {
//attributs
0..*
//méthodes
0..*
Public void reserver(Hotel hotel_star){
Hotel reserverHotel(hotel_star);
}
}
59
AGGREGATION
• Décomposition / aggrégation (Rappel)
• L'agrégation est une relation " possède-un " (faible) où un tout a des parties qui lui appartiennent.
• En java, une relation d’association est représentée comme suivant:
Equipe
public class Avion {
private ArrayList<Equipe> equipe;
0..* public Avion() {
0..* equipe = new ArrayList<Equipe>();
}
Avion public void ajouter( Equipe equipe ) {
…
}
} 60
COMPOSITION
• Décomposition / composition (Rappel)
• L'agrégation est une relation " possède-un " (forte) où un tout a des parties qui lui appartiennent.
• En java, une relation d’association est représentée comme suivant:
Chambre Maison
1..*
public class Maison {
private ArrayList<Room> rooms =new ArrayList<Room>();
public House(){
super();
}
} 61
Association Agrégation Composition
Définition Une interaction très lâche Un tout a une partie, mais les Le tout ne peut exister sans ses
entre deux objets deux peuvent exister parties et vice versa.
complètement indépendants. indépendamment.
Représentation
UML
Exemple du code Public class Personne { public class Avion { public class Maison {
java Public void private private
reserver(Hotel hotel){ ArrayList<Equipe> ArrayList<Room> rooms
reserverHotel(ho equipe; =new ArrayList<Room>();
tel); public Avion() public House(){
} public void super();
} ajouter( Equipe equipe ) }
{ }
…
}
}
62
GÉNÉRALISATION (HERITAGE)
• L'héritage est déclaré en Java à l'aide du mot-clé extends.
• Avec l'héritage, si vous voulez une instance d'une sous-classe, vous devez donner à la super-classe une
chance de préparer les attributs de l'objet de manière appropriée. Les classes peuvent avoir des
constructeurs implicites ou explicites.
Constructeur implicite Constructeur explicite
public abstract class Animal { public abstract class Animal{
protected int nombredepattes; protected int nombredepattes;
public void marcher() { … } public Animal(int pates){
} this.nombredepattes = pates;
}
63
GÉNÉRALISATION (HERITAGE)
• Les constructeurs explicites de la classe mère doivent être référencés par la classe fille. Pour accéder
aux attributs, méthodes et constructeurs de la superclasse, la sous-classe utilise le mot clé super.
• Les classes filles peuvent remplacer les méthodes de leur classe mère, ce qui signifie qu'une classe fille
peut fournir sa propre implémentation pour une méthode héritée de la classe mère.
super override
public class Lion extends Animal { public class Lion extends Animal {
public Lion( int pates ) {
super( pates ); @override
} public void marcher() {
System.out.println("je marche");
}
}
}
64
GÉNÉRALISATION (HERITAGE)
• En Java, seul l'héritage d'une seule implémentation est autorisé. Cela signifie que si une classe mère
(abstraite) peut avoir plusieurs classes filles, une classe fille ne peut hériter que d'une seule classe mère.
• L'héritage peut s'étendre à autant de classes que l'on veut.
65
GÉNÉRALISATION : INTERFACE
• Comme une classe abstraite, une interface Java désigne public interface IAnimal {
également un type, mais une interface ne déclare que public void marcher();
public void crier();
des signatures de méthodes, sans constructeurs,
public void manger();
attributs ou corps de méthodes.
}
• En Java, le mot clé interface est utilisé pour indiquer
qu'une interface est en cours de définition. La lettre "l"
public class Lion implements IAnimal
est parfois placée avant un nom pour indiquer une {
interface. public void marcher() { … }
• Afin d'utiliser une interface, vous devez déclarer que public void crier() { … }
vous allez remplir le contrat tel que décrit dans public void manger() { … }
}
l'interface. Le mot clé en Java pour cette action est
implements.
66
GÉNÉRALISATION : INTERFACE
• Comme les classes abstraites, qui sont des classes qui public class Lion implements IAnimal {
ne peuvent pas être instanciées, les interfaces sont un public void crier() {
moyen de réaliser le polymorphisme. System.out.println( "rugir!" );
}
• Dans les langages orientés objet, on parle de }
polymorphisme lorsque deux classes ont la même
description d'un comportement, mais que les public class Loup implements IAnimal {
implémentations de ce comportement peuvent être public void crier() {
différentes. System.out.println( "hurle!" );
}
}
67
GÉNÉRALISATION : INTERFACE
public interface IVehicleMovement {
public void moveOnX();
• Les interfaces peuvent hériter d'autres interfaces, mais public void moveOnY();
les interfaces ne doivent pas être étendues si vous }
essayez simplement de créer une interface plus grande.
• L'interface A ne doit hériter de l'interface B que si les
comportements de l'interface A peuvent être
public interface IVehicleMovement3D
entièrement utilisés pour remplacer l'interface B.
extends
IVehicleMovement {
public void moveOnZ();
}
68
