Qual è l'uso di un metodo - classe interna locale?

Question

Perché i progettisti di Java lo consideravano utile/necessario?

Answer 1

Utilizzando il metodo, le classi locali possono aumentare la leggibilità del codice tenendo insieme le parti correlate. Come un esempio forzato, supponiamo di avere un metodo che ha bisogno di creare un thread di fare qualcosa in sottofondo:

class Test { 
    void f() { 
     // lots of stuff 
     new Thread(new Runnable() { 
      public void run() { 
       doSomethingBackgroundish(); 
      } 
     }).start(); 
     // lots more stuff 
    } 
} 

Senza classi metodo locale, sarebbe necessario uno:

• creare un nuova classe con nome all'interno di Test per eseguire l'elaborazione in background o
• creare una nuova classe denominata in un file di origine separato per eseguire l'elaborazione in background.

Entrambe queste opzioni possono ridurre la leggibilità del codice spostando l'elaborazione correlata da qualche altra parte nell'albero sorgente (magari nello stesso file sorgente, magari in un altro file sorgente interamente). L'utilizzo di una classe metodo-locale mantiene la logica di elaborazione esattamente dove viene utilizzata.

Questo non è certamente applicabile a tutte le situazioni, ma può essere molto utile in una serie di situazioni comuni. Tale codice è comunemente usato per gli ascoltatori di azioni GUI, che sono classi molto piccole che di solito trasmettono solo chiamate di metodi di azione da un luogo a un altro.

Answer 2

Suppongo che intendi una classe interiore anonima? È fondamentalmente una chiusura. È possibile passarlo indietro dal metodo e mantiene l'ambito delle variabili in cui è stato definito. È utile per cose come ascoltatori dell'interfaccia utente in Swing.

Answer 3

Le classi interne locali (diverse dalle classi interne anonime) sono solo occasionalmente utili, anche se non ho statistiche per voi. Probabilmente la stragrande maggioranza dei programmatori Java non sa che esistono, quindi non stanno per iniziare a usarli.

Perché? Bene, è bello avere un trampolino di lancio tra una classe interiore anonima e una classe interiore standard. Il modo in cui le cose hanno funzionato, non mi aspetterei che fossero nel JLS se fosse appena stato standardizzato ora. Al momento dell'aggiornamento, era stata relativamente poca esperienza con le nuove funzionalità, sebbene il nuovo modello di eventi AWT fosse intimamente collegato.

La maggior parte degli utilizzi è per memorizzare alcune variabili di risultato per i callback sincroni. Tuttavia, in genere si dovrebbe semplicemente restituire un valore attraverso il metodo a cui è stata passata l'istanza o utilizzare qualcosa come un futuro. Inoltre, a volte si desidera costruire la classe in più di un punto all'interno del metodo, ma non si vuole perdere le funzioni di chiusura.

Answer 4

Consente di avere un costruttore (o più) e la possibilità di chiamare nuovi metodi sulla classe e accedere comunque alle variabili finali dichiarate all'interno del metodo di contenimento.

Vale la pena il sovraccarico? Forse non con il senno di poi, ma penso che al momento non fosse affatto ovvio che i limiti dietro le classi interne anonime (senza costruttori specifici e nessuna possibilità di chiamare nuovi metodi al di fuori della classe) fossero qualcosa che poteva essere lasciato lì senza un'alternativa.

Answer 5

Poiché la maggior parte delle persone probabilmente non hanno mai visto una classe interna metodo locale, ecco un esempio:

public class TestMethodLocalInnerClass 
{ 
    public static void main(String[] args) 
    { 
     class Greeter implements Runnable 
     { 
      private final String _greeted; 

      public Greeter(String greeted) 
      { 
       super(); 
       _greeted = greeted; 
      } 

      public void run() 
      { 
       System.out.printf("Hello %s!\n", _greeted); 
      } 
     } 

     new Greeter("world").run(); 
     new Greeter("dog").run(); 
    } 
} 

Questo potrebbe in teoria essere utile come un ulteriore livello di incapsulamento sotto una classe interna quando una classe anonima può essere usato perché hai bisogno di più di un'istanza. Forse se hai bisogno di dire diversi comparatori in diversi metodi e hai bisogno di istanziarli più di una volta. Questo sembra essere molto molto raro (non ho mai scritto una classe simile prima), e non è un grosso problema usare invece le normali classi interne.

Quindi, a mio avviso, non varrebbe la pena di includerlo in un linguaggio di nuova progettazione.

Answer 6

risposta per questa domanda è una domanda:

Come pensate di definire una classe in modo tale che, si sta per utilizzare tale classe con in una sola funzione? Ad esempio: la classe A ha 2 funzioni fun1 e fun2. Come definisci una classe in modo che possa essere utilizzata solo da fun2?

Se si definisce tale classe al di fuori dei metodi, ogni metodo inizierà a utilizzarlo. Come si segrega per essere utilizzato solo con una funzione? Questo può essere fatto rendendo quella classe come classe interna locale per quella funzione. Si può assumere come variabile locale di una funzione, che non può essere utilizzata da altre funzioni. Questo concetto è anche chiamato maggiore livello di sicurezza o incapsulamento.

Answer 7

Può essere utile per l'incapsulamento/l'ambito. Per esempio. il resto del codice non è inquinato con una definizione di classe la cui funzionalità fornita è rilevante solo all'interno di quel metodo.

Queste sono sostanzialmente le stesse prestazioni fornite da classi interne anonime, ma ci sono alcuni vantaggi rispetto una classe interna anonima:

• più istanze possono essere create all'interno del metodo
• possono estendere una classe e attuare una o più interfacce
• possono avere un costruttore