Posso accedere a nuovi metodi nella classe interna anonima con qualche sintassi?

Question

Esiste una sintassi Java per accedere ai nuovi metodi definiti all'interno di classi interne anonime dalla classe esterna? So che ci possono essere varie soluzioni alternative, ma mi chiedo se esista una sintassi speciale?

Per esempio

class Outer { 

    ActionListener listener = new ActionListener() { 

     @Override 
     void actionPerformed(ActionEvent e) { 
      // do something 
     } 

     // method is public so can be accessible 
     public void MyGloriousMethod() { 
      // viva! 
     } 

    }; 

    public void Caller() { 
     listener.MyGloriousMethod(); // does not work! 
    } 


} 

mia soluzione OWN

Mi sono appena trasferito tutti i metodi e membri fino alla classe esterna.

Answer 1

Una volta che l'istanza di classe anonima è stata inoltrata implicitamente nel tipo named, non può essere richiamata perché non esiste un nome per il tipo anonimo. È possibile accedere ai membri aggiuntivi della classe interna anonima tramite this all'interno della classe, nell'espressione immediata dopo l'espressione e il tipo può essere dedotto e restituito tramite una chiamata di metodo.

Object obj = new Object() { 
    void fn() { 
     System.err.println("fn"); 
    } 
    @Override public String toString() { 
     fn(); 
     return ""; 
    } 
}; 
obj.toString(); 



new Object() { 
    void fn() { 
     System.err.println("fn"); 
    } 
}.fn(); 


identity(new Object() { 
    void fn() { 
     System.err.println("fn"); 
    } 
}).fn(); 
... 
private static <T> T identity(T value) { 
    return value; 
} 

Answer 2

Il chiamante conosce listener come ActionListener e quindi non sa nulla di quel nuovo metodo. Penso che l'unico modo per farlo (oltre al fare ginnastica riflessiva, che davvero vanificherebbe lo scopo di usare una classe anonima, ovvero la scorciatoia/semplicità) è semplicemente la sottoclasse ActionListener e non usare una classe anonima.

Answer 3

No, non è possibile. Dovresti lanciare ActionListener nel suo vero nome di sottoclasse, ma dal momento che è anonimo, non ha un nome.

Answer 4

Il modo giusto per farlo sta usando riflessione:

import java.lang.reflect.InvocationTargetException; 

public class MethodByReflectionTest { 

    public static void main(String[] args) throws IllegalAccessException, IllegalArgumentException, InvocationTargetException, NoSuchMethodException, SecurityException { 

     Object obj = new Object(){ 
      public void print(){ 
       System.out.println("Print executed."); 
      } 
     }; 

     obj.getClass().getMethod("print", null).invoke(obj, null); 
    } 
} 

È possibile controllare qui: How do I invoke a Java method when given the method name as a string?

Answer 5

Uno studente nella mia classe ha chiesto il nostro professore se questo potrebbe essere fatto l'altro giorno . Ecco quello che ho scritto come prova fresco di concetto che si può fare, anche se non vale la pena, in realtà è possibile ed ecco come:

public static void main(String[] args){ 

    //anonymous inner class with method defined inside which 
    //does not override anything 
    Object o = new Object() 
    { 
     public int test = 5; 
     public void sayHello() 
     { 
      System.out.println("Hello World"); 
     } 
    }; 

    //o.sayHello();//Does not work 

    try 
    { 
     Method m = o.getClass().getMethod("sayHello"); 
     Field f = o.getClass().getField("test"); 
     System.out.println(f.getInt(o)); 
     m.invoke(o); 
    } catch (Exception e) 
    { 
     e.printStackTrace(); 
    } 
} 

Facendo uso della class Metodo di Java possiamo invocare un metodo passando il valore della stringa e i parametri del metodo. La stessa cosa può essere fatta con i campi.

Ho pensato che sarebbe stato bello condividere questo!

Answer 6

Sì, è possibile accedere al metodo vedere l'esempio di seguito in caso di dubbio si prega di commentare

package com; 
interface A 
{ 
    public void display(); 
} 
public class Outer { 
    public static void main(String []args) 
    { 
     A a=new A() { 
     @Override 
     public void display() { 
      System.out.println("Hello"); 
     } 
    }; 
     a.display(); 
    } 
    }