Poo Java PDF

La Programmation Orientée Objet
POO en Java
Programmation Orientée Objet en JAVA

Module: M22 - 4ième Année FI-GTR
Pr. Abdessamad EL BOUSHAKI

abdessamad.elboushaki@gmail.com
ENSA de Fès
Université Sidi Mohammed Ben Abdellah
Pr. Abdessamad EL BOUSHAKI (ENSA de Fès) Programmation Orientée Objet avancée en JAVA 1
POO en Java
Sommaire
1 La Programmation Orientée Objet
2 POO en Java
POO en Java
POO en Java
L’évolution de la programmation
Aux origines de l’informatique

I Programmation des ordinateurs dictée par le fonctionnement des processeurs.
I Programme = Succession d’instructions

I Organisation du programme et nature des instructions doit être le plus proche
possible de la façon dont le processeur les exécute.
I Modification des données mémorisées.
I Déplacement des données d’un emplacement à un autre.
I Opérations arithmétiques et de logique élémentaire.
I Programmation en langage machine (Ex: l’assembleur).

I Exemple: ”c = a + b” se programme:
I LOAD a, REG1
I LOAD b, REG2
I ADD REG3, REG1, REG2
I MOVE c, REG3
POO en Java
Langages de programmation procéduraux
I En programmation procédural ou structurée, un programme est formé de la
réunion de différentes procédures et de différentes structures de données,
généralement indépendantes de ces procédures.
I Repose sur l”’équation de Writh” :
Algorithmes + Structures de données = Programmes

I Mise au point d’algorithmes plus complexes.
I Nécessité de simplifier la programmation
⇒ Distance par rapport au fonctionnement des processeurs
I Apparition de langages procéduraux:
⇒ Exemple: Cobol, Basic, Pascal, C...
I Permettant d’écrire les programmes en langage plus verbal:
⇒ Ex: IF a>b THEN a = a + b
I Nécessité donc d’une traduction des programmes en instructions élémentaires
→ Compilation.
POO en Java
Malgré ses avantages, l’approche procédurale présente également des

inconvénients:
I Raisonnement reste néanmoins conditionné par la conception des traitements
et leur succession
⇒ Eloigné de la manière humaine de poser et résoudre les problèmes
⇒ Mal adapté à des problèmes de plus en plus complexes.
I Les fonctions, procédures accèdent à une zone où sont stockées les données. Il
y a donc une dissociation entre les données et les fonctions fonctions ce qui
pose des difficultés lorsque l’on désire changer les structures de données.
I Dans le langage structuré, les procédures s’appellent entre elles et peuvent

donc agir sur les mêmes données. Il y a donc un risque de partage de données
(écriture en même temps dans le même fichier).
POO en Java
L’avènement de l’objet
I Afin de:
⇒ Libérer la programmation des contraintes liées au fonctionnement des
processeurs.
⇒ Rapprocher la programmation du mode cognitif de résolution des
problèmes.
I Mise au point d’un nouveau style de langages de programmation
⇒ Exemple: Simula, Smalltalk, C++, Eiffel, Java, C#, Delphi, PowerBuilder,
Python...
I Repose sur le concept d’objet qui est une association de données et de
procédures (ou méthodes) agissant sur ces données :
Méthodes + Données = Objets

I Idée:
⇒ Placer les entités, objets ou acteurs du problème à la base de la conception.
⇒ Etudier les traitements comme des interactions entre les différentes entités.
⇒ Penser aux données AVANT de penser aux traitements.
⇒ Penser un programme en modélisant le monde tel qu’il nous apparaı̂t.
⇒ Définir des objets et les faire interagir.
POO en Java
Qu’est-ce que la POO?
C’est un style consiste à définir les différents acteurs (objets), leurs

caractéristiques et comportements et à les faire interagir.
Permet donc de découper les problèmes informatiques non en termes de

fonctions (que se passe-t-il?) mais en termes de données (qui intervient
dans le problème?) et des services que celles-ci peuvent rendre au reste du
programme (les comportements).
Programmer en OO, c’est donc définir des objets et les faire interagir.
La POO permet une modélisation plus naturelle des systèmes considérés. et

propose un ensemble de concepts indépendants de tout langage de
programmation facilitant le représentations des objets :
du monde réel (personne, voiture, animale ...),
d’un domaine particulier (vecteur, matrice, complexe, ...).
POO en Java
Les avantages de la POO
Les fonctionnalités propres au style objet favorisent:

I La programmation modulaire: Les objets forment des modules compacts
regroupant des données et un ensemble d’opérations.
I L’abstraction: Les entités objets de la POO sont proches de celles du monde
réel. Les concepts utilisés sont donc proches des abstractions. familières que
nous exploitons.
I La spécialisation: un objet de type S peut être spécialisée à partir d’un objet
de type T sans que le programme n’ait de comportement imprévu ou ne perde
de propriétés souhaitées.
L’objectif est de produire du code:

I facile à développer, à maintenir, à faire évoluer,
I réutilisable, tout ou en partie, sans avoir besoin de le dupliquer,
I générique, et dont les spécialisations sont transparentes
POO en Java
Concepts généraux de la POO
Objet
Classe
L’encapsulation
L’héritage
Polymorphisme
POO en Java

Objet
C’est là qu’intervient la programmation orientée objet, fondée justement sur

le concept d’objet, à savoir une association des données et des fonctions
(méthodes) opérant sur ces données.
Un objet est caraxtérisé par:
un état : ensemble de valeurs, les données.
un comportement : ensemble d’opérations réalisables.
état et comportement sont donc indissociables.
Le comportement est conçus pour un objet en particulier et ne peuvent pas
s’appliquer à d’autres objets.
Pour définir un objet, il faut:
connaı̂t ses caractéristiques.
sait comment effectuer les opérations qui le concernent.
réagit à des messages lui demandant d’effectuer un certain traitement.
POO en Java

Objet
Quelques exemples:
Objet Etat Comportement

N0 , marque, Appeler, Prendre un appel,
Téléphone sonnerie, répertoire, opérateur Envoyer SMS, Charger
Plaque, marque, Tourner, accélérer, s’arrêter,
Voiture couleur, vitesse faire le plein, klaxonner
nom, prénom, CIN, taille, respirer, marcher,
humain poids, genre, adresse parler, travailler
POO en Java

Classe
C’est une généralisation de la notion de type.

C’est la description d’un ensemble d’objet ayant une structure de données
commune et disposant des même méthodes.
Une classe décrit le domaine de définition d’un ensemble d’objets.
⇒ Elle détermine tout ce que peut contenir un objet et tout ce qu’on peut
faire de cet objet.
Chaque objet est une instance d’une classe (mécanisme d’instanciation).
Dans une classe, on réunit :
des données variables : les données membres, ou les attributs de la classe.
des fonctions : les fonctions membres, ou les méthodes de la classe.
Une classe peut-être composite ⇔ peut contenir elle-même des objets

d’autres classes.
Ex: Une voiture contient un moteur qui contient des cylindres...
POO en Java

L’encapsulation
L’encapsulation consiste à masquer les détails d’implémentation d’un objet,

en définissant une interface.
Il permet de cacher des membres d’une classe afin que l’interface de la classe
ne dispose que des membres qui ont été choisis par le concepteur de la classe.
Le principe de l’encapsulation des données en POO est qu’on n’agit pas
directement sur les données d’un objet. On interagit par l’intermédiaire de
ses méthodes. Cela facilite la maintenance et la réutilisation.
Intérêts :
facilite l’évolution d’une application car elle stabilise l’utilisation des objets :
on peut modifier l’implémentation des attributs d’un objet sans modifier son
interface.
garantit l’intégrité des données, car elle permet d’interdire l’accès direct aux
attributs des objets (utilisation d’accesseurs).
POO en Java

L’encapsulation - Droits d’accès aux membres
Les droits d’accès aux membres d’une classe concernent aussi bien les
méthodes que les attributs.
En Java, on dispose des droits d’accès suivants :
I Accès public : on peut utiliser le membre de n’importe où dans le
programme.
I Accès private : seule une fonction membre de la même classe A peut utiliser
ce membre ; il est invisible de l’extérieur de A.
I Accès protected : ce membre peut être utilisé par une fonction de cette
même classe A, et pas ailleurs dans le programme il ressemble donc à
private, mais il peut en plus être utilisé par une classe B qui hérite de A.
Il existe une règle de POO qui précise que les attributs doivent être
encapsulées dans la classe pour éviter une utilisation extérieure. C’est une
forme de protection permettant d’éviter une utilisation incorrecte ou non
prévue par le programmeur de la classe. On appliquera ce principe en
déclarant l’ensemble des attributs en private.
POO en Java

L’héritage
L’héritage permet de former une nouvelle classe à partir d’une autre classe
existante.
La nouvelle classe (classe fille, sous-classe) hérite des attributs et des
méthodes de classe à partir laquelle elle a été formée (classe mère,
super-classe).
De nouveaux attributs et de nouvelles méthodes peuvent être définis dans la
classe fille. (Spécialisation)
Des méthodes de classe mère peuvent être redéfinies dans la classe fille.
Intérêts : Réutilisation
Utiliser une classe existante...
I En lui rajoutant des membres
I et/ou en modifiant certains de ses comportements
sans modifier le code de la classe existante.
POO en Java

Polymorphisme
Le nom de polymorphisme vient du grec et signifie qui peut prendre plusieurs

formes.
Dans la POO en Java, le polymorphisme est utilisé en relation avec les
méthodes.
Des méthodes de mêmes noms peuvent avoir des comportements différents
ou effectuer des opérations sur des données de types différents.
On distingue généralement deux types de polymorphisme :
I Le polymorphisme ad-hoc (également surcharge): Représente la possibilité de
définir plusieurs méthodes de même nom mais possédant des paramètres
différents (en nombre et/ou en type).
I Le polymorphisme d’héritage (également redéfinition) : Représente la
possibilité de redéfinir une méthode dans des classes héritant d’une classe de
base s’appelle la spécialisation.
La gestion du polymorphisme est assurée par la machine virtuelle

dynamiquement à l’exécution.
POO en Java
POO en Java
POO en Java
La classe
Définir une classe
La syntaxe de déclaration d’une classe est la suivante :
modificateurs class nomClasse {

... // corps de la classe ( d é finition des attributs et m é thodes )
}
Les modificateurs de classe sont:

I abstract: une classe déclarée abstract ne peut pas être instanciée : il faut
définir une classe qui hérite de cette classe et qui implémente les méthodes
nécessaires pour ne plus être abstraite.
I final: la classe ne peut pas être modifiée, sa redéfinition grâce à l’héritage
est interdite. Les classes déclarées final ne peuvent donc pas avoir de classes
filles.
I private: la classe n’est accessible qu’à partir du fichier où elle est définie.
I public: la classe est accessible partout.
L’ordre des méthodes et des attributs dans une classe n’a pas d’importance.
POO en Java
La classe
Déclaration des attributs
Les attributs d’un objet sont définis par ses variables membres.
Pour définir les attributs d’un objet, il faut donc définir les variables membres
de sa classe.
La syntaxe de déclaration d’un attribut est la suivante :
modificateurs [ options ] type nomAttribut ;
La signature de la variable:
I modificateurs: indiquent le niveau d’accessibilité de la variable.
I [static]: permet la déclaration d’une variable de classe.
I [final]: empêche la modification de la variable (Crée une constante).
I [transient]: on ne tient pas compte de la variable en sérialisant l’objet
I [volatile]: pour le multithreading
I type: le type de la variable (ex: int, String, double,...)
I nomAttribut: le nom de l’attribut (identificateur)
POO en Java
La classe
Déclaration des attributs
Remarque: Les attributs membres sont des variables déclarées à l’intérieur

du corps de la classe mais à l’extérieur d’une méthode particulière, c’est ce
qui les rend accessibles depuis n’importe où dans la classe.
Exemples:
private int maVitesse ;

public final static int ORIGIN = 0;
POO en Java
La classe
Déclaration des méthodes
La classe définit aussi les comportements des objets.

Pour définir les comportements d’un objet, il faut donc définir les méthodes
membres de sa classe.
La syntaxe de déclaration d’une méthode est la suivante :
modificateurs [ options ] typeRetour nomMethode ( typeParam1 param1 ,...)
{
instructions ;
}
Signature d’une méthode:

I Modificateurs d’accès: public, protected, private, aucun.
I [options]: static, native, synchronized, final, abstract.
I [typeRetour]: type de la valeur retournée.
I [nomMethode]: Nom de la méthode (identificateur).
I [typeParam1 param1]: Listes de paramètres entre parenthèses (peut être
vide mais les parenthèses sont indispensables).
I instructions: le corps de la méthode (Implémentation de la méthode).
POO en Java
La classe
Déclaration des méthodes
Au minimum:
I La méthode possède un identificateur et un type de retour.
I Si la méthode ne renvoie rien, le type de retour est void.
Les paramètres d’une méthode fournissent une information depuis l’extérieur
du ”scope” de la méthode.
On a pas besoin de passer les attributs de la classe comme arguments aux
méthodes de cette classe.
Exemples :
public void afficher ()
{
System . out . println ( " I am object " );
}
POO en Java
La classe
L’encapsulation
Les modificateurs d’accès qui caractérisent l’encapsulation sont justifiées par

différents éléments:
Préservation de la sécurité des données
I Les données privées sont simplement inaccessibles de l’extérieur.
I Elles ne peuvent donc être lues ou modifiées que par les méthodes d’accès
rendues publiques.
Préservation de l’intégrité des données
I La modification directe de la valeur d’un attribut privée étant impossible,
seule la modification à travers des méthodes spécifiquement conçues est
possible, ce qui permet de mettre en place des mécanismes de vérification et
de validation des valeurs de l’attributs.
Cohérence des systèmes développés en équipes
I Les développeurs de classes extérieures ne font appel qu’aux méthodes et,
pour ce faire, n’ont besoin que de connaı̂tre la signature. Leur code est donc
indépendant de l’implémentation des méthodes.
POO en Java
La classe
Exemple: la classe Point
Un point d’un plan 2D est caractérisé par ses coordonnées x et y Supposant

que les coordonnées sont des entiers, la classe décrivant un point est déclarée
en Java par:
Fichier Pixel.java
public class Pixel {
// Les attributs
private int x ;
private int y ;
// les m é thodes
public void SetCoord ( int coord_x , int coord_y )
{
x = coord_x ; y = coord_y ;
}
public void Deplacer ( int dx , int dy )
{
x += dx ; y += dy ;
}
public double DistOrigin ()
{
double dist ;
dist = Math . sqrt ( Math . pow (x ,2)+ Math . pow (y ,2));
return dist ;
}
public void Afficher ()
{
system . out . println ( " Point ( " + x + " ," + y + " ) " );
}
}
POO en Java
Création d’instances
Déclaration et instanciation
La déclaration d’une instance d’une classe se fait de la façon:
nomClasse nomInstance ; // d é claration

nomInstance = new nomClasse (); // cr é ation
// ou bien
nomClasse nomInstance = new nomClasse ();
l’operation de déclaration ne réserve pas d’emplacement pour un objet de

type NomClasse, mais seulement un emplacement pour une référence à un
objet de ce type.
L’emplacement pour l’objet proprement dit sera alloué sur une demande
explicite du programme, en faisant appel l’opérateur d’instanciation new.
I Il initialise chaque champ à sa valeur par défaut
I Il peut exécuter un bloc d’initialisation éventuel
I Il retournera la référence de l’objet ainsi créé
Objet qui n’est plus référencé, le ramasse-miettes (garbage collector )
récupère automatiquement la mémoire associée.
POO en Java
Accès aux membres
L’accès aux valeurs des attributs d’une instance de nom nomInstance se fait
comme suite:
nomInstance . nomAttribut
L’appel aux méthodes définies pour une instance de nom nomInstance se

fait à l’aide d’expressions de la forme:
nomInstance . nomMethode ( valParam1 ,...)
Le compilateur regarde le type déclaré de l’objet (ici nomInstance) et vérifie

que le membre (ici nomAttribut ou nomMethode) existe.
Le compilateur vérifie également les droits d’accessibilité.
POO en Java
Exemple: instance de la classe Point
un exemple complet d’une classe nommée TstPixel contenant (seulement)

une fonction main utilisant notre classe Pixel:
Fichier TstPixel.java
public class TstPixel {
public static void main ( String args []){
Pixel a ;
a = new Pixel () ;
a . SetCoord (3 , 5) ;
a . Afficher () ; // P (3 ,5)
a . Deplacer (2 , 0) ;
a . Afficher () ; // P (5 ,5)
Pixel b = new Pixel ();
b . SetCoord (6 , 8) ;
b . Afficher () ; // P (6 ,8)
}
}
POO en Java
Autoréférence : le mot clé this
Dans certaines conditions particulières, il est nécessaire de disposer d’un

moyen de désigner depuis l’intérieur d’une méthode, non pas les données
membres, mais l’instance elle-même de la classe sur laquelle la méthode
membre est appelée.
Le mot clé this permet de désigner l’instance (de l’objet courant) sur
laquelle la méthode a été appelée.
Celui-ci, utilisable uniquement au sein d’une fonction membre.
POO en Java
Autoréférence : le mot clé this
Exemple d’utilisation d’autoréférence this

private int x ;
private int y ;
public void SetCoord ( int x , int y )

{
this . x = x ; this . y = y ; /* Ici this permet de distinguer le param è tre
x de l ’ attribut x de l ’ objet de type Pixel
sur lequel on a appel é SetCoord */
}
public Pixel GetPixel ()
{
return this ; /* Ici this est l ’ objet courant de type Pixel
sur lequel on a appel é GetPixel */
}
public void Afficher ()
{
system . out . println ( " Point ( " + this . x + " ," + this . y + " ) " );
}
}
POO en Java
Les constructeurs
Un constructeur est une méthode particulière de la classe, qui sert à

initialiser un objet une fois que la mémoire est réservée par new.
Permet de garantir des invariants sur un objet sont conservés, par exemple
pour initialiser un objet avec des valeurs particulières
⇒ EX: on veut qu’un Point soit en (1,1).
Le constructeur a le même nom que la classe et pas de type de retour (pas
même void):
Signature d’un constructeur :
I Modificateur d’accès (en général public)
I Pas de type de retour
I Le même nom que la classe
I Les arguments sont utilisés pour initialiser les variables de la classe
Public nomClasse ( typeParam1 param1 ,...)

{
instructions ;
}
POO en Java
Les constructeurs
On peut surcharger les constructeurs, i.e définir de multiples constructeurs

(plusieurs recettes existent pour fabriquer un même objet avec des
ingrédients différents).
Une classe doit toujours avoir au minimum un constructeur.
En l’absence de constructeur explicitement défini, le compilateur ajoute un
constructeur public par default sans paramètre.
Le rôle du constructeur par défaut est de créer une instance non initialisée
quand aucun autre constructeur fourni n’est applicable.
Par exemple, le constructeur par défaut de classe nomClasse sera :
Public nomClasse () // Sans aucun param è tre !
{}
Remarque : Si (au moins) un constructeur a été déclaré dans une classe, le

constructeur par défaut implicite n’est plus disponible. Mais un constructeur
par défaut peut être déclaré.
POO en Java
Les constructeurs
Exemple de définition des constructeurs pour la classe Pixel
private int x ;
private int y ;
Public Pixel () // cr é e un pixel avec les coordonn é es à l ’ origine

{ this . x = 0; this . y = 0; }
public Pixel ( int a ) // cr é e un pixel sur la diagonale ( x == y )
{ this . x = this . y = a ; }
public Pixel ( int x , int y ) /* cr é e un pixel avec les coordonn é es
explicites */
{ this . x = x ; this . y = y ; }
}
Appel des constructeurs

public class TstPixel {
public static void main ( String args []){
Pixel p1 = new Pixel (); // Appel de constructeur Pixel ()
Pixel p2 = new Pixel (5); // Appel de constructeur Pixel ( int )
Pixel p3 = new Pixel (3 , 3); // Appel de constructeur Pixel ( int , int )
}
}
POO en Java
Les constructeurs
Un constructeur peut en appeler un autre en cascade en utilisant this(...)
Syntaxe:
public Constructeur (...)
{
this (...); // appelle au constructeur
...
}
Exemple :
private int x ;
private int y ;
public Pixel ( int x , int y )

{
this . x = x ; this . y = y ;
}
public Pixel ( int v )
{
this (v , v );
}
}
POO en Java
Accesseurs et mutateurs
Si c’est nécessaire, l’accès aux attributs privés d’une classe se fera par
l’intermédiaire de méthodes nommées des accesseurs et mutateurs.
I Un accesseur est une méthode qui permettre d’accéder aux attributs de objets
en lecture
I Un mutateur est une méthode qui permettre d’accéder aux attributs de objets
en écriture
On a l’habitude de les nommer get() pour l’accès en lecture et set() pour
l’accès en écriture d’un attribut.
Modificateur d’accès aux accesseurs et mutateurs est en général public.
Les accesseurs sont du même type que les attributs qu’ils doivent retourner.
Les mutateurs sont, par contre, de type void.
POO en Java
Accesseurs et mutateurs
Exemple de définition de get() et set() pour les attributs de la classe Pixel
private int x ;
private int y ;
// ************* ACCESSEURS *************

public int getX () // Retourne l ’ attribut x
{
return this . x ;
}
public int getY () // Retourne l ’ attribut y
{
return this . y ;
}
// ************* MUTATEURS *************
public void setX ( int x ) // changer la valeur de l ’ attribut x
{
this . x = x ;
}
public void setY ( int y ) // changer la valeur de l ’ attribut y
{
this . y = y ;
}
}
POO en Java
La surcharge des méthodes
En Java, les méthodes comme les constructeurs peuvent être surchargées:

(overloaded)
Plusieurs méthodes peuvent porter le même nom si leurs signatures diffèrent.
La signature d’une méthode correspond aux caractéristiques de ses
paramètres:
I leur nombre
I le type respectif de chacun d’eux
Le compilateur doit pouvoir trouver la méthode qui convient le mieux au site
d’appel, c’est à dire au nombre et au type des arguments.
Si aucune méthode ne correspond exactement, le compilateur peut prendre
une méthode approchée en fonction du typage.
En règle générale, il est préférable d’utiliser la surcharge entre les méthodes
quand elles ont la même sémantique.
POO en Java

Exemple
private int x ;
private int y ;
public Pixel ( int x , int y )

{ this . x = x ; this . y = y ;}
public double distance ( int x , int y )
{ // calculer la distance entre l ’ instance courant et le point (x , y )
int dx = this . x - x ; int dy = this . y - y ;
return Math . sqrt ( dx * dx + dy * dy );
}
public double distance ( Pixel p )
{ // calculer la distance entre l ’ instance courant et l ’ objet p
return distance ( p . getX () , p . getY ());
}
public double distance ( int x )
{ // calculer la distance entre l ’ instance courant et le point (x , x )
return distance (x , x );
}
public double distance ()
{ // calculer la distance entre l ’ instance courant et l ’ origine
return distance (0 ,0);
}
}
POO en Java
Cont...
class PointDist {
public static void main ( String args []) {
Point p1 = new Point (10 , 10);
Point p2 = new Point (30 , 40);
System . out . println ( " p1 . distance ( p2 ) = " + p1 . distance ( p2 ));
System . out . println ( " p1 . distance (60 , 80) = " + p1 . distance (60 , 80));
System . out . println ( " p1 . distance () = " + p1 . distance ());
System . out . println ( " p1 . distance (10) = " + p1 . distance (10));
}
}
POO en Java
Le typage et la surcharge
Les types des arguments peuvent quelquefois être ordonnés par une relation
de sous-typage.
Il y a deux catégories du sous-typage:
I sous-typage sur les types références : lié aux classes, aux interfaces, aux
classes abstraites, à l’héritage...
I sous-typage sur les types primitifs : on parle de conversion implicite
byte > short > int > long > float > double
char > int
Exemple
public class Overloading {
public double somme ( int a , int b ) { return a + b ;}
public double somme ( int a , double b ) { return a + b ;}
public static void main ( String [] args ) {
int i = 1; char c = ’A ’; short s = 2; long l = 20;
float f = 2.5; double d = 3.54;
System . out . println ( somme ( s , i )); // Appel de somme ( int , int )
System . out . println ( somme ( s , l )); // Appel de somme ( int , double )
System . out . println ( somme ( i , f )); // Appel de somme ( int , double )
System . out . println ( somme ( s , c )); // Appel de somme ( int , int )
System . out . println ( somme ( d , d )); /** erreur de conversion * */
}
}
POO en Java
Ambiguité de surcharge
Le compilateur peut ne pas savoir laquelle choisir.
Exemple
public class Overloading {
public static void m ( int i , char c )
{
System . out . println ( " m ( int , char ) " );
}
public static void m ( char c , int i )

{
System . out . println ( " m ( char , int ) " );
}
public static void main ( String [] args ) {

int i = 1;
char c = ’A ’;
m (i , c ); // m ( int , char )
m (c , i ); // m ( char , int )
m (c , c ); /** reference to m is ambiguous ,
both method m ( int , char ) and method m ( char , int ) match * */
}
}
POO en Java
Les membres statiques
Les membres statiques sont liés à la classe et non à une instance particulière
(un objet).
I Attributs: sa valeur n’est pas propre à un objet mais à la classe (l’attribut lui
même, et bien sûr sa valeur, est la même pour tous les objets de la classe).
On y accède à partir du nom de la classe ou de la référence à n’importe
quel objet de la classe.
I Méthodes: son code ne dépend pas d’un objet de la classe et peut être
exécuté même si aucun objet existe (e.g. main)
Les membres statiques sont déclarés avec le mot-clé static.
Tout code utilisé dans les membres statiques ne peut pas faire référence à
l’instance courante (this).

Poo Java PDF

Încărcat de

Informații document

Titlu original

Drepturi de autor

Formate disponibile

Partajați acest document

Partajați sau inserați document

Opțiuni de partajare

Vi se pare util acest document?

Este necorespunzător acest conținut?

Drepturi de autor:

Formate disponibile

Poo Java PDF

Încărcat de

Drepturi de autor:

Formate disponibile

La Programmation Orientée Objet

Programmation Orientée Objet en JAVA

Pr. Abdessamad EL BOUSHAKI

1 La Programmation Orientée Objet

La Programmation Orientée Objet

Aux origines de l’informatique

I Programme = Succession d’instructions

I Programmation en langage machine (Ex: l’assembleur).

Algorithmes + Structures de données = Programmes

Malgré ses avantages, l’approche procédurale présente également des

I Dans le langage structuré, les procédures s’appellent entre elles et peuvent

Méthodes + Données = Objets

Qu’est-ce que la POO?

C’est un style consiste à définir les différents acteurs (objets), leurs

Permet donc de découper les problèmes informatiques non en termes de

La POO permet une modélisation plus naturelle des systèmes considérés. et

Les avantages de la POO

Les fonctionnalités propres au style objet favorisent:

L’objectif est de produire du code:

Concepts généraux de la POO

Concepts généraux de la POO

C’est là qu’intervient la programmation orientée objet, fondée justement sur

Concepts généraux de la POO

Objet Etat Comportement

Concepts généraux de la POO

C’est une généralisation de la notion de type.

Une classe peut-être composite ⇔ peut contenir elle-même des objets

Concepts généraux de la POO

L’encapsulation consiste à masquer les détails d’implémentation d’un objet,

Concepts généraux de la POO

Concepts généraux de la POO

Concepts généraux de la POO

Le nom de polymorphisme vient du grec et signifie qui peut prendre plusieurs

La gestion du polymorphisme est assurée par la machine virtuelle

La syntaxe de déclaration d’une classe est la suivante :

modificateurs class nomClasse {

Les modificateurs de classe sont:

Remarque: Les attributs membres sont des variables déclarées à l’intérieur

private int maVitesse ;

La classe définit aussi les comportements des objets.

Signature d’une méthode:

Les modificateurs d’accès qui caractérisent l’encapsulation sont justifiées par

Un point d’un plan 2D est caractérisé par ses coordonnées x et y Supposant

La déclaration d’une instance d’une classe se fait de la façon:

nomClasse nomInstance ; // d é claration

l’operation de déclaration ne réserve pas d’emplacement pour un objet de

L’appel aux méthodes définies pour une instance de nom nomInstance se

nomInstance . nomMethode ( valParam1 ,...)

Le compilateur regarde le type déclaré de l’objet (ici nomInstance) et vérifie

un exemple complet d’une classe nommée TstPixel contenant (seulement)

Autoréférence : le mot clé this

Dans certaines conditions particulières, il est nécessaire de disposer d’un

Autoréférence : le mot clé this

Exemple d’utilisation d’autoréférence this

public void SetCoord ( int x , int y )

Un constructeur est une méthode particulière de la classe, qui sert à

Public nomClasse ( typeParam1 param1 ,...)

On peut surcharger les constructeurs, i.e définir de multiples constructeurs

Remarque : Si (au moins) un constructeur a été déclaré dans une classe, le

Public Pixel () // cr é e un pixel avec les coordonn é es à l ’ origine

Appel des constructeurs

public Pixel ( int x , int y )

// ************* ACCESSEURS *************

// * ACCESSEURS *