Université Aube Nouvelle

Rappel sur la programmation

(Java)

ELN4/ Laciné KABRE

Année Scolaire 2021-2022
 PLAN(cours 24 H)
• Rappel sur les principes de la programmation en java
• Héritage, interface et polymorphisme +TP
• Architecture client/serveur
• La classe [Link]
• Les sockets en java
• Les flux entrée/sortie (flot de données)
• Les protocoles de communication et Java(TCP,UDP)
• Les services Dns et java
• Les threads en java
• Travaux pratique: mise en ouevre d’un programme
client/serveur
• Évaluation
 Les étapes
• Écrire un programme dans un langage (e.g.
Java)
• Compiler le programme
– Traduire le programme dans un langage de bas
niveau (machine)
– [éventuellement optimisation]
– Produire un programme (code) exécutable
• Exécution
– Charger le programme en mémoire (typiquement en
tapant le nom du programme exécutable)
– Exécution
 Termes
• Programme source, code source
– Programme écrit dans un langage
• Code machine, code exécutable
– Programme dans un langage de machine, directement
exécutable par la machine
• Compilation (compilateur)
– Traduire un code source en code exécutable
• Interpréteur
– Certains langages n’ont pas besoin d’être traduit en code
machine
– La machine effectue la traduction sur la volée (on the fly),
instruction par instruction, et l’exécute
– E.g. Prolog, JavaScript
 Programmation
• Syntaxe d’un langage
– Comment formuler une instruction correcte
(grammaire)
• Sémantique
– Ce que l’instruction réalise
• Erreur
– de compilation: typiquement reliée à la syntaxe
– d’exécution: sémantique (souvent plus difficile à
détecter et corriger)
 Java
• Langage orienté objet
– Notions de classes, héritage, …
• Beaucoup d’outils disponibles (packages)
– JDK (Java Development Kit)
• Historique
– Sun Microsystems
– 1991: conception d'un langage indépendant du
hardware
– 1994: browser de HotJava, applets
– 1996: Microsoft et Netscape commencent à soutenir
– 1998: l‘édition Java 2: plus stable, énorme librairie
 Java
• Compiler un programme en Byte Code
– Byte code: indépendant de la machine
– Interprété par la machine

• javac [Link]
– Génère [Link]
• java programme
– Lance le programme
 Écrire un programme
public class Hello Nom de la classe
{
public static void main(String[] args) Une méthode
{
// afficher une salutation commentaire
[Link]("Hello, World!"); Une instruction
}
}

• Stocker ce programme dans le fichier [Link]

 Lancer un programme
• Compilation
– javac [Link]
– Ceci génère [Link]
• Lancer l’exécution
– java Hello
• Résultat de l’exécution
Hello, World!
 Éléments de base dans un
programme
• mots réservés: public class static void
• identificateurs: args Hello main String System out println
– main String System out println: ont une fonction prédéfinie
• littéral: "Hello World!"
• ponctuation: { accolade } [ crochet ] ( parenthèse )
• Commentaires
– // note importante pour comprendre cette partie du code
– /* … commentaires sur plusieurs lignes
*/
 Classe
• Un programme en Java est défini comme une classe
• Dans une classe:
– attributs, méthodes
• L'en-tête de la classe
public class NomDeClasse
– public = tout le monde peut utiliser cette classe
– class = unité de base des programmes OO
• Une classe par fichier
• La classe NomDeClasse doit être dans le fichier
[Link]
• Si plus d’une classe dans un fichier .java, javac génère
des fichiers .class séparés pour chaque classe
 Classe
• Le corps
{
…
}
• Contient les attributs et les méthodes
– Attributs: pour stocker les informations de la classe
– Méthodes: pour définir ses comportement, ses traitements, …
• Conventions et habitudes
– nom de classe: NomDeClasse
– indentation de { }
– indentation de ...
– Les indentations correctes ne seront pas toujours suivies dans ces
notes pour des raisons de contraintes d’espace par PowerPoint…
 Méthode: en-tête
• L'en-tête:
public static void main(String[] args)
– main: nom de méthode
– void: aucune sortie (ne retourne rien)
– String[] args: le paramètre (entrée)
• String[]: le type du paramètre
• args: le nom du paramètre
• Conventions
– nomDeParametre
– nomDeMethode
– nomDAttributs
– nomDObjet
 Méthode: corps
• Le corps:
{
// afficher une salutation
[Link]("Hello, World!");
}
• contient une séquence d'instructions, délimitée
par { }
– // afficher une salutation : commentaire
– [Link]("Hello, World!"): appel de méthode
• les instructions sont terminées par le caractère ;
 Méthode: corps
• En général:
[Link](<liste des paramètres>)
– [Link]: l'objet qui représente le terminal (l’écran)
– println: la méthode qui imprime son paramètre (+ une fin
de ligne) sur un stream (écran)
[Link]("Hello, World!");
– "Hello, World!": le paramètre de println
• La méthode main
– “java Hello” exécute la méthode main dans la classe
Hello
– main est la méthode exécutée automatiquement à
l’invocation du programme (avec le nom de la classe) qui
la contient
 Variable
• Variable: contient une valeur
– Nom de variable
– Valeur contenue dans la variable
– Type de valeur contenue
• int: entier, long: entier avec plus de capacité
• Integer: classe entier, avec des méthodes
• float: nombre réel avec point flottant, double: double précision
• String: chaîne de caractères ("Hello, World!")
• char: un caractère en Unicode (‘a’, ‘$’, ‘é’, …)
• booleen: true/false
• Définition générale
Type nomDeVariable;

Exemple: int age;

Type: int 0
Nom: age
 Modifier la valeur
• Affecter une valeur à une variable
• E.g. age = 25;
Type: int 25

Nom: age

• Erreur si: age = "vingt cinq";

– Type de valeur incompatible avec la variable
 Condition et test
• Une condition correspond à vrai ou faux
• E.g. (age < 50)
• Tester une condition:
if condition A; else B;
– si condition est satisfaite, alors on fait A;
– sinon, on fait B
– E.g. if (age < 65)
[Link]("jeune");
else
[Link]("vieux");
 Tests
• Pour les valeurs primitives (int, double, …)
– x == y : x et y ont la même valeur?
– x > y, x >= y, x != y, …
– Attention: (== != =)
• Pour les références à un objet
– x == y : x et y pointent vers le même objet?
– [Link](y): retourne -1, 0 ou 1 selon
l’ordre entre le contenu des objets référés par
x et y
 Un exemple de test
public class Salutation
{ args[0]: premier argument
public static void main(String[] args) après le nom
{
int age; [Link](args[0]):
age = [Link](args[0]); reconnaître et transmettre
// afficher une salutation selon l’age la valeur entière qu’il
[Link](“Salut, le "); représente
if (age < 65)
[Link](“jeune!");
print: sans retour à la ligne
else
println: avec retour à la ligne
[Link](“vieux!");
}
}
• Utilisation:
– java Salutation 20 // ici, args[0] = "20"
Salut le jeune!
– java Salutation 70
Salut le vieux!
Attention: Attention:
un ; après le for( ), itère sur ‘i’ n’est déclarée ici qu’à
la condition, et ‘somme’ ne sera
incrémentée qu’une seule fois Boucle l’intérieur de la boucle for

• Pour traiter beaucoup de données en série

• Schémas Schéma d’exécution
– Boucle for
somme=0;
int somme = 0;
for (int i = 0; i<10; i++) somme = somme + i;
– Boucle while i=0;
int somme = 0;
int i = 0; i<10?
while (i<10) { somme = somme + i; oui
i++; non somme=somme+i;
} i++;
• Que font ces deux boucles?

i: 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10

somme: 0 0, 1, 3, 6, 10, 15, 21, 28, 36, 45, sortie

 Schéma d’exécution
Boucle somme=0;

• do A while (condition) i=15;

– Faire A au moins une fois
– Tester la condition pour savoir s’il faut refaire A
i<10?
int somme = 0;
oui
int i = 15;
while (i<10) { somme = somme + i; non somme=somme+i;
i++; i++;
}
somme = 0
Schéma d’exécution
somme=0;
int somme = 0;
int i = 15;
do { somme = somme + i; i=15;
i++;
} somme=somme+i;
while (i<10) i++;

somme = 15 i<10? oui

non
 Exemple
• Calcul des intérêts
• Étant donné le solde initial, le solde souhaité et
le taux d'intérêt, combien d'années seront
nécessaires pour atteindre le solde souhaité
– au lieu d'utiliser une formule, on simule le calcul
• Algorithme (pseudocode):
1. ans = 0;
2. WHILE solde n'atteint pas le solde souhaité
3. incrémenter ans
4. ajouter l'intérêt au solde
 Programme
public void nombreAnnees (double balance, double targetBalance,
double rate ) {
int years = 0;
while (balance < targetBalance) {
years++; years = years + 1;
double interest = balance * rate;
balance += interest; balance = balance + interest;
}
[Link](years + " years are needed");
}

Appel de la méthode:
nombreAnnees(1000, 1500, 0.05)
Résultat:
56 years are needed
 Factorielle
public class Factorielle
{ Si une méthode (ou un
public static double factorielle(int x) {
attribut, une variable) de la
if (x < 0) return 0.0;
double fact = 1.0; classe est utilisée par la
while (x > 1) { méthode main (static), il
fact = fact * x; faut qu’il soit aussi static.
x = x - 1;
}
return fact;
}

public static void main(String[] args) {

int entree = [Link](args[0]);
double resultat = factorielle(entree);
[Link](resultat);
}
}
 Attention:
Array [Link]
Tableau Array list
String
[Link]()
[Link]()

• Pour stocker une série de données de même nature

• Déclaration
int [] nombre; // une série de valeurs int dans le tableau nommé nombre
String [][] etiquette; // un tableau à deux dimensions de valeurs String
• Création
nombre = new int[10]; // crée les cases nombre[0] à nombre[9]
etiquette = new String[3][5]; // crée etiquette[0][0] à etiquette[2][4]
int[] primes = {1, 2, 3, 5, 7, 7+4}; // déclare, crée de la bonne taille et initialise
• Utilisation
nombre[0] = 4;
for (int i=1; i<[Link]; i++) nombre[i]=nombre[i]+1;
etiquette[2][3] = "un texte";
String texte = etiquette[2][3];
 String
• Structure à deux parties:
– En-tête: nom, longueur, …
– Corps: les caractères
etiquette[2][3]
u n t e x t e
texte
– String texte = etiquette[2][3];
– Le contenu du corps ne peut pas être changé, une fois qu’il
est créé (String est immutable)
– Par contre, on peut pointer/référer etiquette[2][3] à un autre
corps: etiquette[2][3] = "autre texte";

etiquette[2][3] a u t r e t e x t e

texte u n t e x t e
 Classe et Objet
• Classe: moule pour fabriquer des objets
• Objet: élément concret produit par le moule
• Définition de classe:
class NomClasse { class Personne {
Attributs; String nom;
Méthodes; int AnneeNaissance;
} public int age() {…}
}

• Une classe regroupe un ensemble d’objets

(instances)
 Objet
• Structure à deux parties:
– Référence
– Corps
• Les étapes
– Déclaration de la classe (e.g. Personne)
– À l’endroit où on utilise:
• Déclarer une référence du type de la classe
• Créer une instance d’objet (new)
• Manipuler l’objet
 Exemple
public class Personne {
public String nom;
public int anneeNaissance;
public int age() {return 2008 - anneeNaissance; }
}
class Utilisation {
public static void main(String[] args) {
Déclaration de référence
Personne qui;
qui = new Personne(); Création d’une instance
[Link] = "Pierre";
[Link] = 1980; Manipulation de l’instance
[Link]([Link]()); référée par la référence
}
}
qui nom: "Pierre"
anneeNaissance: 1980
Personne:
age()
 Un autre exemple
class Circle {
public double x, y; // coordonnées du centre ‘r’ est inaccessible de
private double r; // rayon du cercle l’extérieur de la classe
public Circle(double r) {
this.r = r;
} constructeur
public double area() {
return 3.14159 * r * r;
}
} [Link]
public class MonPremierProgramme {
public static void main(String[] args) {
Circle c; // c est une référence sur un objet de type Circle, pas encore un objet
c = new Circle(5.0); // c référence maintenant un objet alloué en mémoire
c.x = c.y = 10; // ces valeurs sont stockées dans le corps de l’objet
[Link]("Aire de c :" + [Link]());
}
}
 Constructeurs d’une classe
• Un constructeur est une façon de fabriquer une instance
• Une classe peut posséder plusieurs constructeurs
• Si aucun constructeur n’est déclaré par le programmeur, alors on a la version
par défaut: NomClasse()
• Plusieurs versions d’une méthode: surcharge (overloading)

class Circle {
public double x, y; // coordonnées du centre
private double r; // rayon du cercle
public Circle(double r) { this: réfère à l’objet courant
this.r = r;
}
public Circle(double a, double b, double c) {
x = a; y = b; r = c;
}
} Le constructeur
public class Personne { Personne() est
public String nom; déclaré par défaut
public int anneeNaissance;
public int age() { return 2008 - anneeNaissance; }
}
 Manipulation des références
class Circle {
public double x, y; // coordonnées du centre
private double r; // rayon du cercle
public Circle(double r) {
this.r = r;
}
public Circle(double a, double b, double c) {
x = a; y = b; r = c;
}
}
// Dans une méthode, par exemple, main:
Circle c1, c2;
c1 = new Circle(2.0, 3.0, 4.0);
c2 = c1; // c2 et c1 pointent vers le même objet
c2.r = c2.r – 1; // l’objet a le rayon réduit
c1 = new Circle(2.0); // c1 point vers un autre objet, mais c2 ne change pas
c1.x = 2.0; // on modifie le deuxième objet
c2 = c1; // maintenant, c2 pointe vers le 2ième objet aussi

• Que faire du premier objet?

– Aucune référence ne pointe vers lui
– L’objet est perdu et inutilisable
– Ramasse miette (garbage collector) va récupérer l’espace occupé par l’objet
• Comparaison des références
– (c1 == c2): est-ce que c1 et c2 pointent vers le même objet?
 Illustration
c1
null
1. Cercle c1, c2; 1 c2
x: 2.0
c1 y: 3.0
2. c1 = new Cercle(2.0, 3.0, 4.0); 2 r: 4.0
c2
x: 2.0
null
c1 y: 3.0
3. c2 = c1; 3 r: 4.0
c2
null x: 2.0
c1 y: 3.0
4. c2.r = c2.r – 1; 4 r: 3.0
c2
null
x: 2.0
c1 y: 3.0
5. c1 = new Cercle(2.0); 5 r: 3.0

x: 2.0 c2
x: 0.0
c1 y: 3.0 y: 0.0
r: 3.0
6. c1.x = 2.0; 6 c2
r: 2.0

x: 2.0 x: 2.0
y: 0.0 c1 y: 3.0
r: 2.0 7. c2 = c1; 7 r: 3.0
c2
x: 2.0
y: 0.0
r: 2.0
 Manipulation des objets
• Forme générale
réfé[Link]: réfère à un attribut de l’objet
référence.méthode( ): réfère à une méthode de l’objet
• static: associé à une classe
– Attribut (variable) statique: si on le change, ça change la
valeur pour tous les objets de la classe
– Méthode statique: on la réfère à partir de la classe
• Classe.méthode
• E.g. [Link](2.6): Appel à la méthode sqrt de la classe Math
• Constante: [Link]
– Dans une classe: static final float PI = 3.14159265358979;
– Une constante n’est pas modifiable
 Classes et Héritage
• Héritage
– Les enfants héritent les propriétés du parent
– Classe enfant (sous-classe) possède systématiquement les attributs et
les méthodes de la classe parent (super-classe)
– Héritage simple (une seule super-classe au plus)
• E.g.
class Personne {
String nom;
int anneeNaissance;
public int age() { return 2008 - anneeNaissance; }
} Personne
class Etudiant extends Personne {
String [] cours;
String niveau; Etudiant Professeur
String ecole;
…
} Gradue
• Ce qui est disponible dans Etudiant:
– nom, anneeNaissance, age(),
– cours, niveau, ecole, …
 Principe
• Définir les propriétés communes dans la classe
supérieure
• Définir les propriétés spécifiques dans la sous-
classe
• Regrouper les objets le plus possible
• Les objets d’une sous-classe sont aussi des
objets de la super-classe
• La classe dont tous les objets appartiennent:
Object
• Tester l’appartenance d’un objet dans une
classe: instanceof (e.g. qui instanceof Etudiant)
 Exemple
public class Ellipse {
public double r1, r2;
public Ellipse(double r1, double r2) { this.r1 = r1; this.r2 = r2; }
public double area() {...}
}
super(r,r): constructeur de la
final class Circle extends Ellipse { super-classe
public Circle(double r) {super(r, r);}
public double getRadius() {return r1;}
}
// Dans une méthode final assure qu’aucune autre
Ellipse e = new Ellipse(2.0, 4.0); classe n’héritera de Circle
Circle c = new Circle(2.0);
[Link]("Aire de e: " + [Link]() + ", Aire de c: " + [Link]());
[Link]((e instanceof Circle)); // false
[Link]((e instanceof Ellipse)); // true
[Link]((c instanceof Circle)); // true
[Link]((c instanceof Ellipse)); // true (car Circle dérive de Ellipse)
e = c;
[Link]((e instanceof Circle)); // true
[Link]((e instanceof Ellipse)); // true
int r = [Link](); // erreur: méthode getRadius n’est pas trouvée dans la classe Ellipse
c = e; // erreur: type incompatible pour = Doit utiliser un cast explicite
 Casting
• La classe de la référence détermine ce qui est disponible (a priori)
• E.g.
class A {
public void meth() { [Link]("Salut"); }
}
class B extends A {
int var;
}

A a = new A();
B b = new B();
[Link](); // OK
[Link](); // OK, héritée
[Link] = 1; // OK
[Link] = 2; // erreur
a = b;
[Link] = 2; // erreur: var n’est a priori pas disponible pour une classe A
((B) a).var = 2; // OK, casting

• Casting: transforme une référence d’une super-classe à celle d’une sous-classe

• Condition: l’objet référé est bien de la sous-classe
 Surcharge de méthode
class A {
public void meth() {[Link]("Salut"); }
}
class B extends A {
public void meth(String nom) {
[Link]("Salut" +nom);
}
}
• Dans la sous-classe: une version additionnelle
– Signature de méthode: nom+type de paramètres
– Surcharge: créer une méthode ayant une autre signature
 Overriding: écrasement
• Par défaut, une méthode est héritée par une sous-classe
• Mais on peut redéfinir la méthode dans la sous-classe (avec la même
signature)
• Les objets de la sous-classe ne possèdent que la nouvelle version de la
méthode
• E.g.
class A {
public void meth() {[Link]("Salut");}
}
class B extends A {
public void meth() {[Link]("Hello");}
}

A a = new A();
B b = new B();
[Link](); // Salut
[Link](); // Hello
a = b; // a réfère à un objet de classe B
[Link](); // Hello. Même si la référence est de classe A, l’objet est de classe B
 Classe abstraite
• Certains éléments peuvent être manquants dans une
classe, ou la classe peut être trop abstraite pour
correspondre à un objet concret
• Classe abstraite
– Une classe non complétée ou une classe
conceptuellement trop abstraite
• Classe Shape
– on ne connaît pas la forme exacte, donc impossible de créer un
objet
– cependant, on peut savoir que chaque Shape peut être
dessinée
abstract class Shape {
abstract void draw();
}
 Interface
• Interface
– Un ensemble de méthodes (comportements) exigées
– Une classe peut se déclarer conforme à (implanter) une
interface: dans ce cas, elle doit implanter toutes les méthodes
exigées
• E.g.
public abstract interface Inter {
public abstract int carre(int a);
public abstract void imprimer();
}
class X implements Inter {
public int carre(int a) { return a*a; }
public void imprimer() {[Link]("des informations"); }
}
 Exemple
abstract class Shape { public abstract double perimeter(); }
interface Drawable { public void draw(); }
class Circle extends Shape implements Drawable, Serializable {
public double perimeter() { return 2 * [Link] * r ; }
public void draw() {...}
}
class Rectangle extends Shape implements Drawable, Serializable {
public double perimeter() { return 2 * (height + width); }
public void draw() {...}
}
...
Drawable[] drawables = {new Circle(2), new Rectangle(2,3),
new Circle(5)};
for(int i=0; i<[Link]; i++)
drawables[i].draw();
 Utilité de l’interface
• Permet de savoir qu’une classe contient
les implantations de certaines méthodes
• On peut utiliser ces méthodes sans
connaître les détails de leur implantation
• Souvent utilisée pour des types abstraits
de données (e.g. pile, queue, …)
 Package
• On organise les classes et les outils selon leurs
fonctionnalités et les objets qu’elles manipulent
• Les classes qui traitent les mêmes objets: package
• Exemple:
– Les classes pour traiter l’interface graphique sont dans le
package awt
• Organisation des packages
– Hiérarchie java javax
• [Link]
• [Link] awt swing
• [Link]
• … event
classes

classes
 Utiliser les packages existants
• Au début d’un fichier, importer les classes d’un
package
• import [Link].*;
– Importer toutes les classes du package [Link]
(reliées aux fenêtres)
• import [Link].*;
– Importer toutes les classes du package
[Link] (reliées au traitement d’événements)
 Exception
• Quand un cas non prévu survient, il est possible de le
capter et le traiter par le mécanisme d’Exception
– Si on capte et traite une exception, le programme peut continuer
à se dérouler
– Sinon, le programme sort de l’exécution avec un message
d’erreur
– Exemple d’exception: division par 0, ouvrir un fichier qui n’existe
pas, …
• Mécanisme de traitement d’exception
– Définir des classes d’exception
• Exception
– IOException
» EOFException, …
– Utiliser try-catch pour capter et traiter des exceptions
Hiérarchie des classes d’exceptions
 Attraper (catch) une exception
• Attraper une exception pour la traiter
try { Bloc où une exception
statements
: peut se générer
:
} catch (ExceptionClass1 object) {
statements
:
:
} catch (ExceptionClass2 object) {
statements Blocs pour attraper
: les exceptions
:
}…
 Exemple
public static void ouvrir_fichier(String nom) {
try {
ouverture
input = new BufferedReader(new FileReader(nom));
d’un fichier
}
catch (IOException e) {
[Link]("Impossible d'ouvrir le fichier d'entree.\n" +
[Link]());
[Link](1);
}
}

try: on tente d’effectuer des opérations

catch: si une exception de tel type survient au cours, on la traite de cette façon
 finally
• Souvent combiné avec catch
try
{
statements
...
}
catch (ExceptionClass exceptionObject)
{
statements
...
} Même si une exception est
finally attrapée, finally sera toujours
{ exécuté
statements
... Utile pour s’assurer de certaine
} sécurité (cleanup)
 Fichier
• Unité de stockage des données, sur
disque dur
• Stockage permanent (vs. en mémoire
vive)
• Un fichier contient un ensemble
d’enregistrements CPU

• Traitement
Mémoire
vive
fichier

tampon
 Fichier en Java
• Stream: une suite de données (octets ou
caractères)
 Opérations typiques
• Lecture: Établir un canal de
communication
– Ouvrir un stream
– Lire tant qu’il y a des données
– Fermer le stream Relâcher les
• Écriture ressources allouées

– Ouvrir un stream (ou créer un fichier)

– Écrire des données tant qu’il y en a
– Fermer le stream
Écrire ce qu’il est dans le
tampon, et relâcher les
ressources allouées
 Exemple
public static void main(String[] args) { public static void traiter_fichier() {
ouvrir_fichier("liste_mots"); String ligne;
traiter_fichier(); try { // catch EOFException
fermer_fichier();
ligne = [Link]();
}
while (ligne != null) {
public static void ouvrir_fichier(String nom) { [Link](ligne);
try { ligne = [Link]();
input = new BufferedReader( }
new FileReader(nom)); }
}
public static void fermer_fichier() {
catch (IOException e) {
try {
[Link]("Impossible
d'ouvrir le fichier d'entree.\n" + [Link]();
[Link]()); [Link](0);
[Link](1); }
} catch (IOException e) {
} [Link]("Impossible de
fermer les fichiers.\n" + [Link]());
}
}
 Deux unités de base
• Caractère (2 octets=16 bits) ou octet (8
bits)
• Deux hiérarchies de classes similaires
(mais en parallèle)
 Hiérarchies
• En haut des hiérarchies pour stream de
caractères: 2 classes abstraites
• Reader
[Link]
[Link]
• Writer
[Link]
[Link]
• Implantent une partie des méthodes pour lire et
écrire des caractères de 16 bits (2 octets)
Hiérarchie de stream de caractères
• Les sous-classes de Reader

simple pré-traitement
• Chaque sous-classe ajoute des méthodes
Hiérarchie de stream de caractères
• Les sous-classes de Writer
Hiérarchies byte stream

[Link]
Hiérarchie de byte stream

[Link]

[Link]
 Exemple
• Utiliser FileReader et FileWriter
• Méthodes simples disponibles:
– int read(), int read(CharBuffer []), write(int), ..
– Exemple: copier un fichier caractère par caractère (comme un int)

import [Link].*;
public class Copy {
public static void main(String[] args) throws IOException {
File inputFile = new File("[Link]");
File outputFile = new File("[Link]");

FileReader in = new FileReader(inputFile);

FileWriter out = new FileWriter(outputFile);
int c;
while ((c = [Link]()) != -1) [Link](c); Fin de fichier: -1
[Link]();
[Link]();
}
}
– Méthodes limitées
Augmenter les possibilités: wrap
• Créer un stream en se basant sur un autre:
FileReader in = new FileReader(new File("[Link]"));
• Avantage:
– Obtenir plus de méthodes
• Dans File: les méthodes pour gérer les fichiers (delete(),
getPath(), …) mais pas de méthode pour la lecture
• Dans FileReader: les méthodes de base pour la lecture
– Un autre exemple:
DataOutputStream out = new DataOutputStream(
new FileOutputStream("[Link]"));
• FileOutputStream: écrire des bytes
• DataOutputStream: méthodes pour les types de données de base:
write(int), writeBoolean(boolean), writeChar(int), writeDouble(double),
writeFloat(float), …
 Sérialiser
• Convertir un objet (avec une structure) en une
suite de données dans un fichier
• Reconvertir du fichier en un objet
• Utilisation: avec ObjectOutputStream

Employee[] staff = new Employee[3];

ObjectOutputStream out = new ObjectOutputStream(new
FileOutputStream("[Link]"));
[Link](staff);
[Link]();
 Sérialiser
• Utilité de sérialisation
– Stocker un objet dans un fichier
– Créer une copie d’objet en mémoire
– Transmettre un objet à distance
• Devient une transmission de String
 Interface graphique
• Comment créer des fenêtres?
• Comment gérer les interactions avec
l’utilisateur?
– Traiter des événements
 Généralité
Programme

Interface utilisateur

Rôles d’une interface utilisateur:

• montrer le résultat de l’exécution
• permettre à l’utilisateur d’interagir
 Exemple simple
import [Link].*; Importer le package
public class DisplayFrame {
Créer un
public static void main (String[] args) {
objet
JFrame f = new JFrame("FrameDemo");
//… components are added to its content frame.
[Link](300,200); Définir la taille
[Link](JFrame.EXIT_ON_CLOSE);
[Link](true);
}
} afficher
 Afficher une interface
• Importer le package (les classes)
– Les classes sont regroupées en package
– Importer un package = importer toutes les classes du
package
– import [Link].*;
• Créer une fenêtre graphique (JFrame, …)
• Mettre les paramètres (taille, …)
• Afficher
• Différence:
– import [Link].*; les classes dans awt
– import [Link].*; les classes dans event
 Insérer des éléments dans la
fenêtre
• Composition d’une fenêtre JFrame

Structure interne de Jframe

Typiquement, on insère des éléments graphiques dans ContentPane
 Ajouter des composants dans une
fenêtre
import [Link].*;
public class DisplayFrame {
public static void main (String[] args) { Haut niveau

JFrame f = new JFrame("FrameDemo"); Composante

JLabel label = new JLabel("Hello World"); de base
JPanel p = (JPanel)[Link](); Niveau
[Link](label); intermédiaire
[Link](300,200); //alternative: [Link]();
[Link](JFrame.EXIT_ON_CLOSE);
[Link](true);
}
}
 Composer une fenêtre
• Créer une fenêtre (1)
• Créer un ou des composants intermédiaires (2)
– Pour JFrame, un JPanel est associé implicitement
(ContentPane)
• Créer des composants de base (3)

• Insérer (3) dans (2)

• Insérer (2) dans (1)

• Afficher
 Composants de base
pour obtenir des données
• JButton
• JCheckBox a toggled on/off button displaying state to user.
• JRadioButton a toggled on/off button displaying its state to user.
• JComboBox a drop-down list with optional editable text field. The
user can key in a value or select a value from drop-down list.
• Jlist allows a user to select one or more items from a list.
• Jmenu popup list of items from which the user can select.
• Jslider lets user select a value by sliding a knob.
• JTextField area for entering a single line of input.
 Composants de base
pour afficher l’information
• Jlabel contains text string, an image, or both.

• JProgressBar communicates progress of some work.

• JToolTip describes purpose of another component.

• Jtree a component that displays hierarchical data in outline form.

• Jtable a component user to edit and display data in a two-dimensional

grid.

• JTextArea, JTextPane, JEditorPane

– define multi-line areas for displaying, entering, and editing text.
Swing components: Illustration
 Définir ses propres classes
01: import [Link];
02: import [Link].Graphics2D;
03: import [Link];
04: import [Link];
05: import [Link];
06:
07: /**
08: A component that draws two rectangles.
09: */
10: public class RectangleComponent extends JComponent
11: {
12: public void paintComponent (Graphics g)
13: {
14: // Recover Graphics2D
15: Graphics2D g2 = (Graphics2D) g;
16:
17: // Construct a rectangle and draw it
18: Rectangle box = new Rectangle(5, 10, 20, 30);
19: [Link](box);
20:
21: // Move rectangle 15 units to the right and 25 units down
22: [Link](15, 25);
23:
24: // Draw moved rectangle
25: [Link](box);
26: }
27: }
 Créer et voir l’objet
01: import [Link];
02:
03: public class RectangleViewer
04: {
05: public static void main(String[] args)
06: {
07: JFrame frame = new JFrame();
08:
09: final int FRAME_WIDTH = 300;
10: final int FRAME_HEIGHT = 400;
11:
12: [Link](FRAME_WIDTH, FRAME_HEIGHT);
13: [Link]("Two rectangles");
14: [Link](JFrame.EXIT_ON_CLOSE);
15:
16: RectangleComponent component = new RectangleComponent();
17: [Link](component);
18:
19: [Link](true);
20: }
21: }
 Alternative de JFrame: JApplet
• Applet = une fenêtre dans un navigateur
• Permet à n’importe quel utilisateur de
lancer une application
• Plus de contrainte de sécurité (pas
d’écriture)
• Programme englobé dans une page Web
 Afficher deux Rectangles
01: import [Link];
02: import [Link].Graphics2D;
03: import [Link];
04: import [Link];
05:
06: /**
07: An applet that draws two rectangles.
08: */
09: public class RectangleApplet extends JApplet
10: {
Au lancement, paint(…)
11: public void paint (Graphics g) est automatiquement
12: {
13: // Prepare for extended graphics
exécutée
14: Graphics2D g2 = (Graphics2D) g;
15: Pour ré-exécuter: repaint()
16: // Construct a rectangle and draw it
17: Rectangle box = new Rectangle(5, 10, 20, 30);
18: [Link](box);
19:
20: // Move rectangle 15 units to the right and 25 units down
21: [Link](15, 25);
22:
23: // Draw moved rectangle
24: [Link](box);
25: }
26: }
27:
 Lancer un Applet
À partir d’une page Web:
<html>
<head>
<title>Two rectangles</title>
</head>
<body>
<p>Here is my <i>first applet</i>:</p>
<applet code="[Link]" width="300" height="400">
</applet>
</body>
</html>
Différence
 Événement
• Les événements sont des objets
• Sous-classes de la class abstraite [Link]
• Les composants génèrent des événements
• Événements: chaque interaction de l’utilisateur sur un
composant génère un événement
– bouger la souris
– cliquer sur un bouton
– fermer une fenêtre
– …
• Un événement contient des informations: source, type
d’événement, …
public Object getSource();
– Utile pour détecter d’où provient l’événement
 Propagation et traitement des
événements
Composant a: Objet b qui capte
Génère un e l’événement de
événement e l’objet a, du type T:
du type T Traitement de e

• Les événements sont générés et propagés

• Certains autres objets sont capables de capter des événements des types
spécifiés, provenant de ces composants
– b écoute les événements du type T venant de a
– b est un listener de a
• On peut activer le traitement suite à la capture d’un événement
– Le traitement lancé par l’objet b

• Programmation par événement

– Le programme réagit aux événements
 Listener et Event handler: donner la
capacité d’entendre un événement
• Listener: Un objet est intéressé à écouter l’événement
produit (être signalé quand il y a un événement)
• Listener doit implanter l’interface event listener
interface associée à chaque type d’événement
• Event Handler: le programme qui lance un traitement
suite à un événement
• Exemple classe
Type d’événement écouté
public class Capteur implements ActionListener
{
public void actionPerformed(ActionEvent e) { … }
} Action déclenchée
 // Liens d'ecoute
Exemple: changer la couleur [Link](this);
import [Link].*;
[Link](this);
import [Link].*;
}
import [Link].*;
// affichage
public class JAppletExample public void paint(Graphics g)
extends JApplet {
implements ActionListener [Link](g);
{ [Link](couleur);
private JButton rouge, bleu; [Link]("Choisir une couleur.",
private Color couleur = [Link]; 100, 100);
}
public void init()
{ // methode qui reagit aux evenements
rouge = new JButton("Rouge"); public void actionPerformed
bleu = new JButton("Bleu"); (ActionEvent e)
{
Container content = if ([Link]() == rouge)
getContentPane(); couleur=[Link];
[Link](new else if ([Link]() == bleu) couleur =
FlowLayout()); [Link];
[Link](rouge); repaint(); //appeler paint(...) pour
repaindre
[Link](bleu);
}
Types d’événements et écouteur
• ActionEvent, ActionListener:
– Button, List, TextField, MenuItem, JButton, …
– public void actionPerformed(ActionEvent)
• AdjustmentEvent, AdjustmentListener
– Scrollbar, ScrollPane, …
– public void
adjustmentValueChanged(AdjustmentEvent)
• ItemEvent, ItemListener
– Checkbox, CheckboxMenuItem, Choice, List
– public void itemStateChanged(ItemEvent)
Types d’événements et écouteur
• MouseEvent
– Souris
– MouseListener
• public void mouseDragged(MouseEvent)
• public void mouseMoved(MouseEvent)
– MouseMotionListener
• public void mousePressed(MouseEvent)
• public void mouseReleased(MouseEvent)
• public void mouseEntered(MouseEvent)
• public void mouseExited(MouseEvent)
• public void mouseClicked(MouseEvent)
• TextEvent, TextListener
– TextComponent et ses sous-classes
– public void textValueChanged(TextEvent)
 Télécommunication en Java
• Communication sur l’Internet
• Connexion dans Java
 Internet
• Stockage de données (informations)
– Serveur
– Client
• Connexion
– Connexion entre un client et un serveur
– Un canal de communication
• Transmission
– Protocole:
• définit les commandes
• le format de données transmises
Schéma de communication typique
• Serveur:
– Il est lancé, en attente de recevoir un message (commande)
• Client
– Demande à établir une connexion avec le serveur
– Transmet une commande au serveur
• Serveur
– Reçoit la commande
– Traite la commande
– Renvoie la réponse
• Client
– Reçoit la réponse
– Continue à traiter, transmet une autre commande, …
 Établir une connexion
• Identifier l’adresse du serveur à laquelle envoyer une
requête de connexion
• Adresse:
– Adresse IP (Internet Protocol): 4 octets (4 entiers 0-255)
– [Link]
• Domain Naming Service (DNS): le nom correspondant à
une adresse IP
– Ss_domaine. sous_domaine . domaine
– [Link], [Link]
– Traduction de DNS en adresse IP: par un serveur DNS
• Serveur
– Prêt à recevoir des requêtes des types préétablis
– E.g. GET
 Protocole
• Un serveur est établi pour communiquer selon un
protocole
• Canal de communication (numéro de port)
– 0 and 65,535
– HTTP: par défaut: 80
• Serveur Web: prêt à recevoir les requêtes HTTP:
– Adresse d’un document:
• Uniform Resource Locator (URL)
• [Link]/[Link]
– Commande
– GET /[Link] HTTP/1.0 (suivie d’une ligne blanche)
– [Link]
 Protocole HTTP
Commande Signification
• GET Return the requested item
• HEAD Request only the header
information of an item
• OPTIONS Request communications
options of an item
• POST Supply input to a server-side
command and return the result
• PUT Store an item on the server
• DELETE Delete an item on the server
• TRACE Trace server communication
 En Java
• Établir une connexion avec un serveur Web
– Créer un socket entre Client et Serveur
– Socket s = new Socket(hostname, portnumber);
– Socket s = new Socket("[Link]", 80);
 En Java
• Obtenir les streams du socket
InputStream instream = [Link]();
OutputStream outstream = [Link]();
• Cast les streams
Scanner in = new Scanner(instream);
PrintWriter out = new PrintWriter(outstream);
• Fermer le socket
[Link]();
 Exemple
• Un programme pour obtenir une page web d’un
site
– établir une connexion avec un serveur
– envoyer une requête
– recevoir la réponse
– fermer

java WebGet [Link] /

– Lancer WebGet avec 2 paramètres:
• [Link]: DNS
• /: page racine
• Port par défaut: 80
01: import [Link]; 37: final int HTTP_PORT = 80;
02: import [Link]; 38: Socket s = new Socket(host, HTTP_PORT);
03: import [Link]; 39:
04: import [Link]; 42: InputStream instream = [Link]();
05: import [Link]; 43: OutputStream outstream =
06: import [Link]; [Link]();
07: 44:
47: Scanner in = new Scanner(instream);
14: public class WebGet 48: PrintWriter out = new
15: { PrintWriter(outstream);
16: public static void main(String[] args) throws 49:
IOException 52: String command = "GET " + resource + "
17: { HTTP/1.0\n\n";
19: 53: [Link](command);
20: String host; 54: [Link]();
21: String resource; 55:
22: 58: while ([Link]())
23: if ([Link] == 2) 59: {
24: { 60: String input = [Link]();
25: host = args[0]; 61: [Link](input);
26: resource = args[1]; 62: }
27: } 63:
28: else 66: [Link]();
29: { 67: }
30: [Link]("Getting / from 68: }
[Link]");
31: host = "[Link]";
32: resource = "/";
33: }
34:
 Résultat: java WebGet
HTTP/1.1 200 OK
Server: Sun-Java-System-Web-Server/6.1
Date: Tue, 28 Mar 2006 20:07:26 GMT
Content-type: text/html;charset=ISO-8859-1
Set-Cookie: SUN_ID=[Link]:218361143576446; EXPIRES=Wednesday, 31-Dec-2025
23:59:59 GMT; DOMAIN=.[Link]; PATH=/
Set-cookie: JSESSIONID=519A024C45B4C300DA868D076CA33448;Path=/
Connection: close

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "[Link]

g/TR/html4/[Link]">
<html>
<head>
<title>Java Technology</title>
<meta name="keywords" content="Java, platform" />
<meta name="collection" content="reference">
<meta name="description" content="Java technology is a portfolio of products tha
t are based on the power of networks and the idea that the same software should
run on many different kinds of systems and devices." />
<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1"/>
<meta name="date" content="2006-03-23" />
…
 Résumé sur Java
• Programmation classique: traiter des données
des types primitifs
• Programmation OO: regrouper les données
(attributs) et leurs traitements (méthodes)
• Outils disponibles
– Classes regroupées dans des packages
• Interface graphique
• Communication à travers l’Internet
• Package pour interagir avec un SGBD (Système de gestion
de base de données)
• …
 À retenir
• Programme = ?
• Comment un programme est traduit en code
exécutable? (compilation ou interprétation)
• Environnement de programmation
• Quels sont les opérations qu’on peut mettre
dans un programme?
• Concept de base: variable, type, classe, objet,
héritage (OO), …
• Utilisation des packages existants
• Principe de gestion d’interface graphique
• Principe de télécommunication en Java
Mise en œuvre de la classe Livre,
les propriétés sont :
Titre
Auteur;
Nombre de page;
Éditeur.