Programmation orientée objet

appliquée avec le langage Java

Le langage Java – Partie 1
IUT d'Aix‐Marseille
Réseaux et Télécommunications La programmation orientée objet
Novembre 2013
Ivan Madjarov

IvMad, 2008-2013 2

Les notions de l'Objet Le modèle Java
• Introduction au modèle Java
• La Programmation Orientée Objet
• Objets et Classes
• Propriétés et Méthodes
• Encapsulation
• Constructeurs et Destructeurs
• Surcharge et Redéfinition
• Héritage
• Polymorphisme
IvMad, 2008-2013 3 IvMad, 2008-2013 4
 Java ‐ Introduction Java ‐ Modèle VM
• La portabilité de Java

Java Source File javac Bonjour.java

Bonjour.java

Java Class File

java Bonjour Bonjour.class
(byte-code portable)
JVM (Machine virtuelle)
Système d'exploitation

IvMad, 2008-2013 5 IvMad, 2008-2013 6

Java ‐ exemples Java ‐ exemple

• L'exemple de base: • Un deuxième exemple:
class Bonjour {
class Bonjour {
public static void main (String args[]) {
public static void main(String args[]) {
System.out.println("Bonjour tout le monde!"); System.out.println("Bonjour " + args[0]);
} }
} }
– Code source sauvegardé dans Bonjour.java • Code source sauvegardé dans Bonjour.java
– Compilation et exécution:
• Compilation et exécution avec paramètre:

IvMad, 2008-2013 7 IvMad, 2008-2013 8

 Java ‐ programme Java ‐ exemple
• Le déroulement du programme: • Le plus grand de trois nombre donnés au clavier:
class comparerTrois {
• main : méthode (fonction) principale de la classe.  public static void main(String argv[]) { // chaîne de c.
int a = Integer.parseInt(argv[0]); // Conversion vers int
– C'est la méthode appelée par la commande int b = Integer.parseInt(argv[1]); // Conversion vers int
>java Bonjour.  int c = Integer.parseInt(argv[2]); // Conversion vers int
if (a>b && a>c)
– void : caractérise les fonctions qui ne renvoient rien  System.out.println("Le plus grand est a="+a);
if (b>a && b>c)
donc void en anglais. System.out.println("Le plus grand est b="+b);
if (c>a && c>b)
– Le paramètre String [] argv correspond aux paramètres  System.out.println("Le plus grand est c="+c);
éventuellement passés en ligne de commande :  }
}
>java Bonjour Pierre

IvMad, 2008-2013 9 IvMad, 2008-2013 10

La programmation orientée objet La programmation orientée objet
• Le modèle Objet: • Les objectifs de la POO 
– Considère que le monde est composé d’objets – Faciliter la réutilisation de code, encapsulation et 
– Les objets sont identifiables individuellement. abstraction.
– Les objets sont en relation avec d’autres objets – Faciliter l’évolution et l’extension du code.
– Les objets peuvent être abstraits sous la forme de  – Améliorer la conception et la maintenance des grands 
"types" que l’on appelle classes systèmes.
– Les classes sont organisées sous la forme d'hiérarchies – Programmation par "composants". 
– Penser en termes d'abstractions conceptuelles • Conception d’un logiciel à la manière de la fabrication 
– Penser en termes d'entités relativement autonomes d’une voiture par modules fabriqués par des sous‐
traitants.
– Penser en termes de cadres (frameworks) et de 
composants réutilisables

IvMad, 2008-2013 11 IvMad, 2008-2013 12

 La programmation orientée objet La programmation orientée objet
• Objet et Classe • Les concepts de la POO
• La classe représente une description ou une définition  – Concept de modélisation à travers la notion de classe et 
d’un type d’objet (données + méthodes) d’instanciation de ces classes
– Concept d’action à travers la notion d’envoi de messages 
• L'objet en lui‐même est une instance de classe:
et de méthodes à l’intérieur des objets
– instance: Un exemplaire d'une classe;
– Concept de construction par réutilisation et amélioration
– instance: Une copie de la classe;  par l’utilisation de la notion d’héritage
– instance: Sa représentation en mémoire.
• Caractéristiques essentielles d'un langage de POO:
• On déclare une classe comme type complexe – Abstraction,
• On déclare des variables de ce type appelées des  – Encapsulation,
objets. – Héritage,
– Polymorphisme.
IvMad, 2008-2013 13 IvMad, 2008-2013 14

La programmation orientée objet POO – Encapsulation

• Une classe est constituée de descriptions de : • Encapsulation  c’est le fait de réunir 
– données : que l’on nomme attributs. à l'intérieur d'une même entité 
– fonctions : que l’on nomme méthodes (objet) le code (méthodes) + 
données (champs). 
• Une classe est un modèle de définition pour des objets – Il est possible de masquer les 
– la même structure (même ensemble d'attributs), informations d'un objet aux autres 
objets.
– le même comportement (mêmes opérations, méthodes),
– une sémantique commune. 2 niveaux d’encapsulation : 
• Privé ‐ les champs et les méthodes 
• Les objets sont des représentations dynamiques
masqués sont dans la partie privée 
– "vivantes" du modèle défini à travers la classe. de l’objet. 
– Une classe permet d’instancier (créer) plusieurs objets • Public ‐ les champs et les méthodes 
– Chaque objet est l’instance d’une (seule) classe visibles sont dans la partie interface 
de l’objet.
IvMad, 2008-2013 15 IvMad, 2008-2013 16
 Héritage Polymorphisme
• L'héritage permet la création des descendants.  • Le polymorphisme traite de la capacité de l'objet à posséder 
– Les descendants bénéficient des caractéristiques propres de  plusieurs formes.
leur ancêtre (champs et méthodes).  • Cette capacité dérive directement du principe d'héritage. 
– Les descendants conservent la possibilité de posséder leur  • Un objet hérite des champs et méthodes de ses ancêtres. 
propres champs et méthodes.
• L’objet garde toujours la capacité de pouvoir redéfinir une 
méthode afin de la réécrire, ou de la compléter.
• C’est la capacité d'un objet à modifier son comportement 
propre et celui de ses descendants au cours de l'exécution. 
• C’est la capacité du système à choisir 
dynamiquement la méthode qui 
correspond au type réel de 
l'objet en cours.
IvMad, 2008-2013 17 IvMad, 2008-2013 18

La programmation orientée objet La programmation orientée objet
• La structure de la classe Java • Visibilité des attributs dans la classe

IvMad, 2008-2013 19 IvMad, 2008-2013 20

 La programmation orientée objet Déclaration d’une classe
• Format classique d’une application java:
import classes natives;
import mes classes;

class Nom_Classe {
Attribut(s) de la classe;
Méthode(s) de la classe;

public static void main( String args[] ) {

// Construction des instances d'objet
{
}

IvMad, 2008-2013 21 IvMad, 2008-2013 22

La POO – les Objets POO – définition de classes

L'accessibilité entre deux objets public class personne {
// attributs
private String prenom;
private String nom;
private int age;
// méthodes
public void init(String P, String N, int a) {
this.prenom = P;
this.nom = N;
this.age = a;
}
public String toString() {
return (prenom+","+nom+","+age);
}
}

IvMad, 2008-2013 23 IvMad, 2008-2013 24

 Java – le mot clé this Java – opérateur new
• L'instruction this.prenom=P signifie que l'attribut  // Application Java utilisant la classe Personne
public class testPersonne {
prenom de l'objet courant (this) reçoit la valeur P.  public static void main(String args[]) {
personne prs = new personne();
• Le mot clé this désigne l'objet courant : celui dans  prs.init("Jean","Dupont",30);
lequel se trouve la méthode exécutée. System.out.println(prs.toString());
}
}
public void init(String P, String N, int age){
this.prenom = P; • L’operateur new a pour effet de créer un objet de type 
this.nom = N; personne nommé prs et initialisé par défaut : les 
this.age = age; attributs nom et prenom auront la valeur null, et age la 
} valeur 0.
• prs fait référence d’objet instancié de la classe
• l’appel de la méthode se fait par prs.init( … )
IvMad, 2008-2013 25 IvMad, 2008-2013 26

Une application Java Java – Constructeur

Exécution de  Compilation des 
• Un constructeur est une méthode qui porte le nom de 
l’application classes la classe et qui est appelée lors de la création de l'objet. 
• Le constructeur existe toujours, même s’il n’est pas 
présent de manière explicite dans la description de la 
classe:  personne prs = new personne();
• L’appel de la méthode personne() est un appel de 
constructeur pour initialiser l’objet crée à travers 
l’operateur new. 
• Le constructeur est une méthode qui peut accepter des 
arguments mais qui ne rend aucun résultat. 
• Son prototype ou sa définition ne sont précédés 
d'aucun type ou attribut.
IvMad, 2008-2013 27 IvMad, 2008-2013 28
 Constructeur surchargé Java – Constructeur
public class personne { public class test2 {
• Toute classe possède un 
// attributs public static void main(String arg[]) {
constructeur par défaut, implicite. 
private String prenom; personne p1 = new personne();
Celui‐ci peut être redéfini.
private String nom; p1.init("Jean","Dupont",30);
• Une classe peut avoir plusieurs 
private int age; System.out.println(p1.toString());
constructeurs qui diffèrent par le 
// méthodes personne p2 = new personne("Yves","Blanc",28);
nombre et la nature de leurs 
public personne() { System.out.println(p2.toString());
paramètres (surcharge).
} }
public personne(String P, String N, int age) { }
init(P,N,age);
}
public void init(String P, String N, int age) {
this.prenom=P; this.nom=N; this.age=age;
}
public String toString() {
return(prenom+","+nom+","+age);
}
}
IvMad, 2008-2013 29 IvMad, 2008-2013 30

Méthodes des attributs privés Mot‐clé static
// accesseurs pour lecture //modificateurs pour écriture • Placé devant une propriété ou une méthode
– Exemple : static int count = 0;
public String getPrenom() { public void setPrenom(String P) {
this.prenom=P; – Exemple : static Circle bigger(Circle c1, Circle
return prenom; } c2) {..}
} • Effet: Il n'est pas nécessaire d'instancier la classe pour accéder à 
public void setNom(String N) { ses membres statiques (de l’extérieur d’une classe on peut faire 
public String getNom() { this.nom=N; directement  Nom_classe.nom_statique)
return nom; }
– Les propriétés static sont communes à toutes les instances 
} public void setAge(int A) { de la classe
this.age=A; – Les méthodes static sont l’équivalent aux fonctions en C
public int getAge() { }
• Les méthodes statiques ne peuvent pas accéder à this
return age;
} • Les membres statiques sont accessibles via la classe

IvMad, 2008-2013 31 IvMad, 2008-2013 32

 Référence d'Objet  Référence d'Objet 
• La création d'objets • Accéder aux données membres d'un objet
– Un objet est une instance de classe . L'opérateur new suivi  – L'accès aux données membres d'un objet se fait par la 
du nom de la classe l'instancie avec ou sans paramètres  référence de l'objet suivi d'un point, puis du nom de la 
suivant la signature du constructeur: donnée membre. Par exemple :
new String("Bonjour tout le monde!"); reference.nomDonnee = valeur;
• Les références Si la donnée membre est elle‐même la référence d'un autre 
objet, alors on peut accéder à ses données membres:
– L'objet construit est placé dans un endroit de la mémoire  (reference.donneeReference).nomDonnee = valeur
auquel on n'a pas accès direct. La référence de l'objet nous 
donne le point d'accès en mémoire de cet objet:   • Accéder aux méthodes d'un objet
String str = new String("Bonjour tout le monde!");  – L'accès aux méthodes d'un objet se fait comme pour l'accès 
La variable str ne contient pas la chaîne "Bonjour …", mais  aux données membres. La méthode est suivie de 
uniquement une référence (un entier) vers l'objet qui est en  parenthèses, contenant les paramètres, si il y'en a:
mémoire.  reference.methode(parametre1,parametre2);

IvMad, 2008-2013 33 IvMad, 2008-2013 34

Partie II Héritage
• L’objectif de l’héritage est de construire de nouvelles 
classes en réutilisant les attributs et les méthodes de 
L'Héritage classes déjà existantes.
• Les attributs et les méthodes peuvent être modifiés au 
niveau de la sous‐classe. 
• Il peut y avoir des attributs et/ou des méthodes 
supplémentaires dans une sous‐classe.
– Une classe B qui hérite d’une classe A dispose implicitement 
de tous les attributs et de toutes les méthodes définis dans A
– Les attributs et les méthodes définis dans B sont prioritaires 
par rapport aux attributs et aux méthodes de même nom 
définis dans A.

IvMad, 2008-2013 35 IvMad, 2008-2013 36

 L'héritage en Java Héritage
• Rappel: la classe mère "Personne"
Héritage de figures public class Personne {
en géométrie // attributs
private String prenom;
private String nom;
private int age;
// constructeur
public Personne(String P, String N, int a) {
this.prenom = P;
this.nom = N;
Héritage d'objets this.age = a;
graphiques dans un }
système multi-fenêtré // méthode
public String toString() {
fictif
return(prenom + " " + nom + " " + age);
}
}
IvMad, 2008-2013 37 IvMad, 2008-2013 38

Héritage Mot‐clé super

• Définition de la classe "Enseignant" • Une classe ne peut hériter que d'une seule classe à la 
class Enseignant extends Personne {
private String Matiere; // attributs et constructeur
fois (héritage simple en Java). Cet inconvénient est 
public Enseignant(String P, String N, int age, String M){ comblé par les interfaces en Java (implements)
super(P, N, age); // appel au constructeur parent
• Grâce à l’héritage:
this.Matiere = M; // renseigner l'attribut local
} – Une classe peut définir des variables portant le même 
public String toString() { nom que celles de ses classes ancêtres (redéfinition).
return (super.toString() + " " + Matiere);
}
– Une classe peut redéfinir des méthodes redéfinies de 
} sa classe mère.
• L'instruction super(P,N,age) est un appel au  • Le mot clé super fait référence à la classe parente 
constructeur de la classe parent, ici la classe "Personne". quand on est dans le code de la classe.
• L'objet "Enseignant" ne peut pas exister sans la création de  – Grâce à super, une classe peut accéder aux attributs et 
l'objet "Personne" puisqu'il en provienne. méthodes de sa classe mère.
IvMad, 2008-2013 39 IvMad, 2008-2013 40
 Mot‐clé super : exemple Mot‐clé final
class A { // la classe parent
int x=1; • Classe : final indique que la classe ne peut plus 
void m() {...}
} être héritée
class B extends A // B hérite de A
{
int x=2; • Méthode : final indique que la méthode ne peut 
void m() {...}
} plus être redéfinie dans les classes dérivées.
class C extends B { // C hérite de B
int x=3, a; – Une méthode static ou private est 
void m() {...}
void test() { automatiquement final
a = x;
a = super.x; // a reçoit la valeur de la variable x de la classe B • Donnée : final indique qu’il s’agit d’une constante.
a = super.super.x; // Syntax error
a = ((A)this).x; // a reçoit la valeur de la variable x de la classe A – Une donnée final ne peut être affectée qu’une seule 
a = ((B)this).x; // a reçoit la valeur de la variable x de la classe B
super.m(); // Appel à la méthode m de la classe B fois.
super.super.m(); // Syntax error
((A)this).m(); // Appel à la méthode m de la classe A (et non C)
}
}
IvMad, 2008-2013 41 IvMad, 2008-2013 42

Les objets temporaires
• Dans une expression, on peut faire appel explicitement au 
constructeur d'une classe : l'objet est construit, mais nous 
n'y avons pas accès pour le modifier par exemple.
• L'espace mémoire qu'il occupait sera automatiquement 
récupéré ultérieurement par un programme appelé 
"ramasse‐miettes " dont le rôle est de récupérer l'espace 
mémoire occupé par des objets qui ne sont plus référencés 
par des données du programme.

public class testtemp {

public static void main(String arg[]){
new personne("Jean","Dupont",30)).toString();
}
}

IvMad, 2008-2013 43
 Programmation orientée objet
appliquée avec le langage Java
La programmation orientée objet avec le langage Java – Partie 2
http://139.124.26.245/java et sur AmeTice

IUT d'Aix‐Marseille JAVA
Réseaux et Télécommunications PACKAGES, EXCEPTION, 
Novembre 2013
STRING, STREAM
Ivan Madjarov

IvMad, 2008-2013 2

Sommaire Partie III
• Les Exceptions
• Les APIs
• String Les Exceptions
• Stream
• Fichiers
• Classes abstraites
• Polymorphisme
• Interfaces

IvMad, 2008-2013 3 IvMad, 2008-2013 4

 Les exceptions La gestion des exceptions
• Pour traiter les erreurs survenues lors de l’exécution  • De nombreuses fonctions Java sont susceptibles de 
du programme, Java propose un mécanisme qui  générer des exceptions, (erreurs). Les opération I/O 
effectue les instructions dans un bloc d'essai  et réseau sont en priorité une source d'erreurs.
(le bloc try) qui surveille les instructions.  try {
• Lors de l'apparition d'une erreur, celle‐ci est lancée  appel de la fonction susceptible de générer
l'exception
dans un bloc de traitement d'erreur (le bloc catch) 
} catch (Exception e) {
sous forme d'un objet appelé Exception. traiter l'exception e
} finally {
instruction exécutée après try ou catch
}
instruction suivante

IvMad, 2008-2013 5 IvMad, 2008-2013 6

La gestion des exceptions La gestion des exceptions
• Ce sont des instances de classes dérivant de  • Exemple du séquencement :
java.lang.Exception
• La levée d'une exception provoque une remontée 
dans l'appel des méthodes jusqu'à ce qu'un bloc  Object getContent()
{
try 1
catch acceptant cette exception soit trouvé {
openConnection(); void openConnection()
} throws IOException
• Si aucun bloc catch n'est trouvé, l'exception est  7
catch(IOException e) {
...
{
openSocket(); 4 2
capturée par l'interpréteur (JVM) qui l’affiche et le 
}
6 sendRequest();
void sendRequest()
finaly {
... 5 }
receiveResponse();
throws IOException
{
programme s'arrête. }
...
write(header);
write(body); //ERREUR
}
8 }
• Un bloc optionnel finally peut‐être posé à la suite des  3
catch. Son contenu sera exécuté qu’il ait eu une 
exception ou pas.

IvMad, 2008-2013 7 IvMad, 2008-2013 8

 La gestion des exceptions La gestion des exceptions
• Si on désire que l'exception soit traité par les blocs  • Possible exception à la lecture au clavier.
de niveaux supérieurs, il suffit d'inclure à la fin de la  // Lire suite de caractères et retourner une chaîne de caractères
public static String readLine(String prompt) {
série d'instructions contenues dans le bloc catch{}  int ch;
une clause throw, suivie du type de l'exception entre  String ret = "";
boolean done = false;
parenthèse puis du nom de l'exception. System.out.print(prompt); // Affiche message de prompt
while (!done) {
try { try {
// Instructions qui peuvent provoquer des erreurs; ch = System.in.read();
if (ch < 0 || (char)ch == '\n') // Fin de ligne
} done = true;
catch (TypeException e) { else if ((char)ch != '\r') // Passage à la ligne
ret = ret + (char)ch;
// Instructions de traitement de l'erreur; } catch(java.io.IOException e) {
throw (TypeException)e; done = true;
}
} }
// Instructions si aucune erreur est apparue; return ret;
}

IvMad, 2008-2013 9 IvMad, 2008-2013 10

Partie IV Les API java: java.lang.String
• La classe String gère des chaînes de caractères .
• Une String n’est pas modifiable.
Les String • Toute modification  entraine la création d'une 
nouvelle String.
(Chaîne de caractères) • Les valeur littérales ("abc") sont transformées en 
objets String.
• L'opérateur “+” permet la concaténation de 2 String 
– EX: ("abc"+"def" ‐‐>"abcdef" ) 

IvMad, 2008-2013 11 IvMad, 2008-2013 12

 Les API java: java.lang.String java.lang.String
String s = "\u00catre ou ne pas \u00eaetre"; // s="Être ou ne pas être" • "==" compare les références pas les contenus!
int lg = s.length(); // lg = 19 
String s = "Java"+"Soft"; // s = "JavaSoft" – boolean equals(Object obj)
– boolean equalsIgnoreCase(String anotherString);
String s = (String) new – int compareTo(String anotherString); // +,-,0
URL("http://server/big.txt").getContent();
• Exemple:
String data = "Java 2"; // ça va afficher "Java" – if (g.equals("bonjour")) ...
System.out.println(data.substring(0,data.length()-2));
– if "bonjour".equals(g)) ...
String s = String.valueOf(2 * 3.14159); // s = "6.28318" • Autres facilités:
String s = String.valueOf(new Date()); // s = "Sat Jan 18 1997 12:10:36" boolean startsWith(String prefix);
int i = Integer.parseInt("123"); // i = 123
double b = Double.parseDouble("78,987");// b = 78,987 boolean endsWith(String suffix);
int indexOf(String str); // recherche d'une chaine
String s = "java"; int lastIndexOf(...);

if (s == "java") {...} // Erreur

if (s.equals("java") {...} // Ok

IvMad, 2008-2013 13 IvMad, 2008-2013 14

java.lang.StringBuffer La méthode toString()
• La classe StringBuffer gère des chaînes de caractères  • La méthode toString est définie dans la classe Object
(char) modifiable (setCharAt(), append(), insert())
• La méthode toString() convertie une StringBuffer en  dont toutes les classes Java en hérite.
String (fige la valeur: moins gourmand en mémoire) • Lorsqu'on définit une classe, il est utile de redéfinir la 
StringBuffer sb = "abc"; // Erreur: can't convert String to StringBuffer
méthode toString afin de donner une description 
StringBuffer sb = new StringBuffer("abc"); // OK
satisfaisante des objets de cette classe. 
sb.setCharAt(1, 'B'); // sb= "aBc"
• Quand on redéfinit la méthode toString, on fait en sorte 
sb.insert(1, "1234);
sb.append("defg");
// sb = "a1234Bc"
// sb = "a1234Bcdefg"
qu'elle renvoie une chaîne de caractères servant à 
décrire l'objet concerné. 
String s = sb.toString(); // s = "a1234Bcdefg"
sb.append("hij"); // sb = "a1234Bcdefghij" – public String toString();
// s = "a1234Bcdefg"

IvMad, 2008-2013 15 IvMad, 2008-2013 16

 Partie V Les packages 
• Un package regroupe un ensemble de classes sous 
un même espace de nommage.
– L'intérêt est de regrouper les classes par thème, lien 
Les Packages logique, dépendance…
– on peut se représenter le package comme un 
répertoire contenant des fichiers classes
– cela permet de limiter la portée du nom des classes
• un package peut contenir des sous‐packages
– Les noms des packages suivent le schéma : 
name.subname.subsubname ...
• Les API de java sont organisées en packages
(ex: java.lang, java.io, java.net …)
IvMad, 2008-2013 17 IvMad, 2008-2013 18

Les packages: import Les core API
• Les API les plus courant:
• les noms complets des classes sont : 
nom_du_package.nom_de_la_classe; – java.lang : Types de bases, Threads, Exception, Math, ...
– java.util : Hashtable, Vector, Stack, Date, ...
ou encore
– java.applet : Interface vers les applications Web
package.souspackage.classe;
– java.awt : Interface graphique portable
• pour utiliser des classes sans les préfixer du nom de leur package  – java.io : accès aux i/o par flux (fichiers, stdin, stdout,..)
il faut : – java.net : Socket (UDP, TCP, multicast), URL, ...
– import package.souspackage.classe; – java.lang.reflect : introspection sur les classes et les objets
– import package.*; (TOUTE les classes) – java.beans : composants logiciels
– java.sql (JDBC) : accès homogène aux bases de données
• Exemple:  – java.security : signature, cryptographie, authentification
– import java.io.File; // une seule classe – java.rmi : Remote Method Invocation
– import java.io.*; // toutes les classes • les API sont installées en version binaire
• le "*" n ’est pas récursif !  – utilisables via la javadoc associée (au format HTML)
– A télécharger en même temps que le JDK!
• Implicite dans un prog.java : import java.lang.*;
IvMad, 2008-2013 19 IvMad, 2008-2013 20
 Les core API et la Javadoc Les core API et la Javadoc
• La documentation des API de Java est en ligne à : Exemple de la javadoc des API:
Description de la
– http://java.sun.com ou http://www.javasoft.com classe en cours
– Accès direct à l ’API v1.6:
• http://java.sun.com/j2se/1.6/docs/api/
Nom
• Format de la javadoc (dans le navigateur):
Packages A C Description de
(filtre sur les la classe en
classes) cours
B Nom (selectionnée
Classes de l ’API
Description dans B)
(par ordre description
Propriétés
alphabetique)
Constructeurs méthodes
Classes de l ’API
Méthodes (par ordre
alphabetique)

IvMad, 2008-2013 21 IvMad, 2008-2013 22

Packages personnalisés Packages personnalisés
• L'arborescence des répertoires contenant les classes doit être identique à 
• L'instruction package indique à quel package  l'arborescence des packages
appartient la ou les classe(s) du fichier.  – les noms des packages/répertoires sont case sensitifs
– par défaut le package anonyme est le repertoire courant
• package doit être la première instruction du fichier 
• Une classe Circle appartenant au package Forme.2D doit se trouver 
source dans le fichier Forme/2D/Circle.class
• Par défaut (si pas d'instruction package dans le fichier)  sources packages répertoires

une classe appartient au package anonyme. Package Forme;

... Forme
• Exemple : Package Forme.2D;
package forme; ... 2D

class Circle { Package Forme.3D; 3D

...
double x, y, r;
void Circle(double x, double y, double r) { • Le compilateur sait créer automatiquement les sous‐répertoires pour y 
this.x = x; this.y = y; this.r = r; placer les fichiers classes
} • Les répertoires contenant les packages doivent être dans la variable 
... d'environnement CLASSPATH.
IvMad, 2008-2013 23 IvMad, 2008-2013 24
 L’API core java: java.lang.* Les API java: java.lang.Math
Boolean • Fonctions mathématiques:
Character – random, abs, sin, co, tan, sqrt, min,
Class max, log, exp…
Double
Math
Float • Constantes mathématiques:
Number
Integer – Math.PI,…
Object Process
Long
Runtime • Exemple :
String double pi = Math.PI;
StringBuffer // On accède a l'attribut statique de la classe Math
System double r = Math.sqrt(2);
Classes Incluses par defaut
Thread
dans tous les programmes
// On invoque la méthode statique de la classe Math
ThreadGroup java (inutile de les importer)
Throwable

IvMad, 2008-2013 25 IvMad, 2008-2013 26

Les API java: java.util.* Les API java: java.util.Vector
• Cette classe gère une collection d'objets dans un tableau de 
taille dynamique à l'opposé du tableau [] qui a la taille fixe!
BitSet • Inconvénients:
Date – plus gourmand en mémoire qu’un tableau[]
Dictionary Hashtable Properties – plus lent également
Object – ne gère que des objets (pas de types primitifs)
Observable
– mais permet l’hétérogénéité des elements
Random
• Exemple:
StringTokenizer Vector v = new Vector();
Vector Stack v.add(new Personne()); // élément 0
v.add(new date()); // élément 1: date du jour
v.add(1, new String("abcde")); // nouvel élément 1
v.add(new Vector()); // un sous-vecteur!
System.out.println(v.size()+v.elementAt(2));// 4abcde

IvMad, 2008-2013 27 IvMad, 2008-2013 28

 Les API java: java.util.Hashtable java.util.StringTokenizer
• Cette classe gère une collection d'objets au travers une  • Cette classe permet par ses méthodes de découper une 
"table de hachage" String selon un séparateur (ou une liste de séparateurs) 
• La HashTable équivaut à un Vector sauf que les clés sont des  afin d'extraire des mots clés d'une chaîne de caractères.
String au lieu de numériques • Exemple:
• Pas de notion d’ordre comme dans un vecteur !! import java.util.StringTokenizer;
public class stringTokenExtract {
Hashtable ht = new Hashtable();
public static void main(String[] args) {
int i=0;
ht.put("Noël", new Date("25 Dec 2013"));
ht.put("une chaine","abcde"); String str = "avion;bateau;train";
ht.put("un vecteur", new Vector()); StringTokenizer st = new StringTokenizer(str, ";");
while(st.hasMoreTokens()) {
Vector v = (Vector)ht.get("un vecteur"); System.out.println((++i)+". "+st.nextToken());
System.out.println(ht.get(" une chaine ")); // --> abcde }
}  
}

IvMad, 2008-2013 29 IvMad, 2008-2013 30

Partie VI Le modèle I/O Stream
• Pour accéder à une information donnée, un 
programme ouvre un flux vers la source d'information 
(un fichier, mémoire, réseau etc.) et lie cette 
Les Stream IO information de manière séquentielle. 
• Pour écrire une information donnée, un programme 
(les flux E/S) ouvre un flux vers la sortie et la aussi, il écrit de 
manière séquentielle cette information sur le support 
d'écriture (fichier, mémoire, réseau etc.)
• Le modèle des flux:
Données entrantes Données sortantes
Programme

IvMad, 2008-2013 31 IvMad, 2008-2013 32

 Le modèle I/O Stream Le modèle Stream
• Les étapes de lecture/écriture sont identiques et se  • Les flux données sont divisés en 2 catégories, basées 
résument comme suit: sur le type de données: binaire ou texte.
Lecture Ecriture – Flux texte: sert à lire/écrire des information textuelle 
Ouvre un flux en lecture Ouvre un flux en écriture
codées sur 16 bits (unicode). Contient les superclasses: 
Lit tant qu'il y a quelque Écrit tant qu'il y a quelque • Reader
chose à lire chose à écrire – int read();
Ferme le flux Ferme le flux
– int read(char cbuf[]);
• Un Stream doit être vu comme un tuyau – int read(char cbuf[], int offset, int length);
• Le Stream utilise toujours les même méthodes du  • Writer
package : java.io.*  – int write(int c);
– int write(char cbuf[]);
– read();
– int write(char cbuf[], int offset, int length);
– write();
• C'est un exemple de polymorphisme
IvMad, 2008-2013 33 IvMad, 2008-2013 34

Le modèle Stream Les flots d'entrée‐sortie
– Flux binaire: sert à lire/écrire des informations codées  • Résumé:
en iso‐latin‐1 sur 8 bits. Contient les superclasses:  • La communication d’une application Java avec le 
• InputStream
monde extérieur s’effectue par des Stream (flots):
– int read();
– int read(byte cbuf[]); – Flots de données binaires (bytes)
– int read(byte cbuf[], int offset, int length); – Flots de caractères (char)
• OutputStream • Quel que soit la communication établie (fichiers ou 
– int write(int c); 
réseau) et le type de données transportée (Unicode ou 
– int write(byte cbuf[]);
– int write(byte cbuf[], int offset, int length);
binaire), la procédure générale consiste à :
1. ouvrir un flot ("Stream") de communication ;
2. utiliser le flot pour lire ou écrire des données ;
3. fermer le flot de communication.

IvMad, 2008-2013 35 IvMad, 2008-2013 36

 Les flots (Stream) Les API java: java.io.*
• Exemples de sous‐classes de Tout ce qu’il faut ByteArrayInputStream BufferedInputStream
InputStream et OutputStream : pour lire
FileInputStream DataInputStream
– BufferedReader : Lecture de texte depuis un flux  InputStream FilterInputStream LineNumberInputStream
d'entrée (caractères, tableaux et chaînes de caractères). PipedInputStream PushbackInputStream

• Méthode readLine(); pour lire au clavier un String SequenceInputStream
File StringBufferInputStream
– BufferedWriter : Écriture de texte dans un flux de sortie  Object

(caractères, tableaux et chaînes de caractères). 
Accès en R/W et
RandomAccessFile
– DataInputStream : Lecture de données Java primitives.  positionnement

– DataOutputStream : Écriture de données Java primitives.  ByteArrayOutputStream

OutputStream BufferedOutputStream
– FileInputStream : Lecture d'octets depuis un fichier.  FileOutputStream
DataOutputStream
– FileOutputStream : Écriture d'octets dans un fichier. FilterOutputStream
PrintStream
Tout ce qu’il faut PipedOutputStream
pour écrire

IvMad, 2008-2013 37 IvMad, 2008-2013 38

Stream buffer Stream buffer
• Exemple: • Lire un String et un entier au clavier:
BufferedReader IN = new BufferedReader( new public static void main(String[] args) {
InputStreamReader(System.in)); BufferedReader IN = new
BufferedReader(new InputStreamReader(System.in));
String ligne = null; String nom = null;
try{ int age = 0;
ligne = IN.readLine(); // Lire une ligne au clavier try {
System.out.println("Nom: ");
} catch (Exception e){
nom = IN.readLine();
System.err.println(e); System.out.println("Age: ");
System.exit(2); age = Integer.parseInt(IN.readLine());
} System.out.println("Votre nom est "+nom+" et vous avez
"+age+" ans");
– e est un objet dérivé du type Exception. } catch (Exception e){
System.err.println(e);
– IOException, SecurityException, ArithmeticException,  }
etc… }

IvMad, 2008-2013 39 IvMad, 2008-2013 40

 Stream File (fichier) Les flots (Stream)
• java.io.File les méthodes des fichiers. • Exemples (java.io.File):
import java.io.File;
public class monFile {
public static void main(String argv[]) {
File f = new File("java/h.class");
System.out.println(f.exists()); // --> true
System.out.println(f.canRead()); // --> true
System.out.println(f.canWrite()); // --> false
System.out.println(f.length()); // --> 11345
File d = new File("java/");
System.out.println(d.isDirectory()); // --> true
String[] files = d.list();
for (int i=0; i<files.length; i++)
System.out.println(files[i]);
}
}

IvMad, 2008-2013 41 IvMad, 2008-2013 42

Lire un fichier texte Écrire un fichier texte (1)
String chaine=""; String s = "Le message à enregistrer dans un fichier";
String fichier="source.txt"; BufferedWriter bfWr = null;
try { try {
// Ouvrir le fichier // Construire un objet de type BufferedWriter
InputStream ips = new FileInputStream(fichier); bfWr = new BufferedWriter(new FileWriter("fichier.txt"));
// Initialiser le flot de lecture // Ecrire la chaine à la sortie Stream
InputStreamReader ipsr = new InputStreamReader(ips); bfWr.write(s);
// Unité de lecture // Ecrire une fin de ligne
BufferedReader br = new BufferedReader(ipsr); bfWr.newLine();
String ligne=""; } catch (IOException ex) { ex.printStackTrace();
// Lire les lignes du fichier } finally { // Fermer BufferedWriter
while ((ligne = br.readLine()) != null) { try {
chaine += ligne+"\n"; if(bfWr != null) {
} bfWr.flush(); // vider et fermer le buffer
br.close(); bfWr.close(); }
} catch (Exception e){ System.err.println(e.getMessage()); } catch (IOException ex) { ex.printStackTrace(); }
} }

IvMad, 2008-2013 43 IvMad, 2008-2013 44

 Écrire un fichier texte (2) Les flux (Stream)
String s = "Le message à enregistrer dans un fichier";
• java.io.File permet d'accéder en lecture et en écriture à 
FileOutputStream fout;
try { un fichier en binaire.
// Ouvrir le Stream de sortie avec nom de fichier // copier un fichier byte par byte
fout = new FileOutputStream ("file.txt",true); ............
// Écrire une ligne de texte avec la méthode println() FileInputStream fin = new FileInputStream("source.txt");
new PrintStream(fout).println(s); byte[] data = new byte[ fin.available() ];
// Fermer le Stream de sortie // available() retourne le nombre d'octets accessibles à lire
fout.close(); fin.read(data);
} fin.close();
// Attraper toute exception d'entrée/sortie .............
catch (IOException e) { FileOutputStream fout = new FileOutputStream("cible.txt");
System.err.println("Écriture impossible!");
fout.write(data);
}
fout.close();
finally {System.out.println("Enregistrement terminé!");
}

IvMad, 2008-2013 45 IvMad, 2008-2013 46

Les flux (Stream) Les flux (Stream)
• java.io.Data permet de lire et d'écrire des types  • java.io.PrintStream permet de manipuler un 
primitifs et des lignes sur des flux. OutputStream au travers des méthode print() et 
FileInputStream fis = new FileInputStream("source.dat"); println().
DataInputStream dis = new DataInputStream(fis);
• PrintStream ps = new PrintStream(new
int i = dis.readInt(); FileOutputStream("cible.txt", true));
double d = dis.readDouble();
String s = dis.readLine(); • Le paramètre "true" autorise l'ajout de nouvelles lignes 
FileOutputStream fos = new FileOutputStream("cible.dat"); à la fin du fichier "cible.txt".
DataOutputStream dos = new DataOutputStream(fos); – ps.println("Une ligne");
dos.writeInt(123);
– ps.println("Une deuxième);
dos.writeDouble(123.456);
– ps.print("Une autre ligne");
dos.writeChars("Une chaine");
– ps.print("123 et fin");
– ps.flush();
– ps.close();

IvMad, 2008-2013 47 IvMad, 2008-2013 48

 Partie VII Classes abstraites
• Permet d’avoir des classifications plus équilibrées

Classes abstraites Forme Classe abstraite et non-terminale

Cercle Carré Classes concrètes

Classes concrètes
et terminales

IvMad, 2008-2013 49 IvMad, 2008-2013 50

Classes abstraites Classes abstraites
• Les classes abstraites constituent le cœur des  • Les classes abstraites  (prototype)
applications Java – Une classe est dite abstraite si elle ne fournit pas
d'implémentation pour certaines de ces méthodes
Compte bancaire Classe abstraite et non-terminale qui sont dites méthodes abstraites et ainsi ne peut
avoir d'instance.
Compte  Compte  Classes concrètes
– Il appartient à ces classes dérivées de définir du code
courant d'épargne et terminales pour chacune des méthodes abstraites. On parlera
alors de classes concrètes qui peuvent être
Méthodes de classe instanciées.
– Le but est de définir un cadre pour les classes
dérivées en proposant un ensemble de méthodes
pour toute l'arborescence.
IvMad, 2008-2013 51 IvMad, 2008-2013 52
 Mot‐clé abstract Classes abstraites
• Une méthode est dite abstraite si on ne veut écrire que le  • Une classe abstraite est une classe qui ne peut pas 
prototype (la "signature" pas le corps). avoir d'instance
• Si dans une classe, au moins une méthode est déclarée  – Comporte des méthodes abstraites éventuellement
abstract, alors la classe devient abstraite.
• L’implémentation (le corps) de la méthode s’effectuent  • En Java une méthode abstraite est une méthode qui 
dans les classes qui héritent de cette classe. n'a pas de code. A distinguer des méthodes vides qui 
• Pour ne plus être abstraite, une classe fille doit  ne font rien…
implémenter toutes les méthodes abstraites de la classe  abstract void p(); // est abstraite
dont elle hérite. void p(){} // méthode vide, ne fait rien..
• Si une classe est déclarée abstract, alors elle ne peut pas  – Une classe abstraite peut contenir des attributs et des 
être instanciée. méthodes
abstract class C1 { class C2 extends C1{
abstract void methode( ); void methode( ){
void normale( ){ // corps de la méthode
// corps de la méthode }
} }
}

IvMad, 2008-2013 53 IvMad, 2008-2013 54

Classes abstraites Classes abstraites
• Une forme géométrique est une classe abstraite abstract class Forme {
// nom de la forme
• Chaque forme géométrique peut être spécialisée en: private String nom;
– Carré // Constructeur
– Cercle public Forme(String N) {
– Rectangle this.nom = N;
}
– Ellipse
public String getNom() {
• Pour toutes les formes géométriques on peut calculer: return nom;
– L'aire }
– Le périmètre // Méthodes communes à chaque forme
abstract double aire(); // Calcule l'aire
• Si Forme est la classe abstraite, le calcul de l'aire et du  abstract double perimetre(); // et le périmètre
périmètre sont des méthodes abstraites. }

IvMad, 2008-2013 55 IvMad, 2008-2013 56

 Partie VIII Polymorphisme
• Le polymorphisme permet la réutilisation de 
programmes existants et l'extensibilité des applications. 
Polymorphisme • Le polymorphisme correspond à la possibilité pour un 
opérateur ou une fonction d'être utilisable dans des 
contextes différents (différenciables par le nombre et le 
types des paramètres) et d'avoir un comportement 
adapté à ces paramètres. 
• On distingue trois types de polymorphisme : 

IvMad, 2008-2013 57 IvMad, 2008-2013 58

Polymorphisme Polymorphisme par sous‐typage

• C'est la possibilité d'invoquer une fonction définie pour un 
• L'héritage concerne les classes (et leur hiérarchie), le 
paramètre de type X avec un paramètre de type Y défini 
polymorphisme est relatif aux méthodes des objets. 
comme un sous‐type du type X.
• Le polymorphisme consiste, lorsqu'on hérite d'une  • D'un point de vue objet, définir le sous type Y consiste par 
classe, à redéfinir l'une des méthodes pour la  exemple à ajouter de nouvelles variables d'instance à celles 
spécialiser. définies dans le type X, imposer des contraintes sur les 
– Le méthode toString() dans le cas des classes Personne,  valeurs acceptables des variables d'instance ou définir de 
Etudiant, groupeEtudiant des exemples des TPs. nouvelles méthodes applicables à l'objet.
• C'est un concept objet qui consiste à utiliser la "même"  • Exemple: Pour un type Matrice, correspondant à des 
méthode sur des objets différents. matrices carrées, on peut concevoir un nouveau type 
MatriceSymetrique comme sous‐type du précédent.
• Toute matrice symétrique est de fait une matrice ordinaire 
et toutes ses fonctions sont re‐applicables. 
IvMad, 2008-2013 59 IvMad, 2008-2013 60
 Polymorphisme par surcharge Partie IX
• Le polymorphisme ad‐hoc
– Il s'agit essentiellement de la surcharge 
("overloading"). 
• Méthodes;
Interface
• Constructeurs.
– Plusieurs définitions d'un même nom sont fournies 
qui se différencient par la liste et le type de leurs 
paramètres (on parle alors de profils différents)
– Exemple : 
Etudiant();
Etudiant(String Prenom, String Nom, Int Age, int Annee, 
String Matiere, double Moyenne);
IvMad, 2008-2013 61 IvMad, 2008-2013 62

Interfaces Interfaces
• L'héritage multiple  • L'héritage multiple est délicat d'utilisation
– Une classe qui possède plusieurs classes mères afin  • En C++, il y a de l'héritage multiple possible
de modéliser une généralisation multiple. • En Java, il n'y a pas d'héritage multiple
– Exemple: on souhaite ajouter la classe Hovercraft à  • Pour palier à cette situation, Java dispose d'une classe 
notre modèle de parc de véhicules.  particulière
Un Hovercraft est à  – L'interface est déclarée avec le mot clé interface. 
la fois un bateau et 
– Il s'agit d'une classe dont toutes les méthodes sont 
un véhicule terrestre.
abstraites et publiques et tous les attributs sont 
constants. 
– Une classe n'hérite pas d'une interface mais elle 
l'implémente à l'aide du mot clé implements
IvMad, 2008-2013 63 IvMad, 2008-2013 64
 Programmation orientée objet
appliquée avec le langage Java Partie X
Programmation objet avec Java 
• Application et Applet
IUT d'Aix‐Marseille • Dessiner avec une Applet
Réseaux et Télécommunications
Novembre 2013
Ivan Madjarov

IvMad, 2002-2013 2

Application et Applet Applet objet téléchargeable
• Une application Java est un programme "Standalone"  •
c.à.d. à part entière. Pour l'exécuter on a besoin d'une 
JVM installé dans un système d'exploitation.
• Un programme compilé, accessible par un serveur Web 
et téléchargé pour être exécuté par un navigateur Web 
sur sa propre JVM est une applet.
• Ainsi les applets se présentent comme des objets 
téléchargeables ou applications Web.
• Pour assurer la sécurité des systèmes les applets sont 
soumis à des restrictions d'accès!
– Une applet n'accèdent pas aux système de fichiers locaux.

IvMad, 2002-2013 3 IvMad, 2002-2013 4

 Les applets Java  Les applets Java 
Une application • Une applet c’est un objet graphique, c'est aussi un objet actif
Java fait sorties  "créé" et contrôlé par le navigateur Web. 
• La classe Applet possède deux types de méthodes: 
écran en mode 
– les méthodes d'interface graphique (héritées) telles que:
texte, mode 
graphique avec  public void paint(Graphics g);
les API AWT ou  public boolean mouseDown(Event evt, int x, int y);
public boolean action(Event evt, Object what);
SWING etc. 
Une applet Java 
– les méthodes de contrôle d'exécution telles que :
utilise l'interface 
graphique des  public void init();
navigateurs Web. public void start();
public void stop();
public void destroy();
etc. 
IvMad, 2002-2013 5 IvMad, 2002-2013 6

Les applets Java  Les applets Java 
• Une applet dérive de la classe Applet et redéfinit 
tout ou en partie quatre fonctions de base.  • Exemple d’applet : 
import java.awt.*;
• Le code "standard" d’une applet: import java.applet.*;
import java.applet.*; public class helloApplet extends Applet {
public class uneApplet extends Applet { public void paint(Graphics g) {
public void init() {
// afficher un texte aux coordonnées x=50px, y=20px
// code d'initialisation g.drawString("Bonjour tout le monde!",50,20);
} }
public void start() { }
// code de l'exécution
}
public void stop() {
// code de suspension de l'exécution
}
public void destroy() {
// code de terminaison
} }
IvMad, 2002-2013 7 IvMad, 2002-2013 8
 Les applets Java  Les applets Java par JCreator
• L’utilisation de l’applet ce fait à partir d’un document  • Exécution: 
HTML: – Une Applet est un fichier classe appelé par le navigateur 
– On défini le nom de la classe et la taille du cadre dédié  Web à travers un fichier HTML.
à l'applet. • Pour créer une Applet dans JCreator: 
<!DOCTYPE HTML> – File ‐> New File ‐> Java Classes ‐> Applet Classe ‐> Next ‐> 
<html> Name ‐> Location
<head>
</head>
– Rédiger le code de l'applet suivant le sujet du TP
<body> – Sauvegarder et compiler par "Build File"
<applet • Pour créer le fichier HTML qui exécute l'Applet:
code = "helloApplet.class" – File ‐> New File ‐> Other‐> HTML Applet ‐> Next ‐> Name ‐
width = "250" > Location
height = "100" >
– Préciser le nom de la classe sur la ligne: 
</applet>
code = "helloApplet.class" et la taille du cadre d'affichage 
</body> par les "width" et " height" en pixels.
</html>
– Sauvegarder et exécuter le fichier par le menu "Run File"
IvMad, 2002-2013 9 IvMad, 2002-2013 10

Les applets Java avec Eclipse
• Sous Eclipse la rédaction d'une applet ne diffère pas 
de la création d'une application Java.
– On crée un projet Java;
– On ajoute au projet une classe Java qui hérite de la  • drawOval(int x, int y, int width, int height);
classe Applet;
– On rédige le contenu de l'applet;
– On sauvegarde le code de l'applet;
– On exécute l'applet avec appletviewer:
• select Run‐>Run as‐>Java Applet from the menu bar
Dessiner dans une Applet
• Méthodes de tracé graphique
– Pour tracer des cercles et des ellipses:
– Pour tracer des carrés et des rectangles:
• drawRect(double x, double y, double longueur,
double largeur);
– Un hexagone on peut tracer à partir de la méthode 
graphique
• drawPolygon(int[] xPoints, int[] yPoints,
int nPoints);
– Pour tracer un texte à l'écran:
• drawString(String s, int x, int y);

IvMad, 2002-2013 11 IvMad, 2002-2013 12

 Dessiner dans une Applet Dessiner dans une Applet
• Exemple avec texte et rectangle:
• Ainsi notre exercice de
import java.awt.*;
classes sur les formes 
import java.applet.*;
graphiques peut aboutir à 
public class dessinApplet extends Applet {
une présentation 
public void paint (Graphics g) {
graphique des formes 
g.drawString("Rectangle",50,30);
géométriques dans le 
g.drawRect(40,10,100,50);
champ d'affichage
}
d'une applet.
}
• Exercice à faire en TP avec 
Le rectangle est tracé à partir des  des coordonnées 
coordonnées x=40px, y=10px avec une  nécessaires à l'opération 
taille de 100px sur x et 50px sur y.
de tracer.
Le texte est introduit à l'intérieur de la 
figure par ses cordonnées de début.

IvMad, 2002-2013 13 IvMad, 2002-2013 14

Introduction
• Le modèle OSI (Open System Interconnexion)

Partie XI
Programmation réseau en Java 

IvMad, 2002-2013 15 IvMad, 2002-2013 16

 Introduction Introduction
• Routage et Passerelle • Échange d'informations entre client et serveur

Routage

IvMad, 2002-2013 17 IvMad, 2002-2013 18

Couches réseau Package Java
• Trame <‐> Datagramme <‐> Transport <‐> Application • Le package java.net contient toutes les classes 
orientées réseau bas niveau de l'API JAVA.

IvMad, 2002-2013 19 IvMad, 2002-2013 20

 Interface de programmation réseau La Socket
• Un langage de programmation "moderne" offre une  • La Socket (connecteurs réseau) représente une interface 
interface de programmation réseau  de programmation pour les communications entre 
processus. 
– Java, C#, Python, etc.
• Il existe généralement quatre types de sockets :
• Java propose le paquetage java.net. Il fournit des 
– Une socket datagram permet une communication 
facilités pour la programmation réseau par des Sockets bidirectionnelle qui n'est pas séquencée. Un processus 
en implémentant  les protocoles TCP et UDP. utilisant ce type de Socket peut recevoir les données dans 
– Le protocole UDP permet d'établir une connexion, sur  un ordre différent de l'ordre de départ. C'est le protocole 
une Socket, en mode non connecté UDP.
• Transmission de données en mode datagramme.  – Une Socket Stream permet une communication 
– Le protocole TCP permet d'établir une connexion en  bidirectionnelle, sûre, séquencée et un flux de données sans 
duplication pouvant entraîner une fragmentation des 
mode connecté.
paquets transmis.  Il s'agit du protocole TCP.
• Transmission de données en mode connecté
– Une socket raw et une socket sequenced packet.
IvMad, 2002-2013 21 IvMad, 2002-2013 22

La Socket Les ports
• Le rôle des Sockets: • Un service réseau rendu par un programme serveur sur 
– Connexion à une machine distante une machine est accessible par un port
– Envoie/Réception de données • Un port est identifié sur une machine par un nombre 
– Fermeture d'une connexion entier (16 bits)
– Attachement à un port • Les numéros de port de 0 à 1023:
– ports réservés aux services standard assignés par l'IANA 
– Acceptation d'une demande de connexion à un port 
(Internet Assigned Numbers Authority)
local
• A un port est attribué un numéro allant de 1 à 65535
• Les ports de 1 à 1023 sont réservés aux services:
– FTP (21), HTTP (80), SMTP (25)
– Attente de demandes de connexion
• Les numéros de port supérieur à 1024 sont disponibles 
pour placer un service applicatif défini par l'utilisateur.
IvMad, 2002-2013 23 IvMad, 2002-2013 24
Processus de Socket Le processus Socket

Source Christine Bulfone : Le client/serveur et l’API socket Selon les transparents de Rémy Courdier

IvMad, 2002-2013 25 IvMad, 2002-2013 26

Le processus Socket Le processus Socket

Selon les transparents de Rémy Courdier Selon les transparents de Rémy Courdier

IvMad, 2002-2013 27 IvMad, 2002-2013 28

Le processus Socket Le processus Socket

Selon les transparents de Rémy Courdier Selon les transparents de Rémy Courdier

IvMad, 2002-2013 29 IvMad, 2002-2013 30

Le processus Socket

Partie XII 
Programmation réseau en Java 
par Socket en mode non connecté :
Le protocole UDP  (RFC 768)
(User Datagram Protocol)

Selon les transparents de Rémy Courdier

IvMad, 2002-2013 31 IvMad, 2002-2013 32

 Mode datagramme (UDP) Mode datagramme (UDP)
• Le service, offert par la couche IP, fait l'envoi (et surtout  • Les fonctionnalités assurées par le protocole UDP sont 
le routage) de datagrammes de l'émetteur vers le  fournies par le package java.net qui dispose de deux 
destinataire, en mode non connecté  classes pour réaliser la programmation réseau en mode 
– les datagrammes sont indépendants entre eux, même  datagramme : 
lorsqu’ils font partie d’un même message.  – DatagramPacket
– la remise du datagramme au destinataire n'est pas  – DatagramSocket
garantie! • Les données sont mises 
– La structure dans un objet de type 
d'un DatagramPacket qui est 
datagramme envoyé sur le réseau par 
est montré  le biais d’un objet de 
en figure type DatagramSocket.
IvMad, 2002-2013 33 IvMad, 2002-2013 34

Mode datagramme (UDP) Mode datagramme (UDP)
• Le principe de la programmation réseau en mode  • Pour recevoir des datagrammes en Java il faut suivre 
datagramme en Java se base: les étapes suivantes :
– (1) sur l'envoie des datagrammes   – Créer une instance de la classe DatagramSocket qui 
– (2) la reception des datagrammes. attend l’arrivée de données par le réseau.
• Pour envoyer des datagrammes en Java on suit les  – Créer une instance de la classe DatagramPacket qui 
étapes suivantes : reçoit les données par l’instance de DatagramSocket.
– Obtenir l’adresse du destinataire et la mettre dans une 
instance de la classe InetAddress.
– Mettre les données et l’adresse dans une instance de la 
classe DatagramPacket.
– Créer une instance de la classe DatagramSocket et lui 
confier l’envoi du datagramme.
IvMad, 2002-2013 35 IvMad, 2002-2013 36
 Mode datagramme (UDP) Mode datagramme (UDP)
• La classe DatagramPacket fournit deux constructeurs :  • Trouver l’adresse IP correspondant à un nom de machine
– un pour les paquets à recevoir, 
– l'autre pour les paquets à envoyer. import java.net.*;
import java.io.*;
1. Construire un objet pour recevoir un datagramme. 
– public DatagramPacket(byte buffer[], int taille) public class ResoudreNom {
‐ buffer correspond à la zone de réception public static void main(String[] args) {
‐ taille maximale des datagrammes à recevoir.  InetAddress adresse;
Les données reçues au delà de la taille de la zone de stockage sont perdues try {
2. Construire un objet pour envoyer un datagramme.  adresse = InetAddress.getByName(args[0]);
– public DatagramPacket(byte buffer[], int taille, System.out.println("Nom : "+args[0]+", IP: "
InetAddress adresse, int port) + adresse.getHostAddress());
} catch(UnknownHostException e) {
‐ buffer correspond à la zone d'envoie System.err.println(args[0]+" est inconnu\n");
‐ taille correspond à la taille du datagramme à envoyer }
‐ adresse destinataire de la datagramme  }
‐ port du UDP }

IvMad, 2002-2013 37 IvMad, 2002-2013 38

Mode datagramme (UDP) Émetteur UDP
• Deux programmes pour illustrer le mode datagramme: • En première on résout le nom de la machine destinatrice 
– Le programme "Emetteur"  permet l’envoi vers le programme  (passé en argument) en adresse réseau. 
"Recepteur" des messages par le réseau.  – adr = InetAddress.getByName(args[0]);
• Ensuite une chaîne de caractères est transformée en suite 
d’octets pour les transmettre sur le réseau.
– String message = 
– Le programme "Recepteur" se charge d'afficher le message  "Démonstration du mode datagramme";
reçu. – byte[] tampon = new byte[message.length()];
• Un tableau de byte est créé à la taille du message.
• Une transformation en byte se fait par la méthode 
getBytes() de la classe String.
– tampon = message.getBytes();

IvMad, 2002-2013 39 IvMad, 2002-2013 40

 Émetteur UDP Émetteur UDP
import java.io.*; import java.net.*;
public class Emeteur {
• Ensuite, on construit un datagramme en indiquant  int port = 1025;                     // le port d'envoi
l’emplacement des données à transmettre (tempon),  InetAddress adr;                  // variable type objet adresse internet
String message;                    // chaine de caractère contenant le message à envoyer
leur longueur (tampon.length) et enfin l’adresse du  byte[] tampon;                      // tableau de byte (octets), où chaque caractère de l'envoi sera codé en 
binaire
destinataire (adr) et le port de l'écoute (port). DatagramPacket paquet;                   // variable type objet datagramme
DatagramSocket sock;                        // variable type objet socket
– DatagramPacket paquet = new   public Emeteur(String host) {                                                             // Constructeur de la classe
DatagramPacket(tampon, tampon.length, adr, port); try {    adr = InetAddress.getByName(host); 
message = "Demonstration du mode datagramme"; 
// Résoudre l'adresse du destinataire 
// Composer un message
• Enfin on ouvre une DatagramSocket en utilisant sa  tampon = new byte[message.length()]; 
tampon = message.getBytes(); 
// Définir la taille du tableau d'octets
// Charger le tableau d'octets 
méthode send() pour l'envoi du datagramme. paquet = new DatagramPacket(tampon, tampon.length, adr, port);  // Construire datagramme  
sock = new DatagramSocket();  // On ouvre une Socket
– DatagramSocket sock = new DatagramSocket(); sock.send(paquet);  // Envoie du datagramme
{ catch(UnknownHostException e)  {  System.err.println(host+" est inconnu\n"); 
– sock.send(paquet); } catch(ArrayIndexOutOfBoundsException e) {  System.err.println("Adresse du Recepteur " + e);
} catch(SocketException e) { System.err.println("Erreur de Socket " + e);
} catch(IOException e) { System.err.println("Erreur d'Entrée‐Sortie " + e);  }               
{ public static void main(String[] args) { new Emeteur(args[0]);    }    
}  // partie application
IvMad, 2002-2013 41 IvMad, 2002-2013 42

Récepteur UDP Récepteur UDP
import java.io.*;
• Une zone mémoire tampon pour recevoir les données.  import java.net.*;
public class Recepteur {
– byte[] tampon = new byte[200]; int port;                                        // Le port pour la réception
byte[] tampon;                            //  Tableau de byte pour recevoir les données de l'émetteur 
• Ensuite nous créons un DatagramSocket pour écouter  DatagramPacket paquet;          // Réception en créant le packet datagramme
DatagramSocket sock;              // Socket sur le port de réception
sur le port de destination en attente de données. String message;
public Recepteur (int n) {   // Constructeur qui prend le numéro du port en attribut
– DatagramSocket sock = new DatagramSocket(port); try {
port = n;                                 // affectation du port d'écoute
• L’ordre d’attente se fait par la méthode receive() tampon = new byte[200];  // définir le tableau de type byte
paquet = new DatagramPacket(tampon, tampon.length);  // créer l'objet de type packet
– sock.receive(paquet); sock = new DatagramSocket(port); // créer la Socket
sock.receive(paquet);                                               // écoute du port de réception
• La méthode se charge de placer les données dans un  message = new String(tampon);  // Conversion des octets en chaine
System.out.println(message.toUpperCase());  // Afficher le message 
DatagramPacket gérant le tampon. } catch(SocketException e) {  System.err.println("Erreur de Socket " + e);
} catch(IOException e) {  System.err.println("Erreur d'Entrée‐Sortie " + e);  }  
– DatagramPacket paquet = new  }
DatagramPacket(tampon, tampon.length); public static void main(String[] args) {   
new Recepteur(1025);  }     }                                       // créer l'objet anonyme du récepteur

IvMad, 2002-2013 43 IvMad, 2002-2013 44

 Déroulement de l'exécution Mode datagramme (UDP)
•

Un transparent 
du cours  
d'Etienne Duns  

IvMad, 2002-2013 45 IvMad, 2002-2013 46

Programmation orientée objet
appliquée avec le langage Java Partie XIII
Réseaux Programmation en Java par 
Socket en mode connecté (TCP)

IUT d'Aix‐en‐Provence
Réseaux et Télécommunications
Décembre 2013
Ivan Madjarov

IvMad, 2002-2013 2

Mode TCP et UDP Le mode connecté (TCP)
• Fonctionnement en mode connecté
– Données envoyées dans un "tuyau" et non pas par paquet
– Flux de données (Stream)
– Fiable : la couche TCP assure que:
• Les données envoyées sont toutes reçues par la machine 
destinataire
• Les données sont reçues dans l'ordre où elles ont été envoyées

IvMad, 2002-2013 3 IvMad, 2002-2013 4

 Le mode connecté (TCP) Le mode connecté (TCP)
• Le mode est assuré au niveau de la couche de  • Les étapes côté Serveur:
transport selon le modèle OSI par le protocole TCP 1. Instancier la classe ServerSocket et l’instruire à écouter sur 
(Transmission Control Protocol). un port > 1024.
• Le paquetage java.net fourni les classes:  2. Accepter les connexions par la méthode accept() et créer un 
objet Socket pour référencer la nouvelle connexion.
– Socket(host, port);
3. Passer la nouvelle connexion au programme approprié.
– ServerSocket(port); 4. Fermer la connexion par la méthode close().
pour travailler avec le mode connecté (TCP). • Les étapes côté Client:
• Le mode connecté est une interconnexion stable entre  1. Se connecter au service approprié en instanciant la classe 
un client et un serveur. Socket et en lui passant comme paramètres l’adresse du 
Serveur et le port écouté.
2. Lorsque l’échange est terminé fermer la connexion par la 
méthode close().
IvMad, 2002-2013 5 IvMad, 2002-2013 6

Le mode connecté (TCP)
• Le Client et le Serveur en mode connecté
Les Sockets (connecteurs réseau)
• Une application Client se connecte par une adresse IP 
sur un numéro de port.
• Le serveur accepte la connexion et fournit une nouvelle 
socket avec un nouveau port de communication pour 
continuer à écouter sur la socket originale.

• Du côté du client, si la connexion est acceptée, une 
socket est créée pour assurer la communication avec le 
serveur.
IvMad, 2002-2013 7 IvMad, 2002-2013 8
 Les Sockets (connecteurs réseau) Les Sockets (connecteurs réseau)
• Classe java.net.Socket propose: • Mise en œuvre  du modèle Client‐Serveur:
– Méthodes d'émission et de réception de données – La Socket est créé sur le client. 
– Contrairement aux sockets UDP, les sockets TCP n'offre pas  – Le ServerSocket fonctionne sur le serveur en attente de 
directement de services pour émettre‐recevoir des données connexion ( méthode accept() ).
• On récupère les flux d'entrée‐sorties associés à la socket  – La Socket tente de se connecter sur le serveur distant. 
OutputStream getOutputStream()
– Connexion établie, le ServerSocket génère une Socket pour 
• Retourne le flux de sortie permettant d'envoyer des données  communiquer avec le client. 
via la socket InputStream getInputStream()
– La connexion établie, le système Client et Serveur établit un 
• Retourne le flux d'entrée permettant de recevoir des données 
via la socket
canal de communication par flux à partir de leur Sockets pour 
échanger des données. 
– Fermeture d'une socket 
• public close()
– Après fin des échanges, l'un des interlocuteurs clôt le canal 
de communication.
• Ferme la socket et rompt la connexion avec la machine distante

IvMad, 2002-2013 9 IvMad, 2002-2013 10

Les Sockets (connecteurs réseau) Les Sockets (connecteurs réseau)
• Constructeurs: – public inputStream getInputStream() throws
IOException : retourne le flux d'entrée associé à la socket.
– public Socket(String host, int port) throws
UnknownHostException, IOException; – public OutputStream getOutputStream() throws
IOException : retourne le flux de sortie associé à la socket.
– public ServerSocket(int port) throws IOException;
– public void close() throws IOException : ferme la 
• Méthodes: ServerSocket.
– host (String) : nom de la machine vers laquelle la socket est créée.  – public Socket accept() throws IOException : place le 
ServerSocket en attente de requête d'ouverture de socket. 
– addresse (InetAddress) : adresse IP de la machine vers laquelle la 
socket est créée.  • Cette attente est bloquante. Une socket est 
– port (int) : numéro du port sur lequel la socket est créée. automatiquement générée et retournée lors de cette 
– localAddr (InetAddress) : adresse IP locale à la quelle la socket est  requête.
associée. 
– localPort (int) : numéro du port local auquel la socket est associée. 
– public void close() throws IOException : ferme la socket.

IvMad, 2002-2013 11 IvMad, 2002-2013 12

 Les Sockets (connecteurs réseau) Les Sockets (connecteurs réseau)
• Réaliser un Client TCP en Java : • Réaliser un Serveur TCP avec la classe 
– ouverture d’une socket(new socket(host,port)), java.net.ServerSocket :
– ouverture d’un flot d’entrée et de sortie sur la  – ouverture d’une socket serveur, 
socket(in = new BufferReader(...))
out = new PrinterWritter(...) – attente de connexion et ouverture d’une socket client, 
– lecture et écriture sur les flots en accord avec les protocoles  – ouverture d’un flot d’entrée et de sortie sur la socket 
du serveur  client, 
in.readLine(...), – lecture et écriture sur les flots en accord avec les 
out.println(...),
protocoles du client (présenté précédemment), 
– fermeture des flots: 
in.close(), – fermeture des flots, fermeture de la socket serveur et de 
out.close(), la socket client.
– fermeture de la socket : socket.close();

IvMad, 2002-2013 13 IvMad, 2002-2013 14

Serveur d'heure TCP Le Client TCP
import java.net.*; import java.io.*; import java.util.*; // Client cherchant l'heure sur le serveur
class serveurHeure { // Retourne au client la date et l'heure import java.io.*; >java ClientTCPHeure
public static void main(String args[]) { import java.net.*; Wed Nov 25 08:58:32 CET 2013
try { public class ClientTCPHeure { >
// Installer le serveur sur un port public static void main(String args[]) {
ServerSocket sks = new ServerSocket(8181); String ligne = "";
System.out.println("Serveur en attente"); try {
// Tourne en attente de connexion // Etablir une connexion TCP sur un port
Socket sk = sks.accept(); Socket sk = new Socket("localhost",8181);
System.out.println(sk.toString()); // Le flux d'entrée pour recevoir le message serveur
DataOutputStream out = new BufferedReader is = new BufferedReader(new
DataOutputStream(sk.getOutputStream()); InputStreamReader(sk.getInputStream()));
out.writeBytes(new Date()+"\n"); // ecr. date et heure // Lire le flux d'entrée
sk.close(); while ((ligne = is.readLine()) != null)
>java serveurHeure
sks.close(); Serveur en attente System.out.println(ligne); // message du serveur
} catch (IOException e) { Socket[addr=/127.0.0.1,port=49409,localport=8181]
} catch (Exception e) {
System.out.println(e.getMessage()); System.err.println(e.getMessage()); }
} }
} } }
IvMad, 2002-2013 15 IvMad, 2002-2013 16
 Le client TCP émet un message Serveur TCP traite le message
import java.net.*; import java.net.*;
import java.io.*; import java.io.*;
public class ClientTCP { public class ServeurTCP {
Socket sock = null; int port = 1500; // Port de connexion
public ClientTCP(String host, int port, String data) { ServerSocket SkS; // La socket serveur
try { Socket SkC; // La socket client
// Connexion sur le port du serveur BufferedReader input; // Lecteur du flux d'entrée
sock = new Socket(host, port); String message;
// Définir le flux de sortie public ServeurTCP() { // Constructeur de la classe
PrintStream output = new try {
PrintStream(sock.getOutputStream());
// La socket serveur est installée sur le port 1500
output.println(data); // Envoi des données
SkS = new ServerSocket(port);
sock.close();
System.out.println("Serveur sur port: " + SkS.getLocalPort());
} catch(IOException e) { }
// Serveur en attente infinie:
}
(1) connexion d'un client,
public static void main(String[] args) {
(2) réception de messages,
ClientTCP client = new ClientTCP("127.0.0.1",1500,"Bonjour!");
(3) fermeture de la connexion par le client
}
}
IvMad, 2002-2013 17 IvMad, 2002-2013 18

Les Sockets (connecteurs réseaux) Les Sockets (connecteurs réseaux)
while(true) { // Fermeture de la connexion par le client
// Connexion acceptée try {
SkC = SkS.accept(); SkC.close();
System.out.println("Connexion acceptée: "+SkC.getInetAddress()); System.out.println("TCP Serveur STOP!");
// Instancier le lecteur du flux d'entrée break;
input = new BufferedReader(new } catch (IOException e) {
InputStreamReader(SkC.getInputStream())); System.err.println(e); }
// Réception et affichage des messages du client }
try { } catch (IOException e) {
while(true) { System.err.println(e); }
// lecture en boucle des lignes envoyées par le client }
message = input.readLine(); // Application principale avec appel du constructeur
if (message == null) break; // Sortie de la boucle public static void main(String[] args) {
System.out.println(message); // Affiche le message client new ServeurTCP();
} }
} catch (IOException e) { }
System.err.println(e.getMessage());
}

IvMad, 2002-2013 19 IvMad, 2002-2013 20

 Les Sockets (connecteurs réseaux) Le format d'une requête HTTP 1.0
• Le côté client: • Une requête est une ligne de trois éléments séparés 
par un espace: 'Méthode' 'URL' 'Protocole'
– La méthode (GET, POST, …)
– L'URL (Uniform Resource Locator) du fichier demandé
– La version du protocole utilisé par le client (HTTP/1.0) 
• Le côté serveur: • Les champs d'en‐tête de la requête: lignes facultatives
permettant de donner des informations sur la requête
et/ou le client (Navigateur, système d'exploitation, ...).
• Le corps de la requête: lignes optionnelles séparées
une ligne vide et permettant un envoi de données par
une commande POST lors de l'envoi de données par un
formulaire.
IvMad, 2002-2013 21 IvMad, 2002-2013 22

Serveur HTTPD (1) Serveur HTTPD (2)
import java.net.*;  import java.io.*;  import java.util.*;  if (str[0].equals("GET")) {  // Vérifier si la requête démarre par "GET"
public class monoHttpd {  req = str[1].substring(1); // On enlève '/' devant le nom du fichier
// Le serveur traite une seule connexion à la fois try {    
public static void main(String[] argv) throws IOException { FileInputStream fis = new FileInputStream(req);  
ServerSocket ss = new ServerSocket(1234);  // Ouvrir le fichier demandé
// Installation du serveur sur un port byte[] data = new byte[fis.available()];
System.out.println("Serveur HTTP sur le port 1234");    // available() retourne le nombre de bytes à lire
// Message du côté du Serveur fis.read(data);                                                   
Socket sock = ss.accept(); // ça boucle en attente de requête // Lire les données du fichier dans le tableau de bytes
try { out.write(data);
// Formater la sortie // Envoyer les données au client
OutputStream out = sock.getOutputStream(); } catch ( FileNotFoundException e )  {  
// Lecture de la requête new PrintStream(out).println("404 Not Found"); }
String req = (new BufferedReader(new  } else { new PrintStream(out).println("400 Bad Request");  } 
InputStreamReader(sock.getInputStream()))).readLine(); sock.close();
System.out.println("Requête: " + req); }  catch ( IOException e ) { 
// Traitement de la requête "GET /index.html HTTP/1.1" System.out.println("I/O error " + e.getMessage()); }    
String str[] = req.split(" "); // Décompose 'req' par le délimiteur  }    
" " et charge en éléments de tableau }
IvMad, 2002-2013 23 IvMad, 2002-2013 24
 Serveur HTTPD
Le côté Serveur

Partie XIV
La page 'index.html' Le fichier 'index.html' Programmation en Java par 
Socket en TCP
et Threads

IvMad, 2002-2013 25 IvMad, 2002-2013 26

Threads et processus
• Un thread est une portion de code capable de
s'exécuter en parallèle à d'autres traitements.
• Un thread n'est pas un processus.
• Les threads partagent la même mémoire contrairement
aux processus.
• Les threads sont utiles pour:
– faire des traitements en tâche de fond;
– exécuter plusieurs instances d'un même code pour accélérer
le traitement;
– autoriser plusieurs connexions simultanées sur un serveur
HTTP ou un chat;
– les threads s'exécutent en temps partagé.
IvMad, 2002-2013
Les Threads Java
• Lorsqu'un programme est exécuté sur un système
multitâche, l'OS crée un processus dédié, disposant de
certaine ressources (mémoire, ...).
• Un thread est une unité d'exécution plus "petite" qu'un
processus.
– Les threads issus d'un même processus partagent le même
espace mémoire chacun doté d'une certaine priorité.
– Un système multiprocesseur peut exécuter les threads d'un
programme simultanément, un sur chaque processeur.
– On utilise les threads pour améliorer la réactivité d'un 
système: pour traiter séparément une connexion réseau et  
un calcul en mémoire ou pour améliorer la réactivité d'une 
interface graphique.
27 IvMad, 2002-2013 28
 Cycle de vie des Threads Java Cycle de vie des Threads Java
• Un thread peut être dans un des cinq états suivants:
– création : le thread vient d'être créé, mais il n'a pas encore
été exécuté;
– exécutable : le thread est candidat à l'exécution, il attend que
le système lui alloue le processeur pendant une certaine
durée, appelée quantum de temps;
– en cours d'exécution : le thread est en cours d'exécution par
le processeur (sur un système monoprocesseur, un seul
thread peut se trouver dans cet état);
– bloqué : le thread a provoqué une opération bloquante ou
s'est "endormi" volontairement pour une certaine durée;
– détruit : le thread a fini son exécution ou a été arrêté par un
autre thread.

IvMad, 2002-2013 29 IvMad, 2002-2013 30

Manipulation des threads en Java
• Un thread est un objet en Java.
1. Pour utiliser des threads dans un programme, il suffit
d'hériter de la classe Thread et de redéfinir la
méthode run()
– La méthode run() est automatiquement appelée au moment
où le thread est démarré.
2. On peut procéder aussi par l'implémentation de
l'interface Runnable et instancier un objet Thread
avec l'implémentation de cette interface.
IvMad, 2002-2013
Manipulation des threads en Java
• Pour tester les threads on peut créer une classe gérant
un constructeur et un String en paramètre pour
spécifier le nom du thread.
• La classe comprend la méthode getName() pour
retourner ce nom du thread en cours.
• La classe Thread se trouvant dans le package java.lang,
alors aucune instruction import n'est nécessaire.
• Java utilise un ordonnanceur qui détermine l'ordre
d'exécution, qui s'avère souvent aléatoire.
– Lorsque l'ordonnanceur passe d'un thread à un autre, le
thread interrompu est mis en sommeil tandis que l'autre est
en éveil
31 IvMad, 2002-2013 32
 Manipulation des threads en Java TCP en plusieurs clients

L'ordre d'exécution est souvent aléatoire

IvMad, 2002-2013 33 IvMad, 2002-2013 34

TCP en plusieurs clients TCP en plusieurs clients

IvMad, 2002-2013 35 IvMad, 2002-2013 36

 Serveur HTTPD multithread Serveur HTTPD multithread
import java.net.*; class TinyHttpdConnection extends Thread {
import java.io.*; // attribut de la classe
import java.util.*; Socket sock;
public class TinyHttpd { // Constructeur de Thread
public static void main(String argv[]) { public TinyHttpdConnection(Socket s) {
try { this.sock = s;
// Instancier le serveur sur un port setPriority( NORM_PRIORITY ‐ 1 );
ServerSocket ss = new ServerSocket(4141); // Nouveau thread est créé
System.out.println("HTTPD lancé sur port 4141"); this.start();
while(true) }
// 'ss.accept()' est en attente de connexion
new TinyHttpdConnection(ss.accept());
// S'il y a connexion on instancie un thread
} catch (IOException e) { HTTPD lancé sur port 4141
System.err.println(e.getMessage()); Thread‐0
} Request: GET /fileGroupeEtudiants.html HTTP/1.1
}
}
IvMad, 2002-2013 37 IvMad, 2002-2013 38

Serveur HTTPD multithread Serveur HTTPD multithread
// méthode qui lance le thread try {
public void run() { // ouverture du fichier
try { FileInputStream fis = new FileInputStream(req);
// affiche le nom du thread lancé // coder le contenue en byte
System.out.println(this.getName()); byte[] data = new byte[fis.available()];
// flux de sortie vers le client // lecture du fichier
OutputStream out = sock.getOutputStream(); fis.read(data);
// récupère la requête // Envoi sur le réseau vers le client
String req = (new BufferedReader(new out.write(data);
InputStreamReader(sock.getInputStream()))).readLine(); } catch(FileNotFoundException e) {
System.out.println("Request: "+req); new PrintStream(out).println("404 Not Found");}
// décompose la requête } else
StringTokenizer st = new StringTokenizer( req ); new PrintStream(out).println("400 Bad Request");
if ( (st.countTokens() >= 2) && sock.close();
st.nextToken().equals("GET") ) { } catch (IOException e) {
if ( (req = st.nextToken()).startsWith("/") ) System.out.println("I/O error " + e);
req = req.substring( 1 ); }
if ( req.endsWith("/") || req.equals("") ) }
req = req + "index.html"; }

IvMad, 2002-2013 39 IvMad, 2002-2013 40