Chapitre3:

Classe et Objet
Dr. MALKI Abdelhamid
a.malki@esi-sba.dz
Ecole Nationale Supérieure d’Informatique de Sidi Bel Abbes (ENSI)
2015/2016

1
 Classe
 Une classe peut être considérée comme un moule ou un modèle à
partir duquel on peut créer des objets.

 Une classe décrit un ensemble d’objets qui ont:

◦ Les mêmes types de données (nom, type, valeur de base)
◦ Les mêmes types de traitements (nom, paramètres)

 Toutes les voitures appartiennent à la classe voiture

 Tous les étudiants appartiennent à la classe étudiant

 Les objets d’une même classe ont chacun leurs propres données.

 L’identité est portée par l’objet, quelque soit la classe

 La classe sert simplement à décrire la structure des objets (leurs

attributs et leurs méthodes)
2
 Exemple: classe
 Supposons qu’un Compte Bancaire est représenté par le nom de son
titulaire, le solde, et le devise.

 Nous devons donc définir trois attributs dans la classe Compte:

titulaire, solde, devise

Compte
 Supposons que nous souhaitons pouvoir:
◦ Créditer le solde titulaire
◦ Débiter le solde solde
◦ Afficher la description du compte bancaire devise
◦
crediter()
 Nous devons donc disposer de trois méthodes debiter()
 dans la classe Compte : afficher()
◦ crediter()
◦ debiter()
◦ afficher()

3
 Classe en java(1):Class
 Le mot clé class permet de définir une classe java :
 Modificateur Class Nom_Classe
 {
 //le corps de la classe
 }

 Modificateur: {abstract, final, public}

Class Compte Public Class Compte

{ {
//le corps de la classe //le corps de la classe
} }
La classe n’est accessible qu’à La classe est accessible partout
partir du package où elle définie
4
 Classe en java(2):attributs
 Les attributs sont les données de la classe.

 Modificateur_Visibilité type nom_attribut;

 un attribut peut être de type élémentaire: entier, réel (float, double), booléen,
caractère, ou de type objet.

 Le modificateur de visibilité permet de définir des niveaux de protection différents:

◦ Public: l’attribut est accessible partout

◦ Private: l’attribut n’est visible qu'à l'intérieur de la classe, mais il peut être accédé via des méthodes
publiques.

◦ Protected : (dans le chapitre héritage)

 lorsqu'aucun modificateur n'est précisé, l’attribut est visible par toutes les classes se
trouvant dans le même package.

5
 Classe en java(2):attributs
exemple
public Class Compte { public Class Compte {

public String titulaire; public String titulaire, devise;

private double solde; private double solde;
public String devise; }
}

 Le mot clé private précise que le champs solde n’est pas accessible
de l’extérieur de la classe (c-à-d en dehors de ses propres
méthodes).

 A l’opposé on utilise le mot clé public.

6
 Classe en java(3):méthodes
Nom de la
Visibilité méthode

 public void crediter (double montant)

Type de retour
 { Les paramètres

 solde=solde+montant;

 }

7
 La classe Compte
 public Class Compte {

Nom de la classe
 public String titulaire;
 private double solde; Les attributs
 public String devise;

 public void crediter (double montant)

 {solde=solde+montant;}


 public void dediter (double montant) Les méthodes

 {solde=solde-montant;}

 public void afficher(){

 System.out.println("Le solde du compte de "+titulaire
 + " est de " + solde + " " + devise);}
 }

8
 Objet
 Une classe est un plan ou un moule pour fabriquer
un objet, ce qu’on appelle instancier un objet.

 À partir d’une classe, plusieurs objets peuvent être

fabriqués, instanciés, etc.

 Ces objets auront:

◦ Des identités différentes.
◦ Des états définis par les mêmes attributs (ceux de la
classe ) mais avec des valeurs pouvant être différentes.
◦ Un comportement identique (Mêmes méthodes)

9
 Création d’un objet (1)
 Dans la mémoire, un objet est représenté par deux choses:
◦ Un emplacement qui décrit son identité, ou ce que nous entendons par
la référence.
◦ Un emplacement pour les valeurs de ses attributs (état de l’objet).

 La référence contient l’adresse de l’emplacement mémoire

dans lequel est stocké l’objet (les attributs de l’objet).

 Les méthodes ne sont quant à elles pas dupliquées (inutile).

X=1
O1 Y=‘lao’
Z=1988
Référence
De l’objet Les valeur
l’objet(état)

10
 Création d’un objet (2)
Pour créer un objet, il faut tout d’abord le déclarer ensuite l’initialiser

Déclaration: Compte c1;

Cette déclaration ne réserve pas d’emplacement pour un objet de type

Compte, mais seulement un emplacement pour une référence.

Initialisation: c1= new Compte(); <=> Compte c1=new Compte();

l’opérateur new crée un objet de type Compte (emplacement pour son

état) et fournit sa référence.
Celle-ci est affectée à la variable c1 déclarée auparavant:

titulare =null
c1 Solde=0.0
c1=new Compte() Devise=null

Référence 11
 Utilisation d’un objet+ méthode main
 Une fois l’objet est crée, on peut l’utiliser via sa référence, c-a-d, la
variable de type classe.

public class Teste{

public static void main (String args[] ){

Compte c1= new Compte();

c1.titulaire=“Ali”; // modifier l’attribut titulaire de l’objet c1
c1.crediter(100) //permet d’invoquer la méthode qui crédite le
solde de l’objet c1.
c1.afficher() // permet d’invoquer la méthode qui affiche la
description du compte
}}

titulare =null
=Ali
c1 Solde=0.0
Solde=100.0
c1=new Compte() Devise=null
12
 Mais avant d’utiliser un objet,
Comment initialiser ses valeurs
(son état initial)?

Constructeur

13
 Constructeur
 Un constructeur est une méthode spéciale utilisée
pour créer un nouvel objet. Le constructeur se
caractérise par:

 •Il a le même nom que celui de la classe,

 •Ne retourne aucune valeur,
 •N’a aucun type de retour, même pas void

 Modificateur_visibilité Nom_de_classe (paramètres)

 {

 }
14
o public Class Compte {

o public String titulaire;

o private double solde;
o public String devise;

o public Compte (String t, double s, String d) Méthode

o { Constructeur
o titulaire=t; solde=s; devise=d;
o }

o public void crediter (double montant)

o {….}
o public void dediter (double montant)
o {….}
o public void afficher()
o {…..}
o }
15
 Constructeur :exemple
 Compte c1=new Compte("Ali", 200, "dinar");
titulare =‘Ali’
c1 Solde=200.0
c1=new Compte("Ali", 200, "dinar") Devise=‘dinar’

 Compte c2=new Compte("karim", 400, "euro");

titulare =‘karim’
c2 Solde=400.0
c2=new Compte("karim", 400, "euro") Devise=‘euro’

 Compte c3=new Compte("Ali", 200, "dinar");

titulare =‘Ali’
c3 Solde=200.0
c3=new Compte("Ali", 200, "dinar") Devise=‘dinar’ 16
 Règles pour le constructeur: Règle1
 Une classe peut ne disposer d’aucun constructeur. Dans ce cas
les objets sont créés en utilisant un constructeur par défaut sans
arguments comme dans l’instruction c1 = new Compte ();

 public Class Compte {

 public String titulaire;

 private double solde; c1
 public Stringdevise;
public String devise="dinar";
 public void crediter (double montant)
 {….} c1=new Compte()
 public void dediter (double montant)
 {….}
 public void afficher()
titulare
titulare=null
=null
 {…..}
Solde=0.0
Solde=0.0
 }
Devise=dinar
Devise=null
17
 Règles pour le constructeur: Règle 2
 Une classe peut disposer de plusieurs constructeurs.

 public Class Compte {

 public String titulaire;

 private double solde; c1
 public String devise;

public Compte (String t, double s, String d)

{titulaire=t; solde=s; devise=d;} c1=new Compte("Ahmed", 300)
c1=new Compte("Ali", 200, "dinar")

public Compte (String t, double s)

{titulaire=t; solde=s; } titulare =‘Ali’
=‘Ahmed’
Solde=200.0
Solde=300.0
Devise=‘dinar’
Devise=null
 …
 }

18
 Règles pour le constructeur: Règle 3
 Dès qu’une classe possède au moins un constructeur, le constructeur
par défaut ne peut plus être utilisé . Sauf si un constructeur sans
arguments a été définit.

 public Class Compte {

 public String titulaire;

 private double solde; c1
 public String devise;
public Compte (String t, double s, String d)
{titulaire=t; solde=s; devise=d;} c1=new Compte()

public Compte (String t, double s)

{titulaire=t; solde=s; } titulare =null
 … Erreur de
Solde=10.0
 }
public Compte() compilation
Devise=dinar
{ Solde:=10.0; Devise= "dinar";}

19
 Mot-clé: this
 Dans le traitement de l’une de ses méthodes un objet peut avoir à
s’envoyer un message (pour accéder à un de ses attributs ou
invoquer une des ses méthodes). Pour cela, il utilise le mot clé this.
 L’utilisation du mot clé this permet aussi d’éviter l’ambiguïté

 Exemple1: Ambiguïté
 public Compte (String titulaire, double solde, String d)
 { this.titulaire=titulaire; this.solde=solde; devise=d; }

 Exemple2: utilisation d’un autre constructeur

 public Compte (String titulaire, double s)
 { this.titulaire=titulaire; solde=s;}

public Compte (String titulaire, double solde, String d)

{ this (titulaire, solde); devise=d; }

20
 Exercice
 Maintenant on va modifier le type de l’attribut titulaire en utilisant
la classe Person .
 Une personne possède un nom, un prénom, et un sexe.
 La méthode afficher() agisse sur les attributs de la classe Person
en affichant leurs contenues.
 Donnez le code de la classe Person (attributs, 2 constructeurs,
méthode ) ?
 Reprogrammez la classe Compte en tenant compte du nouveau
type de l’attribut titulaire ( 2 constructeurs et les méthodes)

Compte Person
Public String
Persontitulaire
titulaire Public String nom
Public double solde Public String prenom
Public String devise Public char sexe
Public void crediter() Public void afficher()
Public void debiter()
Public void afficher() 21
 public Class Person {

 public String nom;

 Public String prenom;
 public char sexe;

 public Person (String n, String p, char se)

 {this.nom=n; this.prenom=p; this.sexe=se;}


 public Person () {}

 public void afficher(){

 System.out.println(nom+ " " + prenom + " " +sexe);
 }
 }

22
public class Compte {

public Person titulaire;

private double solde;
public String devise;

public Compte(String n, String p, char se, double solde, String devise){

this.titulaire=new Person(n,p,se);
this.solde=solde; this.devise=devise;}

public Compte(Person t, double solde, String devise){

this.titulaire=t; this.solde=solde; this.devise=devise;}

public Compte(){ titulaire=new Person(); }

public void crediter (double montant)

{solde=solde+montant;}
public void dediter (double montant)
{solde=solde-montant;}
public void afficher(){ System.out.println("Le solde du compte de
"+titulaire.nom + " est de " + solde + " " + devise);} 23
 Interface d’encapsulation(1)
 Accès direct aux variables d'un objet possible en JAVA ,
 mais ... n'est pas recommandé car contraire au principe
d'encapsulation

 les données d'un objet doivent être privées (c'est à dire

protégées et accessibles (et surtout modifiables) qu'au travers
de méthodes prévues à cet effet).

 En JAVA, possible lors de leur définition d'agir sur la visibilité

(accessibilité) des membres (attributs et méthodes) d’une classe
vis à vis des autres classes

 Plusieurs niveaux de visibilité peuvent être définis en précédant

la déclaration de chaque attribut, méthode ou constructeur d'un
modificateur (private, public, protected)
24
 Interface d’encapsulation(2): visibilité
Public private

Classe La classe peut être utilisée Interdit

dans n’importe quelle autre
classe

attribut Attribut accessible Attribut accessible uniquement

directement depuis code de dans le code de la classe qui le
n’importe quelle classe définit

méthode Méthode pouvant être Méthode utilisable uniquement

invoquée depuis code de dans le code de la classe qui
n’importe quelle classe la définit

•Aucun modificateur : visible par toutes les classes se trouvant dans le

même package.

•On reverra les autres niveaux de visibilité (abstract, final, protected) en

détail lorsque les notions d'héritage auront été abordées 25
 Interface d’encapsulation(3)
 les attributs déclarés comme privées (private) sont totalement
protégés, ne sont plus directement accessibles depuis le code d’une
autre classe

 Pour accéder à leur valeur il faut passer par une méthode publique
de type fonction, appelée accesseur (getter):GetXxxx

 public double GetSolde() { return this.solde; }

 Pour les modifier il faut passer par une méthode publique de type
procédure, appelée modificateur (setter): SetXxx

 public void SetSolde( double solde) { this.solde=solde; }

26
 L’interface d’encapsulation(2)
 public class Person {
 private String nom, prenom;
 public char sexe;

 public Person (String n, String p, char se)

 {this.nom=n; this.prenom=p; this.sexe=se;}


 public String GetNom() { return this.nom; } //accesseur

 public void SetNom( String nom) { this.nom=nom; } //modificateur

 public String GetPrenom() { return this.prenom; } //accesseur

 public void SetPrenom( String p) { this.prenom=p; } //modificateur

 ….
 } 27
 Référence d’objet(1)
 Un objet est utilisé via sa référence. Cette référence contient
l’adresse de l’emplacement mémoire dans lequel est stocké l’objet
(les attributs de l’objet).
 Compte c1,c2,c3;
 c1=new Compte("Ali", 200, "dinar");
 c2=new Compte("karim", 400, "euro");
 c3=null;
titulaire =‘Ali’
c1 solde=200.0
devise=‘dinar’

titulaire =‘Karim’
c2 solde=400.0
devise=‘euro’

c3
28
 Référence d’objet(2): affectation

 L’affectation c1=c2; permet de recopier seulement l’adresse de

c2 dans le référence de c1.

titulaire =‘Ali’
c1 solde=200.0 System.out.print(c1.titulaire) ‘Ali’
devise=‘dinar’

System.out.print(c1.titulaire) ‘Karim’

titulaire =‘Karim’ System.out.print(c2.titulaire) ‘Karim’

c2 solde=400.0
devise=‘euro’

 Comment réalise-t-on la permutation entre deux objets?

 L’utilisation d’une variable intermédiaire
 c3=c1; c1=c2; c2=c3

29
 Référence d’objet(3): comparaison
 Compte c1,c2,c3;
titulaire =‘Ali’
 c1=new Compte("Ali", 200, "dinar");
c2=new Compte("Ali", 200, "dirar");
c1 solde=200.0
devise=‘dinar’


 c3=c2;

c2 titulaire =‘Ali’
solde=200.0
 Égalité de référence
c3 devise=‘dinar’
 c1==c2 ---> false
 c2==c3 ---> true

 Égalité d’objet
 c1.equals(c2) --->true (il faut passer par une méthode de la classe Compte)

public boolean equals(Compte c) {

Return (titulaire.equals(c.titulaire))&&(solde==c.solde)&&(devise.equals(c.devise));
(titulaire.equals(c.titulaire))&&(solde==c.solde)&&(devise.equals(c.devise));
}
30
 Destruction des objets
 libération de l’espace mémoire alloué aux objets est automatique

 lorsqu'un objet n'est plus référencé le "ramasse miettes" ("garbage

collector") récupère l'espace mémoire qui lui était réservé.

 S’exécute :
◦ lorsqu'il n'y a pas d'autre activité (attente d'une entrée clavier ou d'un
événement souris)
◦ lorsque l'interpréteur JAVA n'a plus de mémoire disponible

 Le ramasse miettes libère l’espace mémoire occupé par un objet en

appelant son destructeur finalize()

 System.gc() --->Appel explicite au garbage collector

31
 Attributs statiques: variables de la classe
 Supposons qu'on veuille compter le nombre d'objets Compte créés dans une
application.
 L’idée est d'inclure dans les constructeurs de la classe Compte , une instruction
incrémentant un compteur (nbCompte).

 La variable compteur (nbcompte) est une variable partagée par toutes les objets d’une
classe  variable de classe.

 Comme c'est un attribut de la classe elle-même et non d'un objet particulier, on le

déclare différemment avec le mot clé static.

 public static int nbCompte; =0;

 Pour accéder aux champs statiques, on utilise le nom de la classe (et non pas
l’objet) Compte.nbCompter;

nbCompte=3
nbCompte=0
nbCompte=1
nbCompte=2

titulare =‘Karim’ titulare =‘Ali’ titulare =‘saad’

solde=400.0 solde=200.0 solde=900.0
devise=‘euro’ devise=‘dinar’ devise=‘dollar’ 32
public Class Compte {
…
public String titulaire; public static void main(String arg[])
private double solde; {
public String devise; Compte c1,c2,c3;
public static int nbCompte;
c1=new Compte(‘‘Ali’’,20,’’dinar’’)
public Compte(String t, double s, String d) System.out.println(Compte.nbCompte)
titulaire=t; solde=s; devise=d;
nbCompte++;} c2=new Compte(‘’karim’’,700)
System.out.println(Compte.nbCompte)
public Compte(String t, double s)
titulaire=t; solde=s; c3=new Compte();
nbCompte++;} System.out.println(Compte.nbCompte)

public Compte(){ nbCompte++;} c1=new Compte();

System.out.println(Compte.nbCompte)
//methodes
1
….. } 2
3
33
4
 Méthodes statiques: méthodes de classe
 Une méthode de classe a un rôle indépendant d’un objet
spécifique. C’est le cas par exemple d’une méthode qui
agit uniquement sur les champs de classe

 En java, on utilise là encore, le mot clé static.

 Une méthode de classe ne peut en aucun cas agir sur

des champs usuels (non static) puisqu’elle n’est liée à
aucun objet en particulier

34
public Class Compte {
…
public String titulaire; public static void main(String arg[])
private double solde; {
public String devise;
Compte c1,c2,c3;
private static int nbCompte;

//constructeurs
public Compte(String t, double s)
{ titulaire=t; solde=s;
nbCompte++;}
c1=new Compte(‘‘Ali’’,20,’’dinar’’)
c2=new Compte(‘’karim’’,700)
c3=new Compte();
System.out.print(Compte.GetnbCompte() )

……….
}
//méthodes usuelles
….. 3
//méthodes statiques
public static int GetnbCompte(){
return nbCompte; }
}

35
 Surcharge:
Surdéfinition des méthode
 Surcharge(overloading) est la possibilité de définir des méthodes
possédant le même nom mais dont les arguments diffèrent

 Surcharge n’est pas limitée aux constructeurs, elle est possible pour
n'importe quelle méthode (usuelles ou satique).

 Lorsque qu'une méthode surchargée est invoquée, le compilateur

sélectionne automatiquement la méthode dont le nombre, le type et
la position des arguments correspondent au nombre ,au type et à la
position des paramètres passés dans l'appel de la méthode

 Des méthodes surchargées peuvent avoir des types de retour

différents mais à condition qu'elles aient des arguments différents

36
public class Compte {
/attributs
…. Compte c1;
/constructeurs c1=new Compte(‘‘Ali’’,20,’’dinar’’)
…. double x=100.0;
public void crediter (double m) c1.crediter(x);
solde+=m;}

public void crediter (float m) float y=200;

solde+=m;} c1.crediter(y);

public void crediter (double m1, float m2) c1.crediter(y,x);

if (m1> m2) solde+=m1;
else solde+=m2;
int z=12;
public void crediter (float m1, double m2) c1.crediter(z);
if (m1> m2) solde+=m1;
else solde+=m2;

c1.crediter(12,12); erreur d’ambigüité

public double crediter (int m)
solde+=m;
return solde;
37
 class A {
public void f (int n, float x) { ..... }
 public void f (float x1, float x2) { ..... }
 public void f (float x, int n) { ..... }
 }
 Avec ces déclarations :
 A a ; short p ; int n1, n2 ; float x ;
 Quelles sont les instructions correctes et, dans ce cas, quelles
sont les méthodes appelées et les éventuelles conversions
mises en jeu ?
 a.f(n1, x) ;
 a.f(x, n1) ;
 a.f(p, x) ;
 a.f(n1, n2) ;

38