Vous êtes sur la page 1sur 24

Plan du module

Programmation par ● Avant-propos


● Introduction à Java
objets [en Java]
● Bases du langage
● Objet, classe, paquetage
● Héritage, classe abstraite, interface
● Interface graphique avec Swing
Olivier Le Goaer
olivier.legoaer@univ-pau.fr

Langages de programmation

● Langages Machines type Assembleur


Avant-propos Ο registres, code instruction, ...
● Langages évolués : ForTran, Basic Programmation
« spaguettis »

Ο étiquettes et sauts (goto), ...


● Langages structurés : Pascal, C Programmation
« lasagnes »
Ο fonctions, structures de données, algorithmes, ...
● Langages objets : C++, Java, C#
Ο encapsulation, héritage, polymorphisme, ... Programmation
« raviolis »

Typologie de langages objets Paradigme de l'objet

● Leprincipe consiste à définir et faire interagir


Langages à Langages à des briques logicielles appelées "objets"
classes prototypes
CLOS
Smalltalk
100% objet ● Un
Ruby objet est la représentation informatisée
Objective C
... d'une entité (tangible ou intangible) du monde
C++ JavaScript réel
Java Self
PHP 5 Lisaac
Orienté objet Visual Basic Lua
C# ...
Eiffel ● En faisant communiquer des objets entre eux,
ADA
... ils collaborent dans un but précis (à fixer)
Propriétés d'un objet

● Un objet possède une identité


Ο Ma voiture n'est pas celle de mon voisin

● Un objet est décrit par des données


Ο Ma voiture est de marque Peugeot et de couleur grise

● Un objet est décrit par des traitements


Ο Ma voiture peut démarrer, avancer ou reculer

Communication inter-objets

● On dit que deux objets communiquement


lorsqu'ils s'échange un message

● Ce message de l'objet émetteur vers l'objet


récepteur correspond à un ordre de traitement

● Selon les traitements qu'est capable de réaliser


l'objet récepteur (son interface), il réagit

Vie et état d'un objet Vers la notion de classe

● Le cycle de vie d'un objet inclue : ● Constat: tous les objets d'une même famille
Ο Sa naissance : création de l'objet censé reflèter une partagent les mêmes caractéristiques
entité du monde réel Ο Toutes les voitures (dont la mienne) ont une marque,
Ο Sa vie : l'objet réagit aux messages que d'autres lui une couleur, peuvent démarrer, avancer ou reculer
envoi et réalise ses traitements en conséquence ● Une"classe d'objets" (ou simplement "classe")
Ο Sa mort : l'objet est définitivement détruit caractérise un ensemble d'objets semblables
Ο C'est la classe des voitures
● L'état
d'un objet : se dit des valeurs de ses ● Unobjet donné est alors vu comme un
données à un instant t représentant (une instance) d'une classe
Ο "L'état de ma voiture est définit par le fait que sa Ο Ma voiture est une instance de la classe des voitures
couleur est grise et sa marque est Peugeot"
Intérêt des classes Points de vue et vocabulaire

● Les classes permettent la réutilisation de code Point de vue représentation des


connaissances par objets
Structure + Comportement
Ο On définit une classe une fois pour toute
Ο On instancie cette classe autant de fois que l'on Point de vue traitements
souhaite produire d'objets semblables Données + Traitements
informatisés

● Idem que les techniques de moulage pour les Point de vue conception objet
Attributs + Opérations (ex : UML)
objets manufacturés
Avec moulage chaque objet est obtenu à partir d'une
empreinte commune Point de vue programmation
Sans moulage chaque objet doit être constuit de A à Z
Champs + Méthodes objet (ex : Java)

Les défis posés par la POO

● Bien programmer avec un langage objet à


classe c'est savoir définir à la fois : Introduction à Java
Ο Des classes
Ο Des objets (instances de ces classes)
Ο Des interactions entre les objets

● Difficultés souvent rencontrées :


Ο Manquer d'abstraction (rester trop "terre-à-terre")
Ο Décomposer une problèmatique sous forme d'objets
Ο Confondre classes et objets

Historique de Java Popularité de Java

● 1990 : Projet (Oak) de Sun Microsystems ● Pas de pointeurs


Ο Maîtres mots : indépendance, orienté objet, légèreté ● Gestion autonome de la mémoire
● Unification
autour de l'objet (un maximum de
● 1995 : Essort autour d'internet chose est considéré comme objet)
Ο Succès des Applets (programmes coté client) puis des ● Vastes librairies disponibles (API)
servlets (programmes coté serveur)
● Indépendance à la plateforme d'éxécution
● Variété
d'applications : "desktop", web (client et
● 2009 : Acquisition par Oracle serveur), embarquée, carte à puce, ...
Mascotte de Java
Popularité de Java Boîte à outil standard

● Le Kit du développeur Java


Ο Java Development Kit (JDK), version 8 actuellement
Ο Téléchargable en ligne sur le site web d'oracle

● Un éditeur de code source


Ο Editeur de texte : notepad++, UltraEdit, ...
Ο Environnement de développement intégré (IDE) :
Eclipse, Dr. Java, NetBeans, ...

Etapes du développement

1 Création du code source


Ο Outil : éditeur de texte, IDE
2 Compilation du code source en bytecode
Ο Outil : compilateur Java
3 Déploiement du bytecode sur la machine cible
Ο Outil : réseaux, disques, clés, ...
4 Exécution sur la machine cible
Ο Outil : machine virtuelle Java (JVM)

Un premier exemple ... Compilation et éxécution


commande
de compilation

/**
/**
**classe
classeHelloWorld
HelloWorld
*/
*/
class
classHelloWorld
HelloWorld{{
////declaration
declarationde delalamethode
methodeprincipale
principalemain
main
static
staticvoid
voidmain(String[]
main(String[]args)
args){{
////ecriture
ecriturede
delalachaine
chainede
decaracteres
caracteres"Hello
"Helloworld
world!!!!!"!"ààl'écran
l'écran
System.out.println("Hello
System.out.println("Helloworldworld!!!!!")
!");; Bytecode
(.class)
}}
}} commande
d'éxécution

Le nom du fichier
doit être
exactement le
même que HelloWorld.java
celui de la classe
Documentation IDE "Dr Java" (Screenshot)

API Java ? Types de développement

● Application Programming Interface (API) Développement pour Développement par


la réutilisation la réutilisation
Ο Ensemble de classes (déjà compilées) mises à
disposition à travers une bibliothèque
Ο Chaque classe est proprement documentée (javadoc)
pour pouvoir être utilisée par un programmeur API
APIJava
Java66
● L'API Java version 6 en quelques chiffres : API
Créé des classes et les APIαα Créé ses classes et surtout
documente en vue de (spécifique)
(spécifique) réutilise des classes
Ο 203 paquetages, 3777 classes, 28306 méthodes leur réutilisation par existantes (grâce à leur
d'autres programmeurs documentation) afin de
● La documentation est consultable en ligne construire son programme

Ο http://download.oracle.com/javase/6/docs/api/

Équation du premier degré ? Solution sans objet

● Équation de la forme ax + b class


classResolutionEqua
ResolutionEqua{{
Ο Solution : -b / a (avec a!=0) public
publicstatic
staticvoid
voidmain(String[]
main(String[]args)
args){{
int
inta,a,b;
b; ////coefficients
coefficientsentiers
entiersde
del’equation
l’equation
double
doublesolution;
solution; ////solution
solutiondedel’equation
l’equation
////initialisation des coefficients
initialisation des coefficients
● Résolution d'une telle équation aa==-1;
-1;
bb==5;5;
Ο Solution sans objet ////calcul
calculde delalasolution
solution
● « A partir des coefficients, je réalise un calcul solution
solution==-b -b//a;a;
arithmétique pour obtenir la solution » ////affichage
affichagede delalasolution
solution
System.out.println(''La
System.out.println(''Lasolution solutionest
est''''++solution);
solution);
Ο Solution avec objet }}
● « Une equation est un objet mathématique, instance de }}
la classe des équations du 1er degré, et qui peut être
résolue par un calcul arithmétique» ResolutionEqua.java
Solution avec objet (1/2) Solution avec objet (2/2)
Définition de
la classe
des équations class
classResolutionEqua
ResolutionEqua{{
du 1er degré

class
classEquation1degre
Equation1degre{{ /*
/*Programme
Programmeprincipal
principal*/
*/
int
intaa;; public
publicstatic
staticvoid
voidmain(String[]
main(String[]args)
args){{
int
intbb;; Equation1degre
Equation1degre monEquation; ////Déclaration
monEquation; Déclarationd’un
d’unobjet
objetEquation
Equation
////Création
Créationd’une
d’unenouvelle
nouvelleéquation
équation(naissance
(naissanced'un
d'unobjet)
objet)
/*
/*Calcul
Calculdedelalasolution
solutionde
del’equation
l’equation*/
*/ monEquation = new Equation1degre();
monEquation = new Equation1degre();
double
doubleresoudre()
resoudre(){{ ////Affectation
Affectationdes
deschamps
champscoefficients
coefficients
double sol
double sol ; ; monEquation.a
monEquation.a==-1; -1;
sol
sol==-b
-b//aa;; monEquation.b
monEquation.b==5;5;
return
returnsol;
sol;
}} //Demande
//Demandedu dutraitement
traitementde derésolution,
résolution,puis
puisaffichage
affichage
double
doublesolution
solution==monEquation.resoudre();
monEquation.resoudre();
}}////fin
finde
delalaclasse
classeEquation1degre
Equation1degre System.out.println(''La
System.out.println(''Lasolution
solutionest
est''''++solution);
solution);
}}
}}////fin
finde
delalaclasse
classeEquationTest
EquationTest
Equation1degre.java
ResolutionEqua.java

Fonctionnement du typage

● En Java, tout doit être préalablement typé


Bases du langage Ο Vous oblige à savoir ce que vous allez mettre dans les
variables et les paramètres des méthodes
Ο Le compilateur est votre ami : il détecte toutes les
incompatibilités de types avant même l'éxécution

● Déclarerune variable c'est annoncer ce qu'elle


est susceptible de contenir à l'avenir
Ο int prix; Voiture maVoiture; ...

Types de bases Types et classes

● Chaque nouvelle classe offre un nouveau type,


Type Nature Taille Domaine
byte Entier signé 8 bits -128 à + 127 en plus des types de bases
short Entier signé 16 bits -32 768 à +32 767
Ο Le système de typage est donc extensible !
int Entier signé 32 bits -2 147 483 648 à +2 147 483 647
long Entier signé 64 bits ... Ο Le nom de la classe devient celui du type

float Réel 32 bits ...


double Réel 64 bits ...
● Types spécifiques de Java
Ο void : représente le néant (void en anglais)
boolean Booléen 1 bit true, false
Ο Object : représente n'importe quelle classe
char Caractère 16 bits 'A', 'T', 'b', 'z', 'u', '@', ... Ο ...
Transtypage (explicite) Les "wrapper" (enveloppes)

● Il
est possible de forcer le typage d'une valeur ● Chaque type de base possède son équivalent
pour l'affecter à une variable en classe d'objets
● Cette conversion forcée (et risquée !) d'un type Ο int → Integer Remarquez la
première lettre
à un autre est appelé "transtypage" Ο bool → Boolean en majuscule
des classes
wrapper

● La technique présuppose une certaine Ο float → Float


proximité conceptuelle entre les types Ο ...
Ο int a = (int) 45.56; // ok ● Depuisla version 5 de Java, l'équivalence de
Ο float b = (float) 89; // ok types est réalisée automatiquement
Ο boolean ok = (boolean) 89; // n'importe quoi ! Ο Technique dite d'auto-boxing

Identificateurs Us et coutumes

● Variables, méthodes, constantes, etc. sont ● Conventions de nommage usuelles


identifiés par une chaîne de caractères qui Ο Classes : 1er caractère en majuscule
peuvent être Ο Variables, méthodes : 1er caractère en minuscule
Ο des lettres : a, b, ..., z, A, B, ..., Z Ο Constantes : entièrement en majuscule
Ο des chiffres : 0, 1, ..., 9 (mais pas comme premier
caractère)
● Recommandations complètes de Sun
Ο le symbole _
Ο le symbole $
Ο Les "JavaStyle"

● Sensible ● Règles internes à chaque entreprise


à la casse (majuscule vs. minuscule)

Variables & constantes Méthodes

● Variables ● Méthodes
Ο Type identificateur [= value] ; Ο Type identificateur(Type arg1, ..., Type argN) { ... }
int a ; // déclaration
a = 5 ; // initialisation
● Deux cas de figures :
float x = 125.45 ; // déclaration et initialisation
a = (int) x ; // transtypage Ο Procédure : void identificateur(...) { ... }
Ο Fonction : Type identificateur(...) { ... return ... }
● Constantes
Ο final Type IDENTIFICATEUR = value ;
final float PI = 3.14159265;
Rq : définition versus appel Passage des paramètres

● Définir une méthode c'est ● Java transfère toujours tous les paramètres
Ο Réfléchir à sa signature : un nom cohérent, le type de d'une méthode par copie
retour, le nombre et type des paramètres formels Ο Soit une valeur dans le cas d'un type de base
Ο Réfléchir à son corps : le bloc de code (souvent un Ο Soit une référence vers une instance
algorithme) à écrire entre les accolades
● Iln'y a donc pas de passage par adresse
comme dans d'autre langages
● Invoquer (appeler) une méthode c'est
Ο L'appeler par son petit nom Java C/C++ VB
foo(int x) { … } foo(int x) { … } Sub foo(x as Integer)
Ο Lui fournir des paramètres effectifs compatibles avec foo(Voiture x) { … } foo(Voiture* x) { … } Sub foo(x as Voiture)
les paramètres formels de sa signature foo(Voiture** x) { … } Sub foo(ByRef x as Voiture)

Retour sur l'exemple Surcharge de méthodes

Définition
d'une classe Variables d'instance
● Il
est admis que plusieurs méthodes d'une
(Cf. Chapitre suivant)
class
classEquation1degre
Equation1degre{{ même classe puissent porter le même nom
int
intaa;;
int
intbb;;
Définition d'une méthode
(ici, une fonction)
● Maiselles ne peuvent pas avoir le même
double
doubleresoudre()
resoudre(){{
double
nombre ni même types de paramètres formels
doublesolsol;;
sol
sol==(-b
(-b//a)a);;
Variable locale
à la méthode return
returnsol;
sol;
}}
● Au moment de l'appel d'une méthode
}}////fin
fin de la classeEquation1degre
de la classe Equation1degre
surchargée, l'ambiguïté sera levée en fonction
des paramètres effectifs qui lui seront fournis
Equation1degre.java

Tableaux Tableaux

● Tableau à 1 dimension (vecteur) ● Un tableau est considéré comme un pseudo-


Ο Déclaration : float[] monTableau; objet
Ο Création : monTableau = new float[20]; //vecteur de 20 Ο monTableau = new float[20];
réels ● La taille d'un tableau est stocké dans son
champs length
● Tableau à 2 dimensions (matrice) Ο monTableau.length
Ο Déclaration : int[][] monTableau; ● Un tableau est indicé de 0 à N-1
Ο Création : monTableau = new int[20][20]; //matrice carrée Ο Accès vecteur : monTableau[4]
20x20 d'entiers Ο Accès matrice : monTableau[4][10]
Chaîne de caractères Opérateurs arithmétiques

● Une chaîne est considéré comme un pseudo- ● Opérateurs binaires


objet, instance de la classe String de l'API Java Symbole Fonction Champs d'application
+ addition entiers ou réels
Ο Déclaration : String message; + concaténation chaînes de caractères
- soustraction entiers ou réels
Ο Création : message = new String("Hello"); * multiplication entiers ou réels
/ division réelle réels
● La longueur d'une chaîne est renvoyée par sa / division entière entiers

méthode length() % reste de la division entière entiers

Ο message.length(); //renverra 5 ● Opérateurs unaires


Symbole Fonction Champs d'application
● L'opérateur + permet de concaténer des + plus entiers ou réels
- moins entiers ou réels
chaînes de caractères ++ pré- ou post-incrémentation entiers ou réels
-- pré- ou post-décrémentation entiers ou réels

Opérateurs logiques Opérateurs d'affectation

● Opérateurs binaires ● Opérateurs ● L'opérateur d'affectation classique est =


Symbole Fonction
relationnels Ο Mode d'emploi : identificateur = valeur;
&& ET logique
|| OU logique Symbole Fonction
Ο Exemples : a = 5; marche = true; ...
> supérieur
>= Supérieur ou égal
< inférieur
● Lavariable est à gauche de l'opérateur
● Opérateurs unaires <= Inférieur ou égal

== égal d'affectation; sa valeur est à droite !


=== identique
Symbole Fonction
!= différent
! NON logique
● A ne pas confondre avec les opérateurs
relationnels == et ===

Opérateurs d'affectation Instructions de contrôles

● Il existe d'autres opérateurs d'affectations ● SI-ALORS-SINON


Ο Ce sont des contractions d'autres opérateurs Ο if (boolean_expression) { ... } else { ... }
Ο Simplifient l'écriture de votre code
● TANT-QUE
● Exemples Ο while (boolean_expression) { ... }
Ο += , -= , *= , /= , %=, ...
Ο a += b équivaut à a = a + b ● JUSQU'A CE QUE
Ο do { ... } while (boolean_expression)
Instructions de contrôles

● POUR Objet, classe,


Ο for (init; boolean_expression; incrementation) { ... }
paquetage
● SELON
Ο switch (selecteur) { case c1: ...; case c2: ...; default:... }

Classe Equation du 2nd degré Classe Equation

class
classEquation2degre
Equation2degre{{ ● La
int
classe
intaa;; ////coeff
coeffen
enX2
X2
Equation2degre
(variables d'instance)

int
intbb;; ////coeff
coeffen
enX1
X1 Equation2degre
CHAMPS

int c ; // coeff en X0
int c ; // coeff en X0
a : int
qualifie complètement
/*
/*Calculs
Calculsdesdesracines
racinesdedel’equation
l’equation*/*/ b : int toutes les équations
c : int
double
doublecalculerRacine1()
calculerRacine1(){{ du 2nd degré :
METHODES

int discri = (b * b - 4 * a * c)
int discri = (b * b - 4 * a * c) ;; calculerRacine1() : double
return
return(-b(-b++Math.sqrt(discri))
Math.sqrt(discri))//(2 (2**a)
a);; calculerRacine2() : double Ο Les trois coefficients de
}}
l'équation (a, b, c)
double
doublecalculerRacine2()
calculerRacine2(){{
int
intdiscri
discri==(b
(b**bb--44**aa**c)c);; Représentation graphique (UML) de la Ο Les 2 calculs pour
return classe 'Equation2degre'
return(-b(-b--Math.sqrt(discri))
Math.sqrt(discri))//(2(2**a)a);; résoudre l'équation
}}
}}////fin (calculerRacine1() et
finde
delalaclasse
classeEquation
Equation
calculerRacine2())
Equation2degre.java

Ce qu'il faut retenir Retour sur l'exemple

● Depuis
sa naissance jusqu'à sa mort, un objet 3 champs qui mémorisent
class
classEquation2degre
Equation2degre{{ l'état d'un objet à un instant t
mémorise son état à travers ses champs int
intaa;;
int
intbb;;
int
intcc;;
Définition d'une méthode
(ici, une fonction)
● L'invocation
des méthodes d'un objet
double
doublecalculerRacine1()
calculerRacine1(){{
permettent (entre autres) de modifier les Usage d'une variable
locale discri
int
intdiscri
discri==(b
(b**bb--44**aa**c)c);;
valeurs de ses champs return
return(-b
(-b++Math.sqrt(discri))
Math.sqrt(discri))//(2(2**a)
a);;
}} Définition d'une autre
méthode (ici, une fonction)

double
doublecalculerRacine2()
calculerRacine2(){{……}}
● Lecorps d'une méthode peut utiliser des }}////fin
finde
delalaclasse
classeEquation2degre
Equation2degre Appel d'une méthode
(fonction) de l'API

champs de l'objet, des variables locales et des


paramètres formels pour fonctionner Equation2degre.java
Naissance d'un objet Constructeurs d'objet

● Tout objet est une instance de classe ● Chaque classe doit spécifier une ou plusieurs
instanciable (c'est-à-dire non abstraite) méthodes particulières : les « constructeurs »
● La création d'un objet est réalisée au moyen Ο Méthodes dont le rôle est d'initialiser les champs
d'un constructeur appelé au travers de Ο Méthodes nommées nécessairement comme la classe
l'opérateur new Ο Méthodes sans aucun retour, même pas Void
● L'effet de cette création est double ● Il est fortement conseillé de définir
Ο créer une instance de la classe et donc réaliser explicitement les constructeurs
l'allocation mémoire de tous les champs ● En leur abscence, Java défini
Ο renvoyer la référence de l'objet créé, ce qui permettra (automatiquement) un constructeur par défaut
de l'utiliser (l'affecter à une variable le plus souvent)
Ο Les champs sont initialisés par défaut (?)

Constructeurs d'objet Allocation mémoire

class
classEquation2degre
Equation2degre{{ ● On peut définir autant Zone de mémoire
statique
Zone de mémoire
dynamique (TAS)
int
intaa;;
int
intbb;;
de constructeurs que Equation2degre
Equation2degreeq1;eq1;
int
intcc;; l'on souhaite Equation2degre
Equation2degreeq2;eq2;
Equation2degre eq3;
Equation2degre eq3; a=2
a=2
bb==44
//Constructeur
//Constructeursans sansparamètres
paramètres Ο Autant de façons de double sol = 1.0;
double sol = 1.0;
eq1 cc==-1-1

Equation2degre()
Equation2degre(){{ construire un objet
a=0;
a=0;b=0;
b=0;c=0;
c=0; //appel
//appeldu duconstructeur
constructeur eq2
}} ● Lesconstructeurs ////avec
avecparamètres
paramètres
//Constructeur eq1 = new Equation2degre(2,4,-1);
//Constructeuravec avecparamètres
paramètres sont des méthodes ... eq1 = new Equation2degre(2,4,-1);
Equation2degre(int //appel
//appeldu duconstructeur
constructeur a=0
Equation2degre(int_a, _a,int
int_b,
_b, a=0
b=0
int
int_c)
_c){{ surchargées ! //sans
//sansparamètres
eq2
paramètres
eq3
b=0
cc==00

aa==_a; eq2==newnewEquation2degre();
Equation2degre();
_a;bb==_b;
_b;cc==_c;
_c; eq3
eq3==eq1;
}} Ο Selon les paramètres eq1;
...... fournis, le bon sol 1.0
}}//Fin
//Finde delalaclasse
classeEquation2degre
Equation2degre constructeur sera choisi
Objet Référence vers

Mort d'un objet Désallocation mémoire

● Un objet disparaît lorsque plus aucune Zone de mémoire


statique
Zone de mémoire
Dynamique (TAS)

référence sur lui n'existe


Ο L'espace qu'il occupe en mémoire peut alors être
a=2
récupéré …… eq1 null
a=2
b=4
b=4
c = -1
c = -1

● La récupération de l'espace mémoire n'est pas eq1


eq1==null;
null; null
eq2
eq2
eq2==null;
à la charge du programmeur null;

......
Ο Contrairement à d'autres langages où il existe des aa==00
b=0
b=0
opérateurs de destruction (free, release, delete, ...) eq3
cc==00

● La JVM se charge de cette opération (ramasse-


sol 1.0
miettes/garbage collecting)
Objet Référence vers
Vie d'un objet Objets vivants en mémoire

● Entre la naissance et la mort d'un objet, il est Zone de mémoire


statique
Zone de mémoire
dynamique (TAS)

possible de l'utiliser en accèdant à : Equation2degre


Equation2degreeq1;eq1;
Ο ses champs (pour les affecter ou les consulter) double
doublesol
sol==1.0;
1.0;
...... a=2
a=2
Ο ses méthodes (les invoquer) eq1 b=4
b=4
cc==-1-1

//appel
//appelduduconstructeur
constructeur
////avec eq2
avecparamètres
paramètres
● Cet eq1
eq1==new
newEquation2degre(2,4,-1);
accès repose sur une notation "pointée" Equation2degre(2,4,-1);
aa==00
Ο monEquation.a = 1; //affectation eq1.resoudre();
eq1.resoudre(); bb==00
c=0
eq3 c=0

Ο System.out.print(monEquation.a); //consultation ......

Ο double sol = monEquation.calculerRacine1(); //invocation sol 1.0

Objet Référence vers

Objets vivants en mémoire La référence nulle

Zone de mémoire
statique
Zone de mémoire
dynamique (TAS)
● Une variable est censé contenir une référence
Equation2degre
à un objet en vie (c-a-d qui existe en mémoire)
Equation2degreeq1;
eq1;
double
doublesol
sol==1.0;
1.0; Ο Si tel n'est pas le cas, chaque accès aux membres de
...... aa==22
eq1 bb==44
c = -1
l'objet produira une exception NullPointerException au
c = -1
//appel
//appelduduconstructeur
constructeur
moment de l'éxécution du programme
////avec eq2
avecparamètres
paramètres ● On peut affecter volontairement une référence
eq1 = new Equation2degre(2,4,-1);
eq1 = new Equation2degre(2,4,-1);
aa==00
nulle à une variable
sol
sol==eq1.calculerRacine1();
eq1.calculerRacine1(); bb==00

eq3
cc==00 Ο monEquation = null; //affectation
......
Ο if (monEquation == null) { ... } //comparaison
sol -23.256

Objet Référence vers

Notion de visibilité Visibilité : exemple


public
publicclass
classEquation2degre
Equation2degre{{
● Il est possible de réguler l’accès (la portée) aux public
publicint
intaa; ;
private
privateint
intbb; ;
champs et aux méthodes d'un objet ……
public
public voidcalculerRacine1()
void calculerRacine1(){{……}}
● Pour cela, Java offre 3 niveaux de visibilité private
privatevoid
voidafficher()
afficher(){{System.out.print(b);
System.out.print(b); }}//possible
//possiblecar
caraccès
accèsdepuis
depuisl'intérieur
l'intérieur

Visibilité Portée Mot clé Java }}////fin


finde
delalaclasse
classeEquation2degre
Equation2degre
Publique Partout public (par défaut)
public
publicclass
classTestEquation
TestEquation{{
Privé Uniquement à l'intérieur de la classe private
Restreint A l'intérieur de la classe et les sous- protected public
publicvoid
voidmain(String[]
main(String[]args)
args){{
classes (Cf. héritage) Equation2degre
Equation2degreeq eq==new
newEquation2degre();
Equation2degre();//Création
//Créationd'une
d'uneequation
equation
eq.a
eq.a = -1; //possiblecar
= -1; //possible carvariable
variablepublique
publique
eq.b
eq.b==6;6; //impossible
//impossiblecar
carvariable
variableprivée
privée
System.out.print(eq.calculerRacine1());
System.out.print(eq.calculerRacine1()); //possible
//possiblecar
carméthode
méthodepublique
publique
● L'interface d'un objet se dit de ce qui est eq.afficher();
eq.afficher(); //impossible
//impossiblecar carméthode
méthodeprivée
privée
}}
publique (accèssible depuis "l'extérieur") }}
Encapsulation Accesseurs et mutateurs

● Il
est raisonnable de tenter d'encapsuler les ● Par convention, pour chaque champs
données Ο Mutateur : public void setNom-du-champs(Type val)
Ο Signifie rendre privé les champs Ο Accesseur : public Type getNom-du-champs()
Ο Signifie rendre publique les méthodes jugées utiles
depuis l'exterieur
public
publicclass
classEquation2degre
Equation2degre{{
● De ce fait, il ne devient possible d'utiliser un private
privateint
intaa;;
……
objet qu'à travers ses méthodes publiques
public
publicvoid
voidsetA(int
setA(int_val)
_val){{aa==_val;
_val;}}
Ο Certaines méthodes (les "mutateurs") serviront alors public
publicint
intgetA()
getA(){{return
returna;a;}}
spécialement à affecter les champs.
}}////fin
finde
delalaclasse
classeEquation2degre
Equation2degre
Ο Certaines méthodes (les "accesseurs") serviront alors
spécialement à consulter les champs.

Accesseurs et mutateurs Classe Equation encapsulée

public
publicclass
classEquation2degre
Equation2degre{{ Equation2degre Equation2degre
private
privateint intaa; ;
...... - a : int
public - b : int
publicvoidvoidsetA(int
setA(int_val)
_val){{aa==_val;
_val;}} + Equation()
public - c : int
publicint intgetA()
getA(){{return
returna;a;}} + Equation(int a, int b, int c)
+ afficher() : void
}}////fin
finde
delalaclasse
classeEquation2degre
Equation2degre
+ Equation()
+ Equation(int a, int b, int c)
public
publicclass
classTestEquation
TestEquation{{ Interface correspondant à la classe
+ afficher() : void
- calculDiscri() : int
public
publicstatic
staticvoid
voidmain(String[]
main(String[]args)
args){{ - calculerRacine1() : double
Equation2degre
Equation2degreeq1; eq1; - calculerRacine2() : double
eq1 = new Equation2degre();
eq1 = new Equation2degre(); Les accesseurs
et mutateurs
eq1.a -1; ////impossible
eq1.a==-1; impossiblede del'affecter
l'affecterdirectement
directement!! ne sont pas
eq1.setA(-1); représentés pour
eq1.setA(-1); //affecte
//affectelelechamps
champsviaviason
sonmutateur
mutateur Vue complète de la classe des raisons de place
System.out.println(eq1.getA());
System.out.println(eq1.getA());
}}
}}

this (Objet courant) this (Objet courant)

● Quand public
publicclass
classEquation2degre
Equation2degre{{
à l’intérieur d’une classe, on accède à private
privateint intaa;;
un champs ou une méthode sans l’avoir préfixé, private
privateint intb;
b;
on fait référence de manière implicite à l’objet ......

courant (on parle aussi d’instance courante) public


publicvoid
voidsetA(int
setA(inta)a){{aa==a;a;}} //correct
//correctmais
maisambigü
ambigü
public
publicint
intgetA()
getA(){{return
returna;a;}}

public
publicvoid
voidsetB(int
setB(intb)b){{this.b
this.b==b;
b;}}//non
//nonambigü
ambigü
● Dans certains cas, il peut être commode de public
publicint
intgetB()
getB(){{return
returnthis.b;
this.b;}}
faire référence explicitement à l’objet courant : public
publicvoid voidcalculerRacine1()
calculerRacine1(){{
this int
intdiscri
discri==this.getB()
this.getB()**this.getB()
this.getB()**--44**...;
...;
......
}}
}}////fin
finde
delalaclasse
classeEquation2degre
Equation2degre
Membre d'instance/de classe Membre d'instance/de classe

● Les
membres d'une classe (champs et les ● Par défaut, tout membre est d'instance
méthodes) sont dits ● Pour le rendre de classe, on utilise le mot clé
Ο D'instance : s'ils sont propres à chaque objets static
Ο De classe : s'ils sont liés à la classe (et non aux objets) Une variable de
classe sert de
variable globale
● Conséquence lors de l'utilisation public
publicclass
classMath
Math{{ au programme

Ο Un membre d'instance nécessite la création d'un objet public


publicstatic
staticdouble
doublesqrt(Number
sqrt(Numbern)
n){{……}}
pour être utilisé
}} public
publicclass
classEquation2degre
Equation2degre{{
● monEquation.afficher(); //monEquation est bien un objet
Ο Pour un membre de classe, la classe suffit public
publicvoid
voidafficher()
afficher(){{……}}
Une méthode
de classe ne peut
● Math.sqrt(9); //Math est bien une classe de l'API pas utiliser
des membres
}}
d'instance

La méthode Main Lancer un programme

● Laméthode main est le "point d'entrée" dans un ● Considérons que la méthode main se trouve
programme dans la classe MaClasse

● Elle
figure obligatoirement dans une de vos ● Deux façons de lancer le programme
classes
Ο java MaClasse : invoque implicitement la méthode main
Ο Peu importe quelle est cette classe se trouvant dans la classe. Une erreur se produit si la
Ο C'est une méthode de classe (static) méthode n'est pas présente.
Ο MaClasse.main(new String[]{}) : invoque explicitement la
méthode de classe nommée main. Testez dans la
● Sa signature standard est la suivante : console Dr Java par exemple.
Ο public static void main(String[] args)

Organisation des classes Paquetage

● Hiérarchie "physique" : paquetage ● On regoupe dans un paquetage des classes


Ο Organisation arborescente similaire aux dossiers (sous- ayant une thématique et/ou des fonctionnalités
dossiers) et fichiers communes
Ο interface graphique, accès aux BDD, sécurité, ...
● Hiérarchie "sémantique" : héritage (Cf. Chapitre ● Un paquetage contient des classes, mais aussi
suivant) des sous-packages et ainsi de suite
Ο Organisation de filiation entre des classes ● Utiliser des paquetages améliore la sécurité
conceptuellement proches
d’utilisation des classes en renforçant encore
plus l’encapsulation
API Java : paquetages Déclaration de paquetages

● Accès par une ● Utilisation du mot clé package


java notation pointée
package
packagefr.univpau.stid.exemple;
fr.univpau.stid.exemple; si on ne précise rien,
Ο java.awt.event on est dans le
paquetage par défaut,
public
publicclass classEquation
Equation{{ constitué de
l’ensemble des classes
...... du répertoire courant
}}////fin
finde delalaclasse
classeEquation
Equation
applet awt lang math ● Chaque paquetage
correspond à un
dossier de même ● La classe (source+compilée) sont dans :
nom Ο <rep_courant>/fr/univpau/stid/exemple/Equation.java
event image peer
Ο java/awt/event/ Ο <rep_courant>/fr/univpau/stid/exemple/Equation.class

Paquetages : conventions Notion de visibilité


● Il est possible de réguler l’accès (la portée) aux
● Le nom des paquetages commence par une
minuscule classes d'un paquetage
● Pour cela, Java offre 2 niveaux de visibilité
Visibilité Portée Mot clé Java
● On définit souvent plusieurs niveaux Publique Partout public (par défaut)
(paquetages et sous-paquetages) Privé Uniquement à l'intérieur du paquetage private
Ο <organisation>.<domaine>.<projet>.<module>.<...>
package
packagefr.univpau.stid.exemple;
fr.univpau.stid.exemple;
Ici, on décide que la classe
public
publicclass classEquation2degre
Equation2degre{{
● Par ex, le paquetage fr.univpau.stid.poo.tp1 Equation2degre sera
accessible lorsque son ......
paquetage sera importé
contiendra vos classes compilées du TP1 }}////fin
finde delalaclasse
classeEquation2degre
Equation2degre

Importation de paquetages Importation par défaut

● Pourutiliser une classe appartenant à un ● Implicitement toute classe a accès au


package, soit paquetage java.lang
Ο Vous utilisez le nom complet de la classe à chaque fois ● Il est importé par défaut, c'est le coeur du
fr.univpau.stid.exemple.Equation2degre eq1 = new
● langage Java
fr.univpau.stid.exemple.Equation2degre();
● Il contient les types de base et les concepts
Ο Vous importez la classe depuis son paquetage en
début de programme (une fois pour toute) primitifs du langage
● import fr.univpau.stid.exemple.Equation2degre; //import Ο System
de la classe Equation2degre Ο Integer
● import fr.univpau.stid.exemple.*; //import de toutes les Ο Object
classes (publiques) du paquetage exemple
Ο ...
Classes internes et classes
anonymes
● Il
existe deux autres types de classes qui Héritage, classe
permettent de se faciliter la vie dans certains
cas : les classes internes et celles anonymes abstraite, interface
● Pas vraiment conseillé pour débuter !
● Classe interne
Ο La classe est définie à l'intérieur d'une autre classe.
● Classe anonyme
Ο La classe ne porte pas de nom, seules les méthodes et
leur implémentation sont données.

Organisation des classes Héritage

● Hiérarchie "physique" : paquetage ● Le mécanisme d’héritage va permettre


Ο Organisation arborescente similaire aux dossiers (sous- d’étendre des classes existantes
dossiers) et fichiers

● Une sous-classe hérite de sa super-classe :


● Hiérarchie "sémantique" : héritage
Ο elle possède tous les membres (champs et méthodes)
Ο Organisation de filiation entre des classes publics et protégés de sa super-classe
conceptuellement proches
Ο elle peut bien sûr avoir de nouveaux membres

● Une classe ne peut avoir qu’une super-classe

Hiérarchie d'héritage Carré "est un" Rectangle

● Cette relation sous/super-classes forme une Rectangle public


publicclass
classRectangle
Rectangle{{
double
doublelongueur
longueur;;
hiérarchie d'héritage longueur : double double
doublelargeur
largeur;;
largeur : double Rectangle(double
Rectangle(doubleL,L,double
doublel)l){...}
{...}
Rectangle(L: double, l: double)
double
doubleperimetre()
perimetre(){...}
{...}
FormeGeometrique On peut voir
l’héritage perimetre() : double double
doublesurface()
surface(){...}
{...}
comme une surface() : double }}////fin
finde
delalaclasse
classeRectangle
Rectangle
relation
“est un”

Rectangle.java
Rectangle Ellipse Triangle

Carre public
publicclass
classCarre
Carreextends
extendsRectangle
Rectangle{{
Carre(double
Carre(doublec)c){{……}}
Carre Cercle }}////fin
finde
delalaclasse
classeCarre
Carre
Carre(c: double)
Carre.java
Héritage : avantages Factorisation de code

● Factorisation de code public


publicclass
classCarre
Carreextends
extendsRectangle
Rectangle{{
Ο Une sous-classe possède les membres (hormis les //ajout
//ajoutd'une
d'uneméthode
méthodespécifique
spécifique public
publicclass
classTestHeritage
TestHeritage{{
constructeurs) de sa super-classe, même si ils public
publicvoid
voidafficherSurface()
afficherSurface(){{
n'apparaissent pas explicitement System.out.print(''La
System.out.print(''Lasurface
surfacevaut
vaut:'');
:''); public
publicstatic
staticvoid
voidmain(...)
main(...){{
System.out.println(this.surface());
System.out.println(this.surface()); Rectangle
Rectangler1;r1;
Ο On accède aux membres hérités de manière tout à fait }} r1
r1==new
newRectangle(2.5,
Rectangle(2.5,7.0);
7.0);
transparente }}////fin
finde
delalaclasse
classeCarre
Carre r1.largeur
r1.largeur==45.23;
45.23;

● Réutilisation de code Carre


Carrec1;
c1;
Carre.java c1
c1==new
newCarre(12.0)
Carre(12.0)
Ο Les méthodes d'une sous-classe peuvent invoquer les c1.afficherSurface();
c1.afficherSurface();
méthodes de la super-classe
}}
Ο Idem pour les constructeurs }}//fin
//finde
delalaclasse
classede
detest
test

TestHeritage.java

Réutilisation de code (1/2) Réutilisation de code (2/2)

● Au même titre que le mot clé this permet de ● On doit obligatoirement définir des
faire référence à l'objet en cours, le mot clé constructeurs ad-hoc dans la sous-classe
super permet de désigner la super-classe Carre.java

public
publicclass
classCarre
Carreextends
extendsRectangle
Rectangle{{
public
publicclass
classCarre
Carreextends
extendsRectangle
Rectangle{{ public
publicclass classRectangle
Rectangle{{ Carre(double
Carre(doublec)c){{
...... this.longueur
this.longueur==c;c;
//ajout Rectangle(double
Rectangle(doubleL,L,double doublel)l){{
//ajoutd'une
d'uneméthode
méthode this.largeur
this.largeur==c;c;
public
publicvoid
voidafficherSurface()
afficherSurface(){{ this.longueur
this.longueur==L;L; }}
System.out.print(''La
System.out.print(''Lasurface
surfacevaut
vaut:''); this.largeur
this.largeur==l;l; }}////fin
:''); finde
delalaclasse
classeCarre
Carre
System.out.println(super.surface());
System.out.println(super.surface()); }}
}} ...... OUpublic class Carre extends Rectangle {
public class Carre extends Rectangle {
}}////fin }}////fin
finde delalaclasse
classeRectangle Carre(double
Carre(doublec)c){{
finde
delalaclasse
classeCarre
Carre Rectangle
super(c,c);
super(c,c);
Rectangle.java }}
Carre.java }}////fin
finde
delalaclasse
classeCarre
Carre

Redéfinition de méthode Redéfinition de méthode

● Ilest possible de redéfinir dans une sous- System.out.println(''Je suis une forme geométrique'');

classe une méthode définie dans la super- FormeGeo


classe afficher()

System.out.println(''Je suis un rectangle'');

● La signature de la méthode doit être strictement Rectangle


identique (≠ surcharge de méthode) afficher()

System.out.println(''Je suis un carré'');

● Le corps de la méthode est changé librement Carre


afficher()
Héritage & Transtypage Transtypage (implicite)

● La proximité conceptuelle entre les types ● Habituellement,


on déclare une variable du
nécessaire au transtypage est naturellement même type que la valeur que l'on y stocke
incarnée par la hiérarchie d'héritage entre les Ο int prix = 15; boolean marche = true;
classes Ο Equation eq1 = new Equation();

● Le transtypage est implicite par défaut ● Avec l'héritage, on peut désormais déclarer une
Ο Il est toujours possible de stocker un objet d'un type variable dont le type est un super-type (direct
dans une variable d'un super-type (voir diapo suivante) ou indirect) de la valeur que l'on y stocke
Ο Rectangle r = new Carre(); Cf. la
relation
● Il peut être explicite dans certains cas Ο FormeGeometrique f = new Carre(); ''est-un''

Type déclaré vs. type réél Type déclaré vs. type réél

FormeGeometrique ● On ne peut néanmoins programmer que sur la


base de l'interface du type déclaré

Rectangle Ellipse Triangle Rectangle


longueur : double Rectangle
Rectangler1;
r1;
largeur : double

perimetre() : double r1
r1==new
newCarre();
Carre();
surface() : double
Carre Cercle
FormeGeometrique r1.perimetre();
FormeGeometriquef1,
f1,f2,
f2,f3;
f3; r1.perimetre();
r1.test();
r1.test();
f1 r1.couleur
r1.couleur==67575;
f1==new
newFormeGeometrique();
FormeGeometrique(); Carre
67575;
f2 newEllipse();
f2==new Ellipse();
f3 = new Cercle();
f3 = new Cercle(); couleur : long

test()

Liaison dynamique Liaison dynamique : exemple

● Cas d'une hiérarchie de classes où une FormeGeo


méthode a été successivement redéfinie afficher()
FormeGeometrique
FormeGeometriquef1,
f1,f2,
f2,f3;
f3;

f1
f1==new
newFormeGeometrique();
FormeGeometrique();
● Le vrai type de l'objet est déterminé à Rectangle f2
f2==new
newRectangle();
Rectangle();
f3
f3==new
newCarre();
Carre();
l'éxécution pour invoquer la bonne méthode : afficher()

cette stratégie est appelée "liaison dynamique" f1.afficher();


f1.afficher();
f2.afficher();
f2.afficher();
f3.afficher();
f3.afficher();
Carre
● C'estdonc la méthode du type réel qui est afficher()

invoquée, pas celle du type déclaré


Hiérarchie d'héritage en Java Redéfinitions usuelles

● En java, la racine de la hiérarchie d'héritage est ● Souvent, on redéfini deux méthodes héritées de
une classe standard nommée "Object" la classe Object
Ο String toString()
Object ● Pour renvoyer une représentation textuelle de l'objet
● Permet d'utiliser simplement System.out.print(...) par
exemple
public
publicclass classTest
Testextends
extendsObject
Object{{
... Test ...... Ο boolean equals(Object obj)
}}////fin
finde delalaclasse
classeTest
Test ● Pour définir une technique de comparaison propre à
l'objet
Inutile car ● D'autres classes de l'API se base sur cette comparaison
... ... par défaut
pour pouvoir fonctionner par exemple

Classe abstraite Classe et méthode abstraite

● Ilest possible de définir volontairement des


public
publicabstact
abstactclass
classFormeGeo
FormeGeo {{
classes non-instanciables
protected
protectedint
intcouleur
couleur;; 3 méthodes sans corps

public
publicabstract
abstractdouble
doubleperimetre()
perimetre();;
● Ellesconservent néanmoins leur utilité au public
publicabstract
abstractdouble
doublesurface()
surface();;
niveau factorisation et réutilisation de code publicabstract
public abstractvoid
voidafficher()
afficher();;

public
publicvoid
voidchangerCouleur(int
changerCouleur(intcouleur)
couleur){{
this.couleur
this.couleur==couleur
couleur;; Il suffit d'une seule
méthode abstraite
● A ladifférence avec les classes normales (dites }} pour rendre la
classe abstraite
}}////fin
finde
delalaclasse
classeFormeGeo
FormeGeo
contrètes), elles peuvent possèder des
méthodes abstraites (c-a-d sans corps)
FormeGeo.java

Redéfinition de méthodes
Héritage de classe abstraite
abstraites
● Lessous-classes d'une classe abstraite
peuvent être public
publicabstract
abstractclass
classFormeGeo
FormeGeo {{ public
publicclass
classRectangle
Rectangleextends
extendsFormeGeo
FormeGeo {{
protected
protectedint
intcouleur
couleur; ; public
Ο Concrètes si elles fournissent le corps manquant de publicdouble
doubleperimetre()
perimetre() {{……}}
public
publicdouble
doublesurface()
surface() {{……}}
toutes les méthodes abstraites héritées, via la public
publicabstract
abstractdouble
doubleperimetre()
perimetre(); ; public
publicvoid
voidafficher()
afficher() {{……}}
redéfinition de méthodes (Cf. précédemment) public
publicabstract
abstractdouble
doublesurface()
surface(); ;
public
publicabstract
abstractvoid
voidafficher()
afficher(); ; }}////fin
finde
delalaclasse
classeRectangle
Rectangle
Ο Abstraites si elles le font en partie ou pas du tout,
laissant alors le soin à leur sous-classes de le faire, et public
publicvoid
voidchangerCouleur(int
changerCouleur(intcouleur)
couleur){{
this.couleur
this.couleur==couleur
couleur; ;
ainsi de suite }}
Rectangle.java
}}////fin
finde
delalaclasse
classeFormeGeo
FormeGeo
Fournit les corps
manquants dans
● Logiquement, on trouve les classes abstraites la super-classe
FormeGeo.java
plutôt "en haut" dans la hiérarchie d'héritage
Vers le concept d'Interface Interface : définition

● On l'a vu, la notion d'interface est formée par ● Uneinterface n'est pas une classe : elle n'a pas
les membres publiques – notamment les vocation à être instanciée
méthodes – d'un objet
● Une interface stipule un ensemble de méthodes
● En Java, cette notion a été réifiée pour en faire Ο Nécessairement abstraites (c-a-d sans corps)
un concept supplémentaire du langage Ο Nécessairement publiques

● En pratique, classes et interfaces sont des ● Uneinterface ne contient pas de champs (sauf
concepts complémentaires des constantes)

Interface : exemples Interface : typage

● Une classe peut implémenter une ou plusieurs ● Une interface est une sorte de contrat qu'une
interfaces classe devra respecter (on dit "implémenter")
● A ce titre, elle offre une sorte de super-type vis-
public
publicinterface
interfaceHero
Hero {{ class
classBatman
Batmanimplements
implementsHero,
Hero,SuperHero
SuperHero {{ à-vis des classes qui l'implémentent, même si il
public
publicvoid
public
voidfight()
fight(); ; Hero.java public
publicvoid
voidfight()
fight() {{……}} n'y a pas de proximité conceptuelle comme
publicvoid
voidjump();
jump(); public
publicvoid
voidjump()
jump() {{……}}
public
public void fly() {{……}}
void fly() avec l'héritage
}}////fin
finde
del'interface
l'interfaceToto
Toto
}}////fin
finde
delalaclasse
classeEssai
Essai ● Avec l'exemple précédent, on pourra écrire :
public
publicinterface
interfaceSuperHero
SuperHero {{ Ο Hero a = new Batman();
Batman.java
public
publicvoid
voidfly(); SuperHero.java
fly(); Ο SuperHero b = new Batman();
}}////fin
finde
del'interface
l'interfaceTiti
Titi

Interface : us et coutumes Les cas "borderline"

● Une interface, en plus d'être techniquement un ● Certaines


classes sont déclarées abstraites,
contrat, dénote sémantiquement une capacité sans même contenir de méthodes abstraites !
Ο Convention de nommage avec le suffixe "-able" Ο L'idée est d'empêcher toute instanciation pour des
Ο Exemples : serializable, comparable, printable, raisons qui appartiennent au développeur de la classe
rezisable, sortable, editable, ... ● Certaines interfaces ne contiennent rien !
● Il est toujours possible d'extraire l'interface (la Ο Elles sont dites "de marquage". Elle servent juste à
notion) de chaque classe sous forme d'une donner des indications sémantiques sur une classe
interface (le concept) ● Certainesclasses abstraites n'ont pas de sous-
Ο Bonne pratique pour garantir l'évolutivité du code classes concrètes
Ο Très utilisé dans les "cadriciels" modernes Ο L'idée est de laisser ces classes comme "points
d'extension" pour des développements futurs
Polymorphisme ?

● EnPOO, vous entendrez souvent parler de Interface graphique


"polymorphisme". Mais à force, ce terme est
devenu galvaudé. avec Swing
● On distingue généralement trois types de
polymorphisme :
Ο polymorphisme ad hoc : lié à la surcharge de méthode
Ο polymorphisme d'héritage : lié à la redéfinition de
méthode
Ο polymorphisme paramétrique : lié à la généricité de
classe et de méthode (non abordée dans ce cours)

Interface graphique ? Comment programmer ?

● GUI (Graphical User Interface) en anglais ● Soit on programme "à partir de zéro"
● Facade visuelle qui lie un programme avec Ο Tout le code doit être écrit par vos soins
l’extérieur et qui facilite les interactions avec le Ο Nécessite une bonne compréhension de l'API
ou les utilisateurs du programme graphique de Java

● Uneinterface graphique nécessite d'être


programmée : ● Soit on s'appuie sur des IDEs spécifiques
Ο Le code est partiellement généré automatiquement
(Approche "wysiwyg" : What you see is what you get !)
WIDGETS
WIDGETS + LAYOUTS
LAYOUTS + EVENTS
EVENTS Ο Permet de se concentrer sur l'ergonomie de l'interface
Quels composants Comment disposer les Comment gérer les
graphiques ? widgets ? actions de l'utilisateur ?

GUI en Java Look'n'Feel adaptatif

● Onva faire appel à l’API Java pour développer ● Rappel : un programme


des interfaces graphiques. Java est indépendant
● Paquetages spécifiques à importer : de la plateforme (OS)
Ο import java.awt.* ;
Ο import java.awt.event.* ; ● L'apparence du GUI
Ο import javax.swing.* ; s'adapte aux codes
esthétiques de la
plateforme où le
● Ainsi,
on va "mixer" les deux paquetages programme est exécuté
nommés AWT et SWING
Composants graphique avec
Hiérarchie d'héritage
Swing : les "Widgets"
● JButton (bouton) ● JTable (tableau) ● Lesclasses de composants graphique forment
● JCheckBox (case à ● JTree (arborescence) une hiérarchie d'héritage
cocher) ● JMenuBar, JMenu,
● JRadioButton, JMenuItem (barre de
ButtonGroup (boutons menu)
radios) ● JFrame (fenêtre)
● JComboBox (Liste
● JOptionPane (boîte de
déroulante)
dialogue)
● JLabel (étiquette de ● ...
texte), JTextField (champ
de saisie)

Fenêtre Boîtes de dialogue (1/2)

import
importjavax.swing.*;
javax.swing.*;
JOptionPane.showMessageDialog(f,
JOptionPane.showMessageDialog(f,
public
publicclass
classTestGUI
TestGUI{{ "Un
"Unmessage
messageinformatif")
informatif"); ;
public
publicstatic
staticvoid
voidmain(String[]
main(String[]args)
args){{

JFrame
JFrameff==new
newJframe();
Jframe();
f.setTitle("Test"); JOptionPane.showMessageDialog(f,
JOptionPane.showMessageDialog(f,
f.setTitle("Test");
f.setSize(400,400); "Un
"Unmessage
messagede
dewarning",
warning",
f.setSize(400,400);
f.setVisible(true); "Titre
"TitreWarning",
Warning",
f.setVisible(true);
JOptionPane.WARNING_MESSAGE)
JOptionPane.WARNING_MESSAGE); ;
}}

}}//fin
//finde
delalaclasse
classeTestGUI
TestGUI JOptionPane.showMessageDialog(f,
JOptionPane.showMessageDialog(f,
"Un
"Unmessage
messaged’erreur",
d’erreur",
"Titre
"TitreErreur",
Erreur",
JOptionPane.ERROR_MESSAGE)
JOptionPane.ERROR_MESSAGE); ;
TestGUI.java

Boîtes de dialogues (2/2) Positionner les Widgets


int
intconfirm
confirm==JOptionPane.showConfirmDialog(f,
JOptionPane.showConfirmDialog(f,
"Est-ce
● Les
composants graphiques se positionnent
"Est-ceque
quevous
vousetes
etessur
sur?");
?");

ifif(confirm
dans des “panneaux” (JPanel).
(confirm== ==JOptionPane.YES_OPTION)
JOptionPane.YES_OPTION){{
/*
/*traitement
traitementouioui*/
*/
}}else ● Une fenêtre est composé d’un panneau :
elseifif(confirm
(confirm==
==JOptionPane.NO_OPTION)
JOptionPane.NO_OPTION){{
/*
/*traitement
traitementnonnon*/*/
}}else
elseifif(confirm
(confirm==
==JOptionPane.CANCEL_OPTION)
JOptionPane.CANCEL_OPTION){{
Ο f.setContentPane(JPanel panel);
/*
/* traitement cancel*/
traitement cancel */
}} ● La position des éléments dans un panneau
dépend du système de “placement” choisi pour
le panneau considéré : le layout
String
Stringstr
str==JOptionPane.showInputDialog(f,
JOptionPane.showInputDialog(f, ● Un panneau peut contenir d’autres panneaux.
"Quel
"Quelest
estton
tonnom,
nom,etranger
etranger?")
?"); ;
/*
/* traitementde
traitement delalachaîne
chaînestr
str*/
*/
Les layouts de placements Les layouts

● FlowLayout() – par défaut ● Il faut voir un layout comme un calque de


Ο Les composants sont ajoutés à la suite les uns des autres, de découpage apposé sur un panneau
gauche à droite et de haut en bas.
● BorderLayout()
Je peux y mettre
Ο Le panneau est découpé en 5 zones : CENTER, NORTH, un widget ou
SOUTH, EAST, WEST un autre panneau,
GridLayout
et ainsi de suite...
Ο Lors de l’ajout, on précise la zone. de 5 x 5

● GridLayout(rows, columns)
Ο Le panneau est découpé en un tableau de rows x columns
cellules.
Ο Les composants sont ajouté successivement dans chacune des
cellules.

FlowLayout : exemple BorderLayout : exemple


import
importjavax.swing.*;
javax.swing.*;
import
importjavax.swing.*;
javax.swing.*; import
importjava.awt.BorderLayout;
java.awt.BorderLayout;
import
importjava.awt.FlowLayout;
java.awt.FlowLayout;
public
publicclass
classTestGUI
TestGUI{ {
public
publicclass
classTestGUI
TestGUI{ {
disposition ''flow'' ……
……
JFrame
JFramef f==new
newJFrame();
JFrame();
JFrame
JFramef f==new
newJFrame();
JFrame(); f.setTitle("Test");
f.setTitle("Test");
f.setTitle("Test");
f.setTitle("Test"); f.setSize(400,400);
f.setSize(400,400);
f.setSize(400,400);
f.setSize(400,400); f.setVisible(true);
f.setVisible(true);
f.setVisible(true);
f.setVisible(true);
JPanel panneau==new
JPanelpanneau newJPanel();
JPanel();
JPanel
JPanelpanneau
panneau==new
newJPanel();
JPanel(); BorderLayout
BorderLayoutplacement
placement==new
newBorderLayout();
BorderLayout();
FlowLayout placement==new
FlowLayoutplacement newFlowLayout();
FlowLayout(); panneau.setLayout(placement);
panneau.setLayout(placement);
//Affecte
//Affecteune
unedisposition
dispositionau
aupaneau
paneau
panneau.setLayout(placement);
panneau.setLayout(placement);
panneau.add(newJButton("Bienvenue"),
panneau.add(new JButton("Bienvenue"),BorderLayout.NORTH);
BorderLayout.NORTH);
panneau.add(new
panneau.add(newJButton("chez"),
JButton("chez"),BorderLayout.SOUTH);
BorderLayout.SOUTH);
panneau.add(new
panneau.add(newJButton("Bienvenue"))
JButton("Bienvenue")); ; panneau.add(new
panneau.add(newJButton("les"),
JButton("les"),BorderLayout.EAST);
BorderLayout.EAST);
panneau.add(new
panneau.add(newJButton("chez"))
JButton("chez")); ; panneau.add(new
panneau.add(newJButton("ch'tis"),
JButton("ch'tis"),BorderLayout.WEST);
BorderLayout.WEST);
panneau.add(newJButton("les
panneau.add(new JButton("lesch'tis
ch'tis!!"))
!!")); ;
panneau.add(newJButton("!!!!"),
panneau.add(new JButton("!!!!"),BorderLayout.CENTER);
BorderLayout.CENTER);
//Affecte
//Affectelelepanneau
panneauààlalafenetre
fenetre
S'adapte au f.setContentPane(panneau);
f.setContentPane(panneau);
f.setContentPane(panneau);
f.setContentPane(panneau);
redimensionnement
de la fenetre ......
......
} }//fin
//finde
delalaclasse
classeTestGUI
TestGUI } }//fin
//finde
delalaclasse
classeTestGUI
TestGUI

GridLayout : exemple Les évènements


import
importjavax.swing.*;
javax.swing.*;
import
importjava.awt.GridLayout;
java.awt.GridLayout; ● Il faut maintenant programmer les choses à
public
publicclass
classTestGUI
TestGUI{ { faire en réponse aux actions de l'utilisateur
……
JFrame
JFramef f==new
newJFrame();
f.setTitle("Test");
JFrame(); Ο « Si l'utilisateur clique sur tel bouton, alors il faut
f.setTitle("Test");
f.setSize(400,400);
f.setSize(400,400);
f.setVisible(true);
afficher tel message dans telle zone de texte »
f.setVisible(true);
3
JPanel
JPanelpanneau
panneau==new
newJPanel();
JPanel();
● On parle parfois de "programmation
GridLayout
GridLayoutplacement
placement==new
newGridLayout(3,2);
GridLayout(3,2);
panneau.setLayout(placement);
panneau.setLayout(placement); évènementielle" pour faire référence à cette
panneau.add(new
panneau.add(newJButton("test1"));
panneau.add(new
JButton("test1"));
panneau.add(newJButton("test2"));
JButton("test2"));
approche par actions/réactions
panneau.add(new
panneau.add(newJButton("test3"));
JButton("test3"));
panneau.add(new JButton("test4"));
panneau.add(new JButton("test4"));
panneau.add(new
panneau.add(newJButton("test5"));
JButton("test5"));
● L'API Java vous fournit pour cela un système
panneau.add(newJbutton("test6"));
panneau.add(new Jbutton("test6"));
f.setContentPane(panneau);
d'écouteurs (ang. Listener) d'évènements
f.setContentPane(panneau);
...... 2
} }//fin
//finde
delalaclasse
classeTestGUI
TestGUI
Les écouteurs : principes Les écouteurs : principes

● Approche écouteur/ecouté ● La mise en oeuvre de ce système est très


Ο Tout widget est susceptible d'émettre un évènement encadré
lorsque celui est sollicité par l'utilisateur de différentes Ο Vos classes écouteurs doivent implémenter des
manières (clic souris, saisie clavier, etc.) interfaces pré-définies pour s'assurer contractuellement
Ο Vous allez alors créer des objets spéciquement "à qu'elle contiennent bien du code à éxécuter dans le cas
l'écoute" de ces types d'évènements, qui contiendront où certains types d'évènements surgissent
le code à exécuter lorsqu'ils surviennent Ο Le corollaire c'est qu'un widget n'accepte d'être écouté
que par des objets qui remplissent ce contrat
● Un même widget peut avoir plusieurs objets ● A tout moment dans le programme, on peut
écouteurs, qui sont autant de façons différentes décider de créer une relation d'écouteur/écouté,
de réagir à l'évènement qui s'est produit ou bien de détruire cette relation

Clic sur un bouton (1/2) Clic sur un bouton (2/2)


import
importjavax.swing.*;
javax.swing.*;
import
importjava.awt.GridLayout; import
java.awt.GridLayout; importjavax.swing.*;
javax.swing.*;
import
importjava.awt.event.ActionListener;
java.awt.event.ActionListener;
API Java public
publicclass
classTestGUI
TestGUI{ {
…… public
JPanel publicclass
classReaction1ClicBouton
Reaction1ClicBoutonimplements
implementsActionListener
ActionListener{ {
JPanelpanneau
panneau==newnewJPanel();
JPanel();
FlowLayout placement==new
FlowLayoutplacement newFlowLayout(); public
<<interface>> panneau.setLayout(placement);
FlowLayout(); publicReaction1ClicBouton()
Reaction1ClicBouton(){ {
panneau.setLayout(placement); //rien
//rienpour
pourl'instant
l'instant
JButton ActionListener …… }}

** actionPerformed(ActionEvent e) Jbutton
Jbuttonb1
b1==new
newJbutton(''Cliquez
Jbutton(''Cliquezici''); //Redéfinition
//Création
ici''); //Redéfinitionobligatoire
obligatoirede
decette
cetteméthode
méthode
//Créationd'un
d'unobjet
objetécouteur
écouteurnommé
nommé'reaction'
'reaction' public
publicvoid
voidactionPerformed(ActionEvent
actionPerformed(ActionEvente)e){ {
addActionListener(ActionListener l) Reaction1ClicBouton
Reaction1ClicBoutonreaction; System.out.println(''Quelqu'un
reaction = new
reaction;
Reaction1ClicBouton(); System.out.println(''Quelqu'unvient
vientd'appuyer
d'appuyer!'');
!'');
reaction = new Reaction1ClicBouton(); }}
//Ajout de l'objet écouteur sur le bouton
//Ajout de l'objet écouteur sur le bouton
b1.addActionListener(reaction); } }//fin
b1.addActionListener(reaction); //finde
delalaclasse
classe

implements //Ajout
//Ajoutdu
duboutton,
boutton,muni
munide
deson
sonécouteur,
écouteur,au
aupaneau
paneau
panneau.add(b1);
panneau.add(b1);
f.setContentPane(panneau);
f.setContentPane(panneau);
Reaction1ClicBouton.java
Reaction1ClicBouton
......
} }//fin
//finde
delalaclasse
classeTestGUI
TestGUI

System.out.println(''Quelqu'un vient d'appuyer !''); actionPerformed(ActionEvent e)


TestGUI.java

Conseils pratiques A vous de jouer !

● Sien réaction, vous avez besoin d'agir sur un


autre widget, soit :
Ο Vous passez la référence de ce dernier au constructeur
de votre classe écouteur
● b1.addActionListener(new Reaction1ClicBouton(trucmuche));
Ο Vous considérez votre classe contenant le main comme
étant une classe écouteur
● class TestGUI implements ActionPerformed
● La seconde solution présente l'avantage de
regrouper tout le code dans un seul fichier,
mais n'aide pas vraiment à comprendre :-/