Programmation Java/Membres
Introduction[modifier | modifier le wikicode]
Les membres d'une classe sont les méthodes (traitements) et attributs (données) qui en font partie.
Exemple :
public class Horloge
{
// Définition des attributs
int heures;
int minutes;
int secondes;
// Définition des méthodes
public void definitHeure()
{
heures = 12;
minutes = 30;
secondes = 30;
}
public void incrementeHeure()
{
secondes++;
if (secondes==60)
{
secondes=0;
minutes++;
if (minutes==60)
{
minutes=0;
heures++;
if (heures==24)
{
heures=0;
}
}
}
}
protected void afficheHeure()
{
System.out.println("Il est "+heures+":"+minutes+":"+secondes);
}
public static void main (String[] args)
{
Horloge montre = new Horloge(); // Nouvelle instance de la classe
// Accès aux membres de la classe de l'objet avec le caractère point : <objet>.<membre>
montre.definitHeure();
for (int i=0 ; i<10 ; i=i+1)
{
montre.incrementeHeure();
montre.afficheHeure();
}
}
}
Dans cet exemple, la classe Horloge contient trois attributs servant à représenter l'heure (heures, minutes et secondes) et trois méthodes (definitHeure qui initialise, incrementeHeure, qui augmente l'heure d'une seconde, et afficheHeure, qui affiche l'heure).
On distingue parmi les méthodes une catégorie particulière, les constructeurs.
Déclaration[modifier | modifier le wikicode]
Attribut[modifier | modifier le wikicode]
La déclaration d'un attribut se fait de la manière suivante :
modificateurs type nom;
Exemple :
protected String auteur;
La déclaration peut inclure une initialisation :
protected String auteur = "Moi";
Constructeur[modifier | modifier le wikicode]
La déclaration d'un constructeur se fait de la manière suivante :
modificateurs NomDeLaClasse(type et nom des paramètres éventuels) { corps du constructeur }
Exemple :
public Livre(String titre, String auteur)
{
//...
}
Méthode[modifier | modifier le wikicode]
La déclaration d'une méthode se fait comme suit :
modificateurs typeDeRetour nom(type et nom des paramètres éventuels) { corps de la méthode }
Exemple :
public String getTitre()
{
return this.titre;
}
En Java (au moins jusqu'à la version 8) les fonctions :
- ne peuvent pas avoir de paramètre avec une valeur par défaut (comme en C++ ou PHP).
- ne peuvent pas contenir de paramètre facultatif.
Cependant, pour le dernier point, si un paramètre peut être facultatif, il est possible de créer deux versions de la méthode ayant le même nom mais dont l'une n'a pas ce paramètre.
Méthode à nombre de paramètres variable[modifier | modifier le wikicode]
Java 5 introduit un mécanisme permettant d'écrire des méthodes acceptant un nombre variable d'arguments ("varargs"), alors qu'il fallait passer par un tableau ou autre artifice similaire auparavant. La syntaxe est très similaire à la syntaxe utilisée pour la fonction printf en C, ce qui a permis d'ajouter une méthode printf dans la classe PrintStream, ce qui permet de faire System.out.printf("what ever %d",5);
Exemple :
public class Message
{
public void message(String recette, String... arguments)
{
System.out.println("Ingrédients pour "+recette+" :");
for (String s : arguments)
System.out.println(s);
}
public static void main (String[] args)
{
Message menu = new Message();
menu.message("déjeuner","ail","oignon","échalote");
}
}
Bloc d'initialisation[modifier | modifier le wikicode]
Une classe peut comporter un ou plusieurs blocs d'instructions servant à initialiser toute instance de la classe, ou à initialiser des membres statiques si le bloc est déclaré statique (static).
Exemple :
public class ImageFile
{
final int MAX_SIZE; // final -> variable initialisée une seule fois
// Bloc d'initialisation
{
int maxsize;
try
{
maxsize = Integer.parseInt(System.getProperty("file.maxsize"));
}
catch(Exception ex) // propriété "file.maxsize" non définie (NullPointerException) ou n'est pas un nombre
{
maxsize = 1000; // valeur par défaut
}
MAX_SIZE = maxsize; // variable initialisée une seule fois
}
ImageFile(File f){ /* ... */ }
ImageFile(File f, int width){ /* ... */ }
ImageFile(File f, int width, int height){ /* ... */ }
}
Les instructions contenues dans les blocs d'initialisation sont appelées avant les instructions du constructeur utilisé. Un bloc d'initialisation permet donc de :
- gérer les exceptions (contrairement à une affectation dans la déclaration de la variable membre),
- éviter la duplication du code dans les différents constructeurs.
La classe peut aussi comporter des blocs d'initialisation statiques, qui sont des blocs d'instructions précédés du modificateur static, et qui sont exécutés au chargement de la classe, juste après l'initialisation des attributs statiques.
Exemple :
public class Exemple
{
static
{
System.out.println("La classe Exemple est chargée");
}
}
Un bloc d'initialisation statique permet de :
- gérer les exceptions (contrairement à une affectation dans la déclaration de la variable membre),
- charger la bibliothèque native implémentant les méthodes natives de la classe.