Vous êtes sur la page 1sur 53

Les classes et objets en Java

Ecole Marocaine des Sciences de l’ingénieur

Mme OUHMIDA Asmae


PLAN

1. Concepts des langages objet


2. Constructeur de classe
3. Destructeur de classe
4. Déclaration d’une classe
5. Objet
6. Les données
7. La méthode main()
8. Les méthodes
CONCEPTS DES LANGAGES OBJET

▪ Objet :

• Une entité contenant des données


(état) et des fonctions associées
(comportement)

• Exemple: un objet rectangle

• Un objet possède une identité unique


et invariable
CONCEPTS DES LANGAGES OBJET

▪ Messages :
• Pour utiliser un objet on lui envoie des messages
• Un message déclenche l’exécution d’une méthode
• Une méthode peut envoyer des messages à d’autres objets
en Java :
rect1.doubler();
d = rect1.diagonale();
System.out.println(“Hello”);
uneListe.insertAt(12, “bien”);
z = Math.cos(2.45);
• Un système est constitué d’objets qui communiquent entre eux
CONCEPTS DES LANGAGES OBJET

▪ Classes
• Une classe est un moule pour fabriquer des
objets de même structure et de même
comportement
• Un objet est une instance d’une classe
• Une classe C définit un type C.
• Une variable de type C peut faire référence à
un objet de la classe C
CONCEPTS DES LANGAGES OBJET

▪ Déclaration d’une classe en Java


// méthodes
class Rectangle { int perimetre() {
return 2 * (largeur+hauteur);
// variables d’instance }
int largeur, hauteur;
int surface() {
// constructeur return largeur*hauteur;
Rectangle(int initialL, int initialH) { }
largeur = initialL; void retaille(double facteur) {
hauteur = initialH; largeur=(int)(largeur*facteur);
} hauteur=(int)(hauteur*facteur;
}

}
CONCEPTS DES LANGAGES OBJET

▪ Utilisation d’une classe Java

• Déclaration de variables
Rectangle r1, r2;

• Création d’objets (instantiation) r1 = new


Rectangle(50, 100); r2 = new Rectangle(32, 150);

• Envoi de messages (utilisation) r2.retaille(1.25);


System.out.println( r2.perimetre() );
CONCEPTS DES LANGAGES OBJET

▪ Représentation mémoire

r1 r2

50 32
100 150
CONCEPTS DES LANGAGES OBJET

▪ Représentation mémoire
r1 et r2 contiennent l'adresse des zones mémoires allouées par l'opérateur new pour
stocker les informations relatives à ces objets
 r1 et r2 sont des références
La référence d’un objet est utilisée pour accéder aux données et fonctions
membres (méthodes) de l’objet
Un objet peut accéder à sa propre référence grâce à la valeur this (variable en
lecture seule)
Une référence contenant la valeur null ne désigne aucun objet
Quand un objet n’est plus utilisé (aucune variable du programme ne contient une
référence sur cet objet), il est automatiquement détruit et la mémoire est récupérée
(garbage collector)
CONCEPTS DES LANGAGES OBJET

▪ Concept de base de la Programmation Orientée Objet -P.O.O.- : la classe

▪ Une classe modélise la structure statique (données) et le comportement


dynamique (méthodes) des objets associés à cette classe.

▪ Un objet d’une classe est appelé une instance

▪ Une classe est la description d’un objet. Chaque objet est créé à partir d’une
classe (avec l’opérateur new)
CONCEPTS DES LANGAGES OBJET

▪ Exemple
Nom de la classe

Compte

structure statique
Numero : entier données membres
Solde : nombre réel

comportement
Initialise (numero,solde) dynamique
deposer (montant) méthodes
retirer (montant)
consulterSolde ()
afficher ()
CONCEPTS DES LANGAGES OBJET

▪ Exemple d’écriture et d’utilisation de la classe Compte

structure statique comportement


class Compte { (données) dynamique
private int numero ; (méthodes)
private float solde ;
public void initialise (int n, float s) { numero = n ; solde = s ; }
public void deposer (float montant) { solde = solde + montant ; }
public void retirer (float montant) { solde = solde – montant ; }
public float consulterSolde ( ) { return solde ; }
public void afficher() {
System.out.println ("Compte : " + numero + " solde: " + solde) ;
}
CONCEPTS DES LANGAGES OBJET

▪ Exemple d’écriture et d’utilisation de la classe Compte

public class Banque


{
static public void main (String args [ ])
{
Compte co1 = new Compte () ; Compte co2 = new Compte () ;
co1.initialise (1234,1000f) ; co2.initialise (5678,500f) ; co1.deposer (2100.95f) ;
co1.afficher () ;
co2.retirer (1000.0f) ; co2.afficher () ;
}
}
CONCEPTS DES LANGAGES OBJET

 Exercice:
Définir une classe Point destinée à manipuler les points d’un plan.
public class Point
{ // instructions de definition des champs et des methodes de la classe
}
Variables: Abscisse, ordonnée
Supposons que nous souhaitions disposer des trois méthodes suivantes :
• initialise pour attribuer des valeurs aux coordonnées d’un point,
• deplace pour modifier les coordonnées d’un point,
• affiche pour afficher un point :(afficher les coordonnées du point).
public class Point
{
private int x ; // abscisse
private int y ; // ordonnee

public void initialise (int abs, int ord)


{ x = abs ;
y = ord ;
}

public void deplace (int dx, int dy)


{ x += dx ;
y += dy ;
}

public void affiche ()


{ System.out.println ("les coordonnees " + x + " " + y) ;
}
}
public class TstPoint
{
public static void main (String args[])
{
Point a ;
a = new Point() ;
a.initialise(3, 5) ;
a.affiche() ;
a.deplace(2, 0) ;
a.affiche() ;
Point b = new Point() ;
b.initialise (6, 8) ;
b.affiche() ;
}
}

les cordonnees 3 5
les coordonnees 5 5
les coordonnees 6 8
CONSTRUCTEUR DE CLASSE

▪ Pour manipuler un objet, on déclare une référence sur la classe de cet objet :
Rectangle r1, r2;
▪ Pour créer un objet, on instancie une classe en appliquant l'opérateur new sur
un de ses constructeurs.
▪ Une nouvelle instance de cette classe est alors allouée en
mémoire :
r1 = new Rectangle(5,10); r2 = new
Rectangle(20,30);

▪ Un constructeur est une méthode appelée au moment de la création de


l’objet
CONSTRUCTEUR DE CLASSE

▪ Un constructeur est utile pour procéder à toutes les initialisations nécessaires lors de
la création de la classe

▪ Toute classe possède un constructeur par défaut, implicite. Il peut être redéfini

▪ Le constructeur porte le même nom que le nom de la classe et n’a pas de valeur
de retour

▪ Une classe peut avoir plusieurs constructeurs qui différent par le nombre et la
nature de leurs paramètres (surcharge des constructeurs)
CONSTRUCTEUR DE CLASSE

▪ Exemples de constructeurs
class Compte { class Rectangle {
// variables d’instance
// variables d’instance private int largeur, hauteur;
private int numero ;

private float solde ; // constructeur


public Rectangle(int L, int H) {
// constructeur largeur = L;
public Compte (int num,float s) { hauteur = H;
numero = num ; }
solde = s ; ….
}
}
….
} Rectangle r1 = new Rectangle(5, 10);
Compte co1 = new Compte (12,100f) ;
CONSTRUCTEUR DE CLASSE

▪ Exemples de constructeurs

class Cercle {
double x, y, r;

public Cercle(double x, double y, double r) { this.x = x;


this.y = y; this.r = r;
}
public Cercle(Cercle c) {
x = c.x; y=c.y; r=c.r;
}
public Cercle(double x, double y) {
this.x = x; this.y = y; this.r = 2d;
}
…...
}
DESTRUCTEUR DE CLASSE

▪ Un destructeur peut être appelé lorsqu’un objet est détruit

▪ Le destructeur doit être utilisé pour libérer les ressources qui ne peuvent être
récupérées par le garbage collector (déconnexion d’une base de données,
fermeture d’un fichier,…)

▪ Un destructeur est une méthode:


Void finalize()
DÉCLARATION D'UNE CLASSE

▪ La syntaxe de déclaration d'une classe

modificateurs class nom_classe [extends classe_mere] [implements


interface]
{
// insérer ici les champs et les méthodes
}

ClassModifiers class ClassName [extends SuperClass] [implemenents


Interfaces]
{
// insérer ici les champs et les méthodes
}
DÉCLARATION D'UNE CLASSE
▪ Les modificateurs de classe (ClassModifiers) sont :

Modificateur Rôle
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.

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.

private la classe n'est accessible qu'à partir du fichier où elle est définie

public La classe est accessible partout


DÉCLARATION D'UNE CLASSE

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

L'ordre des méthodes dans une classe n'a pas d'importance. Si dans une classe, on
rencontre d'abord la méthode A puis la méthode B, B peut être appelée sans problème
dans A
OBJET

▪ La durée 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 déclaration de l'objet et l'instanciation grâce à l'opérateur new


Exemple : nom_classe nom_objet = new nom_classe( ... )

- l'utilisation de l'objet en appelant ces méthodes

- la suppression de l'objet : elle est automatique en Java grâce à la machine virtuelle


(garbage collector)
OBJET

▪ La création d'objets identiques

Exemple : MaClasse m1 = new MaClasse(); MaClasse m2 = m1;


• m1 et m2 contiennent la même référence et pointent donc tous les deux sur le même
objet (copie de surface )
• Pour créer une copie d'un objet, il faut utiliser la méthode clone() : cette méthode
permet de créer un deuxième objet indépendant mais identique à l'original. Cette
méthode est héritée de la classe Object qui est la classe mère de toute les classes en
Java (copie profonde).
Exemple : MaClasse m1 = new MaClasse(); MaClasse m2 = m1.clone();
• m1 et m2 ne contiennent plus la même référence et pointent donc sur des objets
différents
OBJET
▪ La création d'objets identiques

copie de surface copie profonde


MaClasse m2 = m1; MaClasse m2 = m1.clone();

m1 m2 m1 m2

32 32 32
150 150 150
OBJET

▪ Les références et la comparaison d'objets

Les variables de type objet que l'on déclare ne contiennent pas un objet mais une
référence vers cet objet

Si on écrit c1 = c2 (c1 et c2 sont des objets), on copie alors la référence de l'objet c2
dans c1 : c1 et c2 réfèrent au même objet (ils pointent sur le même objet)

L'opérateur == compare ces références. Deux objets avec des propriétés identiques
sont deux objets distincts

 Exemple :
Rectangle r1 = new Rectangle(100,50);
Rectangle r2 = new Rectangle(100,50);
if (r1 == r1) { ... } // vrai
if (r1 == r2) { ... } // faux
OBJET

▪ Les références et la comparaison d'objets

• 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
if (r1.equals(r2)) { ... } // vraie

• 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.
(obj1.getClass().equals(obj2.getClass())
OBJET

▪ L'objet null

 L'objet null est utilisable partout

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 ramasse miette
de libérer la mémoire allouée à l'objet
OBJET

▪ La variable this

• Cette 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é.

Exemple :
private int nombre;
public maclasse(int nombre) {
nombre = nombre;
// variable de classe = variable en paramètre du constructeur
}
• Il est préférable de préfixer la variable d'instance par le mot clé this. this.nombre = nombre;
LES DONNÉES

Une classe c’est un ensemble de données et de fonctions regroupées dans une


même entité

Une classe comporte sa déclaration, des variables (données) 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
et la définition des méthodes
LES DONNÉES

▪ propriétés ou attributs

• Les données d'une classe sont contenues dans des variables nommées propriétés ou
attributs

• Ce sont des variables qui peuvent être des variables d'instances, des variables de
classes ou des constantes.

• Les données (Les méthodes) sont pourvues d'attributs de visibilité qui gère leur
accessibilité par les composants hors de la classe.
LES DONNÉES

▪ Les variables d'instances

• Une variable d'instance nécessite simplement une déclaration de la variable dans le corps
de la classe

• Exemple :
public class MaClasse { variables d'instance
public int valeur1 ;
int valeur2 ;
protected int valeur3 ;
private int valeur4 ;
}
Chaque instance de la classe a accès à sa propre occurrence de la variable.
LES DONNÉES

▪ Les variables de classes

Les variables de classes sont définies avec le mot clé static

 Exemple

Variable de classe
public class MaClasse {
static int compteur ;
}

 Chaque instance de la classe partage la même variable.


LES DONNÉES

▪ Les constantes

Les constantes sont définies avec le mot clé final : leur valeur ne peut pas
être modifiée une fois qu'elles sont initialisées

 Exemple :

constante
public class MaClasse {
final double pi=3.14 ;
}
LES DONNÉES

▪ Les modificateurs d'accès

 Ils se placent avant ou après le type de l'objet.

 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.
LES DONNÉES
• Les modificateurs d'accès

Modificateur Rôle
public Une variable public est visible par tout les autres objets. Dans la philosophie
orientée objet aucune donnée d'une classe ne devraient être déclarée
publique: il est préférable d'écrire des méthodes pour la consulter et la
modifier
par défaut Il n'existe pas de mot clé pour définir ce niveau, qui est le niveau par défaut
lorsqu'aucun modificateur n'est précisé. Cette déclaration permet à une
variable d'être visible par toutes les classes se trouvant dans le même package.

protected Si une variable est déclarée protected , seules les méthodes présentes dans
le même package que cette classe ou ses sous classes pourront y accéder.

private C'est le niveau de protection le plus fort. Les composants ne sont visibles qu'à
l'intérieur de la classe : ils ne peuvent être modifiés que par des méthodes
définies dans la classe prévues à cet effet.
LA MÉTHODE main(..)

▪ La méthode main(..)
 La méthode main est la première méthode exécutée par une application Java lors de son
lancement
La méthode main() de la classe principale d'une application doit être déclarée de la façon
suivante :

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


Une application Java peut avoir des arguments. Ils seront introduits après le nom de l’application.
⬧ Pour les prendre en compte, la méthode main doit avoir comme paramètres la chaîne
" String [ ] args ".
⬧ En effet, un tableau de string est nécessaire pour stocker les arguments introduits. L’indice du
nième argument est n-1.
LA MÉTHODE main()

▪ La méthode main(..)

"args.length" permet de déterminer le nombre d’arguments introduits après le nom


de l’application

Cette déclaration de la méthode main() est imposée par la machine virtuelle pour
reconnaître le point d'entrée d'une application

Si la déclaration de la méthode main() diffère, une exception sera levée lors de la
tentative d'exécution par la machine virtuelle.
LA MÉTHODE main()

▪ La méthode main(..)

 Exemple :

public class test {


public static void main (String args[ ]) { int l;
l=args.length;
System.out.println ("nombre d’arguments = " + l); for (int i=0; i<l; i++)
System.out.println (args[i]);
}
}
LES MÉTHODES

▪ Les méthodes

 Les méthodes sont les fonctions pour le langage C

Les méthodes sont des fonctions qui implémentent les traitements de la classe

 N’importe quelle exécution dans une application Java se fait à l’intérieure d’une méthode

 Une méthode a deux parties : déclaration et le corps

 La syntaxe de la déclaration d'une méthode est la suivante:

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


// définition des variables locales et du bloc d'instructions }
LES MÉTHODES

▪ Les modificateurs de méthodes sont :

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)
LES MÉTHODES

▪ Les modificateurs de méthodes sont :

Modificateur Rôle
static la méthode appartient simultanément à tous les objets de la classe (comme une
constante déclarée à l'intérieur 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


LES MÉTHODES

▪ Le type retourné
Le type retourné peut être élémentaire ou correspondre à un objet. Si la méthode ne
retourne rien, alors on utilise void.
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 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 MÉTHODES

▪ Les arguments
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
LES MÉTHODES

▪ Les arguments

 Exemples :
int add(int a, int b) { return a + b; }

Si la méthode retourne un tableau alors les [ ] peuvent être préciser après le type
de retour ou après la liste des paramètres :
int[ ] valeurs() { ... }
int valeurs()[ ] { ... }
LES MÉTHODES

▪ La transmission de paramètres

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.
LES MÉTHODES

▪ La transmission de paramètres

Si un objet O transmet sa variable d'instance V en paramètre à une méthode


m, deux situations sont possibles :
si V est une variable primitive alors elle est passée par valeur : il est
impossible de la modifier dans m pour que V en retour contienne cette
nouvelle valeur.

 si V est un objet alors m pourra modifier l'objet en


utilisant une méthode de l'objet passé en paramètre.
LES MÉTHODES

▪ L'enchaînement de références à des variables et à des méthodes

 Exemple : System.out.println("bonjour");
Deux classes sont impliquées dans l'instruction : System et PrintStream

La classe System possède une variable nommée out qui est un objet de type PrintStream

 Println() est une méthode de la classe PrintStream

 L'instruction signifie :

utilise la méthode println() de la variable out de la classe System


LES MÉTHODES

▪ La surcharge de 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 lorqu'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
LES MÉTHODES

▪ La surcharge de méthodes Le type des


arguments est
 Exemple : différent
class affiche { int float

public void afficheValeur(int i) {


System.out.println(" nombre entier = " + i);
}
public void afficheValeur(float f) { System.out.println(" nombre
flottant = " + f);
}
}
LES MÉTHODES

▪ La surcharge de méthodes

Il n’est pas possible


 Exemple : d'avoir deux
class affiche { méthodes de même
public float convert(int i){ nom dont tous les
paramètres sont
return((float) i);
identiques et dont
} seul le type
retourné
public double convert(int i){
diffère
return((double) i);
}
}

Vous aimerez peut-être aussi