LelangageJava CoursElec5–EPUusers.polytech.unice.fr/~vg/ressources/Java.pdf · LelangageJava...

Le langage Java

Cours Elec5 – EPU

Granet Vincent

12 octobre 2016

0-0

Bibliography

V. Granet U.N.S.A. Le langage Java 1

Part 1: Bibliography

References

[1] Vincent Granet and Jean-Pierre Regourd.

Aide-Memoire de Java. Dunod, 2 edition,

2008.

[2] Bertrand Meyer. Conception et

Programmation orientees objet. Eyrolles, 2000.

[3] Walter Savitch. Java, an Introduction to

Computer Science and Programming.

Prentice-Hall, 1999.

[4] H.M. Deitel and P.J. Deitel. Java. How to

program. Prentice-Hall, 1998.

[5] J. Skansholm. Java From the Beginning.

Addison Wesley, 2000.

[6] R. Lafore. Data Structures and Algorithms in

Java. Wait Group Press, 1998.

[7] Vincent Granet. Algorithmique et

programmation en Java. Dunod, 2 edition,

2004.

[8] Web Java. voir http://java.sun.com.


Introduction


Part 2: Introduction

Langage a objets vs langage procedural

— criteres de justesse et fiabilite

— structuration autour des actions

programmation descendante par

raffinements successifs

— structuration autour des objets

perinite des objets par rapport aux actions

objet = attributs + methodes— programme = collection d’objets

dynamiques qui sont en interaction

— envoie de messages

— extensibilite, compatibilite, reutilisabilite



Historique

— 1991, J. Gosling et Sun. Langage pour

programmer des processeurs embarques

dans des appareils electromenagers

— Origine du nom : Oak puis Java (kawa)

— 1994, Java utilise pour ecrire un navigateur

Web (futur HotJava)

— Netscape inclut un interprete Java dans

son navigateur

— 2000, Java 2 (J2SE - J2EE)

— Java langage de programmation a usage

general + application pour le Web (applet

= little application)

— Java embarque : PDA, telephones mobiles

— 2009 Oracle rachete Sun

— 2011, Java 7

— 2014, Java 8 - λ-fonctions



Avantages

— langage a objets

— syntaxe simple

— notation issue de C

— portabilite

— API tres vaste

— javadoc

— interfaces graphiques (awt, Swing)

— environnement jdk gratuit



Inconvenients

— produit industriel

— temps d’execution - Interpretation (mais

JIT)

— API tres (trop ?) vaste, difficile a maıtriser

— constructions archaıques issues de C

— temps reel



Premieres applications

/* ma premiere application Java */

c l a s s HelloWorld {

pub l i c s t a t i c void main(String [] args) {

System.out.println("Hello World!");

}

} // fin classe HelloWorld

/* ma premiere applet Java */

import java.awt.Graphics ;

import java.applet.Applet;

pub l i c c l a s s HelloWorldApplet extends Applet {

pub l i c void paint(Graphics g) {

g.drawString("Hello World!", 5, 25);

}

} // fin classe HelloWorldApplet



Compter les caracteres

/** La classe Wc ecrit le nombre de caracteres

* lus sur l’entree standard

*/

import java.io.*;

pub l i c c l a s s Wc {

pub l i c s t a t i c void main (String [] args)

throws IOException

{

i n t nbc = 0; // compteur de caracteres

whi le (System.in.read () != -1)

nbc++;

// fin de fichier de l’entree standard

System.out.println(nbc);

}

} // fin classe Wc



Principe de compilation

— interpretation

bytecode

source

(.java)

Java

Java

compilateur Javafichier

bytecode

(.class)

interprète

Java

Java

Java

— la variable CLASSPATH

— Production code a la volee (JIT)



Comment compiler et executer ?

$ javac HelloWorld.java

$ java HelloWorld

Hello World!

$ javac HelloWorldApplet.java

$ appletviewer HelloWorldApplet.html

<applet

code="HelloWorldApplet.class" width=400 height=150>

</applet>



La documentation

— javadoc

— produit une documentation en html

— traite les commentaires /** */

— reconnaıt des macros :

— @author

— @version

— @param

— @return

— @see

— ...

$ javadoc Wc.java

$ firefox index.html


Les types elementaires


Part 3: Les types elementaires

Les nombres

— Arithmetique classique

— byte (8 bits)

— short (16 bits)

— int (32 bits)

— long (64 bits)

123 0 98 067 0xAeF1

Byte.MIN VALUE Byte.MAX VALUE

Short.MIN VALUE Short.MAX VALUE

Integer.MIN VALUE Integer.MAX VALUE

Long.MIN VALUE Long.MAX VALUE

— float (32 bits)

— double (64 bits)

123.12 0. .12 98. 3.5e-7 1.5e2

Float.MIN VALUE Float.MAX VALUE

Double.MIN VALUE Double.MAX VALUE



Les booleens

— boolean

— false et true

— operateurs :

! la negation

| la disjonction

^ la disjonction exclusive

& la conjection

|| la disjonction conditionnelle

&& la conjection conditionnelle

i f (i<n && t[i]) {

....



Les caracteres

— char

— jeu de caracteres Unicode sur 16 bits

— www.unicode.org

— constantes denotees en apostrophes (e.g.

’a’, ’4’, ’ ’, etc.)

— caracteres speciaux :

\b \f \n \r \t \\ \’

— valeur hexadecimale : \uxxxx (e.g. \u0041)

— int nbEleves;

— double ∆;



Les conteneurs

— Les valeurs des types elementaires ne sont

pas des objets (au sens de la

programmation objet)

Byte Short Integer Long

Float Double

Boolean

Character

— mais conversions implicites (jdk1.5)

Integer i = 5;

char c = new Character(’z’);


Les enonces


Part 4: Les enonces

Les enonces conditionnels

— meme semantique que C

— if

— switch


Part 4: Les enonces

pub l i c s t a t i c void main (String [] args) throws IOEx

{

f i n a l double ε = 0.0001; // precision du calcul

double a = StdInput .readDouble(),

b = StdInput .readDouble(),

c = StdInput .readlnDouble(),

r1 , r2, i1 , i2, ∆;

// a6=0, b et c coefficients reels de

// l’equation du second degre, axˆ2 + bx + c

∆ = (b*b)-4*a*c;

i f (∆>=0) { // calcul des racines reelles

i f (b>0) r1 = -(b+Math.sqrt(∆))/(2*a);

e l s e r1 = (Math.sqrt(∆)-b)/(2*a);

// r1 est la racine la plus grande en valeur absolue

r2 = Math.abs(r1) < ε ? 0 : c/(a*r1);

i1 = i2 = 0;

// (x-r1)(x-r2)=0

}

e l s e { // calcul des racines complexes

r1 = r2 = -b/(2*a);

i1 = Math.sqrt(-∆)/(2*a); i2 = -i1;

}

// (x-(r1+i×i1)) (x-(r2+i×i2)) = 0

// ecrire les racines solutions sur la sortie standard

System.out.println("r1= (" + r1 + "," + i1 + ")");

System.out.println("r2= (" + r2 + "," + i2 + ")");

}


Part 4: Les enonces

Les enonces iteratifs

— meme semantique que C

— while

— do-while

— for

pub l i c s t a t i c long factorielle( long n)

// Antecedent: n > 0

// Consequent: factorielle=n!

{

long i = 0, fact = 1;

// Invariant : fact=i!

whi le (i<n) {

// fact * (i+1) = i!*(i+1) et i<n

i++;

// fact*i = i!

fact*=i;

// fact = i!

}

// i=n et fact = i! = n!

return fact;

}


Les objets


Part 5: Les objets

Objets et Classes

— application = collection d’objets

dynamiques en interaction

— objet = fournisseur de services

utilises par des clients

— programmation par contrat. B.

Meyer.

— classe = moule a objets

— une classe n’est pas un objet (en

Java)

— un objet est une instance d’une

classe

— attributs et methodes

c l a s s Rectangle {

double largeur , longueur ;

}


Part 5: Les objets

Creation des objets

Rectangle r;

r = new Rectangle();

ou

Rectangle r = new Rectangle();

largeur

longueur 0.0

0.0

r

référence

objet de type Rectangle


Part 5: Les objets

References

La variable r est une reference a l’objet, et non pas

l’objet lui-meme.

Pb de l’affectation, de la comparaison et du

passage de parametre.

Rectangle q = r;

largeur

longueur 0.0

0.0

r

référence

q

référence


Part 5: Les objets

Les constructeurs

— pour initialiser l’objet construit

— du nom de la classe

— constructeur par defaut (e.g. Rectangle())

— valeur initiale 0 (0.0, \u0000, false , null)

// construit un Rectangle de largeur l et de longueur L

Rectangle(double l, double L) {

largeur = l; longueur = L;

}

Le constructeur par defaut est perdu ! Il faut le

redefinir.

// construit un Rectangle de largeur et de longueur egales a 0

Rectangle() {

largeur = longueur = 0.0;

}


Part 5: Les objets

Destruction des objets

— automatique en Java

— a la charge du support d’execution

— va dans le sens de la securite


Part 5: Les objets

Les methodes

— procedures et fonctions

— objet = automate a etats

— une procedure modifie l’etat

— une fonction renvoie une description de

l’etat

— modele pas toujours possible


double largeur , longueur ;

// modifie la largeur du Rectangle courant

void changerLargeur(double l) {

largeur = l;

}

// renvoie le perimetre du Rectangle courant

double perimetre() {

return 2 * (largeur + longueur );

}

}


Part 5: Les objets

Acces aux attributs et aux methodes

— notation pointee

r.largeur;

r.perimetre();

— attributs publics

— attributs prives


pr iva t e double largeur , longueur ;

// modifie la largeur du Rectangle courant

pub l i c void changerLargeur(double l) {

largeur = l;

}

// renvoie le perimetre du Rectangle courant

pub l i c double perimetre() {

return 2 * (largeur + longueur );

}

}


Part 5: Les objets

Methodes et attributs statiques

s t a t i c i n t partage ;

s t a t i c void uneMethode() { ... }

— Existent independamment de la creation

des objets

— Accessibles avec le nom de la classe

System.out des attributs

Math.PI

Math.exp(13.4) des methodes

Math.sin(3.14)

StdInput.readInt()

main

Les methodes statiques remettent en cause le

modele objet !


Part 5: Les objets

Paquetages(1/2)

— Paquetage = ensemble de classes d’une

meme thematique (java.awt, java.lang,

java.math, ...)

java

applet awt io lang

javax org

package monpaquetage;

package mon.paquetage;

package java.io;

— le paquetage est un repertoire du systeme

de fichiers

— par defaut une classe appartient au

repertoire courant

— CLASSPATH


Part 5: Les objets

Paquetages(2/2)

Notation qualifiee :

java.util.Random r = new java.util.Random ();

mais

import java.util.Random;

Random r = new Random ();

Exemples

import paquetage.classe;

import paquetage.*;

import java.awt.Canvas;

import java.io.*;


Part 5: Les objets

Portees

— les classes

defaut le paquetage

public partout

— les attributs et les methodes

defaut le paquetage

public partout

private la classe

protected classe

sous-classes

paquetage


Les chaınes de caracteres


Part 6: Les chaınes de caracteres

Les chaınes de caracteres(1/3)

— Les chaınes de caracteres sont des objets

— String et StringBuilder

String s = "Hello";

est equivalent a

String s = new String("Hello");

— la position du 1er caractere est a 0

— operateur de concatenation +

— attribut length longueur du chaıne



String prenom = "Pierre",

nom = "Martin";

System.out.println(prenom + " " + nom);

System.out.println(prenom.length );



Les chaınes de caracteres (2/3)

— La concatenation peut provoquer une

conversion implicite

System.out.println (5 + "2");

— pour un objet : appel implicite a la

methode toString.

pub l i c String toString () {

return "Rectangle (" + largeur + ","

+ longueur + ")";

}



Les chaınes de caracteres (3/3)

char charAt(int index)

int indexOf(int ch)

int indexOf(int ch, int index)

int indexOf(String str)

int indexOf(String str, int index)

String substring(int beginIndex)

String toLowerCase()

String toUpperCase()

int compareTo(String s)

boolean equals(String s)

i n t pos = 0; // position du modele dans le texte

whi le ((pos = texte.indexOf(modele , pos)) != -1)

System.out.println(pos++);


Les tableaux


Part 7: Les tableaux

Tableaux a une dimension (1/4)

— les tableaux sont des objets (mais pas

d’heritage)

— declaration :

i n t [] t; // t est un tableau d’entiers

La declaration d’un tableau NE cree PAS ses com-

posants

i n t [] t1 = new in t [ 10 ]; // 10 entiers

Complexe []t2 = new Complexe [5]; // 5 references

— composants de t[0] a t[max-1]

— initialisation a 0, false , ’\u0000’ou null



double [] t3 = { 3.4, 2.0, -34 }; // 3 reels doubles

t1 = new in t [] { 1, 2, 3 }; // 3 entiers



Tableaux a 1 dimension (2/4)

— la taille du tableau est fixee a sa creation

— l’attribut length retourne le nb de

composants

— length ne peut pas etre modifie

Les variables de type tableau sont des references.

Les operateurs = et == n’operent pas sur les compo-

sants !

t1 = t2 affectation de references

t1 == t2 comparaison de references

idem pour le passage de parametres tableaux

t = ( i n t []) t1.clone();

System.out.println(Arrays.equals(t,t1));




pub l i c c l a s s Table {

pr iva t e i n t [] tab;

// le generateur de nombres alearoires

pr iva t e Random rand = new Random ();

pub l i c Table( i n t n)

// Role: initialise le tableau tab de facon aleatoire

{

i f (n<=0) {

System.err.println("taille <= 0");

System.exit (1);

}

tab = new in t [ n ];

f o r ( i n t i = 0; i < tab.length; i++)

// les elements tab[0]..tab[i-1] sont

// initialises de facon aleatoire

tab[i] = rand.nextInt ();

}

} // fin classe Table




/* Trie une table par selection ordinaire */

pub l i c void selectionOrdinaire () {

f o r ( i n t i = 0; i < tab.length - 1 ; i++) {

// le tableau tab[0..i-1] est trie, et ces elements

// sont inferieurs a ceux de tab[i..tab.length-1]

i n t min = i;

// chercher la place du min dans tab[i..tab.length-1]

f o r ( i n t j = i+1; j < tab.length ; j++)

i f (tab[j] < tab[min]) min = j;

// echanger le ieme et l’element min

echanger (min ,i);

}

}

pr iva t e void echanger ( i n t i, i n t j) {

// echange les valeurs de tab[i] et tab[j]

i n t temp = tab[i];

tab[i] = tab[j];

tab[j] = temp;

}



Parametres de l’application

— tableau de chaınes de caracteres

— parametre de la fonction main

/**

* Cette application ecrit sur la sortie standard

* ses parametres passes lors de son execution

*/

c l a s s Echo {


f o r ( i n t i = 0; i < (args.length -1); i++)

System.out.print(args[i] + " ");

// ecrire le dernier parametre et le passage a la ligne

System.out.println(args[args.length -1]);

}

}



Tableaux a plusieurs dimensions (1/3)

— comme en C tableaux de tableaux

— memes remarques qu’a une dimension

double [][] matriceD = new double[m][n];

Complexe [][][] matriceC = new Complexe [m][n][t];

— le nombre de composants des dimensions

peut etre different

double [][] matriceD = new double[m][];

matriceD [0] = new double [5];

matriceD [1] = new double [10];

...




c l a s s Matrice {

// Invariant : this est une matrice £(lignes,colonnes)£

pr iva t e double [][] m;

pub l i c f i n a l i n t nblgs , nbcols;

// le generateur de nombres alearoires

pr iva t e Random rand = new Random ();

pub l i c Matrice( i n t l, i n t c)

// Role: creer une matrice (l,c)

{ // verifier que l et c sont > 0

...

m = new in t [ l ][ c ];

nblgs = l; nbcols = c;

...

}

} // fin classe Matrice




pub l i c Matrice produit(Matrice m) {

// Antecedent : this(n,k) et m(k,p) sont

// des matrices initialisees

// Consequent : renvoie une matrice (n,p)

// produit de this par m

Matrice c =

new Matrice( t h i s .nblgs ,m.nbcols);

f o r ( i n t i = 0; i < c.nblgs; i++)

f o r ( i n t j = 0; j < c.nbcols; j++) {

// ∀ x ∈ 0..i − 1, ∀ y ∈ 0..j − 1,

// c x, y =∑

k = 1ˆpthis xkm ky

double somme=0;

f o r ( i n t k = 0; k < t h i s .nbcols; k++)

somme += t h i s .m[i][k]*m.m[k][j];

c.m[i][j] = somme;

}

return c;

}


Heritage


Part 8: Heritage

Introduction

— propriete fondamentale des langages a

objets

— outil de la reutilisabilite

— bibliotheques de classes extensibles


Part 8: Heritage

Classe heritieres (1/2)

pub l i c c l a s s Carre {

// Invariant de classe : cote £>£ 0

pr iva t e double cote ;

pub l i c Carre(double c)

{

cote = c;

}

pub l i c double perimetre()

// Role: retourne le perimetre du carre

{

return 4*cote ;

}

pub l i c double surface ()

// Role: retourne la surface du carre

{

return cote * cote ;

}

} // fin classe Carre


Part 8: Heritage

Classe heritieres (2/2)

— un carre est un rectangle particulier

— reutilisation de la classe Rectangle

pub l i c c l a s s Carre extends Rectangle {

// Invariant de classe : largeur == longueur > 0

pub l i c Carre(double c) {

super (c,c);

}

pub l i c void changerCote(double cote ) {

// Role: met a jour le cote

super .changerLargeur(cote );

super .changerLongueur(cote );

}

}

— protected

— super et super()

— la classe Object

— le graphe d’heritage

— heritage = specialisation et extension


Part 8: Heritage

Heritage ou client

— relation est-un

— relation a-un

— mais ...

pub l i c c l a s s Rectangle {

Point origine;

...

}

ou

pub l i c c l a s s Rectangle extends Point {

....

}


Part 8: Heritage

Redefinition des methodes (1/2)

— les classes heritieres peuvent redefinir des

methodes

— elles doivent posseder la meme signature

(sinon surcharge)

— les classes Rectangle et Carre definissent

les methodes suivantes :

// Dans la classe Rectangle

pub l i c String toString ()

{

return "rectangle de largeur " + largeur

+ " et de longueur " + longueur ;

}

// Dans la classe Carre

pub l i c String toString ()

{

return "carre de cote egal a" + largeur;

}


Part 8: Heritage

Redefinition des methodes (2/2)

Rectangle r = new Rectangle(2,4);

Carre c = new Carre (6);

System.out.println(r); // r.toString()

System.out.println(c); // c.toString()

rectangle de largeur 2 et de longueur 4

carre de cote egal a 6


Part 8: Heritage

Recherche d’un attribut ou d’une methode

— chaque fois que l’on desire acceder a un

attribut ou une methode d’une occurrence

d’objet d’une classe C, il devra etre defini

soit dans la classe C, soit dans l’un de ses

ancetres.

— si l’attribut ou la methode n’est pas

trouve, c’est une erreur

— s’il y a eu des redefinitions, sa premiere

apparition en remontant le graphe

d’heritage sera choisie.


Part 8: Heritage

Polymorphisme (1/2)

— langages polymorphiques et non

polymorphiques (langage type et non type)

— polymorphisme dans les langages de classes

est controle par l’heritage

Rectangle r;

Carre c = new Carre (3);

r = c; // valide : un carre est rectangle

c = r; // erreur de compilation !

// un rectangle n’est pas (forcement) un carre

— Cast : c = (Carre) r ; si on est sur que r

est un Carre

— Exemple une classe Forme pour representer

les formes geometriques quelconques


Part 8: Heritage

Polymorphisme (2/2)

Forme

Ellipse Rectangle

Cercle Carré

Forme [] tf = new Formes [10];


Part 8: Heritage

Liaison dynamique

tf[0] = new Rectangle(3 ,10);

tf[1] = new Cercle (7);

...

tf[0] = tf[1]; // tf[0] designe un cercle ?

...

System.out.println(tf[0]); // toString() de Cercle ?

— lorsque qu’il y a des redefinitions de

methodes, c’est a l’execution que l’on

connaıt la methode a appliquer.

— elle est determinee a partir de la forme

dynamique de l’objet sur lequel elle

s’applique.

— Interet :

— localisation

— evite le pb du switch


Part 8: Heritage

Classes et methodes abstraites

— Une methode abstraite n’est definie que

par sa signature

— Introduite par le mot-cle abstract

— Une classe peut etre declaree abstraite,

— elle decrit des caracteristiques mais pas un

fonctionnement

pub l i c ab s t r a c t c l a s s Forme {

pub l i c ab s t r a c t i n t perimetre();

pub l i c ab s t r a c t i n t surface ();

}

Une classe abstraite ne peut etre instanciee !


Part 8: Heritage

Heritage simple vs multiple

— en Java l’heritage est simple

— evite les pb complexes de recherche des

noms de l’heritage multiple

Cercle Carré

CercledansCarré

— les interfaces permettent un heritage

multiple simplifie


Part 8: Heritage

Interfaces (1/2)

— pour une forme simplifiee de l’heritage

multiple

— pour la genericite

— ce sont des classes dont toutes les

methodes sont implicitement abstraites

— elles ne possedent pas d’attribut, a

l’exception de constantes

— ne peuvent pas etre instanciees

pub l i c i n t e r f a c e MonInterface {

s t a t i c f i n a l i n t uneConstate = 10;

ab s t ra c t pub l i c void uneMethode( i n t x);

}


Part 8: Heritage

Interfaces (2/2)

— une classe peut se comporter comme une

ou plusieurs interfaces

— Elle doit implanter (implements) le ou les

interfaces

— elle et ses descendants s’engagent a definir

le corps des methodes de l’interface

c l a s s MaClasse implements MonInterface {

pub l i c void uneMethode( i n t x) {

....

}

}

— Serializable

— Cloneable

— Runnable

— ActionListener

— ...


Part 8: Heritage

Interfaces et Polymorphisme

les interfaces permettent un polymorphisme

independant de la hierarchie d’heritage

une variable de type interface I peut designer

n’importe quel objet de toute classe qui implante

cette interface.

c l a s s C1 implements I {

...

}


...

}


...

}


Part 8: Heritage

I [] table = new I[10];

table[0] = new C1();




Part 8: Heritage

Interfaces et genericite(1/2)

— appliquer un traitement des objets quel

que soit leur type

— jusqu’a la version 1.4.2 de Java, la

genericite est limitee et a mettre en œuvre

avec des interfaces

— version 1.5 : notion du langage a part

entiere

On veut ecrire une methode de tri qui puisse trier

un tableau d’objets quelconques ⇒ on doit

pouvoir les comparer

pub l i c s t a t i c void tri( EltComparable [] t) {

... t[i].infOuEgal(t[j]) ...

}

i n t e r f a c e EltComparable {

pub l i c boolean infOuEgal(EltComparable o);

}


Part 8: Heritage

Interfaces et genericite(2/2)

c l a s s CarreComparable extends Carre

implements EltComparable {

pub l i c boolean infOuEgal(EltComparable o) {

return t h i s .surface () <=

(( CarreComparable) o).surface ();

}

}

c l a s s PersonneComparable extends Personne

implements EltComparable {

pub l i c boolean infOuEgal(EltComparable o) {

return t h i s .taille() <=

(( PersonneComparable ) o).taille ();

}

}


Part 8: Heritage

// trier des carres

CarreComparable [] t1 = {

new CarreComparable (3), ...,

new CarreComparable (12), ...

};

C.tri(t1);

// trier des personnes

PersonneComparable [] t2 = {

new PersonneComparable (1.73) , ...,

new PersonneComparable (1.90) ,

};

C.tri(t2);


Les exceptions


Part 9: Les exceptions

Le probleme

Un evenement qui indique une situation anormale

pouvant provoquer un dysfonctionnement du

programme :

— pb materiel (E/S, memoire, ...)

— pb logiciel (division par zero, non respect

des invariants, ...)

tantque B f a i r e

...

s i erreur a l o r s

traiter erreur

f i n s i

...

fintant

— le code ≪ normal ≫ et le traitement des

erreurs melanges

— code de retour (souvent un entier) pauvre

en information

— un mecanisme elabore : les exceptions



Traitement

Une exception survient au cours de l’execution

d’une action :

— reexecution de l’action en changeant les

conditions initiales d’execution ;

— transmission de l’exception a

l’environnement

E1

E2

E3

E4 exception



Exceptions en Java

— Les exceptions sont des objets

— situation anormale ⇒ emission d’une

exception

— java.lang.Exception → java.lang.Throwable

........

Error

Object

Throwable

Exception

IOExceptionRuntimeException

........ArithmeticException

— toutes les exceptions (sauf

RuntimeException) doivent etre

explicitement capturees ou deleguees



Capture d’une exception (1/2)

— clauses try-catch

try {

// code ≪ normal ≫

...

o.m(); // la methode m peut provoquer une exception

...

}

catch (UneException e) {

// code de traitement de l’exception designee par e

...

}

— clause finally

f i n a l l y {

// code execute quoiqu’il arrive

}



Capture d’une exception (2/2)

try {

i n t x = StdInput .readlnInt();

....

}

catch (IOException e) {

System.err.println(e);

System.exit (1);

}

pub l i c s t a t i c i n t lirelnInt() {

try {

return StdInput .readlnInt();

}

catch (IOException e) {

System.err.println (e);

System.out.println ("reessayer :");

return lirelnInt();

}

}



Delegation d’une exception

— une methode n’est pas tenue de capturer

une exception

— elle peut deleguer la capture a son

environnement

— elle le signale avec la clause throws dans

son en-tete

— sauf pour les exceptions de type

RuntimeException

pub l i c void maMethode() throws IOException {

i n t x = StdInput .readlnInt();

....

}



Creer ses propres exceptions

pub l i c c l a s s MonException extends Exception {

i n t code;

pub l i c MonException() {

super ();

}

pub l i c MonException(String msg) {

super (msg);

}

pub l i c MonException(String msg , i n t c) {

super (msg);

code = c; // c 6= 0

}

pub l i c String toString () {

return getMessage() + " " + code;

}

}



Emettre une exception

— throw (sans s)

pub l i c void uneMethode() {

i f (...) {

throw new ArithmeticException ();

}

...

}

pub l i c void maMethode() throws MonException {

i f (...) {

throw new MonException("une erreur", 3);

}

...

}

— la clause throws est obligatoire dans

l’en-tete de la methode qui leve une

exception (sauf RuntimeException)


Les entrees/sorties


Part 10: Les entrees/sorties

Flots d’octets et de caracteres

— flots sequentiels unidirectionnels

— flots a acces direct

— octets et caracteres Unicode

— quatre classes de base :

lecture ecriture

flots d’octets InputStream OutputStream

flots de caracteres Reader Writer

— paquetage java.io



Fichiers d’octets

Declaration :

FileInputStream is = new FileInputStream("entree");

FileOutputStream os = new FileOutputStream ("sortie");

— methodes de base :

— int read()

— void write(int)

— void close()



Exemple : recopie d’un fichier

pub l i c void copie (String in, String out)

throws IOException

{

FileInputStream is = new FileInputStream(in);

FileOutputStream os = new FileOutputStream (out);

i n t c;

whi le ((c = is.read ()) != -1)

os.write(c);

// EOF de is

is.close();

os.close();

}



Fichier d’objets elementaires

— DataInputStream et DataOutputstream

— readChar, writeChar, readInt, writeInt,

readDouble, writeDouble, ...

— fin de fichier ⇒ exception EOFException

pub l i c double moyenne (String in)

throws IOException {

DataInputStream is = new DataInputStream(

new FileInputStream(in));

i n t nbElem = 0;

double moy = 0;

try {

whi le ( true ) {

moy+= is.readDouble();

nbElem ++;

}

}

catch (EOFException e) {

is.close();

}

return nbElem == 0 ? 0 : moy / nbElem;

}



Fichier d’objets

— ObjectInputStream et ObjectOutputstream

— Object readObject()

— void writeObject(Object)

Rectangle r = new Rectangle(3,4);

ObjectOutputStream os = new ObjectOutputStream (

new FileOutputStream("Frect"));

// ecriture d’un objet de type Rectangle sur le fichier os

os.writeObject(r);

os.close();

ObjectInputStream is = new ObjectInputStream (

new FileInputStream("Frect"));

// lecture d’un objet de type Rectangle sur le fichier is

r = (Rectangle) is.readObject();

// ⇐ la conversion necessaire

is.close();

— interface Serializable

pub l i c c l a s s Rectangle

implements Serializable {



Fichier de texte

- caracteres Unicode

- FileReader et FileWriter



FileReader is = new FileReader("entree ");

boolean etatDansMot = f a l s e ;

i n t c, nbCar = 0, nbMots = 0, nbLignes = 0;

whi le ((c = is.read ()) != -1) {

// incrementer le compteur de caracteres

nbCar++;

i f (c == ’ ’ || c == ’\t’ || c == ’\n’) {

// c est un separateur de mot

i f ( etatDansMot) etatDansMot = f a l s e ;

i f (c == ’\n’)

// fin d’une ligne ⇒ incrementer le compteur de lignes

nbLignes ++;

}

e l s e // on est dans un mot

i f (! etatDansMot) {

// 1er car du mot ⇒ incrementer le compteur de mots

nbMots ++;

etatDansMot = true ;

}

}

// fin de fichier ⇒ afficher les resultats

is.close();

System.out.println(nbLignes + " " + nbMots

+ " " + nbCar);



E/S bufferisees

Pour ameliorer les performances, les lectures et

les ecritures utilisent une zone tampon.

— BufferedInputStream,

BufferedOutputStream

— BufferedReader, BufferedWriter

FileInputStream is =

new FileInputStream("entree");

FileOutputStream os =

new FileOutputStream("sortie");

BufferedInputStream bis =

new BufferedInputStream (is);

BufferedOutputStream bos =

new BufferedOutputStream (os);



Entree et sortie standard

— System.in de type InputStream

— System.out de type PrintStream

— System.err de type PrintStream

La classe PrintStream propose des methodes print

et println pour ecrire tout type d’objet apres

conversion en chaıne de caracteres avec

toString()

System.in ne permet de lire que des octets. Pas de

conversion de type implicite ⇒ classe locale StdIn-

put

double x = System.in.read (); // ⇐ suspect

double x = StdInput .readlnDouble ();


Fonctions anonymes (Lambda)


Part 11: Fonctions anonymes (Lambda)

Introduction

— depuis la version 8 de Java

— API fortement recrite + nouveautes

(Stream)

— modele fonctionnel (lisp, haskell, ...)

— fonction sans nom (anonyme)

(x, y) → x+ y

— valeur fonctionnelle :

(x,y) -> x + y

( i n t x, i n t y) -> x + y



Type d’une fonction anonyme (1/3)

C’est une interface fonctionnelle (une seule

methode abstraite)

i n t e r f a c e FoncInt {

i n t apply( i n t x, i n t y);

}

FoncInt f = (x,y) -> x + y;

FoncInt f = (x,y) -> x * x + y;




(x) -> { assert x >=0;

return Math.sqrt(x);

}

() -> {

System.out.print("n = ");

i n t n = StdInput .readlnInt ();

System.out.println (n*n);

}

i n t e r f a c e FoncDouble {

double apply(double x);

}

i n t e r f a c e Procedure {

void apply() throws IOException ;

}




Les fonctions anonymes peuvent etre generiques

i n t e r f a c e BiFunction <T, U, R> {

R apply(T t, U u);

}

BiFunction <Integer ,Integer ,Integer > f =

(x,y) -> x + y;

— java.util.function



Utilisation

— Evaluation (inference de types)

FoncInt f = (x,y) -> x + y;

System.out.println(f.apply (2 ,3)); // 5

— Lambda en parametre

pub l i c double calculerAire(double a,

double b, i n t n,Function <Double , Double > f)

— Lambda resultat de fonction

// (g ◦ f)(x) = g(f(x))

<T,R,Z> Function <T,Z> compose (Function <T,R> f,

Function <R,Z> g) {

return x -> g.apply(f.apply(x));

}



Fermeture

— Occurrences liees vs libres

— En Java, la portee est statique

(environement de definition de la fct

anonyme)

i n t e r f a c e Procedure { void apply(); }

...

i n t x=1;

Procedure p = () -> { System.out.println(x); };

p.apply();

— Les variables libres sont implicitement

final (i.e. elles ne peuvent donc pas etre

modifiees)

Procedure p = () -> { System.out.println(x++); };

// ERREUR DE COMPILATION !!!!!!!!!!



Methodes par defaut

— plusieurs methodes dans une interface

fonctionnelle ?

— pour garantir la compatibilite avec

l’existant (i.e. Iterable, Runnable, ...)

— methodes par defaut (default)

pub l i c i n t e r f a c e Iterable <T> {

// methode a implementer

pub l i c Iterator <T> iterator ();

// methode par defaut

pub l i c d e f au l t void

forEach(Consumer <? super T> action) {

f o r (T t : t h i s )

action.accept(t);

}

}


L’API


Part 12: L’API

Application Programming Interface

— ensemble de classes pretes a l’emploi

— couvre de nombreux aspects de

l’informatique

— facilite la construction des applications

— offre des algorithmes efficaces

— collections

— arithmetique precision infinie

— gestion d’images 2D et3D

— gestion du son

— interfaces graphiques et applet

— processus legers - synchronisation

— reseau (URL, modele client-serveur RMI,

objets distribues IDL Corba)

— beans

— base de donnees (jdbc)

— reflexivite

— SDK (mecanismes de securite)


Part 12: L’API

Collections et Tables

— paquetage java.util

— Vector, tableaux dynamiques

— Hashtable, tables d’adressage disperse

— Stack, piles

— ensembles

— listes

— arbres

— algorithmes de tri

— algorithmes de recherche

— ...


Part 12: L’API

Collections

Collection

ArrayList Vector LinkedList SortedSet HashSet

TreeSet

SetList

— Liste et Ensembles generiques

— Enonce foreach

List <String > vs = new Vector <String >();

SortedSet <String > ts = new TreeSet <String >(vs);


Part 12: L’API

La classe Vector

tableau dynamique dont la taille est ajustable en

fonction des besoins

Vector v = new Vector (3);

System.out.println(v.size ()); // ⇒ 0

f o r ( i n t i = 0; i < 10; i++)

v.addElement(new Integer(i*i));


System.out.println(v.elementAt(3)); // ⇒ 9

v.setSize (20);

v.setElementAt(new Integer (3) ,18);


v.removeElementAt (0);


v.removeAllElements ();



Part 12: L’API

Tables

SortedMap

TreeMap

Map

HashtableHashMap

— Valeur + Cle


Part 12: L’API

La classe Hashtable

Table dont les elements sont reperes par des cles

et dont l’acces se fait par adressage disperse.

Hashtable <String ,Integer > ht =

new Hashtable <String ,Integer >();

ht.put("Paul", 3);

ht.put("Pierre" ,19);

Integer n = ht.get("Pierre");

i f (n != nu l l )

System.out.println("Pierre = " + n);


Part 12: L’API

Les Properties

— sous-classe de Hashtable

— correspondance cles et des valeurs String

— une instance de Properties peut etre reliee

a une autre instance de Properties

— lues et sauvegardees dans un fichier (texte

ou XML)

Properties p1 = new Properties();

Properties p2 = new Properties(p1);

p1.setProperty("Auteur", "Moliere ");

p2.setProperty("Compositeur", "Bach");

System.out.print(p1.getProperty("Auteur"));

System.out.print(p2.getProperty("Compositeur"));

System.out.println(p2.getProperty("Acteur","inconnu"));

// proprietes de l’environnement d’execution

System.out.print(System.getProperty("java.version "));

System.out.print(System.getProperty("os.version "));

System.out.println(System.getProperty("os.arch"));


Part 12: L’API

Threads

— processus legers vs processus

— execution (quasi) parallele des processus

— partage de ressources communes

— interface runnable

— synchronisation (methodes synchronized)

c l a s s MonThread extends Thread {

pub l i c MonThread() { ... }

pub l i c void run() { ... }

}

pub l i c c l a s s TestThread {

pub l i c s t a t i c void main(String [] arg) {

MonThread threadA = new MonThread(),

threadB = new MonThread();

threadA.start() // et non pas run()

threadB.start();

}

}


Part 12: L’API

Interfaces Graphiques

— necessite des interfaces graphiques

— Abstract Window Toolkit (AWT)

— Java Foundation Classes (JFC) – Swing

— applet (little application)

— programmation par evenements

— composants graphiques (boutons, menus,

canvas, ascenseurs, boıtes de dialogue, etc.)


Introspection


Part 13: Introspection

Introspection

— possibilite de consulter et d’utiliser

dynamiquement la structure de classe des

objets.

— necessaire pour les butineurs de classes,

debogueurs, ...

— la classe Class et le paquetage

java.lang.reflect permet l’introspection


Beans


Part 14: Beans

Beans (1/13)

— grain (de cafe)

— composant logiciel reutilisable destine a

etre manipule par un outil de

developpement interactif et graphique

(beanbox, beanbuilder, ...)

— bean = classe Java

— implemente l’interface Serializable

— constructeur public sans parametre

— pour etre exploitable, un bean doit etre

archive (format jar)


Part 14: Beans

Beans (2/13)

Un bean :

— est capable d’introspection (reflect,

inspector)

— possede des proprietes (accessibles par des

methodes setXX(), getXX(), isXX()),

— realise la persitence (une fois crees, les

beans doivent pouvoir etre conserves)

— communication entre beans par des

evenements


Part 14: Beans

Beans (3/13)

import java.awt.*;

import java.io.*;

pub l i c c l a s s FirstBean extends Canvas


f i n a l pub l i c s t a t i c i n t RECTANGLE = 0;

f i n a l pub l i c s t a t i c i n t CERCLE = 1;

protected i n t forme = CERCLE; // propriete

pub l i c FirstBean() {

setSize (100 ,100); // taille du canvas

}


g.drawRect (2,2,90,90);

g.setColor (Color.red);

i f (forme == RECTANGLE) g.fillRect (10 ,10 ,20 ,20)

e l s e g.fillArc (10 ,10 ,20 ,20 ,0 ,360);

}

// methodes d’acces a la proriete forme

pub l i c i n t getForme () { return forme; }

pub l i c void setForme ( i n t f) { forme = f; }

}


Part 14: Beans

Beans (4/13)

Compilation et archivage

javac FirstBean.java

jar cvfm FirstBean.jar manifest.tmp FirstBean.class

fichier manifest

Name: FirstBean.class

Java-Bean: True


Part 14: Beans

Beans (5/13)

Un bean source peut emettre un evenement qui

produit l’execution d’une action sur un bean cible.

1. definition de l’evenement (ObjectEvent)

import java.util .*;

pub l i c c l a s s MyEvent extends EventObject {

pub l i c MyEvent (Object o) {

super (o);

}

}

2. definition de l’auditeur (EventListener)


pub l i c i n t e r f a c e MyEventListener extends EventListe

pub l i c ab s t r a c t void myEventPerformed (MyEvent e

}


Part 14: Beans

Beans (6/13)

3. gestion de l’emission de l’evenement (source)


Part 14: Beans


pub l i c c l a s s Source {

pr iva t e Vector myEventListeners = new Vector ();

pub l i c synchronized void addMyEventListener (MyEv

myEventListeners .addElement (l);

}

pub l i c synchronized void removeMyEventListener (M

myEventListeners .removeElement (l);

}

protected void notifyMyEvent () {

Vector l;

MyEvent e = new MyEvent ( t h i s );

synchronized ( t h i s ) {

// pour eviter toute modification

l = (Vector) myEventListeners .clone();

}

f o r ( i n t i=0; i<l.size (); i++) {

MyEventListener mel = (MyEventListener)l.ele

mel.myEventPerformed (e);

}

}

...

// appel a notifyMyEvent pour emettre l’evenement

...

}


Part 14: Beans

Beans (7/13)

4. gestion de la reception (cible)

pub l i c c l a s s Cible implements MyEventListener {

Source src = new Source ();

pub l i c Cible() {

src.addMyEventListener ( t h i s );

}

pub l i c void myEventPerformed (MyEvent e) {

// callback ...

}

}


Part 14: Beans

Beans (8/13)

Les proprietes peuvent etre liees (lien

unidirectionnel).

Lorsqu’il y modification d’une propriete liee, il

faut notifier le changement.

Elle envoie un PropertyChangeEvent chaque fois

qu’elle change. L’evenement est recu par les

auditeurs qui implementent

PropertyChangeListener.

PropertyChangeEvent possede les methodes :

— getSource()

— getOldValue()

— getNewValue()

— getPropertyName()


Part 14: Beans

Beans (9/13)

import java.beans.*;

pub l i c c l a s s FirstBean extends Canvas implements

....

pr iva t e PropertyChangeSupport changes

= new PropertyChangeSupport ( t h i s )

pub l i c void addPropertyListener (PropertyChangeListene

{

changes.addPropertyChangeListener (l);

}

pub l i c void removePropertyListener (

PropertyChangeListener l) {

changes.removePropertyChangeListener (l);

}

pub l i c void setForme ( i n t newForme )

{

i n t oldForme = newForme ;

forme = newForme ;

changes.firePropertyChange ("forme",oldForme ,newForm

}

...

}


Part 14: Beans

Beans (10/13)

Le bean auditeur doit implementer l’interface

PropertyChangeListener.


pub l i c c l a s s BeanAudit

implements PropertyChangeListener , Serializable

{

......

pub l i c void propertyChange(PropertyChangeEvent e)

....

}

...

}


Part 14: Beans

Beans (11/13)

Une propriete peut etre aussi contrainte :

— elle envoie un PropertyChangeEvent juste

avant qu’elle ne change. Mais d’autres

composants peuvent s’oppser a ce

changement VetoableChangeListener.

— Les methodes setXX doivent gerer

l’exception PropertyVetoException.


Part 14: Beans

Beans (12/13)


pub l i c c l a s s FirstBean extends Canvas


pr iva t e VetoableChangeSupport veto

= new VetoableChangeSupport ( t h i s )

pub l i c void addVetoableChangeListener (

VetoableChangeListener l) {

changes.addVetoableChangeListener (l);

}

pub l i c void removeVetoableChangeListener (

PropertyChangeListener l) {

changes.removeVetoableChangeListener (l);

}

pub l i c void setForme ( i n t newForme )

throws PropertyVetoException {

i n t oldForme = newForme ;

veto.fireVetoableChange ("forme",oldForme ,newForme );

forme = newForme ;

changes.firePropertyChange ("forme",oldForme ,newForm

}

...

}


Part 14: Beans

Beans (13/13)

Le bean qui emet le veto

pub l i c c l a s s BeanAudit

implements VetoableChangeListener , Serializable

{

......

pub l i c void vetoableChange(PropertyChangeEvent e)

throws PropertyVetoException {

....

}

}


Threads


Part 15: Threads

Introduction

— processus = programme en cours

d’execution

— execution (quasi) parallele des processus

— processus leger (thread)

— la classe Thread (java.lang)

— la methode run

— un thread pour main

— application terminee lorsque tous les

threads sont finis

— priorite (getPriority() et setPriority(p))


Part 15: Threads

La classe Thread

c l a s s MonThread extends Thread {

// constructeur


// code a executer par le thread


}

/**

* Classe de Test qui cree et execute 2 threads

*/

pub l i c c l a s s TestThread {

pub l i c s t a t i c void main(String [] arg) {

MonThread threadA = new MonThread(),

threadB = new MonThread();

threadA.start() // et non pas run()

threadB.start();

}

}


Part 15: Threads

L’interface Runnable (1/2)

— pas d’heritage multiple ⇒

interface fonctionnelle Runnable

— Thread t1 = new Thread(t2)

c l a s s MonThread implements Runnable {



}

....

MonThread tA = new MonThread();

MonThread tB = new MonThread();

new Thread(tA).start ();

new Thread(tB).start ();

Runnable r = () -> System.out.println("1");

new Thread(r).start();

// ci-dessous le type Runnable est determine par inference

new Thread (() -> System.out.println("2")).start();


Part 15: Threads


pub l i c c l a s s Aleatoire implements Runnable {

pub l i c Thread proc = new Thread( t h i s );

pr iva t e Random rand;

pr iva t e long intervalle;

pub l i c Aleatoire( long germe , long time) {

rand = new Random(germe);

intervalle = time * 1000;

}

pub l i c void run() {

whi le ( true ) {

try { Thread.sleep(intervalle); }

catch (InterruptedException e) {}

System.out.print(rand.nextInt () + " ");

System.out.flush();

}

}

} // fin classe Aleatoire


Part 15: Threads


pub l i c c l a s s TestProd {


new Aleatoire(10, 1).proc.start();



}

}


Part 15: Threads

Etats d’un threads

BLOCKED thread en attente de la liberation d’une

donnee.

NEW thread qui n’a pas encore commence a

s’executer.

RUNNABLE thread executable, pret a disposer de la

puissance de calcul.

TERMINATED thread dont l’execution est terminee.

TIMED WAITING thread en attente avec une duree maxi-

mum specifiee.

WAITING thread en attente.

new Thread()

NEW TERMINATED

fin de run()start()

RUNNABLE

yield()

notify()wait()IO ok

IO?fin duréesleep(durée)

TIMED_WAITING BLOCKED WAITING


Part 15: Threads

Interruption d’un processus (1/2)

— methode interrupt()

— le processus peut verifier s’il est

interrompu ou non (il gere l’interruption)


whi le (!Thread.interrupted()) {

try {

Thread.sleep(intervalle);

}

catch (InterruptedException e) {

// interruption lors du sleep

break ;

}

System.out.print(rand.nextInt () + " ");

System.out.flush ();

}

}


Part 15: Threads

Interruption d’un processus (2/2)

pub l i c c l a s s TestProd {




Aleatoire p = new Aleatoire(13, 1);

p.proc.start ();

...

// arret du 3eme thread

p.proc.interrupt();

}

}

— interruption dans le sleep ⇒ exception

— hors du sleep ⇒ drapeau

Thread.interrupted()

— getPriority() et setPriority(int)


Part 15: Threads

Attente de la fin d’un thread

— methodes join() ou join(long ms) (pour

les timeout)


Aleatoire p1 = new Aleatoire(10, 1);



p1.proc.start();

p2.proc.start();

p3.proc.start();

try {

p1.proc.join (); // attendre la fin de p1



}


...

}


Part 15: Threads

Gestion des threads (1/2)

static Thread currentThread()

Retourne une reference sur le thread

actif.

static void dumpStack()

Affiche une trace de la pile d’execution

du thread courant.

String getName()

Retourne le nom du thread.

int getPriority()

Retourne la priorite du thread.

Thread.State getState()

Retourne l’etat courant du thread.

static boolean interrupted()

Retourne true si le thread est inter-

rompu.

boolean isAlive()

Teste si le thread est actif.

void setName(String name)

Change le nom du thread.

void setPriority(int newPriority)

Change la priorite du thread.


Part 15: Threads


void interrupt()

Interrompt le thread.

void join() ou join(long millis) ou join(long

millis, int nanos)

Attend que le thread meurt, au plus le temps

indique en millisecondes et nanosecondes si

ces parametres sont fournis.

void notify()

Reveille le thread precedemment mis en at-

tente.

void run()

Cette methode par defaut ne fait rien. Si le

thread est issu d’un objet de type Runnable,

c’est la methode run de cet objet qui est

executee ou sinon sa redefinition eventuelle.


Part 15: Threads


static void sleep(long millis) ou sleep(long millis, int

nanos)

Provoque l’endormissement du thread pour

une duree egale au nombre de millise-

condes auquel s’ajoutent les eventuelles nano-

secondes.

void start()

Provoque le demarrage du thread, la JVM ap-

pelle alors sa methode run .

void wait() ou wait(long timeout) ou wait(long

timeout, int nanos)

Met le thread en attente d’un notify invoque

par un autre processus ou du depassement du

temps passe en parametre.

void yield()

Force le scheduling, le thread cede sa place aux

autres processus eligibles.


Part 15: Threads

Synchronisation des threads (1/3)

— pb de l’acces a une ressource critique (i.e.

compte bancaire)

— pose d’un verrou

— toutes les methodes qui modifient l’etat

d’un d’objet partage ≪ doivent ≫ etre

declarees synchronized.

c l a s s CompteBancaire {

pr iva t e double solde;

pub l i c synchronized

void operation(double somme)

{

i f (solde+somme <0)

System.err.println("retrait impossible");

e l s e

solde+=somme;

}

}


Part 15: Threads


— synchronized (obj) enonce ;

ainsi une methode qualifiee synchronised peut se

recrire :

...

void uneMethodeASynchroniser () {

synchronized ( t h i s ) {

... //code du corps de la methode

}

}

...


Part 15: Threads


...

synchronized (...) { //debut du bloc controle

... //actions diverses

//tests de verification des donnees

wait (); //les donnees ne sont pas pretes

//attente d’un notify() transmis par ailleurs

//reveil et reprise du cours de l’execution

... //actions sur les donnees

//le besoin de verrouiller n’est plus

notify() //message de reveil des processus endormis

... //actions diverses

} //fin du bloc

...


Part 15: Threads

Producteurs Consommateurs (1/2)

File d’attente

Producteurs Consommateurs

— producteurs et consommateurs doivent se

synchroniser (file vide)


Part 15: Threads

Producteurs Consommateurs (2/2)


pub l i c c l a s s File <T> extends Vector <T> {

pub l i c synchronized void enfiler(T e) {

addElement(e);

notify ();

}

pub l i c synchronized T defiler () {

i f (isEmpty ())

try {

wait ();

}

catch (InterruptedException e) {

return nu l l ;

}

T e = elementAt(0);

removeElementAt (0);

return e;

}

} // fin classe File


Part 15: Threads

Tubes (1/2)

— Un tube est un canal bidirectionnel entre 2

threads

— Les threads peuvent ecrire et lire dans le

tube

TubeThread1 Tread2

— La synchronisation

Producteur/Consommateur est geree par le

support d’execution


Part 15: Threads

Tubes (2/2)

— PipedInputStream et PipedOutputStream

— les tubes d’entree et de sortie doivent etre

connectes :

— a la creation, avec le constructeur

PipedInputStream pi = new PipedInputStream ();

PipedOutputStream po = nu l l ;

try {

po = new PipedOutputStream (pi);

}

catch (IOException e) { System.err.println(e); }

— avec la methode connect()

PipedInputStream pi = new PipedInputStream ();

PipedOutputStream po = new PipedOutputStream ();

try {

pi.connect(po);

}

catch (IOException e) { System.err.println(e); }


Applet


Part 16: Applet

Applet

— applet = petite application graphique

— necessite une autre application graphique

(navigateurs, appletviewer)

— plugin (inclus dans la jre)

— classe Applet

lang.Object

awt.Component

awt.Container

awt.Panel

applet.Applet

— pas de methode main

— pas de constructeur, mais init

— contexte execution HTML


Part 16: Applet

Exemple

import java.awt.*;

import java.applet .*;

pub l i c c l a s s HelloWorldApplet extends Applet {

Font f;

pub l i c void init () {

f = new Font("Times", Font.BOLD , 20);

}


g.setFont(f);

g.setColor (Color.pink );

g.drawString("Hello World!", 5, 25);

}

} // fin classe HelloWorldApplet

<OBJECT code="HelloWorldApplet.class"

width=400 height=150>

</OBJECT>


Part 16: Applet

AppletContext

Concept de contexte d’execution (document

HTML), information sur l’environnement, et en

particulier sur les autres applets du document.

— AppletContext Applet.getAppletContext()

—

Applet AppletContext.getApplet(String name)

—

Enumeration<Applet> AppletContext.getApplets()

—

void AppletContext.showStatus(String status)

—

void AppletContext.showDocument(URL url)

—

void AppletContext.showDocument(URL url, String

avec ou = \_self, \_parent, \_blank, name


Part 16: Applet

AudioClip

Concept de clip audio (necessite un dispositif de

reproduction sonore). Plusieurs clips peuvent etre

interpretes en meme temps par mixage sur la

meme plate-forme.

— AudioClip Applet.getAudioClip(URL url)

charger le clip audio donne a l’URL.

— void AudioClip.loop(), interpretation

indefinie de ce clip.

— void AudioClip.play(), interpretation de ce

clip, une seule fois depuis le debut.

— void AudioClip.stop(), arret de

l’interpretation de ce clip.


Part 16: Applet

La classe Applet (AWT)

— void init(), initialisation

— void start(), juste apres init(), ou

automatiquement a chaque reapparition a

l’ecran (changement de page Web ou

de-iconification), pour signifier a cette applet

qu’elle doit demarrer ou redemarrer sa

veritable execution.

— void stop(), arret de l’applet.

Automatiquement appele a chaque disparition

de l’applet de l’ecran (changement de page

Web ou iconification) ou juste avant sa

destruction complete.

— boolean isActive(), applet est active des le

debut de l’execution de sa methode start() et

cesse de l’etre des que l’execution de stop()

est terminee.

— void resize(Dimension d),

void resize(int l, int h)

— String getAppletInfo()

— void showStatus(String m), affichage du

message m dans la zone d’etat de l’applet.


Part 16: Applet

Evenements

— reaction aux evenements clic de souris

import java.awt.Event;

pub l i c boolean mouseDown(Event event , i n t x, i n t y)

// code traitement

....

return true ;

}


Part 16: Applet

Chargement de fichiers

images ou sons, relatifs a une URL (base du code

ou base du document)

— URL getCodeBase(), adr reseau de l’applet

(.class)

— URL getDocumentBase(), adr reseau du

contexte de l’applet (.html)

— AudioClip getAudioClip(URL u), le clip

audio situe a l’adr reseau u

— AudioClip getAudioClip(URL u, String x),

idem, mais le clip est recherche a l’adresse x,

relativement a l’adresse de base u.

— Image getImage(URL u), l’image situee a l’adr

reseau u. Chargement progressif lors de la

premiere demande d’affichage dans le contexte

graphique courant, sauf si un controleur de

medias (java.awt.MediaTracker bloque l’applet

jusqu’a la fin du chargement).

— Image getImage(URL u, String x), idem ,

l’image est recherchee a l’adresse x,

relativement a l’adresse de base u.

Image image = getImage(getCodeBase(), "Fig/f.gif");


Part 16: Applet

Composants Graphiques

— Utilisation des CG d’AWT (Buttons,

Checkboxes, Labels, Canvas, etc.)

— les methodes de classe Container (par

heritage) permettent leur manipulation

— add, ajout d’un composant

— remove, suppression

— setLayout, definition de l’agenceur

— Composants graphiques Swing

— classe JApplet


Part 16: Applet

Parametres d’une applet (1/2)

import java.awt.event.*;

import java.net.*;


pub l i c c l a s s BoutonURL extends Applet

implements ActionListener {

Button b;

String url;


url = getParameter("URL");

i f (url == nu l l ) url = "Vide";

add(b = new Button(url));

b.addActionListener ( t h i s );

}

pub l i c void actionPerformed(ActionEvent e) {

i f (e.getSource() == b)

try {

getAppletContext (). showDocument(

new URL(b.getLabel ()), "_blank");

}

catch (MalformedURLException ex) {}

}

} // fin BoutonURL


Part 16: Applet

Parametres d’une applet (2/2)

Dans la balise Applet du fichier html, on passe les

valeurs des parametres

<applet code="Bouton.class" width=400 height=150>

<PARAM NAME=Url VALUE="http://www.unice.fr">

</applet>

— noms des parametres conventionnels

(SOURCE, xxxSOURCE, etc)

— les parametres sont des chaınes de car,

mais l’applet pourra interpreter des

entiers, des booleens, etc.

— description des parametres (peut etre

utilisee par le navigateur)


Part 16: Applet

pub l i c String [][] getParameterInfo () {

String [][] info = {

// Parametre Type Description

{"Url", "URL", "page a afficher "},

};

return info;

}


Part 16: Applet

Securite

L’action des applets est limitee. Chaque

navigateur possede un SecurityManager qui

assure le controle (SecurityException).

Une applet ne peut :

— utiliser que son propre code et l’API des

paquetages java.*. C’est tout.

— lire ou ecrire des fichiers de la machine

client. Fichiers cote serveur. Exception

pour les applets locales ou identifiees

(trusted, signature).

— etablir des connexions reseaux, sauf avec la

machine d’ou il est issu. Le serveur peut

servir de passerelles entre plusieurs applets

sur des clients differents.

— executer des programmes de la machine

client.

— lire certaines proritetes systemes :

java.class.path, java.home, user.dir,

user.home, user.name


Part 16: Applet

System.getProperty(""os.name"); // OK


Part 16: Applet

Thread et Applet

— graphique actif (animation)

— initialisation de l’applet (init() ⇒

start())

— terminaison (stop() ⇒ finalize())

import java.awt.*;


pub l i c c l a s s ThreadApplet

extends Applet implements Runnable {

pr iva t e Thread proc;


// initialisation des attributs

}

pub l i c void start() {

i f (proc == nu l l ) {

proc = new Thread( t h i s );

proc.start();

}

}


Part 16: Applet

pub l i c void stop () {

i f (proc != nu l l ) {

proc.interrupt();

proc = nu l l ;

}

}


whi le (isActive ()) {

// attendre laps de temps

// calculer les changements

repaint ();

}

}


// redessiner le motif

}

} // fin classe ThreadApplet


Animation


Part 17: Animation

Introduction

Pb reduction des clignotements lies au reaffichage

1. ne pas effacer la fenetre ;

2. redessinner le strict necessaire (detourage) ;

3. le double buffering.


Part 17: Animation

1 - ne pas effacer la fenetre

repaint ⇒ update ⇒ paint

pub l i c void update (Graphics g) {

g.setColor (getBackground ());

g.fillRect (0, 0, getsize ().width , getsize (). height );

g.setColor (getForeground ());

paint(g);

}

on reecrit update de la facon suivante :

pub l i c void update(Graphics g) {

paint(g);

}

— methode a utiliser lorsque les nouveaux

dessins doivent se superposer avec les

anciens


Part 17: Animation

2 - Detourage

Ne reafficher que ce qui est necessaire

Definir une portion de la fenetre sur laquelle

s’appliquera le reaffichage.

setClip(x, y, w, h) et clipRect(x, y, w, h)

Pour les animations, la portion doit se deplacer !

Pb : les appels a repaint peuvent etre tres

rapides, et certains appels a update et paint

peuvent etre perdus !

void repeindre() {

// Relance le dessin de l’ecran et attend jusqu’a ce que la

// procedure "paint" ait effectivement ete executee.

paintOK = f a l s e ;

repaint ();

whi le (! paintOK) {

try { .... sleep(time); }


}

} // fin repeindre


Part 17: Animation

3 - Double buffering (1/2)

Principe : ecrire dans une image auxiliaire. Une

fois l’image terminee, on l’affiche d’un coup sans

avoir a effacer l’image reelle precedente

Image temp; // Tampon pour image d’ecran.

Graphics gTemp; // Contexte graphique associe.

dans init :

temp = createImage(getSize ().width , getSize (). height );

gTemp = temp.getGraphics ();


Part 17: Animation

3 - Double buffering (2/2)

La methode paint dessine dans le contexte gTemp

associe a l’image tmp, et execute a la fin :

gTemp.drawRect (1,1,30,50);

...

// Afficher l’image tampon sur le veritable ecran :

g.drawImage(temp , 0, 0, t h i s );

g est connecte a l’ecran reel, temp est l’image a

dessiner a partir des coordonnees (0,0). Le dernier

parametre supervise l’affichage.

// suppression du clignotement

pub l i c void update(Graphics g) {

// effacer l’image temp

gTemp.setColor (getBackground ());

gTemp.fillRect (0, 0, getSize ().width , getSize (). heigh

gTemp.setColor (getForeground ());

paint(g);

}


Reseau


Part 18: Reseau

Connexion a des URL (1/3)

— paquetage java.net

— classe java.net.url

— URL (Uniform Ressource Locator)

protocole ://[utilisateur@]hote [:port ][/chemin /fichier ]

URL(adr)

URL(prot,host,file)

getProtocol()

getHost()

getFile()

URLConnection openConnection()

setDoInput(), setDoOutput()

connect()

openStream() (pour la lecture)

getContent()


Part 18: Reseau


URL u =

new URL("ftp ://vg:[email protected]/in/f");

URLConnection uc = u.openConnection ();

// indiquer l’acces en ecriture

uc.setDoOutput( true );

// creer un flot de sortie

OutputStream os = uc.getOutputStream ();

FileInputStream is = new FileInputStream("f");

// copie le fichier f.txt

i n t b;

whi le ((b = is.read ()) != -1)

os.write((byte ) b);

// fin de fichier

is.close(); os.close();


Part 18: Reseau


import java.net.*;

import java.io.*;

pub l i c c l a s s AfficherUrl {

pub l i c s t a t i c void main(String [] args)


try {

URL url = new URL(args [0]);

// convertir l’url en InputStream

InputStream in = url.openStream();

i n t c;

System.out.println(url.getHost ()+ "/" +

url.getFile ());

whi le ((c = in.read ()) != -1)

System.out.print(( char ) c);

}

catch (MalformedURLException e) {

System.err.println("Bad Url: " +

args [0]);

}

catch (UnknownHostException e) {

System.err.println("Bad Url: " +

args [0]);

}

}

} // fin classe AfficherUrl


Part 18: Reseau

Socket

— services (http, ftp, telnet, ...) sont associes

a des ports

— un port est une entree virtuelle de

l’ordinateur

— pour obtenir un service, il faut (host, port)

— dans un programme, on etablit une ligne

virtuelle entre les ports des ordinateurs a

connecter grace a une socket.

programme programme

Ordinateur A Ordinateur B

Internet

socket

port port

— port = entier sur 16 bits. Ports jusqu’a

1024 reserves (http 80, telnet 23, ...), au

dessus, libres

— un programme peut gerer plusieurs ports

et plusieurs sockets


Part 18: Reseau

Modes de transmission

Communication par commutateurs :

1) Mode non connecte :

— commutation par paquets independants,

— chaque paquet possede les adresses de

depart et d’arrivee

— Internet UDP, datagrams

— multicast

— connexion non fiable, ordre non garanti

2) Mode connecte :

— circuit virtuel de commutation etabli au

prealable

— Internet TCP

— connexion fiable, ordre garanti


Part 18: Reseau

Datagrammes (emission 1/2)

— classe DatagramPacket definit les paquets a

transmettre

— classe InetAddress definit les adresses

Internet

InetAddress adrSource = InetAddress.getLocalHost();

InetAddress adrDest = InetAddress.getByName("djinn");

Un paquet Datagram contient l’information a

transmettre :

String msg = "blabla blabla";

byte [] data = msg.getBytes ();

DatagramPacket paquet =

new DatagramPacket(data , data.length ,

adrDest , port );

Pour envoyer le paquet, il faut une socket :


Part 18: Reseau

DatagramSocket socket = new DatagramSocket ();

socket.send(paquet);


Part 18: Reseau

Datagrammes (emission 2/2)

import java.net.*; import java.io.*;

pub l i c c l a s s Emetteur {



// adresse du destinataire

InetAddress adrDest =

InetAddress.getByName(args [0]);

i n t portDest = Integer.parseInt (args [1]);

// creation de la socket

DatagramSocket socket = new DatagramSocket ();

byte [] data;

DatagramPacket paquet = nu l l ;

whi le ( true ) {

System.out.print("> ");

String msg = StdInput .readLine ();

i f (msg == nu l l ) break ;

// convertir le message en tableau de bytes

data = msg.getBytes ();

// creer le paquet et l’expedier

paquet = new DatagramPacket(data ,

data.length , adrDest , portDest );

socket.send(paquet );

}

socket.close();

}

}


Part 18: Reseau

Datagrammes (reception 1/2)

Un paquet Datagram contenant l’information a

recevoir doit etre cree :

byte [] data = new byte [512];

DatagramPacket paquet =

new DatagramPacket(data , data.length);

Pour recevoir le paquet, il faut egalement une

socket avec le port :

DatagramSocket socket = new DatagramSocket(port );

socket.receive(paquet );


Part 18: Reseau

Datagrammes (reception 2/2)

import java.net.*;

import java.io.*;

pub l i c c l a s s Receveur {



i n t port = Integer.parseInt (args [0]);


DatagramSocket socket =

new DatagramSocket(port);

// tampon ou mettre le message recu

byte [] data = new byte [512];

// creer un paquet de reception des messages

DatagramPacket paquet = new DatagramPacket(

data , data.length );

whi le ( true ) {

// recevoir le prochain message

socket.receive(paquet );

// afficher le message recu

System.out.print("from " +

paquet.getAddress(). getHostName ());

String msg = new String(paquet.getData (),

0,paquet.getLength());

System.out.println(" " + msg);

}

}

}


Part 18: Reseau

Datagrammes

Sur l’ordinateur emetteur, lyre :

lyre $ javac Emetteur.java

lyre $ java Emetteur djinn 17000

> blabla blabla

> abracadabra

>

Sur l’ordinateur recepteur, djinn :

djinn $ javac Receveur.java

djinn $ java Receveur 17000

from lyre.esinsa.unice.fr blabla blabla

from lyre.esinsa.unice.fr abracadabra


Part 18: Reseau

Datagrammes - Multicast

— Pour envoyer un message a un groupe de

machines destinatrices

— MulticastSocket

— les paquets sont envoyes a une adresse

multicast : 224.0.0.1 – 239.255.255.255 a

laquelle doit se joindre tous les

destinataires

MulticastSocket mcs = new MulticastSocket(port);

InetAddress mcsAdr =

InetAddress.getByName("228.5.6.7 ");

mcs.joinGroup(mcsAdr);

— Les datagrammes sont ensuite

normalement expedies ou recus avec les

methodes send et receive precedentes

— quitter le groupe :

mcs.leaveGroup(mcsAdr);

— exemple d’utilisation : programme chat


Part 18: Reseau

Mode connecte TCP (emission 1/2)

Un emetteur se connecte sur la machine

destinatrice grace a une socket :

Socket socket = new Socket("djinn", portDest );

// ou bien

Socket socket = new Socket ();

// 1er port libre

socket.bind(new InetSocketAddress ("localhost " ,0));

socket.connect(new InetSocketAddress ("djinn",

portDest ));

Un flot est cree entre les deux machines.

DataOutputStream out =

new DataOutputStream (socket.getOutputStream ());

DataInputStream in =

new DataInputStream(socket.getInputStream ());

L’emetteur ecrit (ou lit) dans le fichier out (ou

in).


Part 18: Reseau

Mode connecte TCP (emission 2/2)

import java.net.*;

import java.io.*;

pub l i c c l a s s Emetteur {



i n t portDest = Integer.parseInt (args [1]);

// creation du socket

Socket socket = new Socket ();

socket.bind(

new InetSocketAddress ("localhost ", 0));

socket.connect (new InetSocketAddress (

args[0], portDest ));

DataOutputStream out =

new DataOutputStream(

socket.getOutputStream ());

whi le ( true ) {

System.out.print("> ");

String msg = StdInput .readLine ();

i f (msg == nu l l ) break ;

// ecrire le message

out.writeChars(msg); out.writeChar(’\n’);

}

out.close();

socket.close ();

}

}


Part 18: Reseau

Mode connecte TCP (reception 1/2)

— Le receveur doit creer une socket speciale,

ServerSocket en specifiant le numero de

port

— Il indique ensuite qu’il est pret a accepter

la connexion d’un emetteur

ServerSocket socketServeur =

new ServerSocket(port);

Socket socketEmetteur = socketServeur.accept ();


Part 18: Reseau

Mode connecte TCP (reception 1/2)

import java.net.*;

import java.io.*;

pub l i c c l a s s Receveur {




// creation de la socket serveur



// creation du socket de reception

Socket socket = socketServeur.accept ();

// creation du flot de communication

BufferedReader din =

new BufferedReader(

new InputStreamReader (

socket.getInputStream ()));

whi le ( true ) {

System.out.print("from " +

socket.getInetAddress (). getHostName ());

System.out.println(" " + din.readLine ());

}

}

}


Part 18: Reseau

Sur l’ordinateur emetteur, lyre :



> blabla blabla

> abracadabra

>

Sur l’ordinateur serveur, djinn :

djinn $ javac Receveur.java

djinn $ java Receveur 17000

Serveur actif sur le port 17000




Part 18: Reseau

Modele Client/Serveur (1/4)

Dans un modele client/serveur, le receveur est le

serveur qui peut accepter plusieurs connexions de

differents clients. Chaque client est traite par

dans un thread.

whi le ( true ) {

// attendre la prochaine connexion

Socket socketClient = socketServeur.accept ();

new GestionDuClient(socketClient); // thread

}


Part 18: Reseau


import java.net.*;

import java.io.*;

pub l i c c l a s s Serveur {







System.out.println ("Serveur actif " +

"sur le port " + port);

whi le ( true ) {

// attendre la prochaine connexion

Socket socketClient =

socketServeur.accept ();

System.out.println(

socketClient.getInetAddress ().

getHostName() + " connecte ");

// gerer le client dans un thread

new GestionDuClient(socketClient);

}

}

}


Part 18: Reseau


c l a s s GestionDuClient implements Runnable {

pub l i c Thread proc = new Thread( t h i s );

pr iva t e Socket socket;

pr iva t e BufferedReader din;

pub l i c GestionDuClient(Socket s)


socket = s;

InputStreamReader in =

new InputStreamReader (s.getInputStream ());

din = new BufferedReader(in);

proc.start();

}


whi le ( true )

try {

// creer un paquet de reception des messages

System.out.print("from " + socket.

getInetAddress (). getHostName ());

System.out.println(" " + din.readLine ());

}

catch (IOException e) { break ; }

System.out.println(socket.getInetAddress ().

getHostName() + " deconnecte");

try { socket.close ();}

catch (IOException e) {}

}

}


Part 18: Reseau


Sur les ordinateurs clients



> blabla blabla

> abracadabra

>

mondrian $ javac Emetteur.java

mondrian $ java Emetteur djinn 17000

> hello ...

>

Sur l’ordinateur serveur, djinn :


Part 18: Reseau

djinn $ javac Serveur.java

djinn $ java Serveur 17000

Serveur actif sur le port 17000

mondrian.esinsa.unice.fr connecte

lyre.esinsa.unice.fr connecte


from mondrian.esinsa.unice.fr hello ...



Jni


Part 19: Jni

Jni (1/6)

Jni (Java Native Interface) permet d’executer du

code C, C++, ... dans une application Java

Interet :

— reutilisation de code existant

(bibliotheque)

— code particulier en assembleur

— ...

Jni permet une communication bidirectionnelle

entre entre les deux formes de code (Java et C par

exemple).


Part 19: Jni

Jni (2/6)

Exemple : l’incontournable HelloWorld

c l a s s HelloWorld {

pub l i c nat ive void displayHelloWorld ();

s t a t i c {

// le code C est dans la bibliotheque hello

System.loadLibrary("hello");

}

pub l i c s t a t i c void main(String[] args) {

new HelloWorld(). displayHelloWorld ();

}

}

On compile

javac HelloWorld.java


Part 19: Jni

Jni (3/6)

Creation du .h associe a la classe HelloWorld

javah HelloWorld

Le fichier donne le prototype de la fonction C qui

assure l’interface avec Java. Nom conventionnel

Java_Nom de la classe _Nom de la methode

Java_HelloWorld_displayHelloWorld


Part 19: Jni

Jni (4/6)

/* DO NOT EDIT THIS FILE - it is machine generated */

#inc lude <jni.h>

/* Header for class HelloWorld */

#i f n d e f _Included_HelloWorld

#de f i n e _Included_HelloWorld

#i f d e f __cplusplus

extern "C" {

#end i f

/*

* Class: HelloWorld

* Method : displayHelloWorld

* Signature: ()V

*/

JNIEXPORT void JNICALL Java_HelloWorld_displayHelloWorl

(JNIEnv *, jobject );

#i f d e f __cplusplus

}

#end i f

#end i f


Part 19: Jni

Jni (5/6)

Le fichier C :

#inc lude <jni.h>

#inc lude "HelloWorld.h"

#inc lude <stdio.h>

JNIEXPORT void JNICALL

Java_HelloWorld_displayHelloWorld (JNIEnv *env , jobject o

{

printf("Hello world!\n");

return ;

}

Creation de la bibliotheque libhello (Linux)

gcc -shared -I${JAVA_HOME}/include \

-I${JAVA_HOME}/include/linux HelloWorld.c -o libhello.so

Execution de l’application Java

LD_LIBRARY_PATH=. java HelloWorld

Hello world!


Part 19: Jni

Jni (6/6)

Jni permet egalement l’acces a Java depuis le

code natif (C, C++).

L’interface JNI offre :

— des definitions d’equivalence de type

(jboolean, jint, jdouble, jstring, jarray,

jclass, etc.)

— des fonctions de manipulation de ces types

par l’intermediaire de (JNIEnv *env)

— l’acces aux attributs et aux methodes

d’objets Java


Jdk 1.5


Part 20: Jdk 1.5

Nouveautes Tiger

La version 1.5 (Tiger) apporte des changements

importants au langage :

— Autoboxing

— Importation static

— Enonce foreach

— Enumerations

— Genericite


Part 20: Jdk 1.5

Autoboxing

Les conversions explicites entre les types

elementaires et leurs equivalents ≪ objet ≫ n’est

plus necessaire :

Character c = ’a’;

i n t i = new Integer (10);

Hashtable ht = new Hashtable();

ht.put("Paul", 3);

ht.put("Pierre", 19);

Integer n = (Integer) ht.get("Pierre");

i f (n != nu l l )



Part 20: Jdk 1.5

Importation static

Specialisation de la directive import pour l’acces

non qualifie aux objets declares static d’une

classe

i1 = Math.sqrt(-∆)/(2*a);

on pourra ecrire :

import s t a t i c java.lang.Math .*;

...

i1 = sqrt(-∆)/(2*a);


Part 20: Jdk 1.5

Enonce ≪ foreach ≫ (1/2)

Forme generalisee de l’enonce pour lorsqu’il s’agit

d’appliquer un meme traitement a tous les

elements d’un tableau ou d’une collection :

— ecriture plus naturelle et plus sure

i n t [] tab;

....

i n t somme = 0;

f o r ( i n t i=0; i <tab.length; i++)

somme += tab[i];

i n t [] tab;

....

i n t somme = 0;

f o r ( i n t x : tab)

somme+=x;


Part 20: Jdk 1.5

Enonce ≪ foreach ≫ (2/2)

Vector v = new Vector ();

v.addElement (13); v.addElement (128); ....

i n t somPairs = 0;

f o r (Iterator i = v.iterator (); i.hasNext (); ) {

Integer x = (Integer ) i.next ();

i f (x % 2 == 0) somPairs +=x;

}

Vector v = new Vector ();

v.addElement (13); v.addElement (128); ....

i n t somPairs = 0;

f o r (Object x : v)

i f ((Integer) x % 2 == 0) somPairs += (Integer) x;


Part 20: Jdk 1.5

Enumeration (1/2)

Enumeration de constantes representees par des

noms (comme en C)

enum Couleur { trefle , carreau , coeur , pique }

enum Valeur {deux , trois , quatre , cinq , six , sept ,

huit , neuf , dix , valet , dame , roi , as }

c l a s s Carte {

Couleur couleur;

Valeur valeur;

Carte(Valeur v, Couleur c) {

valeur = v;

couleur = c;

}

}

...

new Carte(Valeur.as, Couleur.coeur);

...


Part 20: Jdk 1.5

Enumeration (2/2)

— les enumerations sont des objets

— methode predefinie values()

— on peut ajouter des attributs et des

methodes

// fabrication d’un jeu de 52 cartes

Carte [] jeu52 = new Carte [52];

i n t i = 0;

f o r (Couleur c : Couleur.values ())

f o r (Valeur v : Valeur.values ())

jeu52[i++] = new Carte(v, c);


Part 20: Jdk 1.5

enum Valeur {

deux(2), trois(3), quatre (4), cinq (5),

six(6), sept (7), huit(8), neuf (9), dix(10),

valet(10), dame (10), roi(10), as(20);

i n t valeur;

Valeur( i n t v) { valeur = v; }

i n t valeur () { return valeur; }

} // fin enum

System.out.println(Valeur.as); // as

System.out.println(Valeur.as.valeur ()); // 20


Part 20: Jdk 1.5

Genericite (1/5)

— Permet de parametrer le type des

structures de donnees

— evite les conversions explicites de type dues

a Object

— assure les controles de type

Hashtable <String , Integer > ht =

new Hashtable <String , Integer >();

ht.put("Paul", 3);

ht.put("Pierre", 19);

Integer n = ht.get("Pierre"); // pas de conver. explicite

i f (n != nu l l )


Vector <Integer > v = new Vector <Integer >();

v.addElement("toto"); // ! erreur compilation

v.addElement (13); v.addElement (128); ...

i n t somPairs = 0;

f o r (Integer x : v)

// pas de conversion explicite

i f (x % 2 == 0) somPairs += x;


Part 20: Jdk 1.5

Genericite (2/5)

c l a s s Noeud <T> {

T val;

Noeud <T> suivant;

Noeud(T v) { val = v; }

}

c l a s s Pile <E> {

Noeud <E> sommet;

void empiler(E x) {

// ajouter en tete l’element x

Noeud <E> p = new Noeud <E>(x);

p.suivant = sommet;

sommet = p;

}

E sommet() {

// retourner la valeur du sommet de pile

return sommet.val;

}

}


Part 20: Jdk 1.5

Genericite (3/5)

// Definition simplifiee d’une Pile generique

c l a s s Pile <T> {

pr iva t e f i n a l i n t N = 100;

pr iva t e i n t sommet = 0;

// pas de genericite sur les tableaux !

pr iva t e T [] elements = (T[]) new Object[N];

pub l i c void empiler(T x) {

elements [sommet ++] = x;

}

pub l i c void depiler () {

sommet --;

}

pub l i c T sommet () {

return elements [sommet -1];

}

}


Part 20: Jdk 1.5

Genericite (4/5)

// une pile de chaınes

Pile <String > p1 = new Pile <String >();

// une pile de piles d’entiers

Pile <Pile <Integer >> p2 =

new Pile <Pile <Integer >>();

Mais aussi, sans genericite

Pile p = new Pile();

p.empiler("bonjour");

p.empiler(6); // OK

// la conversion suivante est obligatoire

Integer i = (Integer) p.sommet();

mais alors, message du compilateur

Note: Test.java uses unchecked or unsafe operations.

Note: Recompile with -Xlint:unchecked for details.


Part 20: Jdk 1.5

Genericite (5/5)

Genericite sur plusieurs types :

c l a s s Noeud <C,V> {

C cle;

V val;

Noeud <C,V> suivant;

Noeud (C c, V v) { cle = c; val = v; }

}

et avec les interfaces :

i n t e r f a c e Pile <T> { void empiler(T x);

}

// Implementation d’une pile par un tableau

c l a s s PileTableau <E> implements Pile <E> { ... }

// idem avec une structure chaınee

c l a s s PileChaınee <E> implements Pile <E> { ... }

...

Pile <String > p = new PileChaınee <String >();

Notez le meme nom E


Part 20: Jdk 1.5

Genericite et Polymorphisme (1/2)

Pile <Integer > p1 = new Pile <Integer >();

Pile <Object > p2 = p1;

Illegal : car on pourrait empiler autre chose que

des Integer !

De meme :

void afficherSommet(Pile <Object > p) {

System.out.println(p.sommet ());

}

...

Pile <Integer > p = new Pile <Integer >();

afficherSommet(p); // types incompatibles


Part 20: Jdk 1.5

Genericite et Polymorphisme (2/2)

Solution : la notation ?

void afficherSommet(Pile <?> p) {...}

...

Pile <Integer > pi = new Pile <Integer >();

afficherSommet(pi); // OK

Pile <String > ps = new Pile <String >();

afficherSommet(ps); // OK

— pour limiter le polymorphisme aux

sous-classes de A

void afficherSommet(Pile <? extends A> p) {...}

— ? super A pour limiter le polymorphisme

aux super-classes de A


Part 20: Jdk 1.5

Methodes generiques

void dupliquerSommet(Pile <?> p) {

Object o = p.sommet (); // OK

p.empiler(o); // erreur de compilation

// car le type des elements est inconnu

}

Solution : methodes generiques

<T> void dupliquerSommet(Pile <T> p) {

T o = p.sommet ();

p.empiler(o);

}

Pile <Integer > p1 = new Pile <Integer >();

Pile <String > p2 = new Pile <String >();

dupliquerSommet(p1);

dupliquerSommet(p2);


Jdbc


Part 21: Jdbc

JDBC (1/8)

— Java Database Connectivity

— offre la connexion d’applications Java avec

differents types de BD (SQL, tableurs, etc.)

— API JDBC est independante du SGBD.

— Ensemble de classes (java.sql.*)

client client

serveur BDserveur BD

midleware

Modele 2 couches Modele 3 couches


Part 21: Jdbc

JDBC (2/8)

L’acces a la BD se fait par l’intermediaire d’un

pilote.

1. un pont entre JDBC et ODBC (Microsoft).

La communication se fait via des fonctions

C appelees par les methodes du pilote ;

2. les pilotes recourant a des fonctions

non-Java specifiques du SGBD ;

3. les pilotes permettent l’emploi d’un serveur

middleware. Il s’agit d’une interface avec le

SGBD via une API specifique ;

4. les pilotes Java proprietaires utilisant

directement le protocole reseau du SGBD

(e.g. mysql-connector).


Part 21: Jdbc

JDBC (3/8)

— import java.sql.*

— JDBC gere :

— la connexion a la BD

— l’envoi de requetes SQL

— l’exploitation des resultats provenant

de la BD


Part 21: Jdbc

JDBC - Connexion (4/8)

DriverManager :

— gere les pilotes charges (ici pour mysql) :

try {

// creer une nouvelle instance du Driver

Class.forName(

"com.mysql.jdbc.Driver"). newInstance();

}

catch (Exception ex) { /* gerer les erreurs */ }

— cree les connexions (Connection) :

String urlBD="jdbc:mysql:// localhost /bd";

try (Connection conn =

DriverManager.getConnection(urlBD ,"user","pass");

)

{

// code de l’application qui accede a la BD

...

} catch (Exception ex) { /* gerer les erreurs */ }


Part 21: Jdbc

JDBC - Statement (5/8)

— Envoi de requetes SQL (Statement

— createStatement pour une requete SQL

simple (sans parametre)

— prepareStatement pour une requete SQL

(precompilee) avec parametres

— prepareCall pour l’appel d’une procedure

preparee.

— ResultSet executeQuery(),

int executeUpdate()

// creer un Statement

Statement stmt = conn.createStatement ();

// executer une requete SQL

ResultSet rs = stmt.executeQuery(

"SELECT * FROM uneTable ;");


Part 21: Jdbc

JDBC - ResultSet (6/8)

— ResultSet resultat d’une requete SQL (i.e.

lignes de la table)

— methodes get pour acceder aux colonnes

de la ligne courante

— next() pour passer le curseur a la ligne

suivante

— previous()

— conversion de types entre SQL et Java

(getString, getInt, getDate, ...)

rs.absolute (2);

System.out.println("Resultat : " + rs.getInt (1));

rs.beforeFirst();

whi le (rs.next ()) {

String nom = rs.getString("nom");

String espece = rs.getString("espece");

Date naissance = rs.getDate ("naissance ");

System.out.println(nom + " " + espece +

" " + naissance);

}


Part 21: Jdbc

JDBC - prepareStatement (7/8)

— requete precompilee (plus efficace)

— parametres

// INSERT INTO animal VALUES

// -> (’Coco’,’Diane’,’Perroquet’,’f’,’2000-06-09’,NULL);

PreparedStatement pstmt =

conn.prepareStatement (

"INSERT INTO animal VALUES (?,?,?,?,?, NULL );");

// definir les parametres

pstmt.setString(1, "Coco");

pstmt.setString(2, "Diane");

// executer la requete

pstmt.executeUpdate ();


Part 21: Jdbc

JDBC - callStatement (8/8)

— requete precompilee pour appeler une

fonction de la BD

— parametres

CallableStatement cstmt =

conn.prepareCall("call myfunc (?,?); ");

// fixer la valeur du 1er parametre donnee ( e.g. un reel)

cstmt.setFloat (1, 34.5f);

// le 2eme parametre est un resultat ( e.g. une chaıne)

cstmt.registerOutParameter (2,Types.VARCHAR );

// executer la requete

cstmt.execute ();

// afficher le le resultat

System.out.println(cstm.getString(2));


LelangageJava CoursElec5–EPUusers.polytech.unice.fr/~vg/ressources/Java.pdf · LelangageJava...

Documents

Transcript of LelangageJava CoursElec5–EPUusers.polytech.unice.fr/~vg/ressources/Java.pdf · LelangageJava...