Le langage Java X BLANC J DANIEL Xavier

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

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

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

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

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

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.

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.

La plate-forme entreprise « java »

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.

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.

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

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

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

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.

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.

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 * rayon;

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.

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

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

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

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.

Autre exemple public class base { base() {} Constructeur inutile. 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) } } Appel à super inutile car la classe mère n'a qu'un constructeur par défaut.

Création d ’une instance de classe • Pour créer une instance d’une classe on utilise l’opérateur « new » ma. Classe mon. Instance = new ma. Classe(); • Pour supprimer une instance d'une classe on doit affecter la référence de celle-ci à « null » mon. Instance = 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();

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

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; class toto {…} class titi extends toto {…} class tutu extends Exemple. titi {…}

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. Sous. Package; class toto { … }

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; class toto {…} class titi extends toto {…} import Exemple. *; class tutu extends titi {…}

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 Supporte l'héritage multiple. } • Le corps d'une interface est une énumération de méthodes et d'attributs sans la définition de leur code.

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 peut implanter plusieurs interfaces. • Une classe pourra ensuite être manipulée par l'intermédiaire d'une référence vers l'interface.

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.

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

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

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.

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 fixe. Longueur( float longueur ) { this. longueur = longueur; }

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.

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

Chercher et toujours cher. . . public class Disque { public static final float pi = 3. 14; public static final float rayon = 5; public static void fixe. Rayon( float rayon ) { this. rayon = rayon; } public static void main( String [] args ) { System. out. println("Valeur de PI = " +Disque. pi ); } }

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

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

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 }

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 )

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

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 ma. Classe();

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 : – int. Value() – short. Value() – float. Value()

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

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

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. run. Finalization(); – System. run. Finalizers. On. Exit(true);

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. Fourni un mécanisme puissant pour personnaliser la gestion des erreurs. • Une exception est interceptée et traitée par l'application au moyen de gestionnaires d'exceptions.

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.

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

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 mon. Exception("Un exemple d'exception"); L'énumération des exceptions possibles est obligatoire

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 »

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

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

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

Quelques exceptions et erreurs standard ! • Parmi les exceptions standards les plus rencontrées on distingue : – java. lang. Null. Pointer. Exception – java. lang. Class. Cast. Exception – java. lang. Array. Index. Out. Of. Bounds. Exception • Les erreurs standards les plus courantes : – java. lang. Out. Of. Memory – java. lang. Stack. Overflow

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

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

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 : – – – add. Item remove. Item. At get. Item. At remove. All. Items size Cette classe appartiendra au package « istm. util »

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

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

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.

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 »

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.

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.

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

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.

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 nb 1, int nb 2 ); }

Exemple de mise en œuvre d’une classe anonyme public class Classe. Anonyme { public Exemple donne. Ex() { return new Exemple() { public int add( int nb 1, int nb 2 ) { return nb 1+nb 2; } }; } public static void main( String [] args) { System. out. println("Addition 6+2 =" + new Class. Anonyme. donne. Ex(). add(6, 2)); } }

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.

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. Input. Stream » – les sorties : ici c ’est « java. io. Output. Stream » . • Les entrés/sorties en java sont très simple à gérées et permettent facilement d’utiliser l’écran, le clavier, les fichiers.

Les classes « java. io. Input. Stream » et « java. io. Output. Stream » • « Input. Stream » une classe abstraite qui offre les prototypes des méthodes pour toutes les opérations sur un flux d’entrée. • « Output. Stream » 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 )

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

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

La classe « java. io. Print. Writer » • Cette classe permet d’écrire des informations dans un flux de sortie ( Output. Stream ). • Constructeurs : Print. Writer( Output. Stream out ) Print. Wrtier( Output. Stream 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.

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

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 Input. Stream qui symbolise par défaut le clavier. • Il existe deux flux standards de sortie ( ces deux flux sont implantés par des « Print. Writer » ): – 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 )

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 ) : – Data. Input. Stream – Data. Output. Stream • Ces classes offres des méthodes read. XXX et write. XXX pour lire et écrire des types primitifs java ainsi que UTF ( type String ). • On crée une instance de ces classes à partir de Input. Stream et Output. Stream : – Data. Input. Stream( Input. Stream in ) – Data. Output. Stream( Output. Stream out )

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.

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. File. Input. Stream – java. io. File. Ouput. Stream • Ces classes jouent un rôle identique à « Input. Stream » et « Output. Stream » dont elles héritent.

La classe « java. io. File » • Les principales opérations de cette classe sont : – – – boolean can. Read() boolean can. Write() boolean delete() boolean exists() boolean is. Directory() boolean is. File() boolean rename. To( File dest ) long length() boolean mkdirs() String get. Name( )

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.

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

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 has. More. Elements() : retourne « true » si l’énumération comporte encore des éléments. – Object next. Element() : 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.

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 add. Element( Object obj ) : ajoute un nouvel élément au vecteur. – int size() : retourne le nombre d’éléments du vecteur – Object element. At( int index ) : retourne l’élément demandé. – void remove. All. Emements() : supprime tous les éléments. – void remove. Element. At( in index ) : supprime un élément à un index du vecteur – Object last. Element() : retourne le dernier élément du vecteur. – Enumeration elements() : retourne l’ensemble des éléments du vecteur

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.

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.

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

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 get. Property( String key ) : retourne la valeur d’une propriété en fonction de son nom – Enumeration Property. Name() : retourne la liste des noms de propriétés – void list( Print. Stream out ) : écrit dans le flux de sortie la liste des propriétés.

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 get. Property( String key ); – Properties get. Properties(); • Parmi les propriétés systèmes on a : – java. class. path – user. home – java. home

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( Input. Stream in ); • Exemple de fichier de propriétés : # Exemple commentaire dans un fichier de propriétés Nom=Dupont Age 21

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 Char. At(int index ) : retourne un caractère de la chaîne int hash. Code() : retourne une code hash pour la chaîne String to. Upper. Case() : retourne une chaîne équivalente en majuscule String to. Lower. Case() : retourne une chaîne équivalente en minuscule boolean starts. With( String prefix ) : retourne « true » si la chaîne est préfixée de la chaîne passée en paramètre – boolean ends. With( String suffix ) : retourne « true » pour un suffixe

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 index. Of( char c, int from_index ) – int index. Of( String s, int from_index ) – int last. Index. Of( char c ) – int last. Index. Of( String s )

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

La classe « String. Tokenizer » • 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 : String. Tokenizer st = new String. Tokenizer( chaîne, séparateur ) • Les méthodes de cette classe sont : – int count. Tokens() : retourne le nombre de tokens – boolean has. More. Tokens() : retourne « true » si des tokens sont encore disponibles – String next. Token() : récupère le prochain token.

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

Qu’est ce qui est sérialisable ? • Tous les objets du langage java sont sérialisables. Pour être sérialisable, une classe doit tout simplement implanter l’interface « java. io. Serializable » . • 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.

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

Comment désérialiser un objet ? • La désérialisation fait appel à la classe « java. io. Object. Input. Stream » : Object. Input. Stream( Input. Stream in ) • Cette classe offre l’opération « read. Object » pour désérialiser un objet : Object read. Object(); • La désérialisation entraîne la création d’une instance du type de l’objet sérialisé. Ceci implique 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.

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

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

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.

Notion de threads Un processus multi-threads Un processus avec un seul thread 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 » .

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

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

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

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

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.

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 « get. Priority » : public final int get. Priority(); • De plus, pour fixer la priorité d'un thread, on utilise « set. Priority » : public final void set. Priority(int new. Priority);

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 « current. Thread » : public static Thread current. Thread(); • 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 « current. Thread » peut être également utilisée pour récupérer le thread principal.

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.

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.

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

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

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

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

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 « set. Daemon » : public final void set. Daemon(boolean on);

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.