Université Hassan II de Casablanca

Faculté des sciences Ain – Chock

Département de mathématiques et informatique

1
Préparé par : JAI ANDALOUSSI SAID
Plan de cours

 Chapitre 1 : Présentation du langage JAVA

 Chapitre 2 : Classes JAVA
 Chapitre 3 : Héritage
 Chapitre 4 : Exceptions
 Chapitre 5 : Interfaces graphiques (Swing)
 Chapitre 6 : JDBC

2
Plan de cours

 Chapitre 1 : Présentation du langage JAVA

 Chapitre 2 : Classes JAVA
 Chapitre 3 : Héritage
 Chapitre 4 : Exceptions
 Chapitre 5 : Interfaces graphiques (Swing)
 Chapitre 6 : JDBC

3
 Chapitre 1 : Présentation du langage JAVA

Le langage Java est un langage de programmation orienté objet créé par James Gosling
et Patrick Naughton, employés de Sun Microsystems, avec le soutien de Bill Joy
(cofondateur de Sun Microsystems en 1982), présenté officiellement le 23 mai 1995 au
SunWorld.

en 2009

rachetée par

4
 Chapitre 1 : Présentation du langage JAVA

Quelques chiffres et faits à propos de Java en 2011 :

 97% des machines d'entreprises ont une JVM installée

 Java est téléchargé plus d'un milliards de fois chaque année
 Il y a plus de 9 millions de développeurs Java dans le monde
 Java est un des langages les plus utilisé dans le monde
 Tous les lecteurs de Blue-Ray utilisent Java
 Plus de 3 milliards d'appareils mobiles peuvent mettre en oeuvre Java
 Plus de 1,4 milliards de cartes à puce utilisant Java sont produites chaque année

5
 Chapitre 1 : Présentation du langage JAVA

Java possède un certain nombre de caractéristiques qui ont largement contribué à son
énorme succès :
Java est interprété
Le fichier source est compilé en pseudo code ou bytecode puis exécuté par un interpréteur Java : la
Java Virtual Machine (JVM). Ce concept est à la base du slogan de Sun pour Java : WORA (Write Once,
Run Anywhere : écrire une fois, exécuter partout). En effet, le bytecode, s'il ne contient pas de code
spécifique à une plate-forme particulière peut être exécuté et obtenir quasiment les mêmes résultats
sur toutes les machines disposant d'une JVM.

6
 Chapitre 1 : Présentation du langage JAVA

Java possède un certain nombre de caractéristiques qui ont largement contribué à son
énorme succès :

Java est portable

il n'y a pas de compilation spécifique pour chaque plate forme. Le code reste indépendant
de la machine sur laquelle il s'exécute. Il est possible d'exécuter des programmes Java sur
tous les environnements qui possèdent une Java Virtual Machine. Cette indépendance est
assurée au niveau du code source grâce à Unicode et au niveau du bytecode.

Java est orienté objet

comme la plupart des langages récents, Java est orienté objet. Chaque fichier source
contient la définition d'une ou plusieurs classes qui sont utilisées les unes avec les autres
pour former une application. Java n'est pas complètement objet car il définit des types
primitifs (entier, caractère, flottant, booléen,...).

7
 Chapitre 1 : Présentation du langage JAVA

Java possède un certain nombre de caractéristiques qui ont largement contribué à son
énorme succès :

Java est simple

le choix de ses auteurs a été d'abandonner des éléments mal compris ou mal exploités
des autres langages tels que la notion de pointeurs (pour éviter les incidents en
manipulant directement la mémoire), l'héritage multiple et la surcharge des opérateurs,
...

Java est fortement typé

toutes les variables sont typées et il n'existe pas de conversion automatique qui risquerait
une perte de données. Si une telle conversion doit être réalisée, le développeur doit
obligatoirement utiliser un cast ou une méthode statique fournie en standard pour la
réaliser.

8
 Chapitre 1 : Présentation du langage JAVA

Java possède un certain nombre de caractéristiques qui ont largement contribué à son
énorme succès :

Java assure la gestion de la mémoire

l'allocation de la mémoire pour un objet est automatique à sa création et Java récupère
automatiquement la mémoire inutilisée grâce au garbage collector qui restitue les zones
de mémoire laissées libres suite à la destruction des objets.

9
 Chapitre 1 : Présentation du langage JAVA

Java possède un certain nombre de caractéristiques qui ont largement contribué à son
énorme succès :
Java est sûr
la sécurité fait partie intégrante du système d'exécution et du compilateur. Un programme
Java planté ne menace pas le système d'exploitation. Il ne peut pas y avoir d'accès direct à
la mémoire. L'accès au disque dur est réglementé dans une applet.

Les applets fonctionnant sur le Web sont soumises aux restrictions suivantes dans la
version 1.0 de Java :
• aucun programme ne peut ouvrir, lire, écrire ou effacer un fichier sur le système de
l'utilisateur
• aucun programme ne peut lancer un autre programme sur le système de l'utilisateur
• toute fenêtre créée par le programme est clairement identifiée comme étant une
fenêtre Java, ce qui interdit par exemple la création d'une fausse fenêtre demandant
un mot de passe
• les programmes ne peuvent pas se connecter à d'autres sites Web que celui dont ils
proviennent.

10
 Chapitre 1 : Présentation du langage JAVA

Java possède un certain nombre de caractéristiques qui ont largement contribué à son
énorme succès :

Java est économe

le pseudo code a une taille relativement petite car les bibliothèques de classes requises
ne sont liées qu'à l'exécution.

Java est multitâche

il permet l'utilisation de threads qui sont des unités d'exécutions isolées. La JVM, elle
même, utilise plusieurs threads.

11
 Chapitre 1 : Présentation du langage JAVA

Il existe 2 types de programmes avec la version standard de Java : les applets et les
applications.

• Une application autonome (stand alone program) est une application qui s'exécute
sous le contrôle direct du système d'exploitation.
• Une applet est une application qui est chargée par un navigateur et qui est exécutée
sous le contrôle d'un plug in de ce dernier.

Les principales différences entre une applet et une application sont :

 les applets n'ont pas de méthode main() : la méthode main() est appelée par la
machine virtuelle pour exécuter une application.
 les applets ne peuvent pas être testées avec l'interpréteur. Elles doivent être testées
avec l'applet viewer ou doivent être intégrées à une page HTML, elle même visualisée
avec un navigateur disposant d'un plug in Java,

12
 Chapitre 1 : Présentation du langage JAVA

Un bref historique de Java

13
 Chapitre 1 : Présentation du langage JAVA

Un bref historique de Java

Quelle est la différence entre les plates-formes JRE et SE ?

14
 Chapitre 1 : Présentation du langage JAVA

Un bref historique de Java

Quelle est la différence entre JRE et JDK ?

15
 Chapitre 1 : Présentation du langage JAVA

Un bref historique de Java

Depuis sa version 1.2, Java a été renommé Java 2. Les numéros de version 1.2 et 2
désignent donc la même version. Le JDK a été renommé J2SDK (Java 2 Software
Development Kit) mais la dénomination JDK reste encore largement utilisée, à tel point
que la dénomination JDK est reprise dans la version 5.0. Le JRE a été renommé J2RE (Java
2 Runtime Environment).
Trois plate-formes d'exécution (ou éditions) Java sont définies pour des cibles distinctes
selon les besoins des applications à développer :

 Java Standard Edition (J2SE / Java SE) : environnement d'exécution et ensemble complet
d'API pour des applications de type desktop. Cette plate-forme sert de base en tout ou
partie aux autres plate-formes
 Java Enterprise Edition (J2EE / Java EE) : environnement d'exécution reposant
intégralement sur Java SE pour le développement d'applications d'entreprises
 Java Micro Edition (J2ME / Java ME) : environnement d'exécution et API pour le
développement d'applications sur appareils mobiles et embarqués dont les capacités ne
permettent pas la mise en oeuvre de Java SE

16
 Chapitre 1 : Présentation du langage JAVA

Un bref historique de Java

Avec différentes éditions, les types d'applications qui peuvent être développées en Java
sont nombreux et variés :

 Applications desktop
 Applications web : servlets/JSP, portlets, applets
 Applications pour appareil mobile (MIDP) : midlets
 Applications pour appareil embarqué (CDC) : Xlets
 Applications pour carte à puce (Javacard) : applets Javacard
 Applications temps réel

17
 Chapitre 1 : Présentation du langage JAVA

LA SYNTAXE DE JAVA
Java est un langage objet qui s’appuie sur la syntaxe du langage C et du C++. Java est un
langage objet : on doit utiliser les classes et les objets ; C++ est un langage orienté objet,
sorte de langage hybride permettant à la fois la programmation classique sans objets et la
programmation avec objets.
La figure ci-dessous présente un programme réalisant la somme des nb
éléments d’un tableau tabEnt d’entiers.

18
 Chapitre 1 : Présentation du langage JAVA

LA SYNTAXE DE JAVA
• Java est sensible à la casse.
• Les blocs de code sont encadrés par des accolades. Chaque instruction se termine par un
caractère ';' (point virgule).
• Une instruction peut tenir sur plusieurs lignes :
Les commentaires
Il existe trois types de commentaire en Java :

19
 Chapitre 1 : Présentation du langage JAVA

LA SYNTAXE DE JAVA
La déclaration de variables
Une variable possède un nom, un type et une valeur.
La déclaration d'une variable permet de réserver la mémoire pour en stocker la valeur.
Le type d'une variable peut être :
• soit un type élémentaire dit aussi type primitif déclaré sous la forme
type_élémentaire variable;
• soit une classe déclarée sous la forme classe variable ;

Rappel : les noms de variables en Java peuvent commencer par une lettre, par le caractère de
soulignement ou par le signe dollar. Le reste du nom peut comporter des lettres ou des nombres
mais jamais d'espaces.
20
 Chapitre 1 : Présentation du langage JAVA

LA SYNTAXE DE JAVA
Les types élémentaires
Les types élémentaires ont une taille identique quelque soit la plate-forme d'exécution :
c'est un des éléments qui permet à Java d'être indépendant de la plate-forme sur laquelle
le code s'exécute

Remarque : Les types élémentaires commencent tous par une minuscule.

21
 Chapitre 1 : Présentation du langage JAVA

LA SYNTAXE DE JAVA
Exemples de déclaration de variables avec ou sans valeur initiale

22
 Chapitre 1 : Présentation du langage JAVA

LA SYNTAXE DE JAVA
Exemples de déclaration de variables avec ou sans valeur initiale

23
 Chapitre 1 : Présentation du langage JAVA

LA SYNTAXE DE JAVA
Exemples de déclaration de variables avec ou sans valeur initiale
Java vérifie qu’une variable locale (à la fonction main() dans cet exemple) est initialisée
avant son utilisation. Si la variable n’est pas initialisée, le compilateur signale un message
d’erreur comme sur les exemples ci-dessous.

24
 Chapitre 1 : Présentation du langage JAVA

LA SYNTAXE DE JAVA
Exemples de déclaration de variables avec ou sans valeur initiale
L’instruction suivante écrit en début de ligne (indiquée par \n), pour chaque variable, son
nom suivi de sa valeur convertie en caractères. L’opérateur + est ici un opérateur de
concaténation de chaînes de caractères.

25
 Chapitre 1 : Présentation du langage JAVA

LA SYNTAXE DE JAVA
Exemple de résultats d’exécution de la classe TypesPrimitifs :

Remarque : pour chaque type, des constantes indiquant les maximums et les minimums sont définies
: Byte.MIN_VALUE, Byte.MAX_VALUE, Short.MIN_VALUE, etc.
26
 Chapitre 1 : Présentation du langage JAVA

LA SYNTAXE DE JAVA

27
 Chapitre 1 : Présentation du langage JAVA

LA SYNTAXE DE JAVA
Les constantes symboliques
Les constantes symboliques sont déclarées comme des variables précédées de final . Leur
contenu ne peut pas être modifié par la suite. L’identificateur de la constante est souvent
écrit en majuscules. Exemples de déclaration de constantes symboliques :

28
 Chapitre 1 : Présentation du langage JAVA

LA SYNTAXE DE JAVA
Les opérateurs arithmétiques, relationnels, logiques
Les opérateurs arithmétiques réalisent des opérations sur des variables entières ou
réelles. Les opérations possibles sont listées ci-après.

Les opérateurs d’incrémentation

29
 Chapitre 1 : Présentation du langage JAVA

LA SYNTAXE DE JAVA
Les opérateurs (relationnels) de comparaison

Les opérateurs logiques

30
 Chapitre 1 : Présentation du langage JAVA

LA SYNTAXE DE JAVA
Le transtypage (cast)
Le transtypage est nécessaire quand il risque d’y avoir perte d’information, comme lors de
l’affectation d’un entier long (64 bits) à un entier int (32 bits), ou d’un réel double vers un
réel float. On force alors le type, indiquant ainsi au compilateur qu’on est conscient du
problème de risque de perte d’information.

Byte  short  int  long  float  double

Remarque : dans les expressions arithmétiques, les entiers de type byte ou short sont considérés
comme des int (convertis d’office en int). Si b1 est un byte, b1 + 1 est considéré être un int.
L’affectation b1 = b1 + 1 est illégale sans cast (de type int -> byte)
31
 Chapitre 1 : Présentation du langage JAVA

LA SYNTAXE DE JAVA
Les tableaux à une dimension : Les tableaux d’éléments de type primitif
Plusieurs éléments de même type peuvent être regroupés (sous un même nom) en tableau.
On peut accéder à chaque élément à l’aide d’un d’indice. Le premier élément porte l’indice
0. Les tableaux sont alloués dynamiquement en Java. Ils sont initialisés par défaut à 0 pour
les nombres et à faux pour les tableaux de booléens.

Exemples de déclarations : tableau de types primitifs (type int) avec allocation et

initialisation du tableau :

(1) et (2) sont identiques et corrects en Java. La forme (2) indique mieux un tableau d’entiers nommé tabEnt, et
initialisé avec les valeurs 1, 2 et 3.

tabEnt est une référence non initialisée vers un tableau d’entiers. 32

 Chapitre 1 : Présentation du langage JAVA

LA SYNTAXE DE JAVA
Les tableaux à une dimension : Les tableaux d’éléments de type primitif
Exemples de déclarations avec allocation dynamique du tableau :

déclare et définit la variable tabEnt comme une référence sur un tableau d’entiers, mais ne
réserve pas de place mémoire pour ce tableau. L’allocation doit se faire avec new en
indiquant le nombre d’éléments. Ci-après, on réserve 10 éléments de type int, numérotés
de 0 à 9.

33
 Chapitre 1 : Présentation du langage JAVA

LA SYNTAXE DE JAVA
Les tableaux à une dimension : Les tableaux d’éléments de type primitif

Ou encore en une seule instruction :

tabEnt.length fournit la longueur déclarée du tableau tabEnt (soit 10 sur l’exemple).

34
 Chapitre 1 : Présentation du langage JAVA

LA SYNTAXE DE JAVA
Les tableaux à une dimension : Les tableaux d’objets
On déclare de la même façon un tableau d’objets. tabBalle est un tableau d’éléments de
type Balle pouvant référencer six objets de type Balle numérotés de 0 à 5.

Les chaînes de caractères étant gérées en Java sous forme de classes, on peut de même
déclarer des tableaux d’objets de type String (chaînes de caractères).

35
 Chapitre 1 : Présentation du langage JAVA

LA SYNTAXE DE JAVA
Les tableaux à une dimension : Les tableaux à plusieurs dimensions
On peut généraliser la notion de tableau à une dimension pour créer des tableaux
multidimensionnels. Un tableau à deux dimensions est un tableau de tableaux.

Un tableau à deux dimensions de deux lignes

et d’un nombre variable de colonnes.

Un tableau d’entiers à deux dimensions de deux

lignes et trois colonnes.

36
 Chapitre 1 : Présentation du langage JAVA

LA SYNTAXE DE JAVA
Les instructions de contrôle (alternatives, boucles)
Les instructions de contrôle du déroulement lors de l’exécution des instructions ont la
même syntaxe que pour le langage C. Leur syntaxe est présentée succinctement ci-
dessous. L’espace n’étant pas significatif en Java, les instructions peuvent être présentées
(indentées) de différentes façons.

37
 Chapitre 1 : Présentation du langage JAVA

LA SYNTAXE DE JAVA
Les instructions de contrôle (alternatives, boucles)

38
 Chapitre 1 : Présentation du langage JAVA

LA SYNTAXE DE JAVA
Les instructions de contrôle (alternatives, boucles)

39
 Chapitre 1 : Présentation du langage JAVA

LA SYNTAXE DE JAVA
Les instructions de contrôle (alternatives, boucles)
Les boucles for, while et do ... while

• exp1 : évaluée avant de commencer la boucle.

• exp2 : condition évaluée en début d’itération ; la boucle continue si exp2 est vraie.
• exp3 : évaluée en fin de chaque itération.

ou encore surtout s’il y a plusieurs instructions dans la boucle :

40
 Chapitre 1 : Présentation du langage JAVA

LA SYNTAXE DE JAVA
Les instructions de contrôle (alternatives, boucles)

41
Plan de cours

 Chapitre 1 : Présentation du langage JAVA

 Chapitre 2 : Classes JAVA
 Chapitre 3 : Héritage
 Chapitre 4 : Exceptions
 Chapitre 5 : Interfaces graphiques (Swing)

42
 Chapitre 2 : Classes JAVA

La notion de classe
Une classe est une extension de la notion de module. Les données et les fonctions traitant
les données sont réunies ensemble dans une classe qui constitue un nouveau type.

La classe Pile (-indique un attribut ou une méthode privé).

43
 Chapitre 2 : Classes JAVA

La notion de classe

Deux objets (deux instances) de la classe Pile.

• Chaque objet a ses propres attributs (en grisé) qui sont privés (encapsulés dans
l’objet).
• Les méthodes par contre ne sont pas dupliquées

44
 Chapitre 2 : Classes JAVA

La notion de classe

Le codage en Java de la classe Pile est indiqué ci-après. Le mot clé "private" indique
que les attributs sommet et element, et la méthode erreur() sont privés.
45
 Chapitre 2 : Classes JAVA

La notion de classe et Objet

Qu’est ce qu’un objet ?

- Toute entité identifiable, concrète ou abstraite, peut être

considérée comme un objet

- Un objet réagit à certains messages qu'on lui envoie de l'extérieur

• la façon dont il réagit détermine le comportement de l'objet

- Il ne réagit pas toujours de la même façon à un même événement

• sa réaction dépend de l’état dans lequel il se trouve

46
 Chapitre 2 : Classes JAVA

La notion de classe et Objet

- Un objet a :
• une adresse en mémoire (identifie l’objet)
• un comportement (ou interface)
• un état interne
- Le comportement est donné par des fonctions ou procédures, appelées
méthodes
- L’état interne est donné par des valeurs de variables d’instances

47
 Chapitre 2 : Classes JAVA

La notion de classe et Objet

Un objet est une instance, un exemplaire construit dynamiquement sur le modèle que
décrit la classe.

48
 Chapitre 2 : Classes JAVA

La notion de constructeur d’un objet

Constructeur : méthode particulière, portant le même nom que la classe et

automatiquement invoquée juste après la création d’une instance.
• Un constructeur peut avoir un nombre quelconque de paramètres.
• Un constructeur sans paramètre est conseillé sur toute classe.
• Un paramètre peut avoir le même nom qu’une variable d’instance.
L’ exécution d’un constructeur débute par une initialisation éventuelle et
automatique des attributs de l’objet si des valeurs ont été données à la déclaration.
Elle se poursuit avec l’exécution des instructions du constructeur

49
 Chapitre 2 : Classes JAVA

La notion de constructeur d’un objet

Exemple :

50
 Chapitre 2 : Classes JAVA

La notion de constructeur d’un objet

Quelques règles concernant les constructeurs
1) un constructeur ne fournit aucune valeur. Dans son en-tête, aucun type ne doit figurer
devant son nom. Même la présence (logique) de void est une erreur :

2) Une classe peut ne disposer d’aucun constructeur. On peut alors instancier des objets
comme s’il existait un constructeur par défaut sans arguments.

3) Un constructeur ne peut pas être appelé directement depuis une autre méthode. :

51
 Chapitre 2 : Classes JAVA

La notion de constructeur d’un objet

Quelques règles concernant les constructeurs
4) Un constructeur peut appeler un autre constructeur de la même classe. Cette possibilité
utilise la sur-définition des méthodes et nécessite l’utilisation du mot clé super

5) Un constructeur peut être déclaré privé (private ). Dans ce cas, il ne pourra plus être
appelé de l’extérieur, c’est-à-dire qu’il ne pourra pas être utilisé pour instancier des objets :

52
 Chapitre 2 : Classes JAVA

La notion de destruction d’un objet

Ramasse-miette
Java dispose d’un ramasse-miette (garbage collector). L’espace mémoire occupé par tout
objet qui n’est plus référencé est automatiquement récupère au bout d’un certain temps.
La méthode finalize
Il est possible, pour toute classe, d’écrire une méthode finalize, automatiquement invoquée
lorsqu’un objet va être récupéré par le GC (Equivalent des destructeurs C++).

53
 Chapitre 2 : Classes JAVA

Affectation et comparaison d’objets

Exemple 1
Supposons que nous disposions d’une classe Point possédant un constructeur à deux
arguments entiers et considérons ces instructions :

Après leur exécution, on aboutit à cette situation :

54
 Chapitre 2 : Classes JAVA

Affectation et comparaison d’objets

Exécutons maintenant l’affectation : a = b ?
Dorénavant, a et b désignent le
même objet, et non pas deux objets
de même valeur

55
 Chapitre 2 : Classes JAVA

Affectation et comparaison d’objets

Exemple 2
Considérons les instructions suivantes :

Notez bien qu’il n’existe ici que deux objets de type Point et trois variables de type
Point (trois références, dont deux de même valeur).

56
 Chapitre 2 : Classes JAVA

Initialisation de référence et référence nulle

En Java, il n’est pas possible de définir une variable locale d’un type primitif sans l’initialiser.
La règle se généralise aux variables locales de type classe .

Considérez cet exemple utilisant une classe Point disposant d’une méthode affiche :

57
 Chapitre 2 : Classes JAVA

La notion de clone
L’affectation de variables de type objet se limite à la recopie de références. Elle ne provoque
pas la recopie de la valeur des objets.
Si on le souhaite, on peut bien entendu effectuer explicitement la recopie de tous les
champs d’un objet dans un autre objet de même type.

Cette démarche est utilisable tant que la classe concernée ne comporte pas de champs de
type classe.
58
 Chapitre 2 : Classes JAVA

La notion de clone
la copie profonde d’un objet : on se contente de recopier la valeur de tous ses champs, y
compris ceux de type classe,

la copie superficielle d’un objet : comme précédemment, on recopie la valeur des

champs d’un type primitif mais pour les champs de type classe, on crée une nouvelle
référence à un autre objet du même type de même valeur.

59
 Chapitre 2 : Classes JAVA

Comparaison d’objet
Les opérateurs == et != s’appliquent théoriquement à des objets. Mais comme ils portent sur
les références elles-mêmes, leur intérêt est très limité.

Ainsi, avec :

Point a, b ;

L’expression a == b est vraie uniquement si a et b font référence à un seul et même objet, et

non pas seulement si les valeurs des champs de a et b sont les mêmes.

60
 Chapitre 2 : Classes JAVA

Règles d’écriture des méthodes

Méthodes fonction
Une méthode peut ne fournir aucun résultat. Le mot clé void figure alors dans son en-tête
à la place du type de la valeur de retour.

Mais une méthode peut aussi fournir un résultat. Nous parlerons alors de méthode
fonction. Voici par exemple une méthode distance qu’on pourrait ajouter à une classe
Point pour obtenir la distance d’un point à l’origine :

61
 Chapitre 2 : Classes JAVA

Règles d’écriture des méthodes

Méthodes fonction
La valeur fournie par une méthode fonction peut apparaître dans une expression,
comme dans ces exemples utilisant les méthodes distance , getX et getY précédentes :

62
 Chapitre 2 : Classes JAVA

Règles d’écriture des méthodes

Arguments muets ou effectifs
Comme dans tous les langages, les arguments figurant dans l’en-tête de la définition d’une
méthode

Il est possible de déclarer un argument muet avec l’attribut final . Dans ce cas, le compilateur
s’assure que sa valeur n’est pas modifiée par la méthode :

Les arguments fournis lors de l’appel de la méthode portent quant à eux le nom d’arguments
effectifs (ou encore paramètres effectifs).

63
 Chapitre 2 : Classes JAVA

Règles d’écriture des méthodes

Conversion des arguments effectifs
Jusqu’ici, nous avions appelé nos différentes méthodes en utilisant des arguments effectifs
d’un type identique à celui de l’argument muet correspondant.

Il faut simplement que la conversion dans le type attendu soit une conversion implicite
légale

64
 Chapitre 2 : Classes JAVA

Règles d’écriture des méthodes

Conversion des arguments effectifs
Voici quelques exemples usuels :

p.deplace (n1, n2) ;

// OK : appel normal
p.deplace (b+3, n1) ;
// OK : b+3 est déjà de type int
p.deplace (b, n1) ;
// OK : b de type byte sera converti en int
p.deplace (n1, q) ;
// erreur : q de type long ne peut être converti en int
p.deplace (n1, (int)q) ;
65
// OK
 Chapitre 2 : Classes JAVA

Règles d’écriture des méthodes

Conversion des arguments effectifs
Voici quelques autres exemples plus insidieux :

p.deplace (b1, b2) ;

// OK : appel normal
p.deplace (b1+1,b2) ;
// erreur : b1+1 de type int ne peut être converti en byte p.
deplace (b1++, b2) ;
// OK : b1++ est de type byte

66
 Chapitre 2 : Classes JAVA

Attributs statiques :
Un attribut statique est un attribut qui est commun à tous les objets que vous pourrez
créer. On peut par exemple citer un compteur du nombres d'instances de classe que vous
aurez lancées.

L'avantage des attributs statiques est que vous pouvez y accéder même si vous n'avez pas
créé d'instance de votre classe. Ainsi, vous pourrez écrire si vous le souhaitez n'importe où
dans une méthode ceci :
System.out.println("Nombre d'instances crées : " + Test.nb);
Ce code affichera 5.
67
 Chapitre 2 : Classes JAVA

Méthodes statiques :
Une méthode statique est une méthode qui peut être appelée même sans avoir instancié la
classe. Une méthode statique ne peut accéder qu'à des attributs et méthodes statiques.

Exemple d'application avec une méthode statique :

Vous pouvez sans avoir instancié la classe accéder à la méthode statique en tapant ceci :
Test.MaMethodeStatique();

n'importe où dans votre code. 68

 Chapitre 2 : Classes JAVA

La surcharge de méthodes :
La surcharge survient lorsque l'on a deux méthodes du même nom mais qui ne prennent pas
les mêmes paramètres. :
Exemple de surcharge de méthode

69
 Chapitre 2 : Classes JAVA

Les packages en Java

Java permet de regrouper les classes en ensembles appelés packages afin de faciliter la
modularité.

70
 Chapitre 2 : Classes JAVA

Les packages en Java

Parmi les paquetages de Java vous avez :

71
 Chapitre 2 : Classes JAVA

Les packages en Java

Nom : chaque paquetage porte un nom.
Ce nom est soit un simple identificateur ou une suite d'identificateurs séparés par des points.
L'instruction permettant de nommer un paquetage doit figurer au début du fichier source
(.java) comme suit:

Dans cette opération nous venons d'assigner toutes les classes du fichier Exemple.java au
paquetage nomtest.

72
 Chapitre 2 : Classes JAVA

Les packages en Java

Si vous avez besoin d'utiliser une classe se trouve dans le paquetage nomtest
import nomtest .*;

Par cette instruction vous avez demandé d'importer toutes les classes se trouvant dans le
paquetage nomtest

Remarques :
1) Le paquetage java.lang est importé automatiquement par le compilateur.
2) import nomtest.*;
• Cette instruction ne va pas importer de manière récursive les classes se
trouvant dans nomtest et dans ses sous paquetages.
• Elle va uniquement se contenter de faire un balayage d'un seul niveau.
• Elle va importer donc que les classes du paquetage nomtest.
import java.awt.*;
import java.awt.event.*; 73
 Chapitre 2 : Classes JAVA

Les packages en Java

Si deux paquetages contiennent le même nom de classe il y a problème!

Par exemple

• la classe List des paquetages java.awt et java.util ou bien la classe Date des paquetages
java.util et java.sql etc.

• Pour corriger ce problème vous devez impérativement spécifier le nom exact du

paquetage à importer (ou à utiliser).

• java.awt.List (ou) java.util.List ; java.util.Date (ou) java.sql.Date

• import java.awt.*; // ici on importe toutes les classes dans awt
• import java.util.*; // ici aussi
• import java.util.List; // ici on précise la classe List à utiliser

74
 Chapitre 2 : Classes JAVA

Classe String
En Java, les chaînes de caractères sont gérées à l’aide de la classe String fournie
en standard dans le paquetage java.lang. Cette gestion diffère du langage C où les
chaînes de caractères sont mémorisées comme une suite de caractères terminée
par 0.
• Le principe d’encapsulation et l’accès direct aux données d’un objet de la classe String
n’est pas possible et les structures de données utilisées sont inconnues.
• La classe String met à la disposition de l’utilisateur un large éventail de méthodes gérant
les chaînes de caractères.

Remarque :

• la chaîne de caractères d’un objet de type String ne peut pas être modifié .
• En cas de modification, les méthodes fournissent un nouvel objet à partir de la chaîne de
l’objet courant et répondant aux caractéristiques de la méthode. Une même chaîne de
caractères (String) peut être référencée plusieurs fois puisqu’on est sûr qu’elle ne peut
pas être modifiée.
• La classe StringBuffer par contre permet la création et la modification d’une chaîne de
caractères. 75
 Chapitre 2 : Classes JAVA

Classe String
Les premières méthodes sont des constructeurs d’un objet de type String.
• String () : crée une chaîne vide
• String (String) : crée une chaîne à partir d’une autre chaîne
• String (StringBuffer) : crée une chaîne à partir d’une autre chaîne de type String-Buffer

Remarque :
String s = "Monsieur" ; est accepté par le compilateur et est équivalent à
String s = new String ("Monsieur") ;

• char charAt (int n) : fournit le n ième caractère de la chaîne de l’objet courant.

• int compareTo (String s) : compare la chaîne de l’objet et la chaîne s ; fournit 0 si =, <0
si inférieur, > 0 sinon.
• String concat (String s) : concatène la chaîne de l’objet et la chaîne s (crée un nouvel
objet).
• boolean equals (Object s) : compare la chaîne de l’objet et la chaîne s.
• boolean equalsIgnoreCase (String s) : compare la chaîne de l’objet et la chaîne s (sans
tenir compte de la casse).
76
 Chapitre 2 : Classes JAVA

Classe String

• int length () : longueur de la chaîne.

• String toLowerCase () : fournit une nouvelle chaîne (nouvel objet) convertie en
minuscules.
• String toUpperCase () : fournit une nouvelle chaîne (nouvel objet) convertie en
majuscules.
• char charAt (int n) : fournit le n ième caractère de la chaîne de l’objet courant.
• int compareTo (String s) : compare la chaîne de l’objet et la chaîne s ; fournit 0 si =, <0 si
inférieur, > 0 sinon.
• String concat (String s) : concatène la chaîne de l’objet et la chaîne s (crée un nouvel
objet).
• boolean equals (Object s) : compare la chaîne de l’objet et la chaîne s.
• boolean equalsIgnoreCase (String s) : compare la chaîne de l’objet et la chaîne s (sans
tenir compte de la casse).
• int length () : longueur de la chaîne.
• String toLowerCase () : fournit une nouvelle chaîne (nouvel objet) convertie en
minuscules.
• String toUpperCase () : fournit une nouvelle chaîne (nouvel objet) convertie en
majuscules. 77
 Chapitre 2 : Classes JAVA

Classe String
• int indexOf (int c) : indice du caractère c dans la chaîne ; -1 s’il n’existe pas.
• int indexOf (int, int) : indice d’un caractère de la chaîne en partant d’un indice donné.
• int indexOf (String s) : indice de la sous-chaîne s.
• int indexOf (String, int) : indice de la sous-chaîne en partant d’un indice.
• int lastIndexOf (int c) : indice du dernier caractère c.
• int lastIndexOf (int, int) : indice du dernier caractère en partant de la fin et d’un indice.
• int lastIndexOf (String) : indice de la dernière sous-chaîne.
• int lastIndexOf (String, int) : indice de la dernière sous-chaîne en partant d’un
indice.
• String replace (char c1, char c2) : crée une nouvelle chaîne en remplaçant le
caractère c1 par c2.
• boolean startsWith (String s) : teste si la chaîne de l’objet commence par s.
• boolean startsWith (String s, int n) : teste si la chaîne de l’objet commence par s en
partant de l’indice n..
78
 Chapitre 2 : Classes JAVA

Classe String
• boolean endsWith (String s) : teste si la chaîne de l’objet se termine par s.
• String substring (int d) : fournit la sous-chaîne de l’objet commençant à l’indice d.
• String substring (int d, int f) : fournit la sous-chaîne de l’objet entre les indices d
(inclus) et f (exclu).
• String trim () : enlève les espaces en début et fin de chaîne.
• L’opérateur + est un opérateur de concaténation de chaînes de caractères souvent utilisé
pour la présentation des résultats à écrire.
• Il peut aussi s’utiliser pour former une chaîne de caractères.
• Les objets de type String ne sont pas modifiables ; il faut donc créer un nouvel objet de
type String si on concatène deux objets de type String.`
• Si les deux opérandes de l’opérateur + sont de type String, le résultat est de type String.
• Si un des deux opérandes est de type String et l’autre de type primitif (entier, réel,
caractère, booléen), le type primitif est converti en un String.
• Si un des deux opérandes est de type String et l’autre est un objet, l’objet est remplacé
par une chaîne de caractères fournie par la méthode toString() de l’objet (ou celle de la
classe Object, ancêtre de toutes les classes)
79
 Chapitre 2 : Classes JAVA

Classe String
class TestString1 {
public static void main (String[] args) {
String ch1 = "Louis"; int i1 = 13;
String ch2 = ch1 + i1; System.out.println ("ch2 : " + ch2);
// Louis13
String ch3 = i1 + ch1; System.out.println ("ch3 : " + ch3);
// 13Louis
String ch4 = ch1 + i1 + 2; System.out.println ("ch4 : " + ch4);
// Louis132
String ch5 = ch1 + (i1 + 2); System.out.println ("ch5 : " + ch5);
// Louis15
//String ch6 = i1 + 2;
// impossible de convertir int en String
String ch7 = "" + i1 + 2;
// 132
System.out.println ("ch7 : " + ch7); String ch8 = i1 + 2 + "";
// 15
System.out.println ("ch8 : " + ch8); String ch9 = Integer.toString (i1 + 2);
80
// 15 } }
 Chapitre 2 : Classes JAVA

Classe String
Résultats d’exécution

81
 Chapitre 2 : Classes JAVA

Classe StringBuffer
Un objet de type StringBuffer représente une chaîne de caractères modifiable. On peut
changer un caractère, ajouter des caractères au tampon interne de l’objet défini avec une
capacité qui peut être changée.

Un objet sb de la classe StringBuffer.

Il contient six caractères et a une capacité de 22 caractères, numérotés de 0 à 21.

82
 Chapitre 2 : Classes JAVA

Classe StringBuffer
Les méthodes de type StringBuffer append () concatènent au tampon de l’objet courant la
représentation sous forme de caractères de leur argument (boolean, int, etc.).
• StringBuffer append (boolean);
• StringBuffer append (char);
• StringBuffer append (char[]);
• StringBuffer append (char[], int, int);
• StringBuffer append (double);
• StringBuffer append (floa );
• StringBuffer append (int);
• StringBuffer append (long);
• StringBuffer append (Object) : ajoute toString() de l’objet.
• StringBuffer append (String).
• StringBuffer insert (int, boolean) ;
• StringBuffer insert (int, char) ;
• StringBuffer insert (int, char[]) ;
• StringBuffer insert (int, double) ;
• StringBuffer insert (int, floa ) ;
• StringBuffer insert (int, int) ; 83
 Chapitre 2 : Classes JAVA

Classe Vector
Lorsque l'on crée un tableau, il faut spécifier sa taille qui est fixe. Java fourni un objet très
utilisé: le vecteur ( classe java.util.Vector ). L'utilisation d'un vecteur plutôt qu'un tableau
est souvent avantageux lorsque la taille finale du tableau n'est pas connue à l'avance. Un
vecteur est un tableau dynamique. La première cellule d'un vecteur est à l'index zéro.
Principales méthodes de la classe Vector
constructeurs :
• Vector() crée un vecteur vide
• Vector(int nombre) crée un vecteur vide de capacité précisée.
• elementCount nombre d'éléments du vecteur
méthodes :
• isEmpty() retourne true si le vecteur est vide
• size() retoune le nombre d'éléments du vecteur
• addElement(Objet) ajoute un élément à la fin du vecteur
• insertElementAt(Objet, int position) ajoute un élément à la position spécifiée
• contains(Objet) retourne true s'il l'Objet se trouve dans le vecteur : la comparaison
se fait par la méthode equals
• ElementAt(int position) renvoie un objet qu'il faut caster.
84
Integer var=(Integer)MonVecteur.elementAt(0);
 Chapitre 2 : Classes JAVA

Classe Stack
La classe stack hérite directement de la classe Vector et ajoute entre autres les méthodes

• push (objet) : ajoute un objet en tête;

• pop () : retire le premier objet;
• peek () : renvoie une référence au premier objet sans le retirer;
• empty () : testUne pile peut aussi contenir des objets de différents types.e si la pile
est vide.
Une pile peut aussi contenir des objets de différents types.

85
 Chapitre 2 : Classes JAVA

Classe Hashtable
la classe Hashtablel peut être vue comme un dictionnaire composé de deux vecteurs : un
vecteur pour la clé et un vecteur pour l'objet.
Une table de clés possède les méthodes :
• put (clé, objet) :
• get(clé) :
• containsKey (clé) :
• containsValue (objet) :
• isEmpty () :
• .......

86
 Chapitre 2 : Classes JAVA

Classe Set
La classe Set définit un ensemble ne pouvant contenir qu'un exemplaire d'un objet.

Cette classe dispose, entre autres, des méthodes :

• add(objet) qui n'ajoute l'objet que s'il n'est pas déjà présent
• contains (objet) ; renvoie true si l'ensemble contient l'élément spécifié.
• remove (objet) ;
• isEmpty () ;
• ………

87
 Chapitre 2 : Classes JAVA

Classe SortedSet
Un SortedSet est un Set qui garantit que le parcours des éléments, du premier au dernier, se
fera dans l’ordre des éléments.

• subSet(E depuis, E jusqua) Retourne le sous ensembles des valeurs comprises entre
depuis (inclus) et jusqu’a (exclu)
• headSet(E jusqua) Retourne le sous ensembles des valeurs comprises entre le premier
élément (inclus) et jusqu’a (exclu)
• tailSet(E depuis) Retourne le sous ensembles des valeurs à partir de l'élément depuis
(inclus) jusqu'à la fin.
• E first() Retourne le premier élément.
• E last() Retourne le dernier élément.

88
Plan de cours

 Chapitre 1 : Présentation du langage JAVA

 Chapitre 2 : Classes JAVA
 Chapitre 3 : Héritage
 Chapitre 4 : Exceptions
 Chapitre 5 : Interfaces graphiques (Swing)

89
 Chapitre 3 : Héritage JAVA

Héritage
Une classe Java dérive toujours d’un autre classe, Object quand rien n’est spécifié. Pour
spécifier de quelle classe hérite une classe on utilise le mot-clé extends :

La classe D dérive de la classe B. On dit que le classe B est la super classe.

La visibilité protected rend l'accès possible :

• depuis les classes dérivée.

• depuis les classes du paquetage.

90
 Chapitre 3 : Héritage JAVA

Héritage : exemple

class B{ class D extends B {

private int a; int x;
protected int b; void f(){
int c; b = …;
public int d; }
} }
On peut alors représenter un objet de la classe D de la façon suivante :

91
 Chapitre 3 : Héritage JAVA

Héritage
Une référence à une classe de base peut être affectée d’une référence à une classe dérivée,
l’inverse doit faire l’objet d’une opération de conversion de type ou cast :

• B b = new B();
• D d = new D();
• b = d; // OK
• d = b; // interdit
• d = (D) b ; // OK avec cast
Remarque : Cette dernière instruction peut lever une exception si le cast est impossible.

92
 Chapitre 3 : Héritage JAVA

Constructeurs et héritage

class X{
int x;
public X (int x){ class Y extends X{
this.x = x;
} }
}

provoque l'erreur de compilation : le super constructeur implicite X() n'est pas défini pour le
constructeur par défaut.
Chaque instance est munie de deux références particulières :
• this réfère l’instance elle-même.
• super réfère la partie héritée de l’instance.

93
 Chapitre 3 : Héritage JAVA

Opérateur instanceof
L’opérateur instanceof permet de savoir à quelle classe appartient une instance :

class B{ …}
class D extends B{…}
class C {…}
B b = new B();
D d = new D();
C c = new C();
b instanceof B
// true
b instanceof D
// false
d instanceof B
// true
d instanceof D
// true
c instanceof B
94
// erreur de compilation Erreur No. 365 : // impossible de comparer C avec B
 Chapitre 3 : Héritage JAVA

Opérateur instanceof
la méthode equals(Object o), pour une classe X, est définie, en général, de la façon suivante :

public boolean equals(Object o){

if(this==o) return true;
if(!(o instanceof X)) return false;
X x = (X)o;
...
}

95
 Chapitre 3 : Héritage JAVA

Redéfinition des méthodes

class B { class B {
void m(){ void m(){
System.out.println( "méthode m de B"); System.out.println(
} "méthode m de B");
} }
class D extends B{ }
} class D extends B{
void m(){
System.out.println(
"méthode m de D");
}
}

96
 Chapitre 3 : Héritage JAVA

Redéfinition des méthodes

Remarque
Ne pas confondre la redéfinition avec la surcharge :
• Redéfinition : même type de retour et mêmes paramètres.
• Surcharge : type de retour et paramètres différents, les paramètres au moins
doivent être différents.

97
 Chapitre 3 : Héritage JAVA

Héritage : Classe abstraite

Une classe définie avec le modificateur abstract est une classe abstraite qui ne peut pas
produire d’instance.
• Sa définition peux contenir des méthodes abstraites.
• Une classe qui contient une méthode abstraite doit être abstraite.
• Une méthode abstraite est une méthode définie uniquement par son prototype.
• Le rôle des classes abstraites est la factorisation de fonctionnalités communes à
plusieurs classes dérivées.

98
 Chapitre 3 : Héritage JAVA

Héritage : Exemple
Supposons que nous définissions la classe suivante :

99
 Chapitre 3 : Héritage JAVA

Héritage : Exemple
Un chef «est un» employé qui a une prime en plus du salaire :

La méthode getSalaire pourrait être (mieux ?) programmée de la façon suivante : cela

permettrait de changer les accès de nom et salaire en private.

100
 Chapitre 3 : Héritage JAVA

Héritage : Exemple
Une entreprise est un tableau d’employés :

L’affichage des noms et salaires des différents employés se fera de la façon suivante :

101
 Chapitre 3 : Héritage JAVA

Héritage : Exemple
Le calcul de la somme des salaires des employés qui ne sont pas des chefs ?

102
 Chapitre 3 : Héritage JAVA

Héritage : Interface
Java n’autorise que l’héritage simple. Une classe ne peut avoir qu’une seule superclasse. Une
certaine forme d’héritage multiple est obtenue grâce à la notion d’interface.

Une interface définit uniquement des constantes et des prototypes de méthodes.

103
 Chapitre 3 : Héritage JAVA

Héritage : Interface

104
Plan de cours

 Chapitre 1 : Présentation du langage JAVA

 Chapitre 2 : Classes JAVA
 Chapitre 3 : Héritage
 Chapitre 4 : Exceptions
 Chapitre 5 : Interfaces graphiques (Swing)
 Chapitre 6 : JDBC

105
 Chapitre 4 : Exceptions JAVA

Exceptions
 Mécanisme permettant de traiter les comportements exceptionnels.
 Constituent un moyen fiable et pratique d’effectuer un contrôle des erreurs rigoureux sans
alourdir le code.
 La notion d’erreur fait partie intégrante de la fonction

En Java, la fonction peut lancer une exception en indiquant un type d’exception.

• L’exception se "propage" de retour de méthode en retour de méthode jusqu’à ce
qu’une méthode la traite.
• Si aucune méthode ne la prend en compte, il y a un message d’erreur d’exécution.
• Suite à une exception, toutes les instructions sont ignorées, sauf les instructions
chargées de capter cette exception.

106
 Chapitre 4 : Exceptions JAVA

Les exceptions de type RunTimeException

L’exécution du programme suivant provoque un message d’erreur indiquant une exception du
type ArrayIndexOutOfBoundsException, et l’arrêt du programme. Le tableau de 4 entiers
tabEnt a des indices de 0 à 3. L’accès à la valeur d’indice 5 provoque une exception non
captée.

107
 Chapitre 4 : Exceptions JAVA

Les exceptions de type RunTimeException

Dans le programme suivant, la même erreur d’accès à un élément est captée par le
programme. Lors de la rencontre de l’erreur, les instructions en cours sont abandonnées et un
bloc de traitement (catch) de l’exception est recherché et exécuté. Le traitement se poursuit
après ce bloc sauf indication contraire du catch (return ou arrêt par exemple). Le message
"Fin du main" est écrit après interception de l’exception.

Exemples de résultats d’exécution :

108
 Chapitre 4 : Exceptions JAVA

Exemple2 : les débordements de tableaux (dans une méthode)

l’instruction tabEnt[4] provoque
une exception dans la méthode
initTableau(). L’instruction qui suit
n’est pas prise en compte ;
l’exception n’est pas traitée dans
initTableau(). Les instructions qui
suivent l’appel de initTableau() dans
main() (le programme appelant) sont
ignorées également. Par contre, il
existe un bloc catch qui traite
l’exception. Le message "Fin de
main" est lui pris en compte après
le traitement de l’exception.
Exception :
java.lang.ArrayIndexOutOfBoundsException
Fin de main

109
 Chapitre 4 : Exceptions JAVA

Exemple2 : les débordements de tableaux (dans une méthode)

L’exception peut aussi être traitée dans initTableau() comme indiqué ci-dessous. Le
programme se poursuit normalement une fois le bloc catch exécuté (retour de initTableau(),
appel de ecrireTableau() et message de fin).

110
 Chapitre 4 : Exceptions JAVA

Autres exemples d’exceptions de type RunTimeException

L’instructions suivante provoque une exception de type NullPointerException. s1 est une
référence null sur un (futur) objet de type String. On ne peut pas accéder au troisième caractère
de l’objet String référencé par null, d’où l’exception.
Le programme suivant
donne des exemples où une
exception est lancée : chaîne
à convertir en entier ne
contenant pas un entier
(lecture erronée d’un entier
par exemple), division par
zéro, transtypage non
cohérent de deux objets de
classes différentes, essai
d’ouverture d’un fichier
n’existant pas

111
 Chapitre 4 : Exceptions JAVA

La définition et le lancement d’excepetion

Afin de définir une nouvelle sorte d’exception, on crée une nouvelle classe en utilisant une
déclaration de la forme suivante :

la déclaration suivante définit bien une nouvelle classe d’exception PasDefini :

Sachant que Error est prédéfinie en Java

112
 Chapitre 4 : Exceptions JAVA

La définition et le lancement d’excepetion

Il existe de nombreuses classes d’exceptions prédéfinies en Java, que l’on peut classer en trois
Catégories :
• Celles définies en étendant la classe Error : elles représentent des erreurs critiques qui ne
sont pas censée être gérées en temps normal. Par exemple, une exception de type
OutOfMemoryError est lancée lorsqu’il n’y a plus de mémoire disponible dans le système.
• Celles définies en étendant la classe Exception : elles représentent les erreurs qui doivent
normalement être gérées par le programme. Par exemple, une exception de type
IOException est lancée en cas d’erreur lors de la lecture d’un fichier
• Celles définies en étendant la classe RuntimeException : elles représente des erreurs
pouvant éventuellement être gérée par le programme. L’exemple typique de ce genre
d’exception est NullPointerException, qui est lancée si l’on tente d’accéder au contenu
d’un tableau ou d’un objet qui vaut null.

113
 Chapitre 4 : Exceptions JAVA

La définition et le lancement d’excepetion

Chaque nouvelle exception définie entre ainsi dans l’une de ces trois catégories. Si on suit ce
classement, l’exception PasDefini aurait due être déclarée par :

class PasDefini extends Exception {}

ou bien par :

class PasDefini extends RuntimeException {}

car elle ne constitue pas une erreur critique.

114
 Chapitre 4 : Exceptions JAVA

Lancer excepetion
Lorsque l’on veut lancer une exception, on utilise le mot clé throw suivi de l’exception à
lancer, qu’il faut auparavant la créer avec new NomException(), de la même manière que
lorsque l’on crée un nouvel objet par un appel à l’un de des constructeurs de sa classe. Ainsi
lancer une exception de la classe PasDefini s’écrit :

throw new PasDefini();

Lorsqu’une exception est levée, l’exécution normale du programme s’arrête et on saute toutes
les instructions jusqu’à ce que l’exception soit rattrapée ou jusqu’à ce que l’on sorte du
programme. Par exemple, si on considère le code suivant 1 :

115
Chapitre 4 : Exceptions JAVA

116
Plan de cours

 Chapitre 1 : Présentation du langage JAVA

 Chapitre 2 : Classes JAVA
 Chapitre 3 : Héritage
 Chapitre 4 : Exceptions
 Chapitre 5 : Interfaces graphiques (Swing)
 Chapitre 6 : JDBC

117
 Chapitre 5 : Interfaces graphiques (Swing)

Les packages IHM de Java

 java.awt : (awt : abstract window toolkit, java1.1) bas niveau. Anciens composants, dits
composants lourds (ils sont opaques et affichés en dernier).

 javax.swing : java 1.2. Composants légers = pas de code natif (écrits entièrement en
java).
 SWT: la version IBM utilisée dans Eclipse

 La librairie AWT utilise certaines des fonctions du système d’exploitation (pour

l’affichage des fenêtres par exemple). Un même composant AWT aura une apparence
différente sur différentes plate-formes. La portabilité est assurée, mais l’apparence peut
être différente à partir du même fichier de bytecode (un même .class).

 La librairie Swing est totalement gérée par la machine virtuelle ce qui permet de ne plus
se limiter au sous-ensemble de composants graphiques communs à toutes les plates-
formes.

 Swing définit de nouveaux composants. Cependant, la bibliothèque Swing nécessite plus

de temps CPU, car la machine virtuelle doit dessiner les moindres détails des composants
118
 Chapitre 5 : Interfaces graphiques (Swing)

Architecture MVC
La conception des classes Swing s’appuie assez librement sur l’architecture MVC
(Modèle/Vue/Contrôleur).
Le patron modèle-vue-contrôleur (en abrégé MVC, de l'anglais model-view-controller), tout
comme les patrons modèle-vue-présentation ou Présentation, abstraction, contrôle, est un
modèle destiné à répondre aux besoins des applications interactives en séparant les
problématiques liées aux différents composants au sein de leur architecture respective.

Ce paradigme regroupe les fonctions nécessaires en trois catégories :

 un modèle (modèle de données) ;
 une vue (présentation, interface utilisateur) ;
 un contrôleur (logique de contrôle, gestion des événements, synchronisation).

119
 Chapitre 5 : Interfaces graphiques (Swing)

Modèle
 Le modèle représente le cœur (algorithmique) de l'application : traitements des données,
interactions avec la base de données, etc.

 La base de données sera l'un de ses composants. Le modèle comporte des méthodes
standards pour mettre à jour ces données (insertion, suppression, changement de valeur). Il
offre aussi des méthodes pour récupérer ces données.

 Le modèle peut autoriser plusieurs vues partielles des données. Si par exemple le
programme manipule une base de données pour les emplois du temps, le modèle peut
avoir des méthodes pour avoir tous les cours d'une salle, tous les cours d'une personne ou
tous les cours d'un groupe de TD.

120
 Chapitre 5 : Interfaces graphiques (Swing)

Vue
Ce avec quoi l'utilisateur interagit se nomme précisément la vue.
 Sa première tâche est de présenter les résultats renvoyés par le modèle.
 Sa seconde tâche est de recevoir toute action de l'utilisateur (clic de souris, sélection
d'un bouton radio, entrée de texte, de mouvements, de voix, etc.). Ces différents
événements sont envoyés au contrôleur.
 La vue n'effectue pas de traitement, elle se contente d'afficher les résultats des
traitements effectués par le modèle et d'interagir avec l'utilisateur.

121
 Chapitre 5 : Interfaces graphiques (Swing)

Contrôleur

 Le contrôleur prend en charge la gestion des événements de synchronisation pour mettre à

jour la vue ou le modèle et les synchroniser.
 Il reçoit tous les événements de la vue et déclenche les actions à effectuer.
 Si une action nécessite un changement des données, le contrôleur demande la
modification des données au modèle afin que les données affichées se mettent à jour.
 Le contrôleur n'effectue aucun traitement, ne modifie aucune donnée. Il analyse la requête
du client et se contente d'appeler le modèle adéquat et de renvoyer la vue correspondant à
la demande.

122
 Chapitre 5 : Interfaces graphiques (Swing)

Swing : JFrame et superclasses

123
 Chapitre 5 : Interfaces graphiques (Swing)

Swing
Une interface graphique Swing est un arbre qui part d'un objet du système (heavyweight):
 Une fenêtre en java est représentée par la classe Window (package java.awt). Mais on
utilise rarement Window directement car cette classe ne définit ni bords ni titre pour la
fenêtre.
 Dans une application Swing standard, on instanciera un cadre JFrame qui permet d’avoir
une fenêtre principale avec un titre et une barre de menu

 Les noms de composants Swing commencent (souvent) par J

 tous héritent du composant graphique Jcomponent
 JComponent hérite du composant graphique AWT Container qui permet à un composant
d'en contenir d'autres

124
 Chapitre 5 : Interfaces graphiques (Swing)

Swing JFrame

JFrame est la classe permettant de faire une «application». Une instance de JFrame est
composée d'un JRootPane lui même composé de :
exemple d'application
 LayeredPane
 MenuPane : le menu
 ContentPane : les composants
 GlassPane : peut servir à intercepter des événements souris.
 décorations
 Bordure
 Titre
 boutons d'iconification et fermeture
 icone

125
 Chapitre 5 : Interfaces graphiques (Swing)

Swing : JFrame
L'exemple suivant démarre une application avec titre et icône

126
 Chapitre 5 : Interfaces graphiques (Swing)

Swing : JFrame
Visualisation des apparences
Une application a une apparence (metal, motif, Windows, Windows classic, Nimbus, etc ...),
l'exemple suivant permet de visualiser les différents «look and feel» d'une application
(exécuter)

127
 Chapitre 5 : Interfaces graphiques (Swing)

Swing : JComponent
JComponent est la classe de base de tous les composants Swing, à part JFrame, JDialog et
Japplet.

128
 Chapitre 5 : Interfaces graphiques (Swing)

Swing : JComponent
Un JComponent a les caractéristiques suivantes :

 un ToolTipText : un texte de conseil au survol du composant par la souris. Les deux

méthodes getToolTipText et setToolTipText permettent de manipuler ce texte, qui peut
être du texte brut, ou du texte HTML.
 une bordure, et une façon de se dessiner : la bordure est manipulée par les méthodes
setBorder( Border b) et getBorder() et la façon de se dessiner est définie par la méthode
void paintComponent(Graphics g) du composant.

les bordures prédéfinies sont :

 Etched
 Bevel
 Line
 Matte
 Title
 Compound

129
 Chapitre 5 : Interfaces graphiques (Swing)

Swing : JComponent

Un composant est soit opaque soit transparent : void setOpaque(boolean b)

 lorsqu'il est opaque l'affichage se fait en appelant d'abord paintComponent,
puis paintBorder et enfin paintChildren.
 lorsqu'il est transparent, il faut d'abord afficher les composant qui sont
dessous.
 une taille minimale, une taille maximale un alignement en X et en Y : toutes ces
propriétés sont utilisées par le LayoutManager qui place le composant dans l'interface.
 un nom : setName(String n) peut être utile pour des composant n'affichant pas de
texte.
 des propriétés : une propriété est un couple (nom, valeur). Les propriétés sont utilsées
par exemple pour spécifier les contraintes pour certains gestionnaires de placement.
 Un composant peut être actif : setEnabled(true) ou inactif.
 ...

130
 Chapitre 5 : Interfaces graphiques (Swing)

Swing : événements
Les composants Swing créent des événements, soit directement, soit par une action de
l'utilisateur sur le composant. Ces événements peuvent déclencher une action exécutée par
d'autre(s) composant(s).
 Un composant qui crée des événements est appelé source. Le composant source délègue le
traitement de l'événement au composant auditeur.
 Un composant qui traite un événement est appelé auditeur (listener)
Un composant auditeur doit s'inscrire auprès du composant source des événements qu'il veut
traiter.

131
 Chapitre 5 : Interfaces graphiques (Swing)

Swing : événements
Hiérarchie : Schéma de la hiérarchie simplifiée des événements java

132
 Chapitre 5 : Interfaces graphiques (Swing)

Swing : événements
ActionEvent

Les composants sources de ActionEvent sont :

 Boutons : JButton, JRadioButton, JCheckBox, JToggleButton
 Menus : JMenuItem, JMenu, JRadioButtonMenuItem, JCheckBoxMenuItem
 Texte : JTextField
133
 Chapitre 5 : Interfaces graphiques (Swing)

Swing : événements
MouseEvent

Tous les composants

peuvent être sources de
MouseEvent . Lors d'un clic
les méthodes sont appelées
dans l'ordre suivant :
 mousePressed
 mouseReleased
 mouseClicked

134
 Chapitre 5 : Interfaces graphiques (Swing)

Swing : événements
KeyEvent

Tous les composants peuvent être sources de KeyEvent

135
 Chapitre 5 : Interfaces graphiques (Swing)

Swing : événements
Adaptateur
Un adaptateur XxxAdapter est une classe abstraite qui fourni une implémentation de la classe
XxxListener. Les méthodes implémentées sont toutes vides, et ainsi permettent à un
utilisateur de l'adaptateur de ne redéfinir que le traitement qui l'intéresse.

Exemple : Un adaptateur qui ne redéfinit que KeyPressed et keyTyped :

136
Plan de cours

 Chapitre 1 : Présentation du langage JAVA

 Chapitre 2 : Classes JAVA
 Chapitre 3 : Héritage
 Chapitre 4 : Exceptions
 Chapitre 5 : Interfaces graphiques (Swing)
 Chapitre 6 : JDBC

137