IHM2

IHM EN JAVA
PARTIE2 : JAVA ORIENTÉE OBJET
Pr A. Majda
2017 - 2018
DÉROULEMENT DU COURS
 Initiation au Langage Java
 Introduction
 Outils de développement
 Données, Types et Operateurs
 Les structures alternatives et répétitives
 Les tableaux de données et chaines de caractères
 Les instructions d’écriture et de lecture
 Java Orienté Objet

 Classes et Objets
 Héritage
 Packages
 Classes internes et Interfaces
 Les exceptions
 Introduction aux IHMs

 Ergonomie
 Le patron d’architecture logicielle MVC
 Evoluion des IHM dans le temps
 Eléments de base d’une IHM Java

 Composants de base
 Composants SWING
 Les conteneurs
 Les composants atomiques
 Evènements & Ecouteurs
 Principes programmation évènementielle
 Listeners java
 Gestionnaires de positionnement
2
 Connexion à une base de données
LES CLASSES ET OBJETS
Le concept de classe
Une classe est un ensemble de données et de fonctions regroupées dans une même entité
pour former un type d’objets donné.
Dans une classe :

 Les données sont appelées propriétés ou attributs.
 Les fonctions opérant sur les données sont appelées des méthodes.
Pour accéder à une classe il faut en déclarer une instance de classe ou objet.
Instancier une classe consiste à créer un objet sur son modèle.
Entre classe et objet il y a, en quelque sorte, le même rapport qu'entre type et variable.
3
Le concept de classe
Exemple : Classe Personne
Personne
Nom de la prenom : chaine
classe nom : chaine
age : entier
Attributs
- identifie()
- initialise(chaine, chaine, entier)
Méthodes
4
Codage de la classe « Personne » en Java
public class Personne{
private String prenom;

private String nom; Nom classe
private int age;
public void initialise(String P, String N, int

age){
Attributs this.prenom=P;
this.nom=N;
this.age=age; }
public void identifie(){

Méthodes System.out.println(prenom+","+nom+","+age); }
} 5
Forme générale d’une classe
modificateur_accès class C1{
type1 p1; // propriété p1
type2 p2; // propriété p2
…
type3 m3(…){ // méthode m3
…
}
type4 m4(…){ // méthode m4
…
}
… }
A partir de la classe C1 précédente, on peut créer de nombreux objets O1, O2,…
6
Classe et visibilité des attributs
Caractéristiques d’un attribut :
 Variable « globale » de la classe
 Accessible dans toutes les méthodes de la classe

private String prenom; Attribut visible dans
private String nom; les méthodes
private int age;
public void initialise(String P, String N, int age){
this.prenom=P;
this.nom=N;
this.age=age; }
System.out.println(prenom+","+nom+","+age); }
}
N.B. Ne pas confondre attribut et variable d’une méthode

Les objets
Un objet est une instance d’une seule classe

 Se conforme à la description que sa classe fournit
 Admet une valeur propre à lui pour chaque attribut déclaré dans la classe
 Les valeurs des attributs caractérisent l’état de l’objet
 Possibilité de lui appliquer toute opération (méthode ) définie dans la classe
Tout objet est manipulé et identifié par sa référence

 On parle indifféremment d’instance, de référence ou d’objet
8
Exemple : Objet de type Personne

Nom de la
classe Personne
Nom de l’objet, la
référence ou Relation d’instanciation :
l’instance instanceof
p1
- prenom = "Aaaa"
- nom = "Bbbb"
- age = 30
Valeurs des attributs qui

caractérisent l’état de l’objet p1
9
Création d'un objet :

Instancier la classe de cet objet
L’opérateur new
Syntaxe de déclaration nom_classe nom_objet;

Syntaxe de création nom_objet = new nom_classe ();
Exemple création d’un objet de la classe Personne
public class Test1{

public static void main(String arg[]){
…
Personne p1=new Personne();
… }
}
10
Déroulement de la création d’objets

Personne p1=new Personne ();
p1
1. Personne p1; null
p1
objet
2. p1=new Personne ();

attribut1
attribut2
… 11
Programme de test
// import Personne;
import java.io.*;
public class Test1{
Personne p1=new Personne ();
p1.initialise ("Aaaa","Bbbb",30);
System.out.print("p1=");
p1.identifie();
}
}
Résultat
p1= Aaaa , Bbbb , 30 12
Remarques
1- la variable p1 contient une référence (adresse ) sur l'objet
instancié.
2- L'opérateur new est un opérateur de haute priorité qui permet d’:
 instancier des objets
 appeler une méthode particulière de cet objet : le contructeur.
3- Importation de la classe Personne

Le compilateur cherche le code de la classe Personne dans :
- Le fichier qui contient la méthode principale main()
 les paquetages importés par les instructions import
 le répertoire à partir duquel le compilateur a été lancé
13
Structure des objets

Un objet est constitué d’une partie « statique » et d’une partie « dynamique »
Partie « statique »
Ne varie pas d’une instance de classe à une autre
Permet d’activer l’objet
Partie « dynamique »
Varie d’une instance de classe à une autre
Varie durant la vie d’un objet
14
La durée de vie d'un objet
Les objets ne sont pas des éléments statiques

La durée de vie d'un objet passe par 3 étapes :
 la déclaration de l'objet et l'instanciation grâce à l'opérateur new
 l'utilisation de l'objet en appelant ses méthodes
 la suppression de l'objet : elle est automatique en Java grâce à la machine
virtuelle.
15
Objet temporaire
C’est un objet
 créé par un constructeur
 N’est pas référencé
 construit pour les besoins d'évaluation de l'expression puis abandonné.
l'espace mémoire occupé par cet objet sera automatiquement récupéré

ultérieurement
Exemple
// import Personne;
public class Test1{
new Personne().identifie(); }
16
}
L’objet courant
 Il est désigné par le mot clé this :
 this permet aussi de désigner un attribut de l'objet courant dans lequel se trouve la méthode
exécutée :
Exemple :
this.prenom=P;
this.nom=N;
this.age=age; }
L'instruction this.prenom=P;  l'attribut prenom de l'objet courant (this) reçoit la

valeur P.
Remarque
this doit être utilisé explicitement lorsqu'il y a conflit d'identificateurs: Cas de
l'instruction : this.age=age;
17
Gestion des objets

Afficher son type et son emplacement mémoire :System.out.println()
System.out.println(p1) Personne@19821f
Récupérer son type : méthode "getClass()"
p1.getClass(); class Personne
Tester son type : opérateur « instanceof » ou mot clé « class »
if (p1 instanceof Personne) {...} // true

ou
if (p1.getClass() == Personne.class) {...} // true
18
Destruction et ramasse-miettes
La destruction des objets se fait de manière implicite
Le ramasse-miettes ou Garbage Collector se met en route
Automatiquement :
Si plus aucune variable ne référence l’objet
Si le bloc dans lequel il était défini se termine
Si l’objet a été affecté à "null"
Manuellement :
Sur demande explicite du programmeur " System.gc() "
Un pseudo-destructeur « protected void finalize() » peut être défini
explicitement par le programmeur. Il est appelé juste avant la libération de la
mémoire par la machine virtuelle, mais on ne sait pas quand.
19
Les modificateurs d'accès

 Se placent avant ou après le type de l'objet.
 S'appliquent aux classes et/ou aux méthodes et/ou aux
attributs.
 Ne peuvent pas être utilisés pour qualifier des variables
locales.
 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.
20
Les mots clés gérants la visibilité des entités

Il existe 3 présentés dans un ordre décroissant de niveau de visibilité offert
public visible par tous les objets
par défaut visible par les objets des classes se trouvant dans le même
package.
protected visible par les objets de la classe interne ou d'un
objet dérivé
private visible uniquement par les objets de la classe interne
En général
les données d'une classe sont déclarées privées alors que ses méthodes sont
déclarées publiques.
21
Encapsulation par l’exemple

…
private String nom;
public void public class Test1{
initialise(String P, public static void main(String arg[])
String N, int age){ {
this.prenom=P; Personne p1=new Personne ();
this.nom=N; p1.initialise ("Aaaa","Bbbb",30); //Ok
this.age=age; } System.out.print(p1.nom);//erreur
public void identifie(){ p1.identifie(); //Ok
System.out.println(nom);} }
} }
Les données (attributs) doivent être protégés et accessibles pour l’extérieur par des
accesseurs 22
Autres modificateurs
 static le membre appartient à tous les objets de la classe. Il est inutile

d'instancier la classe pour accéder au membre.
 final le membre ne peut pas être modifiée (cas de l'héritage)
 abstract la classe ne pourra pas être instanciée: ses méthodes ne sont pas
implémentées
23
Les propriétés ou attributs

Ce sont des variables :
variables d'instances
Exemple
public class MaClasse { public int valeur1 ; int valeur2 ; protected int valeur3 ; private
int valeur4 ; }
variables de classes
Exemple
public class MaClasse { static int compteur ; }
Constantes
Exemple
public class MaClasse { final double PI=3.14 ; }
24
Initialisation des variables

En Java
 Toute variable appartenant à un objet est initialisée avec une valeur par défaut
 Cette initialisation ne s'applique pas aux variables locales des méthodes de la classe.
 Les valeurs par défaut lors de l'initialisation automatique des variables d'instances
sont :
Type Valeur par défaut
Boolean false
byte, short, int, long 0
float, double 0.0
char \u000 (null Character)
class null
25
Les méthodes
Les méthodes sont des fonctions qui implémentent les traitements de la classe.
Syntaxe de déclaration :
modificateurs type_val_retour nom_méthode ( arg1, ... ) {
... // définition des variables locales et du bloc d'instructions }
Syntaxe d’appel :
Nom_objet.nom_méthode ( par1, ... )
Exemples
 int add(int a, int b) { return a + b; }
 Si la méthode retourne un tableau
int[ ] valeurs() { ... } ou int valeurs()[ ] { ... }

 public static void main(String[ ] args) { System.out.println("Bonjour"); } 26
La surcharge
Définir plusieurs fois une même méthode avec des arguments différents.
Le compilateur choisi la méthode qui doit être exécutée en fonction des arguments.
Simplifier l'interface des classes vis à vis des autres
Exemple classe Personne
this.prenom=P;
this.nom=N;
this.age=age; }
public void initialise(String P, String N){
this.prenom=P;
this.nom=N; }
27
Exemple : Surcharge
public class Voiture { public class Test1 {
private int puissance; public static void main (String[] argv) {
private double vitesse; // Déclaration puis création de v1
Voiture v1 = new Voiture();
private boolean estDemarree;
// Accélération 1 avec un double
… v1.accelere(123.5);
public void accelere(double vitesse) { // Accélération 2 avec un entier
if (estDemarree) { v1.accelere(124);
this.vitesse = this.vitesse + vitesse; }
} }
}
public void accelere(int vitesse) {
if (estDemaree) {
this.vitesse = this.vitesse +(double)vitesse;
}
}
... }
28
Les constructeurs
Un constructeur est une méthode qui porte le nom de la classe et qui est appelée lors
de la création de l'objet.
Initialiser l'objet
C'est une méthode qui :
 peut accepter des arguments
 ne rend aucun résultat.
 Son prototype n’est précédé d'aucun type (même pas void).
Forme générale :
n_classe objet;
objet=new n_classe(arg1,arg2, ... argn);
ou
n_classe objet =new n_classe(arg1,arg2, ... argn); 29
Exemple : Constructeur de la classe Personne

Jusqu’à maintenant
On a utilisé le constructeur par défaut sans paramètre
Les valeurs des attributs au départ sont indéfinies et identique pour chaque objet
Rôle du constructeur en Java

Effectuer certaines initialisations nécessaires pour le nouvel objet créé
Toute classe Java possède au moins un constructeur

Si une classe ne définit pas explicitement de constructeur, un constructeur par défaut sans
arguments et qui n’effectue aucune initialisation particulière est invoquée : cas de la classe
Personne (diapo 7)
30
Exemple Classe Personne

private String prenom; Constructeur
avec trois
private String nom;
paramètres
private int age;
// constructeur1
public Personne(String P, String N, int age){
this.prenom=P;
this.nom=N;
this.age=age; } NB :
// constructeur2
Un constructeur peut être
surchargé
public Personne(Personne P){
this.prenom=P.prenom;
this.nom=P.nom;
this.age=P.age; } 31
Exemple Classe Personne

// méthodes
this.prenom=P;
this.nom=N;
this.age=age;
}
System.out.println(prenom+","+nom+","+age);
} }
32
Programme de test
// import Personne;
import java.io.*;
public class Test1{
Personne p1=new Personne("Aaaa","Bbbb",30);
System.out.print("p1="); p1.identifie();
Personne p2=new Personne(p1);
}
}
33
Programme de test : Les références d’objets

// import Personne;
public class Test2{
// p1
Personne p1=new Personne ("Aaaa","Bbbb",30);
// p2 référence le même objet que p1
Personne p2=p1;
34
Programme de test : Les références d’objets (Suite)
// p3 référence un objet = copie de l’objet réf. par p1

Personne p3=new Personne(p1);
// on change l'état de l'objet réf. par p1
p1.initialise("Cccc","Dddd",20);
// comme p2=p1, l'objet réf. par p2 a du changer d'état
// comme p3 ne référence pas le même objet que p1
}
}
35
Passage de paramètres à une méthode

Un paramètre d’une méthode peut être
 Une variable de type simple
 Une référence d’un objet typée par n’importe quelle classe
En Java tout est passé par valeur

 Les paramètres effectifs d’une méthode
 La valeur de retour d’une méthode (si différente de « void »)
Les types simples

 Leur valeur est recopiée
 Leur modification dans la méthode n’entraîne pas celle de l’original
Les objets
 Leur référence est recopiée et non pas les attributs
 Leur modification dans la méthode entraîne celle de l’original !!!
36
Exemple : type simple
public class param2{
private static void changeString(String S){
S="Mardi";
System.out.println(" Dans la methode S="+S); }
private static void changeInt(int a){
a=21;
System.out.println(" Dans la methode a="+a); }
public static void main(String[] arg){
String S="Lundi";
changeString(S);
System.out.println(" Dans main S="+S);
int jour=20;
changeInt(jour);
System.out.println(" Dans main jour="+jour); }
37
}
Exemple : type objet
// import Personne;
public class test1{
Personne p1=new Personne("Jjjj","Dddd",30);
System.out.print("avant methode 1: "); p1.identifie();
modifie1(p1);
System.out.print("après methode 1 : "); p1.identifie();
System.out.print("avant methode 2: "); p1.identifie();
modifie2(p1);
System.out.print("après methode 2 : "); p1.identifie();
} // main
private static void modifie1(Personne P){
P.initialise("Ssss","Vvvv",52);
System.out.print("dans methode1 :"); P.identifie(); } // modifie1
private static void modifie2(Personne P){

Personne p2=new Personne("Aaaa","Bbbb",30); P=p2;
System.out.print("dans methode 2 :"); P.identifie(); } // modifie2
} // class
38
Accesseurs et Mutateurs
L'encapsulation permet de sécuriser l'accès aux données privées d'une classe

La seule façon d’y accéder est d’utiliser les accesseurs
Un accesseur est une méthode publique qui donne l'accès à une variable d'instance
privée
Exemple
private int valeur = 13;
// accesseur en lecture
public int getValeur(){
return(valeur); }
//modificateur
public void setValeur(int val) {
valeur = val; }
39
Exemple : Classe Personne

private String nom;
private int age;
// constructeur
this.prenom=P;
this.nom=N;
this.age=age;
}
System.out.println(prenom+","+nom+","+age); }
40
Exemple : Classe Personne (Suite)
// accesseurs = getters
public String getPrenom(){ return prenom; }
public String getNom(){ return nom;}
public int getAge(){ return age;}
//modificateurs = setters
public void setPrenom(String P){ this.prenom=P;}
public void setNom(String N){ this.nom=N; }
public void setAge(int age){ this.age=age; }
}
41
Programme de test2
public class Test1{
Personne P=new Personne("Cccc","Dddd",20);
System.out.println("P=("+P.getPrenom()+","+P.getNom()+","+P.getAge()+")");
P.setAge(24);
System.out.println("P=("+P.getPrenom()+","+P.getNom()+","+P.getAge()+")");
}
}
Résultats :
P=(Cccc,Dddd,20)
P=(Cccc,Dddd,24)
42
Les méthodes et attributs de classe
Attributs :
 Il peut être utile de définir pour une classe des attributs indépendamment des instances :
nombre d’objets créées
 Utilisation des Variables de classe comparables aux " variables globales"
Exemple : private static long nbPersonnes; // nombre de Personnes créées
Méthodes :
 Ce sont des méthodes qui ne s'intéressent pas à un objet particulier
 Utiles pour des calculs intermédiaires internes à une classe
 Utiles également pour retourner la valeur d'une variable de classe en visibilité private
 Elles sont définies comme les méthodes d'instances, mais avec le mot clé static
Exemple : public static long getNbPersonnes(){
return nbPersonnes; }
43
La classe Personne devient la suivante :
// attribut de classe
private static long nbPersonnes=0;
// attributs d'objets
…
// constructeur
this.prenom=P;
this.nom=N;
this.age=age;
nbPersonnes++;
}
// méthodes
…
// méthode de classe
public static long getNbPersonnes(){
44
return nbPersonnes; } } // class
Avec le programme suivant

// import Personne;
public class test1{
Personne p1=new Personne("Jjjj","Dddd",30);
new Personne("Aaaa","Bbbb",25);
Personne p3=p2;
System.out.println("Nombre de Personnes créées : "+Personne.getNbPersonnes());
} // main
} //test1
on obtient les résultats suivants :
Nombre de Personnes créées : 2
45
Les tableaux d’objets en Java
Un objet est une donnée comme une autre : Plusieurs objets peuvent être rassemblés
dans un tableau
// import Personne;
public class test1{
Personne[] amis= new Personne[3];
System.out.println("----------------");
amis[0]=new Personne("Aaaa","Bbbb",30);
amis[1]=new Personne("Cccc","Dddd",52);
amis[2]=new Personne("Eeee","Ffff",66);
int i;
for(i=0;i<amis.length;i++)
amis[i].identifie();
} 46
}
L'HÉRITAGE
Définition
Technique offerte par les langages de programmation orientée objet pour
construire une classe à partir d’une autre classe (ou plusieurs) en partageant
ses attributs et opérations
Intérêts
Spécialisation, enrichissement : une nouvelle classe réutilise les attributs et
les opérations d’une classe en y ajoutant des attributs et/ou des opérations
particulières à la nouvelle classe
Redéfinition : une nouvelle classe redéfinit les attributs et opérations d’une
classe de manière à en changer le sens et/ou le comportement pour le cas
particulier défini par la nouvelle classe
Réutilisation : évite de réécrire du code existant et parfois on ne possède pas
les sources de la classe à hériter
47
L'HÉRITAGE
Héritage et Java
 Utilisation du mot-clé extends après le nom de la classe
 Une classe ne peut hériter que d’une seule autre classe
Exemple :
class Enseignant extends Personne{
…}
N.B. : Dans certains autres langages (ex : C++) possibilité d’héritage multiple
 Héritage à plusieurs niveaux
Exemple :
class Chef_dep extends Enseignant{
…}
48
L'HÉRITAGE
Exemple
Classe Enseignant hérite des propriétés de la classe Personne,
on écrira : public class Enseignant extends Personne
 Personne est appelée la classe mère (super classe)
 Enseignant la classe fille (ou dérivée, sous classe)
Un objet Enseignant a toutes les qualités d'un objet Personne


// attributs
private int section;
// constructeur
public Enseignant(String P, String N, int age,int section){
super(P,N,age);
this.section=section;
} }
49
L’instruction super(P,N,age); est un appel au constructeur de la classe mère
L'HÉRITAGE
Exemple (suite)
private String nom;
private int age;

this.prenom=P;
this.nom=N;
this.age=age; }
public String identite(){

return "Personne("+prenom+","+nom+","+age+")"; }
… // accesseurs
… //modificateurs } 50
L'HÉRITAGE
Création d'un objet Enseignant

// import Personne;
// import Enseignant;
public class test1{
Enseignant E= new Enseignant("Jjjj","Dddd",30,27);
System.out.println(E.identite()); }
}
 Ce programme ce contente de créer un objet Enseignant et de l'identifier.
 La classe Enseignant n'a pas de méthode identité mais sa classe mère en a une.
 Cette fonction devient par héritage une méthode publique de la classe Enseignant .
Comme résultats : Personne(Jjjj,Dddd,30)

51
L'HÉRITAGE
Généralisation et Spécialisation
La généralisation exprime une relation « est-un » entre une classe et sa super-classe
Personne
Raffinement
Abstraction
Super-classe
Enseignant
Sous-classe
L’héritage permet
 de généraliser dans le sens abstraction
 de spécialiser dans le sens raffinement
52
L'HÉRITAGE
Remarques
 Un objet de la classe Enseignant est forcément un objet de la classe

Personne
 Un objet de la classe Personne n’est pas forcément un objet de la classe
Enseignant
 Un Enseignant est une Personne
53
L'HÉRITAGE
Surcharge et redéfinition
 Surcharge : possibilité de définir des méthodes possédant le même nom mais dont les
arguments (paramètres et valeur de retour) diffèrent
 Redéfinition : lorsque la sous-classe définit une méthode dont le nom, les paramètres
et le type de retour sont identiques
Dans le cas de l’héritage

 Une sous-classe peut ajouter des nouveaux attributs et/ou méthodes à ceux qu’elle
hérite (surcharge en fait partie)
 Une sous-classe peut redéfinir des méthodes qu’elle héritent et fournir des
implémentations spécifiques pour celles-ci
54
L'HÉRITAGE
Exemple
Dans l'exemple précédent :
 On a uniquement l’identité de la partie Personne de l'Enseignant
 manque de certaines informations propres à la classe Enseignant (la section).
 redéfinition de la fonction identite héritée

int sec;
public Enseignant(String P, String N, int age, int sec){
super(P,N,age);
this.sec=sec;
}
public String identite(){
return "Enseignant("+super.identite()+","+sec+")";
} 55
L'HÉRITAGE
En général
si O est un objet et M une méthode

pour exécuter la méthode O.M, le système cherche une méthode M dans l'ordre
suivant :
 dans la classe de l'objet O
 dans sa classe mère s'il en a une
 dans la classe mère de sa classe mère si elle existe
 etc…
L'héritage permet donc de redéfinir dans la classe fille des méthodes de même nom
dans la classe mère
Adapter la classe fille à ses propres besoins.
56
L'HÉRITAGE
Programme de test
Si on considère le même exemple que précédemment :
// import Personne;
public class test1{
Enseignant E= new Enseignant("Jjjj","Dddd",30,27);
System.out.println(E.identite()); }
}
Résultats obtenus :
Enseignant(Personne(Jjjj,Dddd,30),27)
57
L'HÉRITAGE
Polymorphisme et Java : Surclassement

Java est polymorphique
 A une référence déclarée de la classe Personne, il est possible d’affecter une
référence vers un objet de la classe Enseignant (sous classe)
 On parle de surclassement d’objets ou upcasting
 Plus généralement, à une référence d’un type donné, soit A, il est possible d’affecter
une valeur qui correspond à une référence vers un objet dont le type effectif est
n’importe quelle sous classe directe ou indirecte de A
public class Test {

public static void main (String[] argv) { Objet de type sous-
Personne P1 = classe
new Enseignant(...); directe de la classe
}
}
Personne
58
L'HÉRITAGE
Exemple
Soit le programme suivant :
// import Personne;
public class test1{
Enseignant e= new Enseignant("Llll","Dddd",56,61);
affiche(e);
Personne p= new Personne("Jjjj","Dddd",30);
affiche(p); }
public static void affiche(Object obj){
System.out.println(obj.toString()); }
}
Méthode définie
Les résultats obtenus sont les suivants : dans la classe
Enseignant@1ee789 Object
Personne@1ee770 59
L'HÉRITAGE
Procédure
Le système devra exécuter l’instruction System.out.println(e.toString())

où e est un objet Enseignant.
Il cherche une méthode toString() dans la hiérarchie des classes menant à la classe
Enseignant en commençant par la dernière :
1. dans la classe Enseignant, il ne trouve pas de méthode toString()
2. dans la classe mère Personne, il ne trouve pas de méthode toString()
3. dans la classe mère Object, il trouve la méthode toString() et l'exécute
60
L'HÉRITAGE
Remarque
On peut redéfinir la méthode toString de la classe mère Object pour les classes
Personne et Enseignant.
...
public String toString(){
return "Personne("+prenom+","+nom+","+age+")"; }
... }
private int section;
…
return "Enseignant("+super.toString()+","+section+")"; }
61
}
PAQUETAGES (PACKAGES)
 Le langage Java propose une définition très claire du mécanisme

d’empaquetage qui permet de classer et de gérer les API externes
 Les API sont constituées :
API
Paquetages
Interfaces Classes
Attributs Méthodes
62
Exemples de paquetages
Un paquetage est donc un groupe de classes associées à une fonctionnalité
java.io : lecture et écriture
java.lang : rassemble les classes de base Java (Object, String, System, …)
java.util : rassemble les classes utilitaires (Collections, Date, …)
…
L’utilisation des paquetages permet de regrouper les classes afin d’organiser
des libraires de classes Java
63
Les paquetages : Utilisation des classes
 Lorsque, dans un programme, il y a une référence à une classe, le compilateur la
recherche dans le paquetage par défaut (java.lang)
 Pour les autres, il est nécessaire de fournir explicitement l’information pour savoir où se
trouve la classe :
Utilisation d’import (classe ou paquetage)
ou Nom du paquetage avec le nom de la classe
Exemples
import mesclasses.Point;
import java.lang.String; // Ne sert à rien puisque par défaut
import java.io.ObjectOutput;
import mesclasses.*;
import java.lang.*; // Ne sert à rien puisque par défaut
import java.io.*;
java.io.ObjectOuput toto = new java.io.ObjectOuput(...) 64
Les paquetages : leur « existence » physique

A chaque classe Java correspond un fichier
A chaque paquetage (sous- paquetage ) correspond un répertoire
Un paquetage peut contenir
 Des classes ou des interfaces
 Un autre paquetage (sous- paquetage )
Exemple package
mesclasses;
C1.java
C2.java
I1.java
65
Les paquetages : hiérarchie de paquetages

A une hiérarchie de paquetage correspond une hiérarchie de répertoires dont les noms
coïncident avec les composants des noms de paquetage
Exemple : la classe String
java
lang util math
String.java
66
Création de paquetages sous Eclipse
 Dans chaque classe (ou interface) du paquetage :
l’instruction package nom_package; est placée automatiquement en entête
package mesclasses;
// une interface I1
public interface I1{
int ajouter(int i,int j);
int soustraire(int i,int j);} 67
Les paquetages : visibilité

 L’instruction import nomPackage.* ; ne concerne que les classes du paquetage
indiqué.
 Elle ne s’applique pas aux classes des sous-paquetages
Paquetages
import java.util.zip.*; différents
import java.util.*;
public class Essai {
...
public Essai() {
Date d = new Date(...);
ZipFile z = new ZipFile(...);
...
}
...
} 68
CLASSES INTERNES
C’est une classe définit au sein d'une autre classe
L’utilisation d’une classe interne est souhaitable lorsque la classe n'a d'utilité que dans la
classe qui la contient.
Soit Article une classe interne de la classe Test

Lors de la compilation du source Test.java on obtient deux fichiers .class :
1. Test$Article.class
2. Test.class
69
CLASSES INTERNES
Exemple : Classe interne article de la classe test

// classes importées // données locales
import java.io.*; private Article art;
public class Test{ // constructeur
// classe interne public Test(String code, String nom, double prix){
private class Article{ art= new Article(code, nom, prix);}
// on définit la structure // accesseur
private String code; public Article getArticle(){
private String nom; return art;}
private double prix;
// constructeur //toString
public Article(String code,String nom,double return
prix){ "Article("+art.code+","+art.nom+","+art.prix+")";
this.code=code; }
this.nom=nom;
this.prix=prix; }
} //fin classe article
70
CLASSES INTERNES
Exemple : Classe interne article de la classe test
// main
Test t1= new Test("a100","velo",1000);
System.out.println("art="+t1.getArticle());
System.out.println("art="+t1.toString());
}
} // fin classe Test
71
CLASSES ABSTRAITES
Intérêts
On ne connaît pas toujours le comportement par défaut d’une opération commune à
plusieurs sous-classes
Exemple : aire d’une forme géométrique. On sait que toutes les formes géométriques
ont une aire, mais la formule est différente d’une forme à l’autre
 Solution : on peut déclarer la méthode « abstraite » dans la classe mère et ne
pas lui donner d’implantation par défaut
Méthode abstraite et conséquences : 3 règles à retenir
1- Si une seule des méthodes d’une classe est abstraite, alors la classe devient aussi
abstraite
2- On ne peut pas instancier une classe abstraite car au moins une de ses méthodes n’a
pas d’implémentation
3- Toutes les classes filles héritant de la classe mère abstraite doivent implémenter
toutes ses méthodes abstraites ou sinon elles sont aussi abstraites
72
CLASSES ABSTRAITES
Classes abstraites et Java

On utilise le mot clé abstract pour spécifier une classe abstraite
Une classe abstraite se déclare ainsi :
public abstract class NomMaClasse {
...
}
Une méthode abstraite se déclare ainsi :
public abstract void maMethode(...);
Pour créer une méthode abstraite, on

déclare sa signature (nom et paramètres)
sans spécifier le corps et en ajoutant le
mot-clé abstract 73
CLASSES ABSTRAITES
Exemple
public abstract class Forme {
public abstract float aire(int x,int y);
}
import java.math.*;
public class Cercle extends Forme { public class Rectangle extends Forme {
… …
public float aire(int x, int y){ public float aire(int l, int h){
return (float)Math.PI*x*y; return l*h;
} }
…} …}
Attention : ce n’est pas de la redéfinition. On parle

d’implémentation de méthode abstraite 74
CLASSES ABSTRAITES
Programme de test
public class test {
public static void main(String[] args) {
…
Cercle c1=new Cercle(1,1,25);
System.out.println("L'aire est "+c1.aire(25, 25));
…
Forme f1=new forme(); // Erreur
}
}
Attention : La classe Forme ne peut être instanciée puisqu’elle est

abstraite
75
Pr A. Majda – Fst de Fès Sais-

INTERFACES
Notion d’interface
Une interface est un modèle pour une classe
 Quand toutes les méthodes d’une classe sont abstraites et il n’y a aucun attribut on
aboutit à la notion d’interface
 Elle définit la signature des méthodes qui doivent être implémentées dans les classes
qui respectent ce modèle (Ce contrat)
 Toute classe qui implémente l’interface doit implémenter toutes les méthodes définies
par l’interface
 Tout objet instance d’une classe qui implémente l’interface peut être déclaré comme
étant du type de cette interface
 Les interfaces pourront se dériver 76
INTERFACES
Mise en œuvre d’une interface
 La définition d’une interface se présente comme celle d’une classe. On y utilise
simplement le mot clé interface à la place de class
public interface NomInterface {
...}
 Lorsqu’on définit une classe, on peut préciser qu’elle implémente une ou plusieurs
interfaces donnée(s) en utilisant une fois le mot clé implements
public class NomClasses implements Interface1, Interface2, ... {
...}
 Si une classe hérite d’une autre classe elle peut également implémenter une ou plusieurs
interfaces
public class NomClasses extends SuperClasse implements Interface1, ... {
...}
77
INTERFACES

 Une interface ne possède pas d’attribut
 Une interface peut posséder des constantes
 Une interface ne possède pas de mot clé abstract
 Les interfaces ne sont pas instanciables (Même raisonnement avec les classes
abstraites)
public interface NomInterface {

public static final int CONST = 2; }
NomInterface jeTente = new NomInterface(); // Erreur!!
78
INTERFACES
Toute classe qui implémente l’interface doit implémenter toutes les méthodes définies par
l’interface
Exemple
// une interface I1
public interface I1{
int ajouter(int i,int j);
int soustraire(int i,int j);}
public class C1 implements I1 public class C2 implements I1

{ public int ajouter(int i,int j) { public int ajouter(int i,int j)
{return i+j+1;} {return i+j+10;}
public int soustraire(int i,int j) public int soustraire(int i,int j)
{return i-j+1; {return i-j+10;
} }
} }
79
INTERFACES
Tout objet instance d’une classe qui implémente l’interface peut être déclaré comme étant
du type de cette interface
Exemple :
public class Test{
…
// création d’un objet C
C1 c= new C1();
…
}//main I1 c= new C1();
}//classe test
80
INTERFACES
Les interfaces pourront se dériver

 Une interface peut hériter d’une autre interface : extends
public interface I2 extends I1{
…}
Conséquences
 La définition de méthodes de l’interface mère I1 sont reprises dans l’interface fille I2
 Toute classe qui implémente l’interface fille doit donner une implémentation à toutes les
méthodes mêmes celle héritées
Utilisation
 Lorsqu’un modèle peut se définir en plusieurs sous-modèles complémentaires
81
INTERFACES
Toute classe qui implémente l’interface doit implémenter toutes les méthodes définies par
l’interface
Exemple
// interface I2
public interface I2 extends I1 {
int multiplier( int i, int j);
}
public class C1 implements I2 {

public int ajouter(int i,int j) {return i+j+1;}
public int soustraire(int i,int j) {return i-j+1;}
public int multiplier(int i,int j) {return i*j+1;}
}
82
INTERFACES
Programme de test : Importance des interfaces
public class Test{
private static void calculer(int i, int j, I1 in){
System.out.println(in.ajouter(i,j));
System.out.println(in.soustraire(i,j));}
// création de deux objets C1 et C2 Ex : Calcul de la remise pour
les produits dans un magasin
C1 c1= new C1(); Dépends :
• quantité dans le stock
C2 c2= new C2(); • Durée de vie
// appels de la fonction statique calculer • Produit d’import / terroirs
calculer(4,3,c1);
calculer(14,13,c2);
}//main }//classe Test
Si un ensemble de classes Ci non liées entre-elles par héritage présentent un ensemble de

méthodes de même signature, il peut être intéressant de regrouper ces méthodes dans une
interface I dont hériteraient toutes les classes concernées. 83
EXCEPTIONS
 Définition
Une exception est un signal qui indique que quelque chose d’exceptionnel (comme une
erreur) s’est produite . Elle interrompe le flot d’exécution normal du programme
 A quoi ça sert
Gérer les erreurs est indispensable :
Mauvaise gestion peut avoir des conséquences graves
Mécanisme simple et lisible :
Regroupement du code réservé au traitement des erreurs Possibilité de «
récupérer » une erreur à plusieurs niveaux d’une application (propagation dans la pile
des appels de méthodes)
 Vocabulaire
détecter et de traiter les erreurs ( try catch finally )
lever ou propager ( throw throws )
84
EXCEPTIONS
Mécanisme de traitement
En java, on peut classer les erreurs en deux catégories :

 Les erreurs surveillées
Le programmeur est obligé de les traiter
 Les erreurs non surveillés

Considérées trop graves pour que leur traitement soit prévu à priori
Lorsqu’une erreur de ce type est rencontrée, l’interpréteur :

 Crée immédiatement un objet instance d’une classe particulière et sous classe de
Exception
 Cherche le code susceptible de la traiter
85
EXCEPTIONS
Exemple : Attraper l’exception
public class Prog1{

public static void main(String[] args){
int[] tab=new int[] {0,1,2,3}; // déclaration & initialisation
int i;
for (i=0; i<tab.length; i++)
System.out.println("tab[" + i + "]=" + tab[i]);
tab[100]=6;
} //main
} //classe
86
EXCEPTIONS
Exemple : Attraper l’exception
import java.io.*;
public class Prog1{
public static void main(String[] args){
int[] tab=new int[] {0,1,2,3}; // déclaration & initialisation
for (int i=0; i<tab.length; i++)
System.out.println("tab[" + i + "]=" + tab[i]);
// génération d'une exception
try{ tab[100]=6;
}catch (Exception e){
System.err.println("L'erreur suivante s'est produite : " + e);
} //try-catch
} //main
} //classe
87
EXCEPTIONS
Arbre généalogique des exceptions

 Les exceptions en Java sont considérées comme des objets
 Toute exception doit être une instance d’une sous-classe de la classe

java.lang.Throwable
Throwable
Erreur non récupérable. Erreur que l’on peut traiter
« Plantage » de l’application puisque récupérable
Error Exception
ArithmeticException Exceper 88
EXCEPTIONS
Exception : Bloc try catch finally

try {
operation_risquée1; opération_risquée2;
} catch (ExceptionInteressante e) { traitements
} catch (ExceptionParticulière e) { traitements
} catch (Exception e) {
traitements
} finally{
traitement_pour_terminer_proprement; }
Le bloc Finally est toujours exécuté, qu'une exception soit

levée ou non
N. I. Dans l'ordre séquentiel des clauses catch, un type d'exception de classe ne

doit pas venir après un type d'une exception d'une super classe.
89
EXCEPTIONS
Dans quelle direction sont lancées les exceptions ?

Lorsqu’une exception est lancée
 Si elle n’est pas traitée
 elle est transmise au bloc englobant, …,
jusqu’à ce qu’elle soit traitée ou parvienne
en haut de la pile d’appel.
 Elle stoppe alors l’application
Une exception vient

de se produire 90
EXCEPTIONS
Lancer une exception

Une méthode déclare qu’elle peut lancer une exception par le mot clé throws
public calcul (int x, int y) throws Exception {

...}
Permet à la méthode calcul de lancer une
exception de type Exception
public class test1
{ public static void main(String[] args){
int i = 3; int j = 0;
try {
System.out.println("i/j="+calcul(i,j));
} catch (ArithmeticException e) {
System.out.println("Erreur : Division par zero");
}
}
static int calcul(int a, int b)throws ArithmeticException{
return a/b; 91
} }
EXCEPTIONS
Exemple 1
public class test
{ public static void main(String[] args)throws Exception
{
int i = 3; int j = 0;
try {
System.out.println("i/j="+calcul(i,j));
} catch (Exception e) {
System.out.println("Erreur : Division par zero");
throw e;
…
} Unreachable Code
}
static int calcul (int a, int b){
return a/b;
}
}
92
EXCEPTIONS
Exemple 2
import java.io.*;
public class TestErreur {
public static void main(java.lang.String[] args) {
int s=0;
try {
s=lireInt();
}
catch (IOException e) {
System.out.println(" Erreur de lecture ");
}
System.out.println(" L’entier est "+s);
}
static int lireInt()throws IOException{
BufferedReader br=new BufferedReader(new
InputStreamReader(System.in)) ;
String s=br.readLine();
return Integer.parseInt(s);
}
} 93
EXCEPTIONS
Créer ses propres exceptions

Les exceptions sont des objets nous pouvons donc étendre les classes d’exceptions
Exception
- message : String
+ Exception()
+ Exception(String) Constructeur avec ou sans
+ getMessage() : String argument
+ printStackTrace()
+…
ExcePer
Affiche sur la sortie erreur standard la liste

des appels de méthodes ayant conduit à 94
l’exception
EXCEPTIONS
Exemple : lancer une exception si l’entier lu est négatif
import java.io.*; class ExcePer extends

public class TestErreur { Exception{
public static void main(String[] args) ExcePer(String s){
{ int s=0;
super(s);
try { s=lireInt(); }
catch (IOException e) { }}
System.out.println(" Erreur de lecture "+e.getMessage());}
catch (ExcePer e){
System.out.println(" Erreur : "+e.getMessage()); }
… }
static int lireInt()throws IOException,ExcePer{
BufferedReader br=new BufferedReader(new
InputStreamReader(System.in));
String s=br.readLine();
int i=Integer.parseInt(s);
if (i<0) throw new ExcePer ("Valeur negative");
return Integer.parseInt(s);
}} 95
EXCEPTIONS
Exception : finally
Bloc finally : c’est une instruction optionnelle qui peut servir de « nettoyage ».
Elle est exécutée quelle que soit le résultat du bloc try (c’est-à-dire qu’il ait
déclenché une exception ou non)
Intérêt double :
 Rassembler dans un seul bloc un ensemble d’instructions qui autrement
auraient du être dupliquées
 Effectuer des traitements après le bloc try, même si une exception a été
levée et non attrapée par les blocs catch
96
EXCEPTIONS
Exception : finally
…
{…
try {
s=lireInt();
}
catch (IOException e) {
System.out.println("Erreur de lecture"+e.getMessage());
}
catch (ExcePer e){
System.out.println(" Erreur : "+e.getMessage());
}
finally{System.out.println(" Fin du programme ");
System.exit(0); }
…
97
EXCEPTIONS
Les exceptions courantes
 Java fournit de nombreuses classes prédéfinies dérivées de la classe Exception
 Ces exceptions standards se classent en deux catégories

 Les exceptions explicites mentionnées par le mot clé throws
 Les exceptions implicites qui ne sont pas mentionnées par le mot clé throws
 Liste de quelques exceptions

 ArithmeticException (division par zéro)
 NullPointerException (référence non construite)
 ClassCastException (problème de cast)
 IndexOutOfBoundsException (problème de dépassement d’index dans tableau)
98

IHM2

Transféré par

Droits d'auteur :

Formats disponibles

IHM2

Transféré par

Informations du document

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

IHM2

Transféré par

Droits d'auteur :

Formats disponibles

IHM EN JAVA

PARTIE2 : JAVA ORIENTÉE OBJET

 Java Orienté Objet

 Introduction aux IHMs

 Eléments de base d’une IHM Java

Dans une classe :

Codage de la classe « Personne » en Java

public class Personne{

private String prenom;

public void initialise(String P, String N, int

public void identifie(){

public class Personne{

N.B. Ne pas confondre attribut et variable d’une méthode

Un objet est une instance d’une seule classe

Tout objet est manipulé et identifié par sa référence

Exemple : Objet de type Personne

Valeurs des attributs qui

Création d'un objet :

Syntaxe de déclaration nom_classe nom_objet;

Exemple création d’un objet de la classe Personne

public class Test1{

Déroulement de la création d’objets

2. p1=new Personne ();

3- Importation de la classe Personne

Structure des objets

La durée de vie d'un objet

Les objets ne sont pas des éléments statiques

l'espace mémoire occupé par cet objet sera automatiquement récupéré

L'instruction this.prenom=P;  l'attribut prenom de l'objet courant (this) reçoit la

Gestion des objets

Tester son type : opérateur « instanceof » ou mot clé « class »

if (p1 instanceof Personne) {...} // true

Les modificateurs d'accès

Les mots clés gérants la visibilité des entités

Encapsulation par l’exemple

 static le membre appartient à tous les objets de la classe. Il est inutile

 final le membre ne peut pas être modifiée (cas de l'héritage)

Les propriétés ou attributs

Initialisation des variables

int[ ] valeurs() { ... } ou int valeurs()[ ] { ... }

Exemple : Constructeur de la classe Personne

Rôle du constructeur en Java

Toute classe Java possède au moins un constructeur

Exemple Classe Personne

Exemple Classe Personne

Programme de test : Les références d’objets

Programme de test : Les références d’objets (Suite)

// p3 référence un objet = copie de l’objet réf. par p1

Passage de paramètres à une méthode

En Java tout est passé par valeur

Les types simples

private static void modifie2(Personne P){

L'encapsulation permet de sécuriser l'accès aux données privées d'une classe

Exemple : Classe Personne

public class Personne{

Exemple : Classe Personne (Suite)

Avec le programme suivant

 Héritage à plusieurs niveaux

Un objet Enseignant a toutes les qualités d'un objet Personne

public Personne(String P, String N, int age){