Bases Java - Eclipse / Netbeans Environnements Java 1

Institut Galil´ee PDJ
Master 1
T.P. 1
Bases Java - Eclipse / Netbeans
Environnements Java
Il existe plusieurs environnements Java. Il est ESSENTIEL d’utiliser la “bonne” version, et un
environnement d’ex´ecution identique `a la version de compilation (principalement en cas de chargement
de librairies `a chaud). Le syst`eme que vous avez `a l’Institut Galil´ee a l’environnement java suivant :
— java 1.8.0 111 (/usr/bin/java) : c’est la version SUN/Oracle Java SE.
Il existe aussi une version GNU open source pr´esente par d´efaut sur certains syst`emes. Elle a l’in-
conv´enient majeure de pr´esenter de nombreux probl`emes de compatibilit´e avec le java standard de
Sun.
Terminologie et versions
— Java SE (Standard Edition) : noyau des API (lang, collections, ..., jar, ...) sans machine virtuelle.
— JRE (Java Runtime Environment) : JSE + machine virtuelle + plugin.
— JDK (Java Development Toolkit) : JRE + logiciels d’utilisation (java, javac, jar, ...).
1 Environnement Eclipse
Eclipse est un environnement de d´eveloppement int´egr´e (IDE) libre, extensible et polyvalent, per-
mettant potentiellement de cr´eer des projets de d´eveloppement pour tout langage de programmation.
Eclipse est principalement ´ecrit en Java (`a l’aide de la biblioth`eque graphique SWT, d’IBM), et ce
langage, grˆace `a des biblioth`eques sp´ecifiques, est ´egalement utilis´e pour ´ecrire des extensions. La
sp´ecificit´e d’Eclipse IDE vient du fait de son architecture totalement d´evelopp´ee autour de la notion
de plug-in (en conformit´e avec la norme OSGi) : toutes les fonctionnalit´es de cet atelier logiciel sont
d´evelopp´ees en tant que plug-in. Plusieurs logiciels commerciaux sont bas´es sur ce logiciel libre, comme
par exemple IBM Lotus Notes 8, IBM Symphony ou WebSphere Studio Application Developer.
T´el´echargements, plugins, tutoriaux : www.eclipse.org
1.1 Initialisation
Modifier votre fichier .bashrc afin qu’Eclipse soit accessible. Pour cela, v´erifiez que vous avez
/LOCAL/eclipse/jee-mars dans votre variable d’environnement $PATH.
Remarque : c’est la version ‘mars’ de Eclipse qui est lanc´ee (version 4.5.1).
1.2 Projet
Cr´eation d’un projet File -> New -> Java Project
Project Name : mettre Thread Share
Une sous-fenˆetre Project Explorer vous permet de parcourir les projets et sources cr´e´es. Si la
sous-fenˆetre n’est pas visible, utiliser Window -> Show view -> Project Explorer.
Acc`es aux fichiers Un Workspace contient l’ensemble des projets cr´e´es. Le workspace est un
r´epertoire dans votre environnement de travail, il est d´efini au premier lancement de Eclipse. Vous
pouvez retrouver le nom du r´epertoire par File -> Switch Workspace. Chaque projet est un sous-
r´epertoire contenant un sous-r´epertoire bin pour les ex´ecutables, et un sous-r´epertoire src pour les
sources.
Cr´eation de sources, ex´ecution S´electionner Thread Share/src dans le Project Explorer, puis
bouton droit et New -> Class. Entrer le nom de la classe TestRunnable, cocher main (puisque cette
classe contient la m´ethode main). Puis entrer le code, sauvegarder.
Ex´ecution par Run. Une fenˆetre Console vous donne l’affichage.
1

2 Environnement Netbeans
NetBeans est aussi un environnement de d´eveloppement int´egr´e (IDE) pour Java, plac´e en open
source par Sun. En plus de Java, NetBeans permet ´egalement de supporter diff´erents autres langages,
comme Python, C, C++, XML et HTML. Il comprend toutes les caract´eristiques d’un IDE moderne
(´editeur en couleur, projets multi-langage, refactoring, ´editeur graphique d’interfaces et de pages web).
Il permet en outre :
— de cr´eer et d´eployer des environnements complets web + java
— d’int´egrer la machinerie des beans java (annotations adapt´ees)
— de supporter en plugin des bases de donn´ees (GlassFish en Open Source)
— de contrˆoler le d´eploiement sur un ensemble de machines
2.1 Initialisation
Modifier votre fichier .bashrc afin qu’Eclipse soit accessible. Pour cela, v´erifiez que vous avez
/LOCAL/netbeans/bin dans votre variable d’environnement $PATH.
Remarque : c’est la version 8.0.2 qui est lanc´ee (/LOCAL/netbeans/bin/netbeans).
2.2 Projet et Groupe
Les projets peuvent ˆetre organis´es en groupes. Un groupe est un ensemble de projets et est cr´eable
avec File->Project Groups -> New Group. Donner un nom : TP0.
Cr´eation d’un projet File -> New Project -> Java -> Java Application
Acc`es aux fichiers Un Workspace contient l’ensemble des projets cr´e´es. Le workspace est un
r´epertoire dans votre environnement de travail, il est d´efini au premier lancement de Netbeans. Vous
pouvez retrouver le nom du r´epertoire en regardant les propri´et´es (bouton droit, Properties) d’un
projet particulier.
3 Exercice : Classe et h´eritage
Dans tous les exercices de cette section, d´eterminez ce qui est affich´e par chacun des programmes
donn´es, puis testez vos r´eponses en les implantant.
3.1 Valeurs et r´ef´erences, surcharge
class A{
private int v a l =0;
publi c s t a t i c void affichePlus (int a ) {
a++;
System . out . p r i n t l n ( a ) ;
}
publi c s t a t i c void affichePlus (A a) {
a . v a l ++;
System . out . p r i n t l n ( a . v al ) ;
}
publi c s t a t i c void main ( S t r i n g [ ] a r gs ) {
A unObj = new A ( ) ;
A unAutreObj = new A( ) ;
a f f i c h e P l u s ( unObj . v al ) ;
a f f i c h e P l u s ( unObj . v al ) ;
a f f i c h e P l u s ( unObj ) ;
a f f i c h e P l u s ( unObj ) ;
a f f i c h e P l u s ( unAutreObj ) ;
a f f i c h e P l u s ( unAutreObj ) ;
i f ( unObj == unAutreObj )
System . out . p r i n t l n ( ” Ega le s ” ) ;
2

else
System . out . p r i n t l n ( ” D i f f e r e n t e s ” ) ;
}
}
3.2 Liaison dynamique
class A{
public S t r i n g f (B o bj ) {return ( ”A e t B” ) ; }
public S t r i n g f (A o bj ) {return ( ”A e t A” ) ; }
}
class Bextends A{
public S t r i n g f (B o bj ) {return ( ”B e t B” ) ; }
public S t r i n g f (A o bj ) {return ( ”B e t A” ) ; }
}
class test {
publi c s t a t i c void main ( S t r i n g [ ] ar g s ){
A a1 = new A ( ) ;
A a2 = new B ( ) ;
B b = new B ( ) ;
System . out . p r i n t l n ( a1 . f ( a1 ) ) ;
System . out . p r i n t l n ( a1 . f ( a2 ) ) ;
System . out . p r i n t l n ( a2 . f ( a1 ) ) ;
System . out . p r i n t l n ( a2 . f ( a2 ) ) ;
System . out . p r i n t l n ( a2 . f ( b ) ) ;
System . out . p r i n t l n ( b . f ( a2 ) ) ;
}
}
3.3 Polymorphisme
class A{
public S t r i n g f (D ob j ) {return ( ”A e t D” ) ; }
public S t r i n g f (A o bj ) {return ( ”A e t A” ) ; }
}
class Bextends A{
public S t r i n g f (B o bj ) {return ( ”B e t B” ) ; }
public S t r i n g f (A o bj ) {return ( ”B e t A” ) ; }
}
class Cextends B{
}
class Dextends B{
}
class test {
publi c s t a t i c void main ( S t r i n g [ ] ar g s ){
A a1 = new A ( ) ;
A a2 = new B ( ) ;
B b = new B ( ) ;
C c = new C ( ) ;
D d = new D ( ) ;
System . out . p r i n t l n ( a1 . f ( b ) ) ;
System . out . p r i n t l n ( a1 . f ( c ) ) ;
System . out . p r i n t l n ( a1 . f ( d ) ) ;
System . out . p r i n t l n ( a2 . f ( b ) ) ;
System . out . p r i n t l n ( a2 . f ( c ) ) ;
System . out . p r i n t l n ( a2 . f ( d ) ) ;
System . out . p r i n t l n ( b . f ( b ) ) ;
3

System . out . p r i n t l n ( b . f ( c ) ) ;
System . out . p r i n t l n ( b . f ( d ) ) ;
}
}
3.4 Champs de classe
class A{
int i ;
int f ( ) {return i ; }
static S t r i n g g ( ) {return ( ”A” ) ; }
S t r i n g h ( ) {return g ( ) ; }
}
class Bextends A{
int i =2;
int f ( ) {return −i ; }
static S t r i n g g ( ) {return ( ”B” ) ; }
S t r i n g h ( ) {return g ( ) ; }
}
class test {
publi c s t a t i c void main ( S t r i n g [ ] a r gs ) {
B b = new B ( ) ;
System . out . p r i n t l n ( b . i ) ;
System . out . p r i n t l n ( b . f ( ) ) ;
System . out . p r i n t l n ( b . g ( ) ) ;
System . out . p r i n t l n ( b . h ( ) ) ;
A a = b ;
System . out . p r i n t l n ( a . i ) ;
System . out . p r i n t l n ( a . f ( ) ) ;
System . out . p r i n t l n ( a . g ( ) ) ;
System . out . p r i n t l n ( a . h ( ) ) ;
}
}
4 Application : Les robots pollueurs
On consid`ere que le monde est constitu´e d’une matrice de cases. Diff´erents types de robots agissent
dans ce monde : des robots pollueurs et des robots nettoyeurs.
— Les robots pollueurs se baladent dans le monde et d´eposent des papiers gras sur les cases o`u ils
se trouvent. Les robots nettoyeurs, quant `a eux, ne supportent pas la vue d’un papier gras et
l’enl`event d`es qu’ils en voient un sur une case. Les robots pollueurs sont de deux sortes : robots
sauteurs et robots qui vont tout droit. Chaque robot pollueur suit son parcours et d´epose un
papier gras sur chaque case rencontr´ee. Le parcours pr´ecis des robots pollueurs sera donn´e dans
la suite.
— Les robots nettoyeurs parcourent m´ethodiquement le monde en ”boustroph´edon”, c’est-`a-dire
qu’ils parcourent la premi`ere ligne case par case, puis arriv´e en bout de ligne font demi-tour,
parcourent la deuxi`eme ligne en sens inverse, et ainsi de suite jusqu’`a la derni`ere case de la
derni`ere ligne. Ils enl`event, s’il s’en trouve un, le papier gras de la case o`u ils se trouvent. Parmi
les robots nettoyeurs, certains sont distraits et n’enl`event qu’un papier sur deux.
1. Ecrire la classe Monde qui contient les variables d’instance, les constructeurs et les m´ethodes
suivantes (d´efinir si elles sont d’instance ou de classe) :
— Le nombre de lignes nbL, le nombre de colonnes nbC, et une matrice bool´eenne mat de nbL
lignes et nbC colonnes (true signifiant la pr´esence d’un papier gras).
— Un constructeur avec param`etres et un sans param`etres Monde() : ce constructeur par d´efaut
cr´ee un monde 10*10 sans papiers gras.
—public String toString() : retourne une chaine de caract`eres d´ecrivant le monde. On
repr´esentera un papier gras par le caract`ere ”o”, rien par le caract`ere ”.”(point).
—metPapierGras(int i,int j) : met un papier gras dans la case (i , j ).
—prendPapierGras(int i,int j) : enl`eve le papier gras de la case ( i , j).
4

—estSale(int i , int j) : teste si la case ( i , j) a un papier gras.
—nbPapiersGras() : qui rend le nombre de papier gras dans le monde.
2. Ecrire dans une classe TestRobot avec une m´ethode main et y cr´eer un Monde de 10 lignes et
10 colonnes. Y tester les m´ethodes metPapierGras,prendPapierGras et estSale.
3. Ecrire la classe Robot qui est abstraite car elle n’aura aucune instance, et qui contient les
champs et m´ethodes suivantes :
—posx, posy : position du robot sur le monde.
—m: variable de type Monde. En effet, il faut que le robot connaisse le monde pour pouvoir
s’y d´eplacer et agir.
— deux constructeurs : Robot(int x,int y,Monde m) qui cr´ee un robot `a la position (x,y)
et Robot(Monde m) qui cr´ee un robot avec une position al´eatoire. Le constructeur
Robot(Monde m) doit appeler l’autre constructeur.
—vaEn(int i, int j) : se d´eplace en (i, j).
—parcourir() : m´ethode abstraite qui sera d´efinie dans les sous-classes.
4. Ecrire la classe RobotPollueur (´egalement abstraite car elle n’aura pas d’instance) qui contient
la m´ethode :
—polluer () : met un papier gras l`a o`u ce robot se trouve dans le monde.
5. Ecrire la classe PollueurToutDroit qui contient les champs et m´ethodes suivantes :
—colDepart, num´ero de la colonne o`u il va se rendre pour commencer sa mission.
— constructeur(s).
—parcourir() : cette m´ethode d´efinit la m´ethode parcourir abstraite de la classe Robot. Elle
d´ecrit un parcours de ce robot dans le monde. Le robot se positionne d’abord dans sa
colonne de d´epart en case (0, ColDepart), puis il va tout droit vers le sud en visitant chaque
case de la colonne et d´epose un papier gras sur chacune d’elle. Il s’arrˆete dans la derni`ere
case de la colonne.
6. Ecrire la classe PollueurSauteur, avec les champs et m´ethodes suivants :
—deltax repr´esentant la taille du saut e ?ectu´e `a chaque d´eplacement du sauteur.
— constructeurs.
—parcourir() : cette m´ethode d´efinit la m´ethode parcourir abstraite de la classe Robot. Elle
d´ecrit un parcours de ce robot dans le monde. Le robot se positionne d’abord dans sa
colonne de d´epart en case (0, 0), puis il saute de fa¸con analogue au cavalier des Echecs
et va en (1, deltax), puis en (2, 2* deltax), puis en (3, 3*deltax), etc. Si la colonne sort
de l’´echiquier, on revient au d´ebut. Par exemple, la colonne nbC, qui n’existe pas, sera
transform´ee en nbC modulo nbC, i.e, colonne 0. Chaque case rencontr´ee est souill´ee d’un
papier gras. Le robot s’arrˆete lorsqu’il atteint la derni`ere ligne.
7. Ecrire la classe RobotNettoyeur, qui contient les m´ethodes suivantes :
—nettoyer() : enl`eve le papier gras de la case o`u se trouve ce robot.
— constructeurs,
—parcourir() : cette m´ethode d´efinit la m´ethode parcourir abstraite de la classe Robot. Elle
d´ecrit un parcours complet de ce robot dans le monde. Il part de la case (0, 0) et parcourt
le monde en ”boustroph´edon”. Si la case est sale, il enl`eve le papier gras qui s’y trouve.
8. Ecrire la classe NettoyeurDistrait qui contient les m´ethodes suivantes :
— constructeurs.
—parcourir() : cette m´ethode red´efinit la m´ethode parcourir(). Elle d´ecrit un parcours complet
de ce robot dans le monde. C’est le mˆeme parcours que celui des robots nettoyeurs mais
comme il est distrait, il n’enl`eve qu’un papier sur deux.
9. Ecrire dans une classse TestRobot avec une m´ethode main pour tester les classes d´efinies dans
les exercices pr´ec´edents.
5 Exceptions et lambda-expressions
1. D´efinir une classe Enseignant ayant 4 champs :
— String nom
— int age
— int salaire
5