Programmation Java/Membres

Un livre de Wikilivres.
Aller à : navigation, rechercher


Introduction[modifier | modifier le wikitexte]

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 wikitexte]

Attribut[modifier | modifier le wikitexte]

La déclaration d'un attribut se fait de la manière suivante :

modificateurs type nom;

Constructeur[modifier | modifier le wikitexte]

La déclaration d'un constructeur se fait de la manière suivante :

modificateur d'accès nomDeLaClasse(type et nom des paramètres éventuels) { corps du constructeur } 

Méthode[modifier | modifier le wikitexte]

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 }

Méthode à nombre de paramètres variable[modifier | modifier le wikitexte]

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.print("Ingrédients : \n");
	  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 wikitexte]

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éthode natives de la classe.