Fiches JAVA

Fiches JAVA
1
Classes et objets
Les éléments de base en java sont des objets. On peut avoir différents types
d’objets en Java. Le type d’un objet est appelé sa classe. Chaque fichier java
décrit une classe. Une classe d’objets décrit en particulier quels sont les différents
éléments qui caractérisent un objet de cette classe (attributs) et quelles sont les
fonctions (méthodes) qui permettent de le manipuler.
Par exemple, les objets de type Robot (TP 2 et 5) étaient décrits par leurs
positions (x et y, deux entiers) et leurs noms (une chaı̂ne de caractère). On
pouvait les manipuler en leur demandant de monter, descendre aller à gauche
ou à droite. La classe Robot est décrite de la manière 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
void
void
void
haut()
bas()
gauche()
droite()
{
{
{
{
this.y
this.y
this.x
this.x
=
=
=
=
{
this.y-1;
this.y+1;
this.x-1;
this.x+1;
}
}
}
}
}
Une méthode particulière est ici le constructeur. C’est une fonction qui n’a
pas de type de retour et qui a le même nom que la classe (ici Robot(int X,
int Y, String NOM) ). Elle est appelée lorsqu’un objet de type Robot est crée.
Elle sert à initialiser les attributs du robot.
Notez que le mot clef ”this”, utilisé dans une classe est une référence à l’objet
courant : comprendre ”this” comme ”moi”. Par exemple quand un robot va à
droite, ”son” x augmente (this.x = this.x+1).
2
Création et utilisation d’un objet
Pour créer 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ée 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éthodes 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éthodes peuvent être déclarés private ou public. Un attribut ou une méthode publique est accessible de partout. Un attribut ou une
méthode privée ne peut être modifié 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é */
}
private void f2() {
...
a1 = 0; /* autorisé */
a2 = 1; /* autorisé */
...
}
}
Dans le fichier Truc.java :
Class Truc {
...
public void bidule()
{
Machin m;
...
m.a1 = 0; /* autorisé */
m.a2 = 1; /* interdit ! a2 est privé */
m.f1(); /* autorisé */
m.f2(); /* interdit ! f2() est privé */
}
...
}
2
Le mot clef private sert surtout pour ”protéger” certains attributs d’un
objet.
4
static
Par défaut, les attributs et méthodes d’un objet lui sont propres. On parle
d’attributs et de méthodes d’instance : chaque ”instance” de la classe (chaque
objet) a son propre jeu d’attributs et son propre jeu de méthodes (dans l’exemple
plus haut r1.bas() et r2.bas() sont deux méthodes distinctes). On peut désirer
avoir des attributs ou des méthodes qui concernent la classe dans son entier.
On parle d’attribut ou de méthode de classes et on précède leur définition. 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éristique 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ême chose pour une fonction qui permet de connaı̂tre le
nombre de robots.
Pour accéder à ces attributs ou méthodes, on doit les précéder du nom de la
classe (Robot.nb robots; ou Robot.combien de robots() dans l’exemple).
Notons que la méthode main est toujours une méthode statique : elle indique
le classe peut être exécutée (on peut faire un ”run”).
5
héritage
En Java, une classe peut hériter 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érite de la classe Robot. Elle récupère tous les attributs et
toutes les méthodes de Robot (à l’exception du constructeur qu’il faut récrire).
3
C’est un peu comme si on avait fait un ”copier-coller” de tous les attributs
et méthodes de Robot. On peut tout de même remplacer certaines méthodes.
Dans l’exemple, la classe Robot2 possède les méthodes bas(), gauche() et droite
de Robot, par contre, la méthode haut() a été remplacée (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éthode de Robot2 qui est appelée
*/
r2d2.bas(); /* il descend d’un pas :
* la méthode bas() de Robot2 est celle de Robot
*/
On notera qu’une classe ne peut hériter 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éthodes sans leur code (on parle de prototype
de méthode). Pour indiquer qu’une classe suit une interface (ou implémente
l’interface), on utilise le mot clé implements. Les fonctions de l’interface doivent
alors exister dans la classe. Par exemple :
/* la classe Robot3 hérite de Robot et implémente 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 être utilisée comme type dans les paramètres d’une méthode.
Par exemple :
public void bouge(Lutin l) {
...
}
Cette fonction prend en entrée un objet l quelconque dont on sait juste qu’il respecte l’interface (ici, cela signifie qu’il possède les fonctions getX() et avance()).
Ce peut être un objet dont la classe est Robot3 ou n’importe quelle classe
qui implémente l’interface Lutin. On notera par ailleurs qu’une classe peut
implémenter plusieurs interfaces.
7
Javadoc
Pour utiliser l’outil de génération automatique de documentation Javadoc, deux
choses sont à réaliser :
1. commentez les attributs et les méthodes. Les commentaires ont le forme
suivante, pour les attributs :
/**
* description
*/
int x;
(notez bien la double étoile en début de commentaire), et pour les méthodes :
/**
* description
*
* @param x description de x
* @param y description de y
* @return description de ce qui est renvoyé par la fonction.
*/
int machin(int x, int y)
On commente ainsi tous les paramètres de la méthode, ainsi que son
éventuel résultat (si la fonction est de type void machin(...), pas besoin
de @return évidemment).
2. Appelez javadoc avec comme argument les fichiers java. Par exemple :
javadoc Robot.java
pour le fichier Robot.java, ou plus directement, pour générer une documentation pour tous vos fichiers :
javadoc *.java
5