Embed Size (px)
Citation preview
Plan du coursPlan du cours
• Introduction à “Java”
• Les bases du langage java
• Configuration de l’environnement d’exécution
• Compléments sur le langage java
Introduction à « Java »Introduction à « Java »
Le langage JavaX.BLANC & J. DANIEL
Qu’est ce que « Java » ?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 ?Comment cela fonctionne t’il ?
L’interprète est une machine virtuelle plus connue sousle nom de « jvm ».
Le « Java Development Kit »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 applicationsApplets 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 »La plate-forme entreprise « java »
Quelques atouts de javaQuelques 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 collectorNotion 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 javaLes bases du langage java
Le langage JavaX.BLANC & J. DANIEL
Langage ObjetLangage Objet
Interface Graphique
UnzipZip
OpenClose
Scan
???
ButtonPanelIcon
Un programme ObjetUn programme Objet
Description (Class, …)
Class GUI
Class Zip
…
Instanciation (Objet : main)
Notion de « class »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 classeHé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 classeAttributs 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;
Les types de baseLes 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éthodesMé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éthodesLes 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 classeLes 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 constructeurExemple 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 exempleAutre exemplepublic 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 carla classe mère n'a qu'un constructeur par défaut.
Création d ’une instance de classeCré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();
Espace de désignationEspace 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 »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{ … }
Arborescence de « package »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 { … }
Importation de « package »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{ … }
Notion d’interfaceNotion 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.
Implantation d'une interfaceImplantation 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.
Modificateurs d’accèsModificateurs 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 »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 »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 »
• 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 »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;}
Le point d’entrée d ’une applicationLe 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)...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 chercher...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 );}
}
Un premier essai...Un premier essai...
• Développer une classe représentant un agenda.
• A quoi ressemblerait un agenda réparti ?
Les tests de conditionsLes 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 multiplesLes 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 bouclesLes 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 langageLes 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éritentimplicitement de java.lang.Object
Conversion de typesConversion 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();
Les types de base sous forme objetLes 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()
ConstatConstat
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 sortieMise 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;}
L'opération « finalize » 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);
Notion d’exceptionNotion 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.
Créer une exceptionCré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'exceptionExemple d'exception
Public class monException extends java.lang.Exception{
public monException(){ }
public monException( String msg ){
super(msg);}
}
Générer une exceptionGé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
Intercepter les exceptionsIntercepter 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 exceptionExemple 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érationde l'exception.
Mais quel problème ?Mais quel problème ?
try{
// Bloc d'instructions surveillé par « try »}catch ( java.lang.Exception ex ){
ex.printStackTrace();}catch ( monException ex ){
ex.printStackTrace();}
Les erreurs javaLes 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.Exceptionjava.lang.Error
Quelques exceptions et erreurs standard !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
Les tableauxLes 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 tableauCopier 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épartpour le tableau source
tableau destination
Index de départpour le tableau destination
nombre d'éléments a copier
Le tableau de destination doit être alloué.
A vous de jouer...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 »
Configuration de l’environnementConfiguration de l’environnement
Le langage JavaX.BLANC & J. DANIEL
Distribution des Distribution des applications javaapplications 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’environnementConfiguration 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 packagesArborescence 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 javaCompilation 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 javaExé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 javaCompléments sur java
Le langage JavaX.BLANC & J. DANIEL
Les classes internesLes 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’unbloc d ’instruction, elle n’est utilisable que depuis ce bloc.
Les classes anonymesLes 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 );}
Exemple de mise en œuvre Exemple de mise en œuvre d’une classe anonymed’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));}
}
Les classes statiquesLes 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-sortiesLes 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.
Les classes Les classes « java.io.InputStream » et « java.io.InputStream » et « java.io.OutputStream »« 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 )
La classe « java.io.BufferedOutputStream »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();
La classe « java.io.BufferedInputStream »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();
La classe « java.io.PrintWriter »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.
L’opération « toString »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()
Les flux d’entrée et de sortie standardsLes 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 )
Lecture et écriture de donnéesLecture 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 )
Mise en œuvre des connaissances !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 fichiersLes 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.
La classe « java.io.File »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( )
Encore à vous...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 »
• 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érationsLes é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.
Les vecteursLes 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
Les tables hash codéesLes 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 Les principales méthodes de « java.util.Hashtable »« 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...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 ) ;}
Les propriétésLes 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.
Les propriétés systèmesLes 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
Les fichiers de propriétésLes 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ésNom=DupontAge 21
La classe « java.lang.String »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
Manipulation de chaîne de caractèresManipulation 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 )
Encore à vous de jouer...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 « StringTokenizer »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.
La sérialisationLa 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 ?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 simplementimplanter l’interface « java.io.Serializable ».
Comment sérialiser un objet ?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 »
Comment désérialiser un objet ?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éesplusieurs sortes d’exceptions.
Les modificateurs « transient » et « static »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 classesqui possèdent des attributs « static ».
A vous de jouer… à votre âge !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.
RemarqueLa classe vecteur implante l’interface « java.io.Serializable ».
Les threadsLes 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 threadsNotion 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 3Thread 2
Toute application comporte au moins un thread appelé « thread pincipal ».
Définir un threadDé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 threadUn 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.
Exemple d'utilisation d'un threadExemple d'utilisation d'un threadpublic 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");
}}
A l'exécution...A l'exécution...
Création du thread n°1Création du thread n°2Création du thread n°3Thread n°1, compteur = 5Thread n°2, compteur = 5Thread n°2, compteur = 4Thread n°2, compteur = 3Thread n°3, compteur = 5Thread n°1, compteur = 4Tous les threads sont lancésThread n°3, compteur = 4...
L'ordonnancement est imprévisible.
Interruption et reprise d'un ThreadInterruption 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 threadAutre 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);
Comment récupérer le thread courant ?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 égalementutilisée pour récupérer le thread principal.
Accès concurrentsAccè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 appelerrécursivement cette opération.
Les verrousLes 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 verrouExemple 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 »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 »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();
}}
Le JDK 1.2 et les opérations sur les threadsLe 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émonsLes 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);
Courage c'est la dernière fois...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.
