Classi interne: Android vs Java

Question

Sono consapevole che le classi interne non sono consigliate in Android perché contengono un riferimento alla classe che le include. Tuttavia, in Java, la classe esterna è solo GCed quando la classe interna non viene più referenziata. Ciò significa che, in Android, purché tu abbia un riferimento non statico nella classe di attività esterna alla classe interna, la classe interna non può esistere più a lungo della classe di attività esterna perché l'attività può essere distrutta solo se non contiene un riferimento alla classe interiore (almeno questo è quello che sto dicendo). Quindi qual è il problema usando le classi interne non statiche (dato che non possono ovviamente esistere più a lungo dell'attività esterna se si deduce da java)? Mi sto perdendo qualcosa?

Grazie!

Answer 1

Considerate questo semplice esempio

class Leaker 
{ 
    public static Object leakedObj; 
} 

class MyActivity extends Activity 
{ 
    public class MyInnerClass { ... } 

    void onCreate(Bundle savedState) 
    { 
     Leaker.leakedObj = new MyInnerClass(); 
     //The activity now won't be GCed until Leaker.leakedObj is cleared.   
    } 
} 

Si può facilmente passare una classe non statica interna di fuori del contesto della vostra attività. Finché non passi la tua classe interiore a oggetti al di fuori del ciclo di vita dell'Attività, dovresti stare bene. Ma è certamente possibile divulgare la tua attività attraverso una classe interiore.

Answer 2

Non mi preoccuperò di parafrasare, perché Google può spiegarlo meglio.

Supponendo: classe padre è Foo e classe interna è Foo$Inner:

Il problema è che la VM considera l'accesso diretto ai membri privati ​​di Foo da Foo $ interno di essere illegale perché Foo e Foo $ interno sono diverse classi, anche se il linguaggio Java consente ad una classe interna di accedere ai membri privati ​​di una classe esterna. Per colmare il gap, il compilatore genera un paio di metodi sintetici:

/*package*/ static int Foo.access$100(Foo foo) { 
    return foo.mValue; 
} 
/*package*/ static void Foo.access$200(Foo foo, int value) { 
    foo.doStuff(value); 
} 

Il codice classe interna richiama questi metodi statici ogni volta che deve accedere al campo Lvalore o richiamare il metodo doStuff nella classe esterna. Ciò significa che il codice sopra riportato si riduce a un caso in cui si sta accedendo ai campi membri tramite metodi di accesso. In precedenza abbiamo parlato di come gli accessor sono più lenti degli accessi diretti al campo, quindi questo è un esempio di un determinato linguaggio che ha come risultato un hit "invisibile".

Se si utilizza un codice come questo in un hotspot di prestazioni, è possibile evitare il sovraccarico dichiarando campi e metodi a cui le classi interne accedono per avere accesso al pacchetto, piuttosto che accesso privato. Sfortunatamente questo significa che i campi possono essere richiamati direttamente da altre classi nello stesso pacchetto, quindi non dovresti usarlo nelle API pubbliche.

Fonte: https://developer.android.com/training/articles/perf-tips.html#PackageInner