Créons un premier objet ou une première classe qui représentera le score d'un joueur ou la note d'un élève. Cette classe, nommée score, devra gérer au moins trois données : le nom du joueur, son score, le score maximal autorisé.
Pour la créer, on utilise le fichier score.java :
public class score {
String nom;
int leScore;
int scoMax;
}
Le fichier score.java étant créé, on le compile pour obtenir le fichier score.class.
Pour pouvoir utiliser la classe score, il faut créer une variable de type score dans un programme.
Créons donc un programme test1 (qui est aussi une classe, mais celle-ci a la particularité de posséder une méthode main).
public class test1 {
public static void main(String args[]) {
//déclaration
score sc;
//création ou instanciation
sc=new score();
//initialisation des données
sc.nom="Pierre";
sc.leScore=10;
sc.scoMax=100;
System.out.println(sc.nom+" : "+sc.leScore);
}
}
Compilons et exécutons test1.
Comme nous serons souvent appelés à afficher le contenu de l'objet, écrivons une méthode affiche() qui se charge de ce travail. On l'ajoute dans le fichier score.java.
void affiche() {
System.out.println(nom+" : "+leScore);
}
Après avoir recompilé score.java, on peut créer un nouveau fichier test2.java semblable à test1 mais en remplaçant la ligne System.out..... par sc.affiche(), puis tester le tout.
Les constructeurs sont des méthodes particulières qui prennent le nom de la classe et qui permettent d'initialiser les objets. La classe score possède déjà un constructeur qui a été utilisé en écrivant
sc= new score();
Ce constructeur existe par défaut pour toute classe; il est possible de le réécrire, par exemple pour que le nom par défaut soit "inconnu" et pour que le score initial soit 0 et que le score maximal soit 100. On obtient :
score() {
nom="inconnu";
leScore=0;
scoMax=100;
}
L'exécution de test1 ou de test2 ne donne pas de changement. Pour vérifier l'effet de ce nouveau constructeur, créons le fichier test3 à partir de test2 en supprimant la partie initialisation des données.
public class test3 {
public static void main(String args[]) {
//déclaration
score sc;
//création ou instanciation
sc=new score();
//affichage
sc.affiche();
}
}
On obtient cette fois "inconnu : 0" à l'affichage.
Pour ne pas créer que des inconnus, écrivons un second constructeur qui fixera le nom du joueur.
score(String nom) {
this.nom=nom;
leScore=0;
scoMax=100;
}
Le mot-clé this représente la classe elle-même : cela permet de distinguer le champ nom de la classe et le paramètre nom passé au constructeur.
On peut alors modifier test3 pour créer l'objet score de Henri en écrivant :
sc=new score("Henri");
La gestion de plusieurs joueurs se fait de façon simple en créant plusieurs instances de la classe score. Par exemple, pour deux joueurs nommés Henri et Lise on pourra écrire le fichier test4.
public class test4 {
public static void main(String args[]) {
//déclaration
score scHenri,scLise;
//création ou instanciation
scHenri=new score("Henri");
scLise=new score("Lise");
//affichage
scHenri.affiche();
scLise.affiche();
}
}
Nous avons jusqu'ici présupposé que le score était toujours un nombre positif inférieur ou égal à scoMax. Cependant un programme peut attribuer n'importe quelle valeur au champ leScore. Pour empêcher cela nous allons déclarer ce champ avec le préfixe "private". Ce qui donne :
private int leScore;
Dans ces conditions, aucun programme ne peut lire ou modifier le contenu du champ leScore. Pour permettre d'agir sur lui en tenant compte de ses limites nous devrons ajouter deux nouvelles méthodes : l'une de lecture et l'autre d'écriture.
//méthode de lecture
public int getScore() {
return leScore;
}
//méthode d'écriture
public void setScore(int sco) {
if (sco>scoMax) leScore=scoMax;
else if (sco<0) leScore=0;
else leScore=sco;
}
Les champs et les méthodes d'une classe peuvent être publics (mot-clé public) ou privés (mot-clé private). Comment choisir ?
Terminons la construction de la classe score en lui attribuant une nouvelle méthode permettant d'ajouter des points au score.
public void ajoute(int points) {
setScore(leScore+points);
}
Nous disposons désormais d'une classe permettant de gérer le score d'un joueur pour de nombreux jeux. Mais que se passe-t-il si pour une application particulière nous souhaitons doter la gestion du score de nouvelles possibilités ?
C'est ce que nous allons voir en créant une classe dérivée de la classe score.