Vantaggio delle classi locali Java

Qual è il vantaggio delle classi locali in Java o in qualsiasi altra lingua che fa uso di questa funzione?

Ti consentono di estrarre la logica dalla class padre e oggettivarla. Ciò rimuove la funzionalità da dove non appartiene e la inserisce nella sua class. Ma cosa succede se questo nuovo object è necessario solo per un breve periodo, solo per la durata di un singolo blocco di codice? Bene, è lì che si inserisce una class locale.

Ecco un esempio di come una class interna anonima, una class interna locale e una class interna normale potrebbero essere presenti in un programma. L’esempio sta guardando un metodo myMethod e una class InnerClass presenti nella class MyClass . Per ragioni di discussione, queste classi implementeranno l’interfaccia Runnable :

 public class MyClass { public void myMethod() { // Anonymous inner class Runnable r = new Runnable() { public void run() {} }; // Local inner class class LocalClass implements Runnable { public void run() {} } } // ... // // Inner class class InnerClass implements Runnable { public void run() {} } } 

La class interiore anonima può essere usata semplicemente per creare una class che implementa Runnable senza dover scrivere la class e nominarla, e come krosenvold menzionata nel suo post, è usata come “chiusura di un povero uomo” in Java.

Ad esempio, un modo molto semplice per iniziare una Thread usando una class interna anonima sarebbe:

 new Thread(new Runnable() { public void run() { // do stuff } }).start(); 

Una class interna locale può essere utilizzata per creare una class che rientra nello scope locale: non sarà ansible accedervi da altri metodi al di fuori di myMethod .

Se c’era un altro metodo e abbiamo provato a creare un’istanza di LocalClass che si trova all’interno del metodo myMethod , non saremo in grado di farlo:

 public void anotherMethod() { // LocalClass is out of scope, so it won't be found, // therefore can't instantiate. new Thread(new LocalClass()).start(); } 

Una class interna fa parte della class in cui si trova la class interna. Pertanto, ad esempio, è ansible accedere alla class interna InnerClass da altre classi tramite MyClass.InnerClass . Ovviamente, significa anche che un altro metodo in MyClass può anche creare un’istanza di una class interna.

 public void anotherMethod() { // InnerClass is part of this MyClass. Perfectly instantiable. new Thread(new InnerClass()).start(); } 

Un altro aspetto della class interna anonima e della class interna locale è che sarà in grado di accedere alle variabili final dichiarate in myMethod :

 public void myMethod() { // Variable to access from anonymous and local inner classs. final int myNumber = 42; // Anonymous inner class Runnable r = new Runnable() { public void run() { System.out.println(myNumber); // Works } }; // Local inner class class LocalClass implements Runnable { public void run() { System.out.println(myNumber); // Works } } // ... // 

Quindi, quali sono i vantaggi? L’uso di classi interne anonime e classi interne locali invece di avere una class interna o una class interna completa consentirà al primo di accedere alle variabili final nel metodo in cui sono dichiarate e, allo stesso tempo, le classi sono locali a il metodo stesso, quindi non è ansible accedervi da classi esterne e altri metodi all’interno della stessa class.

Ci sono un certo numero di cose che puoi fare con le classi locali che non ottieni con classi interne anonime.

  • poiché il tipo ha un nome, è ansible aggiungere più membri non nel supertipo
  • un determinato nome può rendere le tracce dello stack più facili da seguire (in particolare per gli oggetti di blocco)
  • sottotipo più di un tipo di base
  • build in più di un posto e più costruttori

D’altra parte fanno una syntax orribilmente prolissa ancora più caotica.