Bases Java - Eclipse / Netbeans Environnements Java 1

Institut Galil´ee PDJ
Ann´ee 2014-2015 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 les environnements java suivants :
– java 1.6.0 33 GNU (IcedTea6 1.8.13) (/usr/bin/java) : c’est la version open source pr´esente
par d´efaut. Elle a l’inconv´enient majeure de pr´esenter de nombreux probl`emes de compatibilit´e
avec le java standard de Sun.
– java 1.6.0 33, jdk1.7.0 25, jdk-1.8 (/usr/java/jdk1.../bin/java) : versions 1.6, 1.7, 1.8 de
Sun/Oracle (donc propri´etaire mˆeme si les sources sont publiques).
Acc`es `a Java 1.7 Modifier votre fichier .bashrc afin que la version 1.7 de java soit accessible. Pour
cela, d´ecommenter dans votre fichier .bashrc la ligne
source /export/home/users/COMMUN/.jdkrc
Attention : ce changement ne prend effet qu’en lan¸cant un nouveau shell bash ou en effectuant la
commande
. ~/.bashrc
V´erifier que le “bon” java est accessible avec la commande javac -version
Acc`es `a Java 1.8 Modifier votre fichier .bashrc afin que la version 1.8 de java soit accessible. Pour
cela, mettre en fin de fichier .bashrc les lignes :
export JAVA HOME=/usr/java/jdk-1.8
export PATH=${JAVA HOME}/bin:$PATH
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 (c’est la version 3.4.1 contrairement
`a ce que le nom ci-dessous pourrait faire penser). Pour cela, d´ecommenter dans votre fichier .bashrc
la ligne
source /export/home/users/COMMUN/.eclipse-3.2rc
Attention : ce changement ne prend effet qu’en lan¸cant un nouveau shell bash ou en effectuant la
commande
. ~/.bashrc
1

Remarque : En fait, c’est la version ’indigo’ de Eclipse qui est lanc´ee (donc la 3.7 et pas la 3.2). Il
existe maintenant la version ’kepler’ (4.3) qui a fait suite `a la version ’juno’ (4.2).
1.2 Projet
Cr´eation d’un projet File -> New -> Java Project
Project Name : mettre Thread Share
V´erifier que le JRE (Java Runtime Environment) est jdk1.6.xx ou jdk1.7.xx. Si ce n’est pas le cas,
utiliser Configure JREs, puis s´electionner ou ajouter (via search si n´ecessaire).
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.
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 que Netbeans soit accessible. Pour cela, d´ecommenter dans
votre fichier .bashrc la ligne
source /export/home/users/COMMUN/.netbeansrc
dans votre .bashrc
Attention : ce changement ne prend effet qu’en lan¸cant un nouveau shell bash ou en effectuant la
commande
. ~/.bashrc
Remarque : c’est la version 6.7.1 qui sera lanc´ee, les versions 6.9.1, 7.1.1, 7.3, 8.0.1 sont aussi install´ees
(/usr/java/netbeans-x.x.x/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 Group -> New Group. Donner un nom : TP0.
Cr´eation d’un projet File -> New Project -> Java -> Java Application
2

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 ” ) ;
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 [ ] a rg 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.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 [ ] a rg 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 ) ) ;
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 rg s ) {
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 ( ) ) ;
4

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).
–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.
5