Vous êtes sur la page 1sur 40

Sommaire

• Introduction
• Concepts de la POO
– Objet , classe, encapsulation, héritage, etc.
• Langage Java
– Introduction
– Syntaxe de Java
– Objets et Classes
– Relations entre classe : Héritage et polymorphisme
– Interfaces graphiques : AWT
– Les indispensables :Collections, exceptions.
– Les entrées sorties
– Les threads
– Les applets
Les classes et les objets en Java
• La classe
Définition
Déclaration
Variables et méthodes de classe
• Méthode
Définition
Déclaration
Mode de passage des paramètres
Surcharge de méthode
• Manipulation des objets
Création (Constructeur)
Accès aux attributs d’un objet
Accès aux méthodes d’un objet
Opérteur instanceOf et l’autoréférence this
Destruction d’objets
• L’encapsulation
Contrôle d’accès
L’approche objet
• Un objet informatique
– maintient son état dans des variables (appelées
champs)
– implémente son comportement à l'aide de méthodes
objet informatique = regroupement logiciel de variables et
de méthodes
• Cycle de vie d’un objet
1. Construction (en mémoire)
2. Utilisation (changements d’état par affectations,
comportements par exécution de méthodes)
3. Destruction
La classe (1) : définition
• Classe : description d’une famille d’objets ayant une
même structure et un même comportement. Elle est
caractérisée par :
– Un nom
– Une composante statique : des champs (ou attributs) nommés
ayant une valeur pour chaque objet de la classe. Ils
caractérisent l’état des objets pendant l’exécution du
programme
– Une composante dynamique : des méthodes représentant le
comportement des objets de cette classe. Elles manipulent les
champs des objets et caractérisent les actions pouvant être
effectuées par les objets.
La classe (2) : représentation graphique
Nom de la
Point classe
Etudiant

Champs nom
Abscisse cycle
Ordonnée
getNom()
translate () getcycle()
distance() Méthodes setNom()
setcycle()
Déclaration d’une classe
 Le nom de la classe est spécifié derrière le mot clé « class »
 Le corps de la classe est délimité par des accolades {}
 On définit dans le corps les attributs et les méthodes qui constituent la classe
Modificateurs class Nomclasse{

< corps de la classe >

}
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
par défaut : Il n'existe pas de mot clé pour définir ce niveau, qui est le niveau par défaut lorsqu'aucun
package modificateur n'est précisé. Cette déclaration permet à une classe d'être visible par toutes les
friendly classes se trouvant dans le même package.
Syntaxe de définition d’une classe
Exemple : Une classe définissant un point
public Class Point Nom de la Classe
{
double x; // abscisse du point
double y; // ordonnée du point Attributs
// translate de point de (dx,dy)
void translate (double dx, double dy) {
x = x+dx;
y = y+dy; Méthodes
}
// calcule la distance du point à l’origine
double distance() {
return Math.sqrt(x*x+y*y);
}
}
Conventions pour les identificateurs
• Classes : tous les mots commencent par une lettre
majuscule
exemple: Point, Personne, Etudiant, System, etc.
• Variables : comme pour les classes, mais le premier mot
commence par une lettre minuscule (ex : nom, point1)
• Constantes : en majuscule avec les mots séparés par le
caractère souligné (ex. : UNE_CONSTANTE)
• Méthodes : comme pour les variables, mais le premier
mot est un verbe (ex. : afficherSomme, calculerPrix)
Notion de méthodes et de paramètres (1)
La notion de méthodes dans les langages objets
 Proches de la notion de procédure ou de fonction
dans les langages procéduraux.

 La méthode c’est avant tout le regroupement d’un


ensemble d’instructions

 Comme pour les procédures ou les fonctions (au


sens mathématiques) on peut passer des
paramètres aux méthodes et ces dernières peuvent
renvoyer des valeurs (grâce au mot clé return).
Notion de méthodes et de paramètres (2)

exemple : public, type de la valeur couples d'un type et d'un


Static, private renvoyée ou void identificateur séparés par des « , »

<modificateur> <type-retour> <nomMéthode> (<liste-param>)


{<bloc>}

public double add (double number1, double number2)


{ Notre méthode
retourne ici une
return (number1 +number2); valeur
}
Mode de passage des paramètres
 Java n'implémente qu'un seul mode de
passage des paramètres à une méthode : le
passage par valeur.
 Conséquences :
– l'argument passé à une méthode ne peut être
modifié,
– si l'argument est une instance, c'est sa référence
qui est passée par valeur. Ainsi, le contenu de
l'objet peut être modifié, mais pas la référence
elle-même.
Surcharge de méthodes (1)
• Dans une même classe, plusieurs méthodes
peuvent posséder le même nom, pourvu qu'elles
diffèrent en nombre et/ou type de paramètres.
– On parle de surdéfinition ou surcharge, on encore en
anglais d’overloading en anglais.
– Le choix de la méthode à utiliser est en fonction des
paramètres passés à l'appel.
• Ce choix est réalisé de façon statique (c'est-à-dire à la
compilation).
– Très souvent les constructeurs sont surchargés (plusieurs
constructeurs prenant des paramètres différents et
initialisant de manières différentes les objets)
Surcharge de méthodes (2)
Class addition {
public double add (double number1, double number2)
{
return (number1 +number2); La méthode add
} est surchargée
public double add (double number1, double number2, double number3 )
{
return (number1 +number2+ number3);
}

}
Méthodes particulières
Méthodes Rôle
Constructeur Un constructeur est une méthode qui permet l’instanciation des objets à partir
d’une classe et l’initialisation des champs de ces objets. Un constructeur a le
même nom que la classe et sans type de retour.
Méthodes d’accès Méthodes qui retourne l’état d’un objet (certains champs) qui sont
(getter) généralement privés .
La notation utilisée est getXXX ; XXX le champs retourné
Méthodes de Méthodes qui modifie l’état d’un objet (certains champs).
modification (setter) La notation utilisée est setXXX ; XXX le champs modifié

Class Point
{
double x; // abscisse du point
double y; // ordonnée du point
// constructeur
Point (){
x=0;
y=0;
}
// méthode qui permet de retourner la valeur de y
double getY() {
return y;
}
// méthode qui permet de modifier la valeur de y
void setY(double dy) {
y=dy;
}
}
L’instanciation (1)
 Instanciation : concrétisation d’une classe en un objet « concret ».
– Dans nos programmes Java nous allons définir des classes et
instancier ces classes en des objets qui vont interagir. Le
fonctionnement du programme résultera de l’interaction entre ces
objets « instanciés ».
– En Programmation Orientée Objet, on décrit des classes et
l’application en elle-même va être constituée des objets instanciés,
à partir de ces classes, qui vont communiquer et agir les uns sur les
autres.

• Instance
– représentant physique d'une classe
– obtenu par moulage du dictionnaire des variables et détenant les valeurs de
ces variables.
– Son comportement est défini par les méthodes de sa classe
– Par abus de langage « instance » = « objet »
L’instanciation (2)
Yanis: Etudiant
nom= " H . Yanis ";
cycle= "Licence ";
getNom()
Etudiant getcycle()
nom setNom()
cycle setcycle()
getNom()
getPrénom Lydia: Etudiant
setNom nom= " H . Lydia ";
Set prénom cycle= "Doctorat ";
getNom()
getcycle()
setNom()
setcycle()

Classe Objets (instances)


Les constructeurs (1)
• L'appel de new pour créer un nouvel objet déclenche, dans l'ordre :
– L'allocation mémoire nécessaire au stockage de ce nouvel objet et
l'initialisation par défaut de ces attributs,
– L'initialisation explicite des attributs, s'il y a lieu,
– L'exécution d'un constructeur.
• Un constructeur est une méthode d'initialisation.
class Point
public class TestPoint {
double x; // abscisse du point
{ double y; // ordonnée du point
public static void main(String args[]) // constructeur
{ Point (double dx, double dy){
Point p1 = new Point(3,4) x=dx;
y=dy;
}
} }
}

x
P1
3
4 y
Les constructeurs (2)
• Lorsque l'initialisation explicite n'est pas possible
(par exemple lorsque la valeur initiale d'un attribut
est demandée dynamiquement à l'utilisateur), il est
possible de réaliser l'initialisation au travers d'un
constructeur.
• Le constructeur est une méthode :
– de même nom que la classe,
– sans type de retour.
• Toute classe possède au moins un constructeur. Si
le programmeur ne l'écrit pas, il en existe un par
défaut, sans paramètres, de code vide.
Les constructeurs (3)

Point.java Définition d’un constructeur. Le


public class Point constructeur par défaut (Point())
{ n’existe plus.
double x; // abscisse du Le code suivant occasionnera une
point erreur
double y; // ordonnée du
point
// constructeur TestPoint.java
Point (double dx, double dy) public class TestPoint
{ {
x=dx; public static void main(String args[])
y=dy; {
} point P2= new Point();//appel du
//constructeur par défaut
} } }
Va donner une erreur à la
compilation
Les constructeurs (4)
• Pour une même classe, il peut y avoir plusieurs
constructeurs, de signatures différentes (surcharge).
• L'appel de ces constructeurs est réalisé avec le new
auquel on fait passer les paramètres.
– p1 = new Point(6,4);
• Déclenchement du "bon" constructeur
– Il se fait en fonction des paramètres passés lors de l'appel
(nombre et types). C'est le mécanisme de "lookup".
• Attention
– Si le programmeur crée un constructeur (même si c'est un
constructeur avec paramètres), le constructeur par défaut
n'est plus disponible. Attention aux erreurs de compilation !
Les constructeurs (5)
Point.java TestPoint.java
public class Point public class TestPoint
{ {
double x; // abscisse du point public static void main(String args[])
double y; // ordonnée du point {
// plusieurs constructeurs Point p1= new Point()
Point (){ Redéfinition Point p2=new Point(3);
d’un
x=0; Point p3=new Point(3,4);
Constructeur
y=0; sans Point p3=new Point(3,4,5);
} paramètres
Point (double dx){ }
x=dx;
y=0; }
}
Point (double dx, double dy){ Va donner une erreur à la compilation
x=dx;
y=dy;
} On définit plusieurs constructeurs
qui se différencient uniquement
} par leurs paramètres (surcharge)
Résumé : Classe et objet en Java
Objets
Point
class Point
{
double x; Point p1, p2;
double x; //
abscisse du point double y; p1= new Point ();
double y; //
} p2= new Point ();
ordonnée du point

L’opérateur d’instanciation en Java est new :


MaClasse monObjet = new MaClasse();
En fait, new va réserver l’espace mémoire nécessaire pour créer
l’objet « monObjet » de la classe « MaClasse », et le constructeur
MaClasse() initialise les attributs de l’objet crée.
Objets, tableaux, types de base
• Lorsqu'une variable est d'un type objet ou tableau,
ce n'est pas l'objet ou le tableau lui-même qui est
stocké dans la variable mais une référence vers cet
objet ou ce tableau (on retrouve la notion
d’adresse mémoire ou du pointeur en C).
• Lorsqu'une variable est d'un type de base, la
variable contient la valeur.
a 0
Int a=0; // variable de type de base
4 tab[0]
Int tab[]={4,5,6}; // tableau
Point p1=new Point(2,5); // objet tab 5 tab[1]
6 tab[2]

x
P1
2
5 y
Opérateur instanceof
• L'opérateur instanceof confère aux instances une capacité
d'introspection : il permet de savoir si une instance est
instance d'une classe donnée.
– Renvoie une valeur booléenne

if ( ... )
Personne Personne nadine= new Etudiant();
else
Personne nadine= new Employe();

//...
Employé Etudiant
?? ?? if (nadine instanceof Employe)
// discuter affaires
else
Nadine // proposer un stage
L’autoréférence : this (1)
• Le mot réservé this , utilisé dans une
méthode, désigne la référence de l'instance à
laquelle le message a été envoyée (donc celle
sur laquelle la méthode est « exécutée »).
• Il est utilisé principalement :
1. Pour lever une ambiguïté,
2. Dans un constructeur, pour appeler un autre
constructeur de la même classe.
L’autoréférence : this (2)
class Point
{
private int x;
private int y;
Point(int x,int y)
{
this.x=x; Pour lever l’ambiguïté sur les mots « x » et
this.y=y; « y » et déterminer si c’est le «x/ y » du
} paramètre ou de l’attribut
}
public Point(int x, int y)
{
this.x=x;
this.y=y;
} Appelle le constructeur
point(int a, int b)
Public Point(int y)
{
this(y,0);
}

public Point() Appelle le constructeur


{ Point(int y)
this(0);
}
Accès aux attributs d’un objet (1)
Point.java
public class Point
{ Point
double x; // abscisse du point
double y; // ordonnée du point
// plusieurs constructeurs
double x; //
double getX (){ abscisse du point
return x double y; //
} ordonnée du point
double getY (){
return y
}
void setX(double dx){
x=dx;
}
void setY(double dy){
y=dy;
}

}
Accès aux attributs d’un objet (2)
TestPoint.java
public class Application Accès aux attributs x et y
{ De l’objet p1
public static void main(String args[])
{
Point p1 = new Point()
p1.x = 10 ;
P1.y = 20 ;
}
}

Remarque :
Contrairement aux variables, les attributs d'une classe, s'ils ne sont pas initialisés, se voient
affecter automatiquement une valeur par défaut.
Cette valeur vaut : 0 pour les variables numériques, false pour les booléens, et null pour les
références.
Accès aux méthodes d’un objet

TestPoint.java Accès au méthodes setX et setY


de l’objet p1
public class Application
{
public static void main(String args[])
{
Point p1 = new Point();
p1.setX ( 10) ;
P1.setY( 20);
}
}
L’encapsulation (1)

• Notion d'encapsulation :
– les données et les procédures qui les manipulent
sont regroupées dans une même entité, l'objet.
– Les détails d'implémentation sont cachés, le monde
extérieur n'ayant accès aux données que par
l'intermédiaire d'un ensemble d'opérations
constituant l'interface de l'objet.
– Le programmeur n'a pas à se soucier de la
représentation physique des entités utilisées et peut
raisonner en termes d'abstractions.
Contrôle d’accès (1)
• Chaque attribut et chaque méthode d'une classe peut être :
Modificateur Rôle
public Une variable, méthode ou classe déclarée public est visible par tous les
autres objets.
par défaut : Il n'existe pas de mot clé pour définir ce niveau, qui est le niveau par défaut
package lorsqu'aucun modificateur n'est précisé. Cette déclaration permet à une
friendly entité (classe, méthode ou variable) d'être visible par toutes les classes se
trouvant dans le même package.
Protected Si une méthode ou 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. On ne peut pas qualifier une classe
avec protected.
C'est le niveau de protection le plus fort. Les composants ne sont visibles
private 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. Les méthodes
déclarées private ne peuvent pas être en même temps déclarée abstract car
elles ne peuvent pas être redéfinies dans les classes filles.
Contrôle d’accès (2)
• En toute rigueur, il faudrait toujours que :
– les attributs ne soient pas visibles,
• Les attributs ne devraient pouvoir être lus ou modifiés
que par l'intermédiaire de méthodes prenant en
charge les vérifications et effets de bord éventuels.
– les méthodes "utilitaires" ne soient pas visibles,
– seules les fonctionnalités de l'objet, destinées à
être utilisées par d'autres objets soient visibles.
– C’est la notion d’encapsulation
Point.java
Contrôle d’accès (3)
public class Point
{
private double x; // abscisse TestPoint.java
private double y; // ordonnée public class TestPoint
// plusieurs constructeurs {
double getX (){ public static void main(String args[])
return x {
} Point p1 = new Point();
p1.x = 5; // Invalide car
double getY(){ l'attribut est privé
return y p1.setX= 4; // OK
} p1.affiche( ); // OK
void setX(double dx){ }
x=dx; }
}
void setYdouble dy){
y=dy;
}
void affiche()
System.out.println(“abscisse est:“+
x + ordonnée est :“+y);
}
Variables de classe (1)
• Il peut s'avérer nécessaire de définir un attribut
dont la valeur soit partagée par toutes les instances
d'une classe. On parle de variable de classe.
• Ces variables sont, de plus, stockées une seule fois,
pour toutes les instances d'une classe.
• Mot réservé : static
• Accès :
– depuis une méthode de la classe comme pour tout
autre attribut,
– via une instance de la classe,
– à l'aide du nom de la classe.
Point.java
Variables de classe (2)
public class Point
{
public static int compteur = 0;
public Point() Variable de classe
{
// compter le nombre d’instance Utilisation de la variable de classe
compteur++; compteur dans le constructeur de
}
} la classe

Utilisation de la variable de classe


public class TestPoint compteur dans une autre classe
{
public static void main(String args[])
{
Int a;
Point p1 = new Point(3,4); 3 x
P1
Point p2 = new Point(5,6); y
a=Point.compteur; 4
System.out.println(“le nombre de points 5 x
P2
créés est :“+ a); y
}
6
} Compteur
2
1
Méthodes de classe (1)
• Il peut être nécessaire de disposer d'une méthode
qui puisse être appelée sans instance de la classe.
C'est une méthode de classe.
• On utilise là aussi le mot réservé static
• Puisqu'une méthode de classe peut être appelée
sans même qu'il n'existe d'instance, une méthode
de classe ne peut pas accéder à des attributs non
statiques. Elle ne peut accéder qu'à ses propres
variables et à des variables de classe.
Méthodes de classe (2)
Point.java TestPoint.java
public class Point public class TestPoint
{ {
private double x,y; Int b;
private static int compteur = 0; public static void main(String args[])
{
public Point() Int a;
{ Point p1 = new Point();
// compter le nombre d’instance Point p2 = new Point();
compteur++; a=Point.Nb_Point();
} System.out.println(“le nombre de points
public static int Nb_Point() créés est :“+ a);
{ b=a; // erreur une méthode static (main)ne
return compteur ; peut accéder à un attribut non statique
} }
} }

Autres exemples de méthodes


Math.sqrt(x);
de classe courantes
String.valueOf (i);
Destruction d’objets (1)
• Java n'a pas repris à son compte la notion de
destructeur telle qu’elle existe en C++ par
exemple.
• C'est le ramasse-miettes (ou Garbage Collector -
GC en anglais) qui s'occupe de collecter les objets
qui ne sont plus référencés.
• Le ramasse-miettes fonctionne en permanence
dans un thread de faible priorité (en « tâche de
fond »). Il est basé sur le principe du compteur de
références.
Destruction d’objets (2)
• Il est possible au programmeur d'indiquer ce
qu'il faut faire juste avant de détruire un objet.
• C'est le but de la méthode finalize()de l'objet.
• Cette méthode est utile, par exemple, pour :
– fermer une base de données,
– fermer un fichier,
– couper une connexion réseau,
– etc.
Destruction d’objets (3)
TestPoint.java
Point.java
public class TestPoint
public class Point {
{ Int b;
private double x,y; public static void main(String args[])
private static int compteur = 0; {
Int a;
public Point() Point p1 = new Point();
{ Point p2 = new Point();
// compter le nombre d’instance a=Point.Nb_Point();
compteur++; System.out.println(“le nombre de points
} créés est :“+ a);
public static int Nb_Point() System.out.println("le nombre de points "+a);
{ p3.finalize();
return compteur ;
p3=null;
}
System.gc();// appel explicite du
protected void finalize()
Garbage collector
{
a=Point.nombre();
compteur--;
System.out.println("le nombre de points "+a);
}
} }
}