Cours JAVA S1 - PPT

Cours Programmation
Orienté Objet : Java

Version préparée par M. Mohamed Saleh
Bouhlel
Présentée par Mme Yosr Naïja
2006/2007
Plan
Introduction générale
Éléments de base du langage JAVA
Les principes de la programmation Objet « Objet,
classe»
Tableaux et chaînes de caractères
Héritage, Interface et Package
Les exceptions
Les Entrées Sorties
Java Data Base Connectivity (JDBC)
Y.Naïja en collaboration avec M.S Bouhlel Cours POO 2

Introduction générale
Qu’est-ce que Java ?
Java est un langage de programmation
Orienté Objet.
Il a été développé par SUN.

Propriétés de Java
Java est un langage:
Simple
- Syntaxe proche du C/C++
- Élimination de la notion de pointeur, structure…
- Assure la gestion de la mémoire (« Garbage collector »)
ÎUn système de ramasse miette permet de décharger le
programme d’une gestion fastidieuse de la mémoire
Presque complètement objet

- Pas d'utilisation d'objets pour les primitives (int, char, double)
Interprété
- Un programme java n’est pas compilé en code machine mais
transformé en code intermédiaire interprété.

Fortement typé
- Interdiction de conversion de type impliquant une perte de
précision.
Ouvert
- Connexion aux bases de données intégrée (JDBC)
- Support des caractères internationaux
- …
Dynamique et muti-tâches (ou multithread)

- Les classes sont chargées au fur et a mesure des besoins.
- La mise à jour de l’application peut se faire classe par classe.
- Gestion multithreading simple : écouter de la musique en
regardant une animation flash.

Portable
- Indépendant de toute plateforme.
- Pas de compilation spécifique pour chaque plateforme.
La devise de java : écrire une fois , exécuter partout
« Write once run everywhere »

Déploiement d’un programme (1/2)
Paradigme classique de la compilation
MonProg.c
Génère du code natif directement

Compilateur exécutable, mais spécifique à
chaque environnement
MonProg.o
010110…

Déploiement d’un programme (2/2)
Compilation avec JAVA
Chaque programme est compilé et interprété
« Write once run everywhere » : écrire une fois exécuter
plusieurs fois
MonProg.java
Traduit le programme en un code
intermédiaire
Compilé une seule fois Compilateur Appelé bytecode – indépendant de
la machine
MonProg.class
JVM JVM JVM

MAC Windows UNIX
La machine virtuelle JAVA (JVM)

Une fois le programme java compilé et converti en Byte-Code, c’est la JVM
qui est capable d’interpréter et de permettre au système d’exécuter ce
code. avec M.S Bouhlel
Y.Naïja en collaboration Cours POO 9
La plateforme Java
Plateforme = environnement hardware ou software sur lequel
le programme est exécuté.
La Java « Platform » se compose de:

¾ La machine virtuelle JAVA (JVM)
Interpréter le bytecode
¾ Les interfaces de programmation d’application (API)

Ensemble de classes prédéfinies de java qui existe dans chaque installation.
Elles sont organisées sous forme de package. (E/S, Swing, Awt…)

Versions de Java
Version Nbr Nbr nouveauté
classes packages
1.0 212 8
1.1 504 23 - Classe interne

- JVM plus performante
- JDBC pour l'accès aux données
1.2 1520 59 -Swing

-Collections
1.3 1842 76 -Java SOUND
1.4 2991 135 -XML (SAX/DOM)

-SSL, Image, …

Chapitre 1 :
Éléments de base
du langage JAVA
Particularité
¾Existe une distinction entre majuscule et minuscule.
Commentaires
Trois notations sont admises pour l’insertion de
commentaire :
¾ // commentaire sur une ligne.
¾ /* commentaire sur
plusieurs
lignes */
¾ /** commentaire d’explication utilisé par javadoc

sur une ou plusieurs lignes */

Points virgules, blocs et blancs
Toute instruction doit se terminer par un point virgule «;»
Un bloc est une suite d’instruction délimité par «{» et «}».
Les blancs sont autorisés entre les éléments du code

sources. (espace, tabulation et saut de ligne)
Exemple:
{
x=2; {x=2;y=10;}
y=10;
}

Identificateurs
Un identificateur désigne le nom de tout objet, variable,
classe, programme que le programmeur souhaite
manipuler.
¾ Commence par une lettre, un trait de soulignement « _ » ou le
signe dollar « $ ».
¾ Les caractères suivants de l’identificateur peuvent contenir des
chiffres.
¾ Existe une distinction entre majuscule et minuscule.
¾ Exemple:
MaClasse, _maVariable, $maFonction, C1, … (Valide)
1var, -maclasse, fonction-recherche, … (non valide)

Identificateurs
¾ Ne doit pas appartenir à la liste des mots réservés
Abstract double int strictfp

boolean else interface super
break extends long switch
byte final native synchronized
case finally new this
catch float package throw
char for private throws
class goto protected transient
const if public try
continue implements return void
default import short volatile
do instanceof static while

Types de données
Java prend en comptes les types de données suivant :
1. Les types primitifs
2. Les chaînes de caractères : Pour manipuler les chaînes de

caractères Java offre une classe appelée String. Une constante
chaîne de caractères est placée entre " " .
3. Des références : Contrairement aux types primitifs qui possèdent

des tailles de mémoire standard et fixes, un type tableau ou un type
classe ne peut pas avoir une taille standard. Au lieu de manipuler
directement un objet de la classe ou un objet tableau, Java
manipule une autre donnée qui représente une référence à l’objet
manipulé. Pour cela classes ou types tableau sont appelés des
références.

Types primitifs
Catégorie logique : Type boolean
en java, un boolean n’est pas considéré comme une valeur
numérique. Seules valeurs possibles sont true ou false.
Ex:
boolean trouve=true;
Catégorie caractère : Type char

le type ‘char’ permet de représenter les caractères isolés (c’est
un caractère Unicode représenté sur 16 bits). Elle est délimité
par deux apostrophes.
exemples:
char x=‘a’; char omega=(char) 969;
char z=‘\u1200’

Types primitifs
Catégorie entier : types byte, short, int et long
il existe 4 types d’entiers en java.
chaque type est déclaré avec l’un des mots clés :byte, short, int et long.
Type Taille Intervalle

byte 1 Octet -2exp7 .. (2exp7) -1
short 2 Octets -2exp15 .. (2exp15) -1
int 4 Octets -2exp31 .. (2exp31) -1
long 8 Octets -2exp63 .. (2exp63) -1
Exemple:
Int x=2;
Long y=3L;

Types primitifs
Catégorie flottant : type float et double
une constante numérique est flottante si elle contient un
point décimal, une partie exponentielle lettre E ou si elle
sont suivit par la lettre F ou D.
Exemple :
2.3F
2.3
2.3E4
4F
Remarque : les expression littérales flottantes sont de type

double sauf si elles sont explicitement suivies par la lettre
F.

Déclaration et affectation
La déclaration et l’affectation s’effectue de manière similaire au C.
Exemple :
int x=0, y=0;
float z=2.3F;
double t=2.3;
char c=‘r’;
Les variables constantes : toute variable dont le type est précédé

par le mot clé final,
¾ elle ne peut plus être modifiée
¾ Elle doit être initialisée lors de sa déclaration.
Exemple :
final double PI=3.14;

Les expressions en java
Les opérateurs
Voir document liste des opérateurs

Conversion de type
Si dans une expression les opérandes sont de différents types le résultat
est alors converti vers le type le plus grand.
Exemple :
int x=2; long y=4, z;
z=x*y; //le résultat est alors converti en long
Pour l’affectation, la donnée à droite est convertie dans le type de celle de

gauche. Si le type de la destination est plus faible l’instruction est
considérée erronée.
Exemple :
int i=2; long x=5;
x=i; //instruction légale
i=x; // instruction erronée
On peut convertir explicitement une valeur en forçant la transformation. Le

type ciblé est placé entre () et est utilisé comme préfixe de l’expression dont
on veut modifier le type.
<nom_variable> = (<type>) <expression>
Exemple :
float z; z=(float) 14.33;
int x; x=(int) z; //x contient la valeur 14

Les structures de base
Structure alternative : if..else
if (<expression booléenne>)
{
//instruction ou bloc d’instruction a exécuter si condition= vrai.
}
else
{
//instruction ou bloc d’instruction a exécuter si condition= faux.
}
La partie else est optionnelle et peut être omise s’il n’y a pas d’actions a
effectuer lorsque la condition est fausse.
Exemple :
int i=2; boolean fin;
if(i<0)
{fin=true; i=0;}
else i++;

Structure alternative : switch
switch (<expression >)
{
case <valeur 1> : <bloc 1> break;
case <valeur 2> : <bloc 2> break;
……
case <valeur n> : <bloc n> break;
default : <bloc n+1>
}
l’expression du switch doit être de type compatible avec un entier. Les

expression en flottant ou en double ne sont pas permises.
la spécification du break sont nécessaire pour gérer les ruptures de

séquences.

Structure alternative : switch
Exemple: Exemple:
int k=0, i=2; int k=0, i=2;
switch(i) switch(i)
{ {
case 1: k+=20; break; case 1: k+=20;
} }
k=2 K=?

Opérateur ternaire
variable = condition ? si_test_vrai : si_test_faux ;
C’est équivalent à :
If(condition)
si_test_vrai
Else
si_test_faux
Exemple:
int a=1,b=3;
int min=(a<b)?a:b; //parenthèse facultatives

Structure répétitive : while
while (<expression_booléenne>)
{
<instruction ou bloc>
}
Exemple:
int i=0;
System.out.println(‘‘je sais compter jusqu’a 10’’);
while (i<10)
{
System.out.println(i);
i++;
}

Structure répétitive : do .. while
do
{
<instruction ou bloc>
}
while (<expression_booléenne>);
Exemple:
int i=10;
System.out.println(‘‘je sais compter jusqu’a 10 a l’envers’’);
do
{
i--;
}
while(i>=0);

Structure répétitive : for
for (
<initialisation> ; <expression_booléenne> ; <incrémentation> )
{
<instruction ou bloc d’instruction>
}
Exemple:
for (int i=0;i<=10;i++)
for ( ; ; ) Î boucle infinie

Convention d’écriture
Classes
class BankAccount, class RacingBike
Interfaces
interface Account
Méthodes
deposer() getName()
Packages
package coursJava
Variables
int accountNumber; int x
Constantes
MAXIMUM_SIZE

Premier Programme
JAVA
Comment développer une application?
Deux façons d’écrire des programmes Java:
En écrivant le code dans un simple éditeur de texte

¾ Compilation et exécution du code en ligne de commande DOS
En utilisant un environnement de développement (IDE)

¾ Netbeans (http://www.netbeans.com )
¾ Borland JBuilder (http://www.borland.com/jbuilder )
¾ IBM WebSphere Studio (http://www.ibm.com/software/awdtools
)
¾ Sun ONE Studio (http://wwws.sun.com/software/sundev)
¾ Microsoft .Net Studio (http://msdn.microsoft.com/vstudio)
¾ Jcreator
¾ …

Une première application : Application HelloWorld
Créer un fichier : HelloWorld.java

La première ligne du programme doit être
public class HelloWorld la déclaration de la classe
{ Tout programme doit contenir une méthode

public static void main (String[]args) main qui porte la signature ci-contre
{
System.out.println("Hello the World"); Écrire à l’écran “Hello the World”
}
} Fermer les accolades
• Compiler le programme : javac HelloWorld.java

• Le compilateur génère le bytecode dans le fichier : HelloWorld.class
• Exécuter l’application : java HelloWorld
• « Hello the World » s’affiche à l’écran

Chapitre 2 :
Les principes de la
programmation Objet
« Objet, classe»
Notion d’objet
C’est une notion très proche de celle de la vie courante. On

représente en permanence le monde qui nous entoure sous
forme d’objets plus ou moins abstraits (chaise, table, stylo,
voiture, animaux...).
Cette vision d’un objet peut être différente en fonction de nos

besoins :
¾ Un conducteur voit une voiture comme un ensemble complexe
de commande pour la faire avancer, diriger et interagir avec
d’autres véhicules.
¾ Un policier voit un ensemble de véhicules comme un ensemble
d’objets qui doivent respecter des règles de circulation. (camion
ou voiture sont de même type)
¾ Un garagiste voit un véhicule comme étant un ensemble
d’objets qui interagissent entre eux.

Notion d’objet
Un objet est définit de la manière dont on peut

interagir avec lui et cela en fonction du problème à
résoudre.
Il correspond à un certain niveau d’abstraction de la

réalité et est représenté essentiellement par les
services qu’il peut nous rendre.
Nous faisons tous en permanence un tel travail

d’abstraction pour pouvoir voir et comprendre
simplement le monde qui nous entoure.

Encapsulation, méthodes et invocation
Un objet est une boite noire qui offre un certain nombre de

fonctions ou méthodes permettant d’interagir avec lui.
La seule chose nécessaire pour pouvoir utiliser un objet est de

savoir ce qu’il peut faire et surtout comment le lui demander.
Ex: un poste de télé est une boite noire ayant pour interface :
une télécommande , écran, haut parleurs. Pour changer de
chaîne il suffit de demander à la boite noire de le faire pour
nous en appuyant sur un bouton.
L’ensemble des méthodes proposées par un objet est appelé

interface de l’objet.

Encapsulation, méthodes et invocation
On dit qu’un objet est encapsulé par son interface Î la seule façon de
communiquer avec cet objet et d’invoquer une des méthodes de son
interface.
L’encapsulation d’un objet par son interface permet de masquer son

contenu Î possibilité de modifier son contenu sans impacte pour le reste
du monde.
L’encapsulation constitue un des points centraux de l’approche objet. En

faisant cela on dit à l’objet ce qu’il doit faire et non comment il doit le
faire.
Ex: si on freine avec la voiture on se contente d’appuyer sur la pédale

(méthode freinage). Peut importe s’il s'agit d’un frein à disque ou ABS…
Ex:un policer invoque la méthode arrêter en levant la main et il ne

s’occupe pas de la manière dont chaque véhicule s’arrête.

classe et instances de classe
Soit la table de cuisine de Mme Fafa

¾ Cette table de cuisine particulière est dite «
instance » de l’ensemble des tables de cuisine
ayant les même fonctionnalités.
¾ Cet ensemble de tables de cuisines est appelée
« classe ».

Niveau d’abstraction et classes d’objets
Une table de cuisine est une table qui possède des

caractéristiques spécifiques. On dit que la classe des tables
de cuisine est une classe fille de la classe des tables et
qu’elle hérite des caractéristiques de cette classe tout en la
spécialisent par l’ajout de nouvelle fonctionnalités.
Une classe fille est définie à partir de sa mère par héritage

(réutilisation de ce qui est déjà défini) et spécialisation (ajout
de nouvelles fonctionnalités).
Meubles
Tables Chaises
Table de cuisine Table de salon

Polymorphisme
C’est un mot Greg « plusieurs formes ».
Signifie qu’une méthode peut être définie dans plusieurs

classe et que chaque classe peut implémenter (réaliser)
cette méthode à sa manière.
Ex: lorsqu’on freine dans une voiture, on sait que la fonction

attendue est de stopper le véhicule. En fonction du type réel
de véhicule (de sa classe plus spécifique), les actions réelles
sont très différentes (ABS, tambours,…). Le conducteur n’a
pas besoin de ce niveau de détail pour savoir s’arrêter.

Objets, Classes
Qu’est ce qu’un objet?

¾ C’est l’unité de base de la conception OO.
¾ Il regroupe à la fois des données et des opérations qui permettent de
manipuler ces dernières.
¾ Les données sont généralement appelé attributs et les opérations sont
appelées méthodes.
Un objet est caractérisé par :

¾ Attributs typés.
¾ Méthodes.
¾ nom, pour le distinguer des autres objets.
Exemple:
¾ On peut modéliser une personne par l’objet Personne. Les attributs sont alors
les informations concernant la personne (nom, prénom, tel,…). Et comme
méthode on aurait par exemple calcul_Age, calcul_salaire…

Objets, Classes
Qu’est ce qu’une classe?

¾ C’est une description d’un ensemble d’objets ayant des propriétés et
des comportements commun.
¾ Les objets sont aussi dits instances de classes.
Une classe en java est définie en précisant son nom, en déclarant ces
attributs et en définissant ses méthodes.
Syntaxe:
Class nom_classe
{
// déclaration des attributs
// déclaration des méthodes
}

Objets, Classes
Exemple:
class Rectangle
{
//déclaration attributs
int long;
int larg;
// autres attributs éventuels
//déclaration des fonctions
void allongerRectangle(int lg)
{ longueur+=lg;}
//… autres méthodes
}
Toutes les méthodes sont écrites à l'intérieur de la classe

La classe ne se termine pas par ";"

Objets, Classes
Déclaration des attributs

[<modificateur_visiblité>] <type> <nom>[=<expression>]
Ex
public int x;
public int y=34;
private int z=2;
Déclaration des méthodes

[<modificateur_visiblité>] <type_retour> <nom>([<arguments>])
{
// déclaration variables
// les instructions
}
Ex.
public int somme(int a){
…
}
Objets, Classes
Constructeur de classe
Un constructeur est une méthode particulière appelée
au moment de la création d’un objet. Son rôle est
d’initialiser l’objet en fonction des paramètres fournis
par l’utilisateur.
Le nom du constructeur doit correspondre au nom de la

classe sans aucun type de retour.
Ex:
Rectangle(int lg,int larg) {
longueur=lg; largeur=larg;
}

Objets, Classes
Constructeur de classe
Une classe peut avoir plus qu’un constructeur
Ex:
Rectangle (int lg,int larg) {
longueur=lg; largeur=larg;
}
Rectangle () {
longueur=0; largeur=0;
}
Chaque classe comporte au moins un constructeur. En effet,

si aucun n’est précisé, le système utilise un constructeur par
défaut.

Objets, Classes
Création et initialisation des objets

1. Déclaration de l'objet : déclarer une variable de la
classe que l’on désire instancier. Cette variable n’est
pas l’objet lui-même mais une référence à cet objet.
Ex: Rectangle r1; // r1 ??
2. Allocation de l'espace à l'objet : allouer l’espace

mémoire nécessaire à l’objet et renvoyer l’adresse de
l’objet à la variable référence. Cette opération se fait à
l’aide de l’opérateur new auquel on passe le nom de la
classe.
ex : r1= new Rectangle();

Objets, Classes
Utiliser un objet
¾ Accès à un attribut :
L’accès direct à un attribut dans une classe se fait toujours à
l’intérieur d’une méthode.
Si on voudrait utiliser les attributs à l’extérieur de la classe,
alors on crée un objet de la classe puis on applique cette
syntaxe:
<nom_Objet>.<Nom_Attribut>
¾ Invocation d’une méthode :

Même principe.
- A l’intérieur de la même classe : appel direct de la méthode :
<nom_méthode>(<liste_arguments>);
- A l’extérieur de la classe on utilise un objet.
<nom_Objet>. <nom_méthode>(<liste_arguments>);

Objets, Classes
Contrôle d’accès au membre :

¾ L’accès aux membres (données et méthodes) d’une classe peut être
contrôlé. En effet, l’utilisation du modificateur d’accès « private »
pour un membre rend impossible tout accès à ce membre à partir de
l’extérieur.
¾ Ex :
Class Rectangle
{ private int longueur;
private int largeur;
// déclaration des méthodes…
}
Class Test
{public static void main (String[] args){
Rectangle r=new Rectangle();
r.longueur=10; //instruction erronée}
}

Objets, Classes
Les références :
¾ Ce sont les variables qui permettent de désigner et manipuler les objets.
¾ Les seuls opérateurs sur les références sont des opérateurs logiques:
==: teste si 2 références désignent le même objet.
!= : teste si 2 référence ne désignent pas le même objet
instanceof : retourne true si l’objet à gauche est une instance de la classe placée
à sa droite ou si la comparaison est faite entre un objet d’une classe implémentant
une interface et cette interface . Sinon il retourne false.
¾ Ex :
Class Rectangle
{ private int longueur; private int largeur;
// déclaration des méthodes…
}
Class Test
{public static void main (String[] args){
Rectangle r=new Rectangle();
boolean val1=r instanceof Rectangle;//val=true
boolean val2=r instanceof Test;//val=false
}}

Objets, Classes
La référence this :
¾ Le mot clé this représente une référence sur l’objet courant (celui qui est en
train d’exécuter la méthode contenant le this).
¾ La référence this peut être utile :
Lorsqu’une variable locale ou un paramètre de fonction porte le même nom d'un
attribut de la classe.
Pour déclencher un constructeur depuis un autre constructeur.
¾ Ex :
Class Date
{
int jour=1, mois=1, an=1990;
Date()
{an=2000; /* peut s’écrire : this.an=2000 (facultatif)*/}
Date(int an)
{this.an=an; /*pour pouvoir accéder à l'attribut de la classe (obligatoire)*/}
Date(int an, int mois, int jour)
{this.jour=jour;
this.mois=mois;
this(an); /* Appel du deuxième constructeur*/}
}

Objets, Classes
La référence null :
¾ Le mot clé null permet de représenter la référence qui ne représente
rien.
¾ On peut assigner cette valeur a n’importe quelle variable ou attribut
contenant une référence.
¾ C’est aussi la valeur par défaut d’initialisation des attributs
représentant des références.
¾ Ex :
Class Test
{
Voiture v1; //initialisation a null par défaut.
void methode()
{
…
if (v1==null) v1=new Voiture();
…
}
}
Objets, Classes
Surcharge des méthodes :

¾ Java permet de réutiliser un même nom de méthode pour
plusieurs fonctionnalités. On dit que la méthode est
surchargée.
¾ Ex :
Une méthode qui permet l’affichage de son argument.
void print(int)
void print(float)
void print (double)
¾ Les méthodes surchargées sont soumises à certaines
règles:
Arguments suffisamment différents (nombre et/ou type)

Objets, Classes
Passage de paramètres des méthodes:

¾ Java ne transmet les arguments de type
simple que par valeur Î l’argument ne
peut être modifié par la méthode appelée.
¾ Si une instance d’un objet est transmise

comme argument a une méthode, le
contenu de l’objet peut être modifié dans la
méthode appelée et non sa référence.

Objets, Classes
¾ Ex :
class Test
{ int val=11;
public void modif(int n) { n=22; }
public void modifObj(Test obj) {obj.val=22;}
public static void main(String a[])

{
Test t=new Test();
int n=0;
t.modif(n); System.out.println(n); //n=0;
t.modifObj(t); System.out.println(t.val); //val=22
}
}

Objets, Classes
Attributs de classe:
¾ C’est un attribut marqué par le mot clé static.
¾ Le mot clé static , utilisé pour un attribut, permet
d’indiquer que cet attribut est commun à tous les objets
de la classe concernée Î si on modifie cet attribut pour
un objet donné, il sera modifié pour tous les objets de la
classe.
public static void main (String[] args){
¾ Ex :
Voiture V1=new Voiture();
class Voiture Voiture V2=new Voiture();
{ static int count =0; System.out.println(V1.count);
count
int id; V1.count=55;
voiture(){ 22
55
1
2 System.out.println(V2.count);
Voiture.count=22;
count++;
System.out.println(V1.count);
id=count; }
} }
Objets, Classes
Attributs de classe:
¾ On accède à un attribut statique :
Via une instance quelconque de la classe : V1.id
Via le nom de la classe : Voiture.id
¾ On peut associer static à final pour un attribut

constant et commun à tous les objets de la
classe.
final static float PI=3.14F;

Objets, Classes
Méthodes de classe:
¾ Une méthode de classe est une méthode de type static.
¾ Une méthode de classe est une méthode dont les actions

concernent la classe entière.
¾ Une méthode statique ne peut accéder qu’aux attributs

statiques de la classe.
¾ On peut invoquer une méthode statique soit à partir de:

La classe elle-même
Un objet de cette classe

Objets, Classes
Méthodes de classe: class Test

Ex : {
class MathTool void methode1()
{ final static double PI=3.14; {
static double getPI() double i = MathTool.power(6);
{return(PI);} }
static double diametre(double rayon) void méthode2()
{return(2*PI*rayon);} {
static double power(double x) MathTool t=new MathTool();
{return (x*x);} double i = t.power(6);
} }
}

Objets, Classes
Méthodes de classe:
¾ Une méthode statique ne peut pas avoir de référence
this car elle peut être appelée sans l’intermédiaire d’un
objet.
¾ On utilise généralement des méthodes static pour

rassembler un ensemble d’outils sur un certain objet.
¾ La méthode main est une méthode de classe, elle est

la première à être appelée quand on lance la JVM
avec sa classe. La méthode main peut être lancée
sans qu’aucune instance de la classe qui la contient
n’existe.

Objets, Classes
Autres remarques
¾ Toute classe est une classe fille de la classe
prédéfinie Object
¾ Toute classe hérite des méthodes de la
classe Object
¾ Méthode prédéfinie toString de la classe
Object :
Prototype public String toString();
Est utilisée générement pour retourner les valeurs
des données membres de l'objet appelant.

Objets, Classes
Ex .
class Date
{
Date (int j, int m, int a){ jour=j; mois=m; an=a;}
public String toString(){

String a = "La date est : "+ jour+ "/"+ mois+"/"+annee;
return a;
}
}
class test{
public static void main(String []args){
Date d=new Date(5, 12, 2006);
System.out.println(d.toString()); // ou System.out.println(d);
}
}

Chapitre 3 :
Tableaux et chaînes de
caractères
Les tableaux
En java le type tableau est assimilable

à une classe Î un tableau est un objet
référencé.
Utilisation d'un tableau :
1. Déclaration : déclarer un tableau en java
revient a réserver de la place mémoire
pour l’adresse de ce tableau.
2. Allocation mémoire : après l’avoir déclaré,
allouer l’espace mémoire nécessaire pour
les cases du tableau

Les tableaux
Tableau à une dimension
¾ Déclaration :
<type> <nomTableau>[ ]; ou
<type> [ ]<nomTableau>;
¾ Exemples:
int notes[]; // tableau entiers
char[] lettres; //tableau de caractères
short t1[100]; //instruction illégale car il n’est pas
//possible de définir un tableau de
//taille fixe à la déclaration.

Les tableaux
¾ Allocation mémoire :
la déclaration ne fait que réserver l’espace mémoire allant contenir
l’adresse du tableau. Cette place mémoire est identifié par le nom du
tableau.
l’allocation mémoire des cases du tableau se fait par le mot clé new :
<nomTableau> = new <Type>[<dimension>];
¾ Exemple :
int []notes;
notes = new int[3]; Déclaration Allocation
notes Ox123
Ox123

Les tableaux
¾ Initialisation:
Lorsqu’un tableau est créé. Chacun de ces éléments est initialisé.
Cette initialisation se fait a 0 si les éléments sont des entiers ou
des réels, à false s’ils sont des booléens et à null sinon.
¾ Exemples:
int []tab={3, 5, 7}; // c’est équivalent a faire
int []tab=new int[3]; tab[0]=3; tab[1]=5; tab[2]=7;
¾ La longueur d’un tableau peut être obtenue à partir de la variable

membre length.
<nomTableau>.length

Les tableaux

¾ Utilisation:
le premier élément d’un tableau commence a l’indice 0 et le
dernier élément a l’indice n-1 (n le nombre d’éléments du
tableau).
l’accès à un éléments du tableau se fait en mettant l’indice de

cet élément entre crochets. Par ailleurs si on essaie d’accéder
à un élément qui se trouve en dehors des bornes du tableau
une erreur sera générée.
¾ Utilisation:
in[] tab=new int[10];
tab[0]=1;
tab[10]=2;// erreur à la compilation

Les tableaux
Tableau à deux dimensions

Un tableau à 2 dimensions est tableau dont chaque composante est
formée par un tableau.
¾ Déclaration & allocation:

1. 1ère méthode
<type>[][]<nomtableau>=new<type>[N1][N2];
N1: nombre de tableau-élément.
N2: nombre d’élément de chaque tableau-élément.
Exemple :
créer une matrice carré :
int [][] matrice= new int[2][2];
matrice[0][0]=1; matrice[0][1]=1;
matrice[1][0]=1; matrice[1][1]=1;

Les tableaux
2. 2ème méthode
<type> [ ][ ]<nomTableau>=new <type> [N1][ ];
<nomTableau>[0]=new <type>[N21];
<nomTableau>[0]=new <type>[N22];…
Exemples:
Int[][] notes=new int[3][];
notes[0]=new int[3];

Les tableaux

¾ Le nombre de tableau-élément peut être
obtenue en utilisant la variable length.
¾ Exemple:
int[][] tab={{1,0,9},{2,8},{8,5,7}};
tab.lengthÎ3
tab[1].lengthÎ2

Les tableaux
Exercice :
1. Écrire une méthode qui permet de faire un affichage de ce genre:

Les chaînes de caractères
String est une classe qui est fourni avec l’API Java pour la
manipulation de chaînes de caractères
Elle dispose des opérateurs + ou += pour concaténation

des chaînes de caractères.
Une chaîne constante est délimitée par des guillemets.

Ex:
String s=‘‘il est beau java’’;
Mise à disposition de méthodes de manipulation de
chaînes de caractères

Les chaînes de caractères
Quelques méthodes de la classe String:
• int length() : retourne le nombre de caractère de la chaîne.
• int indexOf(char c, int i) : retourne la position du caractère c à

partir de la position i.
• String substring(int i, int j): retourne une chaîne extraite de la

chaîne sur laquelle est appliquée la méthode en partant de la
position i a la position j.
• int compareTo(String s) : effectue la comparaison entre deux

chaînes. Elle retourne une valeur <0, =0 ou >0
• char charAt(int i) : retourne la caractère qui se trouve à la

position i.

Chapitre 4 :
Héritage, Interface et
Package
Héritage
Introduction :
• Un des avantages de la POO est de définir des

dépendances entre les classes.
class Date
{ int jour, mois, année;
Date(int j, int m, int a)
{jour=j; mois=m; année=a;}
…
public void affiche()
{ System.out.println(jour+’’/’’+mois+’’/’’+année);}
}
• Supposons qu’on veut définir une 2ème classe
DateEvenement qui associe à une date un événement
donné.

Héritage
Introduction :
• Une solution est de réécrire entièrement cette classe.
class DateEvenement
{ int jour, mois, année;
String evenement;
DateEvenement(int j, int m, int a, String e)

{jour=j; mois=m; année=a; evenement=e;}
public void affecter(int j, int m, int a, String e)

{ jour=j; mois=m; année=a; evenement=e;}
…
public void affiche()
{ System.out.println(jour+’’/’’+mois+’’/’’+année+’’ Î ‘’+evenement);}
}
Héritage
Introduction :
• Cette solution est à l’opposé de ce qu’est la

programmation objet.
• Puisqu’on a déjà la classe Date, on a un moyen plus

simple de définir la classe DateEvenement qui est
l’héritage.
• On dira que la classe DateEvenement hérite des

attributs et des fonctionnalités de la classe de base
Date.
• On parle de classe fille/classe mère ou sous-

classe/superclasse, ou classe dérivée/classe de base

Héritage
Introduction : Syntaxe de l'héritage
• <nom_classe_fille> extends <nom_classe_mère>:
Ex.
class DateEvenement extends Date
{
String evenement;
…
public String quelEvent()
{return evenement;}
}

Héritage
Constructeur de la sous classe :
¾ Lorsqu'on définit une classe dérivée, il faut s'assurer

que, lors de la création des objets de cette nouvelle
classe, les champs propres à cette classe dérivée ainsi
que les champs de la classe de base soient initialisés
correctement.
¾ Un constructeur d'une classe dérivée se compose

généralement de deux parties :
celle concernant les champs de la classe de base en utilsant
super(…)
et celle concernant les champs propres à la classe dérivée.

Héritage
Constructeur de la sous classe :

{
String evenement;
DateEvenement(int j, int m, int a, String e)
{
super(j,m,a); //appel au constructeur de la classe de Base.
evenement=e; //initialisation des champ de la classe dérivée
}
…
}
Remarque : L'invocation de super(...) doit être la première

instruction du constructeur de la classe dérivée.

Héritage
Constructeur de la sous classe : remarques importantes
¾ L'invocation de super(...) doit être la première instruction du constructeur de

la classe dérivée.
¾ Constructeur par défaut : Si le constructeur de la classe dérivée n'invoque

pas le constructeur de la classe de base explicitement avec l'instruction
super(...), Java fait quand même appel au constructeur, sans argument, de
la classe de base : super(). Un constructeur définit comme suit
public DateEvenement(String e) {event = e ; }

est automatiquement transformé en Î
public DateEvenement(String e) { super() ; event = e ; }
¾ Dans le cas où un tel constructeur n'existe pas dans la classe de base, une
erreur de compilation est générée. Il existe un cas où l'absence de
l'instruction super(...) ne conduit pas à cet appel implicite : celui où le corps
du constructeur commence par l'instruction this(...).

Héritage
Enchainement de constructeur :
¾ Pour tout objet créé, le constructeur de la classe de base est

invoqué qui lui à son tour invoque le constructeur de sa classe de
base et ainsi de suite. Il existe donc un enchaînement d'invocation
de constructeurs. Cette cascade d'appels aux constructeurs s'arrête
dès que l'on atteint le constructeur de la classe Object.
¾ La classe Object est la mère de toutes les classes ; toute classe est
dérivée directement ou indirectement de la classe Object.
¾ Ainsi, lors de la création d'un objet, le premier constructeur invoqué

est celui de la classe Object suivi des autres constructeurs dans
l'ordre de la hiérarchie de dérivation des classes.

Héritage
Redéfinition des champs :

Les champs déclarés dans la classes dérivée sont toujours des champs
supplémentaires.
Si l'on définit un champ dans la sous classe ayant le même nom qu'un
champ de la classe de base, il existera deux champs de même noms :
¾ Le nom de champ désignera toujours le champ déclaré dans la classe
dérivée.
¾ Pour avoir accès au champ de la classe de base, il faudra changer le type
de la référence pointant sur l'objet ou en utilisant le mot clé super.
class B extends A {
class A public int i ;
{ ...
public int i ; public void uneMethode() {
... i = 0 ; // i est le champ défini dans la classe B
} this.i = 0 ; // i est le champ défini dans la classe B
super.i = 1 ; // i est le champ défini dans la classe A
( (A) this ).i = 1 // i est le champ défini dans la classe A
…}}
Héritage

Cette technique peut s'appliquer en cascade de la manière suivante :
class C extends B {
public int i ;
...
public void uneMethode()
{
i = 0 ; this.i = 0 ; // i est le champ défini dans la classe C
super.i = 1 ; // i est le champ défini dans la classe B
( (B) this ).i = 1; // i est le champ défini dans la classe B
( (A) this ).i = 1 // i est le champ défini dans la classe A
}}
Par contre, l'instruction suivante est incorrecte :

super.super.i = 1 ; // Incorrect syntaxiquement !
Tout comme l'utilisation du mot clé this, le mot clé super ne peut pas être
utilisé dans les méthodes static.
Héritage
Redéfinition des méthodes:
On n'est, évidemment pas, tenu de déclarer des nouveaux champs dans une classe
dérivée : il est possible que l'on dérive une classe pour uniquement modifier les
méthodes de la classe de base.
Par exemple, si l'on voulait une nouvelle classe DateAnglais qui ne diffère de la
classe Date que par le format d'impression de la date, il suffirait de définir une classe
dérivée de la classe Date et de redéfinir la méthode imprimer pour cette nouvelle
classe.
La redéfinition d'une méthode consiste à fournir une implantation différente de la

méthode de même signature fournie par la classe de base. Dans cet exemple, la
méthode affiche des classes Date et DateAnglais ont la même signature ; celle de la
classe DateAnglais redéfinit celle de la classe Date.
class DateAnglais extends Date {

public void affiche(){
System.out.println(retourneMois() + "/" + retourneJour() + "/" + retourneAnnée() ) ; }
}

Héritage
Méthode de la classe de base:

Pour avoir accès à une méthode redéfinie de la classe de base, à l'intérieur
d'une méthode de la classe dérivée, il faudra utiliser le mot clé super. Comme
pour les champs redéfinis, il suffit de préfixer le nom de méthode par le mot
clé super pour invoquer la méthode de la classe de base.

{
private String event = null ;
public DateEvenement(int j, int m, int a, int e)
{ super(j, m, a) ;
event = e ; }
public void afficher()

{ super.afficher(); System.out.println(e); }
...
}

Héritage
Méthode static:
Une méthode static peut également être redéfinie par une autre méthode
static. Par contre, une méthode static ne peut être redéfinie en une méthode
non static.
Méthode final:
Une méthode final est une méthode qui ne peut être redéfinie dans aucune
sous classe.
Exemple :
class Date {
private int jour, mois, année ;
public final int retouneJour() { return jour ; }
... }

Polymorphisme
Une méthode polymorphe est une méthode

déclarée dans une superclasse et redéfinie
dans une sous-classe.
Avantage : liaison dynamique :
Forme f ;
switch(n){
case 0: f=new Carre();
break();
case 1: f=new Cercle();
break();
}
S=f.superficie(); La fonction est déterminée à l'exécution

Héritage
Classe Final
Une classe final est une classe qui ne peut pas
être dérviée.
final class A{
…
}
class B extends A {
…
}

Héritage
La classe Object :
• C’est la classe de base de toutes les classe Java.
• Les méthodes définis dans cette classe peuvent alors être utilisées
ou redéfinies.
• Exemples de méthodes :
public String toString()
public boolean equals(Object obj)
public final native Class getClass()
public native int hashCode()
protected native Object clone()
protected void finalize() throws Throwable
public final native void notify()
public final native void notifyAll()
public final native void wait(long timeout)throws InterruptedException
public final void wait(long timeout, int nanos)throws InterruptedException
public final void wait()throws InterruptedException

Héritage
La classe Object :
¾public String toString ()

La méthode toString est utilisée pour donner une
représentation textuelle d'un objet.

Héritage
Exemple
class Date
{
Date (int j, int m, int a){ jour=j; mois=m; an=a;}
public String toString(){

String a = jour+ "/"+ mois+"/"+annee;
return a;
}
}
class test{
public static void main(String []args){
Date d=new Date(5, 12, 2006);
System.out.println(d.toString()); // ou System.out.println(d);
}
}

Héritage
La classe Object :
¾public boolean equals (Object obj)
La méthode equals rend la valeur true si l'objet sur
lequel la méthode equals est invoquée est égale à
l'objet passé en paramètre.
Î Qu'est ce que l'égalité ? La notion de l'égalité
dépend des objets concernés. Par défaut, la
sémantique de la méthode equals fournie dans la
classe Object est l'égalité entre les valeurs des
références : les deux références désignent le même
objet.

Héritage
Classes et méthodes abstraites:
On peut parfois utiliser les classes pour définir, non pas un type d'objet
bien précis, mais un concept.
Forme

Carré Cercle
Soit la méthode superficie de la classe Forme Î On ne sait pas implanter

la méthode superficie dans le cas d'une forme générale.
Par contre, une fois connue une forme précise (un carré, un cercle, etc.),
on sait implanter cette méthode pour cette forme.

Héritage
Classes et méthodes abstraite:
Une méthode abstraite est une méthode qu'on ne peut pas

implémentée
Une classe abstraite est

¾ Une classe qui ne peut pas être instanciée
¾ Une classe qui contient au moins une méthode abstraite
Il ne sera jamais possible de créer un objet de type Forme.
Le langage Java impose de qualifier la classe d'abstraite

lorsqu'une de ses méthode est abstraite.

Héritage
Classes et méthodes abstraite:

abstract class Forme {
...
public abstract void superficie() ;
... }
Tout ceci permet de regrouper des données et méthodes communes dans

une classe et de spécifier les méthodes qu'une classe dérivée de celle-ci
doit absolument implanter.
Exemple :
class Carré extends Forme {

...
public void superficie () { ... }
... }
Si l'on définit une sous classe sans implanter toutes les méthodes
abstraites de la classe de base, une erreur de compilation est générée.

Interface
Introduction :
Le langage Java ne permet pas l'héritage multiple. Il palie ce manque par
l'introduction des interfaces. Le choix délibéré de Java de supprimer
l'héritage multiple est dicté par un souci de simplicité.
Pour supprimer les problèmes liés à l'héritage multiple, les interfaces sont
des ``sortes de classes'' qui ne possèdent que des champs static final
(autant dire des constantes) et des méthodes abstraites.
En fait, les interfaces sont un moyen de préciser les services qu'une classe
peut rendre.
On dira qu'une classe implante une interface Z si cette classe fournit les
implantations des méthodes déclarées dans l'interface Z.
¾ Autrement dit, la définition d'une interface consiste à donner une collection de

méthodes abstraites et de constantes.
¾ L'implantation de ces méthodes devra évidemment être fournie par les classes
qui se réclament de cette interface.

Interface
Déclaration des interfaces :
Comme les classes, les interfaces sont constituées de champs et de

méthodes ; mais, comme nous l'avons déjà dit, il existe de très fortes
contraintes sur la nature des membres d'une interface :
Toutes les méthodes sont public et abstract, les mots clés public et
abstract n'apparaissent pas : ils sont implicites.
Tous les attributs d'une interface sont public, static et final. Ils sont
là pour définir des constantes qui sont parfois utilisées dans les
méthodes de l'interface. Les mots clés static et final et public ne
figurent pas dans la définition des champs ; ils sont implicites.

Interface
Déclaration des interfaces :
Exemple :
La syntaxe de la déclaration d'une interface est la suivante :
interface Service
{
int MAX = 1024 ;
...
int une_méthode(...) ;
...
}
Interface
Interface publique :
¾ Une interface peut être qualifiée de public. Une

interface public peut être utilisée par n'importe
quelle classe.
¾ En l'absence de ce qualificateur, elle ne peut être

utilisée que par les seules classes appartenant au
même package que l'interface.

Interface
Implanter les Interfaces :
¾ Les interfaces définissent des ``promesses de services''.

Mais seule une classe peut rendre effectivement les services
qu'une interface promet. Autrement dit, l'interface toute seule
ne sert à rien : il nous faut une classe qui implante l'interface.
Une classe qui implante une interface la déclare dans son
entête
class X implements Service

{ ...
public int une_méthode(...) { ... }
...
}

Interface
Implanter les Interfaces :
¾ Par cette déclaration, la classe X promet d'implanter toutes les

méthodes déclarées dans l'interface Service. La classe X doit donc
fournir l'implantation des méthodes précisées dans l'interface Service ; on
devra donc trouver dans la définition de cette classe, l'implantation de la
la méthode une_méthode.
¾ Lasignature de la méthode doit évidemment être la même que celle

promise par l'interface. Dans le cas contraire, la méthode est considérée
comme une méthode de la classe et non une implantation de l'interface.
¾ Siune méthode de même signature existe dans la classe mais avec un

type de retour différent une erreur de compilation est générée.

Interface
Interface dérivé :
¾Mais, contrairement aux classes, une interface peut étendre
plusieurs interfaces.
interface A extends B {
...
}
interface A extends B, C, D {
...
}
¾Une interface dérivée hérite de toutes les constantes et

méthodes des interfaces ancêtres ; à moins qu'un autre
champ de même nom ou une autre méthode de même
signature soit redéfinie dans l'interface dérivée.
Interface
¾Toutcomme pour les classes, les champs des interfaces

peuvent être redéfinis dans une interface dérivée.
Exemple :
interface A { int info = 1; }
interface B extends A { int info = 2; }
¾La définition du champ info dans l'interface B masque la

définition du champ info de l'interface A. Pour parler du
champ info de l'interface A, on le notera A.info.

Interface
Héritage diamant :
¾ Un même champ peut être hérité de plusieurs manières
pour une même interface
¾ Exemple :
interface A { char infoA = 'A'; }
interface B extends A { char infoB = 'B'; }
interface C extends A { char infoC = 'C'; }
interface D extends B, C { char infoD = 'D'; }
¾ Le champ infoA est hérité par l'interface D de deux

manières : une fois par l'interface B et une autre fois par celle
de C. Mais il n'existera pas deux champs infoA dans
l'interface D ; il n'y en aura qu'un.
Package
Introduction :
¾ Un package est un ensemble de classes, d'interfaces et d'autres

packages regroupés sous un nom.
¾ Il correspondent, en quelque sorte, au concept de librairies adapté

au langage Java. Un fichier source destiné à faire partie du package
monpackage doit préciser son appartenance par la déclaration :
package monpackage ;
¾ Cette déclaration précise que toutes les classes et interfaces définies

dans ce fichier font partie du package monpackage. Elle doit apparaître
avant toute déclaration de classes et interfaces.
¾ Le nom d'un package sert de convention de nommage : il constitue une

sorte de préfixe pour chaque nom figurant dans le fichier source.

Package
Importer des packages :
¾ Lorsqu'on veut utiliser une classe d'un package, le moyen le plus direct est de
nommer cette classe par son nom absolu (fully qualified name) :
CoursJava.monpackage.Date d ;
d = new CoursJava.monpackage.Date(15, 9, 57) ;
¾ On aura compris que cette manière de faire est bien trop fastidieuse pour qu'on
s'en contente.
¾ Pour éviter cette lourdeur, Java dispose de la directive import. Il s'agit de

prévenir le compilateur que l'on risque d'utiliser des noms simplifiés pour nos
classes et qu'il devra préfixé tout seul les noms de classes quand c'est
nécessaire.
import CoursJava.monpackage.Date ; ou import CoursJava.monpackage.*;
Une fois cette classe importée, on pourra désormais utiliser les noms simplifiés
pour les classes importées.
Date d = new Date(15, 9, 57) ;

Package
Visibilité :

Package
public

Classe Interne
Classe interne non statique :

¾ Elles sont une extension du langage JAVA à partir de la version 1.1 du
JDK.
¾ Une classe peut être définie à l’intérieur d’une autre classe. Elle
constitue un membre à part entière des classes d’inclusion au même
titre que les méthodes ou les variables.
¾ Elle permet de définir une classe à l’endroit où une seule autre en a

besoin.
¾ Une classe interne peut être déclarée avec n’importe quel modificateur
d’accès (public, protected, par défault ou private) et les modificateurs
spéciaux final, abstract et static.

Classe Interne

¾ Si une classe interne est déclarée privée, ceci implique
que cette classe ne pourra être utilisée que dans la classe
parente.
¾ Une classe interne ne peut pas déclarer de membre

statique sauf s’il comporte le modificateur final.
¾ Tous les membres de la classe externe sont accessibles

dans la classe interne mêmes ceux déclarés privés.
¾ Elles sont enregistrées dans un fichier .class particulier

dont le nom est de la forme :
ClasseParente$ClasseInterne.class
Classe Interne
class ClasseParente
{
int x = 10; int y = 12;
private int addition()
{ return (x + y); }
class ClasseInterne
{
void verification()
{ if((x + y)== addition())
System.out.println("La classe interne a bien accédé aux membres de sa
classe parente.");
}}
public static void main(String[] args)

{ ClassParente obj_out = new ClasseParente();
ClasseInterne obj_in = obj_out.new ClasseInterne();
//c’est équivalent : ClasseInterne obj_in = (new ClassParente()).new ClasseInterne();
obj_in.verification();
}}

Classe Interne
class Externe {
int x = 10; int y = 12;
Externe(){ new Interne(); }
public static void main(String[] args){

new Externe();}
class Interne {
int x = 8; int y = 14;
Interne() {
if (this.x + this.y == Externe.this.x + Externe.this.y)
System.out.println( "La classe interne a bien accédé à l'ensemble des
membres des classes imbriquées.");
}
}
}

Classe Interne (exemple liste chainé)
public class Famille
{
String nom;
Maillon premier;
Famille(String nom) {this.nom=nom;}
private class Maillon

{ String prenom;
Maillon suivant;
Maillon(String prenom, Maillon suivant)
{
this.prenom = prenom;
this.suivant = suivant;
}
{
return prenom + " , " + nom;
}
}

Classe Interne (exemple liste chainé)
void inserer(String prenom)
{
premier = new Maillon(prenom, premier);
}
void affichage()
{
while (premier!=null)
{
System.out.println(premier);
premier=premier.suivant;
}
}

{
Famille f=new Famille("familleAli");
f.inserer("ali");
f.inserer("ali1");
f.inserer("ali2");
f.affichage();
}
}
Classe Interne
Classe interne locale (local inner-classes):
¾ Elles sont définies à l’intérieure d’une méthode ou d’un

bloc de code.
¾ Elles ne sont utilisables que dans le bloc de code où elle

sont définies.
¾ Elles peuvent avoir accès aux membres de la classe

englobant.

Classe Interne
Classe interne locale (local

If (obj_in.verification())
inner-classes): { x = x + y;
System.out.println("La classe
class ClasseExterne { interne a bien
accédé aux membres de la
int x = 10; int y = 12; classe extérieure.n x = " +
int z = x + y; x+ "ny = " + y + "nz = " + z);
void addition(){ }
class ClasseLocale { else System.out.println("Erreur
!");
boolean verification(){ }
if (x + y == z) return true;
else return false; public static void main(String[] args)
} {
} ClasseExterne obj_out = new
ClasseLocale obj_in = new ClasseExterne();
ClasseLocale(); obj_out.addition(); }
}}
Classe Interne
Seules les variables locales et les paramètres de la méthode d'inclusion, déclarées avec le
modificateur final, peuvent être exploitées par les classes internes locales, sinon une erreur se
produit lors de la compilation. De plus, ces variables doivent être impérativement assignées
avant leur emploi dans la classe locale.
ClasseLocale obj_in = new ClasseLocale();
class ClasseExterne { if (obj_in.verification()){
int x = 10; int y = 12;
x = x + y;
// Paramètre constant utilisable par la classe locale
ClasseExterne(final int p) System.out.println("La classe interne a
{ bien accédé aux membres de la classe
// Constante utilisable par la classe locale extérieure. nx = " + x + "ny = " + y +
final int a = 20; "na = " + a);
// Variable inutilisable par la classe locale }
int b = 44; else
class ClasseLocale {
System.out.println("Erreur !");
boolean verification(){
if(x + y == a + p) }
return true;
else public static void main(String[] args){
return false; ClasseExterne obj_out = new
}} ClasseExterne(2);
}}
Classe Interne
Lorsqu'une classe locale est déclarée dans une méthode

statique, alors les variables d'instances de la classe externe ne
sont plus accessibles pour la classe imbriquée.
Seules, les variables statiques de la classe externe peuvent

être exploitées par la classe localisée dans la méthode
statique.

Classe Interne
class ClasseExterne {
if (obj_in.verification())
static int x = 10;
{ x = x + y;
static int y = 12;
System.out.println("La classe interne
static int z = x + y;
accede aux membres statiques de
static void addition(){ la
class ClasseLocale { classe");}
boolean verification() else
{ if(x + y == z) System.out.println("Erreur !");
return true; }
else
return false; public static void main (String[] args)
}} { addition(); }
}
ClasseLocale obj_in = new ClasseLocale();

Classe Interne
Classe interne statique (static member inner

classes):
¾ Ce sont des classes internes qui ne possèdent pas de référence vers

leur classe principale.
¾ Elles ne peuvent pas accéder aux membres d’instance de la classe

englobant mais peuvent accéder au membre statique.
¾ Pour les déclarer on utilise le modificateur static dans la déclaration de

la classe.
¾ Elles sont interprétée par le compilateur comme étant une classe à part
entière.

Classe Interne
class ClasseParente {
static int x = 10; static int y = 12;
// La classe interne statique ne peut accèder à cette variable
int z = x + y;
static int addition() { return (x + y); }
// La classe interne statique ne peut accèder à cette méthode
int resultat() { return (z); }
static class ClasseInterne
{
ClasseInterne()
{
if((x + y)== addition())
System.out.println("La classe interne a bien accédé aux membres
statiques de sa classe parente.");
}
}
{ new ClasseInterne(); }
}

Classe Interne
Classe interne statique (static member inner

classes):
¾ Il n'est pas nécessaire de créer une instance de la classe
parente pour pouvoir instancier la classe intérieure statique
contrairement aux classes internes simples.
¾ Le mot-clé this n'est pas utilisable dans le contexte des

classes internes statiques, celles-ci n'ont pas accès aux
variables et méthodes non-statiques de leur classe
d'inclusion.
¾ Les méthodes d'une classe interne statique peuvent être

accédées dans la classe parente de la même façon que les
classes internes simples, c'est-à-dire, suite à l'instanciation
de leur propre classe.
Classe Interne
Classe anonyme (anonymous classes):
¾ Elles sont déclarées immédiatement après l'expression d'instanciation

d'une classe, permettant directement d'étendre ou d'implémenter
respectivement la classe ou l'interface instanciée.
¾ Ladéclaration d'une classe anonyme doit être toujours suivie d'un

point virgule immédiatement après son accolade fermante.
¾ Les classes anonymes obéissent aux mêmes restrictions que les

classes locales et de plus, ne peuvent ni être abstraites (abstract) ni
être statiques (static).
Par contre, elles portent toujours implicitement le modificateur final.
¾ En fait, aucun modificateur n'est permis dans une déclaration de

classe anonyme

Classe Interne
class ClasseExterne { obj.addition(x, y);
static int x = 10; static int y = 12; obj.soustraction(x, y);
public static void main(String[] args) obj.multiplication(x, y);
{ obj.division(x, y);
Calcul obj = new Calcul() { }
float resultat; }
public float soustraction(float a, float b) {
resultat = a - b; class Calcul {
System.out.println(resultat); public float addition(float a, float b) {
return resultat; } return a + b;
public float multiplication(float a, float b) { }
resultat = a * b; public float soustraction(float a, float b) {
System.out.println(resultat); return a - b;
return resultat; } }
public float division(float a, float b) { public float multiplication(float a, float b) {
if(b != 0){ return a * b;
resultat = a / b; }
System.out.println(resultat); public float division(float a, float b) {
return resultat; return a / b;
} }
else return 0; }
} };
Classe Interne
Classe anonyme (anonymous classes):
¾ On Pourrat remarquer que le compilateur génèrera un fichier .class de

la classe anonyme sous la forme ClasseEnglobante$1.class.
¾ Une classe anonyme ne peut déclarer explicitement un constructeur, le

compilateur Java fournissant automatiquement un constructeur anonyme
pour ce genre de classe.
¾ Une classe anonyme ne possède pas d'identificateur et est

immédiatement utilisée lors de l'instanciation de la classe ou l'interface
concernée.
¾ Dans le cas d'une implémentation, la classe anonyme doit définir

chacune des méthodes abstraites de l'interface à instancier, sinon une
erreur de compilation se produira.

Classe Interne
class ClasseExterne {
static int x = 10; static int y = 12;
obj.addition();
obj.soustraction();
public static void main(String[]
args){ obj.multiplication();
obj.division();
ICalcul obj = new ICalcul() { }
public float addition() }
{ return (x + y); }
public float soustraction() interface ICalcul {
{ return (x - y); } float addition();
public float multiplication() float soustraction();
{ return x * y; } float multiplication();
public float division() float division();
{ }
if(y != 0) return x / y;
else return 0;
}
}; en collaboration avec M.S Bouhlel
Y.Naïja Cours POO 130
Classes de base
Classe Vector
Un objet de type Vector est un tableau à taille variable (pas

de limite de taille sauf la mémoire)
Un Vector est un tableau dont les éléments dont des objets
Incluse dans bibliothèque java.util.*

Classe Vector
Quelques méthodes :
Constructeurs : ex. Vector v=new Vector()
void addElement(Object obj) : ajout de obj à la fin
void insertElementAt(Object obj, int i) : insertion de obj à la
position i
void removeElementAt(int i) : suppression de l'élémént à la
position i
void removeAllElements() : suppression de tous les
éléments
Object elementAT(int i) : retourne (sans le supprimer)
l'élément à la position i

Classe Vector
Quelques méthodes :
void setElementAt(Object obj,int i) : place l'objet à la
position i( en remplaçant l'ancien objet
boolean contains(Object obj) : retourne true si obj est
dans le tableau
int indexOf(Object obj) : retourne la position de obj (-1 si
obj n'est pas présente)
int size() : retourne la taille du vecteur

Classe Vector
Exemple d'utilisation
class test{
public class carre{
public static void main (String[] args){
private Int cote; Carre c1=new Carre(5);
public cote(int c){ Carre c2=new Carre(10);
cote=c Vector v=new Vector();
v.addElement(c1);
}
v.addElement(c2);
public int getCote(){ for(int i=0; i<v.size(); i++){
return cote; int a=( (Carre)
v.elementAt(i)).getCote().
}
System.out.println(a);
} }
}

Classe StringTokenizer
La classe StringTokenizer permet de

construire des objets qui savent découper
des chaînes de caractères en sous
chaînes
Lors de la création d'un objet de cette
classe, il faut préciser :
¾ La chaîne à découper et
¾ Les caractères qui doivent être utilisés pour découper
la chaîne
Ex : StringTokenizer st=new StringTokenizer("Voici la
liste : voiture, moto, camion.",", :.")

Quelques méthodes
Boolean hasMoreTokens() : retourne true
s'il y a encore des mots à traiter sinon
false
String nextToken() : retourne la prochaine
sous chaîne dans la chaîne à découper.

Class test(){
static void afficheMots(String s){
StringTokenizer st=new StringTokenizer(s, " ,:.")
while(st.hasMoreTokens()){
System.out.println(st.nextToken());
}
}
}
Tets.afficheMots("Voici la liste : voiture, moto, camion.")

Voici
la
liste
voiture
moto
Y.Naïja en collaboration avec M.S Bouhlel

camion Cours POO 138
Chapitre 5 :
La gestion des
exceptions
C’est quoi une exception
Une exception est un événement (une erreur) qui se produit lors de l'exécution d'un
programme, et qui va provoquer un fonctionnement anormal (par exemple l'arrêt du
programme) de ce dernier.
Soit le programme suivant :

1 public class Div1 {
2 public static int divint (int x, int y) {
3 return (x/y);
4 }
5 public static void main (String [] args) {
6 int c=0,a=1,b=0;
7 c= divint(a,b);
8 System.out.println("res: " + c);
9 System.exit(0); } }
Le système affiche l'erreur suivante:

Exception in thread "main" java.lang.ArithmeticException: / by zero
at Div.divint(Div.java:3)
at Div.main(Div.java:7)

Gestion des exceptions
La gestion des exceptions se substitue en quelque sorte à l'algorithmique permettant la
gestion des erreurs. Dans l'exemple précédent, si nous avons voulu anticiper sur la gestion
de l'erreur, il fallait prévoir un traitement adéquat pour contrer la division par zéro:
if (y!=0)
return(x/y);
else
// traitement de l'erreur.
Le traitement de l'erreur pourrait consister à retourner une valeur: -1 pour une division par
zéro, -2 pour un index qui déborde etc. Ce traitement devient fastidieux à la longue !
traitement A
if (!traitement_A) méthodes de correction
else
traitement_B
if (!traitement_B) méthodes de correction
else
etc.

Gestion des exceptions
Le langage Java offre un mécanisme très souple pour la gestion des erreurs. Ce
mécanisme permet d'isoler d'une part la partie du code générant l'erreur du reste
du programme, et d'autre part de dissocier les opérations de détection et de
traitement de cette erreur.
Par ailleurs, le langage Java utilise des objets pour représenter les erreurs
(exceptions) et l'héritage pour hiérarchiser les différents types d'exception.
La gestion des erreurs consiste donc

¾ A définir le bloc pouvant provoquer l'erreur (le bloc try), ainsi ce bloc devient isolé du
reste du programme ;
¾ A lancer (throw) ou attraper (catch) les "objets" représentant les exceptions générées.
public class Div2 {
public static int divint (int x, int y) { return (x/y); }
public static void main (String [] args) {
int c=0,a=1,b=0;
try { c= divint(a,b); }
catch (ArithmeticException e) { System.out.println("Erreur capturée"); }
System.out.println("res: " + c);
System.exit(0);}}
Hiérarchie des exceptions
Il existe deux types d’exception :

¾ Exceptions contrôlée
¾ Exception non contrôlée
Une exception non contrôlée se subdivise en deux

catégories Error et RuntimeException. Elles ne
nécessitent pas d’être capturée.
Une exception contrôlée est une exception qui doit

être capturée par le programme. Les exceptions
créées par le programmeur doivent être contrôlées
sinon une erreur de compilation sera signalée.
Object
Throwable
Error Exception
IllegalAccessException IOEcxeption
LinkageError
NoSuchMethodException
ThreadDeath RuntimeException
VirtualMachineError IndexOutOfBoundsException
NumberFormatException NullPointerException
ArithmeticException

Mécanisme de traitement des exceptions
Lorsqu'une exception est levée dans une méthode

donnée, les instructions qui suivent le lancement de
l'exception, se trouvant dans cette méthode, sont
ignorées (voir exemple en cours)
L'exception peut-être attrapée par un bloc catch (s'il

existe un try) se trouvant dans cette méthode.
Si l'exception n'a pas été capturée, le traitement de

cette exception remonte vers la méthode appelante,
jusqu'à être attrapée ou bien on est arrivé à la fin du
programme (ici nous nous trouvons au niveau de la
méthode main).

1. Une exception est levée
En dehors d'un bloc try :

¾ Dans ce cas, on remonte immédiatement
dans la méthode appelante pour lui donner la
possibilité de traiter cette exception.
¾ Si elle ne peut pas, il y a arrêt du programme.

dans un bloc try :
Un bloc try est défini et contient quelques instructions qui

risqueraient de lever une ou plusieurs exceptions.
try {
c= divint(a,b);
System.out.println ("la suite du programme!");
}
Si une instruction donnée de ce bloc try (par exemple

c=divint(a,b)) ne génère pas une exception, le programme
passe au traitement de l'instruction suivante dans ce bloc.

Par contre, si une des instructions du bloc try

provoque une exception (par exemple:
c=divint(a,b)), les instructions suivantes du bloc try
ne seront pas exécutées.
Dans le précédent exemple : System.out.println ….

ne sera pas exécutée. On sort complètement du
bloc try ; et la main sera donnée à un bloc catch …
Dans une méthode, si nécessaire, il peut y avoir

plusieurs bloc try.

2. Capturons l’exception
Un bloc catch sert à capturer un type d'exception

donné, par exemple ArithmeticException, etc. et de
réaliser des opérations comme:
¾ corriger l'erreur qui a provoqué l'exception, proposer un

traitement alternatif, retourner une valeur particulière,
sortir de l'application, relancer la même exception, faire
qu'une partie du traitement et la méthode appelante fera
le reste etc.
¾ Un bloc catch, s'il existe dans un programme, il suit

immédiatement un bloc try (donc contigu au bloc try).

Dans le cas où il n'y pas eu d'exception levée par

aucune des instructions du bloc try, l'exécution du
programme se poursuit après le dernier bloc catch.
Comme si aucun bloc catch n'a été défini dans le
programme.
Par contre, si une exception est levée, deux cas se

présentent:
¾ 1er cas :S'il existe un bloc catch qui peut capturer

cette exception, il sera exécuté en premier, puis le
programme poursuit après le dernier bloc catch.

public class Div3

{
public static void main (String [] args)
{
int c=0,a=1,b=0;
try
{ c= a/b
}
catch (ArithmeticException e)
{ System.out.println("Erreur a été
capturée"); }
}
}
¾ 2ème cas :Si aucun bloc catch ne peut

capturer cette exception, la main est
donnée à la méthode appelante. À elle de
voir si elle peut traiter cette exception,
sinon on remonte de méthode en
méthode à la recherche d'un bloc catch
adéquat, jusqu'à terminer le programme
(donc niveau main).

public class Div3
{
public static int divint (int x, int y) {
return (x/y);
}
{
int c=0,a=1,b=0;
try
{ c= divint(a,b); }
{ System.out.println("Erreur a été capturée"); }

}
}

3 … mais peut-on la lever?

Si on est sûr qu'une une opération illégale
risquerait d'avoir lieu, nous pouvons nous même
lever l'exception. Pour le faire, nous utilisons le mot
clé throw mais il faudra faire attention aux points
suivants:
¾ Les exceptions sont représentées en quelque

sorte par des "objets", instanciés donc à partir de
classes ; de ce fait, chaque exception fait
référence à une classe.
¾ Pour lever une exception, nous devons créer une
instance de la classe où réside cette exception.
Object
Throwable
Error Exception
LinkageError
ArithmeticException

public class Div3

{
{
int c=0,a=1,b=0;
try
{if (y==0) throw new ArithmeticException();
c= a/b
}
}
}
public class Div3

{
if (y==0) throw new ArithmeticException();
return (x/y);
}
{
int c=0,a=1,b=0;
try
{ c= divint(a,b); }
}
}
Req : les exceptions de type RuntimeException sont propagées automatiquement

Si nous avons affaire à une méthode susceptible de lever une exception qu'elle ne traite
pas localement, cette méthode doit mentionner son type dans son en-tête en utilisant pour
cela, le mot réservé throws.
Soit l'exception est traitée localement, soit elle est propagée par throws.
public class Div3

{
public int divint (int x, int y) throws IllegalAccessException
{ if (y==0) throw new IllegalAccessException();
return (x/y);
}
public int carré(int x, int y) throws IllegalAccessException
{ return divint(x,y)*divint(x,y); }

{ int c=0,a=1,b=0;
try { c= divint(a,b); }
catch (IllegalAccessException e) {System.out.println("Erreur capturée");}
}
}

Définir sa propre exception
Si on veut pouvoir signaler un événement

exceptionnel d’un type non prévue par java, il faut
étendre la classe java.lang.Exception.
Les méthodes utiles de la classe Exception sont :
¾ Exception() : constructeur sans argument, construit une

exception.
¾ Exception(String s) : Construit une exception avec le

message s qui sera stocké dans l’exception créée.
¾ String getMessage() : (méthode hérité de la classe

throwable), renvoie le message stocké dans une
exception.
Définir sa propre exception
class MaArithmeticException extends Exception

{
MaArithmeticException(String s)
{
super(s);
}
MaArithmeticException()
{}
{
return "Mon erreur MaArithmeticException";
}
}
Exemple : factorielle
class Factorielle
{
public int calcul(int x)
{
if(x==0)
La solutionreturn 1;
est simple,
else return
tu t’es trompé :x*calcul(x-1);
tu as
tapé -5 au lieu de 5.
} Fais attention la
Mais,
publicprochaine
static fois
void!!!
main(String[] args) pourquoi ça
{ plante …!!!
Factorielle f=new Factorielle();

System.out.println(f.calcul(-5));
}
}
Que faire ?
Si je me trompe
encore une fois ?
Quelqu’un peut-il
m’aider?

class EntierNegatifException extends Exception

{
EntierNegatifException(){}
{
return "Mon exception : entier < 0";
}
}
class EntierGrandException extends Exception
{ Simple ! Mais tu
n'as pas vu les
EntierGrandException(String s)
exceptions ???
{
super(s);
}
}
C’est tout???
C’est facile alors !!!
Non !!!!
Il manque une
dernière étape???

class Factorielle
{
public int calcul(int x) throws EntierNegatifException, EntierGrandException
{
if(x<0)
throw new EntierNegatifException();
else if (x>27)
throw new EntierGrandException("Mon exception entier > 27");
else if(x==0) return 1;
else return x*calcul(x-1);
}
{
Factorielle f=new Factorielle();
try {System.out.println(f.calcul(88));}
catch (EntierGrandException e) {System.out.println(e.getMessage());}
catch (EntierNegatifException e){System.out.println(e);}
}
}
Ordre des catch
public class Div3
{
return (x/y);
}
{
int c=0,a=1,b=0;
try
{ c= divint(a,b); }
catch (Exception e){
System.out.println("1ère exception captuerèe");
}
{ System.out.println("Cette exception ne sera jamais capturée"); }
}
}
Erreur de compilation affichée par java : Catch is never unreachable

Î Capturer les exceptions dans l'ordre suivant de la classe fille à la
classe mère
Ordre des catch
Object
Throwable
Error Exception
LinkageError
ArithmeticException

Ordre des catch
public class Div3

{
return (x/y);
}
{
int c=0,a=1,b=0;
try
{ c= divint(a,b); }
catch (ArithmeticException e) {
System.out.println("Cette exception peut être capturée"); }
catch (Exception e){
System.out.println("Aère exception capturèe");
}

}
}

Le bloc finally
On peut avoir un bloc d’instructions commençant

avec le mot clé finally :
¾ Soit après un bloc try.
¾ Soit après un bloc try suivit d’un bloc catch.
Les instructions du bloc finally sont exécutées :

¾ Dans le premier cas après la sortie du bloc try.
¾ Dans le second cas après l’exécution du bloc catch.
Il est généralement utilisé pour effectuer des

nettoyages tels que la fermeture de fichier…

Exemple

Exemple

Exemple

Chapitre 6
Les Entrées Sorties
Les E/S Généralités
Dans la plupart des langages de programmation les notions

d'entrées / sorties sont considérées comme une technique
de base, car les manipulations de fichiers, notamment, sont
très fréquentes.
En Java, et pour des raisons de sécurité, on distingue deux

cas :
¾ le cas des applications Java autonomes, où, comme dans n'importe

quel autre langage, on distingue un usage important de fichiers,
¾ le cas des applets Java qui, ne peuvent pas, en principe, accéder,

tant en écriture qu'en lecture, aux fichiers de la machine sur laquelle
s'exécute le navigateur (machine cliente).

Notion de Flux
Les E / S sont gérées de façon portable (selon les OS) grâce à la

notion de flux (stream en anglais).
Un flux est en quelque sorte un canal dans lequel de l'information

transite. L'ordre dans lequel l’information y est transmise est
respecté.
Un flux peut être :

¾ Soit une source d’octets à partir de laquelle il est possible de lire de
l'information. On parle de flux d'entrée.
¾ Soit une destination d’octets dans laquelle il est possible d'écrire de
l'information. On parle de flux de sortie.
Certains flux de données peuvent être associés à des ressources

qui fournissent ou reçoivent des données comme :
¾ les fichiers,
¾ les tableaux de données en mémoire,
¾ les lignes de communication (connexion réseau).
Notion de Flux
L'intérêt de la notion de flux est qu'elle permet une

gestion homogène :
¾ quelle que soit la ressource associée au flux de données,
¾ quel que soit le flux (entrée ou sortie).
Certains flux peuvent être associés à des filtres

¾ Combinés à des flux d’entrée ou de sortie, ils permettent
de traduire les données.
Les flux sont regroupés dans le paquetage java.io
Il existe de nombreuses classes représentant les

flux
¾ il n'est pas toujours aisé de se repérer.
Flux Octets et Flux Caractères
Il existe des flux de bas niveau et des flux de plus

haut niveau (travaillant sur des données plus
évoluées que les simples octets) :
¾ Les flux d’octets

classes abstraites InputStream et OutputStream et
leurs sous-classes concrètes respectives.
¾ Les flux de caractères

classes abstraites Reader et Writer et leurs sous-
classes concrètes respectives.

Exemples
Mme Tout ca est

bien!!!
mais comment vais-
je lire un caractère
que je viens d’écrire
au clavier ???

Exemples
La plupart des plateformes ont une notion classique

d’entrée, de sortie standard et de sortie d’erreur
standard.
En effet, un clavier, un fichier, ou la sortie d’un autre

programme peuvent représenter l’entrée standard.
Une fenêtre, une imprimante, un fichier ou l’entrée d’un

autre programme peuvent constituer la sortie standard.
La sortie d’erreurs standard sert pour afficher les

messages d’erreurs à l’utilisateur.

Exemples
First :
¾ System : La classe System possède les variables statiques in,
out et err qui sont connectées aux trois flots du système avant que le
programme commence son exécution
PrintStream out
Flot standard de sortie
InputStream in
Flot standard d’entrée
PrintStream err
Flot standard de sortie d’erreur

Exemples
Second : utiliser l’entrée standard
public char lectureChar()

{
int b=0;
try
{
b=System.in.read() ;
}
catch(IOException e){System.out.println(‘’erreur E/S’’);}
System.out.println(“Donnée lue :”+(char)b);
return (char)b;
}

Exemples
2ème possibilité
public char lectureChar()

{
char b=‘0’;
try
{
InputStreamReader isr=new InputStreamReader(System.in);
b=(char)isr.read();
}
System.out.println(“Donnée lue :”+b);
return b;
}
La classe InputStream / Reader
Cette classe abstraite InputStream représente la super

classe de toutes les classes d’entré de flux d’octet.
Parmi ces méthodes on site :
¾ public abstract int read() throws IOException : cette méthode lit un

octet sur le flux spécifié et retourne cette valeur sous la forme d’un
entier.
¾ public void close() throws IOException : cette méthode referme le flux
d’entrée et libère les ressources système.
¾ …
La classe abstraite Reader joue le même rôle que la classe

InputStream, mais elle agit sur les caractères.

Exemple
Je crois que je commence a

comprendre mais !!!
Mais si c’est une chaîne de

caractère je fais quoi???

Exemple
J’aurais besoin de quelque chose qui me

permet de stocker les valeurs
(BufferedReader) que je vais entrer au
clavier (System.in).
Î c’est ce qu’on appelle un buffer.
Il existe en java des classes prédéfinies

qui me permettent de gérer ca :
InputStreamReader, BufferedReader.

Exemple

Exemples
public String lectureChaine()

{
String res=null;
try
{
InputStreamReader isr = new InputStreamReader(System.in);
BufferedReader br=new BufferedReader(isr);
res=br.readLine();
}
System.out.println(“Donnée lue :”+res);
return res;
}

Exemples
Et maintenant pour
voir si vous avez
compris.
Comment je fais pour

lire un entier.

Exemples
public int lectureEntier()

{
int res=0;
try
{
InputStreamReader isr = new InputStreamReader(System.in);
BufferedReader br=new BufferedReader(isr);
res=Integer.parseInt (br.readLine());
}
catch(NumberFormatException e){}
catch(IOException e){}
return res;
}

La classe OutputStream / Writer
La classe abstraite OutputStream représente la super classe

de toutes les classes de sortie de flux d’octet.
Parmi ces méthodes on site :
¾ public abstract void write(int b) throws IOException : cette méthode

écrit un octet sur le flux de sortie. L’octet a écrire est passé en
paramètre a la méthode. Cette méthode est bloquante jusqu’à la
réalisation de l’écriture.
¾ public void close() throws IOException : cette méthode referme le flux

de sortie et libère les ressources système relative a ce flux.
¾ …
La classe abstraite Writer joue le même rôle que la classe

outputStream, mais elle agit sur les caractères.
Gestion des Fichiers
Exemples de méthodes pour gérer les fichiers :
¾ Les classes FileInputStream et FileOutputStream :définit

respectivement des flux d’octets en lecture et en écriture.
¾ Les classes FileReader et FileWriter : définit

respectivement des flux de caractère en lecture et en
écriture.
¾ La classe File : qui peut représenter un fichier ou un

répertoire. Elle possède un ensemble de méthodes qui
permettent d'interroger ou d'agir sur le système de
gestion de fichiers du système d'exploitation.
Flux d’octet en lecture sur un fichier
Il faut instancier un objet de la classe

FileInputStream.
Cette classe offre plusieurs constructeurs qui levent

une exception de type FileNotFoundException :
¾ FileInputStream(String nom) : ouvre un flux en lecture sur
le fichier dont le nom est donné en paramètre.
¾ FileInputStream(File f) : idem mais le fichier est précisé
avec un objet de type File.
Cette classe offre aussi plusieurs méthodes :

¾ int read() : permet de lire un octet du flux.
¾ void close() : ferme le flux et libère les ressources qui lui
étaient associé.

Flux d’octet en lecture sur un fichier
public static void main (String[] args)

{
try
{
FileInputStream f=new FileInputStream("e:\\test\\a.txt");
int octet=0;
while(octet!=-1)
{
octet=f.read();
System.out.print((char)octet);
}
f.close();
}
catch(FileNotFoundException e){ System.out.print("fichier introuvable");}
}

Flux d’octet en écriture sur un fichier
Il faut instancier un objet de la classe FileOutputStream.
Cette classe offre plusieurs constructeurs:

¾ FileOutputStream(String nom) : si le fichier précisé n’existe pas, il
sera créé. Si il existe et qu’il contient des données celles-ci seront
écrasées.
¾ FileOutputStream(String nom, boolean ajout) : le boolean permet de
préciser si les données seront ajoutées au fichier (valeur true) ou
écrasent les données existantes (valeur false).

¾ void write(int a) : permet d’écrire l’octet en paramètre dans le flux.
¾ void close() : permet de fermer le flux et libère les ressources qui lui
étaient associé.

Flux d’octet en écriture sur un fichier
{
try{
FileInputStream f=new FileInputStream("e:\\test\\a.txt");
FileOutputStream fcopy=new FileOutputStream("e:\\test\\acopy.txt");
int octet=0;
while(octet!=-1)
{
octet=f.read();
fcopy.write(octet);
}
f.close();
fcopy.close();
}
catch(FileNotFoundException e){System.out.print("errrrrrue");}
}

Flux de caractères en lecture sur un fichier
Il faut instancier un objet de la classe FileReader. Cette

classe hérite de la classe InputStreamReader.
Cette classe offre plusieurs constructeurs qui lèvent une

exception de type FileNotFoundException :
¾ FileReader(String nom) : ouvre un flux en lecture sur le
fichier dont le nom est donné en paramètre.
¾ FileReader(File f) : idem mais le fichier est précisé avec
un objet de type File.

¾ int read() : permet de lire un octet du flux.
¾ void close() : ferme le flux et libère les ressources qui lui
étaient associé.
Flux de caractère en lecture sur un fichier

{
try
{
FileReader f=new FileReader("e:\\test\\a.txt");
int octet=0;
while(octet!=-1)
{
octet=f.read();
System.out.print((char)octet);
}
f.close();
}
}

Flux de caractère en écriture sur un fichier
Il faut instancier un objet de la classe Filewriter.
Cette classe offre plusieurs constructeurs:

¾ FileWriter(String nom) : si le fichier précisé n’existe pas, il sera créé.
Si il existe et qu’il contient des données celles-ci seront écrasées.
¾ FileWriter(String nom, boolean ajout) : le boolean permet de préciser
si les données seront ajoutées au fichier (valeur true) ou écrasent les
données existantes (valeur false).

¾ void write(int a) : permet d’écrire l’octet en paramètre dans le flux.
¾ void close() : permet de fermer le flux et libère les ressources qui lui
étaient associé.

Flux de caractère en écriture sur un fichier
{
try
{
FileReader f=new FileReader("e:\\test\\a.txt");
FileWriter fcopy=new FileWriter("e:\\test\\acopy.txt",true);
int octet=0;
while(octet!=-1)
{
octet=f.read();
fcopy.write(octet);
}
f.close();
fcopy.close();
}
}

Flux de caractère tamponnés avec un fichier
Pour améliorer les performances des flux sur un fichier, la mise en tampon des
données lues ou écrites permet de traiter un ensemble de caractères
représentant une ligne plutôt que de traiter les données caractères par
caractères. Le nombre d’opération est alors réduit.
Il faut instancier un objet de la classe BufferedReader ou BufferedWriter.
Ces classes offre plusieurs constructeurs:

¾ BufferedReader(Reader a) : a correspond au flux a lire.
¾ BufferedReader(Reader a, int taille) : taille correspond a la taille du buffer.
¾ BufferedWriter(writer a) : a correspond au flux dans lequel les données sont
écrites.
¾ BufferedWriter(writer a, int taille) : taille correspond a la taille du buffer.
La classe BufferedReader offre aussi plusieurs méthodes :

¾ String readLine() : permet de lire une ligne de caractère dans le flux (\r, \n).
La classe BufferedWriter offre aussi plusieurs méthodes :

¾ void newLine() : écrit un séparateur de ligne dans le flux.
¾ void write(String ligne) : écrit une ligne dans le buffer.

Exemple

Exemple
public void lecture (String source)

{
try
{
FileReader f=new FileReader(source);
BufferedReader br=new BufferedReader(f);
String ligne;
while((ligne=br.readLine())!=null)
{
System.out.println(ligne);
}
br.close();
}
catch(FileNotFoundException e){System.out.print("errrrrreur");}
}

Exemple
public void copy (String source, String destination)
{
try
{
FileReader f=new FileReader(source);
BufferedReader br=new BufferedReader(f);
FileWriter fcopy=new FileWriter(destination);
BufferedWriter bw=new BufferedWriter(fcopy);
String ligne;
{
bw.write(ligne);
bw.newLine();
}
br.close();
bw.close();
}
catch(FileNotFoundException e){System.out.print("errrrrreur");}
}
La classe File
Voici un aperçu de quelques constructeurs et méthodes de la classe File :

¾ File (String name)
¾ File (String path, String name)
¾ File (File dir, String name)
¾ boolean isFile( ) : teste si le File courant est un fichier.

¾ boolean isDirectory( ) : teste si le File courant est un répertoire.
¾ boolean mkdir( ) : créer le répertoire présent dans le File.
¾ boolean mkdirs( ) : créer le répertoire présent dans le File et toutes l’arborescence si
elle n’existe pas.
¾ boolean exists( ) : teste l’existence du File.
¾ boolean delete( ) : supprime le File courant.
¾ boolean canWrite( ) : Teste la possibilité d’écriture sur le File.
¾ boolean canRead( ) : teste la possibilité de lecture sur le File.
¾ File getParentFile( ) : retourne le chemin du File parent, or null s’il n’y on a pas.
¾ long lastModified( ) : retourne le temps de la dernière modification du fichier.
¾ String[] list() : retourne un tableau de String représentant les noms des répertoires et
fichiers present dans le File courant.
¾ File[] listFiles() : retourne un tableau de File représentant les Files présent dans le
File courant.

Exemple

{
try
{
File fs= new File("e:\\test\\a.txt");
BufferedReader br=new BufferedReader(new FileReader(fs));
File fd= new File("e:\\test\\acopy.txt");
BufferedWriter bw=new BufferedWriter(new FileWriter(fd));
String ligne;
{
bw.write(ligne); bw.newLine();
}
br.close(); bw.close();
}
}
Exemples
Est-ce que l’utilité

de la classe File
s’arrête à ce stade?
Alors c’est pareil à

ce qui précède.

Exemples
C’est une très bonne question.
La réponse est non son utilité

dépasse ce cadre d’utilisation

Exemple : simulation de la commende dir
La méthode dir prend comme paramètre

public void dir(File rep) le répertoire a parcourir.
{
String[] names=rep.list(); Je récupère la liste des fichiers est
for(int i=0; i<names.length;i++) répertoire dans le tableau names.
{
File interim=new File(rep.getPath()+"\\"+names[i]);
if (interim.isFile())
System.out.println(names[i]);
else
System.out.println("repertoire =>"+names[i]);
}
}
On fait l’affichage adéquat On teste si le nom correspond a un

fichier ou un répertoire.

Exemples
Et maintenant pour voir si vous avais compris???
1. Ecrire une méthode qui permet de dupliquer une

arborescence.
2. Ecrire une méthode qui permet de tester si un

fichier existe dans un répertoire ou non.
3. Ecrire une méthode qui retourne le nombre

d’occurrence d’un fichier dans une
arborescence.

Hiérarchie des flux d'octets en entrée

Hiérarchie des flux d'octets en sortie

Chapitre 7
Java Data Base

Connectivity (JDBC)
Introduction
Besoin d’accès a une base de donnée à partir

d’une application JAVA.
Fournir un accès homogène aux SGBDR.
Abstraction des SGBDR cibles.
Support du langage SQL.
Simple à mettre en œuvre.

Qu’est ce que JDBC ?
Java DataBase Connectivity (Core API 1.1)
API Java adaptée à la connexion avec les bases de

données relationnelles (SGBDR).
Fournit un ensemble de classes et d’interfaces

permettant l’utilisation sur le réseau d’un ou
plusieurs SGBDR à partir d’un programme Java.
Î Indépendance vis-à-vis des fournisseurs.

L’API JDBC
Est fournie par le package java(x).sql

¾ Permet de formuler et gérer les requêtes aux
bases de données relationnelles.
¾ supporte le standard « SQL »
¾ Contient les Classes/interfaces définissant les

objets nécessaires :
à la connexion à une base de donnée
et à la création et exécution de requêtes SQL et
récupération du résultat.

Interaction avec une BD
DriverManager
Chargement du driver de la BD.
contient la requète
SQL et la transmet à
la base de données.
Connexion à la base de
charge et configure Connection
données.
permet de parcourir lesla base
le driver de
informations retournées par
de données.
la base de données dans le
cas d'une sélection de
Exécution des commandes
données
SQL. Statement
réalise la connexion
et l'authentification à
Inspection des résultats
la base (si
de données.
ResultSet
disponible).

Chargement du driver de la BD
Il existe quatre types de drivers JDBC:
1. JDBC-ODBC bridge driver : c’est un pont entre JDBC et ODBC.

ODBC (Open Data Base Connectivity) est une API de Windows
permettant d'accéder à diverses bases de données .
2. Native-API partly-Java driver : fait appel à des fonctions natives

(non Java) de l ’API du SGBDR qui sont souvent fournis par le
constructeur.
3. JDBC-Net all-Java driver : interagit avec une API réseau générique

et communique avec une application intermédiaire (middleware) sur
le serveur. Le middleware accède par un moyen quelconque aux
différents SGBDR. Il est portable car entièrement écrit en Java.
4. Native-protocol all-Java driver : utilise le protocole réseau du

SGBDR. Interagit avec la base de données via des sockets
généralement fourni par l’éditeur.

JDBC-ODBC bridge driver
Application java
Driver JDBC
Driver ODBC
Les méthodes du driver JDBC font appel à des

fonctions en langage C d'un driver ODBC.
SGBD


Native-API partly-Java driver
Application java
Partie JAVA
Driver
Partie Native
Les méthodes du driver JDBC font appel à des Protocole du

fonctions d'une bibliothèque écrite dans un SGBDR
autre langage que Java, qui accèdent au SGBD
SGBD

JDBC-Net all-Java driver
Application java
Driver en JAVA
Les méthodes du driver JDBC se Protocole du

connectent par socket au serveur middleware
middleware et lui envoient les requêtes
SQL ; le serveur middleware les traitent Serveur middleware
en se connectant au SGBD
SGBD

Native-protocol all-Java driver
Application java
Driver en JAVA
Les méthodes du driver JDBC utilisent

des sockets pour dialoguer avec le Protocole réseau
SGBD selon son protocole réseau du SGBD
SGBD

Travailler avec JDBC
1. Chargement du driver
Pour se connecter à une base de données via
ODBC, il faut tout d'abord charger le pilote JDBC-
ODBC qui fait le lien entre les deux.
¾ Utiliser la méthode forName de la classe Class :
Class.forName("sun.jdbc.odbc.JdbcOdbcDriver
");
Pour se connecter à une base en utilisant un driver

spécifique, la documentation du driver fournit le nom
de la classe à utiliser. Ex
Class.forName("oracle.jdbc.driver.OracleDri
ver");

1. Chargement du driver
Ce traitement charge le pilote et crée une

instance de cette classe.
La méthode static forName() de la classe

Class peut lever l'exception
java.lang.ClassNotFoundException.

2. Etablissement de la connexion
Pour se connecter à une base de données, il faut instancier
un objet de la classe Connection en lui précisant sous forme
d'URL la base à accéder.
La syntaxe de l’URL peut varier d'un type de base de

données à l'autres mais elle est toujours de la forme :
protocole : sous_protocole : nom
¾ protocole désigne le protocole est vaut toujours « jdbc ».
¾ sous_protocole désigne le sous protocole qui définit le mécanisme
de connection pour un type de bases de données. Ex : « odbc ».
¾ nom désigne le nom de la base de données et doit être celui saisie
dans le nom de la source sous ODBC.

Exemple :
String dbURL=‘‘ jdbc : odbc : test ’’
Connection con = DriverManager.getConnection(dbURL);
La méthode getConnection peut lever une exception

de la classe java.sql.SQLException.
Si la base a laquelle on va ce connecté nécessite un

login et un mot de passe alors :
Connection con = DriverManager.getConnection(dbURL, "Login", "Pwd");

String dbURL=‘‘ jdbc : odbc : test ’’
Mais que représente

test ?
Le nom de la base ou
quoi?



3. Accéder à la base de données

L’accès à la BD se fait a travers un objet Statement que l’on
obtient depuis l’objet Connexion.
Statement stmt = con.createStatement();
Cet objet Statement sert d’intermédiaire pour passer les

requêtes SQL à la BD.
Comment vais-je exécuter la requête alors ?


Ca dépond du type de requête qu’on a :
¾ executeQuery : pour les requêtes de sélection

(SELECT).
¾ executeUpdate : pour les requêtes INSERT, UPDATE,

DELETE, CREATE TABLE et DROP TABLE. Requête
de mise à jour dans le cas générale.
¾ execute : pour quelques cas rares (exécution de

procédures stockées)


Ex : requête de sélection
String req = "SELECT * FROM personne" ;
ResultSet rs = stmt.executeQuery ( req ) ;
Le résultat d’une requête de sélection est un ensemble de ligne
stocker dans un objet ResultSet.
Ex : requête de mise à jour

String req = "INSERT INTO personne VALUES (3,‘ali',‘salah')";
int nbMaj = stmt.executeUpdate ( req ) ;
Le résultat d’une requête de mise à jour est un entier
représentant le nombre de mise à jour effectuer.


La méthode executeQuery est susceptible de générer une exception du
type SQLException :
Î Si la requête SQL est fausse.
Î Si la requête SQL passer comme paramètre ne correspond pas a une
requête de sélection.
La méthode executeUpdate est susceptible de générer une exception du

type SQLException :
Î Si la requête SQL est fausse.
Î Ne correspond pas à une requête de mise à jour.
Si executeUpdate retourne 0 alors :

¾ La requête n’a affecter aucune ligne.
Ou
¾ La requête est une requête DDL.

4. Inspection du résultat
L’instruction :
ResultSet rs = stmt.executeQuery ( req )
Dans le cas d’une requête de sélection le résultat est stocké

dans un ResultSet.
Un ResultSet représente une abstraction d'une table qui se

compose de plusieurs enregistrements constitués de
colonnes qui contiennent les données.
Reste alors le parcours de ce ResultSet ?

Les principales méthodes de la classe ResultSet sont :
¾ getInt(int) / getInt(String) : retourne le contenu de la colonne dont
le numéro / nom est passé en paramètre sous forme d'entier.
¾ getFloat(int) / getFloat(String) : retourne le contenu de la colonne
dont le numéro / nom est passé en paramètre sous forme de nombre
flottant.
¾ getDate(int) / getDate(String) : retourne le contenu de la colonne
dont le numéro / nom est passé en paramètre sous forme de date.
¾ next() : se déplace sur le prochain enregistrement : retourne false si
la fin est atteinte.
¾ Close() : ferme le ResultSet
¾ getMetaData() : retourne un objet ResultSetMetaData associé au
ResultSet.

La méthode next() déplace le curseur sur le prochain
enregistrement.
Le curseur pointe initialement juste avant le premier

enregistrement : il est nécessaire de faire un premier appel à la
méthode next() pour ce placer sur le premier enregistrement.
Des appels successifs à next permettent de parcourir

l'ensemble des enregistrements.
Elle retourne false lorsqu'il n'y a plus d'enregistrement. Il faut

toujours protéger le parcours d'une table dans un bloc de
capture d'exception.

4. Inspection du résultat : exemple
Soit la table
personne suivante :
Elle est constituée

des tuples suivant :

4. Inspection du résultat : exemple

try
{
stmt=con.createStatement();
String req= "select * from personne" ;
rs = stmt.executeQuery (req) ;
while(rs.next())
{
System.out.print("id = "+ rs.getInt (1) +",\t ");
System.out.print("nom = "+ rs.getString (2) +",\t ");
System.out.print("prenom = "+ rs.getString (3) +"\n ");
}
}
catch(SQLException e){e.printStackTrace(); }

5. fermeture
Une fois le travail terminer on ferme toutes les connexions
ouvertes.
On utilise la méthode close() de la classe :

¾ ResultSet
¾ Statement
¾ Connection
Exemple :
try {
rs.close();
stmt.close();
con.close();
} catch(SQLException e){}

Exemple Complet :
import java.sql.*;
class Test {
public static void main(String[] args) {
Connection con=null;
Statement stmt=null;
ResultSet rs=null;
try {
Class.forName("sun.jdbc.odbc.JdbcOdbcDriver");
}catch(ClassNotFoundException e)
{System.out.println("impossible de charger le drivers");}
try {
String url="jdbc:odbc:test";
con=DriverManager.getConnection(url,"","");
}catch(SQLException e)
{System.out.println("impossible de crèer une connexion");}

Suite exemple Complet :

try {
stmt=con.createStatement();
String req="select * from personne";
rs=stmt.executeQuery(req);
while(rs.next()){
System.out.print("id = "+rs.getInt(1)+",\t ");
System.out.print("nom = "+rs.getString(2)+",\t ");
System.out.print("prenom = "+rs.getString(3)+"\n ");
}
}catch(SQLException e){e.printStackTrace(); }
try {
rs.close();
stmt.close();
con.close();
} catch(SQLException e){} } }


Cours JAVA S1 - PPT

Hochgeladen von

Dokumentinformationen

Originaltitel

Copyright

Verfügbare Formate

Dieses Dokument teilen

Dokument teilen oder einbetten

Freigabeoptionen

Stufen Sie dieses Dokument als nützlich ein?

Sind diese Inhalte unangemessen?

Copyright:

Verfügbare Formate

Cours JAVA S1 - PPT

Hochgeladen von

Copyright:

Verfügbare Formate

Cours Programmation

Orienté Objet : Java

Y.Naïja en collaboration avec M.S Bouhlel Cours POO 2

 Il a été développé par SUN.

Y.Naïja en collaboration avec M.S Bouhlel Cours POO 4

 Presque complètement objet

Y.Naïja en collaboration avec M.S Bouhlel Cours POO 5

 Dynamique et muti-tâches (ou multithread)

Y.Naïja en collaboration avec M.S Bouhlel Cours POO 6

La devise de java : écrire une fois , exécuter partout

« Write once run everywhere »

Y.Naïja en collaboration avec M.S Bouhlel Cours POO 7

Génère du code natif directement

Y.Naïja en collaboration avec M.S Bouhlel Cours POO 8

JVM JVM JVM

La machine virtuelle JAVA (JVM)

 La Java « Platform » se compose de:

¾ Les interfaces de programmation d’application (API)

Y.Naïja en collaboration avec M.S Bouhlel Cours POO 10

1.1 504 23 - Classe interne

1.2 1520 59 -Swing

1.3 1842 76 -Java SOUND

1.4 2991 135 -XML (SAX/DOM)

Y.Naïja en collaboration avec M.S Bouhlel Cours POO 11

¾ /** commentaire d’explication utilisé par javadoc

Y.Naïja en collaboration avec M.S Bouhlel Cours POO 13

 Un bloc est une suite d’instruction délimité par «{» et «}».

 Les blancs sont autorisés entre les éléments du code

Y.Naïja en collaboration avec M.S Bouhlel Cours POO 14

 1var, -maclasse, fonction-recherche, … (non valide)

Y.Naïja en collaboration avec M.S Bouhlel Cours POO 15

Abstract double int strictfp

Y.Naïja en collaboration avec M.S Bouhlel Cours POO 16

1. Les types primitifs

2. Les chaînes de caractères : Pour manipuler les chaînes de

3. Des références : Contrairement aux types primitifs qui possèdent

Y.Naïja en collaboration avec M.S Bouhlel Cours POO 17

 Catégorie caractère : Type char

Y.Naïja en collaboration avec M.S Bouhlel Cours POO 18

Type Taille Intervalle

Y.Naïja en collaboration avec M.S Bouhlel Cours POO 19

Remarque : les expression littérales flottantes sont de type

Y.Naïja en collaboration avec M.S Bouhlel Cours POO 20

 Les variables constantes : toute variable dont le type est précédé

Y.Naïja en collaboration avec M.S Bouhlel Cours POO 21

Voir document liste des opérateurs

Y.Naïja en collaboration avec M.S Bouhlel Cours POO 22

 Pour l’affectation, la donnée à droite est convertie dans le type de celle de

 On peut convertir explicitement une valeur en forçant la transformation. Le

Y.Naïja en collaboration avec M.S Bouhlel Cours POO 23

Y.Naïja en collaboration avec M.S Bouhlel Cours POO 24

l’expression du switch doit être de type compatible avec un entier. Les

la spécification du break sont nécessaire pour gérer les ruptures de

Y.Naïja en collaboration avec M.S Bouhlel Cours POO 25

Y.Naïja en collaboration avec M.S Bouhlel Cours POO 26

Y.Naïja en collaboration avec M.S Bouhlel Cours POO 27

Y.Naïja en collaboration avec M.S Bouhlel Cours POO 28

Y.Naïja en collaboration avec M.S Bouhlel Cours POO 29

 for ( ; ; ) Î boucle infinie

Y.Naïja en collaboration avec M.S Bouhlel Cours POO 30

Y.Naïja en collaboration avec M.S Bouhlel Cours POO 31

 En écrivant le code dans un simple éditeur de texte

 En utilisant un environnement de développement (IDE)

Il a été développé par SUN.

Presque complètement objet

Dynamique et muti-tâches (ou multithread)

La Java « Platform » se compose de:

Un bloc est une suite d’instruction délimité par «{» et «}».

Les blancs sont autorisés entre les éléments du code

1var, -maclasse, fonction-recherche, … (non valide)

Catégorie caractère : Type char

Les variables constantes : toute variable dont le type est précédé

Pour l’affectation, la donnée à droite est convertie dans le type de celle de

On peut convertir explicitement une valeur en forçant la transformation. Le

for ( ; ; ) Î boucle infinie

En écrivant le code dans un simple éditeur de texte

En utilisant un environnement de développement (IDE)

Créer un fichier : HelloWorld.java

C’est une notion très proche de celle de la vie courante. On

Cette vision d’un objet peut être différente en fonction de nos

Un objet est définit de la manière dont on peut

Il correspond à un certain niveau d’abstraction de la

Nous faisons tous en permanence un tel travail

Un objet est une boite noire qui offre un certain nombre de

La seule chose nécessaire pour pouvoir utiliser un objet est de

L’ensemble des méthodes proposées par un objet est appelé

L’encapsulation d’un objet par son interface permet de masquer son

L’encapsulation constitue un des points centraux de l’approche objet. En

Ex: si on freine avec la voiture on se contente d’appuyer sur la pédale

Ex:un policer invoque la méthode arrêter en levant la main et il ne

Soit la table de cuisine de Mme Fafa

Une table de cuisine est une table qui possède des

Une classe fille est définie à partir de sa mère par héritage

C’est un mot Greg « plusieurs formes ».

Signifie qu’une méthode peut être définie dans plusieurs

Ex: lorsqu’on freine dans une voiture, on sait que la fonction

Qu’est ce qu’un objet?

Un objet est caractérisé par :

Qu’est ce qu’une classe?

Toutes les méthodes sont écrites à l'intérieur de la classe

Déclaration des attributs

Déclaration des méthodes

Le nom du constructeur doit correspondre au nom de la

Chaque classe comporte au moins un constructeur. En effet,