Les classes anonymes sont des classes qui ne peuvent pas avoir de nom, il n'y a donc aucun moyen de les référencer. Ils doivent être déclarés dans le cadre de la nouvelle déclaration au moment de la création. Cela nécessite une autre forme d'instruction new, comme suit : new <class or interface> <body of class> Cette forme d'instruction new déclare une nouvelle classe anonyme qui étend une classe donnée ou implémente une interface donnée. Il crée également une nouvelle instance de cette classe et la renvoie comme résultat de l'instruction. La classe à étendre et l'interface à implémenter sont les opérandes de la nouvelle instruction, suivis du corps de la classe anonyme. Si une classe anonyme étend une autre classe, son corps peut accéder aux membres de la classe, remplacer ses méthodes, etc., comme n'importe quelle autre classe standard. Si une classe anonyme implémente une interface, son corps doit implémenter les méthodes de l'interface.
Code Java
Copiez le code comme suit :
interface pr
{
annuler print1();
}
classe publique noNameClass
{
destination publique()
{
renvoyer un nouveau pr(){
public void print1()
{
System.out.println("Bonjour tout le monde !!");
}
} ;
}
public static void main (String args[])
{
noNameClass c = new noNameClass();
pr hw=c.dest();
hw.print1();
}
}
PR peut également être une classe, mais la méthode que vous appelez en externe doit être déclarée dans votre classe ou interface. Les méthodes à l'intérieur de la classe anonyme ne peuvent pas être appelées de l'extérieur.
L'endroit le plus couramment utilisé pour les classes anonymes internes en Java est peut-être d'ajouter Listner à Frame.
comme suit:
Code Java
Copiez le code comme suit :
importer java.awt.* ;
importer java.awt.event.* ;
la classe publique QFrame étend le cadre {
public QFrame() {
this.setTitle(/"mon application/");
addWindowListener(nouveau WindowAdapter() {
public void windowClosing (WindowEvent e) {
disposer();
Système.exit(0);
}
});
this.setBounds(10,10,200,200);
}
}
Une classe anonyme interne consiste à créer une classe interne, mais elle ne vous donne pas de nom, c'est-à-dire qu'il n'y a pas de variable faisant référence à l'instance.
Copiez le code comme suit :
nouveau WindowAdapter() {
public void windowClosing (WindowEvent e) {
disposer();
Système.exit(0);
}
}
new consiste à créer un objet WindowAdapter, et le {} suivant indique que l'opération entre parenthèses agit sur le nom de l'objet par défaut, et ce qui suit dans le programme Java ci-dessus est un corps de fonction.
Le but de cette utilisation est de créer une instance d'un objet et de remplacer l'une de ses fonctions. Vous pouvez le trouver en ouvrant le code WindowAdapter. C'est une classe abstraite. Il s'agit d'une implémentation de l'interface WindowListener. Le paramètre de Frame.addWindowListner(); est un WindowListner, et l'implémentation consiste à transmettre une classe anonyme dérivée de WindowAdapter.
1. Comment déterminer l’existence d’une classe anonyme ? Je ne vois pas le nom, j'ai l'impression que c'est juste un objet créé par new à partir de la classe parent, et il n'y a pas de nom pour la classe anonyme.
Regardons d'abord le pseudocode
Copiez le code comme suit :
classe abstraite Père(){
....
}
Test de classe publique{
Father f1 = new Father(){ .... } //Il y a une classe interne anonyme ici
}
De manière générale, lors de la création d'un objet, il doit y avoir un point-virgule après les parenthèses, c'est-à-dire que l'instruction du nouvel objet se termine.
Mais c'est différent lorsqu'il y a des classes internes anonymes. Les parenthèses sont suivies d'accolades et les accolades contiennent la méthode d'implémentation spécifique du nouvel objet.
Parce que nous savons qu'une classe abstraite ne peut pas être nouvelle directement. Il doit y avoir une classe d'implémentation avant de pouvoir créer sa classe d'implémentation.
Le pseudocode ci-dessus indique que new est la classe d'implémentation de Father et que cette classe d'implémentation est une classe interne anonyme.
En fait, diviser la classe interne anonyme ci-dessus peut être
Copiez le code comme suit :
la classe SonOne étend Père{
...//Le code ici est le même que celui de la classe interne anonyme ci-dessus, le code entre accolades
}
Test de classe publique{
Père f1 = new SonOne();
}
2. Précautions pour les classes internes anonymes Notez que la déclaration des classes anonymes est effectuée au moment de la compilation et que l'instanciation est effectuée au moment de l'exécution. Cela signifie qu'une nouvelle instruction dans une boucle for créera plusieurs instances de la même classe anonyme, plutôt que de créer une instance de plusieurs classes anonymes différentes.
Lorsque vous utilisez des classes internes anonymes, gardez les principes suivants à l’esprit :
・Les classes internes anonymes ne peuvent pas avoir de constructeurs.
・Les classes internes anonymes ne peuvent définir aucun membre, méthode ou classe statique.
・Les classes internes anonymes ne peuvent pas être publiques, protégées, privées ou statiques.
・Une seule instance d'une classe interne anonyme peut être créée.
・Une classe interne anonyme doit être derrière new et elle est utilisée pour implémenter implicitement une interface ou implémenter une classe.
・Étant donné que les classes internes anonymes sont des classes internes locales, toutes les restrictions sur les classes internes locales s'appliquent à elles.
・Les classes internes ne peuvent accéder qu'aux variables statiques ou aux méthodes statiques des classes externes.
ceci dans les classes anonymes et les classes internes :
Parfois, nous utiliserons des classes internes et des classes anonymes. Lorsque vous l'utilisez dans une classe anonyme, cela fait référence à la classe anonyme ou à la classe interne elle-même. À ce stade, si nous voulons utiliser les méthodes et variables de la classe externe, nous devons ajouter le nom de la classe externe
3. Le rôle des classes internes anonymes
Les classes internes de Java sont fondamentalement différentes des classes imbriquées en C++ : les classes imbriquées de C++ n'ont pas de handles pour les classes wrapper. Il exprime uniquement le concept d'encapsulation ; mais la classe interne de Java est différente, elle peut accéder aux membres de la classe d'encapsulation (ce qui signifie qu'elle possède un handle vers la classe d'encapsulation).
Les classes internes anonymes sont une manière simplifiée d'écrire des classes internes : return new Wrapper {
...
} ;
Équivalent à : Wrapped extends Wrapper {
...
}
retourner un nouveau Wrapped();
Est-ce le seul rôle des classes internes anonymes ?
Considérons ce cas :
Copiez le code comme suit :
interface ICompte {
int compte();
}
classe Parent {
int je = 0;
int compte() {
renvoie i++ ;
}
}
Il existe une classe Child, qui veut non seulement hériter de la méthode count() de Parent, mais souhaite également implémenter la méthode count dans l'interface ICount. Que dois-je faire à ce moment-là ? Les classes internes peuvent entrer en jeu :
Copiez le code comme suit :
classe Enfant étend Parent {
ICount getCount() {
renvoyer un nouveau ICount {
int je = 0;
int compte() {
retourner (je *= 2);
}
}
}
}
regarde ce code
Copiez le code comme suit :
public static void main (String[] arguments) {
theApp = nouvel analyseur ();
SwingUtilities.invokeLater(new Runnable() { // Classe Runnable anonyme
// objet
public void run() { // Méthode d'exécution exécutée dans le thread
theApp.creatGUI(); // Appel du créateur d'interface graphique statique
}
});
}
public static void main (String[] arguments) {
theApp = new Analyzer(); // Créer un objet
SwingUtilities.invokeLater(new Runnable() { // Classe Runnable anonyme
// Une classe interne anonyme qui implémente un thread
// À l'origine, cette méthode devait passer un paramètre de type Runnable // Ceci peut être réalisé grâce à cette méthode de classe anonyme
// objet
public void run() { // Méthode d'exécution exécutée dans le thread
theApp.creatGUI(); // Appel du créateur d'interface graphique statique
}
});
}
