Fiches JAVA

Fiches JAVA
1 Classes et objets
Les ´el´ements de base en java sont des objets. On peut avoir diff´erents types
d’objets en Java. Le type d’un objet est appel´e sa classe. Chaque fichier java
d´ecrit une classe. Une classe d’objets d´ecrit en particulier quels sont les diff´erents
´el´ements qui caract´erisent un objet de cette classe (attributs) et quelles sont les
fonctions (m´ethodes) qui permettent de le manipuler.
Par exemple, les objets de type Robot (TP 2 et 5) ´etaient d´ecrits par leurs
positions (x et y, deux entiers) et leurs noms (une chaˆıne de caract`ere). On
pouvait les manipuler en leur demandant de monter, descendre aller `a gauche
ou `a droite. La classe Robot est d´ecrite de la mani`ere suivante :
class Robot {
int x;
int y;
String nom;
Robot(int X, int Y, int NOM) {
this.x = X;
this.y = Y;
this.nom = NOM;
}
void haut() { this.y = this.y-1; }
void bas() { this.y = this.y+1; }
void gauche() { this.x = this.x-1; }
void droite() { this.x = this.x+1; }
}
Une m´ethode particuli`ere est ici le constructeur. C’est une fonction qui n’a
pas de type de retour et qui a le mˆeme nom que la classe (ici Robot(int X,
int Y, String NOM) ). Elle est appel´ee lorsqu’un objet de type Robot est cr´ee.
Elle sert `a initialiser les attributs du robot.
Notez que le mot clef ”this”, utilis´e dans une classe est une r´ef´erence `a l’objet
courant : comprendre ”this” comme ”moi”. Par exemple quand un robot va `a
droite, ”son” x augmente (this.x = this.x+1).
2 Cr´eation et utilisation d’un objet
Pour cr´eer un Robot dans notre programme, on utilisera le code suivant :
Robot r1 = new Robot(2, 5, "Bob");
Robot r2 = new Robot(3, 2, "R2D2");
1

On cr´ee ici deux objets de types Robot (r1 et r2), ils disposeront alors tous
deux d’un attribut x, d’un attribut y, d’un nom, et des m´ethodes haut, bas,
gauche et droite. Par exemple, le code suivant permet de demander au robot r1
de monter et au robot r2 de descendre. :
r1.haut();
r2.bas();
3 Private/Public
Les attributs et les m´ethodes peuvent ˆetre d´eclar´es private ou public. Un at-
tribut ou une m´ethode publique est accessible de partout. Un attribut ou une
m´ethode priv´ee ne peut ˆetre modifi´e que dans le fichier de la classe. Par exemple,
dans le fichier Machin.java :
Class Machin {
...
public int a1;
private int a2;
...
public int f1() {
...
return a2; /* autoris´e */
}
private void f2() {
...
a1 = 0; /* autoris´e */
a2 = 1; /* autoris´e */
...
}
}
Dans le fichier Truc.java :
Class Truc {
...
public void bidule()
{
Machin m;
...
m.a1 = 0; /* autoris´e */
m.a2 = 1; /* interdit ! a2 est priv´e */
m.f1(); /* autoris´e */
m.f2(); /* interdit ! f2() est priv´e */
}
...
}
2

Le mot clef private sert surtout pour ”prot´eger” certains attributs d’un
objet.
4 static
Par d´efaut, les attributs et m´ethodes d’un objet lui sont propres. On parle
d’attributs et de m´ethodes d’instance : chaque ”instance” de la classe (chaque
objet) a son propre jeu d’attributs et son propre jeu de m´ethodes (dans l’exemple
plus haut r1.bas() et r2.bas() sont deux m´ethodes distinctes). On peut d´esirer
avoir des attributs ou des m´ethodes qui concernent la classe dans son entier.
On parle d’attribut ou de m´ethode de classes et on pr´ec`ede leur d´efinition. Par
exemple :
class Robot {
static private int nb_robots;
...
static int combien_de_robots() { return nb_robots; }
...
}
Le nombre de robots n’est pas une caract´eristique d’un robot particulier mais
de l’ensemble des robots, c’est donc un attribut de classe ce qui justifie l’emploi
du mot clef static. Mˆeme chose pour une fonction qui permet de connaˆıtre le
nombre de robots.
Pour acc´eder `a ces attributs ou m´ethodes, on doit les pr´ec´eder du nom de la
classe (Robot.nb robots; ou Robot.combien de robots() dans l’exemple).
Notons que la m´ethode main est toujours une m´ethode statique : elle indique
le classe peut ˆetre ex´ecut´ee (on peut faire un ”run”).
5 h´eritage
En Java, une classe peut h´eriter d’une autre. Par exemple :
public class Robot2 extends Robot {
public Robot2() {
this.x = 0;
this.y = 0;
this.nom = "Robot2";
}
public void haut() { this.x = this.x + 2; }
}
La classe Robot2 h´erite de la classe Robot. Elle r´ecup`ere tous les attributs et
toutes les m´ethodes de Robot (`a l’exception du constructeur qu’il faut r´ecrire).
3

C’est un peu comme si on avait fait un ”copier-coller” de tous les attributs
et m´ethodes de Robot. On peut tout de mˆeme remplacer certaines m´ethodes.
Dans l’exemple, la classe Robot2 poss`ede les m´ethodes bas(), gauche() et droite
de Robot, par contre, la m´ethode haut() a ´et´e remplac´ee (pour avancer de deux
pas au lieu d’un). Voir l’exemple suivant :
...
Robot2 r2d2 = new Robot2();
...
r2d2.haut(); /* le robot r2d2 avance de 2 pas :
* c’est la m´ethode de Robot2 qui est appel´ee
*/
r2d2.bas(); /* il descend d’un pas :
* la m´ethode bas() de Robot2 est celle de Robot
*/
On notera qu’une classe ne peut h´eriter que d’UNE seule classe en Java.
6 Interface
Une interface est un ensemble de fonctions. C’est en quelque sorte un ”contrat”
que dois remplir une classe. Une interface se note ainsi :
public interface Lutin {
public void avance();
public int getX();
}
On a donc juste une liste de m´ethodes sans leur code (on parle de prototype
de m´ethode). Pour indiquer qu’une classe suit une interface (ou impl´emente
l’interface), on utilise le mot cl´e implements. Les fonctions de l’interface doivent
alors exister dans la classe. Par exemple :
/* la classe Robot3 h´erite de Robot et impl´emente l’interface Lutin */
public class Robot3 extends Robot implements Lutin {
/* le constructeur */
public Robot3() { ... }
...
/* la fonction avance de l’interface */
public void avance() { haut(); }
/* la fonction getX de l’interface */
public int getX() { return this.x; }
}
4

Une interface peut ˆetre utilis´ee comme type dans les param`etres d’une m´ethode.
Par exemple :
public void bouge(Lutin l) {
...
}
Cette fonction prend en entr´ee un objet lquelconque dont on sait juste qu’il re-
specte l’interface (ici, cela signifie qu’il poss`ede les fonctions getX() et avance()).
Ce peut ˆetre un objet dont la classe est Robot3 ou n’importe quelle classe
qui impl´emente l’interface Lutin. On notera par ailleurs qu’une classe peut
impl´ementer plusieurs interfaces.
7 Javadoc
Pour utiliser l’outil de g´en´eration automatique de documentation Javadoc, deux
choses sont `a r´ealiser :
1. commentez les attributs et les m´ethodes. Les commentaires ont le forme
suivante, pour les attributs :
/**
* description
*/
int x;
(notez bien la double ´etoile en d´ebut de commentaire), et pour les m´ethodes :
/**
* description
*
* @param x description de x
* @param y description de y
* @return description de ce qui est renvoy´e par la fonction.
*/
int machin(int x, int y)
On commente ainsi tous les param`etres de la m´ethode, ainsi que son
´eventuel r´esultat (si la fonction est de type void machin(...), pas besoin
de @return ´evidemment).
2. Appelez javadoc avec comme argument les fichiers java. Par exemple :
javadoc Robot.java
pour le fichier Robot.java, ou plus directement, pour g´en´erer une docu-
mentation pour tous vos fichiers :
javadoc *.java
5