Bases Java - Eclipse / Netbeans Environnements Java 1

Institut Galilée
Master 1
PDJ
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 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ésente par défaut sur certains systèmes. Elle a l’inconvénient majeure de présenter de nombreux problèmes de compatibilité 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é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. Pour cela, vérifiez que vous avez
/LOCAL/eclipse/jee-mars dans votre variable d’environnement $PATH.
Remarque : c’est la version ‘mars’ de Eclipse qui est lancée (version 4.5.1).
1.2
Projet
Création d’un projet File -> New -> Java Project
Project Name : mettre Thread Share
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.
1
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 qu’Eclipse soit accessible. Pour cela, vérifiez que vous avez
/LOCAL/netbeans/bin dans votre variable d’environnement $PATH.
Remarque : c’est la version 8.0.2 qui est lancée (/LOCAL/netbeans/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 Groups -> New Group. Donner un nom : TP0.
Création d’un projet File -> New Project -> Java -> Java Application
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 ” ) ;
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 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
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 ) ) ;
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 ;
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 ( ) ) ;
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è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 ).
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é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.
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
5
— 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