Cours Java

Programmation orientée objet

en Java

Faculté des Sciences de Gabès

LFSI 2- LARI 2
Les classes
Les classes
Une classe est constituée de:
Données : Ce qu’on appelle des attributs
Procédures et/ou des fonctions : Ce qu’on appelle des
méthodes
Une classe est un modèle de définition pour des objets
Ayant même structure (même ensemble d’attributs)
Ayant même comportement (même méthodes)
Ayant une sémantique commune
Les objets sont des représentations dynamiques (instanciation),
du modèle défini pour eux à travers la classe
Une classe permet d’instancier (créer) plusieurs objets
Chaque objet est instance d’une classe et une seule
Structure de classe
Une classe comporte sa déclaration, des variables et la définition de
ses méthodes.

Une classe se compose en deux parties : un en−tête et un corps

Le corps peut être divisé en 2 sections :

La déclaration des données et des constantes

La définition des méthodes.

Les méthodes et les données sont pourvues d'attributs de visibilité

qui gère leur accessibilité par les composants hors de la classe.

Pour accéder à une classe il faut en déclarer une instance de classe

ou objet.
Syntaxe

modificateurs class nomDeClasse [extends classeMere]

[implements interface]
{
// insérer ici les champs
modificateur dataType attribut1;
…
modificateur dataType attributN;
// insérer ici les méthodes
modificateur returnType nomMethode1 (paramètres)
{ //instructions …}
….
modificateur returnType nomMethodeM (paramètres)
{ //instructions …}
}
Modificateurs de classe

! !

! "
Mots clés
Les modificateurs abstract et final ainsi que public et private
sont mutuellement exclusifs

Le mot clé extends permet de spécifier une superclasse

éventuelle : ce mot clé permet de préciser la classe mère dans
une relation d'héritage.

Le mot clé implements permet de spécifier une ou des

interfaces que la classe implémente. Cela permet de récupérer
quelques avantages de l'héritage multiple.
Déclaration des attributs
Les attributs sont les données de la classe

Ils sont considérés comme des variables globales à l’intérieur

de la classe

Ils sont visibles par toutes les méthodes de la classe

Syntaxe:

[modificateurVisibilite] dataType nomAttribut [= expression];

Définition des méthodes
Une méthode est l’équivalent d’une procédure ou des fonctions
dans les autres langages.

Elle est composée d’une entête et d’un corps.

La signature d'une méthode comprend le type de retour, le nom de

la méthode et les types des paramètres.

Syntaxe:

[modificateurVisibilite] typeRetour nomAMethod ([ListeParamêtres])

{
// Déclaration des variables (locales)
// Instructions
}
Exemple
Les objets
#
$ #
! $ #
$ #

#
$ #
Les objets
Les objets contiennent des attributs et des méthodes.

La classe est la description d'un objet.

Un objet est une instance d’une seule classe :

Admet une valeur propre à l’objet pour chaque attribut
déclaré dans la classe
Les valeurs des attributs caractérisent l’état de l’objet
Il est possible de lui appliquer toute opération (méthode)
définie dans la classe
Tout objet est identifié et manipulé par sa référence
Utilisation de pointeur caché
On parle indifféremment d’instance, de référence ou d’objet
Structure d’un objet
Un objet est constitué de deux parties : une partie statique et une
autre dynamique
Partie statique
o Ne varie pas d’une instance de classe à une autre

o Permet d’activer l’objet

o Constituée des méthodes de la classe

Partie dynamique
o Varie d’une instance de classe à une autre

o Varie durant la vie d’un objet

o Constituée d’un exemplaire de chaque attribut de la classe

Cycle de vie d’un objet
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 :

La création: la déclaration de l'objet et l'instanciation grâce

à l'opérateur new

L’utilisation de l'objet en appelant ses méthodes

La destruction de l'objet : elle est automatique en Java

grâce à la machine virtuelle.
Création de l’objet
La création de l’objet se fait dans la classe extérieure à l’aide
de l’opérateur new qui se charge de:

Allouer l’espace mémoire pour stocker les attributs de l’objet

en cours de construction

Appeler le constructeur de l’objet adéquat pour initialiser

les attributs. Le choix du constructeur se base sur les
paramètres passés à l’opérateur new.

Retourner une référence sur l’objet crée.

Il est nécessaire de définir la déclaration d'une variable ayant le

type de l'objet désiré.
Déclaration et instanciation
L'opérateur new se charge de créer une instance de la classe
et de l'associer à la variable

Il est possible de déclarer et d’instancier un objet en une seule

instruction

Syntaxe:

nomClasse nomVariable;
nomVariable = new nomClasse([liste de paramètres]);

nomClasse nomVariable = new nomClasse([liste de paramètres]);

Constructeur (1/2)
Un constructeur est une méthode particulière d’initialisation d’un
objet

Un constructeur n’a pas de type de retour.

Son nom correspond obligatoirement au nom de la classe

Un constructeur est appelé au moment de la création de l’objet. Il

permet d’initialiser l’objet en fonction des paramètres fournis par
l’utilisateur.

Toute classe Java possède au moins un constructeur

Si une classe ne définit pas explicitement de constructeur, un

constructeur par défaut, sans arguments, et de code vide est
invoqué
Constructeur (2/2)
Une classe peut avoir plusieurs constructeurs qui diffèrent par
le nombre et le type de leurs paramètres

Il s’agit de surcharger les constructeurs d’une même classe

ce qui permet d’initialiser les objets de différentes manières

Lorsque l’un des constructeurs est appelé, c’est la liste des

arguments qui détermine lequel des constructeurs est appelé.

Remarque:

La surcharge peut être appliquée pour n’importe quelle

méthode et non seulement pour les constructeurs
Exemple
Création par affectation
On peut créer deux objets identiques par affetation.

Le signe = est l'opérateur d'affectation

x= y signifie que les deux objets x et y sont identiques et

toute modification de x entraîne celle de y

Ces deux objets contiennent la même référence et pointent

donc tous les deux sur le même objet : les modifications
faites à partir d'une des variables modifient l'objet.

Remarque: Pour créer une copie d'un objet, utiliser la méthode

clone() : cette méthode permet de créer un deuxième objet
indépendant mais identique à l'original.
Comparaison entre les objets
On peut comparer deux objets

Le signe == est l'opérateur de comparaison

x==y retourne vrai si les deux objets x et y sont identiques et

leurs références sont aussi identiques

Si les deux objets ne contiennent pas la même référence et

ne pointent donc pas tous les deux sur le même objet : alors
l’opérateur == retourne false

Pour comparer l'égalité des variables de deux instances, il faut

munir la classe d'une méthode à cet effet : la méthode equals
héritée de Object.
Exemple (1/2)
Exemple (2/2)
Destruction de l’objet
La plupart des langages orientés objets possèdent une méthode
nommée destructeur, appelée pour détruire un objet

La destruction d’un objet consiste à libérer les ressources qui lui ont été
déjà affectées par le constructeur.

Un objet est détruit (supprimé) lorsqu’il ne référence aucune zone

mémoire

En Java, la destruction des objets est prise en charge automatiquement

par un mécanisme appelé ramasse-miettes (Garbage Collector, GC)

Le GC fonctionne en arrière plan pendant l’exécution d’un programme

Java. Il est géré dans un thread de faible priorité.

Il est difficile de savoir à quel moment le GC détruit réellement l’objet

Destruction de l’objet (2/2)
La récupération de mémoire peut être aussi invoquée explicitement par
le programmeur à des moments bien précis avec la commande
System.gc()

Certaines situations nécessitent un nettoyage spécial que le GC ne peut

pas effectuer

Par exemple la fermeture des fichiers qui sont déjà ouverts lors de
manipulation d’un objet à détruire

Pour cela, une autre méthode spéciale, appelée finalize() peut être
définie

Cette méthode, si elle est présente, est appelée par le GC lorsque

l’objet est détruit pour assurer ce type de nettoyage spécial.
Utilisation de l’objet
%
%
%
Accès aux membres
Les membres sont accessibles via une instance de la classe ou
via la classe (pour les membres statiques)

On distingue quatre types d’accès aux membres d’une classe:

Accès à un attribut d’une instance

Invocation d’une méthode d’une instance

Accès à un attribut statique d’une classe

Invocation d’une méthode statique d’une classe

L’accessibilité est pondérée par des modificateurs de visibilité

(public, private,…)
Accès à un attribut
Pour accèder à un attribut à partir de l’intérieur de la classe,
l’accès se fait toujours à l’intérieur d’une méthode en indiquant
le nom de l’attribut qu’on souhaite y accèder.

Pour accèder à un attribut à partir de l’extérieur de la classe, il

faut d’abord créer un objet (instance), à partir de cette classe et
ensuite utiliser son nom suivi d’un point et le nom de l’attribut
que l’on souhaite y accèder

Syntaxe: Il s’agit d’utiliser la notation pointée

nomInstance.nomAttribut
Accès à une méthode
Pour accèder à une méthode à partir de l’intérieur de la classe,
l’accès se fait toujours à l’intérieur d’une méthode en précisant
le nom de la méthode ainsi que la liste de ses paramètres

Pour accèder à une méthode à partir de l’extérieur de la classe,

il faut d’abord créer un objet (instance), à partir de cette classe
et ensuite utiliser son nom suivi d’un point et du nom de la
méthode suivie de la liste de ses paramètres

Syntaxe: Il s’agit d’utiliser la notation pointée

nomInstance.nomMethode (param1, …,paramN)

Exemple: Accès interne
Exemple: Accès externe
Attributs statiques (de classe)
Un attribut de classe est un attribut marqué par le mot clé static

Ce dernier permet d’indiquer que cet attribut est commun à toutes

les instances de la classe concernée

Si on modifie cet attribut par une instance donnée, il sera modifié

pour toutes les autres instances.

Ce type de variable est utile pour par exemple compter le nombre

d'instanciation de la classe qui est faite.

On accède à un attribut statique:

Via une instance quelconque de la classe

A l’aide du nom de la classe

Exemple: Attribut statique
Attribut final
Le mot clé final utilisé pour un attribut permet de spécifier que
cet attribut est une constante

Un attribut final doit être obligatoirement initialisé lors de sa

déclaration.

On peut associer static à final pour un attribut constant et

commun pour toutes les instances.
Méthode statique
L’utilisation de la méthode statique ne nécessite pas la création
d’un objet appartenant à la classe correspondante .

Pour cette raison, une méthode statique ne peut accèder que

les attributs statiques de la classe.

Remarque:

La méthode main est une méthode statique, elle se lance

sans qu’aucune instance de la classe qui le contient
n’existe.
Exemple: Méthode statique

!
Références: this et null
Le mot clé this représente une référence sur l’objet courant.

La référence this peut être utilisée pour

Lorsqu’une variable locale ou paramètre cache un attribut de la
classe en portant le même nom ( this.attribut )
Pour déclencher un constructeur depuis un autre constructeur (
this (paramètres) )
Le mot clé null permet de représenter la référence qui référence rien.

Le fait d'initialiser une variable référant un objet à null permet au

ramasse miette de libérer la mémoire allouée à l'objet

On peut assigner l’objet null à n’importe quelle variable référence.

C’est la valeur par défaut d’initialisation d’un objet
Exemple: This
Les méthodes
Les méthodes
Les méthodes sont des fonctions qui implémentent les traitements de la
classe.

La valeur de retour de la méthode doit être transmise par l'instruction

return. Elle indique la valeur que prend la méthode et termine celle-ci:
toutes les instructions qui suivent return sont donc ignorées

Le type de retour d’une méthode peut être élémentaire ou correspondre

à un objet. Si la méthode ne retourne rien, alors on utilise void.

Le type et le nombre d'arguments déclarés doivent correspondre au type

et au nombre d'arguments transmis.

Il n'est pas possible d'indiquer des valeurs par défaut dans les
paramètres.
Les paramètres
Un paramètre d’une méthode peut être:
Une variable de type simple
Une référence d’un objet typé par n’importe quelle classe
En Java tout est passé par valeur
Les paramètres effectifs d’une méthode
La valeur de retour d’une méthode (si différente de « void »)
Les types simples
Leur valeur est recopiée
Leur modification dans la méthode n’entraîne pas celle de
l’original
Les objets
Leur référence est recopiée et non pas les attributs
Leur modification dans la méthode entraîne celle de l’original
Passage des paramètres
Les arguments sont passés par valeur : la méthode fait une copie de
la variable qui lui est locale.

Java transmet les arguments de type primitif par valeur ce qui signifie
que l’argument ne peut pas être modifié par la méthode appelée.

Lorsqu'un objet est transmis comme argument à une méthode, cette

dernière reçoit une référence qui désigne son emplacement mémoire
d'origine et qui est une copie de la variable .

Il est possible de modifier l'objet grâce à ces méthodes mais il n'est

pas possible de remplacer la référence contenue dans la variable
passée en paramètre : ce changement n'aura lieu que localement à
la méthode.
Exemple
Surcharge des méthodes
La surcharge d'une méthode permet de définir plusieurs fois une
même méthode avec des arguments différents.

Le compilateur choisit la méthode qui doit être appelée en fonction du

nombre et du type des arguments.

Une méthode est surchargée lorsqu'elle exécute des actions

différentes selon le type et le nombre de paramètres transmis.

Il est donc possible de donner le même nom à deux méthodes

différentes à condition que les signatures de ces deux méthodes
soient différentes.

Le type de retour des méthodes surchargées peut être différent mais

cette différence à elle même ne suffit pas
Exemple
Modificateurs de visibilité
Modificateurs de visibilité (1/3)
Ils se placent avant ou après le type de l'objet mais la
convention requiert qu'ils soient placés avant.

Ils s'appliquent aux classes, et/ou aux méthodes et/ou aux

attributs.

Ils ne peuvent pas être utilisés pour qualifier des variables

locales : seules les variables d'instances et de classes peuvent
en profiter.

Ils assurent le contrôle des conditions d'héritage, d'accès aux

éléments et de modification de données par les autres objets
Modificateurs de visibilité (2/3)
Il existe 3 modificateurs qui peuvent être utilisés pour définir les
attributs de visibilité des entités (classes, méthodes ou
attributs) : public, private, protected.

Leur utilisation permet de définir des niveaux de protection

différents (présentés dans un ordre croissant de niveau de
protection offert)

Ces modificateurs d'accès sont mutuellement exclusifs

Static est cumulable avec d’autres modificateurs

Sans modificateur de visibilité, un attribut ou une méthode est

appelée amie
Modificateurs de visibilité (3/3)

! !
#

# !

! !
&
' ! ( ! !
&
!
&
) !
! ! !
!
! !
! !
Modificateur de visibilité de 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)
static la méthode appartient simultanément à tous les objets 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

Sans modificateur, la méthode peut être appelée par toutes autres

méthodes des classes du package auquel appartient la classe.
Encapsulation (1/2)
L'encapsulation d’un objet par son interface permet de masquer son
contenu afin de sécuriser l'accès à ses données.

Les données sont généralement considérées comme privées. Elle

ne sont pas accessibles directement.

Les données déclarées private à l'intérieur d'une classe ne

peuvent être accédées et modifiées que par des méthodes
définies dans la même classe.

Ces méthodes constituent l’interface d’interaction avec un objet

de la classe. Les appels de ces méthodes sont appelés
"échanges de message".
Encapsulation (2/2)
Si une autre classe veut accéder aux données de la classe,
l'opération n'est possible que par l'intermédiaire d'une méthode de la
classe prévue à cet effet.

Pour respecter ce principe d’encapsulation, on ne doit intéragir avec

un objet que par l’invocation d’une de cas méthodes de son interface

Java propose plusieurs niveaux de visibilité (modificateur d’accès)

utilisable sur les données d’une classe pour assurer le principe
d’encapsulation
Les accesseurs
Un accesseur est une méthode publique qui donne l'accès à
une variable d'instance privée

Pour une variable d'instance, il peut ne pas y avoir d'accesseur,

un seul accesseur en lecture ou un accesseur en lecture et un
autre en écriture.

Par convention, les accesseurs en lecture commencent par get

et les accesseurs en écriture commencent par set.

On les appelle les getters et setters.

Pour un attribut de type booléen, il est possible de faire

commencer l'accesseur en lecture par is au lieu de get.
Exemple

$ $
! *
Modificateurs de visibilité (Résumé)
! " # $ % ! & ' # $ %
& &
& + &
+ +
! + +
& &
& + &
& + &
! + & + &
& &
& + &
& + &
! + & + &
Classes internes
Classes internes
Une classe interne est une classe définie à l’intérieur d’une
autre classe au même niveau qu’une méthode ou attribut.

Les classes internes sont visibles uniquement par les méthodes

de la classe dans lesquelles elles sont définies.

Elle a accès à tous les éléments de la classe qui les

enveloppent.
Syntaxe
(' ) *

, , , -
.
//
//
, , , , -
.
//
//
0
0
Exemple