Vous êtes sur la page 1sur 140

J1

Pr´eambule

1

Slide 1

Slide 2

Stage Java

Emmanuel Chailloux m´el : Emmanuel.Chailloux@lip6.fr www : http://cadillac.lip6.fr/~emmanuel

du 29 juin au 3 juillet 1998

UFR d’Informatique Universit´e Pierre et Marie Curie www : http://www.ufr-info-p6.jussieu.fr

Organisation
Organisation

cours le matin : 9h30-12h30 couloir 45-46 porte 305

TP l’AM : 13h30-16h30 couloir 45-46 salle GLA 15 machines, comptes individuels environnement Windows NT et Unix

J1

Pr´eambule

2

Slide 3

Slide 4

 
Pr´erequis
Pr´erequis
 

connaissance d’un langage imp´eratif (C ou Pascal)

utilisation d’un OS : Unix/X ou Windows NT

manipulation d’un navigateur

 
Objectifs
Objectifs

Description: via le langage Java de la

 
 

programmation objet

programmation graphique et par ´ev´enements

programmation concurrente

programmation distribu´ee

implantation des langages

pour l’enseignement, le d´eveloppement d’applications et la recherche

J1

Pr´eambule

3

Slide 5

1.

2.

3.

4.

5.

Plan du stage
Plan du stage

noyau du langage Java

types, interfaces et paquetages

processus l´egers, graphisme et applets

persistance et distribution

implantation et extensions

J1

Pr´eambule

4

Slide 6

Bibliographie
Bibliographie

“Java in a Nutshell”, D. Flanagan, O’Reilly, 1997 Tr`es bon pour le programmeur C ou C++, JDK 1.1

“Java : de l’esprit `a la m´ethode -

distribution d’applications sur Internet”,

M. Bonjour, G. Falquet, J. Guyot et A. Le

Grand - International Thomson Publisher,

1996.

Tr`es clair, bonne p´edagogie, JDK 1.0

“Just JAVA and Beyond”, P. van der Linden, SUN Press 1998. Tr`es bonne pr´esentation avanc´ee, JDK 1.1

“Data Structures and Algorithms in Java”,

M. T. Goodrich, R. Tamassia, Wiley 1998.

Algorithmique en Java + un “Primer” en annexe, JDK 1.1

J1

Pr´esentation g´en´erale

5

Slide 7

Slide 8

 
Remerciements
Remerciements
 

Christian Queinnec : transparents

Vassiliki Spathis : polycopi´e

Jean Fran¸cois Perrot, Philippe Codognet : exemples

Michelle Joab : organisation

Fran¸cois Barth´elemy (CNAM) et Pascal Molli (LORIA) : cours en ligne

l’´equipe du DESS GLA : pr´eparation des machines

 
Plan du 1er jour
Plan du 1er jour
 

pr´esentation g´en´erale de Java

noyau imp´eratif : expressions - instructions

noyau objet : classes, instances, h´eritage, liaison retard´ee

gestion m´emoire

contrˆole d’ex´ecution

J1

Pr´esentation g´en´erale

6

Slide 9

 
JAVA
JAVA
 

Simple

Orient´e Objet

Typ´e

Compil´e/Interpr´et´e

Ind´ependant de l’architecture machine

Distribu´e

Processus L´egers (Threads)

Robuste

Petit

Rapide

Sˆur

`a chargement dynamique

J1

Pr´esentation g´en´erale

7

Slide 10

Historique
Historique

1994, Java SUN James Gosling (emacs, NeWS)

“Un coktail innovant de techniques ´ecul´ees!”

“L’originalit´e de Java est de n’en avoir aucune!”

Influences: C, C++, Lisp, ML, Modula3

J1

Pr´esentation g´en´erale

8

Slide 11

Mise en Oeuvre
Mise en Oeuvre

toto.class

8 Slide 11 ✬ ✫ ✩ Mise en Oeuvre toto.class Java BC INTERNET stdout BC stderr
8 Slide 11 ✬ ✫ ✩ Mise en Oeuvre toto.class Java BC INTERNET stdout BC stderr
Java BC
Java
BC
8 Slide 11 ✬ ✫ ✩ Mise en Oeuvre toto.class Java BC INTERNET stdout BC stderr

INTERNET

stdout BC stderr C
stdout
BC
stderr
C

stdin

event GUI order BC
event
GUI order
BC

appletviewer

HTTP-browser

J1

Noyau Imp´eratif

9

Slide 12

JDK BC BC la JVM .o .o C C BC µ µ .o la biblio
JDK
BC
BC
la JVM
.o
.o
C
C
BC
µ
µ
.o
la biblio
C
C
.o
native
µ
Java
le
BC
BC
Java
compilo
Java
Java
Java
BC
BC
BC
BC
µ
bibliothèques
Java
Java
BC
BC
de classes
JDK
BC
BC
µ

J1

Noyau Imp´eratif

10

Slide 13

Noyau imp´eratif
Noyau imp´eratif

`a la C

Expressions:

expression := variable

| operateur expression

| expression operateur

| expression operateur expression

| ( expression )

| (type de base) expression

| expression ? expression : expression

| variable = expression

| variable operateur= expression

J1

Noyau Imp´eratif

11

Slide 14

Slide 15

Types de base:

type tnb bit d´efaut boolean false,true 1 false char Unicode 16 \u0000 byte tous sign´es
type
tnb bit
d´efaut
boolean false,true
1
false
char
Unicode
16
\u0000
byte
tous sign´es
8
0
short
“ “
16
0
int
“ “
32
0
long
“ “
64
0
float
IEEE 754
32
0.0 (F)
double
“ “
64
0.0 (D)

Remarque: Ces valeurs ne sont pas des objets, il existe cependant

, Double.

des classes associ´ees qui sont Boolean, Char, Byte,

Exemples d’expressions
Exemples d’expressions

1

x = x + x++ (z % 3) << 2

z=18

x += 1

(byte)i (x<2) ? 2.7 : 3.14 (x != null) || (y >= 3.14) (b = !b) & (( i ^= ~i) == 0)

s + "Hello" : concat´enation

"an " + 1998 : avec conversion

Stricte s´eparation entre bool´eens et entiers

Non conversion pointeur - bool´een

J1

Noyau Imp´eratif

12

Slide 16

Instructions
Instructions

}

instruction ::= { instruction;

| if ( bool) {instructions};

| if ( bool ) {instructions} else {instructions}

| L: while (bool) {instructions}

| L: do {instructions} while (bool);

| L: for (expressions; bool; expressions) {instructions}

| L:switch (expressions) {case constant : intruction; default : instruction;}

continue label; continue; break label; break;

J1

Noyau Imp´eratif

13

Slide 17

Slide 18

 

 
Exemple d’instructions
Exemple d’instructions
 

i=1;

for (i=1; i < j ; i++) {

 

while (i < j) {

 
 

if

(i*i > j ) break;

if

(i*i > j ) break;

 

i++;

}

}

switch (x % 5) { case 0: {

; break;}

 
 

case 1: case 3: {

;

break;}

default: {

}

 

}

 

 

 
Types des variables
Types des variables
 
 

1.

les types de base

2.

les noms de classe

3.

les noms d’interface

4.

les types tableaux

 

J1

Noyau Imp´eratif

14

Slide 19

Variables locales
Variables locales

`a l’int´erieur d’un bloc

{ // debut du bloc 1

int i; int j = 18;

int h = 22;

{ // debut du bloc 2

int w = J + 4; // float i = 3.14;

} // fin du bloc 2

{ double w = 3.14; } } // fin du bloc 1

for (int i = 0; i < 10; i++) {

}

J1

Noyau Imp´eratif

15

Slide 20

Premier programme
Premier programme

/ premier programme calcul de fibonacci

/

class Fibo {

public static void main (String [] args) { int i; int j = 1; int n = 8; int r = 0;

for ( int v = 1; v < n; v++) {

r = r + j;

i = j;

j = r;

} // que vaut r en sortie?

}

}

J1

Noyau Imp´eratif

16

Slide 21

Tableaux
Tableaux

type [] : un type suivi du symbole []

D´eclaration:

instruction ::= type [] variable; | type [] variable

Cr´eation:

expression ::= new type [taille];

Allocation dynamique de l’espace V´erification des indices - indice `a partir de 0 Pas de dimension multiple : utilisation de tableaux de tableaux.

= {value

} ;

J1

Noyau Imp´eratif

17

Slide 22

Tableau : un exemple
Tableau : un exemple

{ int [] ft; int i; int n = 8;

ft = new int [n+1];

ft[0]=1;

ft[1]=1;

for (i = 2; i < ft.length; i++) { ft[i] = ft[i-1] + ft[i-2];

}

// que contient ft a‘la sortie

}

J1

Noyau Imp´eratif

18

Slide 23

Tableaux de Tableaux
Tableaux de Tableaux

int [][] m,t; int p = 4; int q = 5;

m = new int [p][q]; t = new int [q][p]; // remplissage for (i=0; i<p; i++) { for (j=0; j< q; j++) { m[i][j] = i*j;

}

}

// transposee for (i=0; i<p; i++) { for (j=0; j< q; j++) { t[j][i]=m[i][j];

}

}

J1

Noyau Objet

19

Slide 24

Slide 25

Tableaux (suite)
Tableaux (suite)

dimension possiblement h´et´erog`ene

int [] [] a; a = new int [5] [];

a[0] = new int[1]; a[1] = new int [ a[0].length + 1]; a[0][0] = 33;

a[2].length;

Les tableaux sont des objets avec une classe associ´ee.

// BOOM !!!!

Pause Java
Pause Java

J1

Noyau Objet

20

Slide 26

Slide 27

G´en´eralit´es
G´en´eralit´es

Encapsulation:

Classes et Instances:

Surcharge:

H´eritage:

Red´efinition et Liaison Retard´ee:

Polymorphisme et Sous-Typage:

Terminologie Objet
Terminologie Objet

classe = description des donn´ees et des proc´edures qui les manipulent d´efinit des comportements

objet = instance d’une classe (poss`ede tous les comportements de la classe)

m´ethode = action (proc´edure, fonction) que ln peut effectuer sur un objet

envoi de message = demande d’ex´ecution d’une m´ethode

J1

Noyau Objet

21

Slide 28

Slide 29

}

D´eclaration de Classes
D´eclaration de Classes

[ modifieur ]* class la_classe [ extends la_superclasse ] { // champs [modifieur]* type champ [ = expression] ; // constructeurs [modifieur]* la_classe ( [type variable]*) { instructions // sans return

}

// methodes [modifieur]* TypeRetour methode ([Type variable)*) [throws [exception]+] { instructions // avec return

}

Statique ou Dynamique
Statique ou Dynamique

modifieur static variable ou m´ethode de classe!!!

variables de classe = variables d’instance

m´ethodes de classe = m´ethodes d’instance

Par d´efaut dynamique (non statique) variables ou m´ethodes d’instances!!!

Possibilit´e de m´elanger les 2.

J1

Noyau Objet

22

Slide 30

Java statique : programmation modulaire
Java statique : programmation modulaire

Les variables et m´ethodes de classes :

sont d´eclar´ees avec static

existent d`es le chargement de la classe (sans instance)

existent en un unique exemplaire

accessible par la notation “point”

Une classe qui ne contient que des champs statiques peut ˆetr e consid´er´ee comme un module classique (Unit Pascal) :

o`u les m´ethodes sont les fonctions du modules et les variables les variables globales.

J1

Noyau Objet

23

Slide 31

Exemple en Java statique
Exemple en Java statique

class ES {

static void writeln( String s) { System.out.println(s);

}

}

class TestES {

public static void main (String [] args) { ES.writeln( "Salut tout le monde");

}

}

Enfin, un point d’entr´ee d’un programme est

une classe qui contient une m´ethode public

static void main

: java TestES

J1

Noyau Objet

24

Slide 32

Slide 33

Java dynamique : programmation objet
Java dynamique : programmation objet

Les variables et m´ethodes de d’instances :

ne sont pas d´eclar´ees avec static

sont allou´ees `a la cr´eation d’une instance ( new )

existent pour chaque instance

accessible aussi par la notation “point”

o.m(a) : envoi du message m avec le param`etre a sur l’objet o dne classe c.

Constructeur
Constructeur

Chaque classe poss`ede au moins un constructeur pour initialiser un nouvel objet de ce type.

m´ethode de mˆeme nom que la classe

sans type de retour

appel´e d`es l’allocation ( new )

J1

Noyau Objet

25

Slide 34

Slide 35

Surcharge
Surcharge

La surcharge (overloading) permet de d´efinir au sein de la mˆeme classe des m´ethodes de mˆeme nom qui diff`erent par le type des param`etres ou par le type du r´esultat.

y compris pour les constructeurs.

Classe Point
Classe Point

class Point { // variables d’instance int x, y; // constructeurs Point( int a, int b) { x=a;y=b; } Point() { x=0;y=0; } // methodes d’instance void moveto ( int a, int b) { x=a;y=b; } void rmoveto ( int dx, int dy) { x+=dx;y+=dy; } void affiche() { ES.writeln( "(" + x + "," + y + ")"); } double distance() { return Math.sqrt(x x+y y); }

}

J1

Noyau Objet

26

Slide 36

Programme test de Point
Programme test de Point

class Test {

public static void main(String args[])

{

Point p0 = new Point(); Point p1 = new Point(3,4);

p0.affiche(); p1.affiche();

p0.rmoveto(7,12);

p1.rmoveto(5,6);

p0.affiche(); p1.affiche(); if (p0.distance() == p1.distance()) ES.writeln( "c’est le hasard"); else ES.writeln( "on pouvait parier");

}

}

J1

Noyau Objet

27

Slide 37

Slide 38

H´eritage
H´eritage

Avantage principal de la programmation objet :

Extension du comportement d’une classe existante tout en co ntinuant `a utiliser les variables et les m´ethodes d´ecrites par la classe originale.

Toute d´efinition de classe ´etend une classe existante.

Si l’on ne pr´ecise rien on ´etend la classe Object on h´erite toujours de quelqu’un!!!

Exemple d’H´eritage
Exemple d’H´eritage

class PointColore extends Point {

String c;

PointColore() { c="blanc"; } PointColore( int a, int b, String x){ moveto(a,b);c=x; }

// fin de la classe PoinColore

void affiche bis() { ES.writeln( "(" + x + "," + y + ") de couleur " + c);

}

}

J1

Noyau Objet

28

Slide 39

Red´efinition
Red´efinition

La red´efinition (overriding) permet de d´efinir une m´ethode de mˆeme nom et de mˆeme signature (type) qu’une m´ethode h´erit´ee.

Ce sera donc cette derni`ere qui sera appel´ee lors de l’envoi d’un message de ce nom avec les param`etres correspondants.

class PointColore extends Point { String c; PointColore() { c="blanc"; } PointColore( int a, int b, String x) { moveto(a,b);c=x;

}

void affiche() {

// redefinition

ES.writeln( "(" + x + "," + y + ") de couleur " + c);

}

} // fin de la classe PointColore

J1

Noyau Objet

29

Slide 40

Slide 41

this et super
this et super

this correspond `a l’instance qui ex´ecute la m´ethode. Tout envoi de message sans r´ecepteur est un envoi `a this (param`etre implicite).

Utile pour distinguer les variables locales ou les param`et res des variables d’instance. :

void Point(int x, int yy){ this.x=x; y = yy;}

En cas de red´efinition d’une m´ethode, il peut ˆetre utile d’appeler la m´ethode ancˆetre : super

void affiche() { super.affiche(); ES.write("de couleur "+c);

}

Retour sur les constructeurs
Retour sur les constructeurs

Un constructeur dne classe descendante effectue un appel explicite au constructeur ancˆetre sans param`etre ( super()).

Pour appeler un constructeur ancˆetre avec param`etres, il faut expliciter l’appel : super(3,2.1)

Comme toute classe descend au moins d’ Object, un constructeur est toujours appel´e au new .

J1

Noyau Objet

30

Slide 42

Liaison retard´ee
Liaison retard´ee

Le choix de la m´ethode s’effectuera `a l’ex´ecution (runtime).

Int´erˆets :

permet donc de modifier facilement le comportement d’une cla sse

y compris pour une classe compil´ee (sans le source)

autorise le polymorphisme d’inclusion (voir sous-typage)

J1

Noyau Objet

31

Slide 43

}

}

Exemple
Exemple

//

class InputString{ String txt; InputString(){ txt=""; } String value() { return txt; }

void input(String msg) { ES.write(msg + " :

");

txt=this.read str(); ES.writeln();

}

String read str() { String s = new String(); char c;

while ((c=ES.readkey()) = \ n’)

{ ES.write(c);s=s+c; } return s;

J1

Noyau Objet

32

Slide 44

}

Exemple de red´efinition
Exemple de red´efinition

class InputPasswd extends InputString {

String read str() { String s = ""; char c; do { c = ES.readkey(); if (c = \ n’) { ES.write(’ ’); s = s + c; } } while (c = \ n’); return s;

}

J1

Noyau Objet

33

Slide 45

Ex´ecution
Ex´ecution

class TestInput {

public static void main(String args[]) { InputString s1 = new InputString(); InputPasswd s2 = new InputPasswd();

s1.input( "login"); s2.input( "passwd"); ES.writeln( "\ n\ n"); ES.write(s1.value() + " a " +

s2.value());

}

}

ES.write( " comme mot de passe");

java TestInput login : emmanuel passwd : ******* emmanuel a pilpoil comme mot de passe

J1

Gestion m´emoire

34

Slide 46

Slide 47

Polymorphisme
Polymorphisme

R´eutilisation du mˆeme nom sur des types diff´erents.

param´etrique (`a la Caml) : mˆeme code pour n’importe quel param`etre;

ad hoc (surcharge) : code diff´erent selon le type des param`etres;

d’inclusion (ou d’h´eritage) : code diff´erent selon les sous-types.

En Java polymorphisme ad hoc et d’inclusion (sous-cas plus fin du premier).

Relations
Relations

Est-un (is-a) :

s’il est un descendant

A-un (has-a) :

s’il poss`ede une variable d’instance

Une difficult´e de conception objet provient de la communicat ion entre objets!!!

J1

Exceptions

35

Slide 48

M´emoire et Egalit´e
M´emoire et Egalit´e

pointeur = r´ef´erence = adresse m´emoire pointeur nul = null

les objets et les tableaux sont des r´ef´erences!!! pas les types de base

op´erateur == teste uniquement les adresses, pas le contenu de la zone point´ee Utiliser alors la m´ethode equals(o) h´erit´ee d’ Object!!!

Allocation explicite ( new mais r´ecup´eration automatique (GC).

J1

Exceptions

36

Slide 49

 
Exceptions
Exceptions

Une exception est une rupture de calcul.

 

utilis´ee :

 
 

pour ´eviter les erreur de calcul

 

division par z´ero

acc`es `a la r´ef´erence null

ouverture dn fichier inexistant

 

.

.

.

 

comme style de programmation

 

En Java une exception est un objet

J1

Exceptions

37

Slide 50

Exceptions : Syntaxe
Exceptions : Syntaxe

pose d’un r´ecup´erateur :

instruction ::= try {instructions} catch (type variable) { instructions}

finally { instructions }

d´eclenchement :

throw ThrowableObject ;

indication d’´echappement d’une m´ethode “

throws ExceptionClass}

J1

Exceptions

38

Slide 51

Exemples d’exceptions
Exemples d’exceptions

class Exemple1 { public int division( int a, int b) { return (a / b);

}

}

class Exemple2 {

class Division par zero extends Exception {

}

private int division aux( int a, int b) throws Division par zero { if (b == 0) throw new Division par zero(); else return (a / b);

}

public int division( int a, int b)

J1

Exercices d’application

39

Slide 52

{

}

try { return division aux(a,b); } catch (Division par zero e) { return 0; } finally { ES.writeln( "on passe ici"); }

}

La clause finally est facultative. Son code est ex´ecut´e `a la sortie du try.

J1

Exercices d’application

40

Slide 53

Slide 54

Environnement : salle GLA
Environnement : salle GLA

Windows NT

Solaris (Unix S5)

SunOS (Unix BSD)

jdk 1.1.6 sur Windows NT et Solaris

SunOS utilis´e comme terminal X

Emacs sur toutes les machines

Premiers pas
Premiers pas

Connexion:

constituer 15 binˆomes

r´ecup´erer les login/mdt

effectuer le premier login

catalogue de travail: Cr´eer un catalogue de travail TP1 `a partir de votre HOMEDIR.

J1

Exercices d’application

41

Slide 55

Conventions
Conventions

Java distingue les minuscules et les majuscules

les noms des classes et des interfaces commencent par une majuscule

les noms de m´ethodes commencent par une minuscule

J1

Exercices d’application

42

Slide 56

3 types de commentaires
3 types de commentaires

double valeur = 3.45; // commentaire

/* un commentaire sur plusieurs lignes

*/

/**

un commentaire special pouvant etre traite par javadoc pour la construction de la documentation se place devant une classe une interface, une methode ou une variabel

*/

J1

Exercices d’application

43

Slide 57

}

}

Prise en main de l’´editeur
Prise en main de l’´editeur

Ecrire sous Emacs:

Dans le “buffer” scratch sauver le buffer sous le nom P1.java dans la catalogue TP1.

Ensuite ecrire le programme suivant :

class P1 { public static void main() { System.out.printl("Bonjour!!!");

et sauver le une fois ´ecrit.

J1

Exercices d’application

44

Slide 58

test de l’environnement
test de l’environnement

Ouvrir un shell: dans le menu d’Emacs Test du compilateur: aller dans la fenˆetre shell dans le catalogue TP1 et compiler le programe Java : javac P1.java

Test de l’ex´ecution: dans le shell ex´ecuter le programme P1.class :

java P1

Impression: : imprimer le

J1

Exercices d’application

45

Slide 59

Utilisation de ES
Utilisation de ES

Pour simplifier l’affichage et la lecture clavier en mode texte, on utilise les m´ethodes de classe de la classe ES du paquetage SJ.

En ´ecriture:

void ES.write(String s)

void ES.writeln(String s)

En lecture:

String ES.readln()

int ES.readln int()

En mode caract`ere:

char ES.readkey()

Hasard:

double ES.random()

J1

Exercices d’application

46

Slide 60

Slide 61

Chemin des classes
Chemin des classes

Pour v´erifier que vous atteignez bien la class ES, ajouter dans le programme pr´ec´edent l’affichage d’une chaˆııne de caract`eres.

1.

2.

Exercices
Exercices

c’est plus / c’est moins :

Dans ce jeu la machine peut soit chercher `a d´eterminer un nombre cach´e entr´e par l’utilisateur, soit r´epondre `a un utilisateur qui cherche un nombre.

Cet exercice est une mise en route pour s’habituer `a la synta xe Java.

liste d’associations : une liste d’association est une li ste de couples (cl´e,valeur) permettant de rechercher une valeur `a partir de sa cl´e.

J1

Exercices d’application

47

Exercices

C+/C-

On d´efinit une classe arbitre qui poss`ede une variable enti`ere et les m´ethodes suivantes : void nouveau() : qui choisit un nouveau nombre, String verif(int a) qui retourne une chaine selon le nombre propos´e.

Le programme principal sera constitu´e d’une boucle demandant un nom- bre `a l’utilisateur, et demandant `a une instance d’Arbitre de v´erifi´e ce nom- bre. Selon le retour, le programme repart dans la boucle ou en sort.

Liste d’association

On cherche `a d´efinir des listes d’associations (ensemble de (cl´e,valeur)) per- mettant la recherche d’une valeur par sa cl´e.

1. Ecrire une classe CoupleIC pour la construction de couples compos´es d’un entier et d’une chaine.

2. Ecrire une classe ListeAssoc contenant les m´ethodes : ajoute(couple) qui ajoute un couple `a la liste, recherche(c) qui retourne la valeur associ´ee `a la cl´e si elle existe et sinon d´eclenche une ex ception, et une m´ethode enleve(c) qui retire l’association de la liste.

On repr´esentera la liste par un tableau 1 et un indice.

3. Tester ces classes `a partir d’un programme principal

4. Ecrire une classe ListeAssocOpt qui h´erite de la premi`ere, en ajoutant un champs indiquant qu’elle peut ˆetre optimis´ee, une m´ethode optimise qui effectue le travail (trie le tableau) permettant ensuite une recherche rapide (dichotomique) en modifiant en cons´equence la recherche.

5. Tester cette nouvelle classe.

6. Ecrire une classe, sous classe de ListeAssocPOpt, qui optimise toujours l’acc`es.

7. Tester cette nouvelle classe.

1 Dans le cas d’une liste chaˆıın´ee comment repr´esente-t-on la liste vide?

J1

Exercices d’application

48

Slide 62

Application : jeu de la vie
Application : jeu de la vie

Le jeu de la vie est une simulation d’automates cellulaires.

Le monde est repr´esent´e par un ensemble de cellules. Chaque cellule a 8 voisins (monde torique type chambre `a air).

Les r`egles de vie sont les suivantes :

une cellule meurt si elle a moins de 2 voisins (isolement) ou plus de 3 (surpopulation).

une cellule nait sur une case vide si celle-ci a exactement 3 voisins.

Jeu de la vie

1. Ecrire une classe Cell contenant un champs bool´een et une m´ethode est vivante qui retourne son ´etat.

2. Ecrire la classe Monde contenant l’ensemble des cellules sous la forme dn tableau de cellules `a deux dimensions.

Cette classe contiendra 2 types de remplissage : un al´eatoi re et un deuxi`eme manuel. Les autres m´ethodes seront void affiche() pour l’affichage en mode texte, Cell get cell(x,y), void set cell(x,y,c), int voisins(x,y), void gen suiv pour le calcul de la g´en´eration suivante.

3. Enfin la classe JDLV sera le point d’entr´e du programme.

J1

Exercices d’application

49

/ ∗∗ @author Emmanuel Chailloux @organization Universite Pierre et Marie Curie @version 1.0

/

/ ∗∗ representation du monde des cellules contient la taille du monde un tableau de cellules correspondant le numero de la generation

/

class Monde {

int maxx, maxy; Cell m[][]; int num=1;

/ ∗∗ constructeur sans parametre : construit un monde de taille 20x8

/

Monde() { maxx = 20; maxy = 8; m=new Cell[maxx][maxy]; monde vide();

}

/ ∗∗ constructeur avec taille : construit le monde de cette taille

/

Monde( int x, int y) { maxx=x; maxy=y; m = new Cell[maxx][maxy]; monde vide();

}

/ ∗∗ alloue chaque cellule du monde

/

J1

Exercices d’application

50

void monde vide() { for ( int i=0; i <maxx; i++) { for ( int j=0; j<maxy; j++) { m[i][j]=new Cell();

}

}

}

/ ∗∗ remplissage aleatoire du monde favorise les cases vides (80 %)

/

void init alea() { for ( int i=0; i <maxx; i++) { for ( int j=0; j<maxy; j++) { if (ES.random() > 0.8) set cell(i,j, new Cell( true ));

}

}

}

/ ∗∗ remplissage manuel du monde on indique seulement les cellules vivantes en donnat leurs coordonnees pour sortir on indique des coordonnees inexistantes

/

void init man() { int x,y; while ( true ) { ES.writeln( "Entrer les coordonnees de la case (sur 2 lignes) "); ES.writeln( "ou des coordonnees en dehors du monde pour sortir"); x=ES.readln int(); y=ES.readln int(); if ((x 0)&&(x <maxx)&&(y 0)&&(y <maxy)) { set cell(x,y, new Cell( true )); } else { break; }

}

}

/ ∗∗ change le contenu d’une cellule du monde

/

void set cell( int x, int y, Cell c) {

J1

Exercices d’application

51

m[x][y]=c;

}

/ ∗∗ demande le contenu d’une cellule du monde

/

Cell get cell( int x, int y) { return m[x][y];

}

/ ∗∗ retourne le tableau de cellules du monde

/

Cell [][] get cells() { return m; }

/ ∗∗ calcule le nombre de voissins d’une cellule on suppose que le monde est un tore (chambre a air) on calcule le nombre de cellules vivantes dans un carre 3x3, puis on soustrait si la case centrale etait vivante.

/

int voisins( int x, int y) { int r=0; for ( int i = x-1;i x+1;i++) { int k = (i+maxx) % maxx; for ( int j = y-1;jy+1;j++) { int l = (j+maxy) % maxy; if (m[k][l].est vivante()) r++;

}

}

if (m[x][y].est vivante()) r--;

return r;

}

/ ∗∗ calcul de la generation suivante pour chaque cellule on calcule le nombre de voisins puis on applique les regles de vie et de mort de la simulation

/

void gen suiv() { Monde m2 = new Monde(maxx,maxy);

J1

Exercices d’application

52

// toutes les cellules sont vides

for ( int i=0;i <maxx;i++) { for ( int j=0; j<maxy; j++) { int n = voisins(i,j); if (m[i][j].est vivante()) { if ((n== 2) || (n==3)) { m2.set cell(i,j, new Cell( true )); }

}

else { if (n==3) { m2.set cell(i,j, new Cell( true )); }

}

}

}

m=m2.get cells(); num++;

}

/ ∗∗ affiche la generation i

/

void affiche() { for ( int j=0; j<maxy; j++) { for ( int i=0; i <maxx; i++) { if (m[i][j].est vivante()) ES.write( ""); else ES.write( ". ");

}

ES.writeln();

}

ES.writeln( "Generation "+num);

}

}

/ ∗∗ classe minimale pour les cellules

/

class Cell {

boolean val;

J1

Exercices d’application

53

Cell() { val=false ; } Cell ( boolean b) { val = b; }

boolean est vivante() { return val; }

}

/ ∗∗ classe de l’application JDLV

/

class JDLV {

/ ∗∗ initialisation du monde :

taille et type de remplissage toute la partie initialisation du monde est dans la methode i nit

/

/ ∗∗

determine la taille du monde et le type de remplissage

/

public static Monde init() { String s;

Monde m;

ES.write( "Voulez-vous donner la taille du monde? (O/N)"); s=ES.readln(); ES.writeln(); if (!(s.equals( "O"))) { m = new Monde(30,10); } else { int x,y; ES.write( "largeur : "); x=ES.readln int(); ES.write( "hauteur : "); y=ES.readln int(); m = new Monde(x,y);

}

do { ES.writeln( "Appuyer sur la touche <A> pour un remplissage

J1

Exercices d’application

54

aleatoire"); ES.writeln( " ou <M> manuel"); s=ES.readln(); } while ((!(s.equals( "A"))) && (!(s.equals( "M"))));

}

if (s.equals( "A")) m.init alea(); else m.init man(); return m;

/ ∗∗ boucle sans fin d’attente d’evenements sortie en appuyant sur F (break)

/

public static void boucle(Monde m) { String s;

ES.writeln( "Appuyer sur la touche <F> pour sortir du programme"); ES.writeln( " ou sur une autre touche pour continuer");

}

while ( true ) { m.affiche(); s=ES.readln(); if (s.equals( "F")) break; else m.gen suiv();

}

/ ∗∗ derniere methode appelee avant la sortie

/

public static void fin() {

ES.writeln( "\ n

}

A bientot \ n");

/ ∗∗ point d’entree de l’application

/

public static void main(String args[]) { Monde m; m=init(); boucle(m); fin();

J1

Exercices d’application

55

}

}

J2

Interfaces

56

Slide 63

Slide 64

Plan du 2`eme jour
Plan du 2`eme jour

Interfaces

sous-typage et polymorphisme

paquetages

modifieurs

biblioth`eque standard

Interfaces
Interfaces

[ public ] interface l_intf [ extends [ a_intf]+ ] { declarations

}

Une interface d´eclare un protocole de communication. Les d´eclarations peuvent mentionner des m´ethodes et des constantes.

Les interfaces sont souvent nomm´ees par des adjectifs.

J2

Polymorphisme

57

Slide 65

Slide 66

Implantation d’interfaces
Implantation d’interfaces

[public] class la_classe [extends superclasse] [implements [l_intf]+] {

}

Une classe peut implanter une ou plusieurs interfaces. Elle est alors conforme au protocole d´ecrit dans l’interface.

Int´erˆets:

:

permet d’ˆetre vu de diff´erentes mani`eres

ne n´ecessite pas d’h´eriter

simule de l’h´eritage multiple (sans code)

1.

2.

3.

4.

Types des variables
Types des variables

les types de base

les noms de classe

les noms d’interface

les types tableaux

J2

Polymorphisme

58

Slide 67

Slide 68

Sous-type
Sous-type

ST T : ST est sous-type de T :

une valeur ST peut toujours ˆetre utilis´ee `a la place d’une valeur T !

En Java : une sous-classe est un sous-type En effet une instance d’une sous-classe saura toujours r´epo ndre aux messages que peuvent recevoir les instances de la classe ancˆetre.

De mˆeme une sous-interface est un sous-type!

Conversion implicite
Conversion implicite

pour le passage d’arguments (et l’affectation) :

C x = new C();

SC y = new SC(); // SC sous-classe de C

x = y;

Pas de probl`eme `a l’ex´ecution, le nouvel x saura r´epondre `a tous les messages de C.

// OK

J2

Polymorphisme

59

Slide 69

Slide 70

Conversion explicite
Conversion explicite

est utilis´ee quand la relation de sous-typage n’est pas v´erifi´ee :

SC z = (SC) x;

un test dynamique (`a l’ex´ecution) est alors effectu´e.

Utile: car il n’y a pas de polymorphisme param´etrique en Java!

sous-type, surcharge et red´efinition
sous-type, surcharge et red´efinition

Java ´evite les probl`emes de typage des m´ethodes en diff´er enciant red´efinition et surcharge y compris si les types des param`etres ou le type du r´esultat est un sous-type.

Simplification: quelques fois gˆenante, car cela force a‘ coercer le type dans le programme.

J2

Polymorphisme

60

Slide 71

Exemple
Exemple

class TestC {

public static void main(String args[])

{

PointColore p0 = new PointColore(); Point p1 = new PointColore(3,4, "bleu");

p0.affiche(); p1.affiche();

p0.rmoveto(7,12);

p1.rmoveto(5,6);

p0.affiche(); p1.affiche(); if (p0.distance() == p1.distance()) ES.writeln( "c’est le hasard"); else ES.writeln( "on pouvait parier");

}

}

J2

Paquetages

61

Slide 72

Slide 73

Polymorphisme
Polymorphisme

R´eutilisation du mˆeme nom sur des types diff´erents.

param´etrique (`a la Caml) : mˆeme code pour n’importe quel param`etre;

ad hoc (surcharge) : code diff´erent selon le type des param`etres;

d’inclusion (ou d’h´eritage) : code diff´erent selon les sous-types.

En Java polymorphisme ad hoc et d’inclusion (sous-cas plus fin du premier).

Paquetage
Paquetage

Regroupement de classes et d’interfaces dans un archivage hi´erarchique ( .class).

D´eclaration:

La d´eclaration d’un paquetage est la premi`ere instruction d’un programme.

package nom[.nom]* ;

utilisation:

import nomqualifie; nomqualifie.*;

autorise les r´ef´erences abr´eg´ees.

collisions interdites.

J2

Modifieurs

62

Slide 74

Slide 75

Paquetage (suite)
Paquetage (suite)

Sans rien pr´eciser dans son programme, celui-ci est consid´er´e faisant partie du “paquetage anonyme”.

La hierarchie des paquetages suit la hi´erarchie des catalo gues du syst`eme.

L’appartenance `a un paquetage modifie les r`egles de visibi lit´e.

Modifieurs g´en´eraux abstract final doit ˆetre sous-class´ee C ne peut ˆetre sous-class´ee doit avoir une
Modifieurs g´en´eraux
abstract
final
doit ˆetre sous-class´ee
C ne peut ˆetre sous-class´ee
doit avoir une implantation M ne peut ˆetre raffin´ee
V ne peut ˆetre modifi´ee
et toujours static :
M et V : m´ethode ou variable de classe.
(pas de this dans ces m´ethodes)

J2

Modifieurs

63

Slide 76

Slide 77

Classe abstraite : un exemple
Classe abstraite : un exemple

Listes:

abstract class List { // classe abstraite racine // de l’arbre d’heritage abstract boolean empty() ; abstract int head() throws EmptyList; abstract List tail() throws EmptyList; abstract List cons(int x); abstract void display();

}

class EmptyList extends Exception {}

classes concr`etes : Nil
classes concr`etes : Nil

class Nil extends List { static List NIL = null; boolean empty(){return true;} List cons(int x){return new Cons(x,this);} int head()throws EmptyList {throw new EmptyList();} List tail()throws EmptyList{throw new EmptyList();} void display(){System.out.print("[]");}

}

\end{slide}

\begin{slide}

\heading{Classes concr\‘etes : Cons} \begin{verbatim}

class Cons extends List {

J2

Modifieurs

64

Slide 78

Slide 79

 

int car; List cdr;

Cons(){car=0;cdr=Nil.NIL;}

Cons(int a, List b){car=a;cdr=b;}

}

boolean empty(){return false;} List cons(int x) {return new Cons(x,this);} int head(){return car;} List tail(){return cdr;} void display(){System.out.print(car + "::"); cdr.display();}

 
final
final

static final pour une variable en fait une constante!!!

 

final empˆeche de raffiner une m´ethode

final d’une classe empˆeche le sous-classement.

J2

Modifieurs

65

Slide 80

 
Modifieurs de visibilit´e
Modifieurs de visibilit´e
 

C

M

public

C protected V

 

V

 

C

M default

V

 

M

private

M private

V

protected

V

J2

Modifieurs

66

Slide 81

Visibilit´e
Visibilit´e

// P.A.ja package P; public class A { int i;

}

// Q.D.java

package Q; import P.*; class D {

}

// P/B.java

package P;

class B extends A {

}

// Q/E.java

package Q;

import P.*;

class E extends A {

}

// P/C.java package P; class C {

}

J2

Biblioth`eque standard

67

Slide 82

Slide 83

Repr´esentation graphique
Repr´esentation graphique
D C A B E
D
C
A
B
E

P

Q

Biblioth`eque standard
Biblioth`eque standard

J2

Exercices d’application

68

Slide 84

Que fait ce programme?
Que fait ce programme?

}

this.M1()

}

// classe C int M1() { String M2() {

// Sous-classe SC de C int M1() { autre code}

main

{

C x = new C();

SC y = new SC();

C z = y;

x.M1();

x.M2();

y.M1();

y.M2();

z.M1();

z.M2();

En particulier quelles sont les m´ethodes

d´eclench´ees? Vous pouvez ´ecrire un programme

correspondant `a ce squelette.

J2

Exercices d’application

69

Slide 85

Que fait ce programme?
Que fait ce programme?

}

// class C { int M(C c) {

// sous classe SC de C

int M (C c) { int M (SC c) {

void main

{

}

}

C x = new SC(); SC y = (SC) x; y.M(y) + y.M(x) + x.M(x) // + x.M(y)

En particulier quelles sont les m´ethodes d´eclench´ees? Vous pouvez ´ecrire un programme correspondant `a ce squelette avec des affichages. Que se passe-t-il si on d´ecommente la derni`ere ligne?

J2

Exercices d’application

70

Slide 86

Slide 87

1.

2.

Interface
Interface

D´efinir une interface pour les listes d’association. On p ourra d´efinir des interfaces pour les “cl´es” et les “valeurs” ou p our les couples “cl´e”,”valeur”

D´efinir des classes conformes aux interfaces pr´ec´edentes. On utilisera des listes chaˆın´ees.

Classe abstraite
Classe abstraite

On cherche `a ´etendre les fonctionnalit´es de la classe ExpAr vue en cours.

1.

2.

Ajouter une classe Div

Ecrire une classe Lecteur qui fasse l’analyse syntaxique d’une chaine pour en construire un ExpAr. On prendra des formules sous forme pr´efixe. Les constantes, comme les op´erateurs, ne prendront qu’un caract`ere.

J2

Exercices d’application

71

Calculateur de Bureau

Soit le d´ebut de la hi´erarchie suivante :

class Div0 extends Exception {}

abstract class ExpAr { // classe abstraite racine de l’arbre d’heritage abstract int eval () throws Div0; abstract String scp () ;

}

class Cte extends ExpAr { int val ;

// premiere sous-classe concrete

Cte ( int v) { val = v ; } int eval () { return val ; } String scp () { return ( new Integer(val)).toString() ; }

}

abstract class Bin extends ExpAr { ExpAr og, od ; abstract int oper ( int g , int d) throws Div0; abstract String cop () ;

int eval () throws Div0 { return oper (og.eval(), od.eval()) ; } String scp () { return ( "("+ og.scp() + cop() + od.scp() +")") ; } void init (ExpAr g, ExpAr d) { og = g ; od = d ; }

}

class Add extends Bin { Add (ExpAr g, ExpAr d) { init (g, d) ; } int oper ( int g, int d) { return (g+d) ; } String cop () { return ( "+") ; }

}

class Mult extends Bin { Mult (ExpAr g, ExpAr d) { init (g, d) ; } int oper ( int g, int d) { return (g d) ; } String cop () { return ( "") ; }

}

J2

Exercices d’application

72

Slide 88

Coercion de type
Coercion de type

Ecrire une classe implantant l’interface suivante :

public interface Stack { public int size(); public boolean isEmpty(); public void push(Object e); public Object pop() throws StackEmptyException;

}

Piles d’Objets

On suppose la d´efinition suivante de l’exception :

public class StackEmptyException extends Exception {

}

Ecrire un programme principal manipulant une pile d’entiers et une pile de caract`eres.

J2

Exercices d’application

73

Slide 89

Slide 90

paquetage
paquetage

Faire un paquetage des diff´erents interfaces, classes pour utiliser les piles pr´ec´edentes.

Ressources
Ressources

Explorez la hi´erarchie de classes de la biblioth`eque initiale.

Surfez sur le tutorial de Sun.

Ces ressources existent en local sur les machines du GLA.

J2

Exercices d’application

74

Slide 91

Slide 92

1.

2.

3.

4.

5.

Application : V´erificateur de formules
Application : V´erificateur de formules

Dans la mˆeme veine que le calculateur d’expressions arithm´etique, on se propose d’´ecrire un calculateurs d’expressions bool´eennes dans le but de v´erifier si une formule est toujours vraie.

Ecrire la hi´erarchie de classes pour les ExprBool

Ajouter une classe var pour les variables.

Pour accepter les variables, une possibilit´e est de passer un environnement comme param`etre d’ eval. Effectuer ces modifications. Regarder si vous pouvez le faire , soit direct ement, soit en d´erivant et en implantant une interface plus pr´ecise.

D´efinir une classe Formule, qui contiendra la formule et l’environnement contenant toutes les variables associ´ees `a une valeur. Ecrire la m´ethode env suivant qui calule une nouvelle

s´erie de valeurs pour les variables de la formule.

Ecrire une m´ethode qui calcule toutes les valeurs possibles des variables d’une formule pour construire sa table de v´erit´e.

J3

Processus L´egers

75

Slide 93

Slide 94

Plan du 3`eme jour
Plan du 3`eme jour

Processus l´egers

Interface graphique : AWT

Classes locales

Applet

Processus l´egers (Thread)
Processus l´egers (Thread)

Mod`ele de parall´elisme `a m´emoire partag´ee

contexte d’ex´ecution sur une mˆeme machine virtuelle

mˆeme zone m´emoire ( = fork)

ne d´epend pas du syst`eme (Windows 3.1)

poss`ede un nom et une priorit´e

pas de pr´eemption `a priorit´e ´egale le faire `a la main