oop - En Java, doute sur les classes internes anonymes appelant des méthodes de classe externes

Question

Aujourd'hui, j'ai découvert les classes internes et appris que les classes internes peuvent contenir cela des classes externes, de sorte qu'OuterClass.this.medthod() puisse être utilisé dans les classes internes pour référencer les méthodes de classe externe correspondantes. Mais j'ai écrit le code et il peut s'exécuter. Cependant, je ne comprends pas très bien la logique d'appel. J'espère que vous pourrez m'éclairer !

public class test {
        public void report(){
            System.out.println("I'm invoked!");
        }
        public void perform(){
            new Speaker().handleAction(new Action(){
                @Override
                public void action() {
                    report();//???为什么能调用report？？
                }
                
            });
        }
        public static void main(String[] args) {
            new test().perform();//测试代码
        }
        
    }
    class Speaker{
        void handleAction(Action act){
            act.action();
        }
    }
    interface Action{
        void action();
    }

La conception est la suivante. L'objet de test appelle la méthode perform, qui crée un nouvel objet de classe anonyme Speaker. L'objet appelle sa méthode handleAction. Le paramètre de cette méthode est une interface Action, et l'interface doit remplacer le résumé de l'action. méthode. J'ai utilisé la méthode de rapport appartenant au test. La sortie est normale.

Ensuite, je veux savoir, il y a un objet local d'une classe anonyme dans la méthode de l'objet de test, et le paramètre d'objet local est une classe anonyme qui implémente l'interface. Pourquoi report peut-il être appelé dans cette classe anonyme ? Est-ce qu'il tient le test.ce pointeur ?
Je comprends, new Speaker().handleAction(new Action(){....La logique d'implémentation ici n'a rien à voir avec test.this, et il n'est pas nécessaire d'organiser test.this???

Answer 1

        public void perform(){
            new Speaker().handleAction(new Action(){
                @Override
                public void action() {
                    report();//???为什么能调用report？？
                }
            });
        }

new Speaker() n'est pas une classe interne anonyme, elle porte le nom exact de la classe Speaker
new Action(){} est une classe interne anonyme et sera traité lors de la compilation Donnez-lui un nom de classe (nous supposons que son nom de classe est Test$1, vous pouvez imprimer this.getClass() pour voir)
Voir la différence entre les deux ? Les classes internes anonymes ont un {} supplémentaire.
Puisque new Action(){} est créé dans la portée de l'objet de test, sa classe externe est Test. new Speaker()不是匿名内部类，它有确切的类名Speaker
new Action(){}是匿名内部类，会在编译的时候给它一个类名(我们假定它的类名叫Test，你可以打印this.getClass()看看)
看出两者的区别了吗？匿名内部类多出了个{}。
由于new Action(){}是在test对象的作用域里被创建的，所以它的外部类是Test。

匿名内部类也有构造器，而且和普通类的构造器有点不一样，编译的时候会在匿名内部类的构造器的参数列表之前再插入一个参数，这个参数是外部类的对象的引用，编译之后这个类长这样：

Test implements Action {
    final T this
        public void perform(){
            new Speaker().handleAction(new Test(this));
        }
;
    Test(T thisrrreee){
        this.thisrrreee = thisrrreee;
    }
    
    @Override
    public void action() {
        thisrrreee.report();
    }
}

new Action(){...}

Les classes internes anonymes ont également des constructeurs, et ils sont un peu différents des constructeurs des classes ordinaires lors de la compilation, un autre paramètre sera inséré avant la liste des paramètres du constructeur de la classe interne anonyme. Ce paramètre est une référence à l'objet. de la classe externe Compilation La classe ressemblera alors à ceci :

rrreee

new Action(){...} crée en fait Test$1 et transmet la référence de l'objet de test à Test$1 via le constructeur🎜 rrreee 🎜Ainsi, la classe interne anonyme détient une référence à la classe externe et peut appeler des méthodes de la classe externe🎜