Bases Java - Eclipse / Netbeans Environnements Java 1

Institut Galilée
Année 2014-2015
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écution identique à la version de compilation (principalement en cas de chargement
de librairies à chaud). Le système que vous avez à l’Institut Galilée 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ésente
par défaut. Elle a l’inconvénient majeure de présenter de nombreux problèmes de compatibilité
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étaire même si les sources sont publiques).
Accès à Java 1.7 Modifier votre fichier .bashrc afin que la version 1.7 de java soit accessible. Pour
cela, décommenter dans votre fichier .bashrc la ligne
source /export/home/users/COMMUN/.jdkrc
Attention : ce changement ne prend effet qu’en lançant un nouveau shell bash ou en effectuant la
commande
. ~/.bashrc
Vérifier que le “bon” java est accessible avec la commande javac -version
Accès à 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éveloppement intégré (IDE) libre, extensible et polyvalent, permettant potentiellement de créer des projets de développement pour tout langage de programmation.
Eclipse est principalement écrit en Java (à l’aide de la bibliothèque graphique SWT, d’IBM), et ce
langage, grâce à des bibliothèques spécifiques, est également utilisé pour écrire des extensions. La
spécificité d’Eclipse IDE vient du fait de son architecture totalement développée autour de la notion
de plug-in (en conformité avec la norme OSGi) : toutes les fonctionnalités de cet atelier logiciel sont
développées en tant que plug-in. Plusieurs logiciels commerciaux sont basés sur ce logiciel libre, comme
par exemple IBM Lotus Notes 8, IBM Symphony ou WebSphere Studio Application Developer.
Téléchargements, 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
à ce que le nom ci-dessous pourrait faire penser). Pour cela, décommenter dans votre fichier .bashrc
la ligne
source /export/home/users/COMMUN/.eclipse-3.2rc
Attention : ce changement ne prend effet qu’en lançant un nouveau shell bash ou en effectuant la
commande
. ~/.bashrc
1
Remarque : En fait, c’est la version ’indigo’ de Eclipse qui est lancée (donc la 3.7 et pas la 3.2). Il
existe maintenant la version ’kepler’ (4.3) qui a fait suite à la version ’juno’ (4.2).
1.2
Projet
Création d’un projet File -> New -> Java Project
Project Name : mettre Thread Share
Vérifier 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électionner ou ajouter (via search si nécessaire).
Une sous-fenêtre Project Explorer vous permet de parcourir les projets et sources créés. Si la
sous-fenêtre n’est pas visible, utiliser Window -> Show view -> Project Explorer.
Accès aux fichiers Un Workspace contient l’ensemble des projets créés. Le workspace est un
répertoire dans votre environnement de travail, il est défini au premier lancement de Eclipse. Vous
pouvez retrouver le nom du répertoire par File -> Switch Workspace. Chaque projet est un sousrépertoire contenant un sous-répertoire bin pour les exécutables, et un sous-répertoire src pour les
sources.
Création de sources, exécution Sélectionner 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éthode main). Puis entrer le code, sauvegarder.
Exécution par Run. Une fenêtre Console vous donne l’affichage.
2
Environnement Netbeans
NetBeans est aussi un environnement de développement intégré (IDE) pour Java, placé en open
source par Sun. En plus de Java, NetBeans permet également de supporter différents autres langages,
comme Python, C, C++, XML et HTML. Il comprend toutes les caractéristiques d’un IDE moderne
(éditeur en couleur, projets multi-langage, refactoring, éditeur graphique d’interfaces et de pages web).
Il permet en outre :
– de créer et déployer des environnements complets web + java
– d’intégrer la machinerie des beans java (annotations adaptées)
– de supporter en plugin des bases de données (GlassFish en Open Source)
– de contrôler le déploiement sur un ensemble de machines
2.1
Initialisation
Modifier votre fichier .bashrc afin que Netbeans soit accessible. Pour cela, décommenter dans
votre fichier .bashrc la ligne
source /export/home/users/COMMUN/.netbeansrc
dans votre .bashrc
Attention : ce changement ne prend effet qu’en lançant un nouveau shell bash ou en effectuant la
commande
. ~/.bashrc
Remarque : c’est la version 6.7.1 qui sera lancée, les versions 6.9.1, 7.1.1, 7.3, 8.0.1 sont aussi installées
(/usr/java/netbeans-x.x.x/bin/netbeans).
2.2
Projet et Groupe
Les projets peuvent être organisés en groupes. Un groupe est un ensemble de projets et est créable
avec FIle->Project Group -> New Group. Donner un nom : TP0.
Création d’un projet File -> New Project -> Java -> Java Application
2
Accès aux fichiers Un Workspace contient l’ensemble des projets créés. Le workspace est un
répertoire dans votre environnement de travail, il est défini au premier lancement de Netbeans. Vous
pouvez retrouver le nom du répertoire en regardant les propriétés (bouton droit, Properties) d’un
projet particulier.
3
Exercice : Classe et héritage
Dans tous les exercices de cette section, déterminez ce qui est affiché par chacun des programmes
donnés, puis testez vos réponses en les implantant.
3.1
Valeurs et références, surcharge
class A {
private i n t v a l =0;
public s t a t i c void a f f i c h e P l u s ( i n t a ) {
a++;
System . out . p r i n t l n ( a ) ;
}
public s t a t i c void a f f i c h e P l u s (A a ) {
a . v a l ++;
System . out . p r i n t l n ( a . v a l ) ;
}
public s t a t i c void main ( S t r i n g [ ] a r g s ) {
A unObj = new A ( ) ;
A unAutreObj = new A ( ) ;
a f f i c h e P l u s ( unObj . v a l ) ;
a f f i c h e P l u s ( unObj . v a l ) ;
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 ( ” E g a l e 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 b j ) { return ( ”A e t B” ) ; }
public S t r i n g f (A o b j ) { return ( ”A e t A” ) ; }
}
c l a s s B extends A {
public S t r i n g f (B o b j ) { return ( ”B e t B” ) ; }
public S t r i n g f (A o b j ) { return ( ”B e t A” ) ; }
}
class t e s t {
public s t a t i c void main ( S t r i n g [ ] a r 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.3
Polymorphisme
class A {
public S t r i n g f (D o b j ) { return ( ”A e t D” ) ; }
public S t r i n g f (A o b j ) { return ( ”A e t A” ) ; }
}
c l a s s B extends A {
public S t r i n g f (B o b j ) { return ( ”B e t B” ) ; }
public S t r i n g f (A o b j ) { return ( ”B e t A” ) ; }
}
c l a s s C extends B{
}
c l a s s D extends B{
}
class t e s t {
public s t a t i c void main ( S t r i n g [ ] a r 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 ) ) ;
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 ;
i n t f ( ) { return i ; }
s t a t i c S t r i n g g ( ) { return ( ”A” ) ; }
S t r i n g h ( ) { return g ( ) ; }
}
c l a s s B extends A {
i n t i =2;
i n t f ( ) { return − i ; }
s t a t i c S t r i n g g ( ) { return ( ”B” ) ; }
S t r i n g h ( ) { return g ( ) ; }
}
class t e s t {
public s t a t i c void main ( S t r i n g [ ] a r g 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 .
System . out .
System . out .
System . out .
println (a . i );
println (a . f ());
println (a . g ());
println (a .h ());
}
}
4
Application : Les robots pollueurs
On considère que le monde est constitué d’une matrice de cases. Différents types de robots agissent
dans ce monde : des robots pollueurs et des robots nettoyeurs.
– Les robots pollueurs se baladent dans le monde et déposent des papiers gras sur les cases où ils
se trouvent. Les robots nettoyeurs, quant à eux, ne supportent pas la vue d’un papier gras et
l’enlèvent dès 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épose un
papier gras sur chaque case rencontrée. Le parcours précis des robots pollueurs sera donné dans
la suite.
– Les robots nettoyeurs parcourent méthodiquement le monde en ”boustrophédon”, c’est-à-dire
qu’ils parcourent la première ligne case par case, puis arrivé en bout de ligne font demi-tour,
parcourent la deuxième ligne en sens inverse, et ainsi de suite jusqu’à la dernière case de la
dernière ligne. Ils enlèvent, s’il s’en trouve un, le papier gras de la case où ils se trouvent. Parmi
les robots nettoyeurs, certains sont distraits et n’enlèvent qu’un papier sur deux.
1. Ecrire la classe Monde qui contient les variables d’instance, les constructeurs et les méthodes
suivantes (définir si elles sont d’instance ou de classe) :
– Le nombre de lignes nbL, le nombre de colonnes nbC, et une matrice booléenne mat de nbL
lignes et nbC colonnes (true signifiant la présence d’un papier gras).
– Un constructeur avec paramètres et un sans paramètres Monde() : ce constructeur par défaut
crée un monde 10*10 sans papiers gras.
– public String toString() : retourne une chaine de caractères décrivant le monde. On
représentera un papier gras par le caractère ”o”, rien par le caractère ”.”(point).
– metPapierGras(int i,int j) : met un papier gras dans la case ( i , j ).
– prendPapierGras(int i,int j) : enlève 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éthode main et y créer un Monde de 10 lignes et 10
colonnes. Y tester les méthodes 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éthodes 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éplacer et agir.
– deux constructeurs : Robot(int x,int y,Monde m) qui crée un robot à la position (x,y)
et Robot(Monde m) qui crée un robot avec une position aléatoire. Le constructeur
Robot(Monde m) doit appeler l’autre constructeur.
– vaEn(int i, int j ) : se déplace en (i, j).
– parcourir() : méthode abstraite qui sera définie dans les sous-classes.
4. Ecrire la classe RobotPollueur (également abstraite car elle n’aura pas d’instance) qui contient
la méthode :
– polluer () : met un papier gras là où ce robot se trouve dans le monde.
5. Ecrire la classe PollueurToutDroit qui contient les champs et méthodes suivantes :
– colDepart, numéro de la colonne où il va se rendre pour commencer sa mission.
– constructeur(s).
– parcourir() : cette méthode définit la méthode parcourir abstraite de la classe Robot. Elle
décrit un parcours de ce robot dans le monde. Le robot se positionne d’abord dans sa colonne
de départ en case (0, ColDepart), puis il va tout droit vers le sud en visitant chaque case de
la colonne et dépose un papier gras sur chacune d’elle. Il s’arrête dans la dernière case de la
colonne.
5
6. Ecrire la classe PollueurSauteur, avec les champs et méthodes suivants :
– deltax représentant la taille du saut e ?ectué à chaque déplacement du sauteur.
– constructeurs.
– parcourir() : cette méthode définit la méthode parcourir abstraite de la classe Robot. Elle
décrit un parcours de ce robot dans le monde. Le robot se positionne d’abord dans sa colonne
de départ en case (0, 0), puis il saute de façon 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’échiquier,
on revient au début. Par exemple, la colonne nbC, qui n’existe pas, sera transformée en nbC
modulo nbC, i.e, colonne 0. Chaque case rencontrée est souillée d’un papier gras. Le robot
s’arrête lorsqu’il atteint la dernière ligne.
7. Ecrire la classe RobotNettoyeur, qui contient les méthodes suivantes :
– nettoyer() : enlève le papier gras de la case où se trouve ce robot.
– constructeurs,
– parcourir() : cette méthode définit la méthode parcourir abstraite de la classe Robot. Elle
décrit un parcours complet de ce robot dans le monde. Il part de la case (0, 0) et parcourt le
monde en ”boustrophédon”. Si la case est sale, il enlève le papier gras qui s’y trouve.
8. Ecrire la classe NettoyeurDistrait qui contient les méthodes suivantes :
– constructeurs.
– parcourir() : cette méthode redéfinit la méthode parcourir() . Elle décrit un parcours complet de
ce robot dans le monde. C’est le même parcours que celui des robots nettoyeurs mais comme
il est distrait, il n’enlève qu’un papier sur deux.
9. Ecrire dans une classse TestRobot avec une méthode main pour tester les classes définies dans
les exercices précédents.
5
Exceptions et lambda-expressions
1. Définir une classe Enseignant ayant 4 champs :
– String nom
– int age
– int salaire
– String grade : une énumération pour PU, MCU, PRAG, BIATTS, PUPH, MCUPH
2. Définir un ensemble d’enseignants, comme liste d’instances de la classe Enseignant.
3. Définir une méthode permettant de calculer l’âge étant donné un nom d’enseignant.
4. Définir une méthode calculant la moyenne des âges des enseignants.
5. Définir une méthode calculant la moyenne des salaires des enseignants dont l’âge est compris
entre 40 et 60 ans, idem selon le grade.
6. Définir des classes exception permettant de gérer les cas d’erreurs.
7. Définir des méthodes permettant d’ajouter, ou de supprimer, ou de modifier un enseignant.
6