Metodi di accesso all'interno delle classi interne locali in Java

Question

Esiste un modo per accedere ai metodi delle classi interne locali in Java. Il seguente codice è il codice di esempio che ho provato prima. In base a ciò qual è il meccanismo per accedere al metodo mInner()?

class Outer{ 
    int a=100; 

    Object mOuter(){ 
     class Inner{ 
      void mInner(){ 
       int y=200; 
       System.out.println("mInner.."); 
       System.out.println("y : "+y); 
      } 
     } 
     Inner iob=new Inner(); 
     return iob; 
    } 
} 
class Demo{ 
    public static void main(String args[]){ 
     Outer t=new Outer(); 
     Object ob=t.mOuter(); 
     ob.mInner(); // ?need a solution.. 
    } 
} 

Answer 1

Come dice il commento di ILikeTau, non è possibile accedere a una classe definita in un metodo. Si potrebbe definire al di fuori del metodo, ma un'altra possibilità è definire una interface (o classe astratta). Quindi il codice rimarrebbe all'interno del tuo metodo e potrebbe accedere alle variabili e ai parametri final definiti nel metodo (che non potresti fare se spostassi l'intera classe all'esterno). Qualcosa di simile:

class Outer { 
    int a = 100; 

    public interface AnInterface { 
     void mInner(); // automatically "public" 
    } 

    AnInterface mOuter() { // note that the return type is no longer Object 
     class Inner implements AnInterface { 
      @Override 
      public void mInner() { // must be public 
       int y = 200; 
       System.out.println("mInner.."); 
       System.out.println("y : " + y); 
      } 
     } 
     Inner iob = new Inner(); 
     return iob; 
    } 
} 

class Demo { 
    public static void main(String[] args) { // the preferred syntax 
     Outer t = new Outer(); 
     Outer.AnInterface ob = t.mOuter(); 
     ob.mInner(); 
    } 
} 

Nota: non testato

Si noti che il tipo di ritorno, e il tipo di ob, sono state modificate da Object. Questo perché in Java, se dichiari qualcosa come Object, puoi accedere solo ai metodi definiti per Object. Il compilatore deve sapere, al momento della compilazione (non in fase di esecuzione) che il tuo oggetto ob ha un metodo mInner e non può dire che se l'unica cosa che sa è che è un Object. Modificandolo su AnInterface, il compilatore ora sa che ha un metodo mInner().

Answer 2

Le regole di visibilità di una classe localesono praticamente le stesse delle regole di ambito di una variabile, cioè, si limita al blocco contiene.

Allo stesso modo non è possibile accedere variabile iob da main, non è possibile accedere classe locale Inner da main.

Al di fuori del blocco di chiusura, non c'è differenza tra una classe locale e una classe anonima. Nessuno dei due è accessibile. La differenza è che all'interno del blocco, la classe locale è accessibile per nome, particolarmente utile se è necessario accedervi ripetutamente, ad es. per creare più istanze.

L'unico modo per interagire con una classe locale/anonima al di fuori del blocco che lo contiene, è attraverso qualsiasi superclasse o interfaccia implementata dalla classe in questione.

Answer 3

Per accedere alla classe interna creare un oggetto della classe interna ..

OuterClass.InnerClass innerObject = outerObject.new InnerClass(); 

dal vostro esempio

outer t=new outer(); 

outer.inner inner1=t.new inner(); 

Spero che questo ti aiuta ...