Credo di avere capito la situazione.
L'unico sistema che mi viene in mente è quello di spostare la classe interna, all'esterno e di procedere in modo un po' diverso:
1) Crei la classe Scene
2) Crei la InnerClass (che ora sarà OuterClass ), passandogli un riferimento alla classe Scene.
La classe OuterClass lavorerà esattamente come se si trattasse di una InnerClass, solo che la classe Scene dovrà prevedere dei metodi appositi per consentirle di "accedere" ai suoi campi.
Nella classe OuterClass, invece, dovrai solo prevedere un metodo che permetta di passargli il nuovo oggetto quando esso cambia (scene = new Scene1() ).
Vediamo la situazione:
codice:
public class Scene {
// campi privati (prima erano accessibili dalla classe interna)
private Tipo1 var1;
private Tipo2 var2;
...
private OuterClass outer;
Scene() {...}
...
// Metodi da aggiungere:
public Tipo1 getVar1() { return var1; }
public Tipo2 getVar2() { return var2; }
public void setOuterClass(OuterClass outer) {
this.outer = outer;
}
}
public class Principale {
private OuterClass outer;
private Scene scene;
public Principale() {
scene = new Scene();
OuterClass outer = new OuterClass(scene);
scene.setOuterClass( outer );
}
...
}
// Prima questa era InnerClass
public class OuterClass {
private Scene s; // Tengo un riferimento alla classe...
OuterClass(Scene s) {
this.s = s; // ... che passo al costruttore
}
...
public void updateScene() {
...
s.changesScene(); // Richiamo il metodo che chiamavo anche prima
// Se occorre, gli passo dei parametri
}
// Ora prevedo un metodo per quando la classe cambia:
public void setNuovaScene(Scene s) {
this.s = s;
}
}
Ovviamente sarà il metodo changesScene() che dovrà preoccuparsi di aggiornare la Scene della OuterClass. Questo è un esempio di come agire:
codice:
public void changesScene() {
scene = new Scene1();
outer.setNuovaScene( scene );
}
Grossomodo dovrebbe essere questo l'iter da seguire. Poi sta a te vedere se tutte e due le classi devono vedersi o meno, aggiungendo o togliendo dei riferimenti.
Ciao.