Le langage Java

1
Le langage Java

• X. BLANC J. DANIEL
• Xavier.Blanc_at_lip6.fr , Jerome.Daniel_at_der.edf.fr

2
Plan du cours

• Introduction à Java
• Les bases du langage java
• Configuration de lenvironnement dexécution
• Compléments sur le langage java

3
Introduction à  Java 

• Le langage Java
• X.BLANC J. DANIEL

4
Quest ce que  Java  ?

• Un langage de programmation interprété et
  compilé.
• Langage portable pseudo-code
• Quels types dapplication pour  java  ?

5
Comment cela fonctionne til ?
Linterprè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 doutils
  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 dutiliser 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 dun 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
ButtonPanelIcon
Interface Graphique
Scan
UnzipZip
OpenClose
???
14
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 dune autre classe.
• class nom_de_la_class extends nom_de_la_classe_mèr
  e
• corps de la classe

Lhéritage multiple nexiste 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 nexiste pas en java de types non signés.

19
Méthodes

• Une fonction dune 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 dune instance dune
  classe.
• Si aucun constructeur nest défini par le
  programmeur, java considère que la classe est
  munie dun constructeur par défaut.
• Règles des constructeurs en java
• Les constructeurs en java portent le nom de la
  classe.
• Les constructeurs nont 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 dune 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

• 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 dune classe on utilise
  lopé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 dinterface

• 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 daccè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 dune 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 dy
  accéder sans disposer dune 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 dentré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
• while ( condition )

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 dexception

• 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 )
• ex.printStackTrace()

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.Exception
java.lang.Error
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 int50
• System.out.println("Taille du tableau "
  tab.length )

59
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 lenvironnement

• 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 lenvironnement

• 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
• -Dxxxxyyyyy définie une variable
  d'environnement qui sera accessible pour un
  programme,
• -cp spécifie un CLASSPATH spécifique pour
  l'exécution.

67
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 à
  lintérieur d une classe comme un membre ( au
  même titre quune méthode ), ou bien au sein dun
  bloc dinstructions ( par exemple dans un méthode
  )
• La visibilité dune classe interne est la même
  que celle dun attribut dune classe.

Par conséquent, si la classe interne est définie
au sein dun bloc d instruction, elle nest
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 sutilise 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 dune classe anonyme

• public class ClasseAnonyme
• public Exemple donneEx()
• return new Exemple()
• public int add( int nb1, int nb2 )
• return nb1nb2
• public static void main( String args)
• System.out.println("Addition 62 " 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
  dun ensemble de classes cohérentes.

72
Les entrées-sorties

• Le package  java.io  permet de gérer les
  opérations dentré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 dutiliser
  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 dentrée.
•  OutputStream  est également une classe
  abstraire permettant des opérations sur un flux
  en sortie.
• Le flux dentré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 doctets.
• 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 doctet depuis un
  flux dentré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 sajoutent String, Object )
• void println( xxxx value ) même principe que
   print  avec un retour à la ligne après
  écriture.

77
Lopération  toString 

• Lorsquun objet est passé à la méthode  print 
  ( ou  println  ), lopé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 dentré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 sagit dun 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, cest é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
  dentré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 sagit décrire une méthode qui
  lit le contenu dun 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 linterface
   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 lAPI 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 lensemble des
  éléments du vecteur

87
Les tables hash codées

• Une table hash codée est mise en uvre par
  lintermédiaire de la classe  java.util.Hashtable
   .
• Une table hash permet dinsérer des éléments dans
  un tableau en fonction dune 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 dindex 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
  dune é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 linterface  Pratique , cest à dire
  mettre en uvre l opération  displayElements 
  qui affiche lensemble des éléments dun vecteur
  ou dune table hash codée.
• Interface Pratique
• public void displayElements( java.lang.Object
  object )

90
Les propriétés

• Une propriété ( property ) est lassociation dun
  nom et dune 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 dune 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
• NomDupont
• 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 den
  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 cest le sauvegarder dans un
  flux de sortie.
• Sauvegarder lensemble de ses attributs,
• Sauvegarder lensemble des informations le
  caractérisant.
• Désérialiser cest à partir de données issues
  dun flux d entrée, régénérer un objet.
• Le principe de sérialisation permet de rendre les
  objets java  persistant .

98
Quest ce qui est sérialisable ?

• Tous les objets du langage java sont
  sérialisables.
• Quasiment toutes les classes de lAPI java dont
  la persistance savè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 linterface
 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 lopération suivante pour
  sérialiser un objet
• void writeObject( Object obj )
• Dans ce cas lopération  writeObject 
  nappelle plus  toString  sur lobjet mais
  sérialise celui-ci.

L objet passé en paramètre de la méthode
 writeObject  doit impérativement implanté
linterface  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 lopération  readObject 
  pour désérialiser un objet
• Object readObject()
• La désérialisation entraîne la création dune
  instance du type de lobjet sérialisé. Ceci
  implique que le code de lobjet à 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
dexceptions.
101
Les modificateurs  transient  et  static 

• Lorsquun attribut dune classe est marqué
   transient , celui-ci nest pas sérialisé.
• transient type_de_lattribut nom_de_lattribut
• 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 linterface
   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
Notion de threads
Un processus avec un seul thread
Un processus multi-threads
Thread 1
Thread 3
Thread 2
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 )

108
A l'exécution...

• Création du thread n1
• Création du thread n2
• Création du thread n3
• Thread n1, compteur 5
• Thread n2, compteur 5
• Thread n2, compteur 4
• Thread n2, compteur 3
• Thread n3, compteur 5
• Thread n1, compteur 4
• Tous les threads sont lancés
• Thread n3, 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 )
• // Zone verrouillée.

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.