Une classe membre statique est analogue aux autres membres statiques de la classe dans laquelle elle est déclarée (notée Enveloppe ici) :

On peut dans une autre classe,  instancier un objet de classe statique, à condition d'utiliser le qualificateur de visibilité qu'est le nom de la classe englobante afin d'accéder à la classe interne. Une classe membre statique se comporte en fait comme une classe ordinaire relativement à l'instanciation :

Soit par exemple, la classe Autre souhaite déclarer et instancier un objet Obj0 de classe public clasMembStat1 :

class Autre {
         Enveloppe1.clasMembStat1 Obj0 = new Enveloppe1.clasMembStat1( ) ;
         .......
}

Soit en plus à instancier un objet local Obj1 dans une méthode de la classe Autre :

class Autre{
      Enveloppe1.clasMembStat1 Obj0 = new Enveloppe1.clasMembStat1() ;
       void meth( ){
         Enveloppe1.clasMembStat1 Obj1 = new Enveloppe1.clasMembStat1() ;
      }
}
 
 

1.2 Caractérisation d'une classe membre statique

Une classe membre statique accède à tous les membres statiques de sa classe englobante qu'ils soient publics ou privés, sans nécessiter d'utiliser le nom de la classe englobante pour accéder aux membres (raccourcis d'écriture) :

Exemple :
Ci-dessous la classe membre statique clasMembStat1 contient une méthode "public void meth( )", qui invoque la méthode de classe(statique) void meth12 de la classe englobante Enveloppe1, en lui passant un paramètre effectif statique int a1. Nous écrivons 4 appels de la méthode meth12( ) :

public static class clasMembStat1 {

          public void meth( ){
           meth12(a1);
            Enveloppe1.meth12(a1);
            meth12(Enveloppe1.a1);
           Enveloppe1.meth12(Enveloppe1.a1);
         }
}

Nous notons que les 4 appels de méthodes sont strictement équivalents, en effet ils différent uniquement par l'utilisation ou la non utilisation de raccourcis d'écriture.
 

• Le quatrième appel :  "Enveloppe1.meth12(Enveloppe1.a1)" est celui qui utilise le nom de la classe englobante pour accéder aux membres statiques comme le prévoit la syntaxe générale.

• Le premier appel : "meth12(a1)" est celui qui utilise la syntaxe particulière aux classes membres statiques qui autorise des raccourcis d'écriture.

Une classe membre statique n'a pas accès aux membres d'instance de la classe englobante :

Remarque importante :

Un objet de classe interne statique  ne comporte pas de référence à l'objet de classe externe qui l'a créé.

Remarque Interface statique :

Une interface peut être déclarée en interface interne statique comme une classe embre statique en utilisant comme pour une classe membre statique le mot clef static. Syntaxe : public class Enveloppe {     < membres genre attributs  >     < membres genre méthodes  >     < membres genre classes membres statiques  >     < membres genre interfaces statiques  > } Exemple : public class Enveloppe {      public static Interface Interfstat {       ............      } }

 
 

2. Les classes membres
 

2.1 Définition des classes membres
 

Une classe membre est une classe java définie dans la partie déclaration des membres d'une autre classe qui la contient (nommée classe englobante).  Une classe membre est instanciable. Une classe membre est associée à un objet instancié de la classe englobante . Syntaxe : public class Enveloppe {     < membres genre attributs  >     < membres genre méthodes  >     < membres genre classes membres statiques  >     < membres genre classes membres  > }

Une classe membre se déclare d'une manière identique à une classe membre statique et aux autres membres de la classe englobante (notée Enveloppe2 ici) :

On peut dans une autre classe,  instancier un objet de classe membre, à condition d'utiliser le qualificateur de visibilité qu'est le nom de la classe englobante afin d'accéder à la classe interne. Une classe membre se comporte en fait comme une classe ordinaire relativement à l'instanciation :

Soit par exemple, la classe Autre souhaite déclarer et instancier un objet Obj0 de classe public classeMembre :
 

class Autre {
         Enveloppe1.classeMembre Obj0 = new Enveloppe1.classeMembre( ) ;
         .......
}

Soit en plus à instancier un objet local Obj1 dans une méthode de la classe Autre :
 

class Autre{
      Enveloppe1.classeMembre Obj0 = new Enveloppe1.classeMembre() ;
       void meth( ){
         Enveloppe1.classeMembre Obj1 = new Enveloppe1.classeMembre() ;
      }
}

2.2 Caractérisation d'une classe membre

Remarque importante :

Les classes membres ont les mêmes fonctionalités syntaxiques que les classes membres statiques. La différence notable entre ces deux genres de classes se situe dans l'accès à l'instance d'objet de classe englobante : Un objet de classe interne non statique comporte une référence à l'objet de classe externe qui l'a créé, alors qu'il n'en est rien pour une classe membre statique. L'accès a lieu  à travers le mot clef this qualifié par le nom de la classe englobante : "ClasseEnveloppe.this" .

Exemple d'accès à la référence de l'objet externe :

Question : comment, dans la classe interne membre classeMembre, ci-dessous accéder aux différents champs masqués x0 et t :

public class Enveloppe2 {

      public int x0 ;
      private int a0 ;
       ........
       public class classeMembre {
        boolean t ;
        void meth( boolean x0, char t ) {
         /*
            accéder au membre x0 de Enveloppe2 ;
            accéder au  paramètre formel x0 de meth ;
            accéder au membre t de classeMembre ;
            accéder au  paramètre formel t de meth ;
            */
        }
       ........
      }
   }

Réponse : en utilisant le mot clef this à la fois pour obtenir la référence de l'objet de classe classeMembre et Enveloppe2.this pour obtenir la reférence sur l'objet externe de classe englobante :

Remarque Interface non déclarée static :

Une interface ne peut pas être déclarée en interface interne non statique comme une classe membre ordinaire car on ne peut pas instancier d'objetà partir d'une interface. Si vous oubliez le mot clef static, le compilateur java le "rajoutera"  automatiquement et l'interface sera considérée comme statique !

 
 

3. Les classes locales
 

3.1 Définition des classes locales
 

Une classe locale est déclarée au sein d'un bloc de code Java.généralement dans le corps d'une méthode d'une autre classe qui la contient (nommée classe englobante). Elle adopte un schéma de visibilité gross-mode semblable à celui d'une variable locale. Une classe locale est instanciable comme une classe membre. Une classe locale est associée à un objet instancié de la classe englobante. Syntaxe : public class Enveloppe {     < membres genre attributs  >     < membres genre méthodes  >     < membres genre classes membres statiques  >     < membres genre classes membres  >     < membres genre interfaces statiques  >     < membres genre classes locales  > }

Une classe locale peut être déclarée au sein d'un quelconque bloc de code Java. Ci-dessous 3 classes locales déclarées chacune dans 3 blocs de code différents :

3.2 Caractérisation d'une classe locale
 

Une classe locale n'est visible et utilisable qu'au sein d'un bloc de code Java.où elle a été déclarée. Une classe locale peut utiliser des variables ( locales, d'instances ou paramètres ) visibles dans le bloc ou elle est déclarée à la condition impérative que ces variables aient été déclarées en mode final. Une classe locale peut utiliser des variables d'instances comme une classe membre.

A la lumière de la définition précédente corrigeons le code source de la classe ci-dessous, dans laquelle le compilateur Java signale 3 erreurs :

public class Enveloppe3 {
      public int x0 = 5 ;
      private int a0 ;

       public void meth(char x0 ) {
          int x1=100;
          class classeLocale1 {
            int j = x1; // le int x1 local à meth( )
           int c =  x0;  // le int x0 de Enveloppe3
          }
          for ( int i = 0;  i<10; i++) {
           int k = i;
           class classeLocale2 {
             int j = k + x1 + x0; // le k local au for
           }
          }
      }
   }
Après compilation, le compilateur java signale des accès érronés à des variables non final :

C:\j2sdk1.4.2\bin\javac - 3 errors :

local variable x1 is accessed from within inner class; needs to be declared final int j = x1;  local variable x0 is accessed from within inner class; needs to be declared final int c =  x0;  local variable k is accessed from within inner class; needs to be declared final int j = k + x1 + x0;

On propose une première correction  :

public class Enveloppe3 {
      public int x0=5 ;
      private int a0 ;

       public void meth ( final char x0 ) {
         final int x1=100;
          class classeLocale1 {
           int j = x1;
           int c =  x0;
         }
         for ( int i = 0;  i<10; i++) {
           final int k = i;
            class classeLocale2 {
              int j = k + x1 + x0;
           }
         }
      }
   }

Cette fois-ci le compilateur accepte le code source comme correct. Toutefois cette solution ne correspond pas à la définition de l'instruction "int j = k + x1 + x0; " dans laquelle la variable x0 doit être la variable d'instance de la classe externe Enveloppe3. Ici c'est le paramètre formel "final char x0" qui est utilisé. Si l'on veut accéder à la variable d'instance, il faut la mettre en mode final et qualifier l'identificateur x0 par le nom de la future instance de classe Enveloppe3, soit "Enveloppe3.this" :

Remarque :

Une classe locale ne peut pas être qualifiée en public, private, protected ou static.

 
 

4. Les classes anonymes
 

4.1 Définition des classes anonymes
 

Une classe anonyme est une classe locale qui ne porte pas de nom. Une classe anonyme possède toutesles propriétés d'une classe locale. Comme une classe locale n'a pas de nom vous ne pouvezpas définir un constructeur. Syntaxe : public class Enveloppe {     < membres genre attributs  >     < membres genre méthodes  >     < membres genre classes membres statiques  >     < membres genre classes membres  >     < membres genre interfaces statiques  >     < membres genre classes locales  >     < membres genre classes anonymes  > }

Une classe anonyme est instanciée immédiatement dans sa déclaration selon un esyntaxe spécifique :
new <identif de classe> ( <liste de paramètes de constructions>) { <corps de la classe>}

Soit l'exemple ci-dessous , comportant 3 classes Anonyme, Enveloppe4, Utilise :

La classe Enveloppe4 déclare une méthode public possédant un paramètre formel de type Anonyme :
 public class Enveloppe4 {

       public void meth(Anonyme x){
      }
  }

La classe Anonyme déclare un champ entier public a, un constructeur et deux méthodes public :

class Anonyme{
      public int a;
    // constructeur:
       Anonyme(int x){
         a = x*10;
         methA(x);
         methB();
      }
       public void methA(int x){
         a += 2*x ;       }

       public void methB( ){ }
   }

La classe Utilise déclare un champ objet de type Enveloppe4 et une méthode qui permet la création de 3 classes internes anonymes dérivant chacune de la classe Anonyme :

class Utilise{
      Enveloppe4 Obj = new Enveloppe4() ;

       void meth(){
         /* création d'une première instance anonyme de classe dérivant de Anonyme
             avec comme valeur de construction 8.
         */
         Obj.meth( new Anonyme(8){ });

         /* création d'une seconde instance anonyme de classe dérivant de Anonyme
             avec comme valeur de construction 12, redéfinition de la méthode methA et
             redéfinition de la méthodee methB :
         */
         Obj.meth(new Anonyme(12){
                  public void methA(int x){
                    super.methA(x);
                     a -= 10;
                  }
                  public void methB(int x){
                     System.out.println("a = "+a);
                  }
               });
         /* création d'une troisième instance anonyme de classe dérivant de Anonyme
             avec comme valeur de construction -54 et redéfinition de la seule méthode methA :
         */
         Obj.meth(new Anonyme(-54){
                  public void methB(int x){
                     System.out.println("a = "+a);
                  }
               });
      }
   }
 

4.2 Caractérisation d'une classe anonyme
 

Une classe anonyme étend concrètement une classe déjà existante abstraite ou non, ou bien implémente concrètement une interface. Une classe anonyme sert lorsque l'on a besoin d'une classe pour un seul usage unique, elle est définie et instanciée là où elle doit être utilisée. L'exemple le plus marquant d'utilisation de classe anonyme est l'instanciation d'un écouteur.

Voyons la différence d'écriture entre la version précédente de la classe Utilise avec 3 objets de classes anonymes et la réécriture avec des classes ordinaires :

On doit d'abord créer 3 classes dérivant de Anonyme :

class Anonyme1 extends Anonyme {      Anonyme1(int x){          super(x);       } } class Anonyme2 extends Anonyme {      Anonyme2(int x){          super(x);       }       public void methA(int x){           super.methA(x);           a -= 10;       }       public void methB(int x){           System.out.println("a = "+a);       } } class Anonyme3 extends Anonyme {      Anonyme3(int x){          super(x);       }       public void methB(int x){           System.out.println("a = "+a);       } }

Puis enfin définir la classe Utilise, par exemple comme suit :

class Utilise{       Enveloppe4 Obj = new Enveloppe4() ;       void meth() {          Anonyme1 Obj1 = new Anonyme1(8);          Anonyme2 Obj2 = new Anonyme2(12);          Anonyme3 Obj3 = new Anonyme3(-54);          Obj.meth( Obj1);          Obj.meth( Obj2 );           Obj.meth( Obj3 );       }    }

Vous pourrez comparer l'élégance et la briéveté du code utilisant les classes anonymes par rapport au code classique :

class Utilise{       Enveloppe4 Obj = new Enveloppe4() ;        void meth(){          Obj.meth( new Anonyme(8){ });          Obj.meth(new Anonyme(12){                   public void methA(int x){                     super.methA(x);                      a -= 10;                   }                   public void methB(int x){                      System.out.println("a = "+a);                   }                });          Obj.meth(new Anonyme(-54){                   public void methB(int x){                      System.out.println("a = "+a);                   }                });       }    }