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

Présentation au sujet: "X. BLANC & J. DANIEL Xavier.Blanc@lip6.fr , Jerome.Daniel@der.edf.fr Le langage Java X. BLANC & J. DANIEL Xavier.Blanc@lip6.fr , Jerome.Daniel@der.edf.fr."— Transcription de la présentation:

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

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 Le langage Java X.BLANC & J. DANIEL
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 Principe de fonctionnement d’un garbage collector
Plusieurs techniques ont été mises au point : comptage de référence, la technique Mark-Sweep, la technique Mark-Sweep compacte. Le langage java utilise le principe du Mark-Sweep compact. Livre de référence : « Garbage Collection, Richard Jones, Rafael Lins, éditeur : Wiley ».

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

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

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

15 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.

16 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.

17 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;

18 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.

19 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

20 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

21 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 ».

22 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.

23 Autre exemple Constructeur inutile. Appel à super inutile car
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.

24 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();

25 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 ).

26 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 { … }

27 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 { … }

28 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 { … }

29 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.

30 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.

31 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.

32 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 ».

33 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; }

34 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.

35 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; }

36 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.

37 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");

38 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 );

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

40 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

41 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 }

42 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 }

43 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

44 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();

45 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()

46 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 );

47 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; }

48 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);

49 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.

50 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.

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

52 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

53 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 »

54 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.

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

56 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.Error java.lang.Exception

57 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

58 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 );

59 pour le tableau destination
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 tableau destination nombre d'éléments a copier Index de départ pour le tableau source Index de départ pour le tableau destination Le tableau de destination doit être alloué.

60 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 »

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

62 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

63 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.

64 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 »

65 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.

66 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.

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

68 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.

69 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 ); }

70 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));

71 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.

72 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.

73 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 )

74 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();

75 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();

76 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.

77 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()

78 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 )

79 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 )

80 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.

81 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.

82 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( )

83 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.

84 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

85 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.

86 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

87 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.

88 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.

89 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 ) ; }

90 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.

91 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

92 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

93 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

94 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 )

95 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 ».

96 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.

97 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 ».

98 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 ».

99 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 »

100 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.

101 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 ».

102 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 ».

103 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.

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

105 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 ».

106 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.

107 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");

108 A l'exécution... Création du thread n°1 Création du thread n°2
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.

109 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.

110 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);

111 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.

112 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.

113 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.

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

115 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 ».

116 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(); }

117 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; }

118 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);

119 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.