Java Zriouile

2éme année DSI POO-Java-
SOMMAIRE
Chapitre 1 : Programmation Orientée Objets ............................................................................ 6
1. De la programmation classique vers la programmation orientée objet ............................................. 6
2. Concepts de la Programmation Orientée Objets ............................................................................. 6
2.1 Objet .............................................................................................................................................. 7
2.2 Classe ............................................................................................................................................ 7
2.3 Encapsulation ................................................................................................................................. 7
2.4 Héritage ......................................................................................................................................... 7
2.5 Polymorphisme .............................................................................................................................. 8
3. Comment penser POO.................................................................................................................... 8
Chapitre 2 : Vue d’ensemble de la plate-forme Java .............................................................. 9
1. Introduction ..................................................................................................................................... 9
2. Caractéristiques ................................................................................................................................ 9
3. La plateforme Java ........................................................................................................................... 9
4. Java : de l’édition à l’exécution ....................................................................................................... 10
5. Le Java SE Development Kit ......................................................................................................... 10
6. Java : les éditions ............................................................................................................................ 10
7. Génération de code exécutable dans les langages de programmation ........................................... 10
8. Génération de code en java ............................................................................................................ 11
9. Différents modes de compilation ................................................................................................... 11
10. Avantages de la JVM pour Internet ............................................................................................ 11
11. Exemple: Mon premier programme en Java .............................................................................. 12
12. Exécution d’un programme Java ................................................................................................ 13
Chapitre 3 : Structures de contrôle ............................................................................................ 14
1. Variables ........................................................................................................................................ 14
1.1. Déclaration des variables........................................................................................................ 14
1.2. Initialisation des variables....................................................................................................... 14
2. Style de programmation non standard ........................................................................................... 15
3. L’affectation ................................................................................................................................... 15
4. Types de données en Java .............................................................................................................. 15
4.1. Types primitifs ....................................................................................................................... 15
4.2. Type objet: Constante null ..................................................................................................... 17
5. Transtypage.................................................................................................................................... 17
6. Principaux opérateurs .................................................................................................................... 18
6.1. Opérateurs arithmétiques....................................................................................................... 18
6.2. Opérateurs d’affectation ......................................................................................................... 18
6.3. Opérateurs d’incrémentations et décrémentations ................................................................ 18
Prof : R.ZRIOUILE Page 1
6.4. Opérateurs relationnels .......................................................................................................... 18

6.5. Opérateurs logiques ............................................................................................................... 19
6.6. Opérateurs bit à bit ................................................................................................................ 19
7. Instructions de contrôle ................................................................................................................. 19
Chapitre 4 : les Classes et les Objets ........................................................................................ 21
1. Création d’une classe ..................................................................................................................... 21
2. Création et manipulation d’Objets ................................................................................................. 22
2.1. Introduction ........................................................................................................................... 22
2.2. Etapes de création des Objets ................................................................................................ 22
2.3. Création d’un objet ................................................................................................................ 23
2.4. Initialisation par défaut........................................................................................................... 24
3. Définition des méthodes ................................................................................................................ 24
4. Accès aux membres d’un objet ...................................................................................................... 25
4.1. Accès aux attributs (données membres) ................................................................................. 25
4.2. Accès aux méthodes: appels des méthodes ............................................................................ 26
5. Encapsulation (accessibilité) ........................................................................................................... 27
6. Méthodes d’accès aux valeurs des variables depuis l’extérieur ....................................................... 29
7. Autoréférences: emploi de this ...................................................................................................... 31
8. Champs de classe (variable de classe)............................................................................................. 32
9. Les constructeurs ........................................................................................................................... 32
9.1. Définition de Constructeur .................................................................................................... 32
9.2. Quelques règles concernant les constructeurs ........................................................................ 33
9.3. Surcharge des constructeurs (Plusieurs constructeurs) ........................................................... 34
9.4. Utilisation du mot clé this dans un constructeur .................................................................... 35
Chapitre 5: les tableaux ................................................................................................................. 36
1. Tableaux unidimensionnels ........................................................................................................... 36
1.1. Déclaration de tableaux.......................................................................................................... 36
1.2. Création par l’opérateur new.................................................................................................. 36
1.3. Initialisation............................................................................................................................ 36
1.4. La taille d’un tableau : length ................................................................................................. 36
1.5. Utilisation d’un tableau .......................................................................................................... 37
1.6. Affectation de tableaux........................................................................................................... 37
2. Tableaux multidimensionnels ........................................................................................................ 38
Chapitre 6 : Héritage et polymorphisme ................................................................................... 40
1. Principe de l'héritage ...................................................................................................................... 40
1.1. Présentation ........................................................................................................................... 40

1.2. Appel des constructeurs ......................................................................................................... 41

1.3. Accès d’une classe dérivée aux membres de sa classe de base ............................................... 41
1.4. Redéfinition ........................................................................................................................... 42
2. Polymorphisme .............................................................................................................................. 42
2.1. Surclassement (upcasting) et Déclassement (downcasting) ..................................................... 44
2.2. Régles du polymorphisme en Java ......................................................................................... 44
3. La classe Object ............................................................................................................................. 44
4. Les classes abstraites ...................................................................................................................... 46
4.1. Concept des classes abstraites ................................................................................................ 46
4.2. . Règles des classes abstraites.................................................................................................. 47
4.3. Intérêt des classes abstraites ................................................................................................... 47
5. Les interfaces ................................................................................................................................. 48
5.1. Concept d’interface ................................................................................................................ 48
5.2. Syntaxe ................................................................................................................................... 48
5.3. Interface et dérivations ........................................................................................................... 49
5.4. Conflits des noms................................................................................................................... 50
Chapitre 7 : Gestion d’exception ................................................................................................. 51
1. Présentation ................................................................................................................................... 51
2. Classement des exceptions ............................................................................................................. 51
3. Structure de gestion d’exceptions : le bloc try… catch… finally ....................................................... 52
4. Définition et lancement des exceptions utilisateurs(throws et throw) ............................................. 53
5. Gestion de plusieurs exceptions et transmission d’information ...................................................... 55
Chapitre 8 : Interfaces Comparables et Cloneables/Classes enveloppes56 ................. 56
1. Interfaces Comparables ................................................................................................................. 56
2. Interfaces Cloneables ..................................................................................................................... 56
3. Classes enveloppes ......................................................................................................................... 59
Chapitre 9 : Flux d’entrées sorties.............................................................................................. 61
1. Présentation ................................................................................................................................... 61
2. Création séquentielle d’un fichier binaire ...................................................................................... 63
3. Liste séquentielle d’un fichier binaire............................................................................................. 64
4. Accès directe à un fichier binaire ................................................................................................... 66
5. Création d’un fichier texte.............................................................................................................. 67
6. Lecture d’un fichier texte ............................................................................................................... 68
6.1. Accès aux lignes d’un fichier texte .......................................................................................... 68
6.2. La classe StringTokenizer ...................................................................................................... 69
7. La gestion des fichiers: la Classe File.............................................................................................. 70

7.1. Création d’un objet de type File ............................................................................................. 70

7.2. les méthodes de la classe File ................................................................................................. 70
8. sérialisation et désérialisation ......................................................................................................... 72
8.1. Interface Serializable .............................................................................................................. 72
8.2. Etapes de sérialisation: Ecrire un objet sérialisé dans un fichier ............................................. 73
8.3. Etapes désérialisation ............................................................................................................. 73
Chapitre 10 : Collections ............................................................................................................... 75
1. Définition ....................................................................................................................................... 75
2. Interfaces ....................................................................................................................................... 75
3. Description des interfaces .............................................................................................................. 75
3.1. Interface Collection................................................................................................................ 75
3.2. List ......................................................................................................................................... 76
3.3. Interface Set ........................................................................................................................... 80
3.4. Map........................................................................................................................................ 81
3.5. Description des algorithmes ................................................................................................... 82
Chapitre 11 : Threads ..................................................................................................................... 85
1. Notion de threads .......................................................................................................................... 85
2. Thread et interface runnable.......................................................................................................... 85
3. Durée de vie d’un thread ............................................................................................................... 87
4. Sommeil d'un thread ...................................................................................................................... 88
5. La classe Timer .............................................................................................................................. 88
6. Synchronisation.............................................................................................................................. 89
Chapitre 12 : Interfaces graphiques .......................................................................................... 91
1. Présentation ................................................................................................................................... 91
2. Première fenêtre ............................................................................................................................ 91
2.1. La classe JFrame .................................................................................................................... 91
2.2. Action sur les caractéristiques d’une fenêtre .......................................................................... 92
3. Composants atomiques .................................................................................................................. 92
3.1. Création d’un bouton et ajout dans la fenêtre ........................................................................ 92
3.2. Création d’une case à cocher et ajout dans la fenêtre ............................................................. 92
3.3. Création de Bouton Radio ..................................................................................................... 93
3.4. Création des étiquettes ........................................................................................................... 94
3.5. Création des champs de texte ................................................................................................ 94
3.6. Création des boites de liste..................................................................................................... 94
3.7. Création des boites de liste combinée .................................................................................... 96
4. Gestionnaires de mise en forme..................................................................................................... 96

4.1. BorderLayout......................................................................................................................... 97
4.2. FlowLayout ............................................................................................................................ 97
4.3. CardLayout ............................................................................................................................ 98
4.4. GridLayout............................................................................................................................. 99
4.5. BoxLayout ............................................................................................................................. 99
4.6. Programme sans gestionnaire de mise en forme ............................................................... 100
4.7. Une classe Insets pour gérer les marges ............................................................................... 100
5. JTextArea..................................................................................................................................... 101
6. JTable .......................................................................................................................................... 101
6.1. Tables simples ..................................................................................................................... 102
6.2. Modèles de table .................................................................................................................. 102

Chapitre 1 : Programmation Orientée Objets

1. De la programmation classique vers la programmation orientée objet
La programmation classique telle que étudiée au travers des langages C, Pascal...
définie un programme comme étant un ensemble de données sur lesquelles agissent des
procédures et des fonctions. Les données constituent la partie passive du programme. Les
procédures et les fonctions constituent la partie active.
Programmer dans ce cas revenait à :
- définir un certain nombre de variables (structures, tableaux...)
- écrire des procédures pour les manipuler sans associer explicitement les unes aux
autres.
Exécuter un programme se réduit alors à appeler ces procédures dans un ordre décrit
par le séquençage des instructions et en leur fournissant les données nécessaires à
l’accomplissement de leurs tâches.
Problèmes de la programmation procédurale :

 Instructions exécutées à la suite
 Il n’y a pas de méthode ou de cadre pour bien organiser les fonctions.
 Un seul résultat possible
 Allocation mémoire définie
 Inutilisable pour un logiciel
 Les modifications d’une fonction entraînent d’autres modifications dans autre
fonctions, etc. – la portée d’une modification est trop grande et difficile à gérer.
 Redondance dans le code (la même chose est codée plusieurs fois)
 Propagation des erreurs – débogage difficile
Dans cette approche données et procédures sont traitées indépendamment les unes des
autres sans tenir compte des relations étroites qui les unissent.
Les questions qu’on peut poser dans ce cas :
1. Cette séparation (données, procédures) est-elle utile ?
2. Pourquoi privilégier les procédures sur les données (Que veut-on faire ?) ?
3. Pourquoi ne pas considérer que les programmes sont avant tout des
ensembles objets informatiques caractérisé par les opérations qu’ils connaissent ?
Les langages objets sont nés pour répondre à ces questions. Ils sont fondés sur la
connaissance d’une seule catégorie d’entités informatiques : les objets.
Un objet incorpore des aspects statiques et dynamiques au sein d’une même notion. Avec les
objets ce sont les données qui deviennent prépondérantes. On répond tout d’abord à la
question « De quoi parle-t-on ? »
2. Concepts de la Programmation Orientée Objets
La POO se base sur les notions clés suivantes :
- Encapsulation
- Abstraction
- Classe et objets

- Héritage
- Polymorphisme
2.1 Objet
Un objet est une structure informatique caractérisée par un état et un ensemble d'opérations
exécutables par cet objet qui caractérise son comportement.
Objet = état + comportement (opérations)
Exemple:
Une Fenêtre :
Etat : position, taille, bordure, titre, couleur,...
Opérations: déplacer, réduire, agrandir...
Un Fichier :
Etat : nom, directory, id, protections, propriétaire, contenu,
Opérations : ouvrir, fermer, détruire,
2.2 Classe
Une classe c’est la description d’un ensemble d’objets ayant une structure de données
commune et disposant des mêmes méthodes. Les objets apparaissent alors comme des
variables d’un tel type classe (en P.O.O., on dit aussi qu’un objet est une instance de sa
classe). Bien entendu, seule la structure est commune, les valeurs des champs étant propres à
chaque objet. En revanche, les méthodes sont effectivement communes à l’ensemble des
objets d’une même classe.
Exemple : Materiel
Personne
-Nom :String -Nom :String
-Prenom :String -Prix :int
-Age :int -Nombre :int
+affiche() :void +affiche() :void
+calculeAge() :int +achete() :void
Classe Instances
-Nom : Meknassi
Personne -Prenom :Ali
-Nom :String -Age :23
-Prenom :String Instanciatio
-Age :int n -Nom : Kadiri
+affiche() :void -Prenom :Hamza
+calculeAge() :int -Age :30
2.3 Encapsulation
L’Encapsulation signifie qu’il n’est pas possible d’agir directement sur les données d’un
objet; il est nécessaire de passer par ses méthodes, qui jouent ainsi le rôle d’interface
obligatoire. On traduit parfois cela en disant que l’appel d’une méthode est en fait l’envoi
d’un message à l’objet.
2.4 Héritage
L’héritage permet de définir une nouvelle classe à partir d’une classe existante (qu’on réutilise
en bloc !), à laquelle on ajoute de nouvelles données et de nouvelles méthodes. La conception
de la nouvelle classe, qui hérite des propriétés et des aptitudes de l’ancienne, peut ainsi
s’appuyer sur des réalisations antérieures parfaitement au point et les spécialiser à volonté.
Comme on peut s’en douter, l’héritage facilite largement la réutilisation de produits existants,

d’autant plus qu’il peut être réitéré autant de fois que nécessaire (la classe C peut hériter de B,
qui elle-même hérite de A).
Exemple :
Personne Materiel
-nom :string -nom :string
-prenom :string -prix :int
-age :int -nombre :int
+calculeAge() :int +achete() :void
Etudiant Enseignant Telephone Ordinateur

-cne:int -ppr:int -autonomie:int -µp:string
-3G:boole -fréquence:int
-resolution:string -memoire:string
2.5 Polymorphisme
Le polymorphisme (de poly et morphe : plusieurs formes) est un mécanisme qui permet de
redéfinir certain méthodes héritées de sa classe de base.
3. Comment penser POO
On doit répondre à trois questions :
• Quels objets sont nécessaires ?

• Quelles actions effectuent ces objets ?
• Quelles données stockées pour réaliser ces actions ?
Exemples :
 La voiture SuperCar :
Objets Actions Données

SuperCar démarrer constructeur
accélérer vitesse
freiner essence
allumerles phares
 La roue :
Objets Actions Données

roue tourner taille
regonfler couleur
pression

Chapitre 2 : Vue d’ensemble de la plate-forme Java

1. Introduction
Java est un langage de POO créé par les ingénieurs de la société SUN Microsystems en
1995. SUN a été rachetée par Oracle en 2009.
Java est présent dans de très nombreux domaines d’application des serveurs d’applications
aux téléphones portables, cartes à puces et des systèmes de diffusion télévisuelle.
Exemples d’applications : jeux enlignes, images 3D, solutions de banques, etc…
 97% des machines d'entreprises ont une JVM (Java Virtual Machine) installée
 Java est téléchargé plus d'un milliard 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
 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
2. Caractéristiques
Le langage Java possède de nombreuses caractéristiques :
 C’est un langage compilé : avant d’être exécuté, il doit être traduit dans le langage de
la machine sur laquelle il doit fonctionner.
 Il emprunte sa syntaxe en grande partie du langage C et C++.
 Les programmes Java peuvent être exécutés sous forme d’applications indépendantes
ou distribuées à travers le réseau et exécutées par un navigateur Internet sous forme
d’applets.
 Le langage Java a la particularité principale d’être portable sur plusieurs systèmes
d’exploitation tels que Windows, MacOS ou Linux. C’est la plateforme qui garantit la
portabilité des applications développées en Java.
3. La plateforme Java
Une plateforme est un environnement matériel et/ou logiciel dans lequel un programme
tourne. La plupart des plateformes peuvent être décrites comme une combinaison du système
d’exploitation et du matériel sous-jacent. La plateforme Java est une plateforme de
développement purement logiciel qui tourne sur d’autres plateformes basées sur le matériel.
La plateforme Java a deux composants :
 La Machine Virtuelle Java (Java Virtual Machine): programme permettant
d'interpréter et d'exécuter le bytecode Java (proche du langage machine).
 L’API Java (Java Application Programming Interface): ensemble de bibliothèques
contenant des classes et interfaces organisées en Packages.

4. Java : de l’édition à l’exécution
 Code source : fichier texte avec extension .java

 Compilation avec javac: fichier avec extension .class
 Contenu : code intermédiaire bytecode indépendant de
toute plateforme
 Exécution : bytecode est traduit en code natif, par la
machine virtuelle java, selon le système d’exploitation.
Remarque:
La JVM est contenue dans un framework d’exécution appelé JRE (Java Runtime
Environment). Elle est disponible pour plusieurs systèmes d’exploitation (Microsoft
Windows, Solaris OS, Linux ou Mac OS).
5. Le Java SE Development Kit
Pour exécuter une application développée avec Java, il faut télécharger le JRE. Cependant,
pour les développeurs il faut télécharger le kit de développement Java (JDK). Le JDK est le
kit de développement de référence, distribué gratuitement sur Internet par Sun. La version
courante du JDK est JDK SE 11. Le JDK contient aussi le JRE.
Le JDK SE est composé d'un certain nombre d'outils:
 Javac : C'est le compilateur Java
 Java : Exécute le ou les fichiers compilés par Javac
 AppletViewer : Ce programme permet d'exécuter une Applet Java sans nécessité
d'utiliser un navigateur web
 Javadoc : Outil permettant de construire, à partir des commentaires insérés dans des
sources Java, une documentation HTML
Il y a plusieurs environnements de développement. Parmi lesquelles on peut citer: eclipse et
netbeans. Ils sont téléchargés depuis les sites suivants
 http://www.eclipse.org
 http://www.netbeans.org
6. Java : les éditions
Les principales éditions de Java sont:
 Java ME : Java Micro Edition
Prévu pour le développement d'applications embarquées (assistants personnels et terminaux
mobiles..)
 Java SE : Java Standard Edition
Destiné au développement d'applications pour ordinateurs personnels
 Java EE : Java Entreprise Edition
Destiné à un usage professionnel avec la mise en œuvre de serveurs (serveurs d’applications
et serveurs Web)
7. Génération de code exécutable dans les langages de programmation
Le code est généré par un compilateur en plusieurs étapes :
 Vérification syntaxique.
 Vérification sémantique (typage).
 Production de code dans un langage plus proche de la machine.

Avantages/inconvénients du code natif

 Rapidité d’exécution
 Nécessité de recompiler lors du portage d’un logiciel sur une autre
architecture/système d’exploitation.
8. Génération de code en java
La figure ci-dessous montre les étapes de la génération de code en java.
9. Différents modes de compilation

Les différents modes de compilation sont exposés dans la figure ci-dessous.
10. Avantages de la JVM pour Internet

Grâce à sa portabilité, le bytecode d’une classe peut être chargé depuis une machine distante
du réseau, et exécutée par une JVM locale. La JVM fait de nombreuses vérifications sur le
bytecode avant son exécution pour s’assurer qu’il ne va effectuer aucune action dangereuse

La JVM apporte donc:

 de la souplesse pour le chargement du code à exécuter
 mais aussi de la sécurité pour l’exécution de ce code
 Avantages/Inconvénients du bytecode
 Code portable au niveau binaire
 Moins efficace que du code natif (mais compensé par la technologie JIT permettant
de ne traduire qu’une seule fois en code natif les instructions qui sont exécutées)
11. Exemple: Mon premier programme en Java
Considérons le code source suivant :
public class Principale {
public static void main(String args[]) {
System.out.println("premier programme Java" );
Important:
1. Ce code doit être sauvegardé obligatoirement dans le Fichier source nommé «
Principale.java »
2. Une classe exécutable doit posséder une méthode ayant la signature public static void
main(String[] args).
Dans le cas de l’environnement JDK.
 Pour compiler il suffit d’utiliser la commande javac : javac Principale.java.
 Pour exécuter, il suffira d’utiliser la commande: java Principale.
qui interprète le bytecode de la méthode main() de la classe Principale.
 public class Principale{…..}:La ligne suivante commence par public class, qui veut
dire que nous allons définir une nouvelle classe Java, suivi du nom de cette
classe, qui est aussi le nom de notre programme.
Sachez simplement pour l'instant les choses suivantes :
 Un programme comporte au moins une classe.
 Cette classe doit obligatoirement porter le même nom que le fichier dans lequel le
programme est enregistré. Le fichier possède, en plus, l'extension .java
La deuxième ligne se termine par le caractère {, qui marque le début d'un bloc. Nous verrons
plus loin ce que représente exactement un bloc. Sachez seulement pour l'instant que la
déclaration d'une nouvelle classe est suivie de sa définition, et que celle-ci est incluse dans un
bloc, délimité par les caractères { et } ;
 public static void main (String [] args){…} : cette ligne permet de définir la méthode
particulière nommé main.
main() { signifie que nous allons définir une méthode, ce qui est indiqué entre autres, par les
parenthèses (). Une méthode est une sorte de procédure appartenant à une classe.
Lorsque la méthode est exécutée, elle prend des paramètres de types précis et renvoie une
valeur de type tout aussi précis.

Le mot void désigne le type de valeur renvoyé par la méthode. Et justement, void signifie
"rien", c'est-à-dire aucune valeur.
 public : obligatoire pour que votre programme puisse s’exécuter. Il indique que notre
méthode peut être utilisée par n'importe qui, c'est-à-dire par d'autres classes. Oublier le
mot public n'empêcherait pas le programme d'être compilé normalement, mais cela
empêcherait l'interpréteur de l'utiliser
 Static: Le mot static a une signification un peu plus complexe, qui s'éclaircira dans un
prochain chapitre. Certaines méthodes sont de type static et d'autres non. Sachez
simplement pour l'instant que ce qui est static appartient à une classe et ce qui ne l'est
pas à une instance.
 String[] args : permet de récupérer des arguments transmis au programme au moment
de son lancement. On peut lancer un programme sans fournir d’arguments, mais
l’indication String args[] est obligatoire.
Dans l'exemple simplifié, la méthode ne prend pas de paramètres. Dans notre programme réel,
elle prend un paramètre, dont le nom est args et qui est de type String[]. Nous verrons plus
loin ce que cela signifie.
Pour résumer, retenez qu'une application Java doit contenir une classe : portant le même nom
que le fichier dans lequel elle est enregistrée, comportant (au moins) une méthode : de type
public et static appelée main, ayant un argument.
 System.out.println ("Mon premier programme Java") ; cette ligne sert à définir le
contenu de notre programme qui va afficher le message Mon premier programme Java.
Cette ligne constitue le corps de la méthode main. Elle comporte un appel à une méthode et
un paramètre. La méthode appelée est println. Cette méthode prend un paramètre de type
chaîne de caractères et affiche sa valeur sur la sortie standard. Le paramètre est placé entre
parenthèse.
La méthode println à laquelle nous faisons référence ici appartient à l'objet out. Cet objet
appartient lui-même à la classe System.
12. Exécution d’un programme Java
 Pour exécuter un programme Java on va utiliser l’enivrement de développement
Eclipse (plus utiliser).

Chapitre 3 : Structures de contrôle

1. Variables
• Les variables d’instances:
 sont déclarées en dehors de toute méthode
 conservent l’état d’un objet, instance de la classe
 sont accessibles et partagées par toutes les méthodes de la classe
• Les variables locales:
 sont déclarées à l’intérieur d’une méthode
 conservent une valeur utilisée pendant l’exécution du bloc dans lequel elles sont
définies
 ne sont accessibles que dans le bloc dans lequel elles ont été déclarées
1.1. Déclaration des variables
En Java, toute variable utilisée doit être déclarée avant son utilisation. La syntaxe de la
déclaration : type identificateur; Où :
 type désigne le type de la variable déclarée
 identificateur est une suite de caractères pour désigner les différentes entités
manipulées par un programme: variables, méthode, classe, objet, …
Remarques: concernant les identificateurs:
 Tous les caractères sont significatifs.
 On fait la différence entre les majuscules et les minuscules.
 Mots réservés: un identificateur ne peut pas correspondre à un mot réservé du langage
(par exemple: if, else, while, ..., ).
Exemples:
 int val; double delta;
 Rectangle r1; /* Rectangle est une classe */
 string interface; /* interface est un mot réservé */
 int const; /* const est un mot réservé */
Mots réservés du langage Java
1.2. Initialisation des variables

Une variable doit être initialisée (recevoir une valeur) avant d’être utilisée dans une
expression. Si elles ne sont pas initialisées par le programmeur, les variables d’instance et les
variables de classe reçoivent les valeurs par défaut de leur type (0 pour les types numériques,
par exemple). L’utilisation d’une variable locale non initialisée par le programmeur provoque
une erreur (pas d’initialisation par défaut) à la compilation.

2. Style de programmation non standard

Conventions de nommage en Java: pas obligatoires, mais très fortement recommandées
(essentielles pour la lisibilité du code et sa maintenance).
• Identificateur: pas d'emploi de $ (et de caractères non ASCII) on ne commence pas par
un chiffre
• Nom de classe :
 Si le nom de la classe est composé de plusieurs mots, ils sont accolés (on ne les sépare
pas).
 Commencez chaque mot par une majuscule: exemple: HelloWorld, ClasseTest,
MonPremierProgramme.
• Nom de variable ou méthode :
 Si le nom est composé d’un seul mot: la première lettre est miniscule.
 Si le nom est composé par plusieurs mots, ils sont accolés et respectent la règle
suivante:
 La première lettre du premier mot est miniscule.
 La première lettre des autres mots est majuscule, exemples: maPremiereNote,
initialiseAttribut(), calculTaux(), main(), objEtudiant, …
• Les constantes: majuscules et séparation des mots par _ : VALEUR_MAX;
• Usage non recommandé :
 mapremierevariable
 ma_premiere_variable
Les commentaires
L’utilisation de commentaires est fortement recommandée. Ils sont sautés par le
compilateur (pas de ‘;’ à la fin). Il existe trois types de commentaires en Java :
1. Monoligne. Exemple : int num=1; // déclaration du compteur
2. Multiligne. Exemple : /* commentaires ligne 1
commentaires ligne 2 */
3. De documentation automatique. Ils se placent généralement juste avant une déclaration
(d'attribut ou de méthode). Exemple: /** …………………………….*/
Ils sont récupérés par l'utilitaire javadoc (fourni par le JDK) et inclus dans la documentation
ainsi générée sous format HTML.
3. L’affectation
La syntaxe : identificateur = valeur ;
• identificateur : désigne une variable.
• valeur : est une constante, une variable ou une expression qui retourne une valeur du
même type que la variable référencée par identificateur.
4. Types de données en Java
2 grands groupes de types de données sont manipulés par Java:
 types primitifs
 objets (instances de classe)
4.1. Types primitifs
Java dispose d’un certain nombre de types de base dits primitifs, permettant de manipuler des
entiers, des flottants, des caractères et des booléens. Ce sont les seuls types du langage qui ne
sont pas des classes. Mais ils seront utilisés pour définir les champs de données de toutes les
classes que vous serez amenés à créer.

• Types entiers
Java dispose de quatre types entiers, correspondant chacun à des emplacements mémoire de
taille différente, donc à des limitations différentes. Le tableau suivant en récapitule leurs
caractéristiques. Notez l’existence de constantes prédéfinies de la forme
Type Taille (octets) Valeur minimale Valeur maximale

byte 1 -128 (Byte.MIN_VALUE) 127 (Byte.MAX_VALUE)
short 2 -32 768(Short.MIN_VALUE) 32 767(Short.MAX_VALUE)
int 4 -2 147 483 648 2 147 483 647
(Integer.MIN_VALUE) (Integer.MAX_VALUE)
long 8 -9 223 372 036 854 775 808 9 223 372 036 854 775 807
(Long.MIN_VALUE) (Long.MAX_VALUE)
Integer.MAX_VALUE qui fournissent les différentes limites.
• Types flottants
Les types flottants permettent de représenter, de manière approchée, une partie des nombres
réels. Pour ce faire, ils s’inspirent de la notation dite scientifique (ou exponentielle) bien
connue qu’on trouve dans 1.5 1022 ou 0.472 10-8 ; dans une telle notation, on nomme
mantisses les quantités telles que 1.5 ou 0.472 et exposants les quantités telles que 22 ou -8.
Le tableau suivant récapitule les caractéristiques des types float et double. Notez ici encore
l’existence de constantes prédéfinies de la forme Float.MAX_VALUE qui fournissent les
différentes limites.
Taille Précision (chiffres
Type Valeur absolue minimale Valeur absolue maximale
(octets) significatifs)
1.40239846E-45 3.40282347E38
Float 4 7
(Float.MIN_VALUE) (Float.MAX_VALUE)
4.9406564584124654E-324 1.797693134862316E302
Doule 8 15
(Double.MIN_VALUE) (Double.MAX_VALUE)
• Type caractère
Comme la plupart des langages, Java permet de manipuler des caractères. Mais il offre
l’originalité de les représenter en mémoire sur deux octets en utilisant le code universel
Unicode (les 65536 combinaisons qu’offre Unicode, on retrouve les 128 possibilités du code
ASCII restreint (7 bits) et même les 256 possibilités du code ASCII/ANSI (Latin 1) utilisé par
Windows).
• Type booléen
Ce type sert à représenter une valeur logique du type vrai/faux. Il n’existe pas dans tous les
langages car il n’est pas aussi indispensable que les autres. En effet, on peut souvent se
contenter d’expressions booléennes du genre de celles qu’on utilise dans une instruction if :
if (n<p) ..... // n<p est une expression booléenne valant vrai ou faux
En Java, on peut disposer de variables de ce type, ce qui permettra des affectations telles que:
boolean ordonne ; // déclaration d’une variable de type booléen
.....
ordonne = n<p ; // ordonne reçoit la valeur de l’expression booléenne n<p

Les deux constantes du type booléen se notent true et false ;

4.2. Type objet: Constante null
• null : valeur d'une "référence vers rien" (pour tous types de références)
• Elle indique qu’une variable de type non primitif ne référence rien) ; convient pour
tous les types non primitifs
5. Transtypage
Java est un langage fortement typé. Dans certains cas, il est nécessaire de forcer le programme
à changer le type d’une expression. On utilise pour cela le cast (transtypage) : (type-forcé)
expression.
Exemple:
 int i=13; // i codé sur 32 bit; 13 est une constante codée sur 32 bits
 byte b=i; // Erreur: pas de conversion implicite int →byte. Pour que ça marche, on
doit faire un cast (un transtypage). C’est à dire on doit forcer le programme à changer
le type de int en byte.
byte b=(byte)i; // de 32 bits vers 8 bit. b vaut 13 codé sur 8 bits
• En Java, 2 seuls cas sont autorisés pour les casts :
 entre types primitifs,
 entre classes mère/ancêtre et classes filles.
Casts entre types primitifs
- Un cast entre types primitifs peut occasionner une perte de données sans aucun
avertissement ni message d'erreur.
Exemple :
• int i=13; // i sur 32 bit; 13 codé sur 32 bits
byte b=(byte)i;
b vaut 13 car on a une conversion de 32 bits vers 8 bit (On considère les 8 bits de poids le plus
faible). i est un entier « petit ».
• int i=256; // i sur 32 bit; 256 codé sur 32 bits
byte b=(byte)i;
b vaut 0 car on a conversion de 32 bits vers 8 bits (On considère les 8 bits de poids le plus
faible).
Une affectation entre types primitifs peut utiliser un cast implicite si elle ne provoque aucune
perte.
- Les casts de types « flottants » vers les types entiers tronquent les nombres.
Exemple :
float x=1.99f;
int i = (int)x; // i = 1, et pas 2. On fait une troncature et non un arrondie.
Tableau récapitulatif de conversion de types

6. Principaux opérateurs
Les opérateurs Java sont voisins du C.
6.1. Opérateurs arithmétiques
Symbole Description Exemple

- soustraction x-y
* multiplication 3 *x
Opérateurs arithmétiques / division 4/2
% modulo (reste de la division) 5%2
6.2. Opérateurs d’affectation

= Affectation x=2
Opérateurs d’affectation -= Soustraction et affectation x-=2
+= Addition et affectation x+=2
6.3. Opérateurs d’incrémentations et décrémentations

++ Pré-incrémentation ++x
Opérateurs d’incrémentations ++ Post-incrémentation x++
et décrémentations -- Pré-décrémentation --x
-- Post-décrémentation x--
Remarque :
6.4. Opérateurs relationnels

Ils sont utilisés pour les structures conditionnelles, de choix et itératives. Ils permettent
de comparer une variable par rapport à une autre variable ou une valeur ou une expression. Le
résultat ne peut être que VRAI ou FAUX, on parle de valeur booléenne.
== égal à x==2
< inférieur à x<2
<= inférieur ou égal à x<=3
Opérateurs relationnels
> supérieure à x>2
>= supérieur ou égal à x>=3
!= différent de a !=b

6.5. Opérateurs logiques

Ils sont utilisés exactement comme les opérateurs relationnels
&& et a && b
Opérateurs logiques || ou a ||b
! non !a
6.6. Opérateurs bit à bit

& et a&b
| ou a|b
^ ou exclusif a^b
Opérateurs relationnels
˜ nom ˜x
<< décalage à gauche a<<3
>> décalage à droite b>>2
Exercice: Quel sera le résultat de l’exécution du programme suivant:
7. Instructions de contrôle
Les structures de contrôle sont presque les mêmes que celles utilisées en C ou en C++. On les
rappelle ci-dessous en précisant les spécificités Java.
Structure de contrôle Syntaxe Commentaire
Les parenthèses sont
if (expression) instruction ; obligatoires en Java autour
instruction conditionnelle de l’expression booléenne.
if De même le point-virgule est
if (expression) {bloc d’instructions} obligatoire en fin de bloc.

if (expression) instruction ;
On ne peut pas donner une
instruction conditionnelle else instruction ;
instruction vide après la
if else if (expression) {bloc d’instructions}
condition if.
else {bloc d’instructions}
La partie initialisation se
compose d’une ou plusieurs
initialisations séparées par
des virgules. La partie test
for(initialisation;test;incrémentation)
la boucle for est une expression
{bloc d’instructions}
booléenne. La partie
incrémentation peut contenir
plusieurs instructions
séparées par des virgules.
Interruption de l’itération en
cours et passage à
break ;
l’instruction suivant la
utilisation de break et boucle.
continue dans les boucles Interruption de l’itération en
cours et retour au début de la
continue ;
boucle avec exécution de la
partie incrémentation.
while (expression booléenne)
l’instruction while
{bloc d’instructions}
Les blocs sont délimités par
deux instructions case !
switch (variable){ Lorsqu’une égalité est
case valeur1 : instructions1 ; trouvée, le bloc d’instruction
case valeur2 : instructions2 ; correspondant est exécuté,
l’instruction switch
… ainsi que tous les blocs
default : instructions ; suivant ! Pour qu’un seul
} bloc ne soit exécuté, il faut
utiliser explicitement
l’instruction break.

Chapitre 4 : les Classes et les Objets

1. Création d’une classe
Pour créer une classe (un nouveau type d’objets) on utilise le mot clé class.
La syntaxe pour créer une classe de nom ClasseTest est la suivante:
class ClasseTest{ /* ClasseTest est le nom de la classe à créer */

/* Corps de la classe
- Description des attributs (données membres)
- Description des méthodes
*/
}
Exemple:
Rectangle est une classe utilisée pour créer des objets représentant des rectangles particuliers.
• Elle regroupe 4 données de type réel qui caractérisent le rectangle: longueur, largeur et
origine (x,y) (la position en abscisse et en ordonnée de son origine).
• On suppose qu’on effectue les opérations de déplacement et de calcul de la surface du
rectangle.
• Les symboles + et – sont les spécificateurs d’accès (voir plus loin)
Notation UML (Unified Modeling Language)
- : private
# : protected
+ : public
$ (ou souligné) : static
Code java de la classe Rectangle
class Rectangle {
int longueur;
int largeur;
int x;
Attributs
int y;
void deplace(int dx, int dy) {
x = x+ dx;
Méthodes y = y + dy;
}
int surface() {
return longueur * largeur;
}
}

2. Création et manipulation d’Objets

2.1. Introduction
Une fois la classe est définie, on peut créer des objets (=variables), donc chaque objet est une
variable d’une classe. Il a son espace mémoire. Il admet une valeur propre à chaque attribut.
Les valeurs des attributs caractérisent l’état de l’objet.
• L’opération de création de l’objet est appelée une instanciation. Un objet est aussi
appelé une instance d'une classe. Il est référencé par une variable ayant un état (ou
valeur).
• On parle indifféremment d’instance, de référence ou d’objet
Une classe permet d’instancier plusieurs objets. Les attributs et les méthodes d’un objet
(d’une instance d’une classe) sont les mêmes pour toutes les instances de la classe.
Les valeurs des attributs sont propres à chaque objet.
Par exemple rectangleR1 est une instance de la classe Rectangle
2.2. Etapes de création des Objets

Contrairement aux types primitifs, la création d’objets se passe en deux étapes:
 Déclaration de l’objet
 Création de l’objet
Déclaration d’un objet:
Chaque objet appartient à une classe. C’est est une variable comme les autres. Il faut
notamment qu’il soit déclaré avec son type.
Syntaxe:
NomDeClasse objetId;
NomDeClasse objetId1, objetId2,….;
NomDeClasse est le nom de la classe.

objetId1, objetId2, … sont des variables de type NomDeClasse.
Remarque:
La déclaration d’une variable de type primitif réserve un emplacement mémoire pour stocker
la variable. Par contre, la déclaration d’un objet, ne réserve pas une place mémoire pour
l’objet, mais seulement un emplacement pour une référence à cet objet (les objets sont
manipulés avec des références).

Exemple:
Considérons la classe ClasseTest
class ClasseTest {
// corps de la classe ClasseTest
}
l’instruction: ClasseTest objA;
 déclare objA comme objet (variable) de type ClasseTest
 Définit le nom et le type de l’objet.
 Déclare que la variable objA est une référence à un objet de la classe ClasseTest. Cela
veut dire qu’on va utiliser une variable objA qui référencera un objet de la classe
ClasseTest.
 Aucun objet n’est créé: un objet seulement déclaré vaut « null ».
objA Null
2.3. Création d’un objet
Après la déclaration d’une variable, on doit faire la création (et allocation) de la mémoire de
l’objet qui sera référencé par cette variable. La création doit être demandée explicitement dans
le programme en faisant appel à l’opérateur new. La création réserve de la mémoire pour
stocker l’objet et initialise les attributs. L’expression new NomDeClasse() crée un
emplacement pour stocker un objet de type NomDeClasse.
Exemple
class ClasseTest {
/* Corps de la classe ClasseTest */
}
ClassTest objA ; /* déclare une référence sur l’objet objA */
objA= new ClasseTest(); /* crée un emplacement pour stocker l’objet
objA */
Les deux expressions précédentes peuvent être remplacées par :
ClassTest objA = new ClasseTest();
En générale:
Chaque objet met ses données membres dans sa propre zone mémoire.
Les données membres ne sont pas partagées entre les objets de la même classe.
Exemple : Considérons la classe Rectangle
public class Rectangle{

int longueur; int largeur; int x; int y;
public static void main (String args[]) {
Rectangle rectangleR1; /* déclare une référence sur l’objet
rectangleR1 */
rectangleR1 = new Rectangle(); /* création de l’objet rectangleR1 */
// rectangle R1 est une instance de la classe Rectangle
// Les deux expressions peuvent être remplacées par :
// Rectangle rectangleR1= new Rectangle();
}}

Remarque: déclaration / création

Il ne faut pas confondre la déclaration d’une variable avec la création d’un objet référencé par
cette variable.
Rectangle rectangleR1;
– déclare que l’on va utiliser une variable rectangleR1 qui référencera un objet de la
classe Rectangle mais aucun objet n’est créé rectangle R1 = new Rectangle();
Cette instruction permet la création de l’objet rectangleR1
2.4. Initialisation par défaut
La création d’un objet entraîne toujours une initialisation par défaut de tous les attributs de
l’objet même si on ne les initialise pas:
Type Valeur par défaut

boolean false
char ‘\u0000’ (null)
byte (byte) 0
short (short) 0
int 0
long 0L
float 0.0f
double 0.0
Class null
Cette garantie d’initialisation par défaut ne s’applique pas aux variables locales (variables
déclarées dans un bloc, par exemple variables locales d’une méthode)
3. Définition des méthodes
En Java, chaque fonction est définie dans une classe. Elle est définie par:
– un type de retour
– un nom
– une liste (éventuellement vide) de paramètres.
– une suite d’instructions (un bloc d’instructions) qui constitue le corps de la méthode
Syntaxe :
typeRetour nomMethode ( «Liste des paramètres » ) {
/*corps de la méthode qui peut contenir l’instruction*/
}
 nomMethode : c’est le nom de la méthode (sa 1ère lettre doit être écrite en minuscule)
 « Liste des paramètres » : liste des arguments de la méthode. Elle définit les types et
les noms des informations qu’on souhaite passer à la méthode lors de son appel.
 typeRetour : c’est le type de la valeur qui sera retournée par la méthode après son
appel. Si la méthode ne fournit aucun résultat, alors typeRetour est remplacé par le
mot clé void.

Méthodes et paramètres : à retenir
Remarques importantes :
1) La portée d’une variable locale est limitée au bloc constituant la méthode où elle est
déclarée. De plus, une variable locale ne doit pas posséder le même nom qu’un argument
muet de la méthode :
void f(int n)
{ float x ; // variable locale a f
float n ; // interdit en Java
.....
}
void g ()
{ double x ;//variable locale à g, indépendante de x locale à f
.....
}
2) Les variables locales ne sont pas initialisées de façon implicite (contrairement aux
champs des objets). Toute variable locale, y compris une référence à un objet, doit être
initialisée avant d’être utilisée, faute de quoi on obtient une erreur de compilation.
4. Accès aux membres d’un objet
4.1. Accès aux attributs (données membres)
Considérons la classe ClassTest suivante:
class ClasseTest {
double x; boolean b;
}
ClasseTest objA = new ClasseTest();
// créer un objet de référence objA
// on peut dire aussi objA est une instance de la classe
ClassTest
// ou tous simplement créer un objet objA
ClasseTest objB = new ClasseTest();
Maintenant l’objet dont la référence objA existe. Pour accéder à une donnée membre on
indique le nom de la référence à l’objet suivi par un point suivi par le nom du membre dans
l’objet de la manière suivante:

nomObjet.nomAttibut
nomObjet = nom de la référence à l’objet
nomAttribut =nom de la donnée membre (attribut).
Exemple :
Pour les objets objA et objB de la classe ClassTest qui sont déjà créés:
objA.b=true; // affecte true à l’attribut b de l’objet objA.
objA.x=2.3; // affecte le réel 2.3 au membre x de l’objet objA.
objB.b=false; // affecte false à l’attribut b de l’objet objB.
objB.x=0.35; // affecte le réel 0.35 au membre x de l’objet objB.
4.2. Accès aux méthodes: appels des méthodes
• Les méthodes ne peuvent être définies que comme des composantes d’une classe.
• Une méthode ne peut être appelée que pour un objet.
• L’appel d’une méthode pour un objet se réalise en nommant l’objet suivi d’un point
suivi du nom de la méthode et de sa liste d’arguments:
nomObjet.nomMethode(arg1, ….)
où :
nomObjet : nom de la référence à l’objet
nomMethode : nom de la méthode.
Exemple 1:
soit f() une méthode qui prend un paramètre de type double et qui retourne une valeur de
type int.
class ClasseTest {
float x; int i; boolean b;
int f(double x) {
int n;
// corps de la fonction f()
return n;
}
}
ClasseTest objA = new ClasseTest(); // créer un objet objA
int j = objA.f(5.3); // affecte à j la valeur retournée par f()
Exemple 2 :
Considérons la classe Rectangle dotée de la méthode
initialise qui permet d’affecter des valeurs à l’origine (aux attributs x et y).
int longueur, largeur; int x,y;
void initialiseOrigine(int x0, int y0) {
x=x0; y=y0;
}
public static void main (String args[]) { Rectangle r1;
r1.longueur=4; r1.largeur=2;
r1. initialiseOrigine(0,0); // affecte 0 aux attributs x et y
// Erreur car l’objet n’est pas encore créé. Il faut tout d’abord le
créer (r1=new Rectangle ();)
}}

Exemple 3:
Crée à l’origine un rectangle r1 de longueur 4 et de largeur 2
int longueur, largeur; int x, y;
void initialiseOrigine(int x0, int y0) {
x=x0; y=y0;}
Rectangle r1=new Rectangle (); r1.longueur=4; r1.largeur=2;
r1.initialiseOrigine(0,0);
}
}
5. Encapsulation (accessibilité)
• Une classe permet d’envelopper les objets : un objet est vu par le reste du programme
comme une entité opaque.
• L'enveloppement [wrapping] des attributs et méthodes à l'intérieur des classes plus
(+) le contrôle d'accès aux membre de l’objet est appelé encapsulation.
• Le contrôle d'accès aux membre de l’objet est appelé cacher l'implémentation: les
membres publiques sont vus de l'extérieur mais les membres privés sont cachés.
• L'encapsulation est un mécanisme consistant à rassembler les données et les méthodes
au sein d'une structure en cachant l'implémentation de l'objet, c'est-à-dire en empêchant
l'accès aux données.
• Possibilité d’accéder aux attributs d’une classe Java mais ceci n’est pas recommandé
car contraire au principe d’encapsulation: les données (attributs) doivent être protégés.
• Accessibles pour l’extérieur par des méthodes particulières (sélecteurs)
Plusieurs niveaux de visibilité peuvent être définis en précédant, la déclaration d’un attribut,
d’une méthode ou d’un constructeur, par un modificateur : private, public ou protected.
Spécificateurs d’accès:
L'encapsulation permet de définir 3 niveaux de visibilité des éléments de la classe.
Ces 3 niveaux de visibilité (public, private et protected) définissent les droits d'accès aux
données suivant le type d’accès:
• public: accès depuis l’extérieure (par une classe quelconque)
• private : accès depuis l’intérieure (accès par une méthode de la classe elle-même)
• protected: se comporte comme private avec moins de restriction. Une classe dérivée a
un accès aux membres protected mais pas aux membres private.
Encapsulation "usuelle": les attributs sont privés, et les méthodes sont publiques
Constitution d’un programme Java
• Un programme Java utilise un ensemble de classes
• Les classes sont regroupées par package
• Une classe regroupe un ensemble d’attributs et de méthodes
Visibilité – Encapsulation
Pour une bonne encapsulation, il est préférable de définir les attributs comme « private ». On
définit alors des méthodes «publiques » (accesseurs) permettant de lire et/ou de modifier les
attributs.

Exemple 1: modification depuis l’extérieur d’un champs private
class ClasseTest {
public int x; private int y;
public void initialise (int i, int j){
x=i;
y=j; // accès à l’attribut private y depuis l’intérieure OK
}
}
public class TestA{ // fichier source de nom TestA.java public
static void main (String args[]) {
ClasseTest objA;
objA=new ClasseTest(); // On peut aussi déclarer ClasseTest
objA=new ClasseTest();objA.initialise(1,3);// x vaut 1 et y vaut 3
System.out.println(" x= "+objA.x);
// affiche x = 1 puisque x public, on peut y accéder
System.out.println(" y= "+objA.y);
// ne compile pas car accès à un attribut y privé de ClasseTest
} // depuis l’extérieur (classe TestA)
}
Exemple 2: affichage depuis l’extérieur d’un champs private

Exemple 3: affichage depuis l’intérieur d’un champs private
6. Méthodes d’accès aux valeurs des variables depuis l’extérieur

Comment peut-on accéder à la valeur d’une variable protégée ??
Considérons la classe Etudiant qui a les champs nom et prenom private.
Exemple:
class Etudiant {
private String nom, prenom;
public void initialise(String st1, String st2){
nom=st1; prenom=st2;
}
}
public class MethodeStatic{
public static void main(String[] args) {
Etudiant e= new Etudiant();
e.initialise("Mohd","Ali");
System.out.println("Nom = "+e.nom);
// ne compile pas car le champs nom est privé
// comment faire pour afficher le nom de l’étudiant e ??
}
Méthodes d’accès aux valeurs des variables depuis l’extérieur

Pour afficher la valeur de l’attribut nom (champs private), on définie Un accesseur

(méthode getNom) qui est une méthode permettant de lire, depuis l’extérieur, le contenu
d'une donnée membre protégée.
Exemple:
class Etudiant {
public void initialise(String nom, String prenom) {
this.nom=nom; this.prenom=prenom;
}
public String getNom (){
return nom;
}
public String getPrenom (){
return prenom;
}
}
Etudiant e= new Etudiant(); e.initialise("Mohd","Ali");
System.out.println("Nom = "+e.getNom());
System.out.println("Prenom = "+e.getPrenom());
}
}
Exécution sous eclipse:

Comment peut-on modifier (depuis l’extérieur) le contenu d'un attribut privé?

Exemple:
class Etudiant {
private int cne ;
}
Etudiant e= new Etudiant();
// Modifier le champs cne (attribut private)
e.cne=23541654;
// ne compile pas car le champ cne est un champ protégé (private)
}
}
7. Autoréférences: emploi de this
- Possibilité au sein d’une méthode de désigner explicitement l'instance courante : faire
référence à l’objet qui a appelé cette méthode.
- Par exemple pour accéder aux attributs "masqués" par les paramètres de la méthode.
class ClasseA {
….
public void f(….) {
…… // ici l’emploi de this désigne la référence à l’objet
// ayant appelé la méthode f
}
}
Exemple:
class Etudiant {
public initialise(String st1, String st2) {
nom = st1; prenom = st2;
}}
Comme les identificateurs st1 et st2 sont des arguments muets pour la méthode initialise(),
alors on peut les noter nom et prenom qui n’ont aucune relation avec les champs private nom
et prenom. Dans ce cas la classe Etudiant peut s’écrire comme suit:
class Etudiant {
public initialise(String nom, String prenom){
this.nom=nom; this.prenom=prenom;
}
}
L’autoréférence (this) est utilisée principalement :
 pour lever une ambiguïté,
 dans un constructeur, pour appeler un autre constructeur de la même classe,
 lorsqu'une référence à l'instance courante doit être passée en paramètre à une méthode.

8. Champs de classe (variable de classe)

Considérons la définition simpliste suivante :
class ClasseTest {
int n;
double y;
}
Chaque objet de type ClasseTest possède ses propres champs n et y. Par exemple avec les
déclarations ClasseTest objA1=new ClasseTest() et objA2= new ClasseTest();
objA1.n et objA2.n désignent deux données différentes.
objA1.y et objA2.y désignent aussi deux données différents.
Considérons la classe:
class ClasseTest {
static int n;// la valeur de n est partagée par toutes les instances
double y;
}
Soient objA1 et objA2 deux instances différentes : ClasseTest objA1=new ClasseTest(),
objA2=new ClasseTest(); objA1 et objA2 partagent la même variable n: objA1.n et objA2.n
désignent la même donnée. La valeur de l’attribut n est indépendante de l’instance (objet).
Pour y accéder, on utilise le nom de la classe.
ClasseTest.n // champs (statique) de la classe ClasseTest
9. Les constructeurs
9.1. Définition de Constructeur
Le constructeur est une méthode spéciale qui peut contenir des instructions à exécuter à la
création des objets, en particulier: l’initialisation des attributs.
 La création et l’initialisation peuvent être unifiées
 Quand une classe possède un constructeur, Java l’appelle automatiquement à toute
création d’objet avant qu’il ne puisse être utilisé.
Chaque classe a un ou plusieurs constructeurs qui servent à :
 créer les instances
 initialiser l’état de ces instances
Règles de définition d’un constructeur: un constructeur:
 porte le même nom que la classe.
 n’a pas de type retour.
 peut disposer d’un nombre quelconque d’arguments (éventuellement aucun).

Exemple: Considérons une classe Point et transformons la méthode initialise en un

constructeur.
public class Point{
private int x; // abscisse: variable d’instance
private int y; // ordonnée: variable d’instance
public Point (int abs, int ord) {
// Constructeur, remplace initialise
x=abs; y=ord;
}
public void deplace (int dx, int dy){
x+=dx; y+=dy;
}
public void affiche (){
System.out.println(" abscisse : "+ x + " ordonnée : " + y);
}
Point pA=new Point(1,1); // création et initialisation de l’objet pA
pA.deplace(2,0);
Point pB=new Point(2,3); // création et initialisation de l’objet pB
pB.affiche();
}
}
Remarque:
Les instructions: Point pA=new Point(); et pA.initialise(1,1) ; sont remplacées par:
Point pA = new Point(1,1);
9.2. Quelques règles concernant les constructeurs
1. Aucun type, même void, ne doit figurer devant son nom.
2. Lorsque le code de la classe comporte un constructeur alors il doit être appelé à
chaque création.
3. Lorsque le code d’une classe ne comporte pas de constructeur, un constructeur par
défaut sera automatiquement ajouté par Java. Dans ce cas on peut créer des objets de
la classe ClasseTest par l’instruction ClasseTest c = new ClasseTest();
//ok si ClasseTest n’a pas de constructeur.
4. Règle générale: Si pour une classe ClasseA donnée, l’instruction ClasseA a=new
ClasseA(); est acceptée
Cela signifie que:
- Soit la classe ClasseA ne possède pas de constructeur
- Soit la classe ClasseA possède un constructeur sans arguments.
5. Un constructeur ne peut pas être appelé de la même manière que les autres méthodes.
Par exemple:
Point a=new Point(1,1); // ok car Point possède un constructeur a.Point (2,3);
// Interdit car Point() est un constructeur et
// non une méthode classique.
6. Si un constructeur est déclaré private, dans ce cas il ne pourra plus être appelé de
l’extérieur, c’est-à-dire il ne pourra pas être utilisé pour instancier des objets.

Exemple:
class ClasseA{
private ClasseA() { … } // constructeur privé sans arguments
…
}
…
ClasseA a=new ClasseA();
// erreur, car constructeur ClasseA() est privé
Exemple:
Considérons la classe suivante:
class ClasseTest{
public ClasseTest (…) {… } // Constructeur ClasseTest
…
private int n=10; private int p;
}
L’instruction suivante: ClasseTest objA=new ClasseTest(…); Entraîne successivement:
1. initialisation implicite (par défaut) des champs n et p de l’objet objA à 0
2. initialisation explicite: On affecte au champ n la valeur 10 (la valeur figurant dans sa
déclaration).
3. exécution des instructions du constructeur: Le corps du constructeur n’est exécuté
qu’après l’initialisation par défaut et l’initialisation explicite.
9.3. Surcharge des constructeurs (Plusieurs constructeurs)
Les constructeurs peuvent être surchargés comme n’importe quelle autre méthode. Une classe
peut avoir plusieurs constructeurs. Comme le nom du constructeur est identique au nom de
la classe: Java permet la surcharge des constructeurs.
Exemple :
public class Etudiant {
private int codeNatEtudiant;
public Etudiant(String n, String p) { // Constructeur 1 (2arguments)
nom = n;
prenom = p;
}
public Etudiant(String n, String p, int cne) {
// Constructeur 2 (3 arguments)
nom = n; prenom = p; codeNatEtudiant = cne;
}
}
public class TestEtudiant {
Etudiant e1, e2;
e1 = new Etudiant("Mohd", "Ali");
e2 = new Etudiant("Ouardi", " fatima", 22564321);
}
}

9.4. Utilisation du mot clé this dans un constructeur

Il est possible, qu’au sein d’un constructeur, on peut appeler un autre constructeur de la
même classe. Pour se faire, on fait appel au mot clé this qui est utilisé cette fois comme nom
de méthode.
Exemple: La classe Etudiant peut être réécrite de la façon suivante:
class Etudiant {
private int codeNatEtudiant;
public Etudiant(String n, String p) { // Constructeur 1
nom = n;
prenom = p;
}
public Etudiant(String n, String p, int cne) {// Constructeur 2
this(n,p);
// appel au constructeur 1
Etudiant(String , String);
codeNatEtudiant = cne;
}
}

Chapitre 5: les tableaux

Les tableaux Java sont des structures pouvant contenir un nombre fixe d'éléments de même
nature. Il peut s'agir d'objets ou de primitives. Chaque élément est accessible grâce à un indice
correspondant à sa position dans le tableau. Les tableaux Java sont des objets, même lorsqu'ils
contiennent des primitives.
1. Tableaux unidimensionnels
1.1. Déclaration de tableaux
Les tableaux doivent être déclarés comme tous les objets. Java dispose de deux syntaxes
équivalentes pour la déclaration des tableaux :
type nomTableau [] ; ou type [] nomTableau ;
L'utilisation de l'une ou l'autre de ces syntaxes est une affaire de goût personnel.
Exemple : int t[] ; peut aussi s’écrire : int [] t ;
La différence entre les deux formes devient perceptible lorsque l’on déclare plusieurs
identificateurs dans une même instruction. Par exemple :
int [] t1, t2 ; // t1 et t2 sont des références à des tableaux d’entiers
est équivalent à : int t1[], t2[] ;
La première forme permet le mélange de tableaux de type T et de variables de type T :
int t1[], n, t2[] ; // t1 et t2 sont des tableaux d’entiers, n est entier
En Java, les éléments d’un tableau peuvent être d’un type primitif ou d’un type objet. Par
exemple, si nous avons défini le type classe Point, ces déclarations sont correctes :
Point tp [] ; // tp est une référence à un tableau d’objets de type Point
Point a, tp[], b ; // a et b sont des références à des objets de type Point tp est une
référence à un tableau d’objets de type Point.
1.2. Création par l’opérateur new
La création d’un tableau dans java est réalisée par l’opérateur new :
nomTableau = new int[dimension];
dimension est le nombre d'éléments que le tableau pourra contenir.
Exemple: int tableau [] = new int[50]; // déclaration et allocation
OU int[] tableau = new int[50];
int tab[]; // déclaration tab = new int[50]; //allocation
1.3. Initialisation
 Chaque élément du tableau est initialisé selon son type par l'instruction new : 0 pour
les numériques, \0 pour les caractères, false pour les booléens et null pour les chaînes
de caractères et les autres objets.
 On peut initialiser un tableau au moment de sa déclaration par la syntaxe suivante :
int[] x = {1, 2, 3, 4, 5};// tableau de cinq éléments de type int initialisé par
{1, 2, 3, 4, 5}.
1.4. La taille d’un tableau : length
Un tableau est un objet possédant l'attribut length : c'est la taille du tableau.
Exemple:
int t[] = new int[5] ;
System.out.println ("taille de t : " + t.length) ; // affiche 5
t = new int[3] ;
System.out.println ("taille de t : " + t.length) ; // affiche 3

1.5. Utilisation d’un tableau

En Java, on peut utiliser un tableau de deux façons différentes :
 en accédant individuellement à chacun de ses éléments,
 en accédant globalement à l’ensemble du tableau.
a. Accès individuel aux éléments d’un tableau
On peut manipuler un élément de tableau comme on le ferait avec n’importe quelle variable
ou n’importe quel objet du type de ses éléments.
Exemple: voici un programme qui utilise un tableau de flottants pour déterminer le nombre
d’élèves d’une classe ayant une note supérieure à la moyenne de la classe.
public class Moyenne

{ public static void main (String args[])
{ int i, nbEl, nbElSupMoy ;
double somme ;
double moyenne ;
System.out.print ("Combien d’eleves ") ;
nbEl = Clavier.lireInt();
double notes[] = new double[nbEl] ;
for (i=0 ; i<nbEl ; i++)
{ System.out.print ("donnez la note numero " + (i+1) + " : " ) ;
notes[i] = Clavier.lireDouble() ;
}
for (i=0, somme=0 ; i<nbEl ; i++) somme += notes[i] ;
moyenne = somme / nbEl ;
System.out.println ("\nmoyenne de la classe " + moyenne) ;
for (i=0, nbElSupMoy=0 ; i<nbEl ; i++ )
if (notes[i] > moyenne) nbElSupMoy++ ;
System.out.println (nbElSupMoy + " eleves ont plus de cette
moyenne") ; }}
Combien d’eleves 5
donnez la note numero 1 : 12
donnez la note numero 2 : 14.5
moyenne de la classe 12.3
2 eleves ont plus de cette moyenne
1.6. Affectation de tableaux
Java permet aussi de manipuler globalement des tableaux, par le biais d’affectations de leurs
références.
Exemple:
int [] t1 = new int[3] ;
for (int i=0 ; i<3 ; i++) t1[i] = i ;
int [] t2 = new int[2] ;
for (int i=0 ; i<2 ; i++) t2[i] = 10 + i ;

La situation peut être schématisée ainsi :
Exécutons maintenant l’affectation :

t1 = t2 ; // la référence contenue dans t2 est recopiée dans t1
Nous aboutissons à cette situation :
Dorénavant, t1 et t2 désignent le même tableau. Ainsi, avec :

t1[1] = 5 ;
System.out.println (t2[1]) ; on obtiendra l’affichage de la valeur 5, et non 10.
Il est très important de noter que l’affectation de références de tableaux n’entraîne aucune
recopie des valeurs des éléments du tableau. On retrouve exactement le même phénomène que
pour l’affectation d’objets.
2. Tableaux multidimensionnels
Les tableaux Java peuvent comporter plusieurs dimensions. Il est ainsi possible de créer des
tableaux rectangulaires, cubiques, ou à un nombre quelconque de dimensions. Pour déclarer et
créer un tableau multidimensionnel, vous devez utiliser la syntaxe suivante :
type nomTableau[][]= new type[n1][n2]; ou type [][] nomTableau= new type[n1][n2];
Exemple : Tableau à 2 dimensions 5 lignes sur 10 colonnes
int t2[][] = new int[5][10] ;
Un tableau à plusieurs dimensions peut être initialisé :

int t21[][] = {{1, 2, 3}, {4, 5, 6}};

t21 c’est un tableau dont la première dimension va de l'indice 0 à l'indice 1 et la deuxième

dimension de l'indice 0 à l'indice 2.
Toutes les lignes d’un tableau à 2 dimensions n’ont pas forcément le même nombre
d’éléments :
On peut créer ce type de tableau par le code suivant:

int t22[][] ;
t22 = new int[5][];
for( int i = 0; i< t22.length; ++i){
t22[i]= new int [i+1];
}
for( int i = 0; i< t22.length; ++i){
for( int j = 0; j<t22[i].length; ++j){
//accès à t22[i][j]
}}

Chapitre 6 : Héritage et polymorphisme

1. Principe de l'héritage
1.1. Présentation
L'héritage est un mécanisme qui facilite la réutilisation du code et la gestion de son
évolution. Grâce à l'héritage, les objets d'une classe ont accès aux données et aux méthodes
de la classe parent et peuvent les étendre. Les sous classes peuvent redéfinir les variables et
les méthodes héritées. Pour les variables, il suffit de les redéclarer sous le même nom avec
un type différent. Les méthodes sont redéfinies avec le même nom, les mêmes types et le
même nombre d'arguments, sinon il s'agit d'une surcharge. L'héritage successif de classes
permet de définir une hiérarchie de classe qui ce compose de super classes et de sous classes.
Une classe qui hérite d'une autre est une sous classe et celle dont elle hérite est une
super_classe. Une classe peut avoir plusieurs sous classes. Une classe ne peut avoir qu'une
seule classe mère : il n'y a pas d'héritage multiple en java.
Object est la classe parente de toutes les classes en java. Toutes les variables et méthodes
contenues dans Object sont accessibles à partir de n'importe quelle classe car par héritage
successif toutes les classes héritent d'Object.
On déclare l’héritage par la syntaxe suivante:
public class sous_classe extends super_classe{
Autres Attributs et Méthodes
}
On utilise le mot clé extends pour indiquer qu'une classe hérite d'une autre. En l'absence de ce
mot réservé associé à une classe, le compilateur considère la classe Object comme classe
parent.
Exemple : Il est possible définir une sous-classe PointCol de la classe Point grâce au
mot-clé ‘extends’ :
Public class Point{

public Point () // constructeur par défaut
{
this. x =0 ; this.y = 0 ;
}
public Point (int x, int y)
// constructeur par arguments public class PointCol extends Point{
{ private int couleur ;
this. x =x ; this.y = y ;
} public void colore(int c) {
public void deplace (int dx, int dy) couleur = c ;}
{ x += dx ; y += dy ; }
public void affiche () }
{ System.out.println ("Je suis un point de
coordonnees " + this.x + " " + this.y) ;
}
private int x ; // abscisse
private int y ; // ordonnée
}
Dans cet exemple, on a défini une « sous-classe » (PointCol) à partir d'une « super-classe »
(Point). Cela signifie que la classe PointCol est une extension de la classe Point. On
dit que la classe PointCol « hérite » de la classe Point. Cela signifie que les attributs et
méthodes de la classe Point sont implicitement des attributs ou méthodes de la classe
PointCol.

public class TestePointCol

PointCol pc = new PointCol() ;// constructeur par défaut de PointCol
pc.deplace(4, 5) ; // correct car ‘deplace’ est héritée
pc.colore(6) ; // correct
Point p = new PointCol() ;
p.colore(9) ; // ERREUR ! l’héritage ne marche pas dans ce sens !
}
1.2. Appel des constructeurs
Dans la programmation orienté objet, souvent le constructeur de la sous-classe appelle le
constructeur de la super-classe au début de son corps. Ainsi, on transmet les paramètres
du constructeur de la sous-classe au constructeur de la super-classe:
Public class Point{
// constructeur
public Point (int x, int y) { class PointCol extends Point {
this.x =x ; public int couleur;
this.y = y ;
} public PointCol(int x, int y, int couleur) {
public void deplace (int dx, int dy) // appel du constructeur de la super-classe
{ x += dx ; y += dy ; }
public void affiche () super (x, y) ;
{ this.couleur = c ;
System.out.println ("Je suis un point
de coordonnees " + this.x + " " + }
this.y) ; ...
}
private int x ; // abscisse }
private int y ; // ordonnee
}
Si un constructeur d’une classe dérivée appelle un constructeur d’une classe de base, il doit
obligatoirement s’agir de la première instruction du constructeur et ce dernier est désigné
par le mot-clé super.
1.3. Accès d’une classe dérivée aux membres de sa classe de base
 Une méthode d’une classe dérivée n’a pas accès aux membres privés de sa classe de
base.
Exemple : on cherche à doter dans la sous-classe PointCol de la classe Point la méthode
afficheCouleur qui permet d’afficher les coordonnées du point et la couleur.
public class PointCol extends Point{
private int couleur ;
Public class Point{
public Point (int x, int y) // constructeur par arguments public PointCol( int x, int y, int couleur){
{ super(x, y) ;
this. x =x ; this.y = y ; } Erreur : x et y
public void deplace (int dx, int dy) //deplace (int, int) this.couleur=couleur ;} sont privées
{ x += dx ; y += dy ; } public void afficheCouleur()
public void affiche ()
{ System.out.println ("Je suis un point de coordonnees " { System.out.println ("Je suis en " + x + " " + y) ;
+ this.x + " " + this.y) ; System.out.println (" et ma couleur est : " +
}
private int x ; // abscisse couleur) ;
private int y ; // ordonnee }
}
public void colore(int c) { couleur = c ; }
}
 Une méthode d’une classe dérivée a accès aux membres publics de sa classe de base.
Exemple : pour écrire la méthode afficheCouleur, nous pouvons nous appuyer sur la
méthode affiche de Point en procédant ainsi :
public void afficheCouleur ()
{ affiche() ;//équivalent de this.affiche() ;
System.out.println (" et ma couleur est : " + couleur) ;
}
1.4. Redéfinition
On appelle redéfinition (en anglais « overriding ») d’une méthode, la possibilité de définir le
comportement d’une méthode selon le type d’objet l’invoquant, i.e., de donner une nouvelle
implémentation à une méthode héritée sans changer sa signature.
Exemple : Redéfinition de la méthode affiche de la classe Point dans la classe PointCol
public void affiche ( )
{ affiche() ;//équivalent de this.affiche() ;
System.out.println (" et ma couleur est : " + couleur) ;
}
Attention : Il ne faut pas confondre la redéfinition (en anglais « overriding ») et la surcharge
(en anglais «overloading ») qui a été étudiée dans la partie 14 de ce cours et qui correspond à
la possibilité de définir des comportements différents pour la même méthode selon les
arguments passés en paramètres.
2. Polymorphisme
Le polymorphisme est un concept extrêmement puissant en POO, il permet de manipuler des
objets sans connaître tout à fait leur type tout en se basant sur la relation d’héritage.
Le polymorphisme en Java, se traduit par :
 La compatibilité entre un type dérivée et un type de base.
 La liaison dynamique(ou ligature dynamique) des méthodes : dans le sens où il permet
d’obtenir le comportement adapté à chaque type d’objet, sans avoir besoin de tester sa
nature.
Le polymorphisme se base sur cette affirmation : un objet a comme type non seulement sa
classe mais aussi n’importe quelle classe dérivée.
Exemple1 :
public class graphique {
private int x, y; public class Cercle extends graphique {
public graphique ( int x, int y) { private double rayon =1 ;
this.x = x ; this.y = y ;}
public void identifie () { public Cercle ( int x, int y, double r){
System.out.println (‘’ Je suis une forme super(x,y) ; rayon = r ;}
géometrique ‘’) ;
} public void identifie () {
public void affiche () { System.out.println (‘’ Je suis un cercle ‘’) ;}
this.identifie() ;
System.out.println (‘’ Le centre de l’objet se public double surface (){
trouve dans :’’ + x+ ‘’ et ‘’ + y) ;} return ( rayon * 2* 3.14) ;}
public double surface () {
return (0) ;} }
}
public class Rectangle extends graphique { public class test_poly {
private int larg, long ; public static void main (String [] args) {
public Rectangle ( int x, int y, int larg, int long){ graphique g = new graphique (3,7);

super (x,y) ; this.long = long ; this.larg = larg ;} g.identifie ();

public double surface () { g= new Cercle (4,8,10) ;
return (long*larg);} // compatibilité entre le type de la classe de base
et de la classe dérivéé
public void identifie() {
g.identifie() ;
System.out.println(‘’Je suis un rectangle’’) ;}
g= new Rectangle (7,9,10,3) ;
}
// compatibilité entre le type de la classe de base
et de la classe dérivéé
g.identifie () ;
}
}
Résultat de l’exécution
Je suis une forme géométrique
Je suis un cercle
Je suis un rectangle
Explication : Le même identificateur « g » est initialisé dans la 1ère instruction avec une
référence de type « graphique », puis on a changé la référence de cette variable dans
l’instruction 3 en lui affectant une référence de type « Cercle », puis dans l’instruction 5,
on a changé sa référence avec une référence de classe dérivée « Rectangle ».
Ces affectations confirment la compatibilité entre un type d’une classe de base et la référence
d’une classe dérivée.
L’autre point qui semble plus important c’est la liaison dynamique des méthodes, dans
le sens où le résultat de la méthode « identifie » a changé dans chaque appel selon le type
effectif de la variable « g ».
Exemple 2 : Tableau des objets
Résultat de l’exécution
public class test_poly2 {
Je suis une forme géométrique Le centre de
public static void main (String [] args) {
l'objet se trouve dans : 3 et 2
graphique [] tab = new graphique [6];
Je suis un cercle Le centre de l'objet se trouve
tab[0] = new graphique (3,2);
dans : 10 et 7
tab[1] = new Cercle (10,7,3) ;
Je suis un rectangle Le centre de l'objet se
tab [2] = new Rectangle (4,7,8,6) ;
trouve dans : 4 et 7
tab [3] = new graphique (8,10);
Je suis une forme géométrique Le centre de
tab[4] = new Cercle (8,5,3) ;
l'objet se trouve dans : 8 et 10
tab[5] = new Rectangle (10,17,3,8) ;
Je suis un cercle Le centre de l'objet se
for (i=0 ; i <=5 ; i++) {tab[i].affiche();}
}
Je suis un rectangle Le centre de l'objet se
}
Le gros avantage du polymorphisme est de pouvoir référencer des objets sans connaître à la
compilation véritablement leur classe et de pouvoir par la suite à l’exécution lancer le code
approprié à cet objet. La liaison entre l’identificateur de la méthode polymorphe et son code
est déterminée à l’exécution et non à la compilation, on parle alors de liaison dynamique.
Le polymorphisme se base essentiellement sur le concept d’héritage et la redéfinition
des méthodes. Toutefois, si dans le même contexte d’héritage, on a à la fois une
redéfinition et une surcharge de la même méthode, les règles de polymorphisme
deviennent de plus en plus compliquées.
La notion de polymorphisme peut être généralisée dans le cas de dérivations successives.

2.1. Surclassement (upcasting) et Déclassement (downcasting)

 Upcasting : classe fille → classe mère
On appelle surclassement ou upcasting le fait d’affecter une valeur qui correspond à une
référence d’une instance d’une classe B héritant d’une classe A dans une référence de type A.
En java, cette opération est implicite et constitue la base du polymorphisme.
public class A { . . . }
public class B extends A { . . . }
A a = new B( ) // C’est de l’upcasting ( surclassement ) .
On dit que a est une référence surclassée (elle est du type A et contient l’adresse d’une
instance d’une sous-classe de A).
 Downcasting : classe mère → classe fille

On appelle déclassement ou downcasting le fait de convertir une référence « surclassée »
pour « libérer » certaines fonctionnalités cachées par le surclassement. En java, cette
conversion n’est pas implicite, elle doit être forcée par l’oppérateur de cast : (<nomClasse>).
public class A { . . . }
public class B extends A { . . . }
A a = new B( ) ; // s u r c l a s s e m e n t , u p c a s t i n g
B b = (B) a ; // d o w n c a s t i n g
Pour que la conversion fonctionne, il faut qu’à l’exécution le type réel de la référence à
convertir soit B ou une des sous-classe de B !
Attention : le downcasting ne permet pas de convertir une instance d’une classe de base en
une instance d’une sous-classe !
public class A { A( ) {}}
public class B extends A { B( ) {}}
A a = new A( ) ;
B b = (B) a ;// Erreur
2.2. Régles du polymorphisme en Java
Compatibilité. Il existe une conversion implicite d’une référence à un objet de classe T en une
référence à un objet d’une classe ascendante de T.
Ligature dynamique. Dans un appel de la forme x.f(...) où x est supposé de classe T, le choix
de f est déterminé :
 à la compilation : on détermine dans la classe T ou ses ascendantes la signature de la
meilleure méthode f convenant à l’appel, ce qui définit du même coup le type de la
valeur de retour.
 à l’exécution : on recherche la méthode f de syntaxe voulu, à partir de la classe
correspondant au type effectif de l’objet référencé par x (il est obligatoirement de type
T ou descendant) ; si cette classe ne comporte pas de méthode appropriée, on remonte
dans la hiérarchie jusqu’à ce qu’on en trouve une (au pire, on remontera jusqu’à T).
3. La classe Object
Toutes les classes définies en JAVA sont des sous-classes de la classe de base Object. Ceci
est automatique et n’a pas besoin d’être spécifié. Un intérêt de ceci est de pouvoir définir une
variable de type Object laquelle peut référer à un objet d’une classe quelconque. C’est
avantageux en particulier lorsque vous voulez définir une méthode qui doit manipuler des
objets de type inconnu.
Dans la classe Object, 7 méthodes sont d’accès public et 2 sont d’accès protected. Les classes
définies par un programmeur hériteront de ces 9 méthodes. Nous en verrons 5.

Méthode Fonctionnalité
String toString() Retourne une chaîne de caractères représentant l'objet.
boolean equals(Object obj) Indique si l'objet est égal à un autre.
Retourne la classe d'exécution d'un objet. Par exemple :
Point C = new Point(2, 3);
Class getClass() Class type_objet = C.getClass();
System.out.println(type_objet.getName()) ;//affiche le nom de la

classe ici Point.
C’est la méthode qui est appelée lorsqu’un objet est détruit. On
protected void finalize() peut redéfinir cette méthode à l’intérieur de sa propre classe en
autant que l’on fasse appel à super.finalize().
permet de créer un nouvel objet du même type que l’objet courant
où chaque variable du nouvel objet reçoit la même valeur que celle
protected Object clone() de l’objet courant. Cependant, lorsque des variables de la classe
réfèrent à des objets, ceux-ci ne sont pas automatiquement
dupliqués lors du clonage. Ainsi, 2 objets peuvent partager un
même objet comme donnée membre.
Exemples :
 Class getClass():
public class Marin {

public String name;
public Marin(String name) {
this.name=name;
}
public String getName() {
return name;
}
public static void main(String [] args)
{
Marin m=new Marin("Surcouf");
System.out.println("Classe de marin : " + m.getClass()) ;
System.out.println(m.getName());
}
}
Exemple d’exécution :
Classe de marin : class Marin
Surcouf
 boolean equals(Object obj)

} public class RectEquals {
int l,b;
int surface() {
return l*b;
}
public RectEquals(int l, int b) {
this.l = l;
this.b = b;
}
public boolean equals(RectEquals obj) {
if(this.surface()==obj.surface()) {
return true }
else {
return false;
}
}
public static void main(String []args) {
RectEquals r1= new RectEquals(3,9);
RectEquals r2=new RectEquals(6,4);
System.out.println(r2.equals(r1));
}
Exemple d’exécution
false
 protected void finalize()
public class Garbage {
public void demo() {
System.out.println("hello");
}
public void finalize() {
System.out.println("object is garbage collected");
}
public static void main(String [ ]args) {
Garbage s1=new Garbage();
s1.demo();
s1=null;
//s1.demo();
System.gc();// garbage collector methode
}
}
hello
object is garbage collected.
4. Les classes abstraites
4.1. Concept des classes abstraites
 Une classe abstraite est une classe qui ne permet pas d’instancier des objets, elle ne
peut servir que de classe de base pour une dérivation.
 Dans une classe abstraite, on peut trouver classiquement des méthodes et des attributs,
dont héritera toute classe dérivée et on peut trouver des méthodes dites « abstraites »
qui fournissent uniquement la signature et le type de retour.

Syntaxe :
abstract class A
{public void f() {……} //f est définie dans A
public abstract void g (int n) ;
//g est une méthode abstraite elle n’est pas définie dans A
}
Utilisation
A a ; //on peut déclarer une référence sur un objet de type A ou dérivé
a = new A (….) ; //Erreur pas d’instanciation d’objets d’une classe abstraite
4.2. . Règles des classes abstraites
 Dès qu’une classe abstraite comporte une ou plusieurs méthodes abstraites, elle est
abstraite, et ce même si l’on n’indique pas le mot clé « abstract » devant sa
déclaration.
 Une méthode abstraite doit être obligatoirement déclarée « public », ce qui est logique
puisque sa vacation est d’être redéfinie dans une classe dérivée.
 Les noms d’arguments muets doivent figurer dans la définition d’une méthode
abstraite
public abstract void g(int) ; //Erreur : nom argument fictif est obligatoire
 Une classe dérivée d’une classe abstraite n’est pas obligée de redéfinir toutes les
méthodes abstraites, elle peut ne redéfinir aucune, mais elle reste abstraite tant qu’il y
a encore des méthodes abstraites non implémentées.
 Une classe dérivée d’une classe non abstraite peut être déclarée abstraite.
4.3. Intérêt des classes abstraites
Le recours aux classes abstraites facilite largement la conception orientée objet. On peut
placer dans une classe abstraite toutes les fonctionnalités dont on souhaite disposer pour les
classes descendantes :
 Soit sous la forme d’une implémentation complète de méthodes (non abstraites) et de
champs (privés ou non) lorsqu’ils sont communs à tous les descendants,
 Soit sous forme d’interface de méthodes abstraites dont on est alors sûr qu’elles
existeront dans toute classe dérivée instanciable.
Exemple
abstract class graphique { public class Cercle extends graphique {
private int x, y; private double rayon =1 ;
public graphique ( int x, int y) {
this.x = x ; this.y = y ;} public Cercle ( int x, int y, double r){
public void affiche () { super(x,y) ; rayon = r ;}
System.out.println (‘’ Le centre de l’objet se
trouve dans :’’ + x+ ‘’ et ‘’ + y) ;} public double surface (){
public abstract double surface ();//méthode return ( rayon * 2* 3.14) ;}
abstraite
} }
public class Rectangle extends graphique { public class test_poly2 {
private int larg, long ;
graphique [] tab = new graphique [6];
public Rectangle ( int x, int y, int larg, int long){ //tab[0] = new graphique (3,2); Erreur car une
classe abstraite ne peut pas être instanciée
super (x,y) ; this.long = long ; this.larg = larg ;}
tab[0] = new Cercle (3,2,7);

public double surface () { tab[1] = new Cercle (10,7,3) ;

return (long*larg);}
tab[3] = new Rectangle (8,10,12,10);
} tab[4] = new Cercle (8,5,3) ;
for (int i=0 ; i <=5 ; i++) {tab[i].affiche();}
}}
Remarque : Une classe abstraite peut ne comporter que des méthodes abstraites et aucun
champ. Dans ce cas, on peut utiliser le concept de l’interface.
5. Les interfaces
5.1. Concept d’interface
 Si on considère une classe abstraite n’implantant aucune méthode et aucun champ
(sauf les constantes), on aboutit à la notion d’interface.
 Une interface définit les entêtes d’un certain nombre de méthodes, ainsi que des
constantes.
 L’interface est plus riche qu’un simple cas particulier des classes abstraites :
 Une classe peut implémenter plusieurs interfaces (alors qu’une classe ne pouvait
dériver que d’une seule classe abstraite).
 La notion d’interface va se superposer à celle de dérivation, et non s’y substitue.
 Les interfaces peuvent se dériver.
 Une classe dérivée peut implémenter 1 ou plusieurs interfaces, elle peut même
réimplémenter une interface déjà implémentée par la superclasse.
 On pourra utiliser des variables de type interface.
5.2. Syntaxe
o Définition d’une interface
public interface I
{void f (int n) ; //public abstract facultatifs
void g () ; //public abstract facultatifs
}
Toutes les méthodes d’une interface sont abstraites. On peut ne pas mentionner le
modificateur de visibilité (par défaut public) et le mot clé « abstract ».
o Implémentation d’une interface
Lorsqu’on définit une classe, on peut préciser qu’elle implémente une interface donnée en
utilisant le mot clé « implements ».
Syntaxe:
public interface I1
{….}
public interface I2
{…}
public class A implements I1, I2
{…..A doit définir les méthodes de I1 et I2}

Exemple
public interface Affichable{
public class Flottant implements Affichable {
void affiche() ;
private float val ;
}
public Flottant (float n)
public class Entier implements Affichable {
{val = n ;}
private int val ;
public void affiche() {
public Entier (int n) {val = n ;}
System.out.println (« Je suis un flottant de
valeur » + val) ; }
System.out.println (« Je suis un entier de valeur
}
» + val) ;}}
public class TestInterface {
Affichable [] tab = new Affichable [2]; Résultat de l’exécution
tab[0] = new Entier (25); - Je suis un entier de valeur 25
tab [1] = new Flottant (1.25);
tab [0].affiche(); - Je suis un flottant de valeur 1.25
tab [1].affiche; } }
Interface et constantes
Une interface peut renfermer aussi des constantes symboliques qui seront accessibles à toutes
les classes implémentant l’interface :
public interface I
{void f (int n) ; //public abstract facultatifs
void g () ; //public abstract facultatifs
static final int max = 100 ;
}
Les constantes déclarées sont toujours considérées comme « static » et « final »
5.3. Interface et dérivations
L’interface est totalement indépendante de l’héritage : Une classe dérivée peut implémenter
une ou plusieurs interfaces.
interface I1 {…..}
interface I1 {…..}
class A implements I1 {……}
class B extends A implements I1, I2 {…..}
Exemple
interface I1
{void f(int n) ;
static final int max = 100;
}
interface I2 extends I1
{void g (int n);
static final int min = 10;
}
En fait la définition de I2 est équivalente à

interface I2
{void g (int n);
static final int min = 10;
void f(int n) ;
static final int max = 100;
}
5.4. Conflits des noms

Soit l’exemple suivant :
interface I1
{void f(int n) ;
void g();
}
interface I2
{void f (float x);
void g();
}
class A implements I1, I2
{ /*A doit implémenter la méthode g qui existe dans les 2
interfaces une seule fois*/}
Supposons que la méthode « g » est présente de 2 façons différentes dans I1 et I2
interface I1
{ void g(); } // g est une méthode abstraite de I1
interface I2
{ int g(); } // g est aussi une méthode abstraite de I2
class A implements I1, I2 {
/* Erreur car void g() et int g() ne peuvent pas coexister au sein de la même
classe*/ }

Chapitre 7 : Gestion d’exception

1. Présentation
Une exception est un événement exceptionnel risquant de compromettre le bon déroulement
du programme, par exemple :
 Division par zéro,
 Un débordement de tableau.
 La lecture d’une donnée erronée.
Lors de la détection d’une anomalie, une fonction peut essayer de la traiter directement; elle
peut aussi fournir des informations de retour (par l’intermédiaire d’une variable) indiquant le
type de l’anomalie et laissant au programme appelant le soin de décider de la suite à donner à
cette anomalie.
2. Classement des exceptions
Error : décrit les erreurs internes ou le manque de ressources dans le système d’exécution de
Java.
Exception : se sépare également en deux branches : les exceptions dérivant de
RuntimeException et les autres.
Voici la règle générale : une exception RuntimeException se produit toujours en

raison d’une erreur de programmation. Toutes les autres exceptions ont une cause
externe à votre programme, par exemple une erreur d’entrée/sortie.
Les exceptions héritant de RuntimeException traitent des problèmes comme ceux-ci :

 Un mauvais transtypage.
 Un accès à un tableau en dehors des limites.
Les exceptions n’héritant pas de RuntimeException comprennent :
 Accéder un URL incorrecte.
 Rechercher un objet class en donnant un nom non correspondant à aucune classe
existante.

Exemple1 : Débordements de tableaux (dans main RuntimeException)

public class TestException1 {
public static void main (String[] args) {
int tabEnt[] = { 1, 2, 3, 4 };
// Exception de type java.lang.ArrayIndexOutOfBoundsException
// non controlée par le programme; erreur d’exécution
tabEnt [4] = 0; // erreur et arrêt
System.out.println ("Fin du main"); // le message n’apparaît pas
} // main
}
Exemple 2 : Division par zéro (dans main RuntimeException)

public static void main( String[] args) {
int i = 3; int j = 0;
System.out.println("résultat = " + (i / j)); // erreur et arrêt
System.out.println ("Fin du main"); // le message n’apparaît pas
}
}
3. Structure de gestion d’exceptions : le bloc try… catch… finally
La syntaxe d’un bloc try… catch… finally :
try
{
... // Code pouvant entraîner une exception.
}
catch(Exception e)
{
... // Code prenant en compte une exception i.e. un objet de
// la classe ArithmeticException ou d’une classe dérivée.
}
finally
{
... // Le code d’un bloc finally qui sera à exécuter en dernier lieu.
}
Exemple1 : Débordements de tableaux (dans main RuntimeException)

public static void main (String[] args) {
try {
int tabEnt[] = { 1, 2, 3, 4 };
//Exception de type ArrayIndexOutOfBoundsException
// controlée par le programme
tabEnt [4] = 0; // Exception et suite au catch
System.out.println ("Fin du try"); //non exécutée }
catch (Exception e) {
System.out.println ("Exception : " + e);//écrit le message
}
System.out.println ("Fin du main"); // exécutée

}
}
Exemples d’exécution:
Exception :java.lang.ArrayIndexOutOfBounds : 4
Fin du main
Exemple 4 : Division par zéro (dans main RuntimeException)
public class TestException {

int i = 3;
int j = 0;
try {
System.out.println("résultat = " + (i / j));
}
catch (Exception e) {
System.out.println ("Exception : " + e); //écrit le message
}
System.out.println ("Fin du main"); // exécutée
}
}
Exemples d’exécution :
Exception : java.lang.ArithmeticException: / by zero
Fin du main
4. Définition et lancement des exceptions utilisateurs(throws et throw)
1 Une classe d’exception se définit en héritant de la classe Exception déjà définie dans l’API java.
public class ErrCoord extends Exception { }

public class Point {
private int x,y;
public Point(int x,int y) throws ErrCoord { 2
if(x<0 || y<0) throw new ErrCoord();
3
this.x = x; this.y = y;
}
System.out.println("Je suis un point de coordonnées "+x+" "+y);
}
}
On indique le type d’exceptions qui peuvent être rencontrées dans les méthodes de la classe Point
2 par le mot clé throws.
3 On lance une exception par le mot clé throw new TypeException.

4 Ensuite pour récupérer une exception lancée par une méthode, on utilise les instructions try et
catch :
public class TestExcept {

public static void main(String args[]){
try{ //Instructions qui peuvent voir une exception se
déclencher
Point a = new Point(1,4);
a.affiche();
a = new Point(-3,5);
a.affiche();
}
catch(ErrCoord e)
{ //gestion de l’exception
System.err.println("Erreur de construction");
}
}}
Résultat d’exécution:

5. Gestion de plusieurs exceptions et transmission d’information

Exemple
public class ErrCoord extends public class ErrDep extends Exception
Exception { {
private int abs,ord; private int depx,depy;
public ErrCoord(int abs,int ord) { public ErrDep(int depx,int depy) {
this.abs = abs; this.depx = depx;
this.ord = ord; this.depy = depy;
} }
public int getAbs() public int getDepx() {
{ return abs;} return depx;}
public int getOrd() public int getDepy() {
{return ord;} return depy;}
} }
public class Point { public class TestExcept {

private int x,y; public static void main(String args[])
public Point(int x,iny y) throws {
ErrCoord { try{ //Instructions qui peuvent voir
if(x<0 || y<0) throw new une exception se déclencher
ErrCoord(x,y); Point a = new Point(1,4);
this.x = x; a.affiche();
this.y = y; a.deplace(-3,5);
} a = new Point(-3,5);
public void deplace(int dx,int dy) a.affiche();}
throws ErrDep { catch(ErrCoord e){
if((x+dx<0) || (y+dy<0)) System.out.println("Erreur de
throw new ErrDep(dx,dy); construction"+e.getAbs()+"
x+=dx; "+e.getOrd());
y+=dy; System.exit(-1);}
} catch(ErrDep e){
public void affiche() { System.out.println("Erreur de
System.out.println("Je suis un deplacement "+e.getDepx()+"
point de coordonnées "+x+" "+y); "+e.getDepy());
} System.exit(-1);
} }//l’execution se poursuit ici s’il
n’y a pas d’erreurs
System.out.println("Fin du
programme");
}}

Chapitre 8 : Interfaces Comparables et Cloneables/

Classes enveloppes
1. Interfaces Comparables
L’interface Comparable, nécessite l’implémentation de la méthode compareTo :
interface Comparable {
public int compareTo(Object o);
}
La méthode compareTo permet de comparer l’objet courant (this) à l’objet o reçu en argument
et renvoyer un entier (dont la valeur exacte est sans importance) :
 négatif (la valeur -1)si l’on considère que l’objet courant est "inférieur" à l’objet o (au
sens de l’ordre qu’on veut définir),
 nul (la valeur 0)si l’on considère que l’objet courant est égal à l’objet o (il n’est ni
inférieur, ni supérieur),
 positif (la valeur 1)si l’on considère que l’objet courant est "supérieur" à l’objet o,
2. Interfaces Cloneables
L’interface Comparable, nécessite l’implémentation de la méthode clone :
interface Cloneable {
public Object clone();
}
 Une classe qui veut que ses instances puissent être clonés superficiellement devra
implémenter l’interface Cloneable et redéfinir la méthode clone() :
class XSurface implements Cloneable{

...
public Object clone() throws CloneNotSupportedException {
return super.clone();
}}
 Une classe qui veut que ses instances puissent être clonés en profondeur devra
implémenter l’interface Cloneable et redéfinir la méthode clone() :
class XProfondeur implements Cloneable{

X x;
...
XProfondeur xp = (XProfondeur)super.clone() ;
xp.x = (X)x.clone();
return xp; } }
Exemple1 : Classe personne
public class Personne implements Cloneable{

private String nom; private String prenom;
public Personne(String nom, String prenom) {

this.nom = nom;
this.prenom = prenom;
}
public Object clone() // Permet de cloner l'objet
{
Object o=null;
Try {
o = super.clone();// Appele la methode clone() de la classe
// parente ( la classe Object)
}
catch (CloneNotSupportedException e) //Intercepte une erreur
//lors de la copie
{
System.out.println(e);
}
return o; // ATTENTION : Renvoie un objet de la Classe Object
}
System.out.println("personne: "+prenom+"; "+nom);
}
public void setPrenom(String n) {
this.prenom=n;
}
}
public class Test {
Personne p=new Personne("youssef","dahani") ;
Personne p1=(Personne) p.clone();
System.out.println( p1);
System.out.println(p);
p.affiche();
p1.affiche();
p1.setPrenom("Ahmadi");
p.affiche();
p1.affiche();
}
}
Exemple2 : Clonage superficielle : Classe personne
public class Personne implements Cloneable{

private String nom; private String prenom;
public Personne(String nom, String prenom) {
this.nom = nom;
}

//***********************************************************
}
System.out.println("personne: "+prenom+"; "+nom);
}
public void setPrenom(String n) {
this.prenom=n;
}
}
public class Test {
try{
Personne p=new Personne("youssef","dahani");
Personne p1=(Personne)p.clone();
System.out.println(p);
System.out.println(p1);
p.affiche();
p1.affiche();
p.setPrenom("Ahmadi");
p.affiche();
p1.affiche();
}
catch (CloneNotSupportedException e){
throw new InternalError();
}
}
}
Exemple3 : Clonage profondeur: Classe Cellule
public class Cellule extends Object implements Cloneable {

// Doit implementer la méthode clone() de l'interface Clonable.
int[] t = {1, 2};
// Méthodes
public Object clone(){
try {
}
catch (CloneNotSupportedException e){
throw new InternalError();
}
}
public Object clone(){
Cellule tmp = new Cellule();
tmp.t = (int []) this.t.clone(); //clonage de this.t

return tmp;
}
public void afficher(){
System.out.println(t[0]+" "+t[1]);
}
public void changeMe(){
t[0] = 11;
t[1] = 12;
}
}
public class TestCellule {
public static void main(String args[]){
Cellule x = new Cellule(); // x Objet Cellule
x.afficher();
Cellule y = (Cellule) x.clone(); // y clone de x
y.afficher();
x.changeMe();
y.afficher();
x.afficher();
System.out.println(x);
System.out.println(y);
}
}
3. Classes enveloppes
Les classes enveloppes (wrappers en anglais) vont permettre de manipuler les types primitifs
comme des objets. Chacun des 8 types primitifs (boolean, byte, char, short, int, long, float et
double) possède une classe correspondante, appelée classe enveloppe, qui généralise le type.
Les 8 classes enveloppes sont:
 Boolean,
 Byte,
 Character,
 Short,
 Integer,
 Long,
 Float
 Double.
Ces classes enveloppes sont définies dans java.lang et peuvent donc être utilisées sans
importation.
Toutes les classes enveloppes disposent d’un constructeur recevant un argument d’un type
primitif :
Integer nObj = new Integer (12) ; // nObj contient la référence à un objet
// de type Integer encapsulant la valeur 12
Double xObj= new Double (5.25) ; // xObj contient la référence à un objet
// de type Double encapsulant la valeur 5.25
Elles disposent toutes d’une méthode de la forme xxxValue (xxx représentant le nom du type
primitif) qui permet de retrouver la valeur dans le type primitif correspondant :
int n = nObj.intValue() ; // n contient 12

double x = xObj.doubleValue() ; // x contient 5.25
Ces classes enveloppes sont finales (on ne peut pas créer de classes dérivées) et inaltérables
puisque les valeurs qu’elles encapsulent ne sont pas modifiables.

Chapitre 9 : Flux d’entrées sorties

1. Présentation
Un programme a souvent besoin d’importer de l’information depuis une source externe ou
d’exporter une information vers une destination externe.
Cette information peut être :
 dans un fichier,
 sur un disque,
 quelque part sur le réseau, en mémoire,
 dans un autre programme.
Elle peut être de n’importe quel type :
 type de base,
 objets,
 caractères,
 image,
 sons…
Pour importer une information, un programme ouvre un flux sur une source d’information
(un fichier, la mémoire) et lit l’information séquentiellement.
Pour exporter une information vers une destination externe, le programme peut ouvrir un flux
vers cette destination et y écrire l’information séquentiellement.
Un flux(ou flot ou stream en anglais) est une suite de données (octets, caractères, objets
quelconques) successivement lues ou écrites.
Les étapes de lecture/écriture sont identiques et se résument comme suit:
Lecture Écriture
Ouvre un flux en lecture Ouvre un flux en écriture
Lit tant qu’il ya quelque chose à lire Écrire tant qu’il y a quelque chose à écrire
Ferme le flux Ferme le flux

Types de Flux : Binaire et Texte
Flux Binaire: Superclasse InputStream et OutptStream
Flux Texte: Superclasse Reader et Writer
En Java, le nombre de classes intervenant dans la manipulation des flux est important (plus de
50). Dans ce chapitre, on va réaliser les opérations classiques suivantes :
 création séquentielle d’un fichier binaire ;
 lecture séquentielle d’un fichier binaire ;
 accès direct à un fichier binaire ;
 création d’un fichier texte ;
 lecture d’un fichier texte ;

2. Création séquentielle d’un fichier binaire

Nous vous proposons d’écrire un programme qui enregistre dans un fichier binaire différents
nombres entiers (de type int) fournis par l’utilisateur au moyen du clavier.
La classe abstraite OutputStream sert de base à toutes les classes relatives à des flux binaires
de sortie. La classe FileOutputStream, dérivée de OutputStream, permet de manipuler un flux
binaire associé à un fichier en écriture. L’un de ses constructeurs s’utilise ainsi :
FileOutputStream f = new FileOutputStream ("entiers.dat") ;
Cette opération associe l’objet f à un fichier de nom entiers.dat. Si ce fichier n’existe pas, il est
alors créé (vide). S’il existe déjà, son ancien contenu est détruit. On a donc affaire à une
classique opération d’ouverture d’un fichier en écriture. Cependant, les méthodes de la classe
FileOutputStream sont rudimentaires. En effet, elles permettent seulement d’envoyer sur le
flux (donc d’écrire dans le fichier) un octet ou un tableau d’octets.
En fait, il existe une classe DataOutputStream qui comporte des méthodes plus évoluées et
qui dispose (entre autres) d’un constructeur recevant en argument un objet de type
FileOutputStream. Ainsi, avec :
DataOutputStream sortie = new DataOutputStream (f) ;
On crée un objet sortie qui, par l’intermédiaire de l’objet f, se trouve associé au fichier
entiers.dat. Bien entendu, les deux instructions (création FileOutputStream et
DataOutputStream) peuvent être condensées en :
DataOutputStream sortie = new DataOutputStream ( new FileOutputStream ("entiers.dat)) ;
La classe DataOutputStream dispose notamment de méthodes permettant d’envoyer sur un
flux (donc ici d’écrire dans un fichier) une valeur d’un type primitif quelconque. Elles se
nomment writeInt (pour int), writeFloat (pour float), et ainsi de suite. Ici, writeInt nous
conviendra.
Exemple :
Voici donc un programme complet qui lit des nombres entiers au clavier et qui les recopie
dans un fichier binaire. Ici, par souci de simplicité, nous avons convenu que l’utilisateur
fournirait un entier nul à la suite de sa dernière valeur (il n’est pas recopié dans le fichier).
import java.io.* ; // pour les classes flux
import java.util.Scanner;
public class CreFichierBinaire {
public static void main (String args[]) throws IOException
{
String nomfich;
int n ;
System.out.print ("donnez le nom du fichier a creer : ") ;
Scanner Clavier=new Scanner(System.in);
nomfich = Clavier.nextLine() ;
DataOutputStream sortie = new DataOutputStream
(new FileOutputStream (nomfich)) ;
do { System.out.print ("donnez un entier : ") ;
n = Clavier.nextInt() ;
if (n != 0)
{ sortie. writeInt (n) ;
}
}

while (n != 0) ;
sortie.close () ;
System.out.println ("*** fin creation fichier ***");
}
}
donnez le nom du fichier a creer : entiers
donnez un entier : 12
*** fin creation fichier ***
Remarques:
 On peut fournir en argument du constructeur de FileOutputStream un objet de type File à
la place d’un objet de type String car Java dispose d’une classe File permettant de
manipuler des noms de fichiers ou de répertoires.
 Il est possible de doter un flux d’un tampon. Il s’agit d’un emplacement mémoire qui sert
à optimiser les échanges avec le flux.
 Les informations sont d’abord enregistrées dans le tampon, et ce n’est que lorsque ce
dernier est plein qu’il est "vidé" dans le flux.
 Pour doter un flux de type FileOutputStream d’un tampon, on crée un objet de type
BufferedOutputStream en passant le premier en argument de son constructeur.
DataOutputStream sortie = new DataOutputStream ( new BufferedOutputStream
( new FileOutputStream (nomfich))) ;
3. Liste séquentielle d’un fichier binaire

Voyons maintenant comment relire séquentiellement un fichier tel que celui créé par le
programme précédent, afin d’en afficher le contenu à l’écran.
Comme on peut s’y attendre, par analogie avec ce qui précède, la classe abstraite InputStream
sert de base à toute classe relative à des flux binaires d’entrée. La classe FileInputStream,
dérivée de InputStream, permet de manipuler un flux binaire associé à un fichier en lecture.
L’un de ses constructeurs s’utilise ainsi :
FileInputStream f = new FileInputStream ("entiers.dat") ;
Cette opération associe l’objet f à un fichier de nom entiers.dat. Si ce fichier n’existe pas, une
exception FileNotFoundException (dérivée de IOException) est déclenchée.
Cependant, les méthodes de la classe FileInputStream sont rudimentaires. En effet, elles
permettent seulement de lire dans un fichier un octet ou un tableau d’octets. Ici encore, il
existe une classe DataInputStream qui possède des méthodes plus évoluées et qui dispose
(entre autres) d’un constructeur recevant en argument un objet de type FileInputStream. Ainsi,
avec :
DataInputStream entree = new DataInputStream (f) ;

on crée un objet entree qui, par l’intermédiaire de l’objet f, se trouve associé au fichier
entiers.dat. Ici encore, les deux instructions (création FileInputStream et création
DataInputStream) peuvent être condensées en :
DataInputStream entree = new DataInputStream ( new FileInputStream ("entiers.dat")) ;
Enfin, la classe DataInputStream dispose de méthodes permettant de lire sur un flux (donc ici
dans un fichier) une valeur d’un type primitif quelconque. Elles se nomment readInt (pour
int), readFloat (pour float)... Ici, readInt nous conviendra.
Exemple :
Voici un programme complet qui relit un fichier binaire d’entiers du type de ceux créés.
import java.io.* ; // pour les classes flux
public class LecFichierBinaire
{ public static void main (String args[]) throws IOException
{ String nomfich ;
int n = 0 ;
System.out.print ("donnez le nom du fichier a lister : ") ;
DataInputStream entree = new DataInputStream
( new FileInputStream (nomfich))
System.out.println ("valeurs lues dans le fichier " + nomfich + " :") ;
boolean eof = false ; // sera mis a true par exception EOFile
while (!eof)
{ try
{ n = entree.readInt () ;}
catch (EOFException e)
{ eof = true ;}
if (!eof) System.out.println (n) ;}
entree.close () ;
System.out.println ("*** fin liste fichier ***");
}
}
donnez le nom du fichier a lister : entiers
12
85
55
128
47
0
*** fin fin liste fichier ***

Remarques:
 On peut fournir en argument du constructeur de FileInputStream un objet de type File à la
place d’un objet de type String car Java dispose d’une classe File permettant de
manipuler des noms de fichiers ou de répertoires.
 Pour doter un flux de type FileInputStream d’un tampon, on crée un objet de type
BufferedInputStream en passant le premier en argument de son constructeur.
DataInputStream sortie = new DataInputStream ( new BufferedInputStream
( new FileInputStream (nomfich))) ;
4. Accès directe à un fichier binaire
Pour réaliser l’accès direct à un fichier binaire java dispose une classe spécifique
RandomAccessFile. Cette classe dispose des fonctionnalités des deux classes
DataInputStream et DataOutputStream, en particulier des méthodes readInt, readFloat,
writeInt, writeFloat... Les constructeurs de la classe RandomAccesFile besoin de deux
paramètres:
 Nom de fichier à accéder.
 Mode d’accès : deux valeurs "r" (lecture seule) ou "rw" (lecture et écriture).
RandomAccesFile entree = new RandomAccesFile(“entiers ’’, ‘’r’’);
RandomAccessFile dispose d’une méthode spécifique seek permettant d’agir sur le "pointeur
de fichier".
Remarques:
Le pointeur de fichier correspond au rang du prochain octet à lire ou à écrire (le premier octet
portant le numéro 0).
Exemple :
import java.io.* ;
public class AccesDirect
{ String nomfich ;
int n, num ;
RandomAccessFile entree ;
System.out.print ("donnez le nom du fichier a consulter : ") ;
entree = new RandomAccessFile (nomfich, "r") ;
do
{ System.out.print ("Numero de l’entier recherche : ") ;
num = Clavier.nextInt() ;
if (num == 0) break ;
entree.seek (4*(num-1)) ;
n = entree.readInt() ;
System.out.println (" valeur = " + n) ;
}
while (num != 0) ;
entree.close () ;
System.out.println ("*** fin consultation fichier ***");
}}

donnez le nom du fichier a consulter : entiers.
Numero de l’entier recherche : 3
valeur = 55
valeur = 47
*** fin consultation fichier ***
5. Création d’un fichier texte
Nous vous proposons d’écrire un programme qui lit des nombres entiers au clavier et qui,
pour chacun d’entre eux, écrit une ligne d’un fichier texte contenant le nombre fourni
accompagné de son carré, sous la forme suivante : 12 a pour carre 144
On convient que l’utilisateur fournira la valeur 0 pour signaler qu’il n’a plus de valeurs à
entrer. La classe abstraite Writer sert de base à toutes les classes relatives à un flux texte de
sortie. La classe FileWriter, dérivée de Writer, permet de manipuler un flux texte associé à un
fichier. L’un de ses constructeurs s’utilise ainsi: FileWriter f = new FileWriter ("carres.txt") ;
Cette opération associe l’objet f à un fichier de nom carres.txt. S’il n’existe pas, il est créé
(vide). S’il existe, son ancien contenu est détruit. On a donc affaire à un classique ouverture
en écriture.
Les méthodes de la classe FileWriter permettent d’écrire des caractères, des tableaux de
caractères ou des chaînes. Dans certains cas, elles se révéleront suffisantes. Mais, si l’on
souhaite disposer de possibilités de formatage, on peut recourir à la classe PrintWriter qui
dispose d’un constructeur recevant en argument un objet de type FileWriter.
Ainsi, avec : PrintWriter sortie = new PrintWriter (f); on crée un objet sortie qui, par
l’intermédiaire de l’objet f, se trouve associé au fichier carres.txt.
Bien entendu, les deux instructions peuvent être fusionnées en :
PrintWriter sortie = new PrintWriter (new FileWriter ("carres.txt")) ;
Comme nous l’avons vu dans l’introduction, la classe PrintWriter dispose des méthodes print
et println que nous allons pouvoir utiliser exactement comme nous l’aurions fait pour afficher
l’information voulue à l’écran.
Exemple :
import java.io.FileWriter;
import java.io.IOException;
import java.io.PrintWriter;
public class CreFichierText
{ String nomfich ;
int n ; Scanner Clavier=new Scanner(System.in);
System.out.print ("Donnez le nom du fichier a creer : ") ;
PrintWriter sortie = new PrintWriter (new FileWriter (nomfich)) ;
do
{ System.out.print ("donnez un entier : ") ;

if (n != 0)
{ sortie.println (n + " a pour carre " + n*n) ;
}}
while (n != 0) ; sortie.close () ;
System.out.println ("*** fin creation fichier ***");
}
}
Donnez le nom du fichier a creer : carres.txt
*** fin creation fichier ***
Voici la liste du fichier ainsi créé :
5 a pour carre 25
12 a pour carre 144
45 a pour carre 2025
2 a pour carre 4
6. Lecture d’un fichier texte
Pour lire un fichier texte on distingue deux situations :
 On se contente d’accéder aux lignes du fichier (sans chercher à un interpréter le
contenu).
 On souhaite pouvoir accéder aux différentes informations présentes dans une ligne.
6.1. Accès aux lignes d’un fichier texte
Dans la hiérarchie de la superclasse Reader n’existe pas une classe jouant le rôle symétrique
de PrintWriter. Il faut se contenter de la classe FileReader, symétrique de FileWriter. Les
méthodes de cette classe donnent la possibilité d’accéder des caractères, ce qu’il faut prendre
en considération la gestion de la fin de la ligne. En couplant la classe FileReader avec la
classe BufferedReader qui dispose d’une méthode readLine, nous allons pouvoir lire chacune
des lignes de notre fichier.
BufferedReader entree = new BufferedReader (new FileReader ("carres.txt")) ;
La méthode readLine de la classe BufferedReader fournit une référence à une chaîne
correspondant à une ligne du fichier. Si aucun caractère n’est disponible (pas même une
simple fin de ligne), readLine fournit la valeur null.
Exemple:
import java.io.* ;
public class LecFichierText
{

String nomfich ;
String ligne ;
System.out.print ("Donnez le nom du fichier a lister : ") ;
BufferedReader entree = new BufferedReader (new FileReader
(nomfich)) ;
do
{ ligne = entree.readLine() ;
if (ligne != null) System.out.println (ligne) ;
}
while (ligne != null) ;
entree.close () ;
System.out.println ("*** fin liste fichier ***");
}
}
Donnez le nom du fichier a lister : carres.txt
5 a pour carre 25
12 a pour carre 144
45 a pour carre 2025
2 a pour carre 4
*** fin liste fichier ***
6.2. La classe StringTokenizer
Dans l’exemple précédent, nous nous sommes contentés d’accéder aux différentes lignes du
fichier. Dans certains cas, vous pourrez avoir besoin d’accéder à chacune des informations
d’une même ligne. JAVA dispose d’une classe nommée StringTokenizer, qui permet de
découper une chaîne en différents tokens (sous-chaînes), en se fondant sur la présence de
caractères séparateurs qu’on choisit librement. Par ailleurs, on pourra appliquer à ces
différents tokens, les possibilités de conversion d’une chaîne en un type primitif, ce qui
permettra d’obtenir les valeurs voulues.
Nous lisons chaque ligne du fichier comme précédemment. Puis nous construisons, à partir de
la ligne lue (ici, ligneLue), un objet de type StringTokenizer :
StringTokenizer tok = new StringTokenizer (ligneLue, " ") ;
Méthodes de la classe String Tokenizer :
 countToken, qui compte le nombre de tokens d’un objet du type StringTokenizer ;
 nextToken, qui fournit le token suivant s’il existe
Exemple :
import java.io.* ;
import java.util.* ; // pour StringTokenizer
public class Tokenizer {
public static void main (String args[]) throws IOException {
String nomfich ; int nombre, carre ;
System.out.print ("donnez le nom du fichier a lister : ") ;

BufferedReader entree = new BufferedReader (new FileReader
(nomfich));
System.out.println ("Nombres et carres dans ce fichier") ;
while (true)
{ String ligneLue = entree.readLine() ;
if (ligneLue == null) break ;
StringTokenizer tok = new StringTokenizer (ligneLue) ;
nombre = Integer.parseInt (tok.nextToken()) ;
for (int i=0 ; i<3 ; i++)
tok.nextToken() ; //pour sauter : a pour carre
carre = Integer.parseInt (tok.nextToken()) ;
System.out.println (nombre + " " + carre) ;
}
entree.close () ;
System.out.println ("*** fin liste fichier ***");}}
donnez le nom du fichier a lister : carres.txt
Nombres et carres dans ce fichier
5 25
12 144
45 2025
2 4
*** fin liste fichier ***
7. La gestion des fichiers: la Classe File
Les fichiers et les répertoires sont encapsulés dans la classe File du package java.io. Une
instance de la classe File est une représentation logique d'un fichier ou d'un répertoire qui peut
ne pas exister physiquement sur le disque.
 La classe File dispose des nombreuses méthodes permettant de :
 créer, supprimer ou renommer un fichier ou un répertoire,
 tester l’existence d’un fichier ou d’un répertoire,
 obtenir des informations relatives aux protections ou aux dates de modification,
 lister les noms de fichiers d’un répertoire.
7.1. Création d’un objet de type File
L’instruction : File monFichier = new File ("truc.dat") ; crée un objet de type File, nommé
monFichier, auquel est associé le nom truc.dat.
7.2. les méthodes de la classe File
a. Création et suppression
 boolean createNewFile ()
Crée un nouveau fichier qui doit ne pas exister ; renvoie true si la création s’est déroulée
convenablement.
 boolean delete ()
Essaie de supprimer le fichier ; renvoie true si la suppression a eu lieu. Si le fichier n’existe

pas, renvoie false.
b. Teste d’existence
 boolean exists ()
Fournit true si le fichier correspondant existe.
 boolean isFile ()
Fournit true si l’objet correspond à un nom de fichier (indépendamment de l’existence de ce
fichier).
 boolean isDirectory ()
Fournit true si l’objet correspond à un nom de répertoire (indépendamment de l’existence de
ce répertoire).
c. Informations
 long length()
Fournit la longueur du fichier, en octets (0 s’il n’existe pas ou s’il est vide).
 String getName ()
Fournit une chaîne contenant le nom correspondant (sans nom de chemin).
 boolean isHidden()
Fournit true si l’objet correspond à un fichier caché.
 boolean canRead()
Fournit true si l’objet correspond à un fichier autorisé en lecture.
 boolean canWrite()
Fournit true si l’objet correspond à un fichier autorisé en écriture.
 boolean canExecute()
Fournit true si l’objet correspond à un fichier programme exécutable.
 setReadOnly ()
Marque l’objet comme étant en lecture seule.
d. Accès aux membres d’un répertoire
 String [] liste()
Fournit un tableau de chaînes correspondant.
 File [] listeFiles()
Fournit les mêmes informations que la méthode précédente, mais sous la forme plus pratique
d’un tableau d’objets de type File.
Exemple :
import java.io.*;
public class TestFichier {
public static void main (String args[])throws IOException{
int n;
File monFichier = new File ("ent.dat");
DataOutputStream sortie = new DataOutputStream(new FileOutputStream
(monFichier));
do { System.out.print ("donnez un entier : ") ;
if (n != 0)

{ sortie. writeInt (n) ;}

}while (n != 0) ;
sortie.close () ;
monFichier.setReadOnly();
if (!monFichier.exists()) {
System.out.println("le fichier "+monFichier+" n'existe pas");
System.exit(1); }
System.out.println(" Nom du fichier : "+monFichier.getName());
System.out.println(" Chemin du fichier : "+monFichier.getPath());
System.out.println(" Chemin absolu :"+monFichier.getAbsolutePath());
System.out.println(" Droit de lecture : "+monFichier.canRead());
System.out.println(" Droite d'ecriture : "+monFichier.canWrite());
System.out.println(" Taille de ce fichier en octet:
"+monFichier.length());
}}
Nom du fichier : ent.dat
Chemin du fichier : ent.dat
Chemin absolu : C:\Users\dell\Desktop\java programme\Exception\Classe File\ent
Droit de lecture : true
Droite d'ecriture : false
Taille de ce fichier en octet: 8
8. sérialisation et désérialisation
La sérialisation est la technique qui permet de transformer une structure de données
complexe en mémoire vers une représentation linéaire, sous la forme d’une chaîne de
caractères, qui peut être transmise via le réseau ou de le sauvegarder dans un fichier binaire.
La désérialisation est le procédé inverse, qui prend une donnée linéaire selon un certain
format et reconstruit une structure de données complexe en mémoire isomorphe à celle qui a
été sérialisée.
8.1. Interface Serializable
L’interface Serializable ne définit aucune méthode mais permet simplement de marquer une
classe comme pouvant être sérialisée. Tout objet qui doit être sérialisé doit implémenter cette
interface ou une de ses classes mères doit l'implémenter. Si l'on tente de sérialiser un objet qui
n'implémente pas l'interface Serializable, une exception java.io.NotSerializableException est
levée.
Exemple
public class Personne implements Serializable {

private String nom ;
private String prenom;
private int taille ;
public Personne(String nom, String prenom, int taille) {
this.nom = nom;

this.taille = taille;
}
public String getNom() {
return this.nom;
}
public void setNom( String nom) {
this.nom = nom;
}
public int getTaille() {
return this.taille;
}
public void setTaille( int taille) {
this.taille = taille;
}
public String getPrenom() {
return this.prenom;
}
public void setPrenom(String prenom) {
}
}
8.2. Etapes de sérialisation: Ecrire un objet sérialisé dans un fichier
1- Créer un objet FileOutputStream.
FileOutputStream sortie= new FileOutputStream(‘Personne.txt’);
2- Créer un objet ObjectOutputStream. Cet objet permet d’écrire des objets, mais il ne
peut pas se connecter directement à un fichier. Il a besoin pour ce la d’un
« intermidiaire », ici un FileOutputStream. on va alors chainer les deux flots,
ObjectOutputStream et FileOutputStream
ObjectOutputStream sor= new ObjectOutputStream(‘sortie’);
3- Ecrire les objets a sauvegarder dans ‘Personne.txt’
sor.writeObject(personne1);
sor.writeObject(personne2);
…….
sor.writeObject(personnen);
4- Fermer ObjectOutputStream. La fermeture du premier flot entraine automatiquement
celle des autres.
sor.close();
8.3. Etapes désérialisation
L’interet de sauvegarder un objet est de pouvoir le restaurer le moment venu. Le processus de

désérialisation est très similaire à celui de sérialisation
1- Chainer un objet FileInputStream et un objet ObjectInputStream
FileOutputStream entree= new FileOutputStream(‘Personne.txt’);
ObjectInputStream ent= new ObjectInputStream(‘entree’);
2- À chaque invocation de readObject, l’objet suivant est récupéré.
Object p1=ent.readObject();
…….
Object pn=ent.readObject();

3- Convertir les objets:
Personne p11=(Personne) p1;

Personne p22=(Personne) p2;
…….
Personne pnn=(Personne) pn;
4- Fermer les flots:
ent.close();

Chapitre 10 : Collections
1. Définition
Une collection gère un groupe d'un ensemble d'objets d'un type donné ; ou bien c'est un objet
qui sert à stocker d'autres objets.
2. Interfaces
Les interfaces sont organisées on deux catégories : Collection && Map.
- Collection: un groupe d'objets où la duplication peut être autorisée.

- Set: est ensemble ne contenant que des valeurs et ces valeurs ne sont pas dupliquées. Par
exemple l'ensemble A = {1, 2, 4, 8}. Set hérite donc de Collection, mais n'autorise pas la
duplication. SortedSet est un Set trié.
- List: hérite aussi de collection, mais autorise la duplication. Dans cette interface, un système
d'indexation a été introduit pour permettre l'accès (rapide) aux éléments de la liste.
- Map: est un groupe de paires contenant une clé et une valeur associée à cette clé. Cette
interface n'hérite ni de Set ni de Collection. La raison est que Collection traite des données
simples alors que Map des données composées (clé, valeur). SortedMap est un Map trié.
3. Description des interfaces
3.1. Interface Collection
public Interface Collection{
// les opérations de base
int size(); //nombre d'éléments
boolean isEmpty(); //test de l'absence d'éléments
boolean contains(Object element); //test d'appartenance
boolean add(Object element); //ajouter un élément: Optional
boolean remove(Object element); //supprimer un élément :Optional
Iterator iterator(); //pour le parcours (cf Iterator)
int hashCode();
boolean equals(Object element);
//les operations booleans
boolean containsAll(Collection c); //appartenance collective
boolean addAll(Collection c);//ajouter plusieurs éléments :Optional
boolean removeAll(Collection c);
//supprimer plusieurs éléments :Optional
boolean retainAll(Collection c); //intersection :Optional
void clear(); // tout supprimer : Optional

// Array Operations
Object[] toArray(); //transformation en tableau
Object[] toArray(Object a[]); //tableau de même type que a
}
Les interfaces contiennent des méthodes optionnelles. Cette approche permet de traiter les
collections particulières sans que nous soyons dans l'obligation de définir les méthodes
optionnelles. Ces méthodes optionnelles sont définies qu'en cas de besoin. Un Set non
modifiable n'a pas besoin de redéfinir la méthode add, puisque nous ne pouvons pas le
modifier!
Il y a des opérations réalisées sur un seul objet ou bien sur une collection (un ensemble
d'objets).
 add (remove) permet d'ajouter (resp. de retirer) un élément. Quand à addAll
(removeAll) permet d'ajouter (resp. de retirer même si les éléments sont dupliqués
dans la collection originale) une collection.
 contains (containsAll) permet de vérifier si un objet (resp. les éléments d'une
collection) est présent dans la collection.
 size, isEmpty et clear, permettent respectivement de donner la taille de la collection,
de vérifier si la collection est vide et finalement d'effacer le contenu de la collection.
 retainsAll se comporte comme le résultat de l'intersection de deux ensembles.
Si A={1,2,5,8} et B={3,8} alors A = {8}.
 equals permet de tester si deux objets sont égaux.
 hashCode retourne le code de hachage calculé pour la collection.
 toArray retourne les éléments de la collection sous le format d'un tableau.
 toArray(Object a[]) permet de préciser le type du tableau à retourner. Si le tableau est
grand les éléments sont rangés dans ce tableau, sinon un nouveau tableau est créé pour
recevoir les éléments de la collection.
L'interface collection est dotée d'une instance d'une classe qui implante l'interface Iterator.
C'est l'outil utilisé pour parcourir une collection. L'interface Iterator contient ce qui suit:
public Interface Iterator{
boolean hasNext();
Object next();
void remove(); // Optional
}
 hasNext permet de vérifier s'il y a un élément qui suitnext permet de pointer l'élément
suivant.
 remove permet de retirer l'élément courant.
Les collections vues comme des ensembles réalisent les 3 opérations mathématiques sur des
ensembles:
 union: add et addAll
 intersection: retainAll
 différence: remove et removeAll
3.2. List
Liste est une collection ordonnée. Elle permet la duplication des éléments. L'interface est
renforcée par des méthodes permettant d'ajouter ou de retirer des éléments se trouvant à une
position donnée. Elle permet aussi de travailler sur des sous listes. On utilise le plus souvent

des ArrayList sauf s'il y a insertion d'élément(s) au milieu de la liste. Dans ce cas il est
préférable d'utiliser une LinkedList pour éviter ainsi les décalages.
public Interface List extends Collection{
// Positional Access
Object get(int index);
Object set(int index, Object element); // Optional
void add(int index, Object element); // Optional
Object remove(int index); // Optional
boolean addAll(int index, Collection c); // Optional
// Search
int indexOf(Object o);
int lastIndexOf(Object o);
// Iteration
ListIterator listIterator();
ListIterator listIterator(int index);
// Range-view
List subList(int fromIndex, int toIndex);
}
Les méthodes de l'interface List permettent d'agir sur un élément se trouvant à un index donné
ou bien un ensemble d'éléments à partir d'un index donné dans la liste.
 get (remove) retourne (resp. retirer) l'élément se trouvant à la position index.
 set (add & addAll) modifie (resp. ajouter) l'élément (resp. un seul ou une collection)
se trouvant à la position index.
 indexOf (lastIndexOf) recherche si un objet se trouve dans la liste et retourner son
(resp. son dernier) index.
 subList permet de créer un sous liste d'une liste.
Pour parcourir une liste, il a été défini un itérateur spécialement pour la liste.
public Interface ListIterator extends Iterator{
boolean hasNext();
Object next();
boolean hasPrevious();
Object previous();
int nextIndex();
int previousIndex();
void remove(); //Optional
void set(Object o); // Optional
void add(Object o); // Optional }
 hasNext permet de vérifier s'il y a un élément qui suit.
 next permet de pointer l'élément courant.
 nextIndex retourne l'index de l'élément courant.
Pour les sous listes, elles sont extraites des listes de fromIndex (inclus) à toIndex (non
inclus). Tout changement sur les sous listes affecte la liste de base, et l'inverse provoque un
état indéfini s'il y a accès à la sous liste.
Les classes implémentées l’interface List sont : ArrayList (tableau à taille variable),
LinkedList (liste chaînée) et Vector.

 La classe Array List

La classe ArrayList offre plus de souplesse que les tableaux d’objets dans la mesure où sa
taille (son nombre d’éléments) peut varier au fil de l’exécution (comme celle de n’importe
quelle collection).
Construction: Comme toute collection, un vecteur dynamique peut être construit vide ou à
partir d’une autre collection c :
Après JDK 5.0 Avant JDK 5.0
vecteur dynamique vide
ArrayList <E> v1 = new ArrayList <E> () ; ArrayList v1 = new ArrayList () ;
vecteur dynamique contenant tous les éléments de la collection c
ArrayList <E> v2 = new ArrayList <E>(c) ; ArrayList v2 = new ArrayList (c) ;
Exemple1: Voici un programme créant un vecteur contenant dix objets de type Integer,
illustrant les principales fonctionnalités de la classe ArrayList ;
import java.util.* ;
public class Array1{
public static void main (String args[]){
ArrayList <Integer> v = new ArrayList <Integer> () ;
System.out.println ("En A : taille de v = " + v.size() ) ;
/* on ajoute 10 objets de type Integer */
for (int i=0 ; i<10 ; i++)
v.add (Integer.valueOf(i)) ;
System.out.println ("En B : taille de v = " + v.size() );
/* affichage du contenu, par acces direct (get) a chaque element */
System.out.println ("En B : contenu de v = ");
for (Integer e : v)
System.out.print (e + " ");
System.out.println ();
/* suppression des elements de position donnee */
v.remove (3);
v.remove (5);
System.out.println ("En C : contenu de v = " + v);
/* ajout d’elements a une position donnee */
v.add (2, Integer.valueOf (100));
System.out.println ("En D : contenu de v = " + v);
/* modification d’elements de position donnee */
v.set (1, Integer.valueOf (1000)) ;
v.set (5, Integer.valueOf (2000)) ;
System.out.println ("En E : contenu de v = " + v);
}
}

Exemple2:
import java.util.*;
public class ListExemple {
ArrayList<String> list = new ArrayList<String>();
list.add("Bernadine");
list.add("Elizabeth");
list.add("Gene");
list.add("Elizabeth");
list.add("Clara");
System.out.println(list);
System.out.println("2: " + list.get(2));
System.out.println("0: " + list.get(0));
LinkedList<String> queue = new LinkedList<String>();
queue.addFirst("Bernadine");
queue.addFirst("Elizabeth");
queue.addFirst("Gene");
queue.addFirst("Elizabeth");
queue.addFirst("Clara");
System.out.println(queue);
queue.removeLast();
queue.removeLast();
System.out.println(queue);
}
}
 La classe Vector
Les vecteurs sont des objets de type Vector. La gestion des vecteurs est assez similaire à la
gestion des ArrayList.
Vector liste = new Vector() ;

Méthode Description
add(objet) Ajoute un élément objet en fin de liste.
Insère un élément objet dans la liste, à l’indice spécifié
add(indice, objet)
en paramètre.
Ajoute un élément objet en fin de liste et augmente sa
addElement(objet) taille de un.
Retourne l’élément stocké à l’indice spécifié en
elementAt(indice) paramètre.
clear() Supprime tous les éléments de la liste.
Retourne l’indice dans la liste du premier objet donné en
indexOf(objet)
paramètre, ou –1 si objet n’existe pas dans la liste.
Retourne l’indice dans la liste du dernier objet donné en
lastIndexOf(objet)
paramètre, ou –1 si objet n’existe pas dans la liste.
remove(indice) Supprime l’objet dont l’indice est spécifié en paramètre
Supprime tous les éléments compris entre les indices i
removeRange(i, j)
(valeur comprise) et j (valeur non comprise).
Remplace l’élément situé en position i par l’objet
setElementAt(objet, i)
spécifié en paramètre.
size() Retourne le nombre d’éléments placés dans la liste.
3.3. Interface Set

C'est une interface identique à celle de Collection. De plus cette interface n’accepte pas deux
objets égaux (au sens de equals). Deux implémentations possibles:
 TreeSet: les éléments sont rangés de manière ascendante.
 HashSet: les éléments sont rangés suivant une méthode de hachage.
Exemple :
import java.util.*;
public class SetExemple {
Set<String> set = new HashSet<String>(); // Une table de Hachage
set.add("Clara");
set.add("Maria");
set.add("Gene");
set.add("Elizabeth");
set.add("Clara");
System.out.println(set);
SortedSet<String> sortedset = new
TreeSet<String>(set); // Un Set trié
System.out.println(sortedset);
}
}

3.4. Map
C'est un ensemble de paires, contenant une clé et une valeur (en réalité, nous pouvons associer
plusieurs valeurs. Dans ce cas-là, nous sommes en présence d'une multimap.
Deux clés ne peuvent être égales au sens de equals.
L'interface interne Entry permet de manipuler les éléments d'une paire comme suit:
public interface Entry {
Object getKey();
Object getValue();
Object setValue(Object value);
}
getKey & getValue retournent respectivement la clé et la valeur associée à cette clé.
setValue permet de modifier une valeur d'une paire. Remarque : faire attention de ne pas
modifier directement la valeur associée à une clé. Pour le faire, retirer l'ancienne clé (et donc
sa valeur aussi) et ajouter une nouvelle clé (avec cette nouvelle valeur).
public interface Map {
// Basic Operations
Object put(Object key, Object value);
Object get(Object key);
Object remove(Object key);
boolean containsKey(Object key);
boolean containsValue(Object value);
int size();
boolean isEmpty();
// Bulk Operations
void putAll(Map t);
void clear();
// Collection Views
public Set keySet();
public Collection values();
public Set entrySet();
// Interface for entrySet elements
public interface Entry {
Object getKey();
Object getValue();
Object setValue(Object value);
}
}

 values retourne les valeurs sous la forme d’une Collection.

 keySet et entrySet retournent, respectivement, un ensemble (Set) de clés et un
ensemble (set) d'Entry.
Ceci permet donc d'itérer sur les Map comme suit:
si m est un HashMap alors :
// sur les clés
for (Iterator i = m.keySet().iterator();i.hasNext();)
System.out.println(i.next());
// sur les valeurs
for (Iterator i = m.values().iterator();i.hasNext();)
System.out.println(i.next());
// sur la paire clé/valeur
for (Iterator i = m.keySet().iterator();i.hasNext();){
Map.Entry e = (Map.Entry) i.next();
System.out.println(e.getKey() + " ; " + e.getValue());
}
import java.util.*;
public class MapExample {
Map map = new HashMap();
Integer ONE = new Integer(1);
for (int i=0, n=args.length; i<n; i++) {
String key = args[i];
Integer frequency = (Integer)map.get(key);
if (frequency == null) {
frequency = ONE;
} else {
int value = frequency.intValue();
frequency = new Integer(value + 1);
}
map.put(key, frequency);
}
System.out.println(map);
Map sortedMap = new TreeMap(map);
System.out.println(sortedMap);
}
}
3.5. Description des algorithmes

L'ensemble des algorithmes manipulant les collections se trouve dans la classe Collections (à
ne pas confondre avec l'interface Collection). Ces méthodes ont été définies statiques.
Des algorithmes qui ne s'appliquent que sur des listes:
 Trier:
sort(List list) ; trie une liste.
sort(List list,Comparator comp) ; trie une liste en utilisant un comparateur.

 Mélanger:
shuffle(List liste) ; mélange les éléments de manière aléatoire.
 Manipuler:
reverse(List liste) ; inverse les éléments de la liste.
fill (List liste, Object element) ; initialise les éléments de la liste avec element.
copy(List dest, List src) ; copy une liste src dans une liste dest.
 Rechercher:
binarySearch(List list, Object element) ; une recherche binaire d'un élément.
binarySearch(List list, Object element, Comparator comp) ; une recherche binaire d'un
élément en utilisant un comparateur.
Des algorithmes qui s'appliquent sur toutes les collections:
Ces alogorithmes effectuent des recherches extrêmes: min, max etc.
min (Collection) et max (Collection).
Exercice
1. Définir une classe Stagiaire avec les attributs suivants : nom et prénom.
2. Définir un constructeur permettant d’initialiser les attributs d'un objet stagiaire par des
valeurs saisies par l’utilisateur.
3. Définir la méthode toString ( ) permettant d’afficher les informations d'un stagiaire.
4. Écrire un programme testant la classe Stagiaire.
 Déclarer une collection d'objet stagiaire.
 Ajouter des stagiaires dans la collection.
 Afficher la liste des stagiaires.
5. Modifier la classe de teste pour afficher la liste des stagiaires triée dans un ordre
alphabétique des noms, si des stagiaires ont le même nom, ils seront triés en ordre
alphabétique des prénoms.
 Exemple :
o ALAMI Ali
o SAFI Amal
o SAFI Karim
o SAFI Widad
Note: Pour définir un ordre de tri, la classe stagiaire doit implémenter l'interface
Comparable, ensuite redéfinir la méthode compareTo ().
Correction
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
class TestStagiaire {
List<Stagiaire> stagiaires = new ArrayList<Stagiaire>();
stagiaires.add(new Stagiaire("yves", "amine"));
stagiaires.add(new Stagiaire("alaoui", "samir"));
stagiaires.add(new Stagiaire("yves", "zineb"));
stagiaires.add(new Stagiaire("safi", "amal"));

stagiaires.add(new Stagiaire("yves", "amine"));

stagiaires.add(new Stagiaire("cheick", "mohamed"));
System.out.println("Avant le tri : ");

for (Stagiaire s : stagiaires)
System.out.println("\t" + s);
Collections.sort(stagiaires);
System.out.println("Après le tri : ");

for (Stagiaire s : stagiaires)
System.out.println("\t" + s);
}
}
//Tri d'une liste des objets Stagiaire

//La classe stagiaire doit implémenter l'interface
//Comparable, ensuite re-définir la méthode compareTo
public class Stagiaire implements Comparable<Stagiaire> {
private String nom;
private String prenom;
public Stagiaire(String nom, String prenom) {
this.nom = nom;
}
public String toString() {

return this.nom + " " + this.prenom;
}
@Override
public int compareTo(Stagiaire s) {
if (!this.nom.equals(s.nom))
return this.nom.compareTo(s.nom);
else
return this.prenom.compareTo(s.prenom);
}
}

Chapitre 11 : Threads
1. Notion de threads
La machine virtuelle java (JVM) permet d'exécuter plusieurs traitements en parallèle (en
pratique, ils s'exécutent par “tranche” et en alternance sur le processeur). Ces traitements sont
gérés par des threads of control (fil de contrôle), ou plus simplement threads.
Les threads Java sont des processus légers : ils partagent un ensemble de codes, données et
ressources au sein d'un processus lourd qui les héberge (ce processus est la JVM).
Avantages des processus légers par rapport aux processus système :
- rapidité de lancement et d'exécution
- partage desressources système du processus englobant
- simplicité d'utilisation
Intérêts d'une application multi-threads :
 gérer l'exécution de traitements longs sans bloquer les autres
Exemples:
- calculs, affichage et gestion des interactions dans une interface graphique
- lancer des programmes démons qui tournent en tâche de fond
 lancer plusieurs exécutions du même code simultanément sur différentes données
Exemples :
- répondre à plusieurs requêtes en même temps dans un serveur
- traiter deux flux sonores en parallèle
- simuler le parallèlisme nécessaire à certaines classes d'applications
Inconvénients d'une application multi-threads :
- il faut gérer les problèmes de synchonisation entre threads
- une telle application est difficile à écrire et à débogger
2. Thread et interface runnable
En Java, un thread est une instance de la classe Thread qui implémente l'interface Runnable
dont la méthode run() décrit le traitement à lancer.
public interface Runnable{
public void run();
}
Un thread est crée en sous classant la classe Thread et en redéfinissant sa méthode run(), ou
en instanciant le thread avec un objet Runnable.
new Thread(new Runnable(){
public void run(){
});
Un Thread qui n'est plus référencé n'est pas détruit par le garbage collector car il est
enregistré par un contrôleur d'exécution. Le thread principal est celui de la méthode main.
Exemple 1
public class TstThr1
{ Ecrit e1 = new Ecrit ("bonjour ", 10, 5) ;
Ecrit e2 = new Ecrit ("bonsoir ", 12, 10) ;
Ecrit e3 = new Ecrit ("\n", 5, 15) ;
e1.start() ;
e2.start() ;
e3.start() ;
}}
class Ecrit extends Thread

{ public Ecrit (String texte, int nb, long attente)
{ this.texte = texte ; this.nb = nb ;
this.attente = attente ;
}
public void run ()
{ try
{ for (int i=0 ; i<nb ; i++)
{ System.out.print (texte) ;
sleep (attente) ;
}
}
catch (InterruptedException e) {} // impose par sleep
}
private String texte ;
private int nb ;
private long attente ;
}
bonjour bonsoir bonjour
bonsoir bonjour bonjour bonsoir bonjour
bonjour bonsoir bonsoir
bonsoir bonsoir bonsoir bonsoir bonsoir
Exemple 2
public class TstThr3
{ Ecrit e1 = new Ecrit ("bonjour ", 10, 5) ;
Ecrit e2 = new Ecrit ("bonsoir ", 12, 10) ;
Ecrit e3 = new Ecrit ("\n", 5, 15) ;
Thread t1 = new Thread (e1) ; t1.start() ;
}
}
class Ecrit implements Runnable
{ public Ecrit (String texte, int nb, long attente)
{ this.texte = texte ;
this.nb = nb ;
this.attente = attente ;
}
public void run ()
{ try
{ for (int i=0 ; i<nb ; i++)
{ System.out.print (texte) ;
Thread.sleep (attente) ; // attention Thread.sleep
}
}
catch (InterruptedException e) {} // impose par sleep
}
private String texte ;

private int nb ;
private long attente ;
}
bonjour bonsoir
bonjour bonsoir
bonjour bonjour bonsoir bonjour
bonjour bonsoir bonjour bonjour bonsoir
bonjour bonjour bonsoir
bonsoir bonsoir bonsoir bonsoir bonsoir bonsoir
3. Durée de vie d’un thread
destroy, resume, suspend et stop sont des méthodes agissant sur l'état d'un thread, mais qui
peuvent poser des problèmes de blocage ou de mauvaise terminaison et sont donc
désapprouvées.
Activation : la méthode start() appelle la méthode run() (start() n'est pas bloquante dans le
thread appelant).
Destruction : elle intervient quand la méthode run() se termine.
Il est possible d'interrompre le thread en utilisant la méthode interrupt() qui crée une
InterruptedException si le thread est en attente.
public class MonThread extends Thread{
public void run(){
try{
... // traitement, avec des périodes de sommeil et/ou d'attente
}
catch(InterruptedException e){
... // libération propre des ressources
}
// autre traitement
}
}

4. Sommeil d'un thread

 Thread.sleep(long millis) est une méthode de classe qui met le thread courant en
sommeil un certain nombre de millisecondes. Appelée dans la méthode run() du
thread, elle le met en sommeil. L'exécution d'un thread peut également être
suspendue par des processus bloquant (entrée/sortie en particulier)
 getState() renvoie l'état du thread, isAlive() est vrai si le thread est actif ou
endormi.
public class TestSleep extends Thread{
public TestSleep(String name){super(name);}
public void run(){
try{
System.out.println(this.getName()+" a ete lance");
Thread.sleep(100);
System.out.println(this.getName()+" est terminé");
}
catch(InterruptedExceptione){
System.out.println(this.getName()+" a ete interrompu");
}
}
public static void main(String arg[]){

try{
TestSleep mt = new TestSleep("To");
mt.start();
Thread.sleep(100);
mt.interrupt();
}
catch(InterruptedException ie){}
}
}
De temps en temps, To terminera normalement, d'autres fois il sera interrompu.
5. La classe Timer
La classe java.util.Timer permet de lancer un processus une ou plusieurs fois en précisant
des délais. Un Timer gère les exécutions d'une instance de TimerTask, classe qui
implémente Runnable.
public class ExempleTimer extends TimerTask{

public void run(){
try{
System.out.println("je m'execute");
Thread.sleep(500);
}
catch(InterruptedException
e){System.out.println(e.getMessage());}
}
}
Timer t = new Timer();

// la tâche se répètera toutes les 2s et démarre dans1s
t.schedule(new ExempleTimer(),1000,2000);
Date d = new Date(); d.setTime(d.getTime()+10000);
// la tâche démarre dans 10s
t.schedule(new ExempleTimer(),d);

Une valeur de priorité est affectée à chaque thread et détermine sa priorité d'accès au
temps CPU. Mais la JVM n'assure pas le time slicing : le temps CPU n'est pas forcément
partagé équitablement entre threads de même priorité.
La priorité est modifiée par setPriority(int i) et accédée par int getPriority().
La méthode de classe Thread.yield() suspend l'exécution du thread qui est en train de
s'exécuter pour donner la main à un autre. L'appel de cette méthode peut redonner la main
au thread courant!
La méthode setDaemon(boolean on) appelée avant start() permet de faire du thread un
démon, processus de basse priorité qui tourne en tâche de fond.
Exemple : le garbage collector
6. Synchronisation
Les threads s'exécutant en parallèle sur des données qui peuvent être communes, il faut
gérer des conflits d'accès et des problèmes de synchronisation entre threads.
La synchronisation peut consister à entremêler les exécutions des threads de manière à ce
qu'ils n'accèdent à certaines données ou à certains morceaux de code que chacun à leur tour
alternativement.Une méthode plus simple est la synchronisation sur terminaison : on veut
qu'un morceau de code ne s'exécute qu'après qu'un thread donné ait terminé. La méthode
join () permet une telle synchronisation.
Exemple : on veut que jacko attende que jacki ait fini de parler pour prendre la
parole
 La classe Executor
La méthode Executors.newFixedThreadPool(int nbThreads) permet de lancer plusieurs
threads en même temps mais en nombre limité.
 Moniteur
Une ressource critique est une ressource qui ne doit être accédée que par un seul thread à la
fois.
Exemples : variable globale, périphérique de l'ordinateur.
En Java, il n'est pas possible de contrôler directement l'accès simultané à une variable, il faut
l'encapsuler et contrôler l'exécution de l'accesseur correspondant.
Un moniteur est un verrou qui ne laisse qu'un seul thread à la fois accéder à la ressource.
En Java, tout objet peut jouer le rôle de moniteur. On pose un moniteur sur un bloc de code à
l'aide du mot clé synchronized
 Synchronisation sur moniteur
wait() et notify() synchronisent des threads sur un moniteur :
– l'objet o sur lequel les méthodes sont appelées joue le rôle de moniteur
– le thread qui appelle la méthode o.wait() est placé dans le wait-set de o, perd le
moniteur et attend
– il redeviendra actif dans un des cas suivants :
 si la méthode o.notify() est appelée et qu'il est choisi parmi les threads du wait-set
(activation d'un des threads du wait-set, sélection plus ou moins aléatoire)
 Si la méthode o.notifyAll() est appelée (activation de tous les threads du wait-set)
 Si la durée spécifiée pour le wait est écoulée (cas où wait(int timeout) est
utilisée).

Le thread qui appelle wait ou notify doit posséder le moniteur :
synchronized(obj){ synchronized(obj){
try{ try{
... ...
obj.wait(); obj.notify();
... ...
}
} catch(InterruptedException e){}
catch(InterruptedException e){} }
}
• Synchronisation et POO
La synchronisation est indépendante de l'héritage :
- une méthode synchronisée peut être redéfinie dans une sous-classe sans être synchronisée.
- une méthode non synchronisée peut être redéfinie et synchronisée dans une sousclasse.
La synchronisation d'une méthode de classe se fait sur l'instance de Class représentant la
classe.
public class Machin{
public static synchronized m(){
...
}
}

Chapitre 12 : Interfaces graphiques

1. Présentation
Jusqu’ici, nous n’avons réalisé que des programmes à interface console. Ce chapitre aborde
les bases de la programmation graphique avec Swing, API graphique la plus utilisée en Java.
Le nom des composants Swing commence par la lettre J, par exemple JButton, JTextField,
JLabel, etc.
2. Première fenêtre
Comme vous avez pu le constater au fil des précédents chapitres, l’exécution d’un programme
Java entraîne automatiquement la création d’une fenêtre console. Mais rien de comparable
n’est prévu pour une fenêtre graphique destinée à servir de support à la programmation
événementielle. Le programme doit donc la créer explicitement. Nous allons voir ici comment
y parvenir.Par souci de simplicité, nous nous limiterons à la seule création de cette fenêtre.
Par la suite, nous verrons comment en faire le support de l’interface avec l’utilisateur en
introduisant les composants voulus (menus, boutons, boîtes de dialogue..) et en gérant
convenablement les événements correspondants.
2.1. La classe JFrame
Pour créer une fenêtre graphique, on dispose, dans le paquetage nommé javax.swing, d’une
classe standard nommée JFrame, possédant un constructeur sans arguments. Par exemple,
avec :
JFrame fen = new JFrame() ;
On crée un objet de type JFrame et on place sa référence dans fen. Mais si on se limite à cela,
rien n’apparaîtra à l’écran. Il est en effet nécessaire de demander l’affichage de la fenêtre en
appelant la méthode setVisible:
fen.setVisible (true) ; // rend visible la fenêtre de référence fen
Comme par défaut, une telle fenêtre est créée avec une taille nulle, il est nécessaire d’en
définir les dimensions auparavant; par exemple :
fen.setSize (300, 150) ; // donne à la fenêtre une hauteur de 150 pixels et une largeur de
300 pixels
En général, on choisira d’afficher un texte précis dans la barre de titre. Pour ce faire, on
utilisera la méthode setTitle, par exemple:
fen.setTitle ("Ma premiere fenetre") ;
Voici un programme très simple de création d’une fenêtre graphique :
import java.awt.*;
import javax.swing.* ;
public class Premfen
{ JFrame fen = new JFrame() ;
fen.setSize (300, 150) ;
//hauteur 150pixels et largeur 300 pixels
fen.setTitle ("Ma premiere fenetre") ;
//titre de la fenêtre
fen.setVisible (true) ;
//rendre la fenêtre visible
}
}

L’utilisateur peut manipuler cette fenêtre comme n’importe quelle fenêtre graphique, il peut :
 la retailler,
 la déplacer (ici, elle s’est affichée dans le coin haut gauche de l’écran),
 la réduire à une icône.
2.2. Action sur les caractéristiques d’une fenêtre
 void setBounds(int x, int y, int largeur, int hauteur) : Modifier la position et la taille
d'un composant
 void setVisible(boolean b) : Montrer et cacher un composant
 void setEnabled(boolean b) : Activer et désactiver un composant
 boolean isEnabled() : Connaître l’état (activé ou non) d’un composant
 void setBackground(Color c) : Modifier la couleur de fond d'un composant
 void setForeground(Color c) : Modifier la couleur du premier plan d'un composant
 void setSize(int largeur, int hauteur) : Modifier la taille d'un composant
3. Composants atomiques
La classe JComponent est une classe abstraite dérivée de la classe Container qui
encapsule les composants atomiques d'une interface graphique. Les principaux
composants atomiques offerts par Java sont: les boutons, les cases à cocher, les boutons radio,
les étiquettes, les champs de texte, les boîtes de liste, les boîtes de liste combinée.
3.1. Création d’un bouton et ajout dans la fenêtre
Pour créer un objet bouton on utilise le constructeur de la classe JButton :
JButton monBouton = new JButtton ("ESSAI");
Pour introduire ce bouton dans la fenêtre on utilise la méthode getContentPane de la classe
JFrame qui permet de fournir une référence à ce contenu, de type Container :
Container c = getContentPane() ;
On ajoute ce bouton au contenu de référence c par la méthode add de la classe Container :
c.add (monBouton) ;
Exemple :
public class FenBouton
import javax.swing.*; { public static void main (String
import java.awt.Container; args[]){
public class MaFenetre extends JFrame fen = new MaFenetre() ;
JFrame{ fen.setVisible (true) ;
public MaFenetre () // constructeur }
{ setTitle ("Ma premiere fenetre") ; }
setSize (300, 150) ;
JButton monBouton = new JButton
("ESSAI");
c.add(monBouton) ;
}
3.2. Création d’une case à cocher et ajout dans la fenêtre

Pour créer une case à cocher on utilise le constructeur de la classe JCheckBox:
JCheckBox maCase = new JCheckBox ("CASE");
Pour introduire cette case dans la fenêtre on utilise la méthode getContentPane de la classe
JFrame et la méthode add de la classe Container:

getContentPane().add(maCase) ;
La méthode setSelected de la classe AbstractButton permet de modifier l’état d’une case à
cocher.
maCase.setSelected(true) ; //coche la case de référence maCase
3.3. Création de Bouton Radio

Pour créer une case à cocher on utilise le constructeur de la classe JRadioButton:
JRadioButton bRouge = new JRadioButton ( "Rouge");
JRadioButton bVert = new JRadioButton ( "Vert");
Pour obtenir la désactivation automatique d’autres boutons radio d’un même groupe, il faut de
plus :
 créer un objet de type ButtonGroup, par exemple :
ButtonGroup groupe = new ButtonGroup() ;
 associer chacun des boutons voulus à ce groupe à l’aide de la méthode add :
groupe.add(bRouge) ;
groupe.add(bVert) ;
import java.awt.Container; public class TestRadio{
import java.awt.FlowLayout; public static void main (String
import javax.swing.ButtonGroup; args[])
import javax.swing.JFrame; { MaFenetre fen = new MaFenetre() ;
import javax.swing.JRadioButton; fen.setVisible (true) ;
public class MaFenetre extends JFrame { }
private JRadioButton bRouge; }
private JRadioButton bVert;
public MaFenetre () {
super("Une fenêtre ") ;
setBounds(10,40,300,200) ;
bRouge = new JRadioButton("Rouge") ;
bVert = new JRadioButton("Vert") ;
ButtonGroup groupe = new ButtonGroup() ;
groupe.add(bRouge) ;
groupe.add(bVert) ;
c.setLayout(new FlowLayout()) ;
c.add(bRouge) ;
c.add(bVert) ;
} }
Par défaut, un bouton radio est construit dans l’état non sélectionné (false). Pour le
rendre séléctionné, on peut :
 utiliser la méthode setSelected de la classe AbstractButton:
bRouge.setSelected(true) ;
 Ou le 2 constructeur, de la classe JRadioButton :
ème
JRadioButton bRouge = new JRadioButton ("Rouge", true);

3.4. Création des étiquettes

Une étiquette de type JLabel permet d’afficher dans un conteneur un texte (d’une seule
ligne) non modifiable.
public class MaFenetre extends JFrame public class TestEtiquete{

{ public static void main (String
private JLabel monTexte; args[]){
public MaFenetre () { MaFenetre fen = new MaFenetre() ;
super("Une fenêtre ") ; en.setVisible (true) ;
setBounds(10,40,300,200) ; }
JLabel monTexte = new JLabel }
("texte initial") ;
//création d’une étiquette de
//référence MonTexte contenant le
//texte texte initial
getContentPane().add(monTexte) ;
monTexte.setText("nouveau texte") ;
//modification du texte de
//l’étiquette de référence monTexte
}
}
3.5. Création des champs de texte

Un champ de texte (ou boîte de saisie) de type JTextField est une zone rectangulaire dans
laquelle l’utilisateur peut entrer ou modifier un texte (d’une seule ligne).
public class MaFenetre extends public class TesteChampTexte{

JFrame { public static void main (String
private JTextField monChamp1 ; args[]){
private JTextField monChamp2 ; MaFenetre fen = new MaFenetre() ;
public MaFenetre () { fen.setVisible (true) ;
super("Une fenêtre ") ; }
setBounds(10,40,300,200) ; }
monChamp1 = new JTextField(20) ;
monchamp2 = new
JTextField("texte initial", 10) ;
Container c= getContentPane();
c.setLayout(new FlowLayout());
c.add(monChamp1) ;
c.add(monChamp2) ; ²
}
}
3.6. Création des boites de liste

La boîte de liste de type JList permet de choisir une ou plusieurs valeurs dans une liste
prédéfinie. On crée une boîte de liste en fournissant un tableau de chaînes à son constructeur,
par exemple : String[] couleurs = {"rouge", "bleu", "gris", "vert", "jaune", "noir"};
JList maListe = new JList(couleurs) ;
Après incorporation dans un conteneur, on obtient un composant se présentant ainsi :

Initialement, aucune valeur n’est sélectionnée dans la liste. Le cas échéant, on peut forcer la
sélection d’un élément de rang donné par la méthode setSelectedIndex :
maListe.setSelectedIndex(2) ;
Il existe trois sortes de boîtes de liste, caractérisées par un paramètre de type :
Valeur du paramètre de type Type de sélection correspondante

SINGLE_SELECTION Sélection d’une seule valeur
SINGLE_INTERVAL_SELECTION Sélection d’une seule plage de valeurs
(contiguës)
MULTIPLE_INTERVAL_SELECTION Sélection d’un nombre quelconque de plages de
valeurs
Pour modifier le type de boîte de liste, on utilise la méthode setSelectionMode d’en-tête :

maListe.setSelectionMode (SINGLE_SELECTION) ;
Pour récupérer l’élément sélectionné dans une boîte de liste simple on utilise la méthode
getSelectedValue. Son type de retour est Object.
String ch = (String) maListe.getSelectedValue(); //cast obligatoire
Pour les autres types de boîte de liste, on utilise la méthode getSelectedValues qui
fournit un tableau d’objets.
Object[] valeurs = maListe.getSelectedValues();
for (int i=0 ;i<valeurs.length ;i++)
System.out.println((String) valeurs[i]) ; //cast obligatoire
Par défaut une boîte de liste ne possède pas de barre de défilement. On peut lui en
ajouter une en introduisant la liste dans un panneau de défilement de type JScrollPane (classe
dérivée de la classe JComponent) : JScrollPane defil = new JScrollPane (maListe);
En suite, Il faut ajouter (par add) au conteneur concerné le panneau de défilement; par
exemple, pour un conteneur de type JFrame : getContentPane().add(defil) ;
Par défaut, la liste affichera alors huit valeurs (si elle en contient moins, la barre de défilement
n’apparaîtra pas). On peut modifier ce nombre par la méthode setVisibleRowCount :
maListe.setVisibleRowCount(3) ;
import javax.swing.JFrame; public class TestBoiteListe{

import javax.swing.JList; public static void main (String
import javax.swing.JScrollPane; args[]){
public class MaFenetre extends JFrame MaFenetre fen = new MaFenetre() ;
{ fen.setVisible (true) ;
private JList maListe; }
private JScrollPane defil; }
public MaFenetre () {
super("Une fenêtre avec une boite de
liste ") ;
setBounds(10,40,300,200) ;
String[] couleurs = { "rouge",
"rouge", "rouge", "rouge", "bleu",
"gris", "vert", "jaune", "noir"};
JList maListe = new JList(couleurs) ;
JScrollPane defil = new
JScrollPane(maListe) ;
getContentPane().add(defil) ;
}}

3.7. Création des boites de liste combinée

La boîte de liste combinée (boîte combo) de type JComboBox associe un champ de texte
et une boîte de liste à sélection simple. Tant que le composant n'est pas sélectionné, seul le
champ de texte s'affiche:
Lorsque l'utilisateur sélectionne le champ de texte, la boîte de liste s'affiche :
public class MaFenetre extends JFrame public class TestCombox{

{ public static void main (String
private JComboBox maCombo; args[]){
super("Une fenêtre ") ; fen.setVisible (true) ;
setBounds(10,40,300,200) ; }
String[] couleurs = {"rouge", }
"bleu", "gris", "vert", "jaune",
"noir"};
maCombo = new JComboBox(couleurs) ;
maCombo.setSelectedIndex(2) ;
Container c=getContentPane();
c.setLayout(new FlowLayout());
c.add(maCombo);
maCombo.setMaximumRowCount(2);
//sélection préalable de l’élément de
rang 2
} }
Pour modifier le nombre de valeurs visibles on utilise la méthode setMaximumRowCount.

maCombo.setMaximumRowCount(2) ; //au maximum 2 valeurs sont affichées
Pour rendre le champ de texte associé à une boite combo editable on utilise la méthode
setEditable. maCombo.setEditable(true) ;
La méthode getSelectedItem permet de fournir la valeur sélectionnée. Son résultat est de
type Object. String ch = (String) maCombo.getSelectedItem();
Pour ajouter un objet à la fin de la liste combo on utilise la méthode addItem :
maCombo.addItem("orange") ;
Pour ajouter un objet dans une position bien déterminée à la liste combo on utilise la méthode
insertItemAt : maCombo.insertItemAt("orange", 2) ;
Pour supprimer un objet de la liste combo on utilise la méthode removeItem :
maCombo.removeItem ("gris") ;
4. Gestionnaires de mise en forme
Pour chaque conteneur (fenêtre, boîte de dialogue, …), Java permet de choisir un
gestionnaire de mise en forme (en anglais "Layout manager") responsable de la
disposition des composants.

 BorderLayout,
 FlowLayout
 CardLayout
 GridLayout,
 GridBagLayout
 BoxLayout
La méthode setLayout de la classe Container permet d'associer un gestionnaire de mise en
forme à un conteneur.
4.1. BorderLayout
Le gestionnaire de mise en forme BorderLayout permet de placer chaque composant
dans une zone géographique. L'emplacement d'un composant est choisi en fournissant en
argument de la méthode add de la classe Container l'une des constantes entières suivantes
(on peut utiliser indifféremment le nom de la constante ou sa valeur) :
Constante symbolique Valeur

BorderLayout.NORTH "North"
BorderLayout.SOUTH "South"
BorderLayout.EAST "East"
BorderLayout.WEST "West"
BorderLayout.CENTER "Center"
La classe BorderLayout dispose de deux constructeurs :

 public BorderLayout() ;
 public BorderLayout(int hgap, int vgap)
import java.awt.* ; public class TestBorderLayout{

import javax.swing.* ; public static void main (String
public class MaFenetre extends JFrame { args[])
public MaFenetre () { {MaFenetre fen = new MaFenetre();
super("Une fenetre") ; fen.setVisible (true) ;
setSize(300, 200) ; }
Container c = getContentPane() ; }
c.setLayout(new BorderLayout()) ;
c.add(new JButton("UN")) ;
//bouton placé au centre par défaut
c.add(new JButton("DEUX"), "North") ;
c.add(new JButton("TROIS"), "South") ;
c.add(new JButton("QUATRE"), "West") ;
c.add(new JButton("CINQ"), "East") ;
} }
Le gestionnaire de mise en forme BorderLayout ne tient pas compte de la taille

souhaitée des composants, qui peut être imposée par la méthode setPreferredSize de la classe
JComponent.
4.2. FlowLayout
Le gestionnaire de mise en forme FlowLayout permet de disposer les composants les uns
à la suite des autres, de gauche à droite. La classe FlowLayout dispose trois constructeurs :
 public FlowLayout() ;
 public FlowLayout(int align)

- FlowLayout.LEFT
- FlowLayout.CENTER
- FlowLayout.RIGHT
 public FlowLayout(int align, int hgap, int vgap)
Exemple:
import java.awt.* ; public class TestFlowLayout{

import javax.swing.* ; public static void main (String args[])
public class MaFenetre extends {
JFrame { MaFenetre fen = new MaFenetre() ;
super("Une fenetre") ; setSize(300, }
200) ; }
Container c= getContentPane() ;
c.setLayout(new
FlowLayout(FlowLayout.CENTER)) ;
c.add(new JButton("DEUX")) ; } }
Le gestionnaire de mise en forme FlowLayout tient compte, dans la mesure du possible, de

la taille souhaitée des composants, qui peut être imposée par la méthode
setPreferredSize de la classe Jcomponent.
4.3. CardLayout
Le gestionnaire de mise en forme CardLayout permet de disposer les composants suivant une
pile, de telle façon que seul le composant supérieur soit visible à un moment donné.
import java.awt.* ; public class TestCardLayout{

public MaFenetre () { {
super("Une fenetre") ; MaFenetre fen = new MaFenetre() ;
setSize(300, 200) ; fen.setVisible (true) ;
Container c= getContentPane() ; }
CardLayout pile = new CardLayout(30, 20) }
;
//30 pixels de part et d'autre et 20
pixels en haut et en bas
c.setLayout(pile) ;
//changement de gestionnaire de mise en
forme
c.add(new JButton("UN"), "bouton1") ;
//la chaîne "bouton1" permet
d'identifier le composant
au sein du conteneur
c.add(new JButton("DEUX"), "bouton2") ;
c.add(new JButton("TROIS"), "bouton3") ;
} }

Par défaut, le composant visible est le premier ajouté au conteneur

pile.next(c) ; : affiche le composant suivant .
pile.previous(c) ; : affiche le composant précédent
pile.first(c) ; : affiche le premier composant
pile.last(c) ; : affiche le dernier composant
pile.show(c,"bouton3");: affiche le composant identifié par la chaîne "bouton3 "
4.4. GridLayout
Le gestionnaire de mise en forme GridLayout permet de disposer les composants les
uns à la suite des autres sur une grille régulière, chaque composant occupant une
cellule de la grille.
public GridLayout(int rows, int cols) ; : rows et cols définissent respectivement le
nombre de lignes et de colonnes de la grille.
public GridLayout(int rows, int cols, int hgap, int vgap) ; : hgap et vgap définissent les
espaces entre les composants.
import java.awt.* ; public class TestGridLayout{

public class MaFenetre extends args[])
JFrame { { MaFenetre fen = new MaFenetre() ;
super("Une fenetre") ; }
setSize(300, 200) ; }
c.setLayout(new GridLayout(2,
2,10,10)) ;
//changement de gestionnaire de mise
en forme
c.add(new JButton("DEUX")) ;
c.add(new JButton("TROIS")) ;
c.add(new JButton("QUATRE")) ;
} }
4.5. BoxLayout
Le gestionnaire BoxLayout permet de disposer des composants suivant une seule ligne ou une
seule colonne.
Le composant Box est un conteneur:
- dont le gestionnaire est BoxLayout
- qui est enfant de Container, donc n’est pas dans Swing.
On crée un "box horizontal" avec la méthode statique createHorizontalBox :
Box ligne = Box.createHorizontalBox () ; // box horizontal
De la même manière, on crée un "box vertical" avec la méthode statique createVerticalBox :
Box colonne = Box.createVerticalBox () ; // box vertical

4.6. Programme sans gestionnaire de mise en forme

Il est possible de n'associer aucun gestionnaire de mise en forme à un conteneur. Les
composants sont alors ajoutés au conteneur à l'aide de la méthode setBounds de la
classe Component.
import java.awt.* ; public class TestSetBounds{
public class MaFenetre extends JFrame args[])
{ {
super("Une fenetre") ; setSize(300, fen.setVisible (true) ;
200) ; }
Container c = getContentPane() ; }
c.setLayout(null) ;
//changement de gestionnaire de mise
en forme
JButton bouton1 = new JButton("UN") ;
c.add(bouton1) ;
bouton1.setBounds(40, 40, 80, 30) ;
//le coin supérieur gauche du bouton
est placé au pixel de coordonnées 40,
40 par rapport au coin supérieur
gauche de la fenêtre et les
dimensions du bouton sont de 80 * 30
pixels
}}
4.7. Une classe Insets pour gérer les marges

La méthode getInsets de la classe Container permet de définir les quatre marges (haut,
gauche, bas et droite) d'un conteneur. Elle retourne un objet de type Insets défini par
quatre champs publics de type entier initialisés par le constructeur suivant :
public Insets(int top, int left, int bottom, int right)
import java.awt.* ; public class TestInsetGridLayout{
public MaFenetre () { {
super("Une fenetre") ; MaFenetre fen = new MaFenetre() ;
setSize(300, 200) ; fen.setVisible (true) ;
Container contenu = getContentPane() ; }
contenu.setLayout(new BorderLayout(10, }
10)) ;
contenu.add(new JButton("UN")) ;
contenu.add(new JButton("DEUX"), "North")
;
contenu.add(new JButton("TROIS"),

"South") ;
contenu.add(new JButton("QUATRE"),
"West") ;
contenu.add(new JButton("CINQ"),"East") ;
}
//redéfinition de la méthode getInsets
afin de définir de nouvelles marges
pour la fenêtre
public Insets getInsets() {
Insets normal = super.getInsets() ;
//récupération des marges par défaut de
la fenêtre
return new Insets(normal.top+10,
normal.left+10, normal.bottom+10,
normal.right+10) ;
//création d'un nouvel objet de type
Insets pour modifier les marges de la
fenêtre
} }
5. JTextArea
Un text area affiche plusieurs lignes de texte et autorise l'édition de ce texte par l'utilisateur à
l'aide du clavier et de la souris.
Constructeurs
 JTextArea() : Construit une nouvelle instance de JTextArea.
 JTextArea(int l, int c) : Construit une nouvelle instance de JTextArea, avec l lignes
et c colonnes.
 JTextArea(Sting text) : Construit un JTextArea avec un texte initial.
 JTextArea(String text, int l, int c).
 JTextArea(Document doc) : Contruit un JTextArea à partir du Document doc.
Méthodes
 String getText() : Retourne le texte du JTextArea.
 String getText(int d, int l) : Retourne le texte JTextArea, qui a pour longuer l à partir de
d.
 String getSelectedText(Sting text) : Retourne le texte sélectionné.
 void setTextArea(String text) le texte de JTextArea est remplacé par text
 void append(String text) : Ajoute le texte text à la fin de JTextArea.
 void insert(String text, int pos) : Insère le texte text à la position pos, dans le
JTextArea.
 void replaceRange(String text, int d, int f) : Remplace le texte du JTextArea qui va de d
à f par text .
 void replaceSelection(String text) : Remplace le texte selectionné du JTextArea par text
6. JTable
La JTable est un composant affichant/éditant des données sous forme de feuille de calcul. Les
lignes et les colonnes sont identifiées par un nombre entier (en commençant à 0).

6.1. Tables simples

Les tables les plus simples sont construites avec les constructeurs qui prennent en paramètres
2 tableaux d’Object ou 2 Vector (1 pour les noms des colonnes et 1 pour les données).
import javax.swing.*; private String[] entetes = {"Prénom",

import "Nom", "Couleur favorite", "Homme",
javax.swing.table.TableColumnModel; "Sport"};
import javax.swing.table.TableModel;
import java.awt.*; private TableColumnModel nomsColonnes;
class MaFenetre extends JFrame { private TableModel data;
public MaFenetre(){ JTable table = new JTable(data,
setTitle("JTable"); nomsColonnes);
setSize(200,200);} JScrollPane sp = new JScrollPane(table);
private Object[][] donnees = { // Si on veut définir la taille de la
{"Ali", "Hamzaoui", Color.red, true, zone d’affichage :
"TENNIS"},{"Ahmed", "Meknassi" //table.setPreferredScrollableViewportSiz
Color.black, true, "FOOTBALL"}, e(new Dimension(150, 70));
{"Rachid", "Alaoui", Color.cyan, Container c=getContentPane();
true, "RIEN"}, {"Karim", "Bennani", c.setLayout(new FlowLayout());
Color.blue, false,"NATATION"}, c.add(sp);
{"Samir", "Eljabri", Color.magenta, public class TestMafentre{
false, "FOOTBALL"},{"Khalid", public static void main (String args[])
"Akkad", Color.yellow, { MaFenetre fen = new MaFenetre() ;
false,"TENNIS"},{"Jawad", "Sakani", fen.setVisible (true) ;
Color.pink, true, "FOOTBALL"},}; }
}
Constructeurs de JTable
 JTable() : crée une table avec un modèle de données de type et un modèle de colonnes
de type DefaultTableColumnModel.
 JTable(int ligne, int colonne) : des lignes et des colonnes dont les cellules ne
contiennent rien (null).
 JTable(Object[][] données, Object[] descriptionColonnes) : les données sont rangées
dans un tableau
 JTable(Object[][] données, Object[] descriptionColonnes) : les données sont rangées
dans un tableau
 JTable(TableModel modèleDonnées) : crée une table avec un modèle de données
 JTable(TableModel modèleDonnées, TableColumnModel modèleColonnes) : le modèle
pour les colonnes n’est pas nécessairement un DefaultTableColumnModel
 JTable(TableModel modèleDonnées, TableColumnModel modèleColonnes,
ListSelectionModel modèleSélection) : le modèle de sélection n’est pas nécessairement
un DefaultListSelectionModel
6.2. Modèles de table
Les données sont accessibles par un modèle. Ils peuvent être stockés ou calculés, de façon
transparente. La classe AbstractTableModel implémente les méthodes d’un modèle de table,
sauf : public int getRowCount(), public int getColumnCount() et public Object getValueAt(int
ligne, int colonne) qui retournent respectivement, le nombre de lignes, le nombre de colonnes
et l’objet à afficher dans les ligne et colonne indiquées (sa méthode toString est utilisée).

En plus des trois méthodes obligées, la fonction getColumClass a été redéfinie, pour obtenir
le type des valeurs pour une colonne.
import java.awt.Color; import javax.swing.*;

import javax.swing.*; import java.awt.*;
import javax.swing.table.*; public class maFenetre extends
import java.awt.*; JFrame {
public class ModeleStatique extends public maFenetre(){
AbstractTableModel { ModeleStatique md= new
private Object[][] donnees = { ModeleStatique();
{“Ali", "Hamzaoui", Color.red, true, JTable table = new JTable(md);
"TENNIS"}, {"Ahmed", "Meknassi", Color.black, JScrollPane sp = new
true, "FOOTBALL"}, {"Rachid", "Alaoui", JScrollPane(table);
Color.cyan, true, "RIEN"}, {"Karim", table.setPreferredScrollableViewport
"Bennani", Color.blue, false,"NATATION"}, Size(new Dimension(600, 100));
{"Samir", "Eljabri", Color.magenta, false, Container c=getContentPane();
"FOOTBALL"},{"Khalid", "Akkad", Color.yellow, c.setLayout(new FlowLayout());
false,"TENNIS"}, {"Jawad", "Sakani", c.add(sp);
Color.pink, true, "FOOTBALL"}, }; }
private String[] entetes = {"Prénom", "Nom", }
"Couleur favorite", "Homme", "Sport"}; public class TesteMafenetre{
public ModeleStatique() { public static void main (String
super(); } args[])
public int getRowCount() { { MaFenetre fen = new MaFenetre()
return donnees.length; } ;
public int getColumnCount() { fen.setVisible (true) ;
return entetes.length; } }
public String getColumnName(int columnIndex) }
{
return entetes[columnIndex]; }
public Object getValueAt(int rowIndex, int
columnIndex) {
return donnees[rowIndex][columnIndex];
}
}

Java Zriouile

Transféré par

Droits d'auteur :

Formats disponibles

Java Zriouile

Transféré par

Informations du document

Titre original

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

Java Zriouile

Transféré par

Droits d'auteur :

Formats disponibles

2éme année DSI POO-Java-

6.4. Opérateurs relationnels .......................................................................................................... 18

Prof : R.ZRIOUILE Page 2

1.2. Appel des constructeurs ......................................................................................................... 41

Prof : R.ZRIOUILE Page 3

7.1. Création d’un objet de type File ............................................................................................. 70

Prof : R.ZRIOUILE Page 4

Prof : R.ZRIOUILE Page 5

Chapitre 1 : Programmation Orientée Objets

Problèmes de la programmation procédurale :

Prof : R.ZRIOUILE Page 6

Prof : R.ZRIOUILE Page 7

Etudiant Enseignant Telephone Ordinateur

• Quels objets sont nécessaires ?

Objets Actions Données

Objets Actions Données

Prof : R.ZRIOUILE Page 8

Chapitre 2 : Vue d’ensemble de la plate-forme Java

Exemples d’applications : jeux enlignes, images 3D, solutions de banques, etc…

Prof : R.ZRIOUILE Page 9

4. Java : de l’édition à l’exécution

 Code source : fichier texte avec extension .java

Prof : R.ZRIOUILE Page 10

Avantages/inconvénients du code natif

9. Différents modes de compilation

10. Avantages de la JVM pour Internet

Prof : R.ZRIOUILE Page 11

La JVM apporte donc:

public class Principale {

public static void main(String args[]) {

System.out.println("premier programme Java" );

Prof : R.ZRIOUILE Page 12

Prof : R.ZRIOUILE Page 13

Chapitre 3 : Structures de contrôle

Mots réservés du langage Java

1.2. Initialisation des variables

Prof : R.ZRIOUILE Page 14

2. Style de programmation non standard

Prof : R.ZRIOUILE Page 15

Type Taille (octets) Valeur minimale Valeur maximale

Prof : R.ZRIOUILE Page 16

Les deux constantes du type booléen se notent true et false ;

Prof : R.ZRIOUILE Page 17

Symbole Description Exemple

6.2. Opérateurs d’affectation

Symbole Description Exemple

6.3. Opérateurs d’incrémentations et décrémentations

Symbole Description Exemple

6.4. Opérateurs relationnels

Prof : R.ZRIOUILE Page 18

6.5. Opérateurs logiques

6.6. Opérateurs bit à bit

Symbole Description Exemple

Prof : R.ZRIOUILE Page 19

Prof : R.ZRIOUILE Page 20

Chapitre 4 : les Classes et les Objets

class ClasseTest{ /* ClasseTest est le nom de la classe à créer */

Code java de la classe Rectangle

Prof : R.ZRIOUILE Page 21

/corps de la méthode qui peut contenir l’instruction/