Vous êtes sur la page 1sur 16

Programmation orientée objet

Chapitre 4 :
Construction des classes et instanciations des objets en
Java

1. Déclaration des classes en Java

La classe contient le modèle de construction d’un objet. La structure générale d’une classe en Java est la
suivante :

Modificateur class NomDeClasse


{
Attributs 1 ;
Attribut 2 ;
...
constructeur1()
constructeur2()
...
méthode1()
méthode2()
...
}

Exemple

Public class Etudiant {

…..
}

Les modificateurs de classe (ClassModifiers) sont :

- public La classe est accessible partout


- private la classe n'est accessible qu'à partir du fichier où elle est définie
- final La classe ne peut pas être modifiée, sa redéfinition grâce à l'héritage est interdite. Les
classes déclarées final ne peuvent donc pas avoir de classes filles.
- abstract La classe contient une ou des méthodes abstraites, qui n'ont pas de définition
explicite. Une classe déclarée abstract ne peut pas être instanciée : il faut définir une classe qui
hérite de cette classe et qui implémente les méthodes nécessaires pour ne plus être abstraite.

Les modificateurs abstract et final ainsi que public et private sont mutuellement exclusifs ( on ne
peut spécifier qu’un seul modificateur) .

15
Chiheb-Eddine Ben N’Cir
Programmation orientée objet

Une classe est dite « Exécutable » si elle contient une méthode « public static void main(String
Args[]) ».

Les classes non-exécutables peuvent être instanciables ou non-instaciables.

Les classes non-instanciables doivent être précédées par le modificateur « abstract ». Ces classes ne
possèdent pas une définition complète pour être instanciées..

1.1. Les attributs

Les données d'une classe sont contenues dans attributs. Les attributs sont les propriétés d’une classe,
ils sont tous visibles à l’intérieur de la classe. Les attributs sont donc des variables relatives à une
instance (d’une classe) et qui sont accessibles dans toute la classe. La syntaxe générale de déclaration
des attributs sont : ( Les Champs entre « [ ] » sont optionnels)

[< modificateur de visibilité>] <type> <nom_attribut> [=<expression>] ;

Exemple

class Etudiant
{ private String Nom ;
protected String adresse;
protected String Prenom ;
final double Pi=3.14;
}

Remarques

- Les modificateurs de visibilité pour les attributs sont : « public », « private » et « protected ». On
peut aussi utiliser le modificateur « Final » si l’attributs est une constante.

- Les types des attributs peuvent être des type primitif (int, double, …) ou bien des type références
(object, …)

1.2. Les méthodes

Pour écrire un programme avec un langage orienté-objet, le programmeur écrit uniquement des classes
correspondant aux objets de son système. Les traitements à effectuer sont programmés dans les
méthodes de ces classes qui peuvent faire appel à des méthodes d’autres classes.

La syntaxe générale de déclaration d’une méthode est la suivante :

16
Chiheb-Eddine Ben N’Cir
Programmation orientée objet

modificateurs type_retourné nom_méthode ( arg1, ... ) {

...

// Définition des variables locales et du bloc d'instructions


// Les instructions
}

Les modificateurs de méthodes sont :

- 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)

Le type retourné peut être élémentaire (primitif) ou correspondre à un objet. Si la méthode ne retourne
rien, alors on utilise « void ». Il n'est pas possible d'indiquer des valeurs par défaut dans les
paramètres.

Les arguments sont passés par valeur : la méthode fait une copie de la variable qui lui est locale.
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.

Lorsqu'un objet est passé en paramètre, ce n'est pas l'objet lui même qui est passé mais une référence
sur l'objet. La référence est bien transmise par valeur et ne peut pas être modifiée mais l'objet peut être
modifié via un message (appel d'une méthode).

Pour transmettre des arguments par référence à une méthode, il faut les encapsuler dans un objet qui
prévoit les méthodes nécessaires pour les mises à jour.

Exemple de déclaration de méthodes :

17
Chiheb-Eddine Ben N’Cir
Programmation orientée objet

Public class Etudiant


{ private String Nom ;
private String adresse;
private String Prenom ;

//définition de la méthode afficherEtudiant qui permet d’afficher les données d’un étudiant

public void AfficherEtudiant()


{
System.out.println("le Nom de l'etudiant est:"+Nom);
System.out.println("le prenom de l'etudiant est:"+Prenom);
System.out.println("l'adresse de l'etudiant est:"+Adresse);
System.out.println("le CIN de l'etudiant est:"+CIN);
}

Remarques

- Toutes les méthodes sauf les «constructeurs » doivent avoir un type de retour.

- Les méthodes qui ne renvoient rien, utilisent « void » comme type de retour.

- Une méthode peut ne pas avoir besoin d’arguments, ni de variables à déclarer.

- Les méthodes agissent sur les attributs définis à l’intérieur de la classe.

- Sans modificateur, la méthode peut être appelée par toutes autres méthodes des classes du package
auquel appartient 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.

1.3. Les constructeurs

La déclaration d'un objet est suivie d'une sorte d'initialisation par le moyen d'une méthode particulière
appelée constructeur pour que les variables aient une valeur de départ. Elle n'est systématiquement
invoquée que lors de la création d'un objet.

Le constructeur suit la définition des autres méthodes excepté que son nom doit obligatoirement
correspondre à celui de la classe et qu'il n'est pas typé, pas même void, donc il ne peut pas y avoir
d'instruction return dans un constructeur. On peut définir plusieurs constructeurs pour une classe
(surcharge). La définition d'un constructeur est facultative. Si aucun constructeur n'est explicitement

18
Chiheb-Eddine Ben N’Cir
Programmation orientée objet

défini dans la classe, le compilateur va créer un constructeur par défaut sans argument. Dès qu'un
constructeur est explicitement défini, le compilateur considère que le programmeur prend en charge la
création des constructeurs et que le mécanisme par défaut, qui correspond à un constructeur sans
paramètres, n'est pas mis en oeuvre.
Si on souhaite maintenir ce mécanisme, il faut définir explicitement un constructeur sans paramètres
en plus des autres constructeurs.

Il existe plusieurs manières de définir un constructeur :


1) le constructeur simple : ce type de constructeur ne nécessite pas de définition explicite : son
existence découle automatiquement de la définition de la classe.

public class Etudiant{


…..

public Etudiant() { }

2) le constructeur avec initialisation fixe : il permet de créer un constructeur par défaut

public class Etudiant{


private String Nom;

public Etudiant() {
Nom= “aymen” ;
}
}

3) le constructeur avec initialisation des variables : pour spécifier les valeurs de données à
initialiser on peut les passer en paramètres au constructeur

public class Etudiant{


private String Nom;
….
public Etudiant(String N1 ) {
Nom= N1 ;
}
}

Remarques :

Les objets déclarés en mémoire centrale ne peuvent pas être supprimé manuellement (pour libérer la
mémoire). C’est le Garbage Collector qui gère automatiquement l’espace mémoire. Les objets qui ne
sont plus référencés seront supprimés automatiquement.

19
Chiheb-Eddine Ben N’Cir
Programmation orientée objet

1.4. Les accesseurs

L'encapsulation permet de sécuriser l'accès aux données d'une classe. Ainsi, 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.

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. Ces appels de méthodes sont appelés «
échanges de message ».

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 ».

public class Etudiant{


private String Nom;
….
public Etudiant( ) { }

public String getNom(){


return Nom ;}

public void setNom(String N1){


Nom=N1;
}

2. Instanciation des objets en Java

En Java, une application est un ensemble d’objets en interactions. Les objets sont des instanciations
des classes. Chaque objet est construit à partir d’un modèle (une classe). La classe est donc la
description d'un objet. Pour chaque instance d'une classe, le code est le même, seules les données sont
différentes à chaque objet.

20
Chiheb-Eddine Ben N’Cir
Programmation orientée objet

2.1. La création d'un objet : instancier une classe

Il est nécessaire de définir la déclaration d'une variable ayant le type de l'objet désiré. La déclaration
est de la forme

nom_de_classe nom_de_variable ;

Exemple :

public static void main(String args[]) {

//déclaration des objets

Etudiant E1;
Etudiant3 E2;

//Instanciation des objets

E1=new Etudiant() ;
E2=new Etudiant3() ;

//declaration et instanciations des objets

Etudiant3 E3= new Etudiant3() ;

L'opérateur new se charge de créer une instance de la classe et de l'associer à la variable. Il est possible
de tout réunir en une seule déclaration (comme pour l’objet E3).

Chaque instance d'une classe nécessite sa propre variable. Plusieurs variables peuvent désigner un
même objet. En Java, tous les objets sont instanciés par allocation dynamique. Dans l'exemple, la
variable E1 contient une référence sur l'objet instancié (contient l'adresse de l'objet qu'elle désigne :
attention toutefois, il n'est pas possible de manipuler ou d'effectuer des opérations directement sur
cette adresse comme en C).

Si E2 désigne un objet de type Etudiant, l'instruction « E2 = E1 » ne définit pas un nouvel objet mais
E1 et E2 désignent tous les deux le même objet.

L'opérateur new permet d'instancier des objets et d'appeler une méthode particulière de cet objet : le
constructeur. Il fait appel à la machine virtuelle pour obtenir l'espace mémoire nécessaire à la
représentation de l'objet puis appelle le constructeur pour initialiser l'objet dans l'emplacement obtenu.
Il renvoie une valeur qui référence l'objet instancié. Si l'opérateur new n'obtient pas l'allocation
mémoire nécessaire, il lève l'exception OutOfMemoryError.

21
Chiheb-Eddine Ben N’Cir
Programmation orientée 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 :

1. la déclaration de l'objet et l'instanciation grâce à l'opérateur new


2. l'utilisation de l'objet en appelant ces méthodes
3. la suppression de l'objet : elle est automatique en Java grâce à la machine virtuelle. La
restitution de la mémoire inutilisée est prise en charge par le récupérateur de mémoire
(garbage collector). Il n'existe pas d'instruction « delete » comme en C++.

2.2. Appel des attributs et des méthodes à partir des objets

L’échange des données entre les objets (les messages) est réalisé à travers l’exécution des méthodes de
chaque objet ou bien à travers l’accès à ses attributs. Pour accéder à la valeur d’un attribut d’un objet,
il faut utiliser le modèle de construction de l’objet (la classe) en utilisant la syntaxe suivante :
« Objet. nom_attribut ». Cette opération n’est autorisée sauf si l’attribut est déclaré « Public ».
Exemple : (supposant que l’attribut Nom de la classe Etudiant est déclaré public)

public class principal


{
…..
public static void main(String []args) {
E1= new Etudiant() ;
//On donne une valeur à l’attribut Nom
E1.Nom=”Ahmed” ;

//On récupère le prenom de l’étudiant E1 dans la variabe locale Prenom déclarée dans la
//méthode main.
String Prenom= E1.Prenom;
}
…..
}
Exemple2 : ( les attributs Nom et Prenom de la classe Etudiant sont déclarés private)
public class principal
{
…..
public static void main(String []args) {
E1= new Etudiant() ;
//On donne une valeur à l’attribut Nom
E1.setNom(”Ahmed”) ;

//On récupère le prenom de l’étudiant E1 dans la variabe locale Prenom déclarée dans la
//méthode main.
String Prenom= E1.getPrenom();
}
…..
}

22
Chiheb-Eddine Ben N’Cir
Programmation orientée objet

Concernant l’appel des méthodes, il est réalisé de la même façon que pour les attributs.
Après la création d’un objet, l’appel des méthodes est effectué selon la syntaxe
suivante «Objet.NomMethodes(arg1, arg2,…) ». Si la méthode retourne un résultat, il faut
que la variable déclarée soit de même type. Il est à remarquer aussi que le nombre des
arguments doit correspondre à la définition de la méthode dans la classe correspondante. Si
la méthode ne contient aucun argument, les parenthèses sont maintenues à vide.
« Objet.NomMethodes()».
Exemple 1
public class Etudiant3
{
…..
//Méthode calcul moyenne dans Etudiants 3

public double CaulculMoyenne(double x1, double x2)


{
Double moy=((x1*2)+ x2 ) / 3 ;
return moy ;
}
……..
}

public class principal


{
…..
public static void main(String []args) {

E1= new Etudiant3() ;


double note1=12.45 ;
double notePFE=13 ;

//On affecte le calcule de la moyenne à la variable locale x déclarée dans la méthode main.
Double x= E1.calculMoyenne(note1,notePFE)
}
…..
}
Exemple 2 (on suppose que les attributs de l’étudiants3 (note1 et notePFE sont
appelés en local dans de la fonction calculMoyenne() ).

public class Etudiant3


{
…..
//Attribut de Etudiants 3

public double Note1 ;


public double NotePFE

//Méthode calcul moyenne dans Etudiants 3

public double CaulculMoyenne()

23
Chiheb-Eddine Ben N’Cir
Programmation orientée objet

Double moy=((Note1*2)+ notePFE ) / 3 ;


return moy ;

}
……..

public class principal


{
…..
public static void main(String []args) {

E1= new Etudiant3() ;

E1.Note1=12.45 ;
E1.NotePFE=13 ;

//On affecte le calcule de la moyenne à la variable locale x déclarée dans la méthode main.

Double x= E1.calculMoyenne() ;

}
…..
}

Exemple 3 (on suppose que les attributs privés de l’étudiants3 (note1 et notePFE sont
appelés en local dans de la fonction calculMoyenne() et que ses ).

public class Etudiant3


{
…..
//Attribut de Etudiants 3

private double Note1 ;


private double NotePFE

//Méthode calcul moyenne dans Etudiants 3

public double CaulculMoyenne()


{

24
Chiheb-Eddine Ben N’Cir
Programmation orientée objet

Double moy=((Note1*2)+ notePFE ) / 3 ;


return moy ;

}
……..

public class principal


{
…..
public static void main(String []args) {

E1= new Etudiant3() ;

E1.setNote1(12.45) ;
E1.setNotePFE(13) ;

//On affecte le calcul de la moyenne à la variable locale x déclarée dans la méthode main.

Double x= E1.calculMoyenne() ;

}
…..
}

2.3. La comparaison des objets

Pour créer des objets identiques il faut utiliser la méthode « clone() » qui est héritée de la classe
« Object » qui est la classe mère de toutes les classes crées en Java. L’opérateur « = » ne permet pas
des créer des objets identiques. Il permet seulement de créer des références identiques pointant sur le
même objet.

Exemple 1 :

Etudiant E1 = new Etudiant ();


Etudiant E2 = E1;

if (E1 == E2) { ... } // vrai


Exemple2 :

Etudiant E1 = new Etudiant ();


Etudiant E2 = E1.clone ();
if (E1 == E2) { ... } // faux

25
Chiheb-Eddine Ben N’Cir
Programmation orientée objet

Dans le premier exemple E1 et E2 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 en question.
L'opérateur « == » compare ces références. E1 et E2 sont donc egaux.

Dans le deuxième exemple, une copie de l’objet E1 est créée en la référençant par E2 à travers
l’utilisation de la méthode clone(). Cette méthode permet de créer un deuxième objet indépendant
mais identique à l'original. L'opérateur « == » compare ces références. E1 et E2 donc porte des
propriétés identiques mais sont deux objets distincts (E1==E2) est faux :

Pour comparer l'égalité des variables de deux instances (objets), il faut munir la classe d'une méthode à
cet effet : la méthode equals() héritée de Object.

Exemple

Etudiant E1 = new Etudiant ();


Etudiant E2 = E1.clone ();
if (E1 == E2) { ... } // faux
E1.equals(E2) // vrai

Etudiant E1 = new Etudiant ();


Etudiant E2 = E1;

if (E1 == E2) { ... } // vrai


E1.equals(E2) // vrai

Pour s'assurer que deux objets sont de la même classe, il faut utiliser la méthode getClass() de la
classe Object dont toutes les classes héritent.
Exemple

(E1.getClass().equals(E2.getClass())

3. Les mots clefs et les méthodes spécifiques (relatives aux


méthodes et classes)

3.1. Le mot clé « final »


Le mot clé final s'applique aux variables, aux méthodes et aux classes. Une variable qualifiée de final
signifie que la variable est constante. Une variable déclarée final ne peut etre initialisée qu’une seule
fois. On ne peut déclarer de variables final locales à une méthode. Les constantes sont généralement
qualifiées de final et static.

Exemple :

26
Chiheb-Eddine Ben N’Cir
Programmation orientée objet

public class exemple{

public static final double PI = 3.1416;

…….
}

Ou bien

public class exemple{

public static final double PI;

public exemple(){

PI=3.1416;
}

…….
}

Une méthode final ne peut pas être redéfinie dans une sous classe. Une méthode possédant le
modificateur final pourra être optimisée par le compilateur car il est garanti qu'elle ne sera pas sous
classée.
Lorsque le modificateur final est ajouté à une classe, il est interdit de créer une classe qui en hérite.
Il existe 2 types d’utilisations des attributs finaux : ou bien on initialise la valeur de la variable dés la
déclaration, ou bien on initialise plus tard cette variable et son contenu ne sera jamais modifiée.

3.2. Le mot clefs « this »


Le mot clef « this » (considéré comme variable) sert à référencer dans une méthode l'instance de
l'objet en cours d'utilisation. « this » est un objet qui est égale à l'instance de l'objet dans lequel il est
utilisé.

La référence « this » peut être utile lorsqu’une variable locale (ou un paramètre) cache, en portant le
même nom, un attribut de la classe.

This est aussi utilisé quand l'objet doit appeler une méthode en se passant lui même en paramètre de
l'appel.

public class Etudiant{


private String Nom;
private String Prenom;
private String Adresse;
private String CIN;

….
public Etudiant(String Nom, String Prenom, String Adresse, String CIN ) {
this.Nom= Nom ;

27
Chiheb-Eddine Ben N’Cir
Programmation orientée objet

this.Prenom=Prenom;
this.Adresse=Adresse;
this.CIN=CIN;
}
}

3.3. Le mot clefs « static »


Le mot clé static s'applique aux variables et aux méthodes. Les variables d'instance sont des
variables propres à un objet. Il est possible de définir une variable de classe qui est partagée entre
toutes les instances d'une même classe : elle n'existe donc qu'une seule fois en mémoire. Une telle
variable permet de stocker une constante ou une valeur modifiée tour à tour par les instances de la
classe. Elle se définit avec le mot clé « static ».

Une méthode static est une méthode qui n'agit pas sur des variables d'instance mais uniquement sur
des variables de classe. Ces méthodes peuvent être utilisées sans instancier un objet de la classe. Les
méthodes ainsi définies peuvent être appelées avec la notation « classe.methode() » au lieu de
« objet.methode() » : la première forme est fortement recommandée pour éviter toute confusion.

Un exemple d’utilisation des variables « static » est le compteur d’instanciation d’objets d’une classe.

public class Etudiant{


private String Nom;
private String Prenom;
private String Adresse;
private String CIN;
Static int compteur=0;

….
public Etudiant(String Nom, String Prenom, String Adresse, String CIN ) {
this.Nom= Nom ;
this.Prenom=Prenom;
this.Adresse=Adresse;
this.CIN=CIN;
Compteur=compteur+1;
}
}

public class principal{

public static void main (String args[]) {

Etudiant O1=new Etudiant(“ben ahmed”,”aymen”,”esen”, “111111”);


Etudiant O2=new Etudiant(“ben Amor”,”mohamed”,”manouba”, “222”);

System.out.println(“le nombre d’etudiant est”+ Etudiant.compteur) ; //le système affiche 2


System.out.println(“le nombre d’etudiant est”+ O1.compteur) ; //le système affiche 2
System.out.println(“le nombre d’etudiant est”+ O2.compteur) ; //le système affiche 2

}
}

28
Chiheb-Eddine Ben N’Cir
Programmation orientée objet

3.4. Le mot clefs « instanceof »

Le mot clef « instanceof » est un opérateur qui permet de déterminer la classe de l'objet qui lui est
passé en paramètre. La syntaxe est : « objet instanceof classe »

Exemple :

public class principal{

public static void main (String args[]) {

Etudiant O1=new Etudiant(“ben ahmed”,”aymen”,”esen”, “111111”);

If(O1 instanceof Etudiant) { System.out.println(“c’est un objet de la classe Etudiant ‘’)}


else
{ system.out.println(“c’est un objet qui n’est pas de la classe Etudiant ‘’) }

//le système affiche un objet de la classe Etudiant puisque O1 est instancié de la classe
etudiant

}
}

3.5. Le mot clefs « null »


Le mot clef « NULL », qui référence un objet null, est utilisable dans les classes et les méthodes. Il
n'appartient pas à une classe mais il peut être utilisé à la place d'un objet de n'importe quelle classe ou
comme paramètre. « null » ne peut pas être utilisé comme un objet normal : il n'y a pas d'appel de
méthodes et aucune classe ne peut en hériter.

Le fait d'initialiser une variable référant un objet à null permet au « Garbge Collector » de libérer la
mémoire allouée à l'objet.

4. La 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 choisi la méthode qui doit être appelée en fonction du nombre et du type des
arguments. Ceci permet de simplifier l'interface des classes vis à vis des autres classes.

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. La signature d'une méthode
comprend le nom de la classe, le nom de la méthode et les types des paramètres.

Exemple de surcharge de constructeur et de la méthode afficherEtudiant() :

29
Chiheb-Eddine Ben N’Cir
Programmation orientée objet

public class Etudiant{


private String Nom;
private String Prenom;
private String Adresse;
private String CIN;
Static int compteur=0;

….
public Etudiant(String Nom, String Prenom, String Adresse, String CIN ) {
this.Nom= Nom ;
this.Prenom=Prenom;
this.Adresse=Adresse;
this.CIN=CIN;
Compteur=compteur+1;
}

public Etudiant() {

Compteur=compteur+1;
}

Public void afficherEtudiant() { …. System.out.println(“ méthode 1 “) ;}


Public void afficherEtudiant(String S1) { …. System.out.println(“ méthode 2 “) ;}

public class principal{

public static void main (String args[]) {

Etudiant O1=new Etudiant(“ben ahmed”,”aymen”,”esen”, “111111”); // appel du premier


constructeur
Etudiant O2=new Etudiant(); // appel du deuxième constructeur
O1.afficherEtudiant() ; //affiche methode 1
O1.afficherEtudiant(“surcharge“) ;// Affiche methode 2

30
Chiheb-Eddine Ben N’Cir

Vous aimerez peut-être aussi