Compilation
Compilation
Compilation
Département d’Informatique
Licence 3
Option : Informatique générale
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 à faire . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25
2.5.1 Exercice 1 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25
2.5.2 Exercice 2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25
1
Chapitre 1
Le langage reprend en grande partie la syntaxe du langage C++. Néanmoins, Java a été épuré des
concepts les plus subtils du C++ et à la fois les plus déroutants, tels que les pointeurs et références, et
l’héritage multiple. Les concepteurs ont privilégié l’approche orientée objet de sorte qu’en Java, tout
est objet à l’exception des types primitifs (nombres entiers, nombres à virgule flottante, etc.)
1.1.2 Portabilité
La portabilité (l’indépendance vis-à-vis de la plate-forme), signifie que les programmes écrits
en Java fonctionnent de manière parfaitement similaire sur différentes architectures matérielles. Ce
résultat est obtenu par les compilateurs Java qui compilent le code source à moitié afin d’obtenir
un bytecode (plus précisément le bytecode Java, un langage de type assembleur, proche de la machine
virtuelle et spécifique à la plate-forme Java). Le code est ensuite interprété sur une machine virtuelle
Java (JVM en anglais), un programme écrit spécifiquement pour la machine cible qui interprète le
bytecode Java et fait exécuter par la machine les instructions traduites en code natif. De plus, des
bibliothèques standard sont fournies pour pouvoir accéder à certains éléments de la machine hôte (le
graphisme, le multithreading, la programmation réseau ...) exactement de la même manière sur toutes
les architectures.
Notons que même s’il y a explicitement une première phase de compilation, le bytecode Java est
soit interprété, soit converti à la volée en code natif par un compilateur à la volée (just in time, JIT).
Il existe également des compilateurs Java qui compilent directement le Java en code objet natif pour
la machine cible, supprimant la phase intermédiaire du bytecode mais le code final produit par ces
compilateurs ne peut alors être exécuté que sur une seule architecture.
2
Figure 1.1 – La compilation d’un programme JAVA
laquelle doivent être développés tous les programmes en Java. C’est la garantie de portabilité qui a
fait la réussite de Java dans les architectures client-serveur en facilitant la migration entre serveurs,
très difficile pour les gros systèmes.
3
Figure 1.2 – Propriétés du système
– Dans le répertoire où vous avez enregistré votre fichier source vous allez trouver un nouveau
fichier nommé HelloWorld.class qui correspond au bytecode de votre programme ;
– Pour exé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 méthode main est le point de départ de l’exécution de votre programme. Pour l’instant, vous
pouvez vous contentez de mettre votre code à l’intérieur de cette méthode.
4
Figure 1.4 – Le path
Un identificateur en java est formé de lettres ou de chiffres, le premier caractère étant obligatoirement
une lettre. Les lettres comprennent les majuscules et les minuscules, ainsi que le caractère souligné
( ). Voici quelques identificateurs corrects :
Notez bien, qu’on distingue majuscules des minuscules. Ainsi, Ligne et ligne désignent deux identifi-
cateurs différents.
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
/* Un commentaire
sur plusieurs
lignes
*/
– Nombres entiers ;
– Nombres flottants ;
– Caractères ;
– Booléens.
6
1.2.5 Les diffé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)
Quelques exemples :
7
int n, m, p;
n = 1 + 3;
m = n * 2;
p = m % n;
p++;
n += 2;
import java.util.Scanner;
class Exemple1
{
public static void main(String[] args)
{
Scanner sc = new Scanner(System.in);
System.out.print("Introduire votre nom: ");
8
[else
instruction 2]
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 vérifie si un nombre est bien dans l’intervalle [0, 20] :
import java.util.Scanner;
class Exemple2
{
public static void main(String[] args)
{
Scanner sc = new Scanner(System.in);
Exercice
Écrire un programme Java qui permet de lire un nombre entier au clavier et de tester si il est
négatif, positif ou égal à zéro et d’afficher le message adéquat.
L’instruction switch
Considérons l’exemple suivant qui demande à l’utilisateur d’introduire le numéro du jour, et le
programme affiche le nom du jour correspondant à ce numéro :
import java.util.Scanner;
class Exemple3
{
public static void main(String[] args)
{
Scanner sc = new Scanner(System.in);
int numero_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");
}
}
}
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
import java.util.Scanner;
class Exemple4
{
public static void main(String[] args)
{
Scanner sc = new Scanner(System.in);
int n;
do
{
System.out.print("Introduire un nombre positif: ");
n = sc.nextInt();
} while(n < 0);
do
instruction
while(condition);
10
Exercice
Écrire un programme qui calcule les racines carrées de nombres fournis en donnée. Il s’arrêtera
lorsqu’on lui fournira la valeur 0. Il refusera les valeurs négatives. Son exécution se présentera ainsi :
L’instruction while
Cette exemple calcul la somme 1 + 2 + . . . + n telque n est un nombre entier positif. Nous allons
utilisé la boucle while :
import java.util.Scanner;
class Exemple5
{
public static void main(String[] args)
{
Scanner sc = new Scanner(System.in);
int n;
do
{
System.out.print("Introduire un nombre positif: ");
n = sc.nextInt();
} while(n < 0);
int somme = 0, i = 1;
while(i <= n)
{
somme += i; // Cette écriture est équivalente à "somme = somme + i;"
i++; // Est équivalent "i = i + 1;"
}
while(condition)
instruction
L’instruction for
Nous allons refaire l’exemple 5 mais en utilisant la boucle for :
11
import java.util.Scanner;
class Exemple6
{
public static void main(String[] args)
{
Scanner sc = new Scanner(System.in);
int n;
do
{
System.out.print("Introduire un nombre positif: ");
n = sc.nextInt();
} while(n < 0);
int somme = 0, i;
Exercice
– Écrire un programme qui calcul la valeur de xn , où x est nombre réel et n un entier positif
introduits au clavier en utilisant la boucle while ;
– Écrire un programme qui calcul la valeur de xn , où x est nombre réel et n un entier positif
introduits au clavier en utilisant la boucle f or.
import java.util.Scanner;
class Exo1 {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int n;
if(n < 0) {
System.out.println("Le nombre introduit est négatif");
} else {
12
if(n > 0) {
System.out.println("Le nombre introduit est positif");
} else {
System.out.println("Le nombre introduit est égal à zéro");
}
}
}
}
Exercice 2
import java.util.Scanner;
class Exo2 {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
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
import java.util.Scanner;
class Exo3 {
public static void main(String[] args) {
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
import java.util.Scanner;
class Exo4 {
public static void main(String[] args) {
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 {
if(n > 0) {
for(int i = 1; i <= n; i++)
puiss *= x;
} else {
int m = Math.abs(n);
puiss = 1 / puiss;
14
}
}
15
Chapitre 2
Les tableaux permettent de regrouper une suite de variables de même type. Chaque élément du
tableau est une variable que vous pouvez utiliser comme n’importe quelle variable de ce type. Il est
possible de définir des tableaux pour les types primaires ou les classes. Cependant, tous les éléments
doivent être du même type. En Java, les tableaux sont des objets.
int t[];
16
Exemple
Exemple
tableau anonyme
A tout moment en utilisant l’opérateur new et une liste entre accolades de valeurs. Cette notation
est très pratique pour passer un tableau en paramètres à une méthode sans qu’il faille créer une
variable locale pour ce tableau. En imaginant la déclaration de la méthode suivante
afficheSemaine(String[] joursSemaine);
Exemple
Cette écriture est à la fois un raccourci et évite d’utiliser une variable intermédiaire :
17
2.1.4 Utilisation d’un tableau
Nous pouvons manipuler un élément d’un tableau comme n’importe quelle variable ou n’importe
quel objet de ses éléments. On désigne un élément particulier en plaçant entre crochets, à la suite
du nom du tableau, une expression entière nommée indice indiquant sa position. Le premier élément
correspond à l’indice 0 (et non 1).
\subsection{Exemple}
int t[] = new int[5], a;
t[0] = 15; // place la valeur 15 dans le premier élément du tableau
t[2]++; // incrémente de 1 le troisième élément de t
a = t[4]+23; // utilisation dans un calcul
t[1] = t[0]+5; // initialisation d’un élément à partir d’un autre
t[a-20] = -85; // calcul sur l’indice
System.out.println(Arrays.toString(tableau));
// affichepar exemple à l’écran "[2, 3, 5, 7, 11, 13]"
Si vous voulez effectivement copier toutes les valeurs d’un tableau dans un autre, il faut employer
la méthode copyTo() de la classe Arrays :
Le second paramètre correspond à la longueur du nouveau tableau. Cette méthode est souvent
employée pour augmenter la taille d’un tableau :
Les autres éléments sont remplis de 0 si le tableau contient des nombres, false si le tableau contient
des valeurs booléennes. A l’inverse, si la longueur est inférieure à celle du tableau initial, seules les
valeurs initiales sont copiées.
18
2.1.5 Les tableaux à deux dimensions
De nombreux langages disposent de la notion de tableau à plusieurs indices. Par exemple, un
tableau à deux indices permet de représenter une matrice mathématique.
Java ne dispose pas d’une telle notion. Néanmoins, il permet de la ”simuler” en créant des tableaux de
tableaux, c’est-à-dire des tableaux dont les éléments sont eux-mêmes des tableaux. Cette possibilité
s’avère en fait plus riche que celle de tableaux à plusieurs indices offerte par les autres langages. Elle
permet notamment de disposer de tableaux irréguliers, c’est-à-dire dans lesquels les différentes lignes
pourront être de taille différente.
int t [] [] ;
int [] t [] ;
int [] [] t ;
Elles déclarent que t est une référence à un tableau, dans lequel chaque élément est lui-même une
référence à 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){
accès à t22[i][j]
}
}
19
– boolean remove(int index) supprime l’élément en potion spécifiée par l’élément donné ;
– Object set (int index, Object element) remplace l’élément en potion spécifiée par l’élément
donné.
Exemple pratique
import java.util.*;
public class UseVector1{
public static void main(String args[]){
20
automatiquement par le compilateur. Ainsi, avec :
ch = "bonjour";
on abouti à une situation qu’on peut schématiser ainsi :
2.2.1 Exemple
String ch1 = new String(); //ch1 contient la référence à une chaine vide
String ch2 = new String("Bonjour"); //ch1 contient la référence à une chaine
//contenant la suite "Bonjour"
String ch3 = ch2 //ch3 contient la référence à une chaine copie de ch2,
//contenant "Bonjour"
String ch4 = "Bonjour" // Cette écriture est équivalente à celle de ch2
// mais elle est beaucoup plus concise
2.2.2 Concaténation
Java autorise l’emploi du signe + et += pour joindre (concaténer) deux chaı̂nes.
Exemple
String ch1 = "Java";
String ch2 = "Programme";
String ch3 = ch1+ch2;
//ch3 -> JavaProgramme
ch3 += "Compilation"; // cette notation est équivalente à ch3 = ch3 + "Compilation"
//ch3 -> JavaProgrammeCompilation
Lorsque vous concaté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 à la chaine ch la valeur "Compilation2013"
//Cette caractéristique est couramment utilisée pour l’affichage
System.out.println("La réponse est : " + reponse);
21
4. substring : permet de créer une nouvelle chaı̂ne un extrayant de la chaı̂ne courante tous les
caractères compris entre deux positions données (la premiè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 caractère à la position indiquée (c = ’e’)
int p = mot.indexOf(’o’); // Renvoi la position du caractè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 méthodes de String avec cette
chaı̂ne. Vous pouvez écrire :
int n = "Monsieur".length(); // n est initialisé avec la taille de la cha^
ıne (ici 8)
On peut aussi utiliser la méthode concat pour concaténer deux chaı̂nes :
String ch3 = ch1.concat(ch2);
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 méthode equalsIgnoreCase
La méthode equalsIgnoreCase effectue la mê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’opérateur == pour tester l’égalité de deux chaı̂nes ! Cet opérateur
détermine seulement si les chaı̂nes sont stockées au même emplacement (même référence - adresse de
la variable). Il est évident que si deux chaı̂nes se trouvent à la même adresse, elles doivent être égales.
Mais des copies de chaı̂nes identiques peuvent être stockées à des emplacements différents dans la
mémoire.
22
2.2.5 Comparaison des chaines
La syntaxe de méthode compareTo est comme suit :
ch1.compareTo(ch2);
retourne 0 si les deux chaı̂nes sont égales, une valeur né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 opérateurs ¿, ¿=, ¡, ¡=
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
Écrire un programme qui réalise le tri d’un tableau d’entier. La méthode de tri utilisée est basée
sur la sélection du minimum. Pour chaque indice i du tableau, on recherche à partir de cet indice le
plus petit élément du tableau et on permute cet élément avec celui que se trouve à l’indice i.
2.3.2 Exercice 2
Écrire un programme qui réalise le tri d’un tableau de chaines de caractère. La méthode de tri
utilisée est basée sur la sélection du minimum.
2.3.3 Exercice 3
Écrire un programme qui remplace dans un tableau les mots de langueur inférieur à 3 ou qui se
terminent par ”al” par la chaine ”erreur” , et afficher le tableau.
2.3.4 Exercice 4
Écrire un programme qui demande à l’utilisateur de saisir une chaine de caractère, enregistre dans
un tableau les sous-chaines séparé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{
public static void main(String []args)
{
String[] tab = {"java","c++","html","php","perl","css" };
String swap;
2.4.3 Exercice 3
class exercice3{
public static void main(String []args)
{
String[] tab = {"java","c++","html","php","pascal","perl","css", "c" };
String swap;
2.4.4 Exercice 4
import java.util.Scanner;
import java.util.Vector;
24
class exercice4{
public static void main(String []args){
String swap = "";
Scanner sc = new Scanner(System.in);
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.2 Exercice 2
Écrire un analyseur lexical en utilisant la méthode du cours (table de transition, l’algorithme de
parcour de la table) pour le langage décrit par l’automate suivant : L’exécution du programme peut
ressembler à ceci :
25
26
Chapitre 3
Que l’on soit débutant ou programmeur chevronné, la maı̂trise d’un nouveau langage de program-
mation passe obligatoirement par la pratique.
3.1 Définitions
Un programme classique : Ensemble de structures de données, de fonctions et procédures.
La programmation orientée objet : Ensemble d’objets ; Chaque objet est la concrétisation d’une
structure abstraite appelée Classe, contenant des données et des méthodes.
3.2.1 Classe
Une classe regroupe un ensemble de données (qui peuvent être des variables primitives ou des
objets) et un ensemble de méthodes de traitement de ces données et/ou de données extérieures à la
classe. Une classe est un modèle abstrait d’objet.
Les clauses entre [ ] sont optionnelles. La plus petite déclaration correcte est :
class nomClass {
[déclarations des attributs]
[déclarations des méthodes]
1
}
– Le mot clé extends précise la classe dont hérite une autre classe ;
– Un modificateur intervient sur le champ d’application ou la visibilité de la classe.
Modificateur Rôle
private La classe n’est accessible qu’à partir du fichier où elle est définie
public La classe est accessible de partout
abstract La classe contient une ou plusieurs méthodes abstraites.
Une classe déclarée abstract ne peut pas être instanciée : il faut définir une classe qui
hérite de cette classe et qui implémente les méthodes nécessaires pour ne plus être
abstraite
final La classe ne peut être modifiée, sa redéfinition grâce à l’héritage est interdite.
Les classes déclarées final ne peuvent donc pas avoir de sous-classes.
Une fois la classe déclarée, on peut créer autant d’instances que l’on veut. Tous ses objets auront
les mêmes attributs et méthodes.
Exemple
class Personne {
private String nom, prenom, adresse;
private int age;
2
3.2.2 Objet
Un objet est une instance d’une classe et est référencé par une variable ayant un état (ou valeur).
Pour créer un objet, il est nécessaire de déclarer une variable dont le type est la classe à instancier,
puis de faire appel à un constructeur de cette classe.
Syntaxe
– Déclarer le nom d’un objet de la classe
nomClass nomObjet
– Construire l’objet
nomObjet = new constructeurClass([liste des paramètres])
Exemple L’instanciation d’un objet de la classe Personne faisant appel au constructeur, pourra
s’écrire :
L’usage de parenthèses à l’initialisation de pers, montre qu’une méthode est appelée pour l’instan-
ciation. Cette méthode est un constructeur de la classe Personne. Si le constructeur appelé nécessite
des paramètres d’entrée, ceux-ci doivent être précisés entre ces parenthèses (comme lors d’un appel
classique de méthode). Le constructeur doit porter le même nom que la classe et ne retourne aucun
type, pas même void, car l’objet retourné est toujours implicitement une instance de la classe. Plusieurs
constructeurs peuvent être définis s’ils acceptent des paramètres d’entrée différents.
En effet, les méthodes surchargées doivent se distinguer par des signatures clairement différentes :
– Des nombres d’arguments différents ;
– Et/ou des classes ou types d’arguments différents.
3
3.2.3 Utilisation des objets
Accès aux variables et aux méthodes
Pour accéder à une variable associée à un objet, il faut préciser l’objet qui la contient. On utilise
la syntaxe suivante :
nomObjet.nomAttribut;
La même syntaxe est utilisée pour appeler une méthode d’un objet. Par exemple :
nomObjet.nomMethode();
Exemple
Pour qu’un tel appel soit possible, il faut que trois conditions soient remplies :
1. La variable ou la méthode appelée existe !
2. Une variable désignant l’objet visé existe et soit instanciée.
3. L’objet, au sein duquel est fait cet appel, ait le droit d’accéder à la méthode ou à la variable.
Pour référencer l’objet ”courant” (celui dans lequel se situe la ligne de code), le langage Java fournit
le mot-clé this. Celui-ci n’a pas besoin d’être instancié et s’utilise comme une variable désignant l’objet
courant. Le mot-clé this est également utilisé pour faire appel à un constructeur de l’objet courant.
Ces deux utilisations possibles de this sont illustrées dans l’exemple suivant :
Exemple
4
public Personne(String P_Nom){
this.setNom(P_Nom);
this.setPrenom("Pas de Prenom");
}
public Test()
{
nombre++;
System.out.println("Nombre d’instances crées : " + nombre);
}
}
L’avantage des attributs statiques est que nous pouvons y accéder même sans la création d’instance
de la classe. Ainsi, on peut écrire n’importe où dans une méthode :
Ce code affichera 5.
Constantes de classe
Ce sont des cas particuliers de variables de classe, dont les valeurs ne doivent pas être changées.
On les déclare en combinant les modificateurs final avec static. Par exemple, dans la classe Math,
PI est une constante définie par :
public static final double PI
Bien que Java soit un langage objet, il existe des cas où une instance de classe est inutile. Le mot
clé static permet alors à une méthode de s’exécuter sans avoir à instancier la classe qui la contient.
L’appel à une méthode statique se fait alors en utilisant le nom de la classe, plutôt que le nom de
l’objet.
5
Exemple
3.3 L’héritage
L’idée principale de l’héritage est d’organiser les classes de manière hiérarchique. La relation
d’héritage est unidirectionnelle et, si une classe B hé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 également la classe A.
Grâce à l’héritage, les objets d’une sous 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.
Exemple
En l’absence du mot réservé extends associé à une classe, le compilateur considère la classe Object
comme classe parent. Pour invoquer une méthode d’une classe parent, il suffit d’indiquer la méthode
préfixée par super.
3.4 Exercices
3.4.1 Exercice 1
Dé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 employé(e).
6
Méthodes
– presenteToi() qui affiche tous les attributs de l’employé.
Attribut statique
– nombre pour noter le nombre total d’employés.
3.4.2 Exercice 2
Redéfinir la classe employé en tant que classe qui hérite de la classe Personne.
7
Chapitre 4
Cette opération associe l’objet f à un fichier de nom prog.txt. S’il n’existe pas, il est créé (vide). S’il
existe, son ancien contenu est détruit. On a donc affaire à une classique ouverture en écriture.
Remarque Si le fichier ne se trouve pas dans le même répertoire, il faut spécifier le chemin de ce
dernier. Par exemple :
Classe PrintWriter
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 sont 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 :
Exemple
import java.io.*;
class ExempleEcriture {
public static void main(String[] args) throws IOException {
f.close();
}
}
8
4.1.2 Lecture d’un fichier texte
La classe Scanner est une classe très polyvalente. Sa spécialité, c’est la décomposition de texte.
Certes, cette classe Scanner peut prendre en entrée des textes venant d’un fichier ou d’un flux
quelconque, mais également et tout simplement des chaı̂nes de caractères.
Scanner(File fichier)
Scanner(InputStream flux)
La méthode hasNext() de type boolean, retourne true si un mot est présent dans la ligne courante,
false dans la cas contraire.
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 méthode hasNextLine() de type boolean, vérifie si une ligne est présente. Cette fois-ci, il s’agit
d’une chaı̂ne de caractères qui se termine par une fin de ligne.
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 méthode nextLine() retourne une chaine de caractère qui contient la ligne courante.
9
Exemple
import java.io.*;
import java.util.*;
class ExempleLecture {
while(sc.hasNextLine()) {
System.out.println(sc.nextLine());
4.1.3 Exercice 1
Ecrire un programme permettant de créer séquentiellement un fichier texte comportant pour
différente personnes les informations suivantes : nom, prénom et années de naissance.
Java dispose d’un mécanisme très souple nommé gestion d’exception, qui permet à la fois :
– De dissocier la détection d’une anomalie de son traitement ;
– De séparer la gestion des anomalies du reste du code, donc de contribuer à la lisibilité des
programmes.
D’une manière générale, une exception est une rupture de séquence déclenchée par une instruction
throw comportant une expression de type classe. Il y a alors branchement à un ensemble d’instructions
nommé ”gestionnaire d’exception”. Le choix du bon gestionnaire est fait en fonction du type de l’objet
mentionné à throw.
10
est levée, elle se propage dans le code en ignorant les instructions qui suivent et si aucun traitement
ne survient, elle débouche sur la sortie standard. Voici un code illustrant cela :
public class except {
System.out.println(a[i]);
System.out.println("fin du programme!");
}
}
On voit bien sur cet exemple que l’instruction qui suit la levée de l’exception n’est pas exécutée : On
n’obtient pas l’affichage fin du programme !.
Les exceptions sont traitées via des blocs try/catch qui veulent littéralement dire essayer/attraper.
On exé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 exécutées, pourvu qu’on attrape bien l’exception levée.
Reprenons notre exemple et traitons l’exception. Ce qui donne le code suivant :
public class except {
public static void main(String[] args)
{
try{
System.out.println(a[i]);}
catch(ArrayIndexOutOfBoundsException e)
{
System.out.println("fin du programme!");
}
}
Comme prévu, on obtient bien l’affichage :”Une exception est survenue”. Il faut tout de même
faire attention au type d’exception qu’on met dans le catch : On aurait pu simplement déclarer une
exception de type Exception. Cela aurait pour effet d’attraper toutes les exceptions levées dans le
bloc try car l’ensemble des exceptions déclarées dans la JDK hérite de cette classe Exception, la
réciproque n’est pas vraie. On peut également mettre plusieurs blocs catch qui se suivent afin de
fournir un traitement spécifique pour chaque type d’exception. Cela doit être fait en respectant la
hiérarchie des exceptions.
11
4.2.3 Quelque exceptions
Exception Description
EOFException Sert à indiquer que la fin de fichier a été atteinte lors
de la lecture.
FileNotFoundException Indique que le fichier demandé est introuvable.
IOException Signale qu’un problème d’entrée-sortie est survenu.
Beaucoup de méthodes du package la génère.
InterruptedIOException Signale qu’une entrée-sortie a été interrompue.
NullPointerException Accès à un champ ou appel de méthode non statique
sur un objet valant null. Utilisation de length ou accès
à une case d’un tableau valant null.
ArrayIndexOutOfBoundsException Accès à une case inexistante dans un tableau.
ArrayIndexOutOfBoundsException accès au ieme caractère d’une chaine de caractères de
taille inférieure à i.
ArrayIndexOutOfBoundsException création d’un tableau de taille négative.
NumberFormatException erreur lors de la conversion d’une chaine de caractères
en nombre.
4.2.4 Exercice 2
La division par zéro : créer une ArithmeticException.
1. Cré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 méthode division(). Cette méthode retourne le résultat (double de
la division de la variable monentier d’un objet MonEntier par la variable monentier d’un
autre objet MonEntier appelé diviseur. L’objet diviseur sera passé en paramètre d’entrée de
la méthode division().
3. Testez votre méthode division() sur deux entiers quelconques. Recommencez avec un diviseur
égal à zéro. Que se passe-t-il ?
4. Dans la méthode division() : testez le bloc qui effectue l’opération. Si une ArithmeticExcep-
tion est générée, affichez le message ”Division impossible”.
N.B : Vous pouvez également afficher le message de l’exception en utilisant la méthode getMes-
sage() : System.out.println(variableException.getMessage()) ;
12
Chapitre 5
5.1 Introduction
Le langage Java propose différentes bibliothèques pour programmer des interfaces graphiques, mais
dans ce TP, nous utiliserons essentiellement les packages javax.swing et java.awt présents d’office dans
Java. Nous allons construire ensemble une fenetre avec Java en suivant étape par étape. Vous serez
alors capable de créer une fenêtre, de définir sa taille, etc. Le fonctionnement de base des interfaces
graphiques vous sera également présenté et vous apprendrez qu’en réalité, une fenêtre n’est qu’une
multitude de composants posés les uns sur les autres et que chacun possède un rôle qui lui est propre.
import javax.swing.JFrame;
import java.awt.event.ActionListener;
import java.awt.event.ActionEvent;
}
}
13
Lorsque vous exécutez ce code, vous n’obtenez rien, car par défaut, votre JFrame n’est pas visible.
Vous devez donc la rendre visible de cette manière :
FJava.fenetre.setVisible(true);
Ainsi, lorsque vous exécutez ce code, vous obtenez une fenêtre ouverte.
Pour obtenir une fenêtre plus conséquente, il faudrait donc :
– Qu’elle soit plus grande ;
– Qu’elle comporte un titre ;
– Qu’elle figure au centre de l’écran ;
– Que notre programme s’arrête réellement lorsqu’on clique sur la croix rouge, car, pour ceux qui
ne l’auraient pas remarqué, le processus tourne encore même après la fermeture de la fenêtre.
Pour chacun de ces éléments, il y a aura une méthode à appeler afin que notre JFrame sache à
quoi s’en tenir. Voici le code à ajouter :
14
c.setBackground(Color.GRAY);
c.add(monBouton) ;
La disposition des composants dans une fenêtre est géré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 règles spécifiques pour disposer les
composants. Sachez que, par défaut, Java utilise un gestionnaire de classe BorderLayout avec lequel,
en l’absence d’informations spécifiques, un composant occupe toute la fenêtre. Mais il existe un ges-
tionnaire plus intéressant, de la classe FlowLayout, qui dispose les différents composants ”en flot”,
c’est-à-dire qu’il les affiche un peu comme du texte, les uns à la suite des autres, d’abord sur une
même ”ligne”, puis ligne après ligne.... Pour choisir un gestionnaire, il suffit d’appliquer la méthode
setLayout à l’objet contenu de la fenêtre. Ainsi, pour obtenir un gestionnaire du type FlowLayout
souhaité, nous procéderons comme ceci :
Dans main, ajoutez :
c.setLayout(new FlowLayout());
Déclarez label1 :
15
TextArea1 = new TextArea();
TextArea2 = new TextArea();
NB- (Importez la classe TextArea : import java.awt.TextArea ;)
La méthode setBounds permet de positionner un composant : setBounds(int x, int y, int largeur,
int hauteur) ;
Jusqu’ici, nous nous sommes contentés d’afficher du texte sur un composant en employant la
fonte par défaut. Pour utiliser d’autres fontes, on doit modifier la fonte courante. On y parvient avec
la méthode setFont, à laquelle on transmet un objet de type Font qu’on crée en fournissant à son
constructeur les caractéristiques de la fonte souhaitée.
Ajoutez ces lignes de code dans main pour compléter notre programme et expliquez l’utilité 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.setFont(police1);
FJava.label2.setForeground(Color.RED);
FJava.TextArea1.setFont(police2);
FJava.TextArea2.setFont(police2);
FJava.c.add(label1);
FJava.c.add(TextArea2);
FJava.c.add(monBouton );
FJava.c.add(label2);
FJava.c.add(TextArea1);
– Associer cet écouteur au bouton par la méthode addActionListener (présente dans tous les
composants qui en ont besoin, donc en particulier dans la classe JButton). Voici comment nous
pouvons adapter le programme précédent de façon à faire appel à la méthode enregistrer() à
chaque action sur le bouton :
NB -
16
– Ajoutez cette ligne à main :
monBouton.addActionListener(this);
– Importez la classe ActionEvent : import java.awt.event. ActionEvent ;
– Importez la classe IOException : import java.io. IOException ;
Ajoutez ces deux méthodes pour compléter notre programme
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;
import java.util.Scanner;
17
static Container c ;
static JLabel label1 ;
static JLabel label2 ;
static TextArea TextArea1 ;
static TextArea TextArea2 ;
static String ph ;
public FenetreEnJava(){
FJava.c.setBackground(Color.GRAY);
FJava.c.add(monBouton);
FJava.c.setLayout(new FlowLayout());
18
} // fin de la méthode main
e1.printStackTrace();
}
ph = (String)TextArea2.getText();
f.println(ph);
f.close();
Afficherfichier();
}
19