Compilation

République Algérienne Démocratique et Populaire
Ministère de l’Enseignement Supérieur et de la Recherche Scientifique

Université Abderahmane Mira de Béjaı̈a
Faculté des Sciences Exactes
Département d’Informatique
Licence 3
Option : Informatique générale
Initiation au langage JAVA

Table des matières
1 Introduction au langage JAVA et notions de bases - Langage JAVA - 2

1.1 Introduction au langage JAVA . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2
1.1.1 Le langage java . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2
1.1.2 Portabilité . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2
1.1.3 JRE ( Java Runtime Environment) . . . . . . . . . . . . . . . . . . . . . . . . . 2
1.1.4 JDK (Java Development Kit) . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
1.1.5 configuration de la variable d’environnement . . . . . . . . . . . . . . . . . . . 3
1.1.6 Premier programme en java . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
1.2 Notions de bases - Langage JAVA - . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
1.2.1 Les identificateurs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
1.2.2 Les mots clés . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
1.2.3 Les commentaires . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
1.2.4 Les types primitifs de Java . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
1.2.5 Les différents types d’entiers . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
1.2.6 Les types flottants . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
1.2.7 Type caractère . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
1.2.8 Le type booléen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
1.2.9 Déclaration de varaibles . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
1.2.10 Les opérateurs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
1.2.11 Lecture des entrées clavier . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
1.2.12 Les instructions de contrôle . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
1.3 Solutions des exercices du cours . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
2 Les tableaux et les chaines de caractère 16

2.1 Les tableaux . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16
2.1.1 Définition . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16
2.1.2 Déclaration d’un tableau . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16
2.1.3 Création et initialisation d’un tableau . . . . . . . . . . . . . . . . . . . . . . . 16
2.1.4 Utilisation d’un tableau . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18
2.1.5 Les tableaux à deux dimensions . . . . . . . . . . . . . . . . . . . . . . . . . . . 19
2.1.6 Les tableaux dynamiques . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19
2.2 Chaı̂nes de caractères . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20
2.2.1 Exemple . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
2.2.2 Concaténation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
2.2.3 Manipulation des chaines . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
2.2.4 Test d’égalité des chaı̂nes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22
2.2.5 Comparaison des chaines . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23
2.2.6 Passage en majuscules ou en minuscules . . . . . . . . . . . . . . . . . . . . . 23
2.3 Exercices . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23
2.3.1 Exercice 1 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23
2.3.2 Exercice 2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23
2.3.3 Exercice 3 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23
2.3.4 Exercice 4 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23
1
2.4 Solutions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23
2.4.1 Exercice 1 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23
2.4.2 Exercice 2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24
2.4.3 Exercice 3 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24
2.4.4 Exercice 4 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24
2.5 Travail à faire . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25
2.5.1 Exercice 1 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25
2.5.2 Exercice 2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25
3 Programmation Orientée Objet 1

3.1 Définitions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1
3.2 Programmation orientée-objet . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1
3.2.1 Classe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1
3.2.2 Objet . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
3.2.3 Utilisation des objets . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4
3.3 L’héritage . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
3.3.1 La mise en oeuvre de l’héritage . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
3.4 Exercices . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
3.4.1 Exercice 1 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
3.4.2 Exercice 2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
4 Les fichiers texte et les exceptions 8

4.1 Les fichiers texte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
4.1.1 Création d’un fichier . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
4.1.2 Lecture d’un fichier texte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
4.1.3 Exercice 1 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
4.2 Les exceptions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
4.2.1 Présentation des exceptions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
4.2.2 Traitement des exceptions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
4.2.3 Quelque exceptions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
4.2.4 Exercice 2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
5 Les interfaces graphiques 13

5.1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
5.2 La classe JFrame . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
5.3 La classe JButton . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14
5.4 La classe JLabel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
5.5 La Classe TextArea . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
5.6 Gestion d’un bouton avec un écouteur . . . . . . . . . . . . . . . . . . . . . . . . . . . 16
5.7 Le Code Source Final . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17
1
Chapitre 1
Introduction au langage JAVA et

notions de bases - Langage JAVA -
1.1 Introduction au langage JAVA

1.1.1 Le langage java
Le langage Java est un langage de programmation orienté objet, La particularité principale de
Java est que les logiciels écrits dans ce langage sont très facilement portables sur plusieurs systèmes
d’exploitation tels que UNIX, Windows, Mac OS ou GNU/Linux. C’est la plate-forme qui garantit la
portabilité des applications développées en Java.
Le langage reprend en grande partie la syntaxe du langage C++. Néanmoins, Java a été épuré des
concepts les plus subtils du C++ et à la fois les plus déroutants, tels que les pointeurs et références, et
l’héritage multiple. Les concepteurs ont privilégié l’approche orientée objet de sorte qu’en Java, tout
est objet à l’exception des types primitifs (nombres entiers, nombres à virgule flottante, etc.)
1.1.2 Portabilité
La portabilité (l’indépendance vis-à-vis de la plate-forme), signifie que les programmes écrits
en Java fonctionnent de manière parfaitement similaire sur différentes architectures matérielles. Ce
résultat est obtenu par les compilateurs Java qui compilent le code source à moitié afin d’obtenir
un bytecode (plus précisément le bytecode Java, un langage de type assembleur, proche de la machine
virtuelle et spécifique à la plate-forme Java). Le code est ensuite interprété sur une machine virtuelle
Java (JVM en anglais), un programme écrit spécifiquement pour la machine cible qui interprète le
bytecode Java et fait exécuter par la machine les instructions traduites en code natif. De plus, des
bibliothèques standard sont fournies pour pouvoir accéder à certains éléments de la machine hôte (le
graphisme, le multithreading, la programmation réseau ...) exactement de la même manière sur toutes
les architectures.
Notons que même s’il y a explicitement une première phase de compilation, le bytecode Java est
soit interprété, soit converti à la volée en code natif par un compilateur à la volée (just in time, JIT).
Il existe également des compilateurs Java qui compilent directement le Java en code objet natif pour
la machine cible, supprimant la phase intermédiaire du bytecode mais le code final produit par ces
compilateurs ne peut alors être exécuté que sur une seule architecture.
1.1.3 JRE ( Java Runtime Environment)

( environnement d’exécution Java ) désigne un ensemble d’outils permettant l’exécution de
programmes Java sur toutes les plates-formes supportées. JRE est constitué d’une JVM (Java Virtual
Machine - Machine Virtuelle Java), le programme qui interprète le code Java compilé (bytecode) et
le convertit en code natif. Mais le JRE est surtout constitué d’une bibliothèque standard à partir de
2
Figure 1.1 – La compilation d’un programme JAVA
laquelle doivent être développés tous les programmes en Java. C’est la garantie de portabilité qui a
fait la réussite de Java dans les architectures client-serveur en facilitant la migration entre serveurs,
très difficile pour les gros systèmes.
1.1.4 JDK (Java Development Kit)

La JDK est l’environnement dans lequel le code Java est compilé pour être transformé en bytecode
afin que la machine virtuelle Java (JVM) puisse l’interpréter. Les composants primaires du JDK sont
une sélection d’outils de programmation, incluant :
– javac : le compilateur, qui convertit le code source en fichier .class (contenant le bytecode Java)
– jar : l’archiveur, qui met sous forme d’un paquetage unique l’ensemble des fichiers class en un
fichier JAR,
– javadoc : le générateur de documentation, qui génère automatiquement de la documentation à
partir des commentaires du code source,
– jdb : le débogueur,
1.1.5 configuration de la variable d’environnement

Une fois que la JDK installée, lancez une fenêtre de commande MS-dos, puis tapez les commande
java, java version, javac. On remarque que la troisième commande n’est pas reconnue par l’invité de
commande vu que la variable d’environnement n’est pas configurée.
Configuration :
– Démarrez/panneau de configuration/système/Onglet ”avancé” :
– Cliquez sur le bouton ”variable d’environnement”. Vous obtenez la fenêtre des variables d’envi-
ronnement, contenant une partir ”utilisateur” et une partie ”système”.
– Dans la partie système cliquez sur Path
– Ajoutez à la fin de la chaine valeur de la variable la chaine ”C :\Program Files\Java\jdk1.7\bin
” puis cliquez sur OK.
1.1.6 Premier programme en java

Pour pourvoir programmer en langage Java vous aurez besoin d’un éditeur de texte comme Crimson
Editor ou Notepad++ (Selon votre choix). Voici un exemple très simple de programme qui se contente
d’afficher le message Hello World ! ! !.
– Recopiez ce code source dans votre éditeur de texte ;
– Enregistrer le fichier sous le nom HelloWorld.java ;
– Ouvrez une fenêtre d’invite de commande ;
– Tapez la commande suivante pour compiler votre fichier : javac HelloWorld.java ;
3
Figure 1.2 – Propriétés du système
Figure 1.3 – Variables d’environnement
– Dans le répertoire où vous avez enregistré votre fichier source vous allez trouver un nouveau
fichier nommé HelloWorld.class qui correspond au bytecode de votre programme ;
– Pour exécuter votre programme tapez la commande suivante : java HalloWorld .
Un programme Java doit au moins contenir une classe comme dans notre exemple la classe Hello-
World. On doit enregistrer notre programme sous le nom de cette classe suivi .java en respectant la
casse (Majuscule et minuscule).
La méthode main est le point de départ de l’exécution de votre programme. Pour l’instant, vous
pouvez vous contentez de mettre votre code à l’intérieur de cette méthode.
4
Figure 1.4 – Le path
Figure 1.5 – Premier programme en JAVA
1.2 Notions de bases - Langage JAVA -

1.2.1 Les identificateurs
Dans un langage de programmation, un identificateur est une suite de caractères servant à désigner
les différentes entités manipulées par un programme : variables, fonctions, classes, objets . . .
Un identificateur en java est formé de lettres ou de chiffres, le premier caractère étant obligatoirement
une lettre. Les lettres comprennent les majuscules et les minuscules, ainsi que le caractère souligné
( ). Voici quelques identificateurs corrects :
ligne n total moyenne_x
Notez bien, qu’on distingue majuscules des minuscules. Ainsi, Ligne et ligne désignent deux identifi-
cateurs différents.
1.2.2 Les mots clés

Certains mots-clés sont réservés par le langage à un usage bien défini et ne peuvent pas être utilisés
comme identificateurs. En voici la liste, par ordre alphabétique :
5
abstract assert boolean break byte
case catch char class const
continue default do double else
extends final finally float for
goto if implements import instanceof
int interface long native new
null package private protected public
return short static super switch
synchronized this throw throws transient
try void volatile while
1.2.3 Les commentaires

Java autorise la présence de commentaires dans les programmes source. Ces textes explicatifs
destinés aux lecteurs du programme n’ont aucune incidence sur sa compilation. Java dispose de deux
formes de commentaires : Les commentaires usuels et les commentaires de fin de ligne.
Les commentaires usuels

Ils sont placés entre les caractères /* et */. Ils peuvent être apparaı̂tre à tout endroit du programme
où un espace est autorisé. En voici quelques exemples :
/* Programme de calcul de racines carrees */
/* Un commentaire
sur plusieurs
lignes
*/
int i; /* Compteur de boucle */
Les commentaires de fin de ligne

Ils sont introduits par le double caractère //. Tout le texte suivant jusqu’à la fin de la ligne est
considéré comme un commentaire.
System.out.println("Bonjour"); // Formule de politesse
1.2.4 Les types primitifs de Java

Les types primitifs de java se répartissent en quatre grandes catégories selon la nature des infor-
mations qu’ils permettent de représenter :
– Nombres entiers ;
– Nombres flottants ;
– Caractères ;
– Booléens.
6
1.2.5 Les différents types d’entiers
Type Taille (octets) Valeur minimale Valeur maximale
byte 1 -128 127
(Byte.MIN VALUE) (Byte.MAX VALUE)
short 2 -23 768 32 767
(Short.MIN VALUE) (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)
1.2.6 Les types flottants

Type Taille (octets) Précision Valeur absolue minimale Valeur absolue maximale
float 4 7 1.40239846E-45 3.40282347E38
(Float.MIN VALUE) (Float.MAX VALUE)
double 8 15 4.9406564584124654E-324 1.797693134862316E308
(Double.MIN VALUE) (Double.MAX VALUE)
1.2.7 Type caractère

Une variable de type caractère se déclare en utilisant le mot clé char comme suit :
char c1, c2; // c1 et c2 sont deux variables de type caractère
1.2.8 Le type booléen

Ce type sert à représenter une valeur logique du type vrai/faux.
boolean trouver;
1.2.9 Déclaration de varaibles

Une déclaration de variable se fait comme suit :
<Type de la variable> <Nom de la variable>;
Exemple de déclaration de variables :
byte temperature;
short vitesseMax;
int i, j;
char c = ’a’;
float pi;
String chaineCaractere = "Bonjour tout le monde";
1.2.10 Les opérateurs

Les opérateurs arithmétiques
– ”+” : permet d’additionner deux variables numériques mais aussi de concaténer des chaines de
caractères ;
– ”-” : permet de soustraire deux variables numériques ;
– ”*” : permet de multiplier deux variables numériques ;
– ”/” : permet de diviser deux variables numériques ;
– ”%” : permet de renvoyer le reste de la division entière entre deux variables de type numérique.
Quelques exemples :
7
int n, m, p;
n = 1 + 3;
m = n * 2;
p = m % n;
p++;
n += 2;
Les opérateurs relationnels

Opérateur Signification
< Inférieur à
<= Inférieur ou égal à
> Supérieur à
>= Supérieur ou égale à
== égal à
!= Différent de
1.2.11 Lecture des entrées clavier

Afin qu’on puisse lire les entrées saisi par l’utilisateur, nous devons instancié un objet de type
Scanner. Voici un exemple qui explique comment vous devez faire :
import java.util.Scanner;
class Exemple1
{
public static void main(String[] args)
{
Scanner sc = new Scanner(System.in);
System.out.print("Introduire votre nom: ");
// Lecture d’une chaine de caractère

String nom = sc.nextLine();
System.out.println("Bonjour " + nom);
// Lecture d’un nombre entier

System.out.print("Introduire votre age: ");
int age = sc.nextInt();
System.out.println("Votre age est: " + age);
// Lecture d’un nombre réel

float moyenne;
System.out.print("Introduire votre moyenne: ");
moyenne = sc.nextFloat();
System.out.println("Votre moyenne est: " + moyenne);
}
}
1.2.12 Les instructions de contrôle

L’instruction if
if(condition)
instruction 1
8
[else
instruction 2]
condition est une expression booléenne quelconque.
int n = 15;
if((n % 2) == 0)
System.out.println(n + " est un nombre pair");
else
System.out.println(n + " est un nombre impair");
Un autre exemple qui vérifie si un nombre est bien dans l’intervalle [0, 20] :
class Exemple2
{
{
System.out.print("Introduire un nombre entier: ");

int n = sc.nextInt();
if((n <= 20) && (n >= 0))

{
System.out.println("Le nombre est bien dans l’intervalle [0, 20]");
}
else
{
System.out.println("Le nombre n’est pas dans l’intervalle [0, 20]");
}
}
}
Exercice
Écrire un programme Java qui permet de lire un nombre entier au clavier et de tester si il est
négatif, positif ou égal à zéro et d’afficher le message adéquat.
L’instruction switch
Considérons l’exemple suivant qui demande à l’utilisateur d’introduire le numéro du jour, et le
programme affiche le nom du jour correspondant à ce numéro :
class Exemple3
{
{
int numero_jour;
System.out.print("Introduire le numéro du jour: ");
9
numero_jour = sc.nextInt();
switch(numero_jour)
{
case 1: System.out.println("On est le \"Dimanche\""); break;
case 2: System.out.println("On est le \"Lundi\""); break;
case 3: System.out.println("On est le \"Mardi\""); break;
case 4: System.out.println("On est le \"Mercredi\""); break;
case 5: System.out.println("On est le \"Jeudi\""); break;
case 6: System.out.println("On est le \"Vendredi\""); break;
case 7: System.out.println("On est le \"Samedi\""); break;
default: System.out.println("Aucun jour correspondant");
}
}
}
Syntaxe de l’instruction switch
switch(expression)
{
case constante_1: [Suite d’instructions 1]
case constante_2: [Suite d’instructions 2]
...
case constante_n: [Suite d’instructions n]
[default: Suite d’instructions]
}
L’instruction do . . .while
class Exemple4
{
{
int n;
do
{
System.out.print("Introduire un nombre positif: ");
n = sc.nextInt();
} while(n < 0);
System.out.println("Vous avez introduit: " + n);

}
}
Syntaxe de l’instruction do . . .while
do
instruction
while(condition);
10
Exercice
Écrire un programme qui calcule les racines carrées de nombres fournis en donnée. Il s’arrêtera
lorsqu’on lui fournira la valeur 0. Il refusera les valeurs négatives. Son exécution se présentera ainsi :
Donnez un nombre positif: 12

La racine carree de 12.0 est: 3.4641016151377544
Donnez un nombre positif: -3
SVP positif
L’instruction while
Cette exemple calcul la somme 1 + 2 + . . . + n telque n est un nombre entier positif. Nous allons
utilisé la boucle while :
class Exemple5
{
{
int n;
do
{
n = sc.nextInt();
} while(n < 0);
int somme = 0, i = 1;
while(i <= n)
{
somme += i; // Cette écriture est équivalente à "somme = somme + i;"
i++; // Est équivalent "i = i + 1;"
}
System.out.println("La somme est égale à: " + somme);

}
}
Syntaxe de l’instruction while
while(condition)
instruction
L’instruction for
Nous allons refaire l’exemple 5 mais en utilisant la boucle for :
11
class Exemple6
{
{
int n;
do
{
n = sc.nextInt();
} while(n < 0);
int somme = 0, i;
for(i = 1; i <= n; i++)

{
somme += i;
}
System.out.println("La somme est égale à: " + somme);

}
}
Syntaxe de l’instruction for
for([initialisation]; [condition]; [incrémentation])

instruction
Exercice
– Écrire un programme qui calcul la valeur de xn , où x est nombre réel et n un entier positif
introduits au clavier en utilisant la boucle while ;
– Écrire un programme qui calcul la valeur de xn , où x est nombre réel et n un entier positif
introduits au clavier en utilisant la boucle f or.
1.3 Solutions des exercices du cours

Exercice 1
class Exo1 {
public static void main(String[] args) {
int n;
System.out.print("Introduire un nombre: ");

n = sc.nextInt();
if(n < 0) {
System.out.println("Le nombre introduit est négatif");
} else {
12
if(n > 0) {
System.out.println("Le nombre introduit est positif");
} else {
System.out.println("Le nombre introduit est égal à zéro");
}
}
}
}
Exercice 2
class Exo2 {
double x;
do {
System.out.print("Donnez un nombre positif: ");
x = sc.nextDouble();
if(x < 0)
System.out.println("SVP positif");
else
System.out.println("La racine carree de " + x + " est: " + Math.sqrt(x));
} while(x != 0);
}
}
Exercice 3
class Exo3 {
float x, puiss;
int n;
System.out.print("Introduire x: ");
x = sc.nextFloat();
System.out.print("Introduire n: ");
n = sc.nextInt();
puiss = 1;
if(n == 0) {
System.out.println(x + " puissance " + n + " = " + puiss);
} else {
int i = 1;
13
if(n > 0) {
while(i <= n) {
puiss *= x;
i++;
}
} else {
int m = Math.abs(n);
while(i <= m) {
puiss *= x;
i++;
}
puiss = 1 / puiss;
}
}

}
}
Exercice 4
class Exo4 {
float x, puiss;
int n;
System.out.print("Introduire x: ");
x = sc.nextFloat();
System.out.print("Introduire n: ");
n = sc.nextInt();
puiss = 1;
if(n == 0) {
} else {
if(n > 0) {
for(int i = 1; i <= n; i++)
puiss *= x;
} else {
int m = Math.abs(n);
for(int i = 1; i <= m; i++)

puiss *= x;
puiss = 1 / puiss;
14
}
}

}
}
15
Chapitre 2
Les tableaux et les chaines de caractère
2.1 Les tableaux

2.1.1 Définition
Un tableau est une structure de données contenant un groupe d’éléments tous du même type. Le
type des éléments peut être un type primitif ou une classe.
Les tableaux permettent de regrouper une suite de variables de même type. Chaque élément du
tableau est une variable que vous pouvez utiliser comme n’importe quelle variable de ce type. Il est
possible de définir des tableaux pour les types primaires ou les classes. Cependant, tous les éléments
doivent être du même type. En Java, les tableaux sont des objets.
2.1.2 Déclaration d’un tableau

Comme un tableau est un objet, la création d’un tableau commence par la mise en place de sa
référence afin de pointer ultérieurement vers l’objet tableau lui-même. Voici comment se déclare une
telle référence t de type tableau d’entiers :
int t[];
Exemples de création de tableau

int t[]; // peut s’écrire int[] t ;
int [] t1, t2; // t1 et t2 sont des références à des tableaux d’entiers ;
int t3[], t4[]; // écritures équivalentes ;
int t5[], n, t6[]; // t5 et t6 sont des tableaux d’entiers, n est entier ;
Point tp[]; // tp est une référence à un tableau d’objets de type Point ;
Point a, tp[]; // a est une référence à un objet de type Point tp est une
référence à un tableau d’objets de type Point;
int tab[5]; // erreur : nous ne pouvons pas indiquer de dimension ici.
2.1.3 Création et initialisation d’un tableau

On peut effectuer la création et l’initialisation d’un tableau de trois façons différentes :
Création par l’opérateur new

Après avoir déclaré la variable tableau, il faut allouer les éléments de ce tableau. On utilise pour
ce faire l’opérateur new. A ce niveau, il est obligatoire de préciser le nombre d’éléments du tableau.
Ces derniers sont initialisés automatiquement en fonction du type de tableau (0 pour les numériques,
’\0’
pour les caractères, false pour les boolean et null pour les éléments de type objet).
16
Exemple
public class Main {

int[] tabEntier = new int[30];
// tableau de 30 entiers de valeur nulle
String[] semaine = new String[7];
/* tableau de 7 références vers des objets
* de type String. Par la suite, il sera nécessaire
* pour chaque élément du tableau de
* créer un objet de type String
*/
}
}
Utilisation d’un initialiseur

Lors de la déclaration d’une référence, il est possible de fournir la valeur à chacune des cases du
tableau. Il suffit de donner la liste entre accolades sans utiliser l’opérateur new. Java se sert du nombre
de valeurs figurant dans l’initialiseur pour en déduire la taille du tableau à créer.
Exemple
int[] t = {1, 3, 5, 7};

/* création d'un tableau de 4 entiers de
* valeurs respectives 1, 3, 5, 7 et place
* la référence dans t. Elle remplace les
* instructions suivantes :
*/
int t[];
t = new int[4];
t[0]=1; t[1]=3; t[2]=5; t[3]=7;
tableau anonyme
A tout moment en utilisant l’opérateur new et une liste entre accolades de valeurs. Cette notation
est très pratique pour passer un tableau en paramètres à une méthode sans qu’il faille créer une
variable locale pour ce tableau. En imaginant la déclaration de la méthode suivante
afficheSemaine(String[] joursSemaine);
Exemple
afficheSemaine(new String[] {"Lundi", "Mardi", "Mercredi", "Jeudi", "Vendredi",

"Samedi", "Dimanche"});
Cette écriture est à la fois un raccourci et évite d’utiliser une variable intermédiaire :
String[] jours = {"Lundi", "Mardi", "Mercredi", "Jeudi", "Vendredi", "Samedi", "Dimanche"} ;

afficheSemaine(jours);
17
2.1.4 Utilisation d’un tableau
Nous pouvons manipuler un élément d’un tableau comme n’importe quelle variable ou n’importe
quel objet de ses éléments. On désigne un élément particulier en plaçant entre crochets, à la suite
du nom du tableau, une expression entière nommée indice indiquant sa position. Le premier élément
correspond à l’indice 0 (et non 1).
\subsection{Exemple}
int t[] = new int[5], a;
t[0] = 15; // place la valeur 15 dans le premier élément du tableau
t[2]++; // incrémente de 1 le troisième élément de t
a = t[4]+23; // utilisation dans un calcul
t[1] = t[0]+5; // initialisation d’un élément à partir d’un autre
t[a-20] = -85; // calcul sur l’indice
Nombre d’éléments d’un tableau

Pour connaı̂tre le nombre d’éléments d’un tableau, vous pouvez utiliser l’attribut public length.
Cet attribut peut être utilisé pour tous les types de tableaux. Considérez le code suivant :
int tab[] = new int [10];

int taille = tab.length; // taille est égal à 10
Afficher un tableau dans la sortie standard

Il existe une méthode très simple pour afficher toutes les valeurs d’un tableau dans la sortie stan-
dard, et ce grâce à la méthode toString() de la classe Arrays. L’appel Arrays.toString(tableau)
renvoie une chaı̂ne de caractères contenant les éléments du tableau, insérés entre crochets et séparés
par des virgules :
System.out.println(Arrays.toString(tableau));
// affichepar exemple à l’écran "[2, 3, 5, 7, 11, 13]"
Copie des tableaux

Il est possible de copier une variable tableau dans une autre, mais attention, comme nous l’avons
vu plus haut, les deux variables feront alors référence au même tableau :
int[ ] suite = {17, 19, 23, 29, 31, 37};

int[ ] entier = suite;
entier[3] = 12; // suite[3] vaut maintenant 12
Si vous voulez effectivement copier toutes les valeurs d’un tableau dans un autre, il faut employer
la méthode copyTo() de la classe Arrays :
int[ ] suite = {17, 19, 23, 29, 31, 37};

int[ ] entier = Arrays.copyOf(suite, suite.length);
Le second paramètre correspond à la longueur du nouveau tableau. Cette méthode est souvent
employée pour augmenter la taille d’un tableau :
int[ ] suite = {17, 19, 23, 29, 31, 37};

suite = Arrays.copyOf(suite, 2 * suite.length);
Les autres éléments sont remplis de 0 si le tableau contient des nombres, false si le tableau contient
des valeurs booléennes. A l’inverse, si la longueur est inférieure à celle du tableau initial, seules les
valeurs initiales sont copiées.
18
2.1.5 Les tableaux à deux dimensions
De nombreux langages disposent de la notion de tableau à plusieurs indices. Par exemple, un
tableau à deux indices permet de représenter une matrice mathématique.
Java ne dispose pas d’une telle notion. Néanmoins, il permet de la ”simuler” en créant des tableaux de
tableaux, c’est-à-dire des tableaux dont les éléments sont eux-mêmes des tableaux. Cette possibilité
s’avère en fait plus riche que celle de tableaux à plusieurs indices offerte par les autres langages. Elle
permet notamment de disposer de tableaux irréguliers, c’est-à-dire dans lesquels les différentes lignes
pourront être de taille différente.
Ces trois déclarations sont équivalentes :
int t [] [] ;
int [] t [] ;
int [] [] t ;
Elles déclarent que t est une référence à un tableau, dans lequel chaque élément est lui-même une
référence à un tableau d’entiers. Pour l’instant, aucun tableau de cette sorte n’existe encore.
Exemple
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){
accès à t22[i][j]
}
}
Un tableau à plusieurs dimensions peut être initialisé :
int t21[][] = {{1, 2, 3}, {4, 5, 6}};
2.1.6 Les tableaux dynamiques

Les tableaux dynamiques sont implémentés par la classe Vector faisant partie du package java.util.
Les tableaux dynamiques ont une taille qui peut s’accroı̂tre (ou diminuer) en fonction des besoins,
contrairement à celle des tableaux standard dont la taille est définie statiquement lors de l’instancia-
tion.
Quelques méthodes de la classe Vector

– boolean add (Object o) ou void add(int index, Oject o) permet d’ajouter un objet dans
le vecteur soit à la fin, soit à une position donnée (le début correspond à 0) ;
– int size( ) renvoie la taille du vecteur, c’est-à-dire le nombre d’objets qui y ont été insérés ;
– int capacity( ) renvoie la capacité du vecteur, qui peut être différente de sa taille ;
– boolean contains(Objetc o) renvoie true si l’objet appartient au vecteur ;
– Object get(int index) renvoie sur l’objet en position spécifiée ;
– int indexOf (Object o) renvoie l’index de l’objet dans le vecteur (-1 si inexistant) ;
– boolean isEmpty() renvoie true si le vecteur est vide ;
19
– boolean remove(int index) supprime l’élément en potion spécifiée par l’élément donné ;
– Object set (int index, Object element) remplace l’élément en potion spécifiée par l’élément
donné.
Exemple pratique
import java.util.*;
public class UseVector1{
public static void main(String args[]){
Vector vect = new Vector(5);

vect.addElement(new Integer(3));
vect.addElement(new String("Bonjour"));
vect.addElement(new Float(3.14));
System.out.println("taille du vecteur : " + vect.size());

System.out.println("capacité du vecteur : " + vect.capacity());
System.out.println(vect);
for(int i=0; i < vect.size(); i++)

if(vect.elementAt(i) != null)
System.out.println("vect[" + i + "] : " + vect.elementAt(i).getClass().getName()
+ " --> " + vect.elementAt(i));
else
System.out.println("vect[" + i + "] est null");
if(vect.elementAt(1) != null){
vect.set(1, new Integer(1000));
}
System.out.println("après : " + vect);
vect.remove(0);
System.out.println("après remove : " + vect + " et taille = "
+ vect.size());
}}
Résultat :--> java UseVector1

taille du vecteur : 3
capacité du vecteur : 5
[3, Bonjour, 3.14]
vect[0] : java.lang.Integer --> 3
vect[1] : java.lang.String --> Bonjour
vect[2] : java.lang.Float --> 3.14
après : [3, 1000, 3.14]
après remove : [1000, 3.14] et taille = 2
2.2 Chaı̂nes de caractères

Les chaı̂nes sont des suites de caractères (par exemple : ”hello”). Java ne contient pas de type
chaı̂ne prédéfini. En revanche, la bibliothèque Java standard contient une classe prédéfinie appelée
String. Chaque chaı̂ne est un objet (une référence) de la classe String. Comme toute déclaration d’une
variable objet, l’instruction :
String ch;
déclare que ch est destinée à contenir une référence à un objet de type String. Par ailleur, la nota-
tion ”bonjour” désigne en fait un objet de type String (ou, pour être plus précis, sa référence), créé
20
automatiquement par le compilateur. Ainsi, avec :
ch = "bonjour";
on abouti à une situation qu’on peut schématiser ainsi :
2.2.1 Exemple
String ch1 = new String(); //ch1 contient la référence à une chaine vide
String ch2 = new String("Bonjour"); //ch1 contient la référence à une chaine
//contenant la suite "Bonjour"
String ch3 = ch2 //ch3 contient la référence à une chaine copie de ch2,
//contenant "Bonjour"
String ch4 = "Bonjour" // Cette écriture est équivalente à celle de ch2
// mais elle est beaucoup plus concise
2.2.2 Concaténation
Java autorise l’emploi du signe + et += pour joindre (concaténer) deux chaı̂nes.
Exemple
String ch1 = "Java";
String ch2 = "Programme";
String ch3 = ch1+ch2;
//ch3 -> JavaProgramme
ch3 += "Compilation"; // cette notation est équivalente à ch3 = ch3 + "Compilation"
//ch3 -> JavaProgrammeCompilation
Lorsque vous concaténez une chaı̂ne et une valeur qui n’est pas une chaı̂ne, cette valeur est convertie
en chaı̂ne.
Exemple
String ch = "Compilation" + 2013;
//donne à la chaine ch la valeur "Compilation2013"
//Cette caractéristique est couramment utilisée pour l’affichage
System.out.println("La réponse est : " + reponse);
2.2.3 Manipulation des chaines

Il existe un certain nombre de méthodes intégrées à la classe String pour permettre différentes
manipulations sur les chaı̂nes :
1. length : permet de connaı̂tre la longueur d’une chaı̂ne ;
2. charAt : renvoie le caractère (Unicode) situé à la position désirée (Attention, la première position
est 0).
3. indexOf : renvoie la position à partir du début de la chaı̂ne la première occurrence d’un caractère
donné. (Attention, là aussi la première position est 0. Si le caractère n’existe pas dans la chaı̂ne,
la valeur retournée est -1).
21
4. substring : permet de créer une nouvelle chaı̂ne un extrayant de la chaı̂ne courante tous les
caractères compris entre deux positions données (la première incluse, la second exclue).
Exemple
String mot = "hello";// Initialisation de la chaine mot
int n = mot.length(); // Renvoi la longueur de la chaine (n=5)
char c = mot.charAt(1);// Renvoi le caractère à la position indiquée (c = ’e’)
int p = mot.indexOf(’o’); // Renvoi la position du caractère ’o’ (p = 4)
String mot = mot.substring(0 , 3) + "p"; // mot = "help!"
Le fait que le compilateur construise un objet de type String lorsqu’il rencontre une constante chaı̂ne
(entre guillemets) signifie que vous pouvez parfaitement utiliser les méthodes de String avec cette
chaı̂ne. Vous pouvez écrire :
int n = "Monsieur".length(); // n est initialisé avec la taille de la cha^
ıne (ici 8)
On peut aussi utiliser la méthode concat pour concaténer deux chaı̂nes :
String ch3 = ch1.concat(ch2);
2.2.4 Test d’égalité des chaı̂nes

La méthode equals
La classe String dispose d’une méthode equals qui compare le contenu de deux chaı̂nes et renvoie
true si elles sont égales, et false dans le cas contraire.
Exemple
String ch1 = "hello";
String ch2 = "Bonjour";
boolean test ;
....
test = ch1.equals(ch2); // test = false
test = ch1.equals("hello"); // test = true
test = "bonjour".equals(ch2); // test = false
test = "Bonjour".equals(ch2); // test = true
La méthode equalsIgnoreCase
La méthode equalsIgnoreCase effectue la même comparaison, mais sans distinguer les majuscules
et les minuscules.
Exemple
String ch1 = "hello";
String ch2 = "Hello";
boolean test ;
....
test = ch1.equalsIgnoreCase(ch2); // test = true
test = ch1.equalsIgnoreCase("hello"); // test = true
test = "hello".equalsIgnoreCase(ch2); // test = true
Attention : n’employez pas l’opérateur == pour tester l’égalité de deux chaı̂nes ! Cet opérateur
détermine seulement si les chaı̂nes sont stockées au même emplacement (même référence - adresse de
la variable). Il est évident que si deux chaı̂nes se trouvent à la même adresse, elles doivent être égales.
Mais des copies de chaı̂nes identiques peuvent être stockées à des emplacements différents dans la
mémoire.
22
2.2.5 Comparaison des chaines
La syntaxe de méthode compareTo est comme suit :
ch1.compareTo(ch2);
retourne 0 si les deux chaı̂nes sont égales, une valeur négative si ch1 est plus petit que ch2, ou une
valeur positive si ch2 est plus petit que ch1.
Il ne faut donc pas utiliser les opérateurs ¿, ¿=, ¡, ¡=
2.2.6 Passage en majuscules ou en minuscules

La méthode toLowerCase crée une nouvelle chaı̂ne en remplaçant toutes les majuscules par leur
équivalent en minuscules (lorsque celui-ci existe). La méthode toUpperCase crée une nouvelle chaı̂ne
en remplaçant toutes les minuscules par leur équivalent en majuscules.
Exemple
String ch = "LanGage_3";
......
String ch1 = ch.toLowerCase()//ch1 = "langage_3"
String ch1 = ch.toUpperCase()//ch1 = "LANGAGE_3"
boolean test ;
2.3 Exercices
2.3.1 Exercice 1
Écrire un programme qui réalise le tri d’un tableau d’entier. La méthode de tri utilisée est basée
sur la sélection du minimum. Pour chaque indice i du tableau, on recherche à partir de cet indice le
plus petit élément du tableau et on permute cet élément avec celui que se trouve à l’indice i.
2.3.2 Exercice 2
Écrire un programme qui réalise le tri d’un tableau de chaines de caractère. La méthode de tri
utilisée est basée sur la sélection du minimum.
2.3.3 Exercice 3
Écrire un programme qui remplace dans un tableau les mots de langueur inférieur à 3 ou qui se
terminent par ”al” par la chaine ”erreur” , et afficher le tableau.
2.3.4 Exercice 4
Écrire un programme qui demande à l’utilisateur de saisir une chaine de caractère, enregistre dans
un tableau les sous-chaines séparées par un blanc et enfin afficher le tableau.
2.4 Solutions
2.4.1 Exercice 1
class tri1{
public static void main(String []args)
{
int[] tab = {2,58,21,4,21,63,45,55,6,2,14,32,56,32};
int swap;
23
for(int i = 0; i < tab.length - 1 ; i++)
for (int j = i+1; j < tab.length; j++)
if (tab[j] < tab[i]){
swap = tab[i];
tab[i] = tab[j];
tab[j] = swap;
}
for (int i = 0; i < tab.length ; i++)
System.out.print(tab[i] + " ");
}
}
2.4.2 Exercice 2
class tri2{
{
String[] tab = {"java","c++","html","php","perl","css" };
String swap;
for(int i = 0; i < tab.length - 1 ; i++)

for (int j = i+1; j < tab.length; j++)
if (tab[i].compareTo(tab[j]) > 0){
swap = tab[i];
tab[i] = tab[j];
tab[j] = swap;
}
}
}
2.4.3 Exercice 3
class exercice3{
{
String[] tab = {"java","c++","html","php","pascal","perl","css", "c" };
String swap;
for(int i = 0; i < tab.length ; i++)

if ((tab[i].length() <= 2) || ("al".equals( ""+tab[i].charAt(tab[i].length()-2)
+ tab[i].charAt(tab[i].length()-1))))
tab[i] = "erreur";
}
}
2.4.4 Exercice 4
import java.util.Vector;
24
class exercice4{
public static void main(String []args){
String swap = "";
String mot = sc.nextLine();
Vector vect = new Vector();
for(int i = 0 ; i < mot.length(); i++)
{
while(i < mot.length() && mot.charAt(i) != ’ ’)
{
swap += mot.charAt(i);
i++;
}
vect.addElement(new String(swap));
swap = "";
}
for(int i=0; i < vect.size(); i++)
System.out.println(vect.elementAt(i));
}
}
2.5 Travail à faire

2.5.1 Exercice 1
Faire un programme convivial (à l’aide d’un menu sommaire) qui permet de compléter un tableau
de chaines de caractère de 10 cases, d’afficher son contenu, d’enlever des valeurs. Le menu comporte
5 options :
1. Ajouter une valeur,
2. Enlever la dernière valeur,
3. Afficher le contenu du tableau en majuscule,
4. Afficher le contenu du tableau en minuscule,
5. Quitter le programme.
Au départ le tableau doit être vide. L’affichage lorsqu’il est demandé doit être sous la forme de, par
exemple :”La valeur de la case 5 est : java”. Il faut protéger votre programme par les malversation
de l’utilisateur, en effet il ne doit pas y avoir plus de dix valeurs dans le tableau même si l’opérateur,
sans le faire exprès, veut en rajouter d’autre.
2.5.2 Exercice 2
Écrire un analyseur lexical en utilisant la méthode du cours (table de transition, l’algorithme de
parcour de la table) pour le langage décrit par l’automate suivant : L’exécution du programme peut
ressembler à ceci :
Chaine d’entrée : a0a 1 3 ab a

Résultat :
a0a : identificateur
1 : nombre
3 : erreur, mot non reconnu
ab : identificateur
a :identificateur
25
26
Chapitre 3
Programmation Orientée Objet
Que l’on soit débutant ou programmeur chevronné, la maı̂trise d’un nouveau langage de program-
mation passe obligatoirement par la pratique.
3.1 Définitions
Un programme classique : Ensemble de structures de données, de fonctions et procédures.
La programmation orientée objet : Ensemble d’objets ; Chaque objet est la concrétisation d’une
structure abstraite appelée Classe, contenant des données et des méthodes.
3.2 Programmation orientée-objet

La programmation orientée-objet propose une méthodologie centrée sur les données. Le program-
meur doit identifier un ensemble d’objets, tel que chaque objet représente un élément qui doit être
utilisé ou manipulé par le programme, sous la forme d’ensembles de données.
3.2.1 Classe
Une classe regroupe un ensemble de données (qui peuvent être des variables primitives ou des
objets) et un ensemble de méthodes de traitement de ces données et/ou de données extérieures à la
classe. Une classe est un modèle abstrait d’objet.
Exemple Classe personne :

– Attributs : nom, prenom, age ;
– Méthodes : getNom(), setNom(), afficher().
Déclaration d’une classe

Pour déclarer une classe on utilise la syntaxe suivante :
[modificateur] class nomClass [extends nomSuperClass][implements interface] {

[déclarations des attributs]
[déclarations des méthodes]
}
Les clauses entre [ ] sont optionnelles. La plus petite déclaration correcte est :
class nomClass {
[déclarations des attributs]
[déclarations des méthodes]
1
}
– Le mot clé extends précise la classe dont hérite une autre classe ;
– Un modificateur intervient sur le champ d’application ou la visibilité de la classe.
Modificateur Rôle
private La classe n’est accessible qu’à partir du fichier où elle est définie
public La classe est accessible de partout
abstract La classe contient une ou plusieurs méthodes abstraites.
Une classe déclarée abstract ne peut pas être instanciée : il faut définir une classe qui
hérite de cette classe et qui implémente les méthodes nécessaires pour ne plus être
abstraite
final La classe ne peut être modifiée, sa redéfinition grâce à l’héritage est interdite.
Les classes déclarées final ne peuvent donc pas avoir de sous-classes.
Une fois la classe déclarée, on peut créer autant d’instances que l’on veut. Tous ses objets auront
les mêmes attributs et méthodes.
Encapsulation des données

Lors de la conception d’un programme orienté-objet, on doit identifier les objets et les données
appartenant à chaque objet. Et aussi les droits d’accès qu’ont les autres objets sur ces données.
L’encapsulation de données dans un objet permet de cacher ou non leur existence aux autres objets
du programme. Une donnée peut être déclarée en accès :
– public : les autres objets peuvent accéder à la valeur de cette donnée ainsi que la modifier ;
– privé : les autres objets n’ont pas le droit d’accéder directement à la valeur de cette donnée
(ni de la modifier). En revanche, ils peuvent le faire indirectement par des méthodes de l’objet
concerné (si celles-ci existent en accès public).
Exemple
class Personne {
private String nom, prenom, adresse;
private int age;
// Méthodes d’accés aux données privées (les getters)

public String getNom() {
return nom;
}
public String getPrenom() {

return prenom;
}
// Méthodes d’éffectation aux données privées (les setters)

public void setNom(String nouveauNom) {
nom = nouveauNom;
}
public void setPrenom(String nouveauPrenom) {

nom = nouveauPrenom;
}
}
2
3.2.2 Objet
Un objet est une instance d’une classe et est référencé par une variable ayant un état (ou valeur).
Pour créer un objet, il est nécessaire de déclarer une variable dont le type est la classe à instancier,
puis de faire appel à un constructeur de cette classe.
Construction d’un objet

Pour la construction d’un objet on utilise la syntaxe suivante :
Syntaxe
– Déclarer le nom d’un objet de la classe
nomClass nomObjet
– Construire l’objet
nomObjet = new constructeurClass([liste des paramètres])
Exemple L’instanciation d’un objet de la classe Personne faisant appel au constructeur, pourra
s’écrire :
Personne pers = new Personne();
L’usage de parenthèses à l’initialisation de pers, montre qu’une méthode est appelée pour l’instan-
ciation. Cette méthode est un constructeur de la classe Personne. Si le constructeur appelé nécessite
des paramètres d’entrée, ceux-ci doivent être précisés entre ces parenthèses (comme lors d’un appel
classique de méthode). Le constructeur doit porter le même nom que la classe et ne retourne aucun
type, pas même void, car l’objet retourné est toujours implicitement une instance de la classe. Plusieurs
constructeurs peuvent être définis s’ils acceptent des paramètres d’entrée différents.
Exemple de constructeur pour la classe Personne

class Personne {
public Personne(String leNom, String lePrenom) {
nom = leNom;
prenom = lePrenom;
}
}
Surcharge : La surcharge appliquée à un constructeur ou à une méthode est le processus permettant

dans une même classe de donner le même nom à un autre constructeur ou une autre méthode. Le
compilateur saura identifier exactement la variante appelée, en fonction de sa signature.
En effet, les méthodes surchargées doivent se distinguer par des signatures clairement différentes :
– Des nombres d’arguments différents ;
– Et/ou des classes ou types d’arguments différents.
Exemple Ces deux constructeurs de la classe Personne ne sont pas identiques.

public Personne(String leNom, String lePrenom, int lAge) {
...
}
public Personne(String leNom, String lePrenom) {

...
}
3
3.2.3 Utilisation des objets
Accès aux variables et aux méthodes
Pour accéder à une variable associée à un objet, il faut préciser l’objet qui la contient. On utilise
la syntaxe suivante :
nomObjet.nomAttribut;
La même syntaxe est utilisée pour appeler une méthode d’un objet. Par exemple :
nomObjet.nomMethode();
Exemple
Personne p = new Personne();

p.getNom();
Pour qu’un tel appel soit possible, il faut que trois conditions soient remplies :
1. La variable ou la méthode appelée existe !
2. Une variable désignant l’objet visé existe et soit instanciée.
3. L’objet, au sein duquel est fait cet appel, ait le droit d’accéder à la méthode ou à la variable.
Pour référencer l’objet ”courant” (celui dans lequel se situe la ligne de code), le langage Java fournit
le mot-clé this. Celui-ci n’a pas besoin d’être instancié et s’utilise comme une variable désignant l’objet
courant. Le mot-clé this est également utilisé pour faire appel à un constructeur de l’objet courant.
Ces deux utilisations possibles de this sont illustrées dans l’exemple suivant :
Exemple
public class Personne {

String nom;
String prenom;
public void setNom(String P_Nom) {

this.nom = P_Nom;
}
public void setPrenom(String P_Prenom) {

this.prenom = P_Prenom;
}
public String getNom() {

return this.nom;
}
public String getPrenom() {

return this.prenom;
}
public Personne(String P_Nom, String P_Prenom){

this.setNom(P_Nom);
this.setPrenom(P_Prenom);
}
4
public Personne(String P_Nom){
this.setNom(P_Nom);
this.setPrenom("Pas de Prenom");
}
public String getPersonne() {

return (" Mr. "+this.nom +" "+ this.prenom);
}
Attributs statiques (variables de classe)

Un attribut statique est un attribut qui est commun à tous les objets qu’on peut créer. On peut
par exemple citer un compteur de nombre d’instances d’une classe. Pour compter le nombre de fois
où une classe ”Test” est lancée, on écrit ceci :
public class Test

{
public static int nombre;
public static final int nb = 5;
public Test()
{
nombre++;
System.out.println("Nombre d’instances crées : " + nombre);
}
}
L’avantage des attributs statiques est que nous pouvons y accéder même sans la création d’instance
de la classe. Ainsi, on peut écrire n’importe où dans une méthode :
System.out.println("Nombre d’instances crées : " + Test.nb);
Ce code affichera 5.
Constantes de classe
Ce sont des cas particuliers de variables de classe, dont les valeurs ne doivent pas être changées.
On les déclare en combinant les modificateurs final avec static. Par exemple, dans la classe Math,
PI est une constante définie par :
public static final double PI
Méthodes de classe (ou méthodes statiques)

Supposons que nous voulons écrire une méthode int abs(int x) dans une classe Math qui calcule
la valeur absolue d’un nombre x . Le comportement de cette méthode ne dépend pas de la valeur des
variables d’instance de la class Math. Pourquoi devrait-on créer un objet de la classe Math pour
utiliser cette méthode ? Ce serait perdre de la place. La classe Math existe en Java, ainsi que la
méthode abs(). Et effectivement il n’est pas possible d’instancier cette classe.
Bien que Java soit un langage objet, il existe des cas où une instance de classe est inutile. Le mot
clé static permet alors à une méthode de s’exécuter sans avoir à instancier la classe qui la contient.
L’appel à une méthode statique se fait alors en utilisant le nom de la classe, plutôt que le nom de
l’objet.
5
Exemple
public class MaClassMath {

...
public static int min( int a, int b) {
// retourne la plus petite valeur
}
}
public TestMaClassMath {
public static void main ( String [] args ){
int x = MaClassMath .min (21 ,4);
}
}
3.3 L’héritage
L’idée principale de l’héritage est d’organiser les classes de manière hiérarchique. La relation
d’héritage est unidirectionnelle et, si une classe B hérite d’une classe A, on dira que B est une sous-
classe de A. Cette notion de sous-classe signifie que la classe B est un cas particulier de la classe A et
donc que les objets instanciant la classe B instancient également la classe A.
Grâce à l’héritage, les objets d’une sous classe ont accès aux données et aux méthodes de la classe
parent et peuvent les étendre. Les sous classes peuvent redéfinir les variables et les méthodes héritées.
Pour les variables, il suffit de les redéclarer sous le même nom avec un type différent. Les méthodes
sont redéfinies avec le même nom, les mêmes types et le même nombre d’arguments, sinon il s’agit
d’une surcharge.
3.3.1 La mise en oeuvre de l’héritage

Une relation d’héritage se définit en Java par le mot-clé extends utilisé comme dans l’exemple
suivant :
Exemple
class Etudiant extends Personne { ... }
En l’absence du mot réservé extends associé à une classe, le compilateur considère la classe Object
comme classe parent. Pour invoquer une méthode d’une classe parent, il suffit d’indiquer la méthode
préfixée par super.
3.4 Exercices
3.4.1 Exercice 1
Définir une classe Employe avec les champs suivants :
Attributs
– nom, prenom, adresse, sexe de type String ;
– age de type int ;
– salaire de type double ;
– numero de type int pour attribuer un identifiant employé(e).
6
Méthodes
– presenteToi() qui affiche tous les attributs de l’employé.
Constructeur La classe va contenir trois constructeurs :

– Constructeur 1 : il a un argument : nom ;
– Constructeur 2 : il a les arguments : nom et age ;
– Constructeur 3 : il a les arguments : nom et salaire.
Attribut statique
– nombre pour noter le nombre total d’employés.
3.4.2 Exercice 2
Redéfinir la classe employé en tant que classe qui hérite de la classe Personne.
7
Chapitre 4
Les fichiers texte et les exceptions
4.1 Les fichiers texte

4.1.1 Création d’un fichier
Classe FileWriter
La classe abstraite Writer sert de base à toutes les classes relatives à un flux texte de sortie. La
classe FileWriter, dérivée de Writer, permet de manipuler un flux texte associé à un fichier1. L’un
de ses constructeurs s’utilise ainsi :
FileWriter f = new FileWriter ("prog.txt") ;
Cette opération associe l’objet f à un fichier de nom prog.txt. S’il n’existe pas, il est créé (vide). S’il
existe, son ancien contenu est détruit. On a donc affaire à une classique ouverture en écriture.
Remarque Si le fichier ne se trouve pas dans le même répertoire, il faut spécifier le chemin de ce
dernier. Par exemple :
FileWriter f = new FileWriter ("/tmp/prog.txt");
Classe PrintWriter
Les méthodes de la classe FileWriter permettent d’écrire des caractères, des tableaux de caractères
ou des chaı̂nes. Dans certains cas, elles sont suffisantes. Mais, si l’on souhaite disposer de possibilités
de formatage, on peut recourir à la classe PrintWriter qui dispose d’un constructeur recevant en
argument un objet de type FileWriter. Ainsi, avec :
PrintWriter sortie = new PrintWriter (f) ;
Exemple
import java.io.*;
class ExempleEcriture {
public static void main(String[] args) throws IOException {
PrintWriter f = new PrintWriter(new FileWriter("exemple.txt"));
f.write("Hello World !!!");
f.close();
}
}
8
4.1.2 Lecture d’un fichier texte
La classe Scanner est une classe très polyvalente. Sa spécialité, c’est la décomposition de texte.
Certes, cette classe Scanner peut prendre en entrée des textes venant d’un fichier ou d’un flux
quelconque, mais également et tout simplement des chaı̂nes de caractères.
Scanner(File fichier)
Scanner(InputStream flux)
La méthode hasNext() de type boolean, retourne true si un mot est présent dans la ligne courante,
false dans la cas contraire.
Les méthodes de vérification

Les méthodes suivantes Contrôlent si la prochaine valeur en entrée (suite de caractères) peut se
transformer dans la valeur correspondant au type spécifié dans le nom de la méthode. Pour les types
entiers, ces méthodes sont mêmes capables de déterminer si la suite de caractères proposée respecte
la base spécifiée en argument..
boolean hasNextBoolean()
boolean hasNextByte()
boolean hasNextByte(int base)
boolean hasNextDouble()
boolean hasNextFloat()
boolean hasNextInt()
boolean hasNextInt(int base)
boolean hasNextLong()
boolean hasNextLong(int base)
boolean hasNextShort()
boolean hasNextShort(int base)
La méthode hasNextLine() de type boolean, vérifie si une ligne est présente. Cette fois-ci, il s’agit
d’une chaı̂ne de caractères qui se termine par une fin de ligne.
Les méthodes de transformation

Les méthode suivantes Interprètent la chaı̂ne de caractère présente dans la ligne courante et la
transforme dans le type correspondant à la méthode choisie. Si la transformation se déroule correcte-
ment la méthode renvoie la valeur. Pour les types entiers, il est possible de travailler avec des valeurs
numériques de base quelconque. La méthode retourne alors la valeur décimale équivalente.
boolean nextBoolean()
byte nextByte()
byte nextByte(int base)
double nextDouble()
float nextFloat()
int nextInt()
int nextInt(int base)
long nextLong()
long nextLong(int base)
short nextShort()
short nextShort(int base)
La méthode nextLine() retourne une chaine de caractère qui contient la ligne courante.
9
Exemple
import java.io.*;
import java.util.*;
class ExempleLecture {
public static void main(String[] args) throws IOException {
File f = new File("exemple.txt");
Scanner sc = new Scanner(f);
while(sc.hasNextLine()) {
System.out.println(sc.nextLine());
4.1.3 Exercice 1
Ecrire un programme permettant de créer séquentiellement un fichier texte comportant pour
différente personnes les informations suivantes : nom, prénom et années de naissance.
4.2 Les exceptions

4.2.1 Présentation des exceptions
Même lorsqu’un programme est au point, certaines circonstances exceptionnelles peuvent com-
promettre la poursuite de son exécution ; il peut s’agir par exemple de données incorrectes ou de la
rencontre d’une fin de fichier prématurée (alors qu’on a besoin d’informations supplémentaires pour
continuer le traitement).
Un gestionnaire d’exception établit un ensemble de routines de traitement d’erreurs, définies par

le programmeur, sur un bloc (dans une fonction ou une méthode du programme) ; ces routines sont
activées pendant toute la durée d’exécution du bloc protégé.
Java dispose d’un mécanisme très souple nommé gestion d’exception, qui permet à la fois :
– De dissocier la détection d’une anomalie de son traitement ;
– De séparer la gestion des anomalies du reste du code, donc de contribuer à la lisibilité des
programmes.
D’une manière générale, une exception est une rupture de séquence déclenchée par une instruction
throw comportant une expression de type classe. Il y a alors branchement à un ensemble d’instructions
nommé ”gestionnaire d’exception”. Le choix du bon gestionnaire est fait en fonction du type de l’objet
mentionné à throw.
4.2.2 Traitement des exceptions

Les objets de type Exception ou bien de l’une de ses sous-classes sont instanciés lorsqu’une erreur
au niveau applicatif survient. On dit, dans ce cas-là, qu’une exception est levée. Lorsqu’une exception
10
est levée, elle se propage dans le code en ignorant les instructions qui suivent et si aucun traitement
ne survient, elle débouche sur la sortie standard. Voici un code illustrant cela :
public class except {

{
int a[] = {12,5,45,3,2,14,25,32};
for (int i = 0; i <= a.length; i++)
System.out.println(a[i]);
System.out.println("fin du programme!");
}
}
On voit bien sur cet exemple que l’instruction qui suit la levée de l’exception n’est pas exécutée : On
n’obtient pas l’affichage fin du programme !.
Les exceptions sont traitées via des blocs try/catch qui veulent littéralement dire essayer/attraper.
On exécute les instructions susceptibles de lever une exception dans le bloc try et en cas d’erreur ce
sont les instructions du bloc catch qui seront exécutées, pourvu qu’on attrape bien l’exception levée.
Reprenons notre exemple et traitons l’exception. Ce qui donne le code suivant :
public class except {
{
int a[] = {12,5,45,3,2,14,25,32};
try{
for (int i = 0; i <= a.length; i++)
System.out.println(a[i]);}
catch(ArrayIndexOutOfBoundsException e)
{
System.out.println("Une exception est survenue");

}
System.out.println("fin du programme!");
}
}
Comme prévu, on obtient bien l’affichage :”Une exception est survenue”. Il faut tout de même
faire attention au type d’exception qu’on met dans le catch : On aurait pu simplement déclarer une
exception de type Exception. Cela aurait pour effet d’attraper toutes les exceptions levées dans le
bloc try car l’ensemble des exceptions déclarées dans la JDK hérite de cette classe Exception, la
réciproque n’est pas vraie. On peut également mettre plusieurs blocs catch qui se suivent afin de
fournir un traitement spécifique pour chaque type d’exception. Cela doit être fait en respectant la
hiérarchie des exceptions.
11
4.2.3 Quelque exceptions
Exception Description
EOFException Sert à indiquer que la fin de fichier a été atteinte lors
de la lecture.
FileNotFoundException Indique que le fichier demandé est introuvable.
IOException Signale qu’un problème d’entrée-sortie est survenu.
Beaucoup de méthodes du package la génère.
InterruptedIOException Signale qu’une entrée-sortie a été interrompue.
NullPointerException Accès à un champ ou appel de méthode non statique
sur un objet valant null. Utilisation de length ou accès
à une case d’un tableau valant null.
ArrayIndexOutOfBoundsException Accès à une case inexistante dans un tableau.
ArrayIndexOutOfBoundsException accès au ieme caractère d’une chaine de caractères de
taille inférieure à i.
ArrayIndexOutOfBoundsException création d’un tableau de taille négative.
NumberFormatException erreur lors de la conversion d’une chaine de caractères
en nombre.
4.2.4 Exercice 2
La division par zéro : créer une ArithmeticException.
1. Créez une classe d’objet MonEntier qui contient une variable monentier de type int. Ecrivez
le constructeur de cette classe.
2. Munissez cette classe de la méthode division(). Cette méthode retourne le résultat (double de
la division de la variable monentier d’un objet MonEntier par la variable monentier d’un
autre objet MonEntier appelé diviseur. L’objet diviseur sera passé en paramètre d’entrée de
la méthode division().
3. Testez votre méthode division() sur deux entiers quelconques. Recommencez avec un diviseur
égal à zéro. Que se passe-t-il ?
4. Dans la méthode division() : testez le bloc qui effectue l’opération. Si une ArithmeticExcep-
tion est générée, affichez le message ”Division impossible”.
N.B : Vous pouvez également afficher le message de l’exception en utilisant la méthode getMes-
sage() : System.out.println(variableException.getMessage()) ;
12
Chapitre 5
Les interfaces graphiques
5.1 Introduction
Le langage Java propose différentes bibliothèques pour programmer des interfaces graphiques, mais
dans ce TP, nous utiliserons essentiellement les packages javax.swing et java.awt présents d’office dans
Java. Nous allons construire ensemble une fenetre avec Java en suivant étape par étape. Vous serez
alors capable de créer une fenêtre, de définir sa taille, etc. Le fonctionnement de base des interfaces
graphiques vous sera également présenté et vous apprendrez qu’en réalité, une fenêtre n’est qu’une
multitude de composants posés les uns sur les autres et que chacun possède un rôle qui lui est propre.
5.2 La classe JFrame

Pour créer une fenêtre graphique, on dispose, dans le paquetage nommé javax.swing, d’une classe
standard nommée JFrame, possédant un constructeur sans arguments. Pour utiliser une fenêtre de
type JFrame, vous devez l’instancier. Pour commencer notre programme, créez une classe nommée
FenetreEnJava et complétez par le code suivant :
import javax.swing.JFrame;
import java.awt.event.ActionListener;
import java.awt.event.ActionEvent;
public class FenetreEnJava implements ActionListener {
// Déclaration des variables et des composants de la fen^

etre
static JFrame fenetre ;
// Déclaration du constructeur de la classe

public FenetreEnJava(){
fenetre = new JFrame();
}
public static void main(String[] args){

FenetreEnJava FJava = new FenetreEnJava();
}
public void actionPerformed(ActionEvent e) {
}
}
13
Lorsque vous exécutez ce code, vous n’obtenez rien, car par défaut, votre JFrame n’est pas visible.
Vous devez donc la rendre visible de cette manière :
FJava.fenetre.setVisible(true);
Ainsi, lorsque vous exécutez ce code, vous obtenez une fenêtre ouverte.
Pour obtenir une fenêtre plus conséquente, il faudrait donc :
– Qu’elle soit plus grande ;
– Qu’elle comporte un titre ;
– Qu’elle figure au centre de l’écran ;
– Que notre programme s’arrête réellement lorsqu’on clique sur la croix rouge, car, pour ceux qui
ne l’auraient pas remarqué, le processus tourne encore même après la fermeture de la fenêtre.
Pour chacun de ces éléments, il y a aura une méthode à appeler afin que notre JFrame sache à
quoi s’en tenir. Voici le code à ajouter :
//Définir un titre pour notre fen^

etre
FJava.fenetre.setTitle("Ma première fen^
etre Java");
//Définir sa taille : 600 pixels de large et 500 pixels de haut
FJava.fenetre.setSize(600, 500);
//Positionner la fen^etre au centre
FJava.fenetre.setLocationRelativeTo(null);
//Terminer le processus lorsqu’on clique sur la croix rouge
FJava.fenetre.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
5.3 La classe JButton

On crée un objet bouton en utilisant le constructeur de la classe JButton issue du package ja-
vax.swing, auquel on communique le texte qu’on souhaite voir figurer à l’intérieur :
Déclarez monBouton :
static JButton monBouton;
Dans le constructeur de la classe, ajoutez :
monBouton = new JButton("Envoyer");
NB- (Importez la classe JButton : import javax.swing.JButton ;)

Il faut ensuite introduire ce bouton dans la fenêtre. Ici, les choses sont un peu moins naturelles,
car un objet de type JFrame possède une structure a priori quelque peu complexe. En effet, il est
théoriquement formé d’une superposition de plusieurs éléments, en particulier une racine, un contenu
et une vitre. En général, il vous suffit de savoir que c’est sa partie contenu qui nous intéresse puisque
c’est à elle que nous incorporerons les différents composants. La méthode getContentPane de la classe
JFrame fournit la référence à ce contenu, de type Container. Ainsi, depuis une méthode quelconque
d’une fenêtre, nous obtiendrons une référence à son contenu par :
Déclarez c :
static Container c;
c = fenetre.getContentPane();
NB- (Importez la classe Container : import java.awt.Container ;)
On peut cependant modifier la couleur de l’objet contenu de la fenêtre à l’aide de la méthode
nommée setBackground. Il suffit pour cela de savoir qu’elle reçoit en argument un objet de type
Color et que cette classe dispose de quelques constantes prédéfinies correspondant à quelques couleurs
usuelles ; par exemple Color.GRAY pour gris :
Dans main, ajoutez :
14
c.setBackground(Color.GRAY);
NB- (Importez la classe Color : import java.awt.Color ;)

D’autre part, la méthode add de la classe Container permet d’ajouter un composant quelconque
à un objet de ce type. Pour ajouter le bouton précédent (de référence monBouton) au contenu de
référence c, il suffit de procéder ainsi :
c.add(monBouton) ;
La disposition des composants dans une fenêtre est gérée par ce qu’on nomme un gestionnaire
de mise en forme ou encore de disposition (en anglais Layout Manager). Il existe plusieurs gestion-
naires (fournis, naturellement, sous forme de classes) utilisant des règles spécifiques pour disposer les
composants. Sachez que, par défaut, Java utilise un gestionnaire de classe BorderLayout avec lequel,
en l’absence d’informations spécifiques, un composant occupe toute la fenêtre. Mais il existe un ges-
tionnaire plus intéressant, de la classe FlowLayout, qui dispose les différents composants ”en flot”,
c’est-à-dire qu’il les affiche un peu comme du texte, les uns à la suite des autres, d’abord sur une
même ”ligne”, puis ligne après ligne.... Pour choisir un gestionnaire, il suffit d’appliquer la méthode
setLayout à l’objet contenu de la fenêtre. Ainsi, pour obtenir un gestionnaire du type FlowLayout
souhaité, nous procéderons comme ceci :
c.setLayout(new FlowLayout());
NB- (Importez la classe FlowLayout : import java.awt.FlowLayout ;)
5.4 La classe JLabel

Un composant de type JLabel permet d’afficher dans un conteneur un texte (d’une seule ligne)
non modifiable par l’utilisateur, mais que le programme peut faire évoluer. Le constructeur de JLabel
précise le texte initial :
JLabel texte = new JLabel ("texte initial") ;
Déclarez label1 :
static JLabel label1 ;

static JLabel label2;
label1 = new JLabel("Veuillez saisir votre text... ");

label2 = new JLabel("Affichage...");
NB- (Importez la classe JLabel : import javax.swing.JLabel ;)

La classe JLabel définit plusieurs méthodes pour modifier l’apparence du composant. On donne
l’exemple de la méthode setForeground(Color) qui fixe la couleur d’affichage par défaut.
5.5 La Classe TextArea

La classe TextArea encapsule une zone de saisie de texte multi lignes. Elle hérite de la classe
TextBoxBase. La méthode setVisibleLines() permet de préciser le nombre de lignes qui seront visibles.
Déclarez TextArea1 et TextArea2 :
static TextArea TextArea1;

static TextArea TextArea2;
15
TextArea1 = new TextArea();
NB- (Importez la classe TextArea : import java.awt.TextArea ;)
La méthode setBounds permet de positionner un composant : setBounds(int x, int y, int largeur,
int hauteur) ;
Jusqu’ici, nous nous sommes contentés d’afficher du texte sur un composant en employant la
fonte par défaut. Pour utiliser d’autres fontes, on doit modifier la fonte courante. On y parvient avec
la méthode setFont, à laquelle on transmet un objet de type Font qu’on crée en fournissant à son
constructeur les caractéristiques de la fonte souhaitée.
Ajoutez ces lignes de code dans main pour compléter notre programme et expliquez l’utilité de
chaque ligne :
Font police1 = new Font("Tahoma", Font.ITALIC,20 );
Font police2 = new Font("Arial Black",Font.BOLD ,14 );
FJava.label1.setFont(police1);
FJava.label1.setForeground(Color.BLACK);
FJava.label2.setForeground(Color.RED);
FJava.TextArea1.setFont(police2);
FJava.c.add(label1);
FJava.c.add(TextArea2);
FJava.c.add(monBouton );
NB- (Importez la classe Font : import java.awt.Font ;)
5.6 Gestion d’un bouton avec un écouteur

Un bouton ne peut déclencher qu’un seul événement correspondant à l’action de l’utilisateur sur
ce bouton. Généralement, cette action est déclenchée par un clic sur le bouton, mais elle peut aussi
être déclenchée à partir du clavier.
Il suffit simplement de savoir que l’événement qui nous intéresse est l’unique événement d’une
catégorie d’événements nommée Action. Il faudra donc :
– Créer un écouteur qui sera un objet d’une classe qui implémente l’interface ActionListener ;
Cette dernière ne comporte qu’une méthode nommée actionPerformed ;
if (e.getSource() ==monBouton){
try {
enregistrer();
} catch (IOException e1) {
e1.printStackTrace();
}
}
}
– Associer cet écouteur au bouton par la méthode addActionListener (présente dans tous les
composants qui en ont besoin, donc en particulier dans la classe JButton). Voici comment nous
pouvons adapter le programme précédent de façon à faire appel à la méthode enregistrer() à
chaque action sur le bouton :
NB -
16
– Ajoutez cette ligne à main :
monBouton.addActionListener(this);
– Importez la classe ActionEvent : import java.awt.event. ActionEvent ;
– Importez la classe IOException : import java.io. IOException ;
Ajoutez ces deux méthodes pour compléter notre programme
public static void Afficherfichier() throws IOException {

File f = new File("c:/source.txt");
TextArea1.setText(TextArea1.getText()+" Le message envoyé est: "+
sc.nextLine()+"\n");
}
}
public static void enregistrer() throws IOException {

PrintWriter f = null;
try {
f = new PrintWriter(new FileWriter("c:/source.txt"));
}
ph = (String)TextArea2.getText();
f.println(ph);
f.close();
Afficherfichier();
}
5.7 Le Code Source Final
import java.awt.Color;
import java.awt.Container;
import java.awt.FlowLayout;
import java.awt.Font;
import java.awt.TextArea;
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JLabel;
import java.awt.Container;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
import java.io.PrintWriter;
public class FenetreEnJava implements ActionListener{
static JFrame fenetre ;

static JButton monBouton ;
17
static Container c ;
static TextArea TextArea1 ;
static TextArea TextArea2 ;
static String ph ;
public FenetreEnJava(){
fenetre = new JFrame();

monBouton = new JButton("Envoyer");
c = fenetre.getContentPane();
label1 = new JLabel("Veuillez saisir votre text... ");
label2 = new JLabel("Affichage...");
ph = new String(); //
monBouton.addActionListener(this);
}
public static void main(String[] args){

FenetreEnJava FJava = new FenetreEnJava();
FJava.fenetre.setVisible(true);
//Définir un titre pour notre fen^

etre
FJava.fenetre.setTitle("Ma première fen^
etre Java");
//Définir sa taille : 400 pixels de large et 100 pixels de haut

FJava.fenetre.setSize(600, 500);
//Positionner la fen^etre au centre
FJava.fenetre.setLocationRelativeTo(null);
//Terminer le processus lorsqu’on clique sur la croix rouge
FJava.fenetre.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
FJava.c.setBackground(Color.GRAY);
FJava.c.add(monBouton);
FJava.c.setLayout(new FlowLayout());
Font police1 = new Font("Tahoma", Font.ITALIC,20 );

Font police2 = new Font("Arial Black",Font.BOLD ,14 );
FJava.label1.setForeground(Color.BLACK);
FJava.label2.setForeground(Color.RED);
FJava.c.add(monBouton );
18
} // fin de la méthode main

if (e.getSource() ==monBouton){
try {
enregistrer();
}
}
}
public static void enregistrer() throws IOException {

PrintWriter f = null;
try {
f = new PrintWriter(new FileWriter("c:/source.txt"));
}
ph = (String)TextArea2.getText();
f.println(ph);
f.close();
Afficherfichier();
}
public static void Afficherfichier() throws IOException {

File f = new File("c:/source.txt");
TextArea1.setText(TextArea1.getText()+" Le message envoyé est: "+
sc.nextLine()+"\n");
}
}
}
19

Compilation

Transféré par

Informations du document

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Compilation

Transféré par

Droits d'auteur :

Formats disponibles

République Algérienne Démocratique et Populaire

Ministère de l’Enseignement Supérieur et de la Recherche Scientifique

Initiation au langage JAVA

1 Introduction au langage JAVA et notions de bases - Langage JAVA - 2

2 Les tableaux et les chaines de caractère 16

3 Programmation Orientée Objet 1

4 Les fichiers texte et les exceptions 8

5 Les interfaces graphiques 13

Introduction au langage JAVA et

1.1 Introduction au langage JAVA

1.1.3 JRE ( Java Runtime Environment)

1.1.4 JDK (Java Development Kit)

1.1.5 configuration de la variable d’environnement

1.1.6 Premier programme en java

Figure 1.3 – Variables d’environnement

Figure 1.5 – Premier programme en JAVA

1.2 Notions de bases - Langage JAVA -

ligne n total moyenne_x

1.2.2 Les mots clés

1.2.3 Les commentaires

Les commentaires usuels

/* Programme de calcul de racines carrees */

int i; /* Compteur de boucle */

Les commentaires de fin de ligne

System.out.println("Bonjour"); // Formule de politesse

1.2.4 Les types primitifs de Java

1.2.6 Les types flottants

1.2.7 Type caractère

1.2.8 Le type booléen

1.2.9 Déclaration de varaibles

1.2.10 Les opérateurs

Les opérateurs relationnels

1.2.11 Lecture des entrées clavier

// Lecture d’une chaine de caractère

// Lecture d’un nombre entier

// Lecture d’un nombre réel

1.2.12 Les instructions de contrôle

condition est une expression booléenne quelconque.

System.out.print("Introduire un nombre entier: ");

if((n <= 20) && (n >= 0))

System.out.print("Introduire le numéro du jour: ");

Syntaxe de l’instruction switch

System.out.println("Vous avez introduit: " + n);

Syntaxe de l’instruction do . . .while

Donnez un nombre positif: 12

System.out.println("La somme est égale à: " + somme);

Syntaxe de l’instruction while

for(i = 1; i <= n; i++)

System.out.println("La somme est égale à: " + somme);

Syntaxe de l’instruction for

for([initialisation]; [condition]; [incrémentation])

1.3 Solutions des exercices du cours

System.out.print("Introduire un nombre: ");

Scanner sc = new Scanner(System.in);

System.out.println(x + " puissance " + n + " = " + puiss);

Scanner sc = new Scanner(System.in);

for(int i = 1; i <= m; i++)

System.out.println(x + " puissance " + n + " = " + puiss);

Les tableaux et les chaines de caractère

2.1 Les tableaux

2.1.2 Déclaration d’un tableau

Exemples de création de tableau

2.1.3 Création et initialisation d’un tableau

Création par l’opérateur new