Autres membres d`une classe

Chapitre 4
Autres membres d’une classe
Dans le modèle objet, toutes les variables et méthodes sont liées à un objet.
C’est-à-dire que pour accéder à une donnée ou déclencher un traitement, il faut
d’abord instancier une classe.
Cette nécessité de créer d’abord un objet est difficile à respecter dans certains
cas particuliers :
→ Déclenchement du point d’entrée du programme : la méthode main.
Comment envoyer un message sans avoir à créer d’objets ?
→ Les flots d’entrée/sortie standards référencés par les variables constantes
out, in, err doivent être définis d’une manière unique avant le début de l’exécution.
Où définir ces variables et comment les positionner avant l’appel au point
d’entrée du programme ?
→ Les opérations mathématiques (abs(), sin(), . . .) s’appliquent, en Java, à
des types de base.
Comment rendre disponible ces opérations qui ne s’appliquent pas à un objet ?
La construction classe va servir à contenir les données et traitements qui ne
ne sont pas liés à des objets. Une classe n’est plus seulement la description d’une
encapsulation mais devient utilisable à l’exécution.
Par défaut, une méthode ou une variable est attachée à un objet. Le mot-clé
static permet d’attacher une méthode ou une variable à une classe. Comme pour
un objet, c’est la notation pointée qui est utilisé pour accéder à ces nouveaux membres. C’est un message envoyé à la classe et non à une instance de cette classe,
par exemple : java.lang.System.out, java.lang.Math.abs().
Remarque : En Java, il est autorisé d’utiliser les méthodes de classe et variables
de classe à travers une instance.
25
4.1
Variable de classe
Une variable de classe est partagée par toutes les instances de la classe. Sa
modification affecte toutes les instances. Une variable de classe existe avant toute
instanciation de la classe.
static [ final ] [ public | private ] type nom ;
⋄ Même si une variable de classe n’est pas stockée dans la zone mémoire de
l’objet, elle fait partie de l’ensemble des attributs de chaque instance de cette
classe.
⋄ L’initialisation d’une variable de classe s’effectue au chargement de la classe.
Elle peut de faire dans un « bloc statique » déclaré à l’intérieur de la classe. La
machine virtuelle exécute le bloc statique au chargement de la classe.
Par exemple pour initialisation d’une variable de classe qui contient un tableau.
class Exemple {
static f i n a l private Porte [ ] portes = new Porte [ 1 0 ] ;
static private double [ ] mesReels = new double [ 2 0 ] ;
4 // ...
static {
for ( int i = 0; i < mesIndicateurs . length ; i ++)
portes [ i ] = new PorteCoulissante ( i + 1)
for ( int i = 0; i < mesReels . length ; i ++)
mesReels [ i ] = Math . random ( ) ;
9
}
}
Boutez Vos Neurones : Pourquoi l’initialisation d’une variable de classe dans un
constructeur est-elle problématique ?
L’utilisation la plus fréquente est la définition d’une constante, par exemple
System.out ou java.lang.Long.MAX_VALUE.
Un exemple d’utilisation de variables de classe constantes pour la mise en œuvre
d’une énumération représentant la couleur dans un jeux de cartes français 1 .
public class Enseigne {
5
final
final
final
final
public
public
public
public
static
static
static
static
Enseigne
Enseigne
Enseigne
Enseigne
COEUR = new Enseigne ( "Coeur" , 2 ) ;
CARREAU = new Enseigne ( "Carreau" , 1 ) ;
PIQUE = new Enseigne ( "Pique" , 3 ) ;
TREFLE = new Enseigne ( "Trefle" , 0 ) ;
f i n a l private int ordre ;
f i n a l private String nom;
10
private Enseigne ( String nom, int ordre ) {
this .nom = nom;
this . ordre = ordre ;
}
1. Avant l’apparition de la classe Enum dans l’A.P.I. Java Enum TREFLE, CARREAU, COEUR, PIQUE;.
26
15
public boolean estPlusFort ( Enseigne c ) {
return ordre > c . ordre ;
}
public boolean estMoinsFort ( Enseigne c ) {
return ordre < c . ordre ;
}
20
25
public String nom ( ) {
return nom;
}
30
public static void main ( String . . . args ) {
Enseigne e = Enseigne .COEUR;
System . out . p r i n t l n ( c . estMoinsFort (ENSEIGNE.TREFLE ) ) ;
System . out . p r i n t l n ( c . non ( ) ) ;
}
}
4.2
Méthode de classe
static [ public | private ] type méthodedeClasse ([ liste de paramètres ])
{
}
// code .
⋄ Le code d’une méthode de classe a accès aux variables de classe et aux méthodes de classe définies dans la classe.
⋄ Par contre, la référence this n’est pas définie (aucune instance n’est créée).
Il n’est donc pas possible d’utiliser directement les variables d’instance et les
méthodes d’instance. L’utilisation doit se faire à travers une instance de la
classe soit passée par paramètre, soit instanciée par le code de la méthode.
⋄ Une méthode de classe peut être surchargée.
Les méthodes de classe s’emploient couramment pour fabriquer des instances
(voir la classe javax.swing.border.LineBorder) ou contenir les traitements ne correspondant à aucune encapsulation. (voir les classes java.lang.Math et java.util.Arrays).
Un exemple de méthode de fabrication d’instance.
import matos . onde . DentBleu ;
public class PorteCharniere {
5
10
static PorteCharniere creerFerme ( ) {
PorteCharniere p = new PorteCharniere ( true ) ;
return p ;
}
static PorteCharniere creerOuvert ( ) {
return new PorteCharniere ( f a l se ) ;
}
27
private boolean estFerme ;
private f i n a l DentBleu maDent ;
15
private PorteCharniere ( boolean estFerme ) {
maDent = new DentBleu ( ) ;
i f ( estFerme )
fermer ( ) ;
else
ouvrir ( ) ;
}
20
public boolean estFerme ( ) {
return estFerme ;
}
25
public void fermer ( ) {
maDent . connecter ( ) ;
maDent . envoyer ( " pivoter_charniere " ) ;
maDent . deconnecter ( ) ;
estFerme = true ;
}
30
35
public void ouvrir ( ) {
maDent . connecter ( ) ;
maDent . envoyer ( " manoeuvrer_bec " ) ;
maDent . envoyer ( " pivoter_charniere " ) ;
maDent . deconnecter ( ) ;
estFerme = f a l se ;
}
40
public static void main ( String . . . args ) {
PorteCharniere a = PorteCharniere . creerOuvert ( ) ;
PorteCharniere . creerOuvert ( ) . estFerme ( ) ;
}
45
}
Un exemple d’action sur toutes les instances :
1 package
matos . onde ;
public class DentBleu {
private static java . i o . PrintWriter s o r t i e ;
6
11
16
static public void changerSortie ( java . i o . Writer s ) {
s o r t i e = new java . i o . PrintWriter ( s ) ;
}
static public void changerSortie ( ) {
s o r t i e = null ;
}
private void ecrireLog ( String ordre ) {
i f ( null == s o r t i e )
return ;
s o r t i e . p r i n t l n ( "[" + System . identityHashCode ( this ) + ", " + ordre + "]" ) ;
s o r t i e . flush ( ) ;
}
28
21
public void connecter ( ) {
ecrireLog ( " connexion " ) ;
// Todo: code de connexion
}
26
public void envoyer ( String commande) {
ecrireLog (commande ) ;
// Todo: code d'envoi de l'ordre
}
31
public void deconnecter ( ) {
ecrireLog ( " deconnexion " ) ;
// Todo: code de deconnexion
}
36
void r e i n i t i a l i s e r ( ) {
ecrireLog ( " reinitialisation " ) ;
// Todo: code de reinitialisation
}
41
}
// DentBleu . changerSortie (new java.io. OutputStreamWriter (System.out ));
// Que faut -il changer si ecrireLog () est une methode de classe ?
Pour simplifier l’écriture de l’appel à une variable de classe ou une méthode de
classe d’un autre paquetage, il est possible d’utiliser la déclaration import static
au début du fichier. Par exemple import static java.lang.Math.*; permet d’écrire directement PI dans le code (à la place de java.lang.Math.PI).
4.3
Statut de la classe en Java
Avec l’introduction des variables de classe et des méthodes de classe, la classe
n’est plus seulement une construction syntaxique. Elle peut être assimilée à la
notion de module mais aussi à la notion d’objet.
Dans le modèle objet, les objets sont les seules entités d’exécution. Si les classes
sont utilisables à l’exécution (envoi de messages), ce sont forcément des objets.
La classe est donc la mise en œuvre d’une encapsulation particulière décrivant
le service commun aux classes. Ce service fournit les informations sur ces déclarations/définitions contenues dans une classe : variables, portée, méthodes, constructeurs, liste de paramètres...
C’est le choix du langage Java :
– la description de l’encapsulation particulière class est définie dans la classe
java.lang.Class. Chaque classe Java est instance de java.lang.Class ;
– à l’exécution, une classe est représentée d’une manière unique par son fichier
.class 2 : System.out.println(tec.EtatPassager.class);
– Il est possible de définir des variables du type Class.
void a f f i c h e ( Class c ) {
System . out . p r i n t l n ( c ) ;
}
2. Ce fichier est chargé dynamiquement par la machine virtuelle Java et le compilateur
29
– Quelques opérations définies dans java.lang.Class :
– forName(String) permet de récupérer l’instance de Class correspondant au
nom complet en paramètre ;
– newInstance() permet d’instancier la classe qui reçoit ce message (en utilisant
le constructeur sans paramètre).
– getFields(), getMethods(), getSuperClass(), getConstructors() fournissent des
informations sur la définition d’une classe.
Ces opérations autorisent l’introspection des classes Java (voir les classes du
paquetage java.lang.reflect). L’introspection est une technique de réflexion qui permet à un programme d’examiner son propre état pendant l’exécution (mais pas de
le modifier).
Dans les classes de test, pour éviter d’oublier de compléter la méthode lancer(),
il suffit par introspection de récuperer à l’exécution toutes les méthodes dont le
nom commence par la sous-chaine test et de les exécuter.
public void runTest ( ) throws Exception {
Class c = this . getClass ( ) ;
java . lang . r e f l e c t . Method [ ] mesMethodes = c . getMethods ( ) ;
int nbTest = 0;
5
for ( int i = 0; i < mesMethodes . length ; i ++) {
java . lang . r e f l e c t . Method m = mesMethodes [ i ] ;
i f (m. getName ( ) . startsWith ( "test" ) ) {
System . out . p ri nt ( "." ) ;
m. invoke ( this ) ;
nbTest ++;
}
}
System . out . p r i n t l n ( "(" + nbTest + "):OK: " + getClass ( ) . getName ( ) ) ;
10
15
}
30