Java, local classes

Per local class (classe locale) si intende una inner class che è definita in un blocco di codice. Un blocco di codice potrebbe essere il corpo di un metodo, di un costruttore, un blocco locale, un inizializzatore statico o un inizializzatore di istanza.
Alcune caratteristiche di una local class:

  • una local class non può avere memebri statici (questo però non esclude la possibilità di avere un membro final static, essendo esso una costante)
  • una local class non può avere modificatori di accessibilità (public, private, ecc.). Sarà quindi dichiarata scrivendo semplicemente class nomeClasse {…}
  • una local class può estendere un’altra classe
  • all’interno del blocco in cui è definita, una local class può accedere solo ai membri dichiarati final
  • una non-static local class può accedere sia ai membri statici sia ai membri non statici della classe contenitore (da non confondere con il blocco contenitore)
  • una static local class può accedere solo ai membri statici della classe che la contiene
  • una local class (essendo locale) può essere istanziata solo nel blocco nel quale è definita e deve essere dichiarata prima di essere utilizzata

Prima accortezza: se il blocco contenente la dichiarazione della local class è definito in un contesto statico (ad esempio un metodo statico o un inizializzatore statico) allora la local class è implicitamente statica e quindi non richiede alcun oggetto contenitore per essere istanziata.
Facciamo però attenzione al fatto che, sebbene in certi contesti (appena visti) la local class è intesa implicitamente statica, essa non consente di utilizzare nella propria dichiarazione la parola chiave static. Mai.
Facciamo anche attenzione al fatto che se una local class si trova dichiarata in un contesto statico, ciò influenzerà quello che la local class può “vedere” nel contesto contenitore.
Possiamo leggere i commenti nel seguente esempio per chiarirci (spero) le idee…

public class EsempioLocalClass{
private int varNonStatica = 15;

void metodoNonStatico (final int param) {
final int flv = 10;
final int hlv = 30;
int nflv = 20;
class localClassNonStatica { // dichiarazione local class. siamo nel metodo "metodoNonStatico", non dimentichiamolo
static int f1; // errore! Non si possono dichiarare variabili static non final in una local class
final static int f2 = 10; // va bene. Varibile final static consentita in una local class
int f3 = param; // tutto ok. Abbiamo visibilità della costante param
int f4 = flv; // ok. flv appartiene al metodo contenitore ad è final
int f5 = nflv; // errore! Del blocco contenitore possiamo "vedere" solo le variabili definite "final"
int f6 = varNonStatica; // ok. varNonStatica è dichiarata nella Top Level Class, quindi è visibile nella local class
}
}

static void metodoStatico (final int param) { // attenzione! Questo è un metodo statico... quindi?
final int flv = 10;
final int hlv = 30;
int nflv = 20;
class localClassImplicitamenteStatica {
static int f1; // errore! Repetita iuvant: niente static non final in una local class
final static int f2 = 10; // va bene invece una final static
int f3 = param; // ok. param appartine al metodo contenitore ed è final
int f4 = flv; // ok. flv appartine al metodo contenitore ed è final
int f5 = nflv; // errore! nflv non è final
int f6 = varNonStatica; // errore! Ora la nostra local class è implicitamente statica e quindi non abbiamo accesso alle variabili della Top Level Class (a meno che non siano dichiarate static)
}
}
}

Hai letto questi articoli?