Langage Java Notions de base

SOMMAIRE

1 Notions de base .................................................................................................. 2

1.1. Classes et Objets .................................................................................... 2
1.1.1 Définition d’une classe ....................................................................... 3
1.1.2 Déclaration et création d’objets.......................................................... 5
1.1.3 Utilisation des objets .......................................................................... 6
1.1.4 Classes internes .................................................................................. 6
1.2. Les éléments du langage ........................................................................ 7
1.2.1 Types de données ............................................................................... 7
1.2.2 Opérateurs......................................................................................... 10
1.2.3 Structures de contrôle ....................................................................... 11
1.2.4 Traitement d’exception : throw-try-catch ........................................ 12
2 Programmes Java ............................................................................................. 14
2.1. Structure d’une application java .......................................................... 14
2.2. Quelques classes utiles ........................................................................ 16
2.3. Paquetages :package ............................................................................ 18
2.4. Entrées/Sorties ..................................................................................... 19
2.4.1 Entrées-Sorties sur clavier/écran ...................................................... 20
2.4.2 Entrées-Sorties sur fichier ................................................................ 21
2.5. Exercices .............................................................................................. 23
3 Héritage et Interface ........................................................................................ 23
3.1. Héritage ............................................................................................... 23
3.2. Interfaces – héritage multiple .............................................................. 26
3.3. Exercices .............................................................................................. 27

Formateurs : ASSALE Adjé & KOUAME Appoh 1/27 INP-HB

Langage Java Notions de base

LANGAGE JAVA
Le langage Java développé par Sun Microsystems dans les années 90 a été lancé
en 1995. C’est un langage qui s’apparente beaucoup au langage C++.

Le JDK (Java Developpment Kit) se compose entièrement de classes et

d’interfaces, les deux sont des programmes. Chaque programme qu’on écrit en
Java est soit une classe soit une interface.
Le compilateur Java (Javac) compile un programme et fournit un pseudo code
(bytecode) qui est interprétable par toute machine virtuelle Java (JVM).

1 Notions de base

1.1. Classes et Objets

La programmation par objets consiste essentiellement à structurer les applications

en entités autonomes construites selon les types de données. Ce qui permet
d’obtenir des logiciels fiables, évolutifs et faciles à maintenir. Le programmeur
par objet se pose en premier la question : quels sont les objets fondamentaux de
l’application ? Quels sont les choses et les concepts qui constituent le domaine de
l’application ? Il décrit alors chaque type d’objet sous forme de variables qui
caractérisent son état puis il s’intéresse aux opérations (traitements) que peuvent
subir ces objets et les décrit sous forme de procédures.

Considérons un rectangle comme exemple. Un tel rectangle est caractérisé par une
longueur (L) et une largeur (l), il est initialisé avec une longueur et une largeur
donnée, il peut calculer son périmètre et sa surface. On le décrira par une
association d’états et de procédures. C’est une telle association de données et de
procédures que l’on nomme habituellement un objet. Ici L, l sont des variables et
perimetre, surface et initialiser sont des procédures.

Il existe de nombreux langages permettant la programmation par objets :

Simula, Smalltalk, Eiffel, Turbo Pascal Objet, C++, Java. Ces
langages ont en commun les notions suivantes :
• La notion d’objet, qui possède deux aspects totalement indépendants :
 Un objet est une chose dotée d’une identité (on peut le référencer).
Ceci s’oppose à la notion de valeur (par exemple 12 n’est pas un
objet).

Formateurs : ASSALE Adjé & KOUAME Appoh 2/27 INP-HB

Langage Java Notions de base

 Un objet peut, accessoirement, être composé de données et de

procédures liées à ces données – les données de l’objet constituent le
contexte de travail pour les procédures associées.
• La notion de classe, qui n’est autre que celle de type (ou modèle) d’objets,
• La notion d’héritage, qui permet de définir des types d’objets plus précis à
partir de types d’objets plus généraux. Elle permet de définir une hiérarchie.
L’héritage permet la conception de logiciels extensibles et favorise la
réutilisation de modules logiciels existants.

1.1.1 Définition d’une classe

La notion de classe est un enrichissement de la notion usuelle de type. Une classe

permet de définir un type d’objet, éventuellement compliqué, associant des
données et des procédures qui accèdent à ces données. Les données se présentent
sous forme de champs désignés par identificateurs et dotés d’un type.
Ces champs sont généralement des variables qui représentent l’état de l’objet. Les
procédures, également appelées méthodes, définissent les opérations possibles
sur un tel objet. Ces données et procédures sont qualifiées de membres ou
composants de la classe.

- La syntaxe générale de définition d’une classe est la suivante :

[public] [abstract] class Nom_de_la_classe [extends

Classe_de_base] [implements Nom_interface] { … }

Le mot clé extends permet de dériver une classe d’une autre classe (voir héritage).
Le mot clé implements (sous-entend un héritage particulier) permet
d’implémenter une interface (voir interface). Le mot clé abstract signifie que la
classe n’est pas encore terminée. En d’autres termes, certaines méthodes peuvent
être redéfinies.
Le mot clé public précise que la classe peut être invoquée par d’autres classes.

Par exemple :

class Rectangle{
private float L ;
private float l ;
public Rectangle(float longueur, float largeur) //initialisation
{ L=longueur ; l=largeur ;}
public Rectangle() //autre initialisation possible

Formateurs : ASSALE Adjé & KOUAME Appoh 3/27 INP-HB

Langage Java Notions de base

{L=0 ; l=0 ;}
private float perimetre()
{return(2*(L+l)) ;}
public float surface()
{return (L*l); }
}

Une classe est composée de données et de méthodes. Les données constantes sont
définies à l’aide du mot clé final.
Les composants d’une classe (données et méthodes) peuvent être qualifiés private,
protected et public :
• private : inaccessible par toutes les classes (accessible uniquement par les
membres de la classe).
• protected : accessible par les classes héritières, par les classes du même
paquetage et inaccessible par les autres.
• public : accessible par toutes les classes.
• Si le composant n’est pas qualifié, il est accessible par les classes du même
paquetage et inaccessible par les autres.

Une classe peut définir une ou plusieurs procédures d’initialisation appelées

constructeurs. Ces procédures portent toute le même que la classe, et s’il y en a
plusieurs, elles se distinguent par le type ou le nombre des paramètres. Si une
classe n’a aucun constructeur explicitement défini, Java définit le constructeur par
défaut, qui est sans paramètre.

Il est parfois nécessaire, dans la définition d’une méthode de classe, de faire appel
à l’instance courante de la classe, dans ce cas on utilise le mot clé this
(littéralement « lui ») qui représente l’instance courante.

Composants non liés à des objets :

On a parfois besoin de procédures ou propriétés non associées à un objet. Une
telle procédure ou propriété doit être rédigée dans une classe, car il n’y a pas de
membres isolés en Java. Une telle procédure ou propriété doit être déclarée avec
l’attribut static par la syntaxe :

[public | private | protected] static typeproc nomproc (liste de paramètres)

{ corps de la procédure}

Le nom donné à ce type de membres est membre de classe, dans le cas contraire
on parle de membres d’instances ou d’objets.

Formateurs : ASSALE Adjé & KOUAME Appoh 4/27 INP-HB

Langage Java Notions de base

Une méthode static n’ayant pas d’objet courant, this n’y est pas défini. Pour les
propriétés toute dernière affectation modifie la valeur pour tous les objets
instanciés de la classe.

1.1.2 Déclaration et création d’objets

Une définition de classe constitue un modèle d’objets dont on peut ensuite créer
autant d’exemplaires que l’on veut (on dit également instances). En Java, la
déclaration et la création des objets sont deux choses séparées. La déclaration
consiste à définir un identificateur et lui associer un type afin que cet identificateur
puisse désigner un objet de ce type. Par exemple, la déclaration des identificateurs
rect1 et rect2 pour désigner des objets de type Rectangle s’écrit : Rectangle rect1
; Rectangle rect2 ;
En Java, comme dans de nombreux langages à objets tels que Eiffel, PascalDelphi
ou Smalltalk, un identificateur de variable de type classe est associé à une
référence qui désigne un objet. Une référence est l’adresse d’un objet, mais
contrairement à un pointeur (tel qu’on en trouve en C, C++ ou Pascal) la valeur
d’une référence n’est ni accessible, ni manipulable : elle ne peut que permettre
l’accès à l’objet qu’elle désigne.
La déclaration seule ne crée pas d’objet. Elle associe l’identificateur à une
référence null qui ne fait référence à rien.

Pour créer un objet de classe X, il faut exécuter new en citant un constructeur de

la classe X, avec ses paramètres. La primitive new rend en résultat la référence
sur l’objet créé, qu’il suffit d’affecter à la variable déclarée.

…
rect1 = new Rectangle(5.2,3.0) ; //appel du constructeur à 2 paramètres
…
rect2 = new Rectangle() ; //appel du constructeur par défaut

Il est possible de faire en une seule instruction déclaration et création :

Rectangle rect3 = new Rectangle(6.0,2.2) ;

La syntaxe générale de déclaration et création d’une instance (ou un objet) est la

suivante :
[accès] [static] [final] Nom_de_classe Nom_objet = new
Nom_de_classe(paramètres)

où l’accès est soit : private, protected ou public.

Si le mot clé static est précisé, le composant n’est lié à aucun objet.

Formateurs : ASSALE Adjé & KOUAME Appoh 5/27 INP-HB

Langage Java Notions de base

1.1.3 Utilisation des objets

Les composants d’un objet (champs de données et méthodes accessibles) sont

désignés au moyen d’une notation pointée :

rect1.surface() ; //calcul la surface du rectangle rect1

rect2.perimetre() ; //calcul le périmètre du rectangle rect2

Il n’est pas possible de faire rect3.L=12.0 car le membre L qui a le statut private
n’est pas accessible.

1.1.4 Classes internes

Java permet de définir une classe à l’intérieur d’une autre classe. Une telle classe
est dite interne (inner class en anglais). L’intérêt d’avoir une telle classe interne
réside dans la modularité que cela apporte : le nom de la classe interne est
purement local et cette classe peut même être rendue invisible depuis l’extérieur
de la classe englobante si on la déclare avec l’attribut private.

A l’extérieur de la classe englobante, on peut citer une classe interne (non privée)
sous la forme : classe englobante.classe interne

Si la classe interne ne fait référence à aucun membre de la classe englobante ; on

peut la déclarer avec l’attribut static.

Dans le cas général, une classe interne utilise les composants de l’objet courant de
la classe englobante ; il y a alors pratiquement une nouvelle classe interne par
objet de la classe englobante, chacune étant liée à un objet. La création d’un objet
de la classe interne doit dans ce cas citer un objet de la classe englobante.

La syntaxe de déclaration et création d’un objet de la classe interne est :

Classe_englobante.classe_interne objet_classe_interne =
objet_classe_englobante.new constructeur_classe_interne

Notons que la création d’un objet instance d’une classe interne diffère légèrement
de la création d’un objet d’une classe normale, la syntaxe est :
objet.new constructeur

Formateurs : ASSALE Adjé & KOUAME Appoh 6/27 INP-HB

Langage Java Notions de base

Par exemple, pour programmer une pile qui sera dotée d’un moyen de parcours de
ses éléments, de sorte que plusieurs parcours puissent se dérouler en même temps
sur une pile, on définira une classe Parcours associée à la pile et on créera un
objet de cette classe chaque fois que l’on veut réaliser un parcours. Le constructeur
Parcours() initialise le parcours à partir du sommet, suivant() passe au suivant
dans la pile, element() rend l’élément du parcours et estEnFin() teste si le
parcours est fini.

class PileEnt {
private int s ; private int P[] = new int[100] ;
public PileEnt() {s=-1;}
public void empiler(int e) {s=s+1; P(s)=e;} public void
depiler() {s=s-1;}
public int sommet() {return P[s];}

public class Parcours {

private int courant;
public Parcours() {courant=s;} public
int element() {return P[courant];}
public void suivant() {courant--;}
public Boolean estEnFin() {return courant==-1;}
}
}

Exemple d’utilisation :

PileEnt p= new PileEnt(); … //

deux parcours sur p:
PileEnt.Parcours parc1= p.new Parcours() ; PileEnt.Parcours
parc2= p.new Parcours() ;
parc1.element() ; parc1.suivant() ;

1.2. Les éléments du langage

1.2.1 Types de données

Formateurs : ASSALE Adjé & KOUAME Appoh 7/27 INP-HB

Langage Java Notions de base

• Type entier (integer)

Type Plage de valeurs Longueur
byte de –128 à +127 1 octet
short de –32 768 à + 32 767 2 octets
int de –2 147 483 648 à +2 147 483 647 4 octets
long de –9 223.1018 à +9 223.1018 8 octets

Les méthodes et classes qui se rapportent aux entiers se trouvent dans le paquetage
java.lang.Integer.

• Type flottant
Type Plage de valeurs Longueur
float +/- 3 403.1038 avec 6 ou 7 décimales 4 octets
significatives
double +/- 1 798.10308 avec 15 8 octets
décimales significatives

Voir les paquetages java.lang.Float et java.lang.Double pour les méthodes se

rapportant.

• Type char
char est un type de caractères Unicode, codé sur 2 octets, soit au total 65 000
caractères qui figurent toujours entre apostrophes ‘ ‘.
La définition d’un caractère Unicode se fait soit directement en tant que caractère
‘A’, soit en tant que nombre hexadécimal ‘\u0000’ jusqu’à ‘\uFFFF’. Il existe des
séquences d’échappement, comme ‘\u’ qui signifie « caractère Unicode »

Séquence Dénomination Valeur Unicode

d’échappement
\' Apostrophe ' \u0027
\" Guillemets " \u0022
\\ Antislash (barre oblique inverse) \u005c
\b Retour (effacement du dernier caractère) \u0008
\n Retour à la ligne (nouvelle ligne) \u000a
\r Retour chariot \u000d
\t Tabulation \u0009

Pour les méthodes se rapportant voir paquetage java.lang.

Formateurs : ASSALE Adjé & KOUAME Appoh 8/27 INP-HB

Langage Java Notions de base

• Type booléen
boolean valeur_test = true;

Pour les méthodes se rapportant aux booléens voir le paquetage java.lang.

• Type String
String n’est pas un type de données simple. C’est pourquoi il n’est pas prédéfini,
contrairement à int ou float.
String introduit du texte c’est une chaîne de caractères, écrit entre guillemets. Ils
est une instance de la classe java.lang.String ou String.

String saluation = "Hello";

String rien = "";

Voir paquetage java.lang pour les méthodes s’y rapportant.

• Type null null est une constante utilisée pour créer

l’instance d’un objet qui n’est pas encore utile ou nécessaire.

• Tableaux et vecteurs
- Tableau : la déclaration d’un tableau s’effectue à l’aide du symbole [] qui peut
se placer après le type ou le nom de la variable.
Par exemple : int [] tab_entier; ou int tab_entier [];
La déclaration d’un tableau comme pour les objets de type classe, ne fait
qu’associer l’identificateur à une variable de nature référence initialisée à null.
Pour que cet identificateur désigne un objet, il faut lui affecter soit le résultat d’une
création, grâce à la primitive new, soit un objet déjà existant : tab_entier = new
int[10] ;

On peut combiner déclaration et création :

int tab_entier [] = new int[10] ; -- on a 10 cases numérotées de 0 à 9

String [] chaine = {"texte1","texte2","texte3"} ;

On ne fixe la taille du tableau qu’une seule fois, pour que la taille soit variable, on
fait recours aux vecteurs. Une fois la taille du tableau fixée, on peut la récupérer
à la l’aide de la propriété length par exemple tab_entier.length donnera 10.

Les tableaux à dimension multiple

int [] [] matrice; ou

Formateurs : ASSALE Adjé & KOUAME Appoh 9/27 INP-HB

Langage Java Notions de base

int [] matrice [] ; ou
int matrice [] [] ;
matrice = new int [4] [5] ;

matrice.length nombre de lignes

matrice[0].length nombre de colonnes

- Les vecteurs sont généralement employés dans les programmes de bases de

données, ce sont des sortes de tableau dont la taille est modifiable.
Vector vecteur = new Vector() ;

Leur affectation et manipulation utilisent des méthodes (voir paquetage java.util).

1.2.2 Opérateurs

- arithmétiques

+, -, *, / et % (reste de divison)
+=, -=, *=, /= et %= affectation après calcul
++ et -- (incrémentation et décrémentation d’une unité)

- logiques

<, >, = = (égalité), != (différent), <= et >=

&& (ET logique), || (OU logique) et !(NON)

- binaires

& (ET binaire), | (OU binaire) et ^ (OU exclusif binaire)

<< (décalage de bits vers la gauche), >> (décalage vers la droite avec signe) et
>>> (décalage de bits vers la droite sans signe) &=, |=, ^=, <<=, >>= et >>>=
affectation après calcul.

- conversion

Casting
Le casting est la conversion d’un type de données en un autre à l’aide d’une
syntaxe. La syntaxe figure entre parenthèse devant la valeur à convertir.

Formateurs : ASSALE Adjé & KOUAME Appoh 10/27 INP-HB

Langage Java Notions de base

Exemple : double valeurd = 4.23 ; int valeurint = (int) valeurd ; Conversion

ad hoc
« ad hoc » signifie qui convient. C’est une conversion automatique de format
lors d’une affectation de valeur, cela n’est possible que si la valeur à
transmettre se situe dans la plage de valeurs de la valeur à laquelle elle est
affectée.
Exemple : int valeurint = 14 ;
long valeur1 = valeurint ;
String str = "texte" + valeurint;
Conversion à l’aide de méthodes
Cela consiste à utiliser les méthodes des classes correspondantes qui sont :
- soit de la forme toxxx, par exemple toString,
- soit de la forme xxxValue qui convertit la valeur au type de données, par
exemple longValue,
- soit encore de la forme parsexxx, par exemple parseInt. xxx étant un type de
données : voir chapitre 3.3.1 Entrées-Sorties sur clavier

Exemple : String str ;

int valeurint = 25.
Str = Integer.toString(valeurint) ;

Avant conversion on peut vérifier qu’un objet est l’instance d’une classe
donnée à l’aide de l’opérateur instanceof.
Exemple : monObjet obj ;
if (monObjet instanceof Classe) { … }

1.2.3 Structures de contrôle

- Affectation

= comme dans le langage C/C++

- Instructions conditionnelles/branchements

if (condition) {
…}
[else
{…}]

Formateurs : ASSALE Adjé & KOUAME Appoh 11/27 INP-HB

Langage Java Notions de base

switch (valeur_de_requête)
{
case valeur1 : … [break] ;
case valeur2 : … [break];
…
default: … [break];
} valeur_de_requête est soit tout type entier sauf long, soit
char.

- Boucles

while (condition) { … }

do { … } while (condition) ;

for (valeur_de_démarrage;condition_d’exécution;compteur) { … }

- break, continue et return

break permet de sortir de n’importe quelle boucle et d’un switch. On simule

un goto en faisant un break nommé.

continue interrompt le passage de la boucle en cours sans la quitter comme

break.

return s’utilise dans les fonctions qui retourne une valeur.

- Commentaires

D’une ligne à l’aide du symbole // ceci est un commentaire.

De plusieurs lignes à l’aide des symboles /* et */ ; /* voici un commentaire sur
plusieurs lignes */.
Commentaire de documentation entre les symboles /** et */, transformable par
l’application Javadoc pour produire de la documentation HTML.

1.2.4 Traitement d’exception : throw-try-catch

Les exceptions sont des classes de traitements d’erreurs. Grâce à elles, le

programmeur peut contourner d’éventuelles erreurs afin d’éviter le plantage du

Formateurs : ASSALE Adjé & KOUAME Appoh 12/27 INP-HB

Langage Java Notions de base

programme. Les erreurs se produisent lors du temps d’exécution d’un programme.

C’est l’origine du terme « runtime error ».

Les classes des Exceptions

Throwable

Exception Error

IOException RuntimeException

Si une méthode est susceptible de déclencher une exception, cela doit être indiqué
dans son profil, au moyen de la directive throws : Int p( ) throws xxxException {
…}

Si une méthode p( ) utilise une méthode q( ) susceptible de déclencher une

exception, on peut traiter l’exception de deux manières :
 Soit capter, et éventuellement traiter l’exception, à l’aide des routines
try – catch au sein de la méthode p( ).
void p( ) { …
try { … q( ) … }
catch (xxxException e) { traitement de e}
}
Définition
try { /*instructions qui doivent être exécutées mais dont on est pas sûr qu’elles
peuvent s’exécuter correctement */
} catch
(l’exception e) {
// instructions qui seront exécuter en cas d’erreur
}
 Soit propager l’exception, en indiquant au moyen de la directive throws
que p( ) est elle-même susceptible de déclencher cette exception :
void p( ) throws xxxException { … q( ) … }

Remarque : on peut ajouter aux routines try-catch la routine finally { … } qui

contiendra les instructions à exécuter dans tous les cas : erreur ou pas erreur

Formateurs : ASSALE Adjé & KOUAME Appoh 13/27 INP-HB

Langage Java Notions de base

Exceptions fréquentes
Exception Description
NumberFormatException Conversion d’un texte en valeur numérique
ArrayIndexOutOfBondsException Appel de champs de tableau qui n’existent
pas
NullPointerException Un programme essaye d’appliquer la valeur
null alors qu’un objet est attendu
MalformedURLException Indication d’une URL inexistante (également
pour les fautes de frappe)

2 Programmes Java

Un programme Java est un fichier dont le code source a pour extension .java.
Après compilation à l'aide de la commande javac l'on obtient un fichier .class qui
soit est interprétable par l'interpréteur java pour les applications ou insérable dans
une page HTML pour les applets.

2.1. Structure d’une application java

Une application java se présente de la manière suivante:

Fichier: Exemple.java

import *.* ; import

…;
public class Exemple
{
//Déclaration de variable de classe
// déclaration de fonction
public / private type fonction (paramètres)
{
"Déclaration de variable locales
…………….
}
…………………..
}
N.B. : un fichier source doit comporter au plus une classe public et doit avoir le
même nom que la classe public s’il y en a une.

L’instruction import permet d’inclure dans le programme des classes contenues

dans des paquetages (voir chapitre Paquetages).

Formateurs : ASSALE Adjé & KOUAME Appoh 14/27 INP-HB

Langage Java Notions de base

Si une des fonctions et une seule est main( ) l'application est exécutable par
l'interpréteur java à l'aide de la commande java. Dans le cas contraire l'application
est considérée comme une classe et elle peut être utilisée par une application.
Le profil de la méthode main( ) est :
public static void main( String argv[])
Le paramètre argv est un tableau de chaînes de caractères. Ce tableau est initialisé
avec les chaînes accompagnant (éventuellement) la commande de lancement.

-Dans une application interprétable les fonctions membres de la classe associée

ont généralement le statut public static. Ce statut permet de définir une simple
procédure en Java, car en Java il n’y a pas de procédures isolées, il n’y a que des
méthodes de classe. Par exemple pour écrire un programme qui utilise une
fonction carre pour calculer le carré d’un réel, on écrira ceci :

Formateurs : ASSALE Adjé & KOUAME Appoh 15/27 INP-HB

Langage Java Notions de base

2.2. Quelques classes utiles

Les différentes méthodes de la classe String

Fonction java
endsWith( ) Recherche si le mot se termine par le ou les caractères
passés en paramètres
startWith( ) Recherche si le mot commence par le ou les caractères
passés en paramètres
charAt( ) Recherche le caractère placé à la position spécifiée en
paramètre. Le premier caractère occupe la position et le
dernier la position
IndexOf( ) Localise un caractère ou une sous-chaine d'un mot à
partir du début du mot. Renvoie la valeur –1 si le
caractère ou la chaîne ne fait pas partie du mot.
castIndexof( ) Localise un caractère ou une sous-chaine d'un mot à
partir de la fin du mot. Renvoie la valeur –1 si le
caractère ou la chaîne ne fait pas partie du mot.
subString( ) Extrait une sous-chaine d'un mot
compareTo( ) .•Nulle si les deux mots sont égales
•Inférieur à 0 si le premier mot est plus grand
•Supérieur à 0 si le premier mot est plus petit
equals( ) True si les deux mots sont identiques False
dans le cas contraire
equalsIgnoreCase( Equals (sans différentiation de minuscules
) et majuscules)
toLowerCase( ) Transforme en minuscule la chaîne sur laquelle la
méthode est appliquée
toUpperCase( ) Transforme en majuscule la chaîne sur laquelle la
méthode est appliquée
concat( ) Concatène la chaîne spécifiée en java à la suite de la
chaîne sur laquelle la méthode est appliquée
replace( ) Remplace systématiquement dans la chaîne sur laquelle
la méthode est appliquée tous les caractères donnés en
premier argument par le caractère donné en 2nd
argument
length( ) Calcule le nbre de caractères de la chaîne sur laquelle la
méthode est appliquée

Formateurs : ASSALE Adjé & KOUAME Appoh 16/27 INP-HB

Langage Java Notions de base

La librairie Math

Fonction java
Math.cos()
Math.sin()
Math.tan()
Math.log()
Math.exp()
Math.floor() Arrondir à l'entier inférieur
Math.ceil() Arrondir à l'entier supérieur
Math.sqrt()
Math.pow() ab
Math.abs()
Math.max()
Math.min()
Math.random() Nombre au hasard entre 0 et 1

-programmation dynamique: les vecteurs

Vector liste = new Vector();

Fonction java Operation

add(objet) Ajoute un élément objet en fin de liste
add(indice, objet) Insère un élément objet dans la liste, à l'indice
spécifié en paramètre
addElement(objet) Ajoute un élément objet en fin de liste et augmente
sa taille de un
elementAt(indice) Retourne l'élément stocké à l'indice spécifié en
paramètre
clear() Supprime tous les éléments de la liste
indiceOf(objet) Retourne l'indice dans la liste du premier objet
donné en paramètre ou -1 si l'objet n'existe pas dans
la liste
lastIndexOf() Retourne l'indice dans la liste du dernier objet donné
en paramètre ou –1 si l'objet n'existe pas dans la liste

remove(indice) Supprime l'objet dont l'indice est spécifié en

paramètre

Formateurs : ASSALE Adjé & KOUAME Appoh 17/27 INP-HB

Langage Java Notions de base

removeRange(i,j) Supprime tous les éléments compris entre les indices

i (valeur comprise) et j (valeur non comprise)

setElementAt(objet, i) Remplace l'élément situé en position i par l'objet

spécifié en paramètre
size() Retourne le nombre d'éléments placés dans la liste

-Notion de dictionnaire

En Java l'on peut créer un dictionnaire de sorte que la recherche d'éléments ne

s'effectue plus sur l'ensemble des données mais sur une clé unique qui lui est
associée.
La manipulation d'un dictionnaire s'effectue à travers le type Hashtable.
Hashtable.nom_Dico= New Hashtable( ).
Les méthodes les plus utilisées sont:

FONCTIONS JAVA OPERATIONS

put(clé,objet) Place dans le dictionnaire l'association
clé-objet
get(clé) Retourne l'objet associé à la clé spécifiée
en paramètre
remove(clé) Supprime dans le dictionnaire
l'association clé-objet à partir de la clé
spécifiée en paramètre
size() Retourne le nombre d'associations
définies dans le dictionnaire.
Le parcours du dictionnaire se fait généralement à l'aide de la classe Enumeration
outil du package java.util qui utilise 2 méthodes: hasMoreElement() qui
détermine s'il existe encore des éléments
nextElement() qui permet l'accès à l'élément suivant
On associe le dictionnaire à une classe Enumeration de la manière suivante :
Enumeration nom_Enum = nom_Dico.keys() ;

2.3. Paquetages :package

Les packages (paquetages) regroupent des classes et interfaces en fonction de leur

domaine. Les paquetages se créent en insérant l’instruction :
package mon_paquetage ;
à la première ligne du fichier java ; les classes et interfaces définies dans ce fichier
appartiennent aux mêmes paquetage mon_paquetage.

Formateurs : ASSALE Adjé & KOUAME Appoh 18/27 INP-HB

Langage Java Notions de base

Au sein d’un paquetage, on a accès aux classes de ce paquetage et aux classes

déclarées public des autres paquetages. Dans le dernier cas, il faut utiliser un nom
absolu : nom_de_package.nom_classe . De plus, les classes compilées d’un
paquetage doivent être placées dans un répertoire de même nom que le paquetage.

Il est possible de désigner les classes par leur nom court, sans préciser le
paquetage, à condition d’utiliser la directive import.
import nom_de_package.* ; // désigner toutes les classes du paquetage import
nom_de_package.classe ;

Exemple : Soient les deux fichiers de classes suivants :

A.java B.java

package p1 ; package p1 ;

public class A{ public public class B{ public

A( ) { B( ) {
System.out.println(″Ok″); System.out.println(″Ko″);
}} }}

La compilation des fichiers A.java et B.java crée le paquetage p1 qui contient les
classes A et B. Il faudrait en plus créer un répertoire p1 dans lequel on placera les
classes compilées A.class et B.class. Ce répertoire doit être désigné par la variable
d’environnement PATH ou CLASSPATH comme répertoire de recherches de
paquetages. Avec l’option –d <répertoire>, le compilateur javac place
automatiquement les classes créées dans les répertoires qu’il faut.
Par exemple : javac –d . A.java, placera la classe A.class dans le répertoire p1 du
répertoire courant désigne par le point (.).

Java offre une bibliothèque de paquetages, les plus usuels étant :

java.lang : classes de base du langage (chaînes, math, processus, exceptions)
java.util : structures de données (vecteurs, piles, tables, parcours, …)
java.io : entrées-sorties classiques (texte sur clavier-écran, fichiers, …)
java.awt : interfaces homme-machine (fenêtrage, événements, graphique,…)
java.net : communications Internet (manipulation d’URL, de sockets, …)
java.applet : insertion de programme dans des documents HTML

2.4. Entrées/Sorties

Formateurs : ASSALE Adjé & KOUAME Appoh 19/27 INP-HB

Langage Java Notions de base

Java offre deux sortes de communications avec l’extérieur :

• des entrées-sorties traditionnelles : lectures et écritures de textes ou objets
sur clavier/écran ou fichiers ;
• des interactions à travers un système de fenêtrage : création de fenêtres,
création de boîte de dialogues, réaction à des événements (voir paragraphe
événements, fenêtres et boîtes de dialogues).

Les classes et interfaces nécessaires aux entrées/sorties sur clavier/écran ou

fichiers se trouvent dans le paquetage java.io. Pour les utiliser, il est nécessaire de
placer l'instruction import java.io.*.

2.4.1 Entrées-Sorties sur clavier/écran

Pour ces entrées-sorties, on dispose des appels de méthodes suivants :

System.out.print(String s) ; impression de la chaîne s,
System.out.println(String s) ; idem avec retour à la ligne.

System.in.read( ) ; lecture d’un caractère.

Ce sont des méthodes des classes PrintStream et InputStream définies dans le
paquetage java.io. Leur profil est :
void println(String s) ; void
print(String s) ; int
System.in.read( ) throws IOException ;

System est une classe du paquetage java.lang. Cette classe définit l’objet out de
la classe PrintStream pour les impressions sur écran et l’objet in de la classe
InputStream pour les lectures au clavier.

La méthode read( ) lit un caractère et retourne un entier correspondant au code

ASCII du caractère frappé, pour obtenir le caractère frappé, il faut faire une
conversion (un cast) :
char c ; … c = (char) System.in.read( ) ;

Pour l’interprétation numérique de chaînes de chiffres, la classe Integer offre la

méthode statique suivante: int parseInt( String s )
Qui convertir la chaîne s en entier décimal.
Il existe des méthodes similaires pour les classes Long, Short, Byte, Float et
Double : parseLong, parseShort, parseByte, parseFloat et parseDouble.

Chaque classe dispose de la méthode toString(xxx val) qui convertit une valeur
val de type xxx (short, byte, int, float ou double) en type String. Il existe aussi le

Formateurs : ASSALE Adjé & KOUAME Appoh 20/27 INP-HB

Langage Java Notions de base

méthode xxxValue() qui retourne la valeur en tant que type xxx et la méthode
valueOf(String s) qui retourne un objet de la classe. Ces deux méthodes
permettent de convertir une chaîne de caractère s en un type xxx.
Par exemple :
x=0.0f ; x=Float.valueOf(s).floatValue();
convertit la chaîne s en type float.

Pour ces méthodes de conversion l’on doit traiter l’exception de type

NumberFormatException (voir chapitre 1.3.4 Traitement d’exception).

2.4.2 Entrées-Sorties sur fichier

On distingue principalement 2 types de flux. Les flux de caractères et les flux

d'octets.

•Les fichiers textes

Ils utilisent les stream FileReader (pour la lecture dans un fichier) et FileWriter
(écriture dans un fichier). Ces deux classes possèdent 3 constructeurs. Les 2
principaux constructeurs s'utilisent avec:
un objet de type file une
chaîne de caractères
Ainsi, l'on peut écrire la
déclaration suivante
FileReader entrée = new FileReader(new File("fichier.text")).
Ou bien
FileReader entrée = new FileReader("fichier.text")

Les classes FileReader et FileWriter respectivement disposent des méthodes

suivantes: read( ) et write( ).

• read( ) qui lit un caractère et retourne un entier. En fin de fichier

l’entier –1 est retourné.
• read(char [ ] buf, int, ind, int longueur ) dans sa version avec
argument lit longueur caractères et les place dans le tableau buf à partir de l'indice
ind.

• write(int c) écrit un caractère. Le caractère est spécifié par son code

• write(char [ ] buf, int ind, int longueur ) écrit longueur caractères à
partir de tableau buf, en commençant à l'indice ind. Les deux derniers paramètres
peuvent être omis.

Formateurs : ASSALE Adjé & KOUAME Appoh 21/27 INP-HB

Langage Java Notions de base

Généralement, on préfère effectuer la lecture et l'écriture d'un fichier à travers un

tampon en utilisant les classes BufferedReader et BufferedWriter.
La classe BufferedReader peut être crée en utilisant, comme paramètres de son
constructeur, un objet de type InputStreamReader ou un objet de type FileReader
dans le cas des fichiers.

Dans le cas d'un objet de type InputStreamReader, le passage d'un paramètre de

type InputStream est nécessaire. On peut utiliser le champ statique in de la classe
System pour lire au clavier. Dans le cas d'un objet de type FileReader on passe
un paramètre de type File.

La classe BufferedReader contient une méthode readLine( ) qui lit une ligne de
texte jusqu'au caractère "fin de ligne" exclus et le résultat est affecté à une chaîne
de caractères. null est retourné en fin de fichier.

Les instructions suivantes:

BufferedReader br = new BufferedReader (new InputStreamReadern
(System.in) ); String S = br.readLine();

permettent de lire une ligne au clavier.

Alors que les instructions:
BufferedReader fr = new BufferedReader (new FileReader(new
File(nom de fichier))); String chaine = fr.ReadLine();

Permettent de lire une ligne dans le fichier dont le nom est contenu dans la variable
nom de fichier.
La classe BufferedWriter utilise pour sa construction des objets de type
OutPutStreamWriter et FileWriter, qui s'utilisent de la même que dans la classe
BufferedReader.
La classe BufferedWriter dispose de la méthode newLine( ) qui permet d'écrire
le caractère fin de ligne.

-Les fichiers d'objet

Ici on parle de sérialisation et de dé-sérialisation.

On stocke un objet sur un flux de fichiers ou on le sérialise en utilisant une classe
ObjectOutPutStream grâce à sa méthode writeObject( ). On dé-sérialise un objet
en utilisant une classe ObjectInPutStream grâce à sa méthode readObject( ). Ces
outils sont applicables à tous les objets prédéfinis du langage Java, tel que les
String, les vecteurs (Vector) ou les dictionnaires (Hashtable).

Formateurs : ASSALE Adjé & KOUAME Appoh 22/27 INP-HB

Langage Java Notions de base

Pour sérialiser un objet dont le type est défini par le programmeur, il est nécessaire
de le rendre sérializable en réalisant une implémentation de l'interface
Serializable pour cet objet, par la syntaxe suivante:

Public Class Exemple implements Serializable

{"données et méthodes "
}

Ainsi, tous les objets déclarés de Exemple peuvent être lus ou écrit dans des
fichiers d'objets. Toutes les informations relatives à l'objet seront placées dans un
flux à l'exception des variables de classe définie en static qui sont communes à
tous les objets.
Les streams objectOutPutStream et objectInPutStream sont respectivement
généralement enveloppé dans un FileOutPutStream et FileInPutStream. Il existe
également les classes BufferInPutStream et BufferedOutPutStream qui permet
la lecture et l'écriture de données Objet à l'aide d'un tampon.

2.5. Exercices
Fiche de TD exercices 1, 2, 3 et 4

3 Héritage et Interface

3.1. Héritage

On a parfois besoin de définir un type d’objet similaire à un type existant, avec

quelques propriétés supplémentaires. L’héritage permet de définir ce nouveau
type sans tout reprogrammer : il suffit de déclarer que le nouveau type hérite du
précédent et on se borne à rédiger ses fonctionnalités supplémentaires
En Java, l’héritage d’une classe s’exprime à l’aide du mot clé extends. Seuls les
composants de la classe mère qualifiés par public ou protected sont hérités par la
classe fille. La syntaxe est :
class Classe_fille extends Classe_mere { … }

Par exemple :

class Personne {
String nom ;
int age ;
Personne (String lenom, int lage) {nom=lenom ; age=lage ;}

Formateurs : ASSALE Adjé & KOUAME Appoh 23/27 INP-HB

Langage Java Notions de base

}
class Salarie extends Personne {
int salaire ; int prime() {return
salaire*age/100 ;} Salarie (String n, int s)
{super(n); salaire=s;}
}
Class Eleve extends Personne{
String classe;
boolean bourse;
Eleve (String ch, int n, String cl, Boolean b) {super(ch, n);
classe=cl; bourse=b;}
Eleve (String ch, int n, String cl) {super(ch,n); classe=cl; bourse=false;}
}

Remarquons que les membres de la classe Personne sont définis sans aucun
attribut : de tels membres sont accessibles par les classes qui font partie du même
paquetage, et inaccessibles par les autres. Les attributs : public : définit des
membres accessibles par toutes les classes.
protected : définit des membres accessibles par toutes les classes dérivées
(héritières), et les classes du même paquetage, inaccessibles par les autres.
private : définit des membres inaccessibles par toutes les classes, accessibles que
par les membres de la classe.

Au début du corps d’un constructeur de la classe dérivée (héritière), on peut

appeler explicitement un constructeur de la classe de base (mère) avec les
paramètres souhaités grâce à la notation : super( paramètres )
Si on omet cet appel, l’exécution du constructeur est de toute façon précédée par
l’exécution du constructeur sans paramètre de la classe de base.

Compatibilité entre types : le fait qu’un type B hérite d’une type A signifie que B
est un sous-type de A, c’est-à-dire qu’un objet de type B est également de type A.
par exemple, un Salarié est également une Personne. Donc toute opération
applicable au type A est également applicable au type B. le type B est dit plus
précis que A, et A plus vague que B.
La règle générale de compatibilité de types peut être informellement énoncée ainsi
: partout où une expression de type A est attendue, une expression de type plus
précis que A est acceptable. En revanche, l’inverse est interdit. Cette règle
s’applique essentiellement en deux circonstances : en partie droite d’une
affectation ou bien en que paramètre effectif de procédure. Par exemple, avec les
déclarations suivantes :

Formateurs : ASSALE Adjé & KOUAME Appoh 24/27 INP-HB

Langage Java Notions de base

Personne p … ; Salarie s … ; void

Q(Personne p) { … } ;

Ces instructions sont permises : p=s ; Q(s) ;

Pendant l’exécution, la variable p et le paramètre formel p sont des références sur

l’objet précis de type Salarie qui leur est assigné.
Cependant p ne donne pas directement accès aux membres du type précis Salarie
: on ne peut pas écrire p.salaire, ni p.prime(). Le compilateur refuse ces
expressions, à juste titre car l’objet désigné par p pourrait être parfois du type
Personne, et ces accès n’auraient aucune signification. Pour profiter vraiment du
fait que l’objet désigné par p est du type précis Salarie, il faut utiliser la notion
de méthode virtuelle.
L’opérateur instanceof permet de tester si un objet est l’instance d’une classe :
nomobjet instanceof classe rend true si l’expression désigne un objet de la classe
indiquée, false sinon.

Le polymorphisme en Java s’exprime par le fait qu’une méthode définie à la fois

dans la classe mère et dans la classe fille s’exécute en fonction de l’objet associé
à l’appel et non plus suivant le nombre et le type des paramètres, comme c’est le
cas de la surcharge de méthodes à l’intérieur d’une même classe.

Quand une méthode est redéfinie dans une classe fille, l’héritage est supprimé.
Pour faire appel à la méthode de la classe mère il faudrait écrire :
super.Methode_classe_mere

Les méthodes virtuelles permettent de prévoir des opérations similaires sur des
objets d’espèces différentes. On les appelle également méthodes différées pour
insister sur le fait qu’elles sont destinées à être définies ou redéfinies pour chaque
sous-espèce d’objets que l’on inventera ultérieurement.
En Java, toute méthode est potentiellement virtuelle, sauf si on lui donne l’attribut
final, auquel cas elle ne pourra être redéfinie par les classes dérivées.

En Java, une classe peut annoncer une méthode sans la définir. Une telle classe
est dite abstraite et elle doit être introduite par le mot clé abstract. Les méthodes
qui ne sont pas définies sont également qualifiées abstract et seul leur profil est
indiqué. Syntaxe :
abstract class A { class B extends A {
… …
abstract void p( ) ; void p( ) { … }
… …

Formateurs : ASSALE Adjé & KOUAME Appoh 25/27 INP-HB

Langage Java Notions de base

void q( ) { … } void q( ) { … }
} }

La classe A annonce mais ne définit pas la méthode p. C’est une classe abstraite.
La classe dérivée B définit p et redéfinit q.
Une classe abstraite n’ayant pas toutes ses méthodes définies, il est interdit de
créer des objets de ce type.

Java n’offre vraiment pas les types génériques, mais permet de les réaliser, au
moyen de la classe object et du typage forcé (coercition explicite ou cast). La
classe objet est la classe dont héritent implicitement toutes les classes
programmées en Java. Ainsi pour définir des données de type quelconque, il suffit
de structurer des objets de type object.

Exemple

Soit à définir une classe Personne avec les membres nom et age de statut privé et
nbre_enf (nombre d’enfants) de statut public. On définira un constructeur qui
permettra d’initialiser les membres nom et age, et une méthode publique plusage
renvoyant un booléen (vrai - si la personne courante est plus âgée qu’une personne
x passée en paramètre).
Définir une sous classe de Personne appelée Travailleur qui a les membres
supplémentaires lieu (lieu de travail) statut public, salaire statut privé, prime qui
retourne la prime calculée dont la valeur est le salaire proportionné à 10% du
nombre d’enfants. On redéfinit le membre plusage qui compare cette fois ci le
salaire du travailleur courant avec un autre ; on définit enfin une méthode
plusancien qui compare l’âge du travailleur courant avec un autre.
Définir une classe TestPersonne contenant la méthode main() dans laquelle on
initialisera des Personnes et des Travailleurs, ensuite on affichera qui est plus
ancien ou plus âgé que qui.

3.2. Interfaces – héritage multiple

Certains langages comme C++, permettent l’héritage multiple : une classe peut
hériter de plusieurs classes. Ce n’est pas le cas de Java où une classe ne peut hériter
que d’une seule classe.
Cependant Java offre la notion d’interface, notion voisine, plus simple et
suffisante dans les cas usuels.

Une interface est une collection de déclarations de méthodes. On peut la

considérer comme un cas limite de classe abstraite : elle ne définit aucun corps de

Formateurs : ASSALE Adjé & KOUAME Appoh 26/27 INP-HB

Langage Java Notions de base

méthode, ni aucun composant variable. Il n’y figure que le profil des méthodes et
éventuellement des déclarations de constantes.

- La syntaxe de définition d’une interface est la suivante :

[public] interface Nom_interface { … }

Une classe peut ″implémenter″ une ou plusieurs interfaces (mot clé implements),
en définissant les méthodes de ces interfaces. La syntaxe est :
[public] class Nom_de_classe implements Nom_interface { … }

Les interfaces sont abstraites, cela signifie que, à l’instar des classes, elles ne
peuvent être instanciées. Par contre, il faut redéfinir dans la classe toutes les
méthodes d’une interface implémentée.

3.3. Exercices

Fiche de TD exercices 4 et 5

Formateurs : ASSALE Adjé & KOUAME Appoh 27/27 INP-HB