Developpez.com - Java
X

Choisissez d'abord la catégorieensuite la rubrique :


Chapitre 4 : La programmation orientée objet

13/10/2002

Par Jean-Michel Doudoux (autres articles)
 


4. La programmation orientée objet
4.1. Le concept de classe
4.1.1. La syntaxe de déclaration d'une classe
4.2. Les objets
4.2.1. La création d'un objet : instancier une classe
4.2.2. La durée de vie d'un objet
4.2.3. La création d'objets identiques
4.2.4. Les références et la comparaison d'objets
4.2.5. L'objet null
4.2.6. Les variables de classes
4.2.7. La variable this
4.2.8. L'opérateur instanceof
4.3. Les modificateurs d'accès
4.3.1. Les mots clés qui gèrent la visibilité des entités
4.3.2. Le mot clé static
4.3.3. Le mot clé final
4.3.4. Le mot clé abstract
4.3.5. Le mot clé synchronized
4.3.6. Le mot clé volatile
4.3.7. Le mot clé native
4.4. Les propriétés ou attributs
4.4.1. Les variables d'instances
4.4.2. Les variables de classes
4.4.3. Les constantes
4.5. Les méthodes
4.5.1. La syntaxe de la déclaration
4.5.2. La transmission de paramètres
4.5.3. L'emmission de messages
4.5.4. L'enchainement de références à des variables et à des méthodes
4.5.5. La surcharge de méthodes
4.5.6. La signature des méthodes et le polymorphisme
4.5.7. Les constructeurs
4.5.8. Le destructeur
4.5.9. Les accesseurs
4.6. L'héritage
4.6.1. Le principe de l'héritage
4.6.2. La mise en oeuvre de l'héritage
4.6.3. L'accès aux propriétés héritées
. Le transtypage induit par l'héritage facilitent le polymorphisme
4.6.5. La redéfinition d'une méthode héritée
4.6.6. Les interfaces et l'héritage multiple
4.6.7. Des conseils sur l'héritage
4.7. Les packages
4.7.1. La définition d'un package
4.7.2. L'utilisation d'un package
4.7.3. La collision de classes.
4.7.4. Les packages et l'environnement système
4.8. Les classes internes
4.8.1. Les classes internes non statiques
4.8.2. Les classes internes locales
4.8.3. Les classes internes anonymes
4.8.4. Les classes internes statiques
4.9. La gestion dynamique des objets


4. La programmation orientée objet


L'idée de base de la programmation orientée objet est de rassembler dans une même entité appelée objet les données et les traitements qui s'y appliquent.

Ce chapitre ce compose de plusieurs sections :

  • Le concept de classe
    Cette section présente le concept et la syntaxe de la déclaration d'une classe
  • Les objets
    Cette section présente la création d'un objet, sa durée de vie, le clonage d'objets, les références et la comparaison d'objets, l'objet null, les variables de classes, la variable this et l'opérateur instanceof.
  • Les modificateurs d'accès
    Cette section présente les modificateurs d'accès des entités classes, méthodes et attributs ainsi que les mots clés qui permettent de qualifier ces entités
  • Les propriétés ou attributs
    Cette section présente les données d'une classe : les propriétés ou attributs
  • Les méthodes
    Cette section présente la déclaration d'une méthode, la transmissions de paramètres, l'emmission de messages, la surcharge, la signature d'une méthode et le polymorphisme et des méthodes particulières : les constructeurs, le destructeur et les accesseurs
  • L'héritage
    Cette section présente l'héritage : son principe, sa mise en oeuvre, ces conséquences. Il présente aussi la redéfinition d'une méthode héritée et les interfaces
  • Les packages
    Cette section présente la définition et l'utilisation des packages
  • Les classes internes
    Cette section présente une extension du langage java qui permet de definir une classe dans une autre.
  • La gestion dynamique des objets
    Cette section présente rapidement la gestion dynamique des objets grace à l'introspection


4.1. Le concept de classe


Une classe est le support de l 'encapsulation : c'est un ensemble de données et de fonctions regroupées dans une même entité. Une classe est une description abstraite d'un objet. Les fonctions qui opèrent sur les données sont appelées des méthodes. Instancier une classe consiste à créer un objet sur son modèle. Entre classe et objet il y a, en quelque sorte, le même rapport qu'entre type et variable.

java est un langage orienté objet : tout appartient à une classe sauf les variables de type primitives.

Pour accéder à une classe il faut en déclarer une instance de classe ou objet.

Une classe comporte sa déclaration, des variables et la définition de ses méthodes.

Une classe se compose en deux parties : un en-tête et un corps. Le corps peut être divisé en 2 sections : la déclaration des données et des constantes et la définition des méthodes. Les méthodes et les données sont pourvues d'attributs de visibilité qui gère leur accessibilité par les composants hors de la classe.


4.1.1. La syntaxe de déclaration d'une classe


modificateurs nom_de_classe [extends classe_mere] [implements interface] { ... }

ClassModifiers class ClassName [extends SuperClass] [implemenents Interfaces] { // insérer ici les champs et les méthodes }
Les modificateurs de classe (ClassModifiers) sont :

Modificateur Rôle
abstract la classe contient une ou des méthodes abstraites, qui n'ont pas de définition explicite. Une classe déclarée abstract ne peut pas être instanciée : il faut définir une classe qui hérite de cette classe et qui implémente les méthodes nécessaires pour ne plus être abstraite.
final la classe ne peut pas être modifiée, sa redéfinition grace à l'héritage est interdite. Les classes déclarées final ne peuvent donc pas avoir de classes filles.
private la classe n'est accessible qu'à partir du fichier où elle est définie
public La classe est accessible partout
Les modificateurs abstract et final ainsi que public et private sont mutuellement exclusifs.

Le mot clé extends permet de spécifier une superclasse éventuelle : ce mot clé permet de préciser la classe mère dans une relation d'héritage.

Le mot clé implements permet de spécifier une ou des interfaces que la classe implémente. Cela permet de récupérer quelques avantages de l'héritage multiple.

L'ordre des méthodes dans une classe n'a pas d'importance. Si dans une classe, on rencontre d'abord la méthode A puis la méthode B, B peut être appelée sans problème dans A.


4.2. Les objets


Les objets contiennent des attributs et des méthodes. Les attributs sont des variables ou des objets nécessaires au fonctionnement de l'objet. En java, une application est un objet. La classe est la description d'un objet. Un objet est une instance d'une classe. Pour chaque instance d'une classe, le code est le même, seul les données sont différentes à chaque objet.


4.2.1. La création d'un objet : instancier une classe


Il est nécessaire de définir la déclaration d'une variable ayant le type de l'objet désiré. La déclaration est de la forme classe nom_de_variable

Exemple :
MaClasse m;
L'opérateur new se charge de créer une instance de la classe et de l'associer à la variable

Exemple :
m = new MaClasse();
Il est possible de tout reunir en une seule déclaration

Exemple :
MaClasse m = new MaClasse();
Chaque instance d'une classe nécessite sa propre variable. Plusieurs variables peuvent désigner un même objet.

En Java, tous les objets sont instanciés par allocation dynamique. Dans l'exemple, la variable m contient une référence sur l'objet instancié ( contient l'adresse de l'objet qu'elle désigne : attention toutefois, il n'est pas possible de manipuler ou d'effectuer des opérations directement sur cette adresse comme en C).

Si m2 désigne un objet de type MaClasse, l'instruction m2 = m ne définit pas un nouvel objet mais m et m2 désignent tous les deux le même objet.

L'opérateur new est un opérateur de haute priorité qui permet d'instancier des objets et d'appeler une méthode particulière de cet objet : le contructeur. Il fait appel à la machine virtuelle pour obtenir l'espace mémoire nécessaire à la représentation de l'objet puis appelle le constructeur pour initialiser l'objet dans l'emplacement obtenu. Il renvoie une valeur qui référence l'objet instancié.

Si l'opérateur new n'obtient pas l'allocation mémoire nécessaire il lève l'exception OutOfMemoryError.


Remarque sur les objets de type String : Un objet String est automatiquement créer lors de l'utilisation d'une constante chaine de caractères sauf si celle ci est déjà utilisée dans la classe. Ceci permet une simplification dans l'écriture des programmes.

Exemple :
String chaine = « bonjour » ; et String chaine = new String(« bonjour »); sont équivalents.

4.2.2. La durée de vie d'un objet


Les objets ne sont pas des éléments statiques et leur durée de vie ne correspond pas forcément à la durée d'exécution du programme.

La durée de vie d'un objet passe par trois étapes :

  • la déclaration de l'objet et l'instanciation grace à l'opérateur new

Exemple :
nom_de_classe nom_d_objet = new nom_de_classe( ... );

  • l'utilisation de l'objet en appelant ces méthodes
  • la suppression de l'objet : elle est automatique en java grace à la machine virtuelle. La restitution de la mémoire inutilisée est prise en charge par le récupérateur de mémoire (garbage collector). Il n'existe pas d'instruction delete comme en C++.


4.2.3. La création d'objets identiques


Exemple :
MaClasse m1 = new MaClasse(); MaClasse m2 = m1;
m1 et m2 contiennent la même référence et pointent donc tous les deux sur le même objet : les modifications faites à partir d'une des variables modifient l'objet.

Pour créer une copie d'un objet, il faut utiliser la méthode clone() : cette méthode permet de créer un deuxième objet indépendant mais identique à l'original. Cette méthode est héritée de la classe Object qui est la classe mère de toute les classes en Java.

Exemple :
MaClasse m1 = new MaClasse(); MaClasse m2 = m1.clone();
m1 et m2 ne contiennent plus la même référence et pointent donc sur des objets différents.


4.2.4. Les références et la comparaison d'objets


Les variables de type objet que l'on déclare ne contiennent pas un objet mais une référence vers cette objet. Lorque l'on écrit c1 = c2 (c1 et c2 sont des objets), on copie la référence de l'objet c2 dans c1 : c1 et c2 réfèrent au même objet (ils pointent sur le même objet). L'opérateur == compare ces références. Deux objets avec des propriétés identiques sont deux objets distincts :

Exemple :
Rectangle r1 = new Rectangle(100,50); Rectangle r2 = new Rectangle(100,50); if (r1 == r1) { ... } // vrai if (r1 == r2) { ... } // faux
Pour comparer l'égalité des variables de deux instances, il faut munir la classe d'un méthode à cette effet : la méthode equals héritée de Object.

Pour s'assurer que deux objets sont de la même classe, il faut utiliser la méthode getClass() de la classe Object dont toutes les classes héritent.

Exemple :
(obj1.getClass().equals(obj2.getClass())

4.2.5. L'objet null


L'objet null est utilisable partout. Il n'appartient pas à une classe mais il peut être utilisé à la place d'un objet de n'importe quelle classe ou comme paramètre. null ne peut pas etre utilisé comme un objet normal : il n'y a pas d'appel de méthodes et aucunes classes ne peut en hériter.

Le fait d'initialiser un variable référent un objet à null permet au ramasse miette de libérer la mémoire allouée à l'objet.


4.2.6. Les variables de classes


Elles ne sont définies qu'une seule fois quelque soit le nombre d'objets instanciés de la classe. Leur déclaration est accompagnée du mot clé static

Exemple :
public class MaClasse() { static int compteur = 0; }
L'appartenance des variables de classe à une classe entière et non à un objet spécifique permet de remplacer le nom de la variable par le nom de la classe.

Exemple :
MaClasse m = new MaClasse(); int c1 = m.compteur; int c2 = MaClasse.compteur; c1 et c2 possèdent la même valeur.
Ce type de variable est utile pour par exemple compter le nombre d'instanciation de la classe qui est faite.


4.2.7. La variable this


Cette variable sert à référencer dans une méthode l'instance de l'objet en cours d'utilisation. this est un objet qui est égale à l'instance de l'objet dans lequel il est utilisé.

Exemple :
private int nombre; public maclasse(int nombre) { nombre = nombre; // variable de classe = variable en paramètre du constructeur }
Il est préférable d'écrire

this.nombre = nombre;

Cette référence est habituellement implicite :

Exemple :
class MaClasse() { String chaine = « test » ; Public String getChaine() { return chaine) ; // est équivalent à public String getChaine (this.chaine); }
This est aussi utilisé quand l'objet doit appeler une méthode en se passant lui même en paramètre de l'appel.


4.2.8. L'opérateur instanceof


L'opérateur instanceof permet de déterminer la classe de l'objet qui lui est passé en paramètre. La syntaxe est objet instanceof classe

Exemple :
void testClasse(Object o) { if (o instanceof MaClasse ) System.out.println(« o est une instance de la classe MaClasse »); else System.out.println(« o n'est pas un objet de la classe MaClasse »); }
Il n'est toutefois pas possible d'appeler une méthode de l'objet car il est passé en paramètre avec un type Object

Exemple :
void afficheChaine(Object o) { if (o instanceof MaClasse) System.out.println(o.getChaine()); // erreur à la compil car la méthode getChaine() //n'est pas définie dans la classe Object }
Pour résoudre le problème, il faut utiliser la technique du casting (conversion).

Exemple :
void afficheChaine(Object o) { if (o instanceof MaClasse) { MaClasse m = (MaClasse) o; System.out.println(m.getChaine()); // OU System.out.println( ((MaClasse) o).getChaine() ); } }

4.3. Les modificateurs d'accès


Ils se placent avant ou après le type de l'objet mais la convention veut qu'ils soient placés avant.

Ils s'appliquent aux classes et/ou aux méthodes et/ou aux attributs.

Ils ne peuvent pas être utilisés pour qualifier des variables locales : seules les variables d'instances et de classes peuvent en profiter.

Ils assurent le contrôle des conditions d'héritage, d'accès aux éléments et de modification de données par les autres objets.


4.3.1. Les mots clés qui gèrent la visibilité des entités


De nombreux langages orientés objet introduisent des attributs de visibilité pour reglémenter l'accès aux classes et aux objets, aux méthodes et aux données.

Il existe 3 modificateurs qui peuvent être utilisés pour définir les attributs de visibilité des entités (classes, méthodes ou attributs) : public, private et protected. Leur utilisation permet de définir des niveaux de protection différents (présenté dans un ordre croissant de niveau de protection offert):

Modificateur Rôle
public Une variable, méthode ou classe déclarée public est visible par tout les autres objets. Dans la version 1.0, une seule classe public est permise par fichier et son nom doit correspondre à celui du fichier. Dans la philosophie orientée objet aucune donnée d'une classe ne devraient être déclarée publique : il est préférable d'écrire des méthodes pour la consulter et la modifier
par défaut :
package friendly
Il n'existe pas de mot clé pour définir ce niveau, qui est le niveau par défaut lorsqu'aucun modificateur n'est précisé. Cette déclaration permet à une entité (classe, méthode ou variable) d'être visible par toutes les classes se trouvant dans le même package.
protected Si une classe, une méthode ou une variable est déclarée protected , seules les méthodes présentes dans le même package que cette classe ou ses sous classes pourront y acceder. On ne peut pas qualifier une classe avec protected.
private C'est le niveau de protection le plus fort. Les composants ne sont visibles qu'à l'intérieur de la classe : ils ne peuvent être modifiés que par des méthodes définies dans la classe prévues à cet effet. Les méthodes déclarée private ne peuvent pas être en même temps déclarée abstract car elles ne peuvent pas être redéfinies dans les classes filles.
Ces modificateurs d'accès sont mutuellement exclusifs.


4.3.2. Le mot clé static


Le mot clé static s'applique aux variables et aux méthodes.

Les variables d'instance sont des variables propres à un objet. Il est possible de définir une variable de classe qui est partagée entre toutes les instances d'une même classe : elle n'existe donc qu'une seule fois. Une telle variable permet de stocker une constante ou une valeur modifiée tour à tour par les instances de la classe. Elle se définit avec le mot clé static.

Exemple :
public class Cercle { static float pi = 3.1416f; float rayon; public Cercle(float rayon) { this.rayon = rayon; } public float surface() { return rayon * rayon * pi;} }
Il est aussi possible par exemple de mémoriser les valeurs min et max d'un ensemble d'objet de même classe.

Une méthode static est une méthode qui n'agit pas sur des variables d'instance mais uniquement sur des variables de classe. Les méthodes ainsi définies peuvent être appelée avec la notation classe.méthode au lieu de objet.méthode. Ces méthodes peuvent être utilisées sans instancier un objet de la classe.

Il n'est pas possible d'appeler une méthode d'instance ou d'accéder à une variable d'instance à partir d'une méthode de classe statique


4.3.3. Le mot clé final


Le mot cle final s'applique aux variables, aux méthodes et aux classes.

Une variable qualifiée de final signifie que la variable est constante. Le compilateur ne contrôle ni n'empéche la modification. On ne peut déclarer de variables final locale à une méthode. Les constantes sont qualifiées de final et static

Exemple :
public static final float PI = 3.141f;
Une méthode final ne peut pas être redéfinie dans une sous classe. Une méthode possédant le modificateur final pourra être optimisée par le compilateur car il est garanti qu'elle ne sera pas sous classée.

Lorsque le modificateur final est ajouté à une classe, il est interdit de créer un classe qui en hérite.

Pour une méthode ou une classe, on renonce à l'héritage mais ceci peut s'avérer nécessaire pour des questions de sécurité ou de performance. Le test de validité de l'appel d'une méthode est bien souvent repoussé à l'éxécution, en fonction du type de l'objet appelé (c'est le polymorphisme). Ces tests ont un coup en terme de performance.


4.3.4. Le mot clé abstract


Le mot cle abstract s'applique aux méthodes et aux classes.

Abstract indique que la classe ne pourra être instanciée telle quelle. De plus, toutes les méthodes de cette classe abstract ne sont pas implémentées et devront être redéfinies par des méthodes complètes dans ses sous classes.

Abstract permet de créer une classe qui sera une sorte de moule. Toutes les classes dérivées pouront profiter des méthodes héritées et n'auront à implémenter que les méthodes déclarées abstract.

Exemple :
abstract class ClasseAbstraite { ClasseBastraite() { ... //code du constructeur } void méthode() { ... // code partagé par tous les descendants} abstract void méthodeAbstraite(); } class ClasseComplete extends ClasseAbstraite { ClasseComplete() { super(); ... } void méthodeAbstraite() { ... // code de la méthode } // void méthode est héritée }
Une méthode abstraite est une méthode déclarée avec le modificateur abstract et sans corps. Elle correspond à une méthode dont on veut forcer l'implémentation dans une sous classe. L'abstraction permet une validation du codage : une sous classe sans le modificateur abstract et sans définition explicite d'une ou des méthodes abstraites génère une erreur de compilation.

Une classe est automatiquement abstraite dès qu'une de ses méthodes est déclarée abstraite. Il est possible de définir une classe abstraite sans méthodes abstraites.


4.3.5. Le mot clé synchronized


Permet de gérer l'accès concurrent aux variables et méthodes lors de traitement de thread (exécution « simultanée » de plusieurs petites parties de code du programme)


4.3.6. Le mot clé volatile


Le mot cle volatile s'applique aux variables.

Précise que la variable peut être changée par un périphérique ou de manière asynchrone. Cela indique au compilateur de ne pas stocker cette variable dans des registres. A chaque utilisation, on lit la valeur et on réécrit immédiatement le résultat s'il a changé.


4.3.7. Le mot clé native


Une méthode native est une méthode qui est implémentée dans un autre langage. L'utilisation de ce type de méthode limite la portabilité du code mais permet une vitesse exécution plus rapide.


4.4. Les propriétés ou attributs


Les données d'une classe sont contenues dans les propriétés ou attributs. Ce sont des variables qui peuvent être des variables d'instances, des variables de classes ou des constantes.


4.4.1. Les variables d'instances


Une variable d'instance nécessite simplement une déclaration de la variable dans le corps de la classe.

Exemple :
public class MaClasse { public int valeur1 ; int valeur2 ; protected int valeur3 ; private int valeur4 ; }
Chaque instance de la classe a accès à sa propre occurrence de la variable.


4.4.2. Les variables de classes


Les variables de classes sont définies avec le mot clé static

Exemple (code java 1.1):
public class MaClasse { static int compteur ; }
Chaque instance de la classe partage la même variable.


4.4.3. Les constantes


Les constantes sont définies avec le mot clé final : leur valeur ne peut pas être modifiée.

Exemple (code java 1.1):
public class MaClasse { final double pi=3.14 ; }

4.5. Les méthodes


Les méthodes sont des fonctions qui implémentent les traitements de la classe.


4.5.1. La syntaxe de la déclaration


La syntaxe de la déclaration d'une méthode est :

modificateurs type_retourné nom_méthode ( arg1, ... ) {... } // définition des variables locales et du bloc d'instructions }
Le type retourné peut être élémentaire ou correspondre à un objet. Si la méthode ne retourne rien, alors on utilise void

Le type est le nombre d'arguments déclarés doivent correspondrent au type et au nombre d'arguments transmis. Il n'est pas possible d'indiquer des valeurs par défaut dans les paramètres. Les arguments sont passés par valeur : la méthode fait une copie de la variable qui lui est locale. Lorsqu'un objet est transmis comme argument à une méthode, cette dernière reçoit une référence qui désigne son emplacement mémoire d'origine et qui est une copie de la variable . Il est possible de modifier l'objet grace à ces méthodes mais il n'est pas possible de remplacer la référence contenue dans la variable passée en paramètre : ce changement n'aura lieu que localement à la méthode.
Les modificateurs de méthodes sont :

Modificateur Rôle
public la méthode est accéssible aux méthodes des autres classes
private l'usage de la méthode est réservée aux autres méthodes de la même classe
protected la méthode ne peut être invoquée que par des méthodes de la classe ou de ses sous classes
final la méthode ne peut être modifiée (redifinition lors de l'héritage interdite)
static la méthode appartient simultanément à tous les objets de la classe (comme une constante déclarée à l'intérieur de la classe). Il est inutile d'instancier la classe pour appeler la méthode mais la méthode ne peut pas manipuler de variable d'instance. Elle ne peut utiliser que des variables de classes.
synchronized la méthode fait partie d'un thread. Lorsqu'elle est appelée, elle barre l'accès à son instance. L'instance est à nouveau libérée à la fin de son éxécution.
native le code source de la méthode est écrit dans un autre langage
Sans modificateur, la méthode peut être appelée par toutes autres méthodes des classes du package auquel appartient la classe.

La valeur de retour de la méthode doit être transmise par l'instruction return. Elle indique la valeur que prend la méthode et termine celle ci : toutes les instructions qui suivent return sont donc ignorées.

exemple :
int add(int a, int b) { return a + b; }
Il est possible d'inclure une instruction return dans une méthode de type void : cela permet de quitter la méthode.

La méthode main() de la classe principale d'une application doit être déclarée de la façon suivante :

Déclaration d'une méthode main() :
public static void main (String args[]) { ... }
Si la méthode retourne un tableau alors les [] peuvent être préciser après le type de retour ou après la liste des paramètres :

exemple :
int[] valeurs() { ... } int valeurs()[] { ... }

4.5.2. La transmission de paramètres


Lorsqu'un objet est passé en paramètre, ce n'est pas l'objet lui même qui est passé mais une référence sur l'objet. La référence est bien transmise par valeur et ne peut pas être modifiée mais l'objet peut être modifié via un message (appel d'une méthode).

Pour transmettre des arguments par référence à une méthode, il faut les encapsuler dans un objet qui prévoit les méthodes nécessaires pour les mises à jour.

Si un objet o transmet sa variable d'instance v en paramètre à une méthode m, deux situations sont possibles :

  • si v est une variable primitive alors elle est passée par valeur : il est impossible de la modifier dans m pour que v en retour contiennent cette nouvelle valeur.
  • si v est un objet alors m pourra modifier l'objet en utilisant une méthode de l'objet passé en paramètre.


4.5.3. L'emmission de messages


Un message est émis lorsqu'on demande à un objet d'exécuter l'une de ses méthodes.

La syntaxe d'appelle d'une méthode est : nom_objet.nom_méthode(parametre, ... ) ;

Si la méthode appelée ne contient aucun paramètre, il faut laisser les parenthèses vides.


4.5.4. L'enchainement de références à des variables et à des méthodes


exemple :
System.out.Println("bonjour");
Deux classes sont impliqués dans l'instruction : System et PrintStream. La classe System possède une variable nommée out qui est un objet de type PrintStream. Println() est une méthode de la classe PrintStream. L'instruction signifie : « utilise la méthode Println() de la variable out de la classe System ».


4.5.5. La surcharge de méthodes


La surcharge d'une méthode permet de définir plusieurs fois une même méthode avec des arguments différents. Le compilateur choisi la méthode qui doit être appellée en fonction du nombre et du type des arguments. Ceci permet de simplifier l'interface des classes vis à vis des autres classes.

Une méthode est surchargée lorqu'elle exécute des actions différentes selon le type et le nombre de paramètres transmis.

exemple :
class affiche{ public void afficheValeur(int i) { System.out.pintln(« nombre entier = » + i); } public void afficheValeur(float f) { System.out.println(« nombre flottant = » + f); } }
Il n'est pas possible d'avoir deux méthodes de même nom dont tous les paramètres sont identiques et dont seul le type retourné diffère.

exemple :
class Affiche{ public float convert(int i){ return((float) i); } public double convert(int i){ return((double) i); } }
Résultat à la compilation :
C:\>javac Affiche.java Affiche.java:5: Methods can't be redefined with a different return type: double convert(int) was float convert(int) public double convert(int i){ ^ 1 error

4.5.6. La signature des méthodes et le polymorphisme


Il est possible de donner le même nom à deux méthodes différentes à condition que les signatures de ces deux méthodes soient différentes. La signature d'une méthode comprend le nom de la classe, le nom de la méthode et les types des paramètres. Cette facilité permet de mettre en oeuvre la polymorphisme.

Le polymorphisme est la capacité, pour un même message de correspondre à plusieurs formes de traitements selon l'objet auquel ce message est adressé. La gestion du polymorphisme est assurée par la machine virtuelle dynamiquement à l'exécution


4.5.7. Les constructeurs


La déclaration d'un objet est suivie d'une sorte d'initialisation par le moyen d'une méthode particulière appelée constructeur pour que les variables aient une valeur de départ. Elle n'est systématiquement invoquée que lors de la création d'un objet.

Le constucteur suit la définition des autres méthodes excepté que son nom doit obligatoirement correspondre à celui de la classe et qu'il n'est pas typé, pas même void, donc il ne peut pas y avoir d'instruction return dans un constructeur. On peut surcharger un constructeur.

La définition d'un constructeur est facultative. Si elle n'est pas définie, la machine virtuelle appelle un constructeur par défaut vide créé automatiquement. Dès qu'un constructeur est explicitement défini, Java considère que le programmeur prend en charge la création des constructeurs et que le mécanisme par défaut, qui correspond à un constructeur sans paramètres, est supprimé. Si on souhaite maintenir ce mécanisme, il faut définir explicitement un constructeur sans paramètres.

Il existe plusieurs manière de définir un constructeur :

  1. le constructeur simple : ce type de constructeur ne nécessite pas de définition explicite : son existence découle automatiquement de la définition de la classe.
  2. Exemple :
    public MaClasse() {}
  3. le constructeur avec initialisation fixe : il permet de créer un constructeur par défaut
  4. Exemple :
    public MaClasse() { nombre = 5; }
  5. le constructeur avec initialisation des variables : pour spécifier les valeurs de données à initialiser on peut les passer en paramètres au constructeur
  6. Exemple :
    public MaClasse(int valeur) { nombre = valeur; }


4.5.8. Le destructeur


Un destructeur permet d'éxécuter du code lors de la libération de la place mémoire occupée par l'objet. En java, les destructeurs appellés finaliseurs (finalizers), sont automatiquement appellés par le garbage collector.

Pour créer un finaliseur, il faut redéfinir la méthode finalize() héritée de la classe Object.


4.5.9. Les accesseurs


L'encapsulation permet de sécuriser l'accès aux données d'une classe. Ainsi, les données déclarées private à l'intérieur d'une classe ne peuvent être accédées et modifiées que par des méthodes définies dans la même classe. Si une autre classe veut accéder aux données de la classe, l'opération n'est possible que par l'intermédiaire d'une méthode de la classe prévue à cet effet. Ces appels de méthodes sont appelés « échanges de message ».

Un accesseur est une méthode publique qui donne l'accès à une variable d'instance privée. Pour une variable d'instance, il peut ne pas y avoir d'accesseur, un seul accesseur en lecture ou un accesseur en lecture et un en écriture. Par convention, les accesseurs en lecture commencent par get et les accesseurs en écriture commencent par set.

Exemple :
private int valeur = 13; public int getValeur(){ return(valeur); } public void setValeur(int val) { valeur = val; }

4.6. L'héritage



4.6.1. Le principe de l'héritage


L'héritage est un mécanisme qui facilite la réutilisation du code et la gestion de son évolution.

Grace à l'heritage, les objets d'une classe ont accès aux données et aux méthodes de la classe parent et peuvent les étendre. Les sous classes peuvent redéfinir les variables et les méthodes héritées. Pour les variables, il suffit de les redéclarer sous le même nom avec un type différent. Les méthodes sont redéfinies avec le même nom, les mêmes types et le même nombre d'arguments, sinon il s'agit d'une surcharge.

L'héritage successif de classes permet de définir une hiérarchie de classe qui ce compose de super classes et de sous classes. Une classe qui hérite d'une autre est une sous classe et celle dont elle hérite est une super classe. Une classe peut avoir plusieurs sous classes. Une classe ne peut avoir qu'une seule classe mère : il n'y a pas d'héritage multiple en java.

Object est la classe parente de toutes les classes en java. Toutes les variables et méthodes contenues dans Object sont accessibles à partir de n'importe quelle classe car par héritage succéssif toutes les classes héritent d'Object.


4.6.2. La mise en oeuvre de l'héritage


On utilise le mot clé extends pour indiquer qu'une classe hérite d'une autre. En l'absence de ce mot réservé associé à une classe, le compilateur considère la classe Object comme classe parent.

Exemple :
class Fille extends Mere { ... }
Pour invoquer une méthode d'une classe parent, il suffit d'indiquer la méthode préfixée par super. Pour appeler le constructeur de la classe parent il suffit d'écrire super(paramètres) avec les paramètres adéquats.

Le lien entre une classe fille et une classe parent est géré par le langage : une évolution des règles de gestion de la classe parent conduit à modifier automatiquement la classe fille dès que cette dernière est recompilée.

En java, il est obligatoire dans un constructeur d'une classe fille de faire appel explicitement ou implicitement au constructeur de la classe mère.


4.6.3. L'accès aux propriétés héritées


Les variables et méthodes définies avec le modificateur d'accès public restent publiques à travers l'héritage et toutes les autres classes.

Une variable d'instance définie avec le modificateur private est bien héritée mais elle n'est pas accessible directement mais via les méthodes héritées.

Si l'on veut conserver pour une variable d'instance une protection semblable à celle assurée par le modificateur private, il faut utiliser le modificateur protected. La variable ainsi définie sera hérité dans toutes les classes descendantes qui pourront y accéder librement mais ne sera pas accessible hors de ces classes directement.


. Le transtypage induit par l'héritage facilitent le polymorphisme


L'héritage définit un cast implicite de la classe fille vers la classe mere : on peut affecter à une référence d'une classe n'importe quel objet d'une de ses sous classes.

Exemple : la classe Employe hérite de la classe Personne
Personne p = new Personne («Dupond», «Jean»); Employe e = new Employe(«Durand», «Julien», 10000); p = e ; // ok : Employe est une sous classe de Personne Objet obj; obj = e ; // ok : Employe herite de Personne qui elle même hérite de Object
Il est possible d'écrire le code suivant si Employe hérite de Personne

Exemple : la classe Employe hérite de la classe Personne
Personne[] tab = new Personne[10]; tab[0]:= new Personne( «Dupond»,«Jean»); tab[1]:= new Employe(«Durand», «Julien», 10000);
Il est possible de surcharger une méthode héritée : la forme de la méthode à éxécuter est choisie en fonction des paramètres associés à l'appel.

Compte tenu du principe de l'héritage, le temps d'exécution du programme et la taille du code source et de l'éxécutable augmentent


4.6.5. La redéfinition d'une méthode héritée


La redéfinition d'une méthode héritée doit impérativement conserver la déclaration de la méthode parent (type et nombre de paramètres, la valeur de retour et les exceptions propagées doivent être identique).

Si la signature de la méthode change, ce n'est plus une redéfinition mais une surcharge. Cette nouvelle méthode n'est pas héritée : la classe mere ne possède pas de méthode possédant cette signature.


4.6.6. Les interfaces et l'héritage multiple


Avec l'héritage multiple, une classe peut hériter en même temps de plusieurs super classes. Ce mécanisme n'existe pas en java. Les interfaces permettent de mettre en oeuvre un mécanisme de remplacement.

Une interface est un ensemble de constantes et de déclarations de méthodes correspondant un peu à une classe abstraite. C'est une sorte de standard auquel une classe peut répondre. Tous les objets qui se conforment à cette interface (qui implémentent cette interface) possèdent les méthodes et les constantes déclarée dans celle-ci. Plusieurs interfaces peuvent être implémentées dans une même classe.

Les interfaces se déclarent avec le mot cle interface et sont intégrées aux autres classes avec le mot clé implements. Une interface est implicitement déclarée avec le modificateur abstract.

Déclaration d'une interface :
[public] interface nomInterface [extends nomInterface1, nomInterface2 ... ] { // insérer ici des méthodes ou des champs static }
Implémentation d'une interface :
Modificateurs class nomClasse [extends superClasse] [implements nomInterface1, nomInterface 2, ...] { //insérer ici des méthodes et des champs }
Implémentation d'une interface :
interface AfficheType { void AfficheType(); } class Personne implements AfficheType { public void afficheType() { System.out.println(« Je suis une personne »); } } class Voiture implements AfficheType { public void afficheType() { System.out.println(« Je suis une voiture »); } }
Exemple : déclaration d'un interface à laquelle doit se conformer tout individus
interface Individu { String getNom(); String getPrenom(); Date getDateNaiss(); }
Toutes les méthodes d'une interface sont publiques et abstraites : elles sont implicitement déclarées comme telles.

Une interface peut être d'accès public ou package. Si elle est publique, toutes ses méthodes sont publiques même si elles ne sont pas déclarées avec le modificateur public. Si elle est d'accès package, il s'agit d'une interface d'implémentation pour les autres classes du package et ses méthodes ont le même accès package : elles sont accessible à toutes les classes du packages.

Les seules variables que l'on peut définir dans une interface sont des variables de classe qui doivent être constantes : elles sont donc implicitement déclarées avec le modificateur static et final même si elles sont définies avec d'autres modificateurs.

Toute classe qui implémente cette interface doit au moins posséder les méthodes qui sont déclarées dans l'interface. L'interface ne fait que donner une liste de méthodes qui seront à définir dans les classes qui implémentent l'interface.

Les méthodes déclarées dans une interface publique sont implicitement publiques et elles sont héritées par toutes les classes qui implémentent cette interface. Une tel classe doit, pour être instanciable, définir toutes les méthodes héritées de l'interface.

Une classe peut implémenter une ou plusieurs interfaces tout en héritant de sa classe mère.

L'implémentation d'une interface définit un cast : l'implémentation d'une interface est une forme d'héritage. Comme pour l'héritage d'une classe, l'héritage d'une classe qui implémente une interface définit un cast implicite de la classe fille vers cette interface. Il est important de noter que dans ce cas il n'est possible de faire des appels qu'à des méthodes de l'interface. Pour utiliser des méthodes de l'objet, il faut définir un cast explicite : il est préférable de controler la classe de l'objet pour éviter une exception ClassCastException à l'éxecution


4.6.7. Des conseils sur l'héritage


Lors de la création d'une classe « mère » il faut tenir compte des points suivants :

  • la définition des accès aux variables d'instances, très souvent privées, doit être réfléchie entre protected et private
  • pour empecher la redéfinition d'une méthode (surcharge) il faut la déclarer avec le modificateur final

Lors de la création d'une classe fille, pour chaque méthode héritée qui n'est pas final, il faut envisager les cas suivant

  • la méthode héritée convient à la classe fille : on ne doit pas la redéfinir
  • la méthode héritée convient mais partiellement du fait de la spécialisation apportée par la classe fille : il faut la redéfinir voir la surcharger. La plupart du temps une redéfinition commencera par appeler la méthode héritée (via super) pour garantir l 'évolution du code
  • la méthode héritée ne convient pas : il faut redéfinir ou surcharger la méthode sans appeler la méthode héritée lors de la redéfinition.


4.7. Les packages



4.7.1. La définition d'un package


En java, il existe un moyen de regrouper des classe voisines ou qui couvrent un même domaine : ce sont les packages. Pour réaliser un package, on écrit un nombre quelconque de classes dans plusieurs fichiers d'un même repertoire et au début de chaque fichier on met la directive ci dessous ou nom-du-package doit être identique au nom du répertoire :

package nomPackage;

La hiérarchie d'un package se retrouve dans l'arborescence du disque dur puisque chaque package est dans un répertoire nommé du nom du package.


Remarque : Il est préférable de laisser les fichiers source .java avec les fichiers compilés .class

D'une façon générale, l'instruction package associe toutes les classes qui sont définies dans un fichier source à un même package.

Le mot clé package doit être la première instruction dans un fichier source et il ne doit être présent qu'une seule fois dans le fichier source (une classe ne peut pas appartenir à plusieurs packages).


4.7.2. L'utilisation d'un package


Pour utiliser ensuite le package ainsi créé, on l'importe dans le fichier :

import nomPackage.*;

Pour importer un package, il y a trois méthodes si le chemin de recherche est correctement renseigné :

Exemple Rôle
import nomPackage; les classes ne peuvent pas être simplement désignées par leur nom et il faut aussi préciser le nom du package
import nomPackage.*; toutes les classes du package sont importées
import nomPackage.nomClasse; appel à une seule classe : l'avantage de cette notation est de réduire le temps de compilation

Attention : l'astérisque n'importe pas les sous paquetages. Par exemple, il n'est pas possible d'écrire import java.*.

Il est possible d'appeler une méthode d'un package sans inclure ce dernier dans l'application en precisant son nom complet :

nomPackage.nomClasse.nomméthode(arg1, arg2 ... )

Il existe plusieurs types de packages : le package par défaut (identifié par le point qui représente le répertoire courant et permet de localiser les classes qui ne sont pas associées à un package particulier), les packages standards qui sont empaquetés dans le fichier classes.zip et les packages personnels

Le compilateur implémente automatiquement une commande import lors de la compilation d'un programme Java même si elle ne figure pas explicitement au début du programme : import java.lang.*; Ce package contient entre autre les classes de base de tous les objets java dont la classe Object.

Un package par défaut est systématiquement attribué par le compilateur aux classes qui sont définies sans déclarer explicitement une appartenance à un package. Ce package par défaut correspond au répertoire courant qui est le répertoire de travail.


4.7.3. La collision de classes.


Deux classes entre en collision lorsqu'elles portent le même nom mais qu'elles sont définies dans des packages différents. Dans ce cas, il faut qualifier explicitement le nom de la classe avec le nom complet du package.


4.7.4. Les packages et l'environnement système


Les classes Java sont importées par le compilateur (au moment de la compilation) et par la machine virtuelle (au moment de l'éxécution). Les techniques de chargement des classes varient en fonction de l'implémentation de la machine virtuelle. Dans la plupart des cas, une variable d'environnement CLASSPATH référence tous les répertoires qui hébergent des packages succeptibles d'être importés.

Exemple sous Windows :

CLASSPATH = .;C:\Java\JDK\Lib\classes.zip; C:\rea_java\package

L'importation des packages ne fonctionne que si le chemin de recherche spécifié dans une variable particulière pointe sur les packages, sinon le nom du package devra refléter la structure du répertoire ou il se trouve. Pour déterminer l'endroit où se trouvent les fichiers .class à importer, le compilateur utilise une variable d'environnement dénommée CLASSPATH. Le compilateur peut lire les fichiers .class comme des fichiers indépendants ou comme des fichiers ZIP dans lesquels les classes sont reunies et compressées.


4.8. Les classes internes


Les classes internes (inner classes) sont une extension du langage java introduite dans la version 1.1 du JDK. Ce sont des classes qui sont définies dans une autre classe. Les difficultés dans leur utilisation concerne leur visibilité et leur accès aux membres de la classe dans laquelle elles sont définies.

Exemple très simple :
public class ClassePrincipale1 { class ClasseInterne { } }
Les classes internes sont particulièrement utiles pour :

  • permettre de définir une classe à l'endroit ou une seule autre en a besoin
  • définir des classes de type adapter (essentiellement à partir du JDK 1.1 pour traiter des évenements émis par les interfaces graphiques)
  • définir des méthodes de type callback d'une façon générale

Pour permettre de garder une compatibilité avec la version précédente de la JVM, seul le compilateur a été modifié. Le compilateur interprète la syntaxe des classes internes pour modifier le code source et générer du byte code compatible avec la première JVM.

Il est possible d'imbriquer plusieurs classes internes. Java ne possèdent pas de restrictions sur le nombre de classes qu'il est ainsi possible d'imbriquer. En revanche une limitation peut intervenir au niveau du système d'exploitation en ce qui concerne la longueur du nom du fichier .class généré pour les différentes classes internes.

Si plusieurs classes internes sont imbriquées, il n'est pas possible d'utiliser un nom pour la classe qui soit déjà attribuée à une de ces classes englobantes. Le compilateur génèrera une erreur à la compilation.

Exemple :
public class ClassePrincipale6 { class ClasseInterne1 { class ClasseInterne2 { class ClasseInterne3 { } } } }
Le nom de la classe interne utilise la notation qualifié avec le point préfixé par le nom de la classe principale. Ainsi, pour utiliser ou accéder à une classe interne dans le code, il faut la préfixer par le nom de la classe principale suivi d'un point.

Cependant cette notation ne représente pas physiquement le nom du fichier qui contient le byte code. Le nom du fichier qui contient le byte code de la classe interne est modifié par le compilateur pour éviter des conflits avec d'autres nom d'entité : à partir de la classe principale, les points de séparation entre chaque classe interne sont remplacé par un caractère $ (dollard).

Par exemple, la compilation du code de l'exemple précédent génère quatres fichiers contenant le byte code : ClassePrincipale6$ClasseInterne1$ClasseInterne2ClasseInterne3.class
ClassePrincipale6$ClasseInterne1$ClasseInterne2.class
ClassePrincipale6$ClasseInterne1.class
ClassePrincipale6.class

L'utilisation du signe $ entre la classe principale et la classe interne permet d'éviter des confusions de nom entre le nom d'une classe appartenant à un package et le nom d'une classe interne.

L'avantage de cette notation est de créer un nouvel espace de nommage qui dépend de la classe et pas d'un package. Ceci renforce le lien entre la classe interne et sa classe englobante.

C'est le nom du fichier qu'il faut préciser lorsque l'on tente de charger la classe avec la méthode forName() de la classe Class. C'est aussi sous cette forme qu'est restitué le résultat d'un appel aux méthodes getClass().getName() sur un objet qui est une classe interne.

Exemple :
public class ClassePrincipale8 { public class ClasseInterne { } public static void main(String[] args) { ClassePrincipale8 cp = new ClassePrincipale8(); ClassePrincipale8.ClasseInterne ci = cp. new ClasseInterne() ; System.out.println(ci.getClass().getName()); } }
Resultat :
java ClassePrincipale8 ClassePrincipale8$ClasseInterne
L'accessibilité à la classe interne respecte les règles de visibilité du langage. Il est même possible de définir une classe interne private pour limiter son accès à sa seule classe principale.

Exemple :
public class ClassePrincipale7 { private class ClasseInterne { } }
Il n'est pas possible de déclarer des membres statiques dans une classe interne :

Exemple :
public class ClassePrincipale10 { public class ClasseInterne { static int var = 3; } }
Resultat :
javac ClassePrincipale10.java ClassePrincipale10.java:3: Variable var can't be static in inner class ClassePri ncipale10. ClasseInterne. Only members of interfaces and top-level classes can be static. static int var = 3; ^ 1 error
Pour pouvoir utiliser une variable de classe dans une classe interne, il faut la déclarer dans sa classe englobante.

Il existe quatres types de classes internes :

  • les classes internes non statiques : elles sont membres à part entière de la classe qui les englogent et peuvent accéder à tous les membres de cette dernière
  • les classes internes locales : elles sont définies dans un block de code. Elles peuvent être static ou non.
  • les classes internes anonymes : elles sont définies et instanciées à la volée sans posséder de nom
  • les classe internes statiques : elles sont membres à part entière de la classe qui les englogent et peuvent accéder uniquement aux membres statiques de cette dernière


4.8.1. Les classes internes non statiques


Les classes internes non statiques (member inner-classes) sont définies dans une classe dite " principale " (top-level class) en tant que membre de cette classe. Leur avantage est de pouvoir accéder aux autres membres de la classe principale même ceux déclarés avec le modificateur private.

Exemple :
public class ClassePrincipale20 { private int valeur = 1; class ClasseInterne { public void afficherValeur() { System.out.println("valeur = "+valeur); } } public static void main(String[] args) { ClassePrincipale20 cp = new ClassePrincipale20(); ClasseInterne ci = cp. new ClasseInterne(); ci.afficherValeur(); } }
Resultat :
C:\testinterne>javac ClassePrincipale20.java C:\testinterne>java ClassePrincipale20 valeur = 1
Le mot clé this fait toujours référence à l'instance en cours. Ainsi this.var fait référence à la variable var de l'instance courante. L'utilisation du mot clé this dans une classe interne fait donc référence à l'instance courante de cette classe interne.

Exemple :
public class ClassePrincipale16 { class ClasseInterne { int var = 3; public void affiche() { System.out.println("var = "+var); System.out.println("+this.var); } } ClasseInterne ci = this. new ClasseInterne(); public static void main(String[] args) { ClassePrincipale16 cp = new ClassePrincipale16(); ClasseInterne ci = cp. new ClasseInterne(); ci.affiche(); } }
Resultat :
C:\>java ClassePrincipale16 var = 3 this.var = 3
Une classe interne a accès à tous les membres de sa classe principale. Dans le code, pour pouvoir faire référence à un membre de la classe principale, il suffit simplement d'utiliser son nom de variable.

Exemple :
public class ClassePrincipale17 { int valeur = 5; class ClasseInterne { int var = 3; public void affiche() { System.out.println("var = "+var); System.out.println("+this.var); System.out.println("valeur = "+valeur); } } ClasseInterne ci = this. new ClasseInterne(); public static void main(String[] args) { ClassePrincipale17 cp = new ClassePrincipale17(); ClasseInterne ci = cp. new ClasseInterne(); ci.affiche(); } }
Resultat :
C:\testinterne>java ClassePrincipale17 var = 3 this.var = 3 valeur = 5
La situation se complique un peu plus, si la classe principale et la classe interne possède tous les deux un membre de même nom. Dans ce cas, il faut utiliser la version qualifée du mot clé this pour accéder au membre de la classe principale. La qualification se fait avec le nom de la classe principale ou plus généralement avec le nom qualifié d'une des classes englobantes.

Exemple :
public class ClassePrincipale18 { int var = 5; class ClasseInterne { int var = 3; public void affiche() { System.out.println("var = "+var); System.out.println("+this.var); System.out.println("ClassePrincipale18. +ClassePrincipale18.this.var); } } ClasseInterne ci = this. new ClasseInterne(); public static void main(String[] args) { ClassePrincipale18 cp = new ClassePrincipale18(); ClasseInterne ci = cp. new ClasseInterne(); ci.affiche(); } }
Resultat :
C:\>java ClassePrincipale18 var = 3 this.var = 3 ClassePrincipale18.this.var = 5
Comme une classe interne ne peut être nommée du même nom que l'une de ces classes englobantes, ce nom qualifié est unique et il ne risque pas d'y avoir de confusion.

Le nom qualifié d'une classe interne est nom_classe_principale.nom_classe_interne. C'est donc le même principe que celui utilisé pour qualifié une classe contenue dans un package. La notation avec le point est donc légèrement étendue.

L'accès au membre de la classe principale est possible car le compilateur modifie le code de la classe principale et celui de la classe interne pour fournir à la classe interne une référence sur la classe principale.

Le code de la classe interne est modifié pour :

  • ajouter une variable privée finale du type de la classe principale nommée this$0
  • ajouter un paramètre supplémentaire dans le constructeur qui sera la classe principale et qui va initialiser la variable this$0
  • utiliser cette variable pour préfixer les attributs de la classe principale utilisés dans la classe interne.

La code de la classe principale est modifié pour :

  • ajouter une méthode static pour chaque champ de la classe principale qui attend en paramètre un objet de la classe principale. Cette méthode renvoie simplement la valeur du champ. Le nom de cette méthode est de la forme access$0
  • modifier le code d'instanciation de la classe interne pour appeler le constructeur modifié

Dans le byte code généré, une variable privée finale contient une référence vers la classe principale. Cette variable est nommée this$0. Comme elle est générée par le compilateur, cette variable n'est pas utilisable dans le code source. C'est à partir de cette référence que le compilateur peut modifier le code pour accéder aux membres de la classe principale.

Pour pouvoir avoir acces aux membres de la classe principale, le compilateur génère dans la classe principale des accesseurs sur ces membres. Ainsi, dans la classe interne, pour accéder à un membre de la classe principale, le compilateur appelle un de ces accesseurs en utilisant la référence stockée. Ces méthodes ont un nom de la forme access$numero_unique et sont bien sûre inutilisables dans le code source puisqu'elles sont générées par le compilateur.

En tant que membre de la classe principale, une classe interne peut être déclarée avec le modificateur private ou protected.

Une classe peut faire référence dans le code source à son unique instance lors de l'éxécution via le mot clé this. Une classe interne possède au moins deux références :

  • l'instance de la classe interne elle même
  • éventuellement les instances des classes internes dans laquelle la classe interne est imbriquée
  • l'instance de sa classe principale

Dans la classe interne, il est possible pour accéder à une de ces instances d'utiliser le mot clé this préfixé par le nom de la classe suivi d'un point :
nom_classe_principale.this
nom_classe_interne.this

Le mot this seul désigne toujours l'instance de la classe courante dans son code source, donc this seul dans une classe interne désigne l'instance de cette classe interne.

Une classe interne non statique doit toujours être instanciée relativement à un objet implicite ou explicite du type de la classe principale. A la compilation, le compilateur ajoute dans la classe interne une référence vers la classe principale contenu dans une variable privée nommée this$0. Cette référence est initialisée avec un paramètre fourni au constructeur de la classe interne. Ce mécanisme permet de lier les deux instances.

La création d'une classe interne nécessite donc obligatoirement une instance de sa classe principale. Si cette instance n'est pas accessible, il faut en créer une et utiliser une notation particulière de l'opérateur new pour pouvoir instancier la classe interne. Par défaut, lors de l'instanciation d'une classe interne, si aucune instance de la classe principale n'est utilisée, c'est l'instance courante qui est utilisée (mot clé this).

Exemple :
public class ClassePrincipale14 { class ClasseInterne { } ClasseInterne ci = this. new ClasseInterne(); }
Pour créer une instance d'une classe interne dans une méthode statique de la classe principale, (la méthode main() par exemple), il faut obligatoirement instancier un objet de la classe principale avant et utiliser cet objet lors de la création de l'instance de la classe interne. Pour créer l'instance de la classe interne, il faut alors utiliser une syntaxe particulière de l'opérateur new.

Exemple :
public class ClassePrincipale15 { class ClasseInterne { } ClasseInterne ci = this. new ClasseInterne(); static void maMethode() { ClassePrincipale15 cp = new ClassePrincipale15(); ClasseInterne ci = cp. new ClasseInterne(); } }
Il est possible d'utiliser une syntaxe condensée pour créer les deux instances en une seul et même ligne de code.

Exemple :
public class ClassePrincipale19 { class ClasseInterne { } static void maMethode() { ClasseInterne ci = new ClassePrincipale19(). new ClasseInterne(); } }
Une classe peut hériter d'une classe interne. Dans ce cas, il faut obligatoirement fournir aux contructeurs de la classe une référence sur la classe principale de la classe mère et appeler explicitement dans le constructeur le constructeur de cette classe principale avec une notation particulière du mot clé super

Exemple :
public class ClassePrincipale9 { public class ClasseInterne { } class ClasseFille extends ClassePrincipale9.ClasseInterne { ClasseFille(ClassePrincipale9 cp) { cp. super(); } } }
Une classe interne peut être déclarée avec les modificateurs final et abstract. Avec le modificateur final, la classe interne ne pourra être utilisée comme classe mère. Avec le modificateur abstract, la classe interne devra être étendue pour pouvoir être instanciée.


4.8.2. Les classes internes locales


Ces classes internes locales (local inner-classes) sont définies à l'intérieure d'une méthode ou d'un bloc de code. Ces classes ne sont utilisables que dans le bloc de code où elles sont définies. Les classes internes locales ont toujours accès aux membres de la classe englobante.

Exemple :
public class ClassePrincipale21 { int varInstance = 1; public static void main(String args[]) { ClassePrincipale21 cp = new ClassePrincipale21(); cp.maMethode(); } public void maMethode() { class ClasseInterne { public void affiche() { System.out.println("varInstance = " + varInstance); } } ClasseInterne ci = new ClasseInterne(); ci.affiche(); } }
Resultat :
C:\testinterne>javac ClassePrincipale21.java C:\testinterne>java ClassePrincipale21 varInstance = 1
Leur particularité, en plus d'avoir un accès aux membres de la classe principale, est d'avoir aussi un accès à certaines variables locales du bloc ou est définie la classe interne.

Ces variables définies dans la méthode (variables ou paramètres de la méthode) sont celles qui le sont avec le mot clé final. Ces variables doivent être initialisée avant leur utilisation par la classe interne. Celles ci sont utilisables n'importe ou dans le code de la classe interne.

Le modificateur final désigne une variable dont la valeur ne peut être changée une fois qu'elle a été initialisée.

Exemple :
public class ClassePrincipale12 { public static void main(String args[]) { ClassePrincipale12 cp = new ClassePrincipale12(); cp.maMethode(); } public void maMethode() { int varLocale = 3; class ClasseInterne { public void affiche() { System.out.println("varLocale = " + varLocale); } } ClasseInterne ci = new ClasseInterne(); ci.affiche(); } }
Resultat :
javac ClassePrincipale12.java ClassePrincipale12.java:14: Attempt to use a non-final variable varLocale from a different method. From enclosing blocks, only final local variables are availab le. System.out.println("varLocale = " + varLocale); ^ 1 error
Cette restriction est imposée par la gestion du cycle de vie d'une variable locale. Une telle variable n'existe que durant l'éxécution de cette méthode. Une variable finale est une variable dont la valeur ne peut être modifiée après son initialisation. Ainsi, il est possible sans risque pour le compilateur d'ajouter un membre dans la classe interne et de copier le contenu de la variable finale dedans.

Exemple :
public class ClassePrincipale13 { public static void main(String args[]) { ClassePrincipale13 cp = new ClassePrincipale13(); cp.maMethode(); } public void maMethode() { final int varLocale = 3; class ClasseInterne { public void affiche(final int varParam) { System.out.println("varLocale = " + varLocale); System.out.println("varParam = " + varParam); } } ClasseInterne ci = new ClasseInterne(); ci.affiche(5); } }
Resultat :
C:\>javac ClassePrincipale13.java C:\>java ClassePrincipale13 varLocale = 3 varParam = 5
Pour permettre à une classe interne locale d'accéder à une variable locale utilisée dans le bloc de code ou est définie la classe interne, la variable doit être stockée dans un endroit ou la classe interne pourra y accéder. Pour que cela fonctionne, le compilateur ajoute les variables nécessaires dans le constructeur de la classe interne.

Les variables accédées sont dupliquées dans la classe interne par le compilateur. Il ajoute pour chaque variable un membre privé dans la classe interne dont le nom est de la forme val$nom_variable. Comme la variable accédée est déclarée finale, cette copie peut être faite sans risque. La valeur de chacune de ces variables est fournie en paramètre du constructeur qui a été modifié par le compilateur.

Une classe qui est définie dans un bloc de code n'est pas un membre de la classe englobante : elle n'est donc pas accessible en dehors du bloc de code ou elle est définie. Ces restrictions sont équivalentes à la déclaration d'une variable dans un bloc de code.

Les variables ajoutées par le compilateur sont préfixées par this$ et val$. Ces variables et le constructeur modifié par le compilateur ne sont pas utilisables dans le code source.

Etant visible uniquement dans le bloc de code qui la définie, une classe interne locale ne peut pas utiliser les modificateurs public, private, protected et static dans sa définition. Leur utilisation provoque une erreur à la compilation.

Exemple :
public class ClassePrincipale11 { public void maMethode() { public class ClasseInterne { } } }
Resultat :
javac ClassePrincipale11.java ClassePrincipale11.java:2: '}' expected. public void maMethode() { ^ ClassePrincipale11.java:3: Statement expected. public class ClasseInterne { ^ ClassePrincipale11.java:7: Class or interface declaration expected. } ^ 3 errors

4.8.3. Les classes internes anonymes


Les classes internes anonymes (anonymous inner-classes) sont des classes internes qui ne possèdent pas de nom. Elles ne peuvent donc être instanciées qu'à l'endroit ou elles sont définies.

Ce type de classe est très pratique lorsqu'une classe doit être utilisée une seule fois : c'est par exemple le cas d'une classe qui doit être utilisée comme un callback.

Une syntaxe particulière de l'opérateur new permet de déclarer et instancier une classe interne :

new classe_ou_interface () { // définition des attributs et des méthodes de la classe interne }
Cette syntaxe particulière utilise le mot clé new suivi d'un nom de classe ou interface que la classe interne va respectivement étendre ou implémenter. La définition de la classe suit entre deux accolades. Une classe interne anonyme peut soit hériter d'une classe soit implémenter une interface mais elle ne peut pas explicitement faire les deux.

Si la classe interne étend une classe, il est possible de fournir des paramètres entre les parenthèses qui suivent le nom de la classe. Ces arguments éventuels fournis au moment de l'utilisation de l'opérateur new sont passés au constructeur de la super classe. En effet, comme la classe ne possède pas de nom, elle ne possède pas non plus de constructeur.

Les classes internes anonymes qui implémentent une interface héritent obligatoirement de classe Object. Comme cette classe ne possèdent qu'un constructeur sans paramètre, il n'est pas possible lors de l'instanciation de la classe interne de lui fournir des paramètres.

Une classe interne anonyme ne peut pas avoir de constructeur puisqu'elle ne possède pas de nom mais elle peut avoir des initialisateurs.

Exemple :
public void init() { boutonQuitter.addActionListener( new ActionListener() { public void actionPerformed(ActionEvent e) { System.exit(0); } } ); }
Les classes anonymes sont un moyen pratique de déclarer un objet sans avoir a lui trouver un nom. La contre partie est que cette classe ne pourra être instanciée dans le code qu'à l'endroit ou elle est définie : elle est déclarée et instanciée en un seul et unique endroit.

Le compilateur génère un fichier ayant pour nom la forme suivante : nom_classe_principale$numéro_unique. En fait, le compilateur attribut un numéro unique à chaque classe interne anonyme et c'est ce numéro qui est donné au nom du fichier préfixé par le nom de la classe englobante et d'un signe '$'.


4.8.4. Les classes internes statiques


Les classes internes statiques (static member inner-classes) sont des classes internes qui ne possèdent pas de référence vers leur classe principale. Elles ne peuvent donc pas accéder aux membres d'instance de leur classe englobante. Elles peuvent toutefois avoir accès aux variables statiques de la classe englobante.

Pour les déclarer, il suffit d'utiliser en plus le modificateur static dans la déclaration de la classe interne.

Leur utilisation est obligatoire si la classe est utilisée dans une méthode statique qui par définition peut être appelée dans avoir d'instance de la classe et que l'on ne peut pas avoir une instance de la classe englobante. Dans le cas contraire, le compilateur indiquera une erreur :

Exemple :
public class ClassePrincipale4 { class ClasseInterne { public void afficher() { System.out.println("bonjour"); } } public static void main(String[] args) { new ClasseInterne().afficher(); } }
Resultat :
javac ClassePrincipale4.java ClassePrincipale4.java:10: No enclosing instance of class ClassePrincipale4 is i n scope; an explicit one must be provided when creating inner class ClassePrinci pale4. ClasseInterne, as in "outer. or "outer. . new ClasseInterne().afficher(); ^ 1 error
En déclarant la classe interne static, le code se compile et peut être exécuté

Exemple :
public class ClassePrincipale4 { static class ClasseInterne { public void afficher() { System.out.println("bonjour"); } } public static void main(String[] args) { new ClasseInterne().afficher(); } }
Resultat :
javac ClassePrincipale4.java java ClassePrincipale4 bonjour
Comme elle ne possède pas de référence sur sa classe englobante, une classe interne statique est en fait traduite par le compilateur comme une classe principale. En fait, il est difficile de les mettre dans une catégorie (classe principale ou classe interne) car dans le code source c'est une classe interne (classe définie dans une autre) et dans le byte code généré c'est une classe principale.

Ce type de classe n'est pas très employée.


4.9. La gestion dynamique des objets


Tout objet appartient à une classe et Java sait la reconnaitre dynamiquement.

Java fournit dans son API un ensemble de classes qui permettent d'agir dynamiquement sur des classes. Cette technique est appellée introspection et permet :

  • de décrire une classe ou une interface : obtenir son nom, sa classe mère, la liste de ces méthodes, de ses variables de classe, de ses constructeurs et de ses variables d'instances
  • d'agir sur une classe en envoyant, à un objet Class des message comme à tout autre objet. Par exemple, créer dynamiquement à partir d'un objet Class une nouvelle instance de la classe représentée

Voir le chapitre sur l'introspection.



Responsables bénévoles de la rubrique Java : Mickael Baron - Robin56 -