Discussion :

[mimi84]

Bonjour a tous, j aimerai trouver des réponses a ces questions :

Dans la déclaration d’une classe anonyme :

a) Quel est le rôle du type indiqué juste après le new ?
b) Sera-t-il instancié ?
c) Peut-il être une interface ?
d) Quel constructeur est utilisé pour instancier la classe anonyme ?
e) Une classe anonyme peut-elle être étendue ?

merci

[bouye]

a) cela indique le type a étendre ou implémenter.

Grosso modo faire :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
public class MaClasse  {
 
[...]
 
    addMachinListener(new Toto() {
        [...]
    });
 
[...]
 
}

revient presque a faire :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
public class MaClasse  {
 
[...]
 
    Titi titi = new Titi();
    addMachinListener(titi);
 
[...]
 
}

avec Titi une classe interne de MaClasse qui étend Toto :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
private class Titi extends Toto {
    [...]
}

ou si Toto est une interface :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
private class Titi implements Toto {
    [...]
}

b) Vi le nouveau type sera instancié.

c) Oui, voir a)

d) Le constructeur par défaut sera invoqué s'il n'est pas surchargé.

Pour la surcharge :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
addMachinListener(new Toto() {
   // Constructeur.
   {
       [...]
   }  
 
   [...]
});

e) Jamais essayé mais je dirai non car tu n'as pas de type déclaré que tu puisses manipuler dans ton code.
Il est peut-être possible de le faire en bidouillant le byte-code, ou via la reflection et en faisant des références à genre MaClasse.$1 mais :

• Ça restera impossible si elles sont implicitement déclarée final par le compilateur.
• Ça reste hyper facile à casser : il suffit de déclarer une autre classe anonyme juste avant pour que tout l'ordre change à la prochaine compilation.

[mimi84]

Merci Bouye pour tes réponses. elles auront éclairées ma lanterne.

Par contre pour la question d) quand tu dis que le constructeur par défaut sera invoqué si il n 'a pas été surchargé.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
addMachinListener(new Toto() {
   // Constructeur.
   {
       [...]
   }  
 
   [...]
});

comment appellera t'on ce constructeur puisque la classe anonyme n 'a pas de nom.

Merci

[bouye]

Ben la réponse est dans ce que tu cites (si tu prends la peine de comparer ce bout de code avec celui qui est tout en haut) : ce que j'ai appelé un constructeur (et qui est en fait en fait un bloc d’initialisation d'instance) n'a pas de nom et commence par un { et se termine par un }.

Dans une classe, rien ne t'oblige (a part les bonnes manières) à écrire :

<- ici, présence d'un constructeur sans argument (écrit par le programmeur).

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
public class Toto {
    public Toto(){
        System.out.println("Toto !");
    }    
}

Tu peux tout aussi bien écrire :

<- ici, présence d'un bloc d’initialisation et d'un constructeur par défaut (implicite).

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
public class Toto {
    {
        System.out.println("Toto !");
    }    
}

Voir carrément :

<- ici, présence de bloc d’initialisation et d'un constructeur sans argument (écrit par le programmeur).

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
public class Toto {
    {
        System.out.println("Toto1 !");
    }    
 
    public Toto() {
        System.out.println("Toto2 !");
    }
}

Le contenu du bloc d’initialisation est invoqué avant le contenu du constructeur sans argument et comme c'est un bloc d'instance (y a pas écrit static devant) on peut même bidouiller les variables d'instance (membre) avant que le constructeur ne le fasse.
donc pour une classe anonyme on peut sans problème écrire un bloc d'initialisation qui se charge de faire les même choses qu'un constructeur normal sans argument (genre conserver une référence sur un truc dont on va avoir besoin par la suite, aller zieuter les prefs utilisateur, etc.).

Et avant que tu ne poses la question, oui, les classes anonymes peuvent aussi avoir des variables d'instance.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
addMachinListener(new Toto() {
   private TrucMuche machinChose = obtenirMachinChose();
 
   public void faireUnTruc(UnEvent event) {
       machinChose.faireQuelqueChoseAvecLEvent(event);
   }
});

Hum quoi d'autre ? Tu peux avoir plusieurs bloc d’initialisation, ils sont invoqués dans l'ordre dans lequel ils apparaissent dans la classe et ils sont toujours tous invoqués avant les instructions contenues dans le constructeurs écri par le développeur. En gros, lorsque tu invoques le constructeur d'une classe, sauf boulette de ma part, on doit avoir un truc du genre :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
// Chargement de la classe parente
->  bloc d’initialisation statique parent #1
->  [...]
->  bloc d’initialisation statique parent #k
// On charge la classe courante.
<- bloc d’initialisation statique #1
<- [...]
<- bloc d’initialisation statique #m
// On crée l'instance parente (invocation du super constructeur).
-> bloc d’initialisation instance parent #1
->  [...]
-> bloc d’initialisation instance parent #n
-> Contenu du constructeur parent invoqué.
// On crée l'instance (invocation du constructeur).
<- bloc d’initialisation instance #1
<-  [...]
<- bloc d’initialisation instance #o
<- Contenu du constructeur invoqué.

[mimi84]

Merci Bouye

Tout cela est plus claire a présent.

[thelvin]

Pour information :

Ça restera impossible si [les classes anonymes] sont implicitement déclarée final par le compilateur.

C'est bien le cas, sans surprise.

Ça reste hyper facile à casser : il suffit de déclarer une autre classe anonyme juste avant pour que tout l'ordre change à la prochaine compilation.

Il suffit de faire getClass() sur l'instance créée avec. Cela permet d'étudier un peu quel constructeur est défini pour une classe pareille.
Je n'ai pas vu d'intérêt à faire ça par contre.