fgbfg vdxdfd b xgxd bdgdg

1. Le langage Java
X. BLANC & J. DANIEL
Xavier.Blanc@lip6.fr , Jerome.Daniel@der.edf.fr

2. Plan du cours
• Introduction à “Java”
• Les bases du langage java
• Configuration de l’environnement d’exécution
• Compléments sur le langage java

3. Introduction à « Java »
Le langage Java
X.BLANC & J. DANIEL

4. Qu’est ce que « Java » ?
• Un langage de programmation interprété et compilé.
– Langage portable : pseudo-code
• Quels types d’application pour « java » ?

5. Comment cela fonctionne t’il ?
L’interprète est une machine virtuelle plus connue sous
le nom de « jvm ».

6. Le « Java Development Kit »
• Java est un langage de programmation.
• Le « Java Development Kit » est une boite à outils :
– il fournit un compilateur java
– il fournit une machine virtuelle « jvm »
– il fournit un ensemble de bibliothèques d’outils pour faciliter la
programmation.

7. Applets et applications
• Deux types de développements sont possibles :
– les Applets
il s'agit d'un programme s'exécutant par exemple au sein d'un
navigateur web. Une applet ne peut s'exécuter indépendamment et
doit être logée et activée par une autre application.
– les applications
il s'agit de programme standard et indépendant.

8. La plate-forme entreprise « java »

9. Quelques atouts de java
• Les principaux atouts de java :
– génère des applications portables,
– un langage simple et puissant,
– un langage qui introduit directement la notion de thread,
– une API très riche,
– une gestion automatique de la mémoire.

10. Notion de garbage collector
• Un garbage collector gère la désallocation de la mémoire :
– le programmeur alloue la mémoire dont il a besoin,
– le programmeur ne désalloue pas la mémoire :
• plus de risque de fuite mémoire,
• plus de risque d’utiliser un pointeur désalloué.
• Le concept de garbage collector apparaît très tôt au sein des
langages de programmation, par exemple dès 1969 dans LISP.

11. Les bases du langage java
Le langage Java
X.BLANC & J. DANIEL

12. Langage Objet
Interface
Graphique
Unzip
Zip
Open
Close
Scan
???
Button
Panel
Icon

13. Un programme Objet
Description (Class, …)
Class GUI
Class Zip
…
Instanciation (Objet : main)

14. Notion de « class »
• « java » est un langage objet et permet de définir des classes :
class nom_de_la_class
{
corps de la classe
}
• La langage « java » oblige à ce que le fichier contenant la description d'une classe
porte le nom de celle-ci.
Nous ne pourrons décrire qu'une classe par fichier.

15. Héritage de classe
• Une classe peut hériter d’une autre classe.
class nom_de_la_class extends nom_de_la_classe_mère
{
corps de la classe
}
L’héritage multiple n’existe pas en java.

16. Attributs de classe
• Un attribut est une donnée d'une classe dont la déclaration respecte la
syntaxe :
type_de_l'attribut nom_de_l'attribut [ = valeur ] ;
• Par exemple :
int a;
float pi = 3.14;
float rayon = 5;
float surface = pi * pi * rayon;

17. Les types de base
• Comme tous langages de programmation, java propose un ensemble de
types de base :
– byte,
– boolean
– short,
– int,
– long,
– float,
– double,
– char.
• Il n’existe pas en java de types non signés.

18. Méthodes
• Une fonction d’une classe est appelée « méthode ».
• En java une méthode peut retourner une valeur et avoir une liste de paramètres :
type_de_retour nom_de_méthode ( liste_des_paramètres )
{
corps de la méthode
}
• Exemple :
int addition( int a, int b )
{
return a + b;
}
Le mot clef « return » permet de renvoyer une valeur

19. Les paramètres des méthodes
• Une méthode peut avoir un nombre quelconque de paramètres.
• Tous les paramètres sont passés par valeur.
• Un paramètre ne peut pas être déclaré avec un modificateur (
abstract, final, static )
• Format d'un paramètre :
type_du_paramètre nom_du_paramètre

20. Les constructeurs de classe
• Un constructeur est une méthode automatiquement appelée lors de la
création d’une instance d’une classe.
• Si aucun constructeur n’est défini par le programmeur, java considère que
la classe est munie d’un constructeur par défaut.
• Règles des constructeurs en java :
– Les constructeurs en java portent le nom de la classe.
– Les constructeurs n’ont pas de type de retour.
– Une même classe peut avoir plusieurs constructeurs qui doivent se distinguer
par leurs paramètres.
– Si une classe hérite d’une autre classe, son constructeur doit appeler
impérativement celui de la classe mère en utilisant le mot clef « super ».

21. Exemple de constructeur
public class base
{
int add( int a, int b )
{
return a + b;
}
}
public class herite extends base
{
herite()
{ }
}
Pas de constructeur défini
Un constructeur sans paramètre est
équivalent à un constructeur par défaut.
De plus s'il n'effectue aucun traitement
il est inutile.

22. Autre exemple
public class base
{
base()
{ }
int add( int a, int b )
{
return a + b;
}
}
public class herite extends base
{
herite( int a )
{
super( );
System.out.println( "Création de herite : " + a )
}
}
Constructeur inutile.
Appel à super inutile car
la classe mère n'a qu'un
constructeur par défaut.

23. Création d ’une instance de classe
• Pour créer une instance d’une classe on utilise l’opérateur « new »
maClasse monInstance = new maClasse();
• Pour supprimer une instance d'une classe on doit affecter la référence de
celle-ci à « null »
monInstance = null;
• L'instance n'est pas détruite immédiatement mais uniquement lors de la
mise en route du garbage collector. On peut activer le garbage collector
par l'instruction :
System.gc();

24. Espace de désignation
• Plusieurs classes peuvent être rassemblés au sein d'un « package ».
• Pour indiquer qu'une classe est membre d'un package on utilise le mot clef
« package » :
package Premier;
class toto { … }
• Un package peut être vue comme un répertoire dans lequel est rangé la
classe java.
• Un package introduit un espace de désignation ( plusieurs classes peuvent
porter le même nom si elles sont placées dans des packages différents ).

25. Utilisation des « packages »
• Pour accéder à un élément défini dans un package on doit utiliser son nom
complet sauf si l'élément qui l'utilise est dans le même package :
nom_de_package . nom_de_l'élément
• Exemple :
package Exemple; package Exemple;
class toto class titi extends toto
{ … } { … }
class tutu extends Exemple.titi
{ … }

26. Arborescence de « package »
• On peut définir une arborescence de package en incluant un package dans
un autre package.
• Pour ajouter une classe dans un tel package, on utilise également le mot
clef « package » suivit du chemin désignant le package.
• Exemple :
package Exemple.SousPackage;
class toto { … }

27. Importation de « package »
• Le langage java fournit une facilité d'écriture par l'emploi de la notion
d'importation de package.
• En utilisant le mot clef « import », on importe les définitions un ou
plusieurs éléments d'un package.
• Exemple :
package Exemple; package Exemple;
class toto class titi extends toto
{ … } { … }
import Exemple.*;
class tutu extends titi
{ … }

28. Notion d’interface
• Une interface décrie un rôle qui doit ensuite être incarné par une classe.
• La syntaxe de description d'une interface est la suivante :
interface nom_de_l'interface [ extends noms d'interfaces ]
{
corps de l'interface
}
• Le corps d'une interface est une énumération de méthodes et d'attributs
sans la définition de leur code.
Supporte l'héritage multiple.

29. Implantation d'une interface
• Une classe implante une interface c'est à dire incarne un rôle.
• L'implantation consiste à développer le code associé aux méthodes
énumérées dans l'interface.
class nom_de_class implements liste_d'interfaces
{
corps de la classe
}
• Une classe pourra ensuite être manipulée par l'intermédiaire d'une
référence vers l'interface.
Une classe peut implanter plusieurs interfaces.

30. Modificateurs d’accès
• Chaque classe, constructeur, méthode et attribut peut être paramètré par un
modificateur qui peut être :
– public : accès non contrôlé
– private : accès limité à la classes ou l'interface courante
– protected : accès limité au membre du package et à ses descendantes
– friend : accès limité au membre du package. Il n'existe pas de mot clef pour ce
type de modificateur, de ce fait si aucun mot clef parmi public, private ou
protected n'est utilisé alors l'élément est considéré comme friend.
• Une interface et une classe peuvent uniquement être publiques ou friends.

31. Le modificateur « abstract »
• Une classe, une interface ou une méthode peuvent être spécifiés comme
étant abstraite en utilisant le mot clef « abstract ».
– On ne pourra pas créer d'instance d'une classe abstraite, ou d'une classe
possédant une méthode abstraite.
– De plus un classe qui possède une méthode abstraite doit obligatoirement est
marqué abstraite.
• Implicitement, toutes les interfaces sont abstraites, l'utilisation du mot clef
« abstract » est obsolète.
• Le modificateur « abstract » intervient en complément des autres
modificateurs comme « public » ou « private ».

32. Le modificateur « final »
• Une classe, un attribut, une méthode et une interface peuvent être spécifiés
comme « final ».
• On emploi le mot clef « final » pour signaler qu'un élément est final.
• Dans ce cas on ne pourra pas soit surcharger ( dans le cas d'une classe,
d'une méthode ou d'une interface ), soit modifier ( dans le cas d'un attribut
).
• Exemple :
public class Exemple
{
public final float pi = 3.14;
}

33. Le modificateur « static »
• Le modificateur « static » peut s'appliquer à une méthode ou un attribut
d’une classe. Dans ce cas, l'élément statique est partagé par toutes les
instances de la classe. On dit que l’élément est porté par la classe. Il est
aussi possible d’y accéder sans disposer d’une instance, mais directement
par la classe.
• Une méthode ou un attribut statique ne doit employer pour ses traitements
que des méthodes ou attributs statiques.
• Exemple :
public class Exemple
{
public final float pi = 3.14;
public static void float perimetre( float rayon )
{ return rayon * 2 * pi; }
}
Erreur car pi n'est pas statique.

34. L ’Attribut caché « this »
• Chaque instance de classe comporte un attribut appelé « this » qui désigne
l'instance courante de la classe.
• Cette attribut peut être utile pour retourner une référence vers l'instance ou
pour lever certaines ambiguïtés sur les identifiants.
• Exemples :
public float longueur;
public void fixeLongueur( float longueur )
{
this.longueur = longueur;
}

35. Le point d’entrée d ’une application
• Pour débuter une application on doit fournir un point d'entrée. Lorsqu'une
classe sert d'application elle doit fournir ce point d'entrée qui est une
méthode statique portant le nom de « main ».
• Ce point d'entrée doit respecter la syntaxe suivante :
public static void main( String [ ] args )
{
// Corps du point d'entrée
}
• Où « args » correspond à la liste des arguments passé depuis la ligne de
commande.

36. Chercher l'erreur(s)...
public class Exemple
{
Exemple()
{ }
private void print( String msg )
{
System.out.println( msg );
}
public static void main( String [] args )
{
Exemple ex = new Exemple();
ex.print("Bonjour");
}
}

37. Chercher et toujours chercher...
public class Disque
{
public static final float pi = 3.14;
public static final float rayon = 5;
public static void fixeRayon( float rayon )
{
this.rayon = rayon;
}
public static void main( String [] args )
{
System.out.println("Valeur de PI = " +Disque.pi );
}
}

38. Un premier essai...
• Développer une classe représentant un agenda.
• A quoi ressemblerait un agenda réparti ?

39. Les tests de conditions
• Les tests de conditions en java sont équivalents à ceux
du C ou du C++ :
if ( condition )
// Bloc d'instruction si la condition est vraie
else
// Bloc d'instruction si la condition est fausse

40. Les choix multiples
• On peut également utiliser une structure à choix
multiples :
switch ( type )
{
case valeur :
// Bloc d'instructions
default :
// Bloc d'instructions par défaut
}

41. Les boucles
• Plusieurs types de boucles existent en java au même titre qu'en C ou C++ :
for ( compteur; max; increment )
// Bloc d'instructions
while ( condition )
// Bloc d'instructions exécuté tant que la condition est vraie
do
{
// bloc d'instructions exécuté tant que la condition est vraie
}
while ( condition )

42. Les aspects objets du langage
• Le langage java est un langage objet qui propose une classe de base
appelée : « java.lang.Object »
• Pour connaître le type réel d'un objet on utilise l'opérateur
« instanceof ».
if ( obj instanceof maClasse )
// Bloc d'instructions
Toutes les classes java héritent
implicitement de java.lang.Object

43. Conversion de types
• La conversion de type ( « cast » ) est une technique fondamental de
la programmation :
– Pour convertir un type en un autre on respecte la syntaxe suivante :
( type de convervion ) type_a_convertir
– Attention la conversion est uniquement possible si le type à convertir
est lié au type de conversion.
• Exemple :
java.lang.Object obj = ( java.lang.Object ) new maClasse();

44. Les types de base sous forme objet
• Une série de classe sont définies pour encapsuler les types de bases :
– Short
– Integer
– Long
– Float
– Double
– Charactere
– Byte
• Chacune de ces classes proposes des opérations pour passer d'un type à
l'autre. Par exemple la classe « Integer » comporte les opérations :
– intValue()
– shortValue()
– floatValue()

45. Constat
public class Exemple
{
public void carre( int valeur )
{
valeur = valeur * 2;
}
public static void main( String [] args )
{
Exemple ex = new Exemple();
int val = 2;
ex.carre( val );
System.out.println("Valeur au carré = " + val );
}
}

46. Mise en place de paramètres en sortie
public class Exemple
{
public void carre( IntConteneur val )
{
val.valeur = val.valeur * 2;
}
public static void main( String [] args )
{
Exemple ex = new Exemple();
IntContener val = new IntConteneur(2);
ex.carre( val );
System.out.println("Valeur au carré = " + val.valeur );
}
}
public class IntConteneur
{
public int valeur;
}

47. L'opération « finalize »
• L'utilisation d'un garbage collector ne supprime pas l'intérêt d'utiliser un destructeur
( rappel : un destructeur est une opération appelée automatiquement à la destruction
d'une instance ).
• L'opération « finalize » est appelée automatiquement par la machine virtuelle au
moment de la destruction de l'instance par le garbage collector.
protected void finalize()
{
// Code de finalize
}
• Il n'est pas obligatoire de fournir une opération « finalize ».
• Deux opérations sont à connaître :
– System.runFinalization();
– System.runFinalizersOnExit(true);

48. Notion d’exception
• Une exception modélise un contexte d'anomalie.
• Une exception est générée par l'application lorsqu'un problème
survient.
• Une exception est interceptée et traitée par l'application au moyen
de gestionnaires d'exceptions.
Fourni un mécanisme puissant pour
personnaliser la gestion des erreurs.

49. Créer une exception
• Toutes les exceptions utilisateurs doivent hériter de la classe
standard « java.lang.Exception »
• Cette Exception propose deux constructeurs :
– un constructeur par défaut
– un constructeur qui prends en paramètre une chaîne de caractères (
String ) qui correspond à un message d'information concernant
l'exception.

50. Exemple d'exception
Public class monException extends java.lang.Exception
{
public monException()
{ }
public monException( String msg )
{
super(msg);
}
}

51. Générer une exception
• Lorsqu'une méthode peut générer une exception elle doit le
signaler au moyen de la clause « throws » :
[ modificateur ] type_de_retour nom_de_methode ( liste_des_parametres )
throws liste_des_exceptions
• Pour générer l'exception, on utilise l'instruction « throw » :
throw new monException("Un exemple d'exception");
L'énumération des exceptions possibles est obligatoire

52. Intercepter les exceptions
• Pour intercepter une exception on emploi un gestionnaire
d'exception.
• Syntaxe d'un gestionnaire d'exception :
catch ( nom_de_l'exception_a_intercepter identifiant )
{
// Traitement de l'exception
}
• Un gestionnaire d'exception suit bloc d'instructions entamé par le
mot clef « try »

53. Exemple d'interception d'une exception
try
{
// Code surveillé par le bloc « try »
}
catch ( monException ex )
{
System.out.println("Une exception a été interceptée…");
ex.printStackTrace();
}
Imprime des informations sur l'état de
l'exécution au moment de la génération
de l'exception.

54. Mais quel problème ?
try
{
// Bloc d'instructions surveillé par « try »
}
catch ( java.lang.Exception ex )
{
ex.printStackTrace();
}
catch ( monException ex )
{
ex.printStackTrace();
}

55. Les erreurs java
• Une « erreur » est un concept proche de celui de l'exception dans la
terminologie « java ».
• Une erreur symbolise un problème survenu au sein de la machine virtuelle.
• Les erreurs héritent toutes de « java.lang.Error ».
• Une erreur est interceptée de la même façon qu'une exception.
java.lang.Throwable
java.lang.Exception
java.lang.Error

56. Quelques exceptions et erreurs standard !
• Parmi les exceptions standards les plus rencontrées on distingue :
– java.lang.NullPointerException
– java.lang.ClassCastException
– java.lang.ArrayIndexOutOfBoundsException
• Les erreurs standards les plus courantes :
– java.lang.OutOfMemory
– java.lang.StackOverflow

57. Les tableaux
• On peut définir un tableau sur tous les types java ( types primitifs,
classes, interfaces, tableaux ).
• Syntaxe de définition d'un tableau :
type [ ] nom;
• Un tableau est un objet qui contient un attribut indiquant sa taille :
« length »
int [ ] tab = new int[50];
System.out.println("Taille du tableau " + tab.length );

58. Copier un tableau
• Pour copier un tableau, on utilise l'opération « System.arraycopy »:
System.arraycopy( source, position, destination, position, nombre );
• Exemple
System.arraycopy( liste, 0, tmp, 0, liste.length );
tableau source
Index de départ
pour le tableau source
tableau destination
Index de départ
pour le tableau destination
nombre d'éléments
a copier
Le tableau de destination doit être alloué.

59. A vous de jouer...
• Mettre en œuvre la classe « List » qui gère une liste bornée
d'éléments quelconques et qui propose les opérations suivantes :
– addItem
– removeItemAt
– getItemAt
– removeAllItems
– size
Cette classe appartiendra au package « istm.util »

60. Configuration de l’environnement
Le langage Java
X.BLANC & J. DANIEL

61. Distribution des applications java
• Tous les fichiers « .class » issus de la compilation peuvent être
rassemblés au sein d'un fichier d'archivage :
– soit de type ZIP
– soit de type JAR ( Java Archive )
• Pour créer une archive JAR, on utilise la commande « jar » qui est
similaire à la commande « tar » d'unix et qui prends à ce titre les
mêmes paramètres :
tar [xvfuct] nom_de_l'archive liste_de_fichiers

62. Configuration de l’environnement
• Pour exécuter une application, la machine virtuelle java doit savoir où sont
stockées les classes à utiliser.
• Utilisation de la variable d'environnement « CLASSPATH ».
– Peut contenir des chemins absolus ou relatif,
– Peut énumérer des noms de fichiers ZIP ou JAR.
• A partir du JDK 1.2 il n'est plus nécessaire d'ajouter dans le CLASSPATH
le chemin des classes standards du JDK.

63. Arborescence réelle des packages
• A l'issu de la compilation, un répertoire est créé pour chaque
package.
• Il en résulte une arborescence réelle à partir de l'arborescence
logique utilisée dans la programmation.
• La répertoire qui contient l'arborescence doit être placé dans le
variable d'environnement « CLASSPATH »

64. Compilation d'une application java
• Pour compiler une application avec le JDK, on utilise l'utilitaire « javac ».
• Syntaxe de javac :
javac [ options ] nom_application
• Quelques options de cet utilitaire :
– -version : affiche le version du compilateur,
– -classpath : spécifie un CLASSPATH pour cette compilation,
– -sourcepath : spécifie un chemin ou sont contenus des fichiers java pouvant
être nécessaires à la compilation.

65. Exécution d'une application java
• Pour exécuter une application java à partir du JDK, on doit emploi
l'utilitaire « java ».
• Syntaxe de « java »
java [ options ] nom_de_l'application.class arguments
• Options
– -Dxxxx=yyyyy : définie une variable d'environnement qui sera accessible pour
un programme,
– -cp : spécifie un CLASSPATH spécifique pour l'exécution.

66. Compléments sur java
Le langage Java
X.BLANC & J. DANIEL

67. Les classes internes
• Une classe interne ( uniquement depuis java 1.1 ) est une classe qui
comporte deux propriétés fondamentales :
– Une classe interne peut être définie à l’intérieur d ’une classe comme
un membre ( au même titre qu’une méthode ), ou bien au sein d’un
bloc d’instructions ( par exemple dans un méthode )
– La visibilité d’une classe interne est la même que celle d’un attribut
d’une classe.
Par conséquent, si la classe interne est définie au sein d’un
bloc d ’instruction, elle n’est utilisable que depuis ce bloc.

68. Les classes anonymes
• Une classe anonyme est une classe interne définie sans préciser son
nom.
• Ce type de classe s’utilise essentiellement dans la gestion des
événements dans le cas des interfaces graphiques.
• Exemple :
interface Exemple
{
public int add( int nb1, int nb2 );
}

69. Exemple de mise en œuvre
d’une classe anonyme
public class ClasseAnonyme
{
public Exemple donneEx()
{
return new Exemple()
{
public int add( int nb1, int nb2 )
{ return nb1+nb2; }
};
}
public static void main( String [] args)
{
System.out.println("Addition 6+2 =" + new ClassAnonyme.donneEx().add(6,2));
}
}

70. Les classes statiques
• Une classe interne peut être marquée « static ».
• Une classe interne ne peut pas :
– contenir une classe interne statique,
– définir une variable statique.
• Une classe interne statique est appelée « classe principale
imbriquée ».
– Une telle classe est uniquement accessible depuis sa classe englobante
et permet la construction d’un ensemble de classes cohérentes.

71. Les entrées-sorties
• Le package « java.io » permet de gérer les opérations d’entrées /
sorties.
• Parmi les classes et interfaces du package « java.io » on distingue
essentiellement deux catégories :
– les entrées : dans ce cas, toutes les classes héritent de la classe
« java.io.InputStream »
– les sorties : ici c ’est « java.io.OutputStream ».
• Les entrés/sorties en java sont très simple à gérées et permettent
facilement d’utiliser l’écran, le clavier, les fichiers.

72. Les classes
« java.io.InputStream » et « java.io.OutputStream »
• « InputStream » une classe abstraite qui offre les prototypes des
méthodes pour toutes les opérations sur un flux d’entrée.
• « OutputStream » est également une classe abstraire permettant des
opérations sur un flux en sortie.
• Le flux d’entrée est quelconque ( clavier, fichier, socket ).
• Le flux de sortie est quelconque ( écran, fichier, socket )

73. La classe « java.io.BufferedOutputStream »
• Cette classe permet d’écrire dans un flux de sortie des séries
d’octets.
• Constructeur :
BufferedOutputStream( OutputStream out );
• Les principales opérations de cette classe sont :
– void write( byte [] buffer, int offset, int length );
– void flush();

74. La classe « java.io.BufferedInputStream »
• Permet la lecture de séries d’octet depuis un flux d’entrée.
• Constructeur :
BufferedInputStream( InputStream in )
• Les principales méthodes de cette classe sont :
– int read( byte [] buffer, int offset, int length );
– long skip( int n )
– void reset();

75. La classe « java.io.PrintWriter »
• Cette classe permet d’écrire des informations dans un flux de sortie
( OutputStream ).
• Constructeurs :
PrintWriter( OutputStream out )
PrintWrtier( OutputStream out, boolean autoflush )
• Les principales méthodes de cette classe sont :
– void print( xxxx value ) : écrit une donnée de type xxxx ( xxxx est un
des types primitifs de java auxquels s’ajoutent String, Object )
– void println( xxxx value ) : même principe que « print » avec un
retour à la ligne après écriture.

76. L’opération « toString »
• Lorsqu’un objet est passé à la méthode « print » ( ou « println » ),
l’opération « toString » de celui-ci est automatiquement appelée.
• Une opération « toString » est définie par défaut dans la classe
« java.lang.Object ».
• La signature de cette opération est :
public String toString()

77. Les flux d’entrée et de sortie standards
• Le flux d ’entrée standard est accessible depuis l ’attribut statique
« in » de la classe « java.lang.System ». Il s’agit d’un InputStream
qui symbolise par défaut le clavier.
• Il existe deux flux standards de sortie ( ces deux flux sont
implantés par des « PrintWriter » ):
– out : qui est un attribut statique de la classe « System » et qui par
défaut l’écran
– err : est également un attribut statique qui symbolise le flux de sortie
pour les erreurs ( par défaut, c’est également l’écran )

78. Lecture et écriture de données
• Pour lire et écrire des données on utilise respectivement les classes
( définies dans le package java.io ) :
– DataInputStream
– DataOutputStream
• Ces classes offres des méthodes readXXX et writeXXX pour lire et
écrire des types primitifs java ainsi que UTF ( type String ).
• On crée une instance de ces classes à partir de InputStream et
OutputStream :
– DataInputStream( InputStream in )
– DataOutputStream( OutputStream out )

79. Mise en œuvre des connaissances !
• Ecrire une application qui lit depuis le flux d’entrée
standard une chaîne de caractère et qui affiche à l’écran
le contenu de celle-ci.

80. Les fichiers
• On peut facilement créer un fichier à partir de la classe
« java.io.File » :
• Pour écrire ou lire des données depuis un fichier, on utilise les
classes :
– java.io.FileInputStream
– java.io.FileOuputStream
• Ces classes jouent un rôle identique à « InputStream » et
« OutputStream » dont elles héritent.

81. La classe « java.io.File »
• Les principales opérations de cette classe sont :
– boolean canRead()
– boolean canWrite()
– boolean delete()
– boolean exists()
– boolean isDirectory()
– boolean isFile()
– boolean renameTo( File dest )
– long length()
– boolean mkdir()
– boolean mkdirs()
– String getName( )

82. Encore à vous...
• Cette fois-ci, il s’agit d’écrire une méthode qui lit le contenu d’un
fichier texte et qui affiche celui-ci à l ’écran.

83. Le package « java.util »
• Le package java.util est l'un des packages les plus couramment
utilisé par les programmeurs java.
• Ce package inclus diverses classes qui offrent des fonctionnalités
très utiles :
– vecteur,
– table hash codée,
– pile,
– dictionnaire,
– manipulation de date, de chaîne de caractères

84. Les énumérations
• Une énumération correspond à une liste d’éléments accessibles
séquentiellements.
• Une énumération est définie par l’interface
« java.util.Enumeration » et propose les deux opérations suivantes :
– boolean hasMoreElements() : retourne « true » si l’énumération
comporte encore des éléments.
– Object nextElement() : récupère l’élément suivant de l’énumération.
• Plusieurs opérations de l’API java retournent une énumération afin
de parcourir une liste de valeurs.

85. Les vecteurs
• La classe « java.util.Vector » offre les fonctions permettant de
gérer une séquence de données ( de type java.lang.Object ).
• Parmi les méthodes proposées par cette classe on a :
– void addElement( Object obj ) : ajoute un nouvel élément au vecteur.
– int size() : retourne le nombre d’éléments du vecteur
– Object elementAt( int index ) : retourne l’élément demandé.
– void removeAllEmements() : supprime tous les éléments.
– void removeElementAt( in index ) : supprime un élément à un index
du vecteur
– Object lastElement() : retourne le dernier élément du vecteur.
– Enumeration elements() : retourne l’ensemble des éléments du vecteur

86. Les tables hash codées
• Une table hash codée est mise en œuvre par l’intermédiaire de la
classe « java.util.Hashtable ».
• Une table hash permet d’insérer des éléments dans un tableau en
fonction d’une clef. Pour récupérer l'élément on doit fournir la clef.
• Les éléments et les clefs sont du type « java.lang.Object ».
• Un hash code est calculé à partir de la clef, qui par la suite sert
d’index de l’élément au sein du tableau.

87. Les principales méthodes de
« java.util.Hashtable »
• Parmi les méthodes de « java.util.Hashtable », les suivantes sont
les plus utilisées :
– void clear() : supprime tous les éléments de la table,
– Enumeration elements() : retourne sous forme d’une énumération tous
les éléments de la table,
– Enumeration keys() : retourne cette fois ci toutes les clefs,
– Object put( Object key, Object value ) : ajoute un élément dans la
table
– Object get( Object key ) : récupère un élément de la table,
– int size() : nombre d ’éléments dans la table,
– Object remove( Object key ) : supprime un élément.

88. Mise en pratique… et hop...
• Implanter l’interface « Pratique », c’est à dire mettre en œuvre
l ’opération « displayElements » qui affiche l’ensemble des
éléments d’un vecteur ou d’une table hash codée.
Interface Pratique
{
public void displayElements( java.lang.Object object ) ;
}

89. Les propriétés
• Une propriété ( property ) est l’association d’un nom et d’une
valeur.
• On distingue deux types de propriétés :
– les propriétés utilisateurs,
– les propriétés systèmes.
• La classe « java.util.Properties » permet la gestion des propriétés.
Les principales méthodes de cette classe sont :
– String getProperty( String key ) : retourne la valeur d’une propriété en
fonction de son nom
– Enumeration PropertyName() : retourne la liste des noms de
propriétés
– void list( PrintStream out ) : écrit dans le flux de sortie la liste des
propriétés.

90. Les propriétés systèmes
• Il existe un ensemble prédéfini de propriétés systèmes qui sont
accessible à partir de la classe « java.lang.System ».
• Pour récupérer les propriétés systèmes on utilises les méthodes
suivantes :
– String getProperty( String key );
– Properties getProperties();
• Parmi les propriétés systèmes on a :
– java.class.path
– user.home
– java.home

91. Les fichiers de propriétés
• Un fichier de propriétés énumère un ensemble de propriétés.
• Pour charger les propriétés sauvées dans un fichier, on fait appel à
la méthode « load » de la classe « java.util.Properties ».
void load( InputStream in );
• Exemple de fichier de propriétés :
# Exemple commentaire dans un fichier de propriétés
Nom=Dupont
Age 21

92. La classe « java.lang.String »
• La classe « String » permet la manipulation des chaînes de
caractères.
• Voici quelques unes des opérations les plus usitées de cette classe :
– int length() : retourne la taille de la chaîne
– char CharAt(int index ) : retourne un caractère de la chaîne
– int hashCode() : retourne une code hash pour la chaîne
– String toUpperCase() : retourne une chaîne équivalente en majuscule
– String toLowerCase() : retourne une chaîne équivalente en minuscule
– boolean startsWith( String prefix ) : retourne « true » si la chaîne est
préfixée de la chaîne passée en paramètre
– boolean endsWith( String suffix ) : retourne « true » pour un suffixe

93. Manipulation de chaîne de caractères
• Des méthodes supplémentaires de la classe « java.lang.String »
permettent la manipulation des chaînes de caractères :
– String substring( int begin_index )
– String substring( int begin_index, int end_index )
– int indexOf( char c, int from_index )
– int indexOf( String s, int from_index )
– int lastIndexOf( char c )
– int lastIndexOf( String s )

94. Encore à vous de jouer...
• A partir d ’un vecteur qui contiendrait une liste de noms, écrire une
fonction capable d’en extraire tout ceux qui commence par « esi ».

95. La classe « StringTokenizer »
• Cette classe découpe une chaîne en sous-chaînes appelés « token ».
• Pour effectuer le découpage, on doit fournir une liste de séparateur qui
correspondent aux délimiteurs entres les sous-chaînes :
StringTokenizer st = new StringTokenizer( chaîne, séparateur )
• Les méthodes de cette classe sont :
– int countTokens() : retourne le nombre de tokens
– boolean hasMoreTokens() : retourne « true » si des tokens sont encore
disponibles
– String nextToken() : récupère le prochain token.

96. La sérialisation
• Sérialiser un objet c’est le sauvegarder dans un flux de sortie.
– Sauvegarder l’ensemble de ses attributs,
– Sauvegarder l’ensemble des informations le caractérisant.
• Désérialiser c’est à partir de données issues d’un flux d ’entrée,
régénérer un objet.
• Le principe de sérialisation permet de rendre les objets java
« persistant ».

97. Qu’est ce qui est sérialisable ?
• Tous les objets du langage java sont sérialisables.
• Quasiment toutes les classes de l’API java dont la persistance
s’avère judicieuse implantent cette classe.
• L ’interface « java.io.Serializable » ne comporte aucune opération.
Pour être sérialisable, une classe doit tout simplement
implanter l’interface « java.io.Serializable ».

98. Comment sérialiser un objet ?
• Pour sérialiser un objet, on utilise la classe
« java.io.ObjectOutputStream ».
ObjectOutputStream( OutputStream out )
• Cette classe offre l’opération suivante pour sérialiser un objet :
void writeObject( Object obj );
Dans ce cas l’opération « writeObject » n’appelle plus
« toString » sur l’objet mais sérialise celui-ci.
L ’objet passé en paramètre de la méthode « writeObject »
doit impérativement implanté l’interface « java.io.Serializable »

99. Comment désérialiser un objet ?
• La désérialisation fait appel à la classe
« java.io.ObjectInputStream » :
ObjectInputStream( InputStream in )
• Cette classe offre l’opération « readObject » pour désérialiser un
objet :
Object readObject();
• La désérialisation entraîne la création d’une instance du type de
l’objet sérialisé. Ceci implique que le code de l’objet à désérialiser
( donc le fichier .class ) existe.
Les opérations de sérialisation et de désérialisation peuvent générées
plusieurs sortes d’exceptions.

100. Les modificateurs « transient » et « static »
• Lorsqu’un attribut d’une classe est marqué « transient », celui-ci
n’est pas sérialisé.
transient type_de_l’attribut nom_de_l’attribut;
• Les attributs « static » ne sont pas non plus sérialisables.
Attention aux utilisations de la sérialisation avec des classes
qui possèdent des attributs « static ».

101. A vous de jouer… à votre âge !
• Mettre en place une première méthode qui sérialise un vecteur, puis
une seconde méthode qui effectue la désérialisation.
Remarque
La classe vecteur implante l’interface « java.io.Serializable ».

102. Les threads
• Dans un environnement mutlti-tâches, plusieurs processus peuvent
s'exécuter en parallèle.
• Dans une application mutli-threads, plusieurs activités peuvent
s'exécuter en parallèles.
• Par exemple plusieurs fonctions d'une application peuvent s'exécuter en
même temps.
• Un « thread » est également appelé activité ou processus léger.

103. Notion de threads
Un processus avec
un seul thread
Il faut voir une processus comme le code correspondant au programme.
Le thread est l'entité qui exécute le code.
Un processus multi-threads
Thread 1 Thread 3
Thread 2
Toute application comporte au moins un thread appelé
« thread pincipal ».

104. Définir un thread
• Définir un thread revient à créer une activité d'exécution pour un
processus.
• La définition d'un thread revient à créer une classe qui hérite de
« java.lang.Thread ».
• Le fait de créer une instance de la classe qui implante « java.lang.Thread »
n'entraîne pas la création d'un thread.
• Pour créer un thread, on doit appeler la méthode « start »
• L'appel à « start » entraîne la création du thread et le début de son
traitement qui commence par la méthode « run ».

105. Un exemple de thread
public class monThread extends java.lang.Thread
{
// …
public void run()
{
// Traitement du thread.
}
// ...
}
La sortie de la méthode « run » met fin à la vie du Thread.

106. Exemple d'utilisation d'un thread
public class ExempleThread extends java.lang.Thread
{
public static int threadCompteur = 0;
public int numThread = 0;
public int count = 5;
public ExempleThread()
{
numThread = ThreadCompteur++;
System.out.println("Création du thread n°" + numThread );
}
public void run()
{
while ( count != 0 )
{
System.out.println("Thread n°" + numThread + " , compteur = " + count-- );
}
}
public static void main( String [] args )
{
for ( int i=0; i<3; i++ )
new ExempleThread().start();
System.out.println("Tous les threads sont lancés");
}
}

107. A l'exécution...
Création du thread n°1
Création du thread n°2
Création du thread n°3
Thread n°1, compteur = 5
Thread n°2, compteur = 5
Thread n°2, compteur = 4
Thread n°2, compteur = 3
Thread n°3, compteur = 5
Thread n°1, compteur = 4
Tous les threads sont lancés
Thread n°3, compteur = 4
...
L'ordonnancement est imprévisible.

108. Interruption et reprise d'un Thread
• On peut interrompre un thread par l'intermédiaire de l'opération
« suspend ».
• Pour relancer l'exécution d'un thread, on fait appel à la méthode
« resume ».
• On peut également marquer une pause dans l'exécution d'un thread en
employant l'opération « sleep ».
• Enfin, un thread peut attendre la fin d'un autre thread en appliquant
l'opération « join » sur le thread en question.

109. Autre opérations d'un thread
• Pour arrêter un thread on utilise l'opération « stop » :
public final void stop();
• Pour connaître la priorité d'un thread, on emploi la méthode
« getPriority » :
public final int getPriority();
• De plus, pour fixer la priorité d'un thread, on utilise « setPriority » :
public final void setPriority(int newPriority);

110. Comment récupérer le thread courant ?
• Lorsqu'une méthode est exécutée, elle peut l'être par plusieurs
threads.
• Pour connaître le thread courant, elle peut utiliser l'opération
« currentThread » :
public static Thread currentThread();
• A partir de la référence vers le thread récupéré, on peut appliquer
toutes les opérations traditionnelles aux threads.
L'opération « currentThread » peut être également
utilisée pour récupérer le thread principal.

111. Accès concurrents
• Que se passe t'il si plusieurs threads accèdent à la même méthode ou à la
même ressource au même instant ?
– Comportement imprévisible selon les applications
– problématique des accès concurrents
• Pour qu'une méthode ne soit pas utilisée par plus d'un thread à la fois, il
faut la spécifier « synchronized » :
synchronized type_de_retour nom_methode ( liste des paramètres )
Un même thread pourra tout de même appeler
récursivement cette opération.

112. Les verrous
• Un verrou ( en anglais « mutex » ) est un concept qui lorsqu'il est
activé empêche les threads qui n'ont pas activés le verrou d'utiliser
le code verrouillé.
• Tant que le verrou n'est pas levé, seul un thread peut être actif dans
le code verrouillé.
• Chaque objet java peut servir de verrou.
• Comment créer une zone verrouillée ?
– On applique « synchronized » sur un objet.

113. Exemple de verrou
java.lang.Object verrou = new java.lang.Object();
synchronized ( verrou )
{
// Zone verrouillée.
}
On pourrait très bien écrire :
synchronized ( this )
{
// Zone verrouillée.
}

114. L'interface « java.lang.Runnable »
• Pour définir un thread, on peut également implanter l'interface
« java.lang.Runnable » plutôt que d'hériter de « java.lang.Thread »
• Cette interface définie l'opération « run » qui doit être implantée et qui
correspond à la méthode appelée au lancement du thread.
• Pour créer un thread à partir d'une classe qui implante « Runnable », on
doit créer une instance de « java.lang.Thread » qui prenne en paramètre
une référence vers cette classe.
public Thread(Runnable target);
On ne peut pas appliquer les opération de « Thread »
directement sur une classe qui implante « Runnable ».

115. Exemple de thread utilisant « Runnable »
public class monThread implements Runnable
{
public void run()
{ // … }
public static void main( String [] args )
{
Thread t = new Thread( new monThread() );
t.start();
}
}

116. Le JDK 1.2 et les opérations sur les threads
• Plusieurs opérations sont notés « deprecated » dans le JDK 1.2.
• En particulier les opérations « suspend » et « resume » ne doivent
plus être utilisées.
– Utiliser à la place une synchronisation à partir d'un verrou.
• De plus, l'opération « stop » est également déconseillée au profit de
l'utilisation d'une variable :
public void run()
{
while ( stop != true )
{ // … }
}
public void stop()
{ stop = true; }

117. Les threads démons
• Lorsqu'une application créée un thread, celle-ci reste bloquée tant que le
thread ne meurt pas.
• Pour éviter cela, il est possible de signaler qu'un thread joue le rôle de
démon.
• Lorsqu'une application termine, tous les threads démons sont alors
stoppés.
• Pour signaler le fait qu'un thread est un démon, on doit lui appliquer
l'opération « setDaemon » :
public final void setDaemon(boolean on);

118. Courage c'est la dernière fois...
• Développer une application qui comporte deux threads. Les threads
partageront la même ressource dont l'interface est :
interface Ressource
{
public void ouvrir();
public void fermer();
public boolean est_ouvert();
}
• Les threads travailleront de la façon suivante :
– un premier qui applique ouvrir puis fermer sur la ressource commune,
– un second qui applique fermer puis ouvrir sur la ressource.
– chaque thread doit vérifier l'état de la ressource après chaque traitement.
– Les traitements sont infinis.