Poo PDF

Bases de la programmation orientée objet en Java
Jean-Baptiste Vioix
(jean-baptiste.vioix@iut-dijon.u-bourgogne.fr)
IUT de Dijon-Auxerre - LE2I
http://jb.vioix.free.fr 1-33
Avant propos
Difficultés. . .
La programmation orienté objet n’est pas forcement facile pour tout le monde.
C’est un ensemble de solutions (héritage, surcharge,. . . ) qu’il faut connaı̂tre avant de les
assembler.
Certaines notions vont sembleront abstraites dans un premier temps, admettez les. Avec le
temps, elles s’éclaireront d’elles mêmes (normalement).
N’hésitez pas à poser des questions au fur et à mesure du cours, et restez concentré ce
cours est extrêmement dense en nouvelles informations.
Ces éléments seront approfondis et détaillés en TD/TP, pensez à reprendre ce cours après
les séances.
UML
Dans ce cours des éléments d’UML seront présentés, ils permettent de matérialiser les
relations entre les différents éléments d’un programme.
L’approche retenue a été (un peu) simplifiée, le but de ce module n’est pas le génie logiciel.
Vous devez savoir comment passer d’un diagramme UML à du code Java (c’est un ensemble
de règles simples qu’un ordinateur est capable d’appliquer).
Avant propos
Difficultés. . .
assembler.
les séances.
UML
Avant propos
Difficultés. . .
assembler.
les séances.
UML
Avant propos
Difficultés. . .
assembler.
les séances.
UML
Avant propos
Difficultés. . .
assembler.
les séances.
UML
Avant propos
Difficultés. . .
assembler.
les séances.
UML
Avant propos
Difficultés. . .
assembler.
les séances.
UML
Avant propos
Difficultés. . .
assembler.
les séances.
UML
Classes et objets Introduction
Classes et objets
Première approche
Deux nombreux objets ont des caractéristiques communes que ce soit physique ou
fonctionnelles.
Ils ont souvent des “capacités” communes : un DVD peut être enregistré, un livre peut être lu,
une lampe allumé,. . .
Mais les mêmes objets d’une famille ne sont pas tous identiques : tous les DVD ne
contiennent pas le même film, tous les livres n’ont pas le même nombre de pages, toutes les
lampes n’ont pas la même puissance,. . .
Lien avec la POO

Dans le cadre de la POO, le DVD sera une classe et Matrix, Star Wars,. . . des objets de cette
classe (on parle aussi d’instance de cette classe).
La POO s’intéresse à la description de classe et à leurs interactions.
Les classes sont composées d’attributs (le titre du film, la puissance de la lampe) et de
méthodes (lire le film, allumer la lampe,. . . )
Classes et objets
Première approche
fonctionnelles.
Lien avec la POO

Classes et objets
Première approche
fonctionnelles.
Lien avec la POO

Classes et objets
Première approche
fonctionnelles.
Lien avec la POO

Classes et objets
Première approche
fonctionnelles.
Lien avec la POO

Classes et objets
Première approche
fonctionnelles.
Lien avec la POO

Classes et objets Attributs
Les attributs
Définition des attributs

A l’intérieur d’une classe, des variables définissent l’état d’un objet de cette classe (le titre de
ce film,. . . ).
Chaque instance (objet) de cette classe à un jeu d’attribut propre en mémoire (sauf
exception. . . ) indépendant des autres objets de cette classe.
Ce variables sont des attributs qui peuvent être des types primitifs (int,. . . ) ou des objets.
Ils sont déclarés comme les autres variables.
Les attributs

ce film,. . . ).
Les attributs

ce film,. . . ).
Les attributs

ce film,. . . ).
int nbPages ;
String Titre ;
Classes et objets Méthodes
Les méthodes (1)
Définition des méthodes

A l’intérieur d’une classe, des morceaux de code permettent d’interagir avec l’extérieur de la
classe : ce sont les méthodes
Elles peuvent aussi modifier les attributs de la classe.
Application à Java
Une méthode est composée de deux éléments : la déclaration (entête, signature,. . . ) et
l’implémentation (corps,. . . ).
Une méthode est déclarée par son type de retour, son nom et une liste d’arguments (qui peut
être vide).
la liste des arguments est entre parenthèse, les arguments sont déclarés exactement comme des
variable (type puis nom)
le type de retour peut être un type primitif, une classe ou void si la méthode ne renvoie rien.
Après la parenthèse fermante, on place le code de l’implémentation dans une paire
d’accolades.
Si la méthode renvoie quelque chose on doit impérativement trouver le mot return suivi
d’un élément du type correspondant à celui déclaré dans l’implémentation.
Les méthodes (1)

être vide).
d’accolades.
Les méthodes (1)

être vide).
d’accolades.
Les méthodes (1)

être vide).
d’accolades.
Les méthodes (1)

être vide).
d’accolades.
Les méthodes (1)

être vide).
d’accolades.
Les méthodes (1)

être vide).
d’accolades.
Les méthodes (1)

être vide).
d’accolades.
Les méthodes (1)

être vide).
d’accolades.
float MaMethode ( int unEntier , float unFlottant ) {

flottant produit =0;
produit = unEntier * unFlottant ;
return produit ;
}
Les méthodes (2)
Surcharge de méthodes
Une même méthode peut avoir plusieurs déclarations différentes dans la même classe.
Le nombre et le type des arguments (et du retour) peuvent librement varier sous réserve que
pour un même ensemble d’arguement (nombres et types) il n’y ait qu’une seule déclaration.
Le compilateur choisit la méthode à utiliser en fonction des arguments passés.
Exemple en Java
boolean Connecter ( String url ) {

...
}
boolean Connecter ( String url , int port ) {

...
}
Les méthodes (2)
Exemple en Java

...
}

...
}
Les méthodes (2)
Exemple en Java

...
}

...
}
Les méthodes (2)
Exemple en Java

...
}

...
}
Classes et objets Constructeurs
Le constructeur
Une méthode particulière : le constructeur

Toutes les classes ont une méthode qui porte le nom de la classe et qui n’a pas de type de
retour (même pas void) : le constructeur
Cette méthode est appelée quand on créé (instancie,. . . ) un nouvel objet de la classe
concernée.
Lors de la création, le constructeur est appelé, il a normalement en charge l’initialisation des
différents éléments.
Si aucun constructeur n’est défini, un constructeur par défaut (il est vide) est crée.
L’auto référence
A l’intérieur d’une classe il peut être nécessaire d’accéder à un attribut ou d’appeler une
méthode.
On utilise alors l’opérateur this suivi d’un point puis de l’attribut ou de la méthode
voulue :this.maMethode(unArgument)
Si il n’y a pas d’ambiguı̈té, on peut omettre this et utiliser simplement le nom de la méthode
ou le nom de l’attribut.
Le constructeur

concernée.
méthode.
Le constructeur

concernée.
méthode.
Le constructeur

concernée.
méthode.
Le constructeur

concernée.
méthode.
Le constructeur

concernée.
méthode.
Le constructeur

concernée.
méthode.
Le constructeur

concernée.
méthode.
Le constructeur

concernée.
méthode.
Le constructeur

concernée.
Livre () {
}
Livre( String unTitre ) {

this. titre = unTitre ;
}
Livre( String unAuteur , String unTitre ){

this. titre = unTitre ;
this. auteur = unAuteur
}
méthode.
Classes et objets Classes
Les classes
Représentation en UML
Une classe est représentée par une boite à trois compartiment :
le nom de la classe,
les attributs de la classe (sous la forme nom : type),
les méthodes de la classe (sous la forme Nom(type nom,...) : type de retour
Les types sont souvent écrit en langage usuel (caractère, flottant, entier,. . . ).
Une classe doit être stockée dans un fichier qui porte le même nom qu’elle (attention à la
casse) suivi de l’extension .java
Une classe est déclarée avec les mots clés public class suivie du nom de la classe, puis
de tous les éléments dans des accolades.
L’ordre de déclaration des éléments est sans importance, mais on place souvent les attributs
puis les méthodes.
Les classes
Les classes
Les classes
Les classes
Les classes
MaClasse
unAttribut : entier
UneMethode(entier unArgument)
Les classes
MaClasse
unAttribut : entier
UneMethode(entier unArgument)
Les classes
Les classes
Les classes
public class MaClasse {

...
int unAttribut ;
void UneMethode ( int unArgument ) {

...
}
}
Déclaration et construction
Déclaration
La déclaration sert à réserver de l’espace mémoire pour un futur objet.
Pour déclarer une variable qui va désigner un objet, on utilise la même notation que pour les
types primitifs : Classe nomVariable ;
La variable est alors initialisée à null
Construction
La construction d’un nouvel objet se fait avec l’opérateur new suivit du constructeur de la
classe et d’une liste (optionnelle) d’arguments entre parenthèses (éventuellement vides).
L’objet renvoyé par le constructeur est liée à la variable qui le référence à l’aide de l’opérateur
=
Référence
Les variables référencent un objet, elles ne sont pas l’objet.
Deux variables peuvent référencer le même objet, quand un objet n’a plus aucune référence
il est détruit.
Pour détruire une référence, on utilise la valeur null
Déclaration
Construction
=
Référence
il est détruit.
Déclaration
Livre monLivre;
Construction
=
Référence
il est détruit.
Déclaration
Construction
=
Référence
il est détruit.
Déclaration
Construction
=
Référence
il est détruit.
Déclaration
Construction
=
Référence
il est détruit.
Déclaration
Construction
=
Livre monLivre;
monLivre = new Livre(‘‘Orwell’’,‘‘1984’’);
Référence
il est détruit.
Déclaration
Construction
=
Référence
il est détruit.
Déclaration
Construction
=
Référence
il est détruit.
Déclaration
Construction
=
Référence
il est détruit.
Déclaration
Construction
=
Référence
il est détruit.
monLivre = null;
Accès aux éléments
Accès aux attributs d’un objet

Les attributs d’un objet sont désigné par le nom de la référence à cet objet suivit d’un point
suivit du nom de l’attribut.
Toutes les opérations usuelles sont ensuite possible (comme l’affectation).
Dans certains cas, on peut interdire l’accès direct aux attributs.
Accès aux méthodes d’un objet

La même notation est utilisée pour accéder aux méthode d’un objet.
Le nom de la méthode doit obligatoirement être suivit d’une paire de parenthèses contenant
les arguments (ou des parenthèses vides).
Cascade
Les accès peuvent être chainés :


Cascade


Cascade

Livre unLivre;
unLivre.nombreDePage = 542;

Cascade


Cascade


titre = unLivre.changeEmprunteur(‘‘Pierre’’);
Cascade


Cascade


Cascade
titre = unLivre.renvoieTitre().upCase();
Relations entre les classes Agrégation
L’agrégation (1)
Principe
Un attribut d’une classe peut être un objet instance d’une autre classe.
L’élément agrégé (l’objet) peut être partagé entre différents éléments.
Un élément agrégé peut exister indépendamment de son conteneur.
Représentation UML
1..* 1 Fichier
EditeurDeTexte Nom : chaine
unFichier : Fichier Ouvrir()
AfficherTexte() Fermer()
Principe
1..* 1 Fichier
Principe
1..* 1 Fichier
Principe
1..* 1 Fichier
Implémentation en Java
L’élément agrégé est référencé par un attribut dans le conteneur.
Selon la cardinalité (nombre d’éléments agrégés), on utilisera soit une variable simple soit un
tableau, une liste,. . .
public class public class Fichier {

EditeurDeTexte{
... String nom ;
Fichier unFichier ;
... void Ouvrir () {
void A f f i c h e r T e x t e () { ...
... }
}
... void Fermer () {
} ...
}
...
}
L’élément agrégé est référencé par un attribut dans le conteneur.
Selon la cardinalité (nombre d’éléments agrégés), on utilisera soit une variable simple soit un
tableau, une liste,. . .
public class public class Fichier {

EditeurDeTexte{
... String nom ;
Fichier unFichier ;
... void Ouvrir () {
void A f f i c h e r T e x t e () { ...
... }
}
... void Fermer () {
} ...
}
...
}
Relations entre les classes Composition
La composition (1)
Principe
La composition est proche de l’agrégation mais la relation est plus contraignante pour le
contenu.
La suppression du conteneur entraı̂ne la suppression du contenu
Un seul élément ne peut appartenir qu’à une seule composition.
Tableur 1 1..*
titreFeuille : chaine Cellule
cells[][] : Cellule valeur : flottant
La composition (1)
Principe
contenu.
Tableur 1 1..*
La composition (1)
Principe
contenu.
Tableur 1 1..*
La composition (2)
La solution la plus simple consiste à créer les éléments composés dans le constructeur du
conteneur.
La destruction du conteneur conduit à la destruction du contenu s’il n’y a pas d’autre
références (dans ce cas, ce n’est plus une composition !).
public class Tableur { public class Cellule {

... float valeur ;
Cellule cells [][]; ...
... }
void Tableur () {
// I n s t a n c i a t i o n des
cellules
}
...
}
La composition (2)
La solution la plus simple consiste à créer les éléments composés dans le constructeur du
conteneur.
La destruction du conteneur conduit à la destruction du contenu s’il n’y a pas d’autre
références (dans ce cas, ce n’est plus une composition !).
public class Tableur { public class Cellule {

... float valeur ;
Cellule cells [][]; ...
... }
void Tableur () {
// I n s t a n c i a t i o n des
cellules
}
...
}
Relations entre les classes Heritage
L’héritage (1)
Principe
Des classes ayant des fonctionnalités communes peuvent être construites en utilisant le
mécanisme d’héritage.
On peut spécialiser des classes à partir d’une classe générique.
L’héritage est représenté par une flèche à pointe triangulaire placée sur la classe mère.
InterfacesReseaux
port : byte
LireOctect()
EcrireOctet(byte b)
InterfaceTCP InterfaceUDP
LireOctect() LireOctect()
EcrireOctet(byte b) EcrireOctet(byte b)
L’héritage (1)
Principe
InterfacesReseaux
port : byte
LireOctect()
EcrireOctet(byte b)
L’héritage (1)
Principe
InterfacesReseaux
port : byte
LireOctect()
EcrireOctet(byte b)
L’héritage (2)
Interêt de l’héritage
Le code commun entre différentes classes est factorisé dans la classe mère, les
modifications se trouvent facilitées.
On peut construire une classe spécialisée à partir d’une classe existante sans connaı̂tre le
détail de la classe mère.
Conséquence de l’héritage
La classe fille contient toutes les méthodes et tous les attributs de la classe mère (même s’il
ne sont pas visibles).
Les instances de la classe fille (objets) sont aussi des instances de la classe mère,
l’opérateur instanceof renvoie true
La classe fille peut en plus contenir d’autres méthodes ou d’autres attributs ou redéfinir
ceux de la classe mère.
L’héritage (2)
L’héritage (2)
L’héritage (2)
L’héritage (2)
L’héritage (3)
Utilisation en Java
L’héritage est spécifié lors de la déclaration de la classe à l’aide du mot clé extends
La classe object
Toutes les classes qui n’héritent pas d’une autre classe héritent directement de la classe
object.
Toutes les classes héritent donc indirectement de la classe object.
Cette classe contient (entre autres) les méthodes : toString(), getClass() et finalize()
L’héritage (3)
Utilisation en Java
public class U n e C l a s s e F i l l e extends U n e C l a s s e M e r e {

...
}
La classe object
object.
L’héritage (3)
Utilisation en Java

...
}
La classe object
object.
L’héritage (3)
Utilisation en Java

...
}
La classe object
object.
L’héritage (4)
Redéfinition des méthodes

A l’intérieur d’une classe fille, une méthode implémentée dans la classe mère peut être
récrite : c’est la redéfinition (on utilise aussi le mot surcharge).
Dans ce cas, elle remplace la méthode de la classe mère pour les objet appartenant à la
classe fille.
Elle doit avoir le même nom, les même attributs (type et ordre) et le même type de retour que
Réutilisation du code existant

Dans une méthode redéfinie, il est possible d’appeler la méthode de la classe mère avec le
mot clef super() dans la première ligne de l’implémentation.
Cette approche est très souvent utilisée dans les constructeurs redéfinis ; on profite ainsi de
toutes les initialisations faites par la classe mère.
Il remplace exactement le nom de la méthode et peut donc être utilisé avec des arguments
d’appel.
L’héritage (4)

classe fille.

d’appel.
L’héritage (4)

classe fille.

d’appel.
L’héritage (4)

classe fille.

d’appel.
L’héritage (4)

classe fille.

d’appel.
L’héritage (4)

classe fille.

d’appel.
public class Mere {
void AfficheTexte ( String str ) {
System . out . println ( " La mere affiche " + str );
}
}
L’héritage (4)

classe fille.

d’appel.
public class Fille extends Mere{
void AfficheTexte ( String str ) {
super ( str );
System . out . println ( " La fille affiche "+ str ) ;
}
}
L’héritage (4)

classe fille.

d’appel.
...
Mere a= new Mere () ;
Fille b = new Fille () ;
a . afficheTexte (" Bonjour de A" );

b . afficheTexte (" Bonjour de B" );
...
L’héritage (4)

classe fille.

d’appel.
La mere affiche Bonjour de A
La mere affiche Bonjour de B
La fille affiche Bonjour de B
Relations entre les classes Classes et méthodes abstraites
L’héritage : les méthodes abstraites
Les méthodes abstraites

Une méthode abstraite est une méthode qui est déclarée (entête) mais qui n’est pas
implémentée (corps).
Il s’agit simplement de définir l’existence d’une méthode qui sera implémenté lors d’un
héritage.
Représentation UML et déclaration en Java

Dans le diagramme UML les éléments (classe ou méthode) abstraits sont notés en italique.
En Java, c’est le mot clé abstract qui permet de déclarer une méthode abstraite.
abstract float CalculerSurface () ;
Polygone
...
sommets[][] : Point
...
...
CalculerSurface() : flottant
...

héritage.

Polygone
...
sommets[][] : Point
...
...
...

héritage.

Polygone
...
sommets[][] : Point
...
...
...

héritage.

Polygone
...
sommets[][] : Point
...
...
...
L’héritage : les classes abstraites
Principe
Une classe abstraite ne peut pas être instanciée ; seules ses classes filles peuvent l’être.
Le but est de décrire un comportement général puis de le raffiner dans les classes filles.
Une classe qui contient une (ou plusieurs) méthode(s) abstraite(s) doit être déclarée
abstraite. Ce n’est pas réciproque, une classe abstraite peut avoir toutes ces méthodes
d’implémentées.

En Java, c’est le mot clé abstract qui permet de déclarer un élément abstrait.
public abstract class Polygone {

...
Polygone abstract float CalculerSurface () ;
... ...
sommets[][] : Point
... }
...
...
Principe


...
... ...
sommets[][] : Point
... }
...
...
Principe


...
... ...
sommets[][] : Point
... }
...
...
Principe


...
... ...
sommets[][] : Point
... }
...
...
Principe


...
... ...
sommets[][] : Point
... }
...
...
Relations entre les classes Interfaces
L’héritage : présentation des interfaces
Principe
Une classe fille pourrait hériter de plusieurs classes mères.
Java interdit l’héritage multiple (contrairement à d’autres langages).
A la place, on utilise les interfaces. Les interfaces sont une liste de méthodes (juste les
déclarations) que les classes implémentent.
Elles ne contiennent pas d’attributs.

Dans le diagramme UML les interfaces sont représentées comme des classes, le mot
interface apparaı̂t avant le nom.
En Java, on les déclare à l’aide du mot clef interface que l’on utilise “presque” comme
class
Le fichier Dessinable.java contient :
public interface Dessinable {
void DessinerFormeVide () ;
void DessinerFormePleine () ;
}
Interface Dessinable
DessinerFormePleine()
DessinerFormeVide()
Principe

class
}
DessinerFormeVide()
Principe

class
}
DessinerFormeVide()
Principe

class
}
DessinerFormeVide()
Principe

class
}
DessinerFormeVide()
Principe

class
}
DessinerFormeVide()
L’héritage : utilisation des interfaces
Les relations d’implémentation sont représenté par une ligne pointillée avec une flèche à
l’extrémité de l’interface.
Interface Imprimable Interface Enregistrable

Imprimer() Enregistrer(String nomDuFichier)
FichierTexte FichierBinaire
Nom : Chaine Nom : Chaine
Enregistrer(String nomDuFichier) Enregistrer(String nomDuFichier)
Imprimer() Executer()
Utilisation en Java
Le mot clé implements permet de construire la relation entre la classe et l’interface.
Une classe implémentant une interface doit avoir toutes les méthodes de cette interface.
Interface Imprimable Interface Enregistrable

Imprimer() Enregistrer(String nomDuFichier)
FichierTexte FichierBinaire
Nom : Chaine Nom : Chaine
Enregistrer(String nomDuFichier) Enregistrer(String nomDuFichier)
Imprimer() Executer()
Utilisation en Java
Utilisation en Java
Les fichiers Enregistrable.java et
Imprimable.java contiennent
public interface Imprimable {
void Imprimer () ;
}
public interface Enregistrable {

void Enregistrer ( String nomDuFichier ) ;
}
Utilisation en Java
Les fichiers Enregistrable.java et
Imprimable.java contiennent
public interface Imprimable {
void Imprimer () ;
}

}
Utilisation en Java
Les fichiers Enregistrable.java et Le fichier FichierTexte.java contient
Imprimable.java contiennent public FichierTexte implements
Imprimable , Enregistrable {
public interface Imprimable { String nom ;
void Imprimer () ;
}
void Imprimer () {
...
}
}
void Enregistrer ( String nomDuFichier ){
...
}
}
Utilisation en Java
Les fichiers Enregistrable.java et Le fichier FichierExecutable.java
Imprimable.java contiennent public FichierBinaire implements
Enregistrable {
public interface Imprimable { String nom ;
void Imprimer () ;
}
void Executer () {
...
}
}
void Enregistrer ( String nomDuFichier ){
...
}
}
L’héritage : classes abstraites ou interfaces
Comment choisir ?. . .
L’idée commune est de signifier la présence d’une méthode qui sera implémentée dans les
classes liées(filles ou implémentantes).
L’utilisation d’une classe abstraite impose une relation d’héritage entre les différentes
classes ; les interfaces n’imposent aucune relation d’héritage.
Les classes abstraites permettent d’avoir des attributs en commun contrairement aux
interfaces.
Une classe ne peut hériter que d’une seule classe abstraite alors qu’elle peut implémenter
plusieurs interfaces.
Intérêt
Les classes abstraites et les interfaces peuvent être utilisées à la place d’un type ou d’une
classe dans les arguments d’une méthode.
On ne connaı̂t pas exactement la classe mais on sait qu’elle implémente telle ou telle
méthode.
Elles sont très utilisées dans l’API graphique (Swing) de Java
interfaces.
Intérêt
méthode.
interfaces.
Intérêt
méthode.
interfaces.
Intérêt
méthode.
interfaces.
Intérêt
méthode.
interfaces.
Intérêt
méthode.
interfaces.
Intérêt
méthode.
void S a u v e r F i c h i e r ( E n r e g i s t r a b l e destinat io n ) {
...
destinati o n . Enregitre r () ;
...
}
interfaces.
Intérêt
méthode.
Relations entre les classes Interdire l’héritage
L’héritage : le modificateur final
Interdire l’héritage d’une classe

Pour interdire l’héritage d’une classe (créer des classes filles), on place le modificateur final
dans la déclaration.
Certaines classes (comme String) sont déclarées finales, souvent pour des raisons de
sécurité (instanceof. . . ).
Interdire l’héritage d’une méthode

Il est possible d’interdire l’héritage d’une méthode en la déclarant final.
La méthode ne peut plus être surchargée dans les classes filles.
Création d’une constante

Java ne connaı̂t pas de mot clef pour définir une constante.
Pour déclarer un attribut constant, on utilise la combinaison des mots clefs static et final




public final class C l a s s e F i n a l e {

...
}










public class UneClasse {

...
public final void U n e M e t h o d e F i n a l e () {
...
}
}










Extrait de la classe Math.java :
public static final double PI = 3 . 1 4 1 5 9 2 6 5 3 5 8 9 7 9 3 ;
Visibilité
La visibilité : l’encapsulation
Principe
Un des intérêts de la POO est de protéger au maximum le code présent dans une classe de
l’extérieur.
Pour chaque attribut ou méthode, il est possible de définir un degré de visibilité depuis
l’extérieur de la classe.
On peut, par exemple, avoir des méthodes qui ne peuvent être appelées que dans la classe
ou dans ses classes filles.
Il est possible ainsi de définir des attributs en lecture seule (ou écriture seule).
Règles usuelles
Les attributs (sauf nécessité) doivent être privés, des méthodes publiques assurant l’interface
avec l’extérieur : ce sont les assesseurs
Le ou les constructeurs doivent être déclarés publiques pour pouvoir être appelés depuis une
autre classe.
Les méthodes qui ne appelées qu’à l’intérieur de la classe doivent avoir une visibilité réduite.
Visibilité
Principe
l’extérieur.
Règles usuelles
autre classe.
Visibilité
Principe
l’extérieur.
Règles usuelles
autre classe.
Visibilité
Principe
l’extérieur.
Règles usuelles
autre classe.
Visibilité
Principe
l’extérieur.
Règles usuelles
autre classe.
Visibilité
Principe
l’extérieur.
Règles usuelles
autre classe.
Visibilité
Principe
l’extérieur.
Règles usuelles
autre classe.
Visibilité
La visibilité
Déclaration
La visibilité d’un élément (méthode ou attribut) est définie lors de la déclaration.
Quatre visibilités sont possibles pour les méthodes et les attributs.
On précède la déclaration d’un mot clé parmi :private, protected et public
Synthèse des différents modificateurs

``` Visibilité
```
Modificateur ``` Même classe Classe fille Même paquetage Autre cas
(Notation UML) ```
private (-) × − − −
protected (#) × × × −
Aucun (“friendly” ) () × − × −
public (+) × × × ×
Visibilité
La visibilité
Déclaration

``` Visibilité
```
(Notation UML) ```
private (-) × − − −
public (+) × × × ×
Visibilité
La visibilité
Déclaration

``` Visibilité
```
(Notation UML) ```
private (-) × − − −
public (+) × × × ×
Visibilité
La visibilité
Déclaration

``` Visibilité
```
(Notation UML) ```
private (-) × − − −
public (+) × × × ×
Visibilité
La visibilité
public class UneClasse {
private int unAttributPrive ;

protected float unAttributProtege ;
public String unAttributPublic ;
char unAttributFriendly ;
UneClasse
- unAttributPrive : entier private int UneMethodePrivee () {
# unAttributProtege : flottant
...
+ unAttributPublic : chaine }
unAttributFriendly : caractere
- UneMethodePrivee() : entier
protected void UneMethodeProtege ( int
# UneMethodeProtege(entier anInt) :
anInt ){
+ UneMethodePublique() :
...
UneMethodeFriendly() : Chaine
}
public void UneMethodePublique () {

...
}
String UneMethodeFriendly () {
...
}
Éléments statiques
Le modificateur static
Les méthodes statiques

Les méthodes statiques peuvent être appelées sans créer d’objet.
Elles sont appelées en utilisant le nom de la classe : b=Math.cos(a).
Elles peuvent toutefois être appelées depuis une instance de la classe.
Si elles font appel à d’autres méthodes (ou des attributs) de la classe, ils doivent aussi être
statiques.

Dans le diagramme UML les éléments statiques sont soulignés.
En Java, c’est le mot clé static qui permet de déclarer un élément statique.
public class Math {

...
Math
... public static double cos ( double angle) {
... ...
cos(double angle) :double }
...
...
}

statiques.

public class Math {

...
Math
... ...
...
...
}

statiques.

public class Math {

...
Math
... ...
...
...
}

statiques.

public class Math {

...
Math
... ...
...
...
}

statiques.

public class Math {

...
Math
... ...
...
...
}

statiques.

public class Math {

...
Math
... ...
...
...
}
Les attributs statiques

Les attributs statiques sont partagés par toutes les instances de la classe.
Les modifications se répercutent sur tous les objets.
Ils peuvent aussi être accédés directement avec le nom de la classe.
Exemple
public class ExempleStatic {
static int nb =0;
public ExempleStatic () {
nb ++;
}
public void AfficheNb () {

System . out . println ( " Nb vaut : "+ nb );
}
}

Exemple
static int nb =0;
nb ++;
}

}
}

Exemple
static int nb =0;
nb ++;
}

}
}

Exemple
static int nb =0;
nb ++;
}

}
}

Exemple
public class ExempleStatic { ...

public static void main( String [] args ) {
static int nb =0; ExempleStatic unElement , unDeuxiemeElement ;
unElement = new ExempleStatic () ;
public ExempleStatic () { unElement . AfficheNb () ;
nb ++; unDeuxiemeElement = new ExempleStatic () ;
} unDeuxiemeElement . AfficheNb () ;
unElement . AfficheNb () ;
public void AfficheNb () { System . out . println (" Nb vaut dans la classe : " +
System . out . println ( " Nb vaut : "+ nb ); ExempleStatic . nb ) ;
} }
} ...

Exemple
public class ExempleStatic { Nb vaut : 1

Nb vaut : 2
static int nb =0; Nb vaut : 2
Nb vaut dans la classe : 2
nb ++;
}

}
}
Éléments statiques Programme exécutable
Création d’un programme exécutable
Classe principale
Un programme Java est composé d’un ensemble de classes qui interagissent.
Une des classe sera le point d’entré du programme, pour cela elle doit contenir une méthode
particulière.
C’est cette méthode que la machine virtuelle (JVM) exécutera en premier.
La méthode main
Pour qu’un programme java soit exécutable, il doit contenir une méthode main.
Cette méthode doit être déclarée comme : public static void main(String[] args)
Les arguments (args) de la méthode représentent les arguments passés dans la ligne de
commande.
Classe principale
particulière.
La méthode main
commande.
Classe principale
particulière.
La méthode main
commande.
Classe principale
particulière.
La méthode main
commande.
Classe principale
particulière.
La méthode main
commande.
Classe principale
particulière.
La méthode main
commande.
D’UML à Java
Exemple de transformation UML/Java
Description du projet
On souhaite modéliser le stockage des données sur un disque dur.
Trois éléments coexistent : les fichiers, les répertoires et les raccourcis (ou liens).
Ces éléments sont tous stockés dans des répertoires.
Un raccourci désigne un fichier ou un répertoire.
D’UML à Java
On propose le schéma UML ci dessous (ne vous concentrez pas sur “l’efficacité” du
programme mais sur la manière d’écrire les classes et les interfaces en fonction du schéma
UML) :
FichierAbstrait
- nom : chaine Interface Designable
+ EcrireNom(chaine unNom) :
+ LireNom() : chaine + ConstruireLien(chaine unNom) : Lien
Repertoire
- listeFichiers[] : FichierAbstrait
Lien + ConstruireLien(chaine unNom) : Lien
- cible : Designable Fichier + AjouterFichier(FichierAbstrait unFichier) :
+ DetruireLien() : + DetruireFichier(FichierAbstrait unFichier) :
+ LireLien() : Designable + ConstruireLien(chaine unNom) : Lien + ListerFichier() : Designable
D’UML à Java
Ecriture du programme Java

Les différents éléments sont construit à partir du schéma UML.
D’UML à Java

public interface Designable {
public Lien ConstruireLien ( String unNom) ;
}
D’UML à Java

public abstract class FichierAbstrait {
private String nom ;
public void EcrireNom ( String unNom ) {

...
}
public String LireNom () {
...
}
}
D’UML à Java

public class Lien extends FichierAbstrait {
private Designable cible;
public void DetruireLien () {

...
}
public Designable LireLien () {
...
}
}
D’UML à Java

public class Fichier extends FichierAbstrait implements D esignable {
public Lien ConstruireLien ( String unNom) {

...
}
}
D’UML à Java

public class Repertoire extends FichierAbstrait implemen ts Designable {
private FichierAbstrait listeFichiers [];
public Lien ConstruireLien ( String unNom) {

...
}
public void AjouterFichier ( FichierAbstrait unFichier ) {

...
}
public void DetruireFichier ( FichierAbstrait unFichier ) {
...
}
public Designable ListerFichier () {
...
}
}

Poo PDF

Enviado por

Dados do documento

Título original

Direitos autorais

Formatos disponíveis

Compartilhar este documento

Compartilhar ou incorporar documento

Opções de compartilhamento

Você considera este documento útil?

Este conteúdo é inapropriado?

Direitos autorais:

Formatos disponíveis

Poo PDF

Enviado por

Direitos autorais:

Formatos disponíveis

Bases de la programmation orientée objet en Java

IUT de Dijon-Auxerre - LE2I

Lien avec la POO

Lien avec la POO

Lien avec la POO

Lien avec la POO

Lien avec la POO

Lien avec la POO

Définition des attributs

Définition des attributs

Définition des attributs

Définition des attributs

Les méthodes (1)

Définition des méthodes

Les méthodes (1)

Définition des méthodes

Les méthodes (1)

Définition des méthodes

Les méthodes (1)

Définition des méthodes

Les méthodes (1)

Définition des méthodes

Les méthodes (1)

Définition des méthodes

Les méthodes (1)

Définition des méthodes

Les méthodes (1)

Définition des méthodes

Les méthodes (1)

Définition des méthodes

float MaMethode ( int unEntier , float unFlottant ) {

Les méthodes (2)

boolean Connecter ( String url ) {

boolean Connecter ( String url , int port ) {

Les méthodes (2)

boolean Connecter ( String url ) {

boolean Connecter ( String url , int port ) {

Les méthodes (2)

boolean Connecter ( String url ) {

boolean Connecter ( String url , int port ) {

Les méthodes (2)

boolean Connecter ( String url ) {

boolean Connecter ( String url , int port ) {

Une méthode particulière : le constructeur

Une méthode particulière : le constructeur

Une méthode particulière : le constructeur

Une méthode particulière : le constructeur

Une méthode particulière : le constructeur

Une méthode particulière : le constructeur

Une méthode particulière : le constructeur

Une méthode particulière : le constructeur

Une méthode particulière : le constructeur

Une méthode particulière : le constructeur

Livre( String unTitre ) {

Livre( String unAuteur , String unTitre ){

public class MaClasse {

void UneMethode ( int unArgument ) {

Accès aux éléments

Accès aux attributs d’un objet

Accès aux méthodes d’un objet

Accès aux éléments

Accès aux attributs d’un objet

Accès aux méthodes d’un objet