Chapitre 1 : Notions de base sur les objets en

Java

I- Notion d’objet
Un objet est une entité du monde réel . On associe à
un objet une représentation informatique. On
distingue 2 types d’objets : les objets concrets qu’on
peut toucher du doigt (Personne, Livre, …) et les
objets abstraits (Compte bancaire, un Point, …). Un
objet possède les caractéristiques suivantes :
- Un ensemble de propriétés que l’on appelle des
attributs
- Un ensemble d’opérations que l’objet sait réaliser
ou que l ’on peut réaliser sur l’objet. Ces
opérations sont organisées en fonctions appelées
méthodes
- Un nom unique qui l’identifie dans un programme

Exemples :
Un point posséde comme attributs une abscisse x
et une ordonnée y. On peut définir une méthode
 translater(…) qui est une fonction qui permet de
déplacer un point quelconque .

Un compte bancaire peut posséder les attributs

suivants : un numéro, un libellé, un sens et un
solde. On peut définir les méthodes suivantes :
crediter(..), debiter(…), transferer(…) sur des
comptes bancaires .

II-Cycle de vie d’un objet

- Un objet doit d’abord être créé : créer un objet
consiste à définir les valeurs initiales de ses
attributs. Par exemple un point P1 est créé si on
fournit les valeurs de ses coordonnées x et y. Un
compte C1 est créé lorsqu’on fixe les valeurs du
numéro , du sens , du libellé et du solde.
- Après la création de l’objet , on fait appel aux
méthodes qui permettent d’exploiter l’objet. Par
exemple, on peut créditer ou débiter le compte
C1 ou translater le Point P1.
- Destruction de l’objet automatique à la fin de
l’application via l’outil logiciel ramasse-miettes
(garbage collector).
III-Notion de Classe
Les objets qui possèdent les mêmes attributs et
auxquels on peut appliquer les mêmes
opérations(méthodes) sont regroupés dans une
famille appelée Classe.
Tous les langages de programmations possèdent des
types prédéfinis : int , double, char, etc…
Lorsque l’utilisateur crée une classe, il crée alors un
nouveau type qui étend donc les types existants. Il lui
faut alors définir des variables de ce type appelées
instances d’objets.
Ainsi, on a les correspondances suivantes :
Programmation structurée Programmation objet

Types Classes
Variables instances d’objets
Fonctions Méthodes

Une classe est une structure de programmation

définie pour des objets issus d’une même famille et
dans laquelle on décrit :
- Leurs attributs communs
- Leurs méthodes communes
Soit une classe C quelconque, sa structure est ainsi
définie

public class C
{
//attributs et méthodes
}
Ce code sera stocké dans un fichier nommé C.java
Il faut noter que 2 objets issus d’une même famille
possèdent les mêmes attributs et mêmes méthodes
mais se différencient par leurs valeurs d’attributs et
les méthodes qu’ils réalisent à l’instant t.
Le nom d’une classe commence toujours par une
majuscule et chaque nouveau mot dans le nom
commence par une majuscule.

IV- Méthodes
Une méthode est une fonction qui réalise une
opération. Une méthode est toujours suivie de
parenthèses et peut être avec ou sans paramètres
(arguments)
Ex : méthode qui effectue la somme de 2 entiers
x et y

public int somme(int x , int y)

{
return x + y ;
}

On appelle prototype ou signature d’une

méthode le type de retour , le nom de la méthode
et ses paramétres.
Dans notre exemple , le type de retour est int
donc cette méthode retourne un entier. Le nom
de la méthode est somme et les paramètres sont
les entiers x et y.
Le corps de la méthode est constitué des
instructions dans le bloc { }. Notre méthode
possède une seule instruction return x+y ; donc
notre méthode renvoie la somme des 2 entiers x
et y.

En java, le nom d’une méthode commence par

une minuscule et chaque nouveau mot dans le
nom de la méthode commence par une
 majuscule. Contrairement aux attributs qui ont le
spécificateur private , les méthodes ont en
général le spécificateur public pour qu’elles
puissent être invoquées en dehors de leurs
classes. Lorsque le type de retour d’une méthode
est void , cette méthode ne renvoie aucun
résultat traite elle-même les résultats et les
affiche.
V- Notion d’encapsulation
Un objet doit être protégé lors qu’on y accède. Pour
pouvoir accéder aux valeurs des attributs en dehors
de la classe où ils sont définis , on doit utiliser des
méthodes. Ainsi pour accéder à la valeur d’un attribut
en dehors de sa classe de définition, on utilise une
méthode appelée accesseur ou getter. Pour fixer ou
modifier la valeur d’un attribut en dehors de sa classe
de définition, on utilise une méthode appelée
modificateur ou setter.
Pour mettre en œuvre cette protection, on utilise le
spécificateur private devant chaque attribut. Les
méthodes ont en général le spécificateur public pour
qu’elles puissent être invoquées en dehors de leur
classe.
En général, si une classe possède n attributs, on
définit alors n setters et n getters.
Les getters sont des méthodes sans paramètres dont
le nom commence par le mot get suivi du nom de
l’attribut avec la première lettre de l’attribut en
majuscule. Un getter a toujours comme type de retour
un type différent de void. Son type est celui du type
de l’attribut dont il retourne la valeur.
Les setters sont des méthodes avec paramètres dont
le nom commence par le mot set suivi du nom de
l’attribut avec la première lettre de l’attribut en
majuscule. Le paramètre d’un setter représente la
nouvelle valeur que doit prendre l’attribut. Les setters
ont toujours void comme type de retour.

Exemple : Supposons qu’on dispose d’une classe

Personne pour effectuer des opérations sur des objets
de type Personne. Une personne possède 2 attributs :
un nom et un prénom. Nous pouvons alors définir
cette classe comme suit :

public class Personne

{
private String nom ;
private String prenom ;

public String getNom()

{
return nom ;
}
public String getPrenom()
{
return prenom ;
}
public void setNom(String nom)
{
this.nom=nom ;
}
public void setPrenom(String prenom)
{

this.prenom=prenom ;
}
}
Nous constatons dans cet exemple que l’on a 2
attributs, 2 getters et 2 setters. On remarquera
l’utilisation du mot clé this au niveau d’un setter dû au
fait que l’attribut et le paramètre portent le même
nom. Ainsi pour les différencier, on met le mot this
devant l’attribut.
X-Notion de constructeur
Avant de pouvoir faire appel à un getter, un setter ou
autre méthode, on doit d’abord créer l’objet.
Créer un objet consiste à fixer les valeurs initiales de
ses attributs.
Cette opération se fait via une méthode spécifique de
la classe appelée un constructeur.
L’utilisateur doit spécifier au moins un ou plusieurs
constructeurs.
S’il n’en définit pas, le système propose un
constructeur par défaut qui crée des objets vides
c.a.d. des objets sans valeurs initiales des attributs. Il
faudra alors dans ce cas faire appel aux setters pour
fixer les valeurs initiales des attributs de l’objet.
L’utilisateur doit éviter le constructeur par défaut et
proposer son propre constructeur.
Le constructeur d’une classe C quelconque est une
méthode qui porte le même nom que la classe qui ne
possède pas de type de retour (même pas le type
void) et qui peut être avec ou sans paramètres. Si le
constructeur possède des arguments, ces derniers
représentent alors les valeurs initiales à fournir aux
arguments.
C’est pourquoi l’on dit que les objets sont créés à
partir de leurs classes ( rôle du constructeur). Les
objets sont alors des instances de leurs classes.
En général, la règle est la suivante :
Si une classe possède n attributs, le constructeur doit
alors posséder n arguments, un argument pour
initialiser chaque attribut.
Ainsi dans une classe , l’ordre de définition des
méthodes est le suivant :
- Définir un constructeur avec arguments
- Définir les getters et setters
- Définir les autres méthodes
Supposons que l’on dispose d’une classe Point pour
décrire les points dans un espace 2D. Chaque point
possède comme attributs l’abscisse x et l’ordonnée y
public class Point
{
private double x ;
private double y ;

//constructeur
public Point (double x , double y)
{
this.x=x ;
this.y=y ;
}
public double getX()
{
return x ;
}
public double getY()
{
return y ;
}
public void setX(double x)
{
this.x=x ;
}
public void setY(double y)
{
this.y=y ;
}

Analysons le constructeur
//constructeur
public Point (double x , double y)
{
this.x=x ;
this.y=y ;
}
Les paramètres x et y en arguments représentent les
valeurs initiales qu’il faut attribuer aux attributs x et
y. Cependant comme les arguments et les attributs
portent le même nom, on préfixe les attributs par le
mot this pour les différencier.

VI- Instructions de création d’objets

Les objets sont créés dans une classe autre que leur
classe de définition par exemple dans une classe
Application qui doit intégrer la méthode principale
main() qui est la première à être exécutée. En effet
une classe sans méthode main() peut être compilée
mais pas exécutée

Exemple : fichier Application.java

public class Application

{
public static void main(String [] args)
{
// instructions de création des objets
// instructions de manipulation des objets
}
}

Pour créer un point p1

Point p1 = new Point(2,5) ;
L’instruction new charge le constructeur de la classe
Point avec comme arguments les paramètres 2 et 5 à
fournir aux attributs x et y

Pour créer un point p2

Point p2 = new Point(8,-3) ;
L’instruction new charge le constructeur de la classe
Point avec comme arguments les paramètres 8 et -3 à
fournir aux attributs x et y
Pour obtenir l’abscisse du point p1, on donne
l’instruction
p1.getX() ;
Pour obtenir l’ordonnée du point p2, on donne
l’instruction
p2.getY() ;
Pour modifier l’abscisse du point p2 par 6,on donne
l’instruction
p2.setX(6) ;

VII- Autres méthodes que les constructeurs,

getters et setters
On peut trouver dans une classe d’autres méthodes :
-les méthodes générales : elles utilisent les valeurs des
attributs pour fournir de nouvelles informations qui
ne sont pas stockées en tant qu’attributs dans la
classe. En effet, les informations calculées ne doivent
pas être représentées comme attributs dans la classe.
Exemple : calcul de la norme d’un point dans une
classe Point à partir des attributs x et y
On peut alors définir une méthode norme() dans la
classe Point
public double norme()
{
return Math.sqrt(x*x+y*y) ;
}

-les modificateurs multiples qui peuvent modifier

plusieurs attributs à la fois
Exemple : une méthode translater(..) dans la classe
Point qui permet de déplacer un point de la classe
Point en modifiant les valeurs des attributs x et y

public void translater (double dx, double dy)

{
X =x+dx ;
Y=y+dy ;
}
XVI-Surchage de méthodes

En programmation structurée, une méthode a un

nom unique dans une application. En POO, on
peut définir plusieurs méthodes de même nom
mais elle doivent se différencier par le type et/ou
le nombre d’arguments . On parle de surchage de
méthodes. On peut surchager des constructeurs (
 définir plusieurs constructeurs ) ou des méthodes
simples

Ex :
public int somme (int x, int y)
{
return x+y ;
}
public double somme(double x, double y)
{
return x+y ;
}

VIII-Attributs d’instance, attributs statiques,

méthodes d’instance et méthodes statiques

Un attribut d’instance d’une classe est un attribut

dont la valeur change d’objet à objet
Exemple : le nom et le prénom d’une personne sont
des attributs d’instance car leurs valeurs varient de
personne à personne. Une méthode d’instance d’une
classe est une fonction dont le résultat change d’objet
à objet. Ainsi les getters, setters, les méthodes
norme() et translater() de la classe Point sont des
méthodes d’instance car le résultat de leur exécution
varie de point à point.
Les attributs d’instance et codes des méthodes
d’instance sont dupliqués en mémoire centrale
chaque fois qu’un objet est créé.
Un attribut statique statique au contraire n’est pas lié
à la nature de l’objet (indépendant de l’objet), n’est
pas dupliqué en mémoire chaque fois qu’un objet est
créé. Il représente une variable globale dont la valeur
est accessible par tous les objets. Pour accéder à la
valeur d’un attribut statique, on utilise une méthode
statique qui ne dépend pas des objets mais que de la
classe. Une méthode statique n’a pas accès
directement aux attributs de la classe mais peut
manipuler les objets de cette classe.
Une méthode d’instance nécessite la présence d’un
objet pour son exécution.
Son format d’appel est
nom_objet.methode_instance(…) ;
Une méthode statique ne dépend que de la classe
Son format d’appelle est C.methode_statique(…) où C
représente la classe où est définie la méthode
statique
Exemple : on veut compter le nombre de points créés
On dispose alors d’une classe Point (fichier Point.java)
qui est la suivante :
public class Point
{
private double x ;
private double y ;
private static int nombre=0 ;

//constructeur
public Point (double x , double y)
{
this.x=x ;
this.y=y ;
nombre++ ;
}
public double getX()
{
return x ;
}
public double getY()
{
return y ;
}

public void setX(double x)

{
this.x=x ;
}
public void setY(double y)
{
this.y=y ;
}
public static getNombre()
{
return nombre ;
}
}

La variable statique nombre n’est pas un attribut

naturel de la classe Point. Elle est utilisée pour
compter le nombre de points créés. Cette variable
existe en un seul exemplaire en mémoire et a été
initialisée à 0 contrairement aux attributs x et y qui
sont dupliqués en mémoire chaque fois qu’un objet de
type Point est créé. Dans le constructeur de la classe
Point, on incrémente nombre chaque fois qu’un point
est créé.
La variable statique nombre étant private , on a
besoin d’un accesseur qui est une méthode statique
qui ne peut qu’accéder qu’aux attributs statiques d’
une classe (pas aux attributs d’instance) nommée ici
getNombre() qui renvoie la valeur de la variable
statique
On peut alors après la classe Point, créer une classe
Application.java dont le contenu est le suivant :
public class Application
{
public static void main(String [] args)
{
Point p1 = new Point(3,4) ;
Point p2 = new Point(5,6) ;
System.out.println(‘’Nombre de points
créés :’’+Point.getNombre()) ;

}
}

Lorsqu’on invoque une méthode statique,elle est

précédée de sa classe contrairement aux méthodes
d’instance qui elle nécessitent un objet lors de leur
appel
Invocation de la méthode statique getNombre()
Point.getNombre() ;
Invocation d’une méthode d’instance par exemple
p1.getX() ou p2.getX()
La méthode getX() est une méthode d’instance car elle
opère sur un objet et donne des résultats différents
d’objet à objet
On peut même invoquer la méthode statique
getNombre() pas via sa classe uniquement mais via les
objets
p1.getNombre() sera égal à p2.getNombre() car la
variable statique a une valeur unique quelque soit
l’objet.

Voir les TP1 et TP2 sur les classes et objets pour

l’illus{
return x+y ;
}
tration des attributs statiques, d’instance et méthodes
statiques et d’instance

IX- Les collections

Les collections sont des objets semblables aux
tableaux mais avec une taille illimitée. Elles peuvent
stocker une très grande quantité d’objets d’une classe
C quelconque et nous évite ainsi de donner un nom à
chaque objet. La plus simple est la classe ArrayList de
la bibliothèque java.util.* ;
Pour créer une liste vide de type C, on donne
l’instruction
ArrayList<C> nom_liste = new ArrayList<C>() ;
On crée un objet x de C
C x = new C(…) ;
On ajoute l’objet x dans la liste par l’instruction
nom_liste.add(x) ;

Pour parcourir les objets de la liste et les traiter, on

met en œuvre la boucle suivante :
for (C k : liste)
{
// traitement de l’objet k
}
k est appelée une variable itérateur et prend à chaque
fois un objet de la liste la boucle est exécutée et ainsi
de suite jusqu’à la fin de la liste.