3. Éléments statiques

On appelle élément statique d'une classe tout élément attaché à cette classe plutôt qu'à l'une de ses instances. Un élément statique peut exister, être référencé, ou s'exécuter même si aucune instance de cette classe n'existe. Un élément statique ne peut référencer this. Il est possible de définir quatre types d'éléments statiques :

des champs statiques : la valeur de ce champ est la même pour tous les objets instance de la classe ;
des méthodes statiques ;
des blocs statiques ;
des classes membre statiques.

3.1. Champ statique

Par défaut, chaque instance de chaque classe occupe son propre espace mémoire. Deux objets instances d’une même classe occupent donc deux espaces mémoire qui ne se recouvrent pas. Lorsque que l’on déclare un membre statique ( static), il est au contraire placé dans un espace mémoire commun à tous les objets de la classe. Si un des objets modifie la valeur d’un champ statique (par exemple), tous les objets verront la valeur de ce champ modifiée. Nous avons déjà rencontré une méthode statique : la méthode main, appelée lors du lancement d'une application Java. Dans la mesure où un élément statique ne dépend d’aucune instance de la classe à laquelle il appartient, il est possible de l’appeler avec une syntaxe particulière, sans passer par une instance particulière de la classe. Il est même possible d’invoquer un élément statique d’une classe sans que celle-ci n’ait jamais été instanciée. Il est une bonne pratique de n'appeler les membres statiques d'une classe que de façon "statique", c'est-à-dire en utilisant le nom de la classe plutôt qu'une de ses instances. Voyons ceci sur un exemple.

Exemple 25. Utilisation d'un champ statique

public  class Marin {  // dans le fichier Marin.java  
     public  static  int nombreMarins =  0 ;  
      
     public Marin() {  
        nombreMarins ++ ;  
    }  
}  
  
 public  class Application {  // dans le fichier Application.java  
      
     public  static  void main(String [] args) {  
        Marin marin1 =  new Marin() ;  
        Marin marin2 = null ;  
        
         // affiche 1  
        System.out.println("Nombre de marins = " + Marin.nombreMarins) ;
        
         // affiche 1, méthode non recommandée  
        System.out.println("Nombre de marins = " + marin1.nombreMarins) ; 
        
         // affiche 1, bien que marin2 soit null
        System.out.println("Nombre de marins = " + marin2.nombreMarins) ;   
    }  
}

Sur cette exemple, nous voyons trois façon d'accéder au champ statique nombreMarins. Notons qu'y accéder via une instance nulle de la classe Marin est valide, ce qui peut paraître bizarre au premier coup d'œil, et qu'il l'est sans aucun doute ! La méthode préférée pour accéder à un champ statique, est d'y accéder via le nom de la classe qui contient ce champ : Marin.nombreMarins.

3.2. Cas des constantes

L'utilisation de constantes en algorithmique est très fréquente et même indispensable. La bonne façon de définir une constante en Java est de la définir dans un champ public static final. Le fait qu'il soit publique et statique permet d'y accéder de n'importe où. Le déclarer final interdit sa modification, ce qui est en général recherché pour une constante ! Le premier exemple qui vient à l'esprit est la définition de PI dans la classe Math.

Exemple 26. Déclaration d'une constante

public  class Math {   
  
     public  static  final  double PI =  3.14159265358979323846 ;  
  
}

Il est donc possible d'utiliser la constante Math.PI dans n'importe quel programme Java. La gestion des constantes a évolué entre Java 1.4 et Java 5. Jusqu'en Java 1.4, la façon préférée pour déclarer une constante est celle que nous venons de décrire. En toute rigueur il en existe une autre, qui consiste à déclarer ce champ public final dans une interface plutôt qu'une classe. Ce pattern de Java 1.1 a été jugé hérétique il y a quelques temps déjà, et on ne doit donc plus l'utiliser sous peine de s'attirer les foudres de l'inquisition espagnole. La gestion des constantes a légèrement évolué entre Java 4 et Java 5. Lors de la compilation, un code qui référence une constante est remplacé par la valeur de la constante. Mais ce code, qui vit dans une classe possède un import vers la classe qui porte cette constante. En Java 5 ce point a été revu, avec l'introduction d'une nouvelle notion : l'import statique. Le code qui utilise une constante peut continuer à l'utiliser comme en 1.4 (dans le cas de Math.PI, c'est assez justifié...), mais il peut aussi choisir d'importer cette valeur de constante statiquement. Dans ce cas, la classe qui utilise cette constante ne dépend plus de celle qui déclare cette constante, et le Jar de cette classe n'a plus besoin d'ête en dépendance du premier.

3.3. Bloc statique

Un bloc statique est un ensemble d'instructions déclaré suivant une syntaxe particulière. Nous verrons dans la suite comment ce bloc est pris en compte lors de l'exécution d'un programme. Voyons un exemple de bloc statique.

Exemple 27. Déclaration d'un bloc statique

public  class Marin {  
      
     static {  
         // ceci est un bloc statique  
    }  
}

Ces blocs sont à utiliser avec précautions, notamment lorsque l'on se préoccupe de la testabilité du code que l'on écrit. Nous reverrons la testabilité d'un code en détails, et expliquerons comment et en quoi ce genre de choses peut nuire à la testabilité d'une classe.

3.4. Classe membre statique

Nous avons déjà vu les classes membre. Une classe membre peut être déclarée statique. Dans ce cas, on notera qu'il est possible à la machine Java de la charger, sans charger la classe dans laquelle cette classe est déclarée.