[Java] Classe annidata

[speriamobene]

ho una classe A che ha al suo interno una classe A1 listener che fa riferimento ad un metodo di A, setX().

Ebbene:
creo B estendendo A e senza creare il proprio listener. Faccio l'overriding di setX()

Il listener mi funziona ma non chiama B.setX o meglio esegue setX di B pare ma le variabili sono quelle di A e non di B.

Come risolvere?

[Matteo982]

non si potrebbe vedere un po' il codice?? :master:

[speriamobene]

il codice complica solo la vita in questo caso dal momento che ho debuggato cmq tutto...

quello che nn riesco a fare è fare riferimento alle variabili ed ai metodi locali.

per B altri metodi in ovverriding faccio riferimento a this.nomemetodo() (anche nei metodi di A) e mi viene eseguito quello della classe estesa B...

ma nella classe annidata... se faccio this mi viene vista quella attuale. se faccio super.this non va, se faccio A.this. ... mi viene eseguito il metodo di A e non quello di B

[LeleFT]

Originariamente inviato da speriamobene
Il listener mi funziona ma non chiama B.setX o meglio esegue setX di B pare ma le variabili sono quelle di A e non di B.

Sinceramente non ho capito nulla...
Potresti postare un esempio ridotto della tua situazione? Ovvero... la struttura delle classi con le variabili in gioco, aggiungendo cosa ti aspetti che succeda e quello che, invece, succede. Perchè così proprio non ho capito niente.


Ciao.

[Matteo982]

Come ho già detto prima e ha detto anche LeleFT vedere almeno un pezzo del codice aiuta a capire...spiegato così tu sai cosa hai fatto e lo capisci ma per chi non ne sa niente è un po' dura!

Ciao.

[speriamobene]

cerco di essere più chiaro.

ho una classe così fatta:

public class Scene {

  private TipoVar var

  Scene() {
  }

  class InnerScene() extends PickBehaviour {
     InnerScene() {
     }
     public void updateScene() {
     }
  }
}

e fin qui tutto ok.

poi creo:

public class Scene1 extends Scene

Da un'altra classe Principale:
Chiamo:

Scene scene = new Scene();

ed eseguo.

l'updateScene della InnerScene di Scene esegue un metodo che è in A:

public void changeSscene() {
  scene = new Scene1();
}

che ha il compito di sostituire la scena con la scena1.


A questo punto accade che con la creazione di scene1 questa si ritrova anche una sua InnerScene ereditata e viene eseguita questa.


Ebbene... a questo punto ho provato a fare static la InnerScene ma non può andare in quanto chiama metodi in overriding e cmq variabili non static e che non possono diventare static.


Spero di essere stato chiaro, sicuramente + di postare l'intero codice di oltre 1300 linee per la sola classe Scene.

[LeleFT]

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:

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:

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.

[Matteo982]

oltre a questo io non ho capito a cosa serve definire il costruttore della classe se poi non ci metti niente...non che sia sbagliato ma mi pare un po' inutile...:master:

[speriamobene]

ovviamente non e' vuoto ma quello che ci metto non e' significativo per illustrare il problema... semplice no?

provo la soluz di LeleFT e poi vi faccio sapere.

[Matteo982]

si col problema lo so che non centra era una semplice curiosità per quello che hai scrittu su...