reindirizzare l'object id di una classe su una funzione di una sottoclasse

[chad9]

salve a tutti,

ho questa semplice classe:

class classe1
{
public void funzione()
{
System.out.println("sono la classe 1");
}
}

e questa:

class classe2 extends classe1
{
public void funzione()
{
System.out.println("sono la classe 2");
}
}

ho il programma principale:

class classe
{
public static void main(String argv[])
{
classe1 C1;
classe2 C2;
C1=new classe1();
C2=new classe2();
if(C1 instanceof classe2)
((classe2)C1).funzione();
else
System.out.print("NON ISTANZIA");
}
}

il problema è che l'object id di classe1 ( C1 ) non referenzia "funzione" di classe2...
Mi potete aiutare ?
Grazie

[LeleFT]

Originariamente inviato da chad9
il problema è che l'object id di classe1 ( C1 ) non referenzia "funzione" di classe2...
Mi potete aiutare ?
Grazie

Eh? Il codice che hai postato, effettivamente, non ha molto senso... un oggetto della classe "classe1" non è affatto un oggetto di classe "classe2"... è vero il contrario, per l'ereditarietà.

E' come se "classe1" fosse la classe "Animale" e "classe2" fosse la sottoclasse "Uomo"... è vero che qualunque oggetto della classe "Uomo" è anche un animale... ma non è affatto vero il contrario.

Quindi... spiega bene qual è il problema.

PS: Cerca di uniformarti allo standard, perchè stai scrivendo "al contrario": i nomi delle classi vanno scritti con l'iniziale maiuscola... i nomi delle variabili sempre con l'iniziale minuscola... altrimenti farai più fatica a "scontrarti" con la documentazione che trovi in giro.

Ciao.

[chad9]

Ciao e grazie della risposta.
Lo so che referenziare un metodo della superclasse è normale, ma avevo bisogno di fare il contrario... Cioè appunto da un object-id della superclasse verso un metodo della derivata e per questo ho fatto un cast:

((classe2)C1).funzione();

[LeleFT]

Sì, ma quello non lo puoi fare.
Tu hai istanziato un oggetto della classe "classe1" e non un oggetto della classe "classe2".

Un conto è avere un oggetto di classe "classe2", referenziato da una variabile dichiarata di tipo "classe1" (ed è lecito, per l'ereditarietà), di cui si desidera usare un metodo proprio della "classe2"... questo si fa con un cast, che va prima testato (deve essere lecito):

Animale a = new Uomo();
if (a instanceof Uomo) {
   // Lo posso fare perchè
   // 1) Ho effettuato il test ed ha dato esito positivo
   // 2) a1 è effettivamente un Uomo
   ((Uomo) a).guida();
}

Una cosa ben diversa è ciò che stai cercando di fare tu.

Animale b = new Animale();   // Questo non è un Uomo e non potrà mai guidare!!!
if (b instanceof Uomo) {
   // Qui non entrerò mai perchè a2 non è un uomo, ma un animale qualunque
   // (potrebbe essere tranquillamente una gallina)
   ((Uomo) b).guida();
}

Ciao.

[chad9]

ciao grazie ancora

pero'

class classe
{
 public static void main(String argv[])
 {
  classe1 C1=new classe2(); // istanzio l'oggetto di classe1 C1 per usare metodi classe2
  classe2 C2=new classe2();
  C1.funzione(); // visulizza "funzione" di classe2
  if(C1 instanceof classe2)
    ((classe2)C1).funzione(); //visualizza "funzione" di classe2
  else
    System.out.print("NON ISTANZIA");
 }
}

C1 anche senza il cast mi fa vedere il contenuto di fuzione di classe2...

se invece faccio

class classe
{
 public static void main(String argv[])
 {
  classe1 C1;
  classe2 C2;
  C1=new classe1();
  C2=new classe2();
  C1.funzione(); // visualizza "funzione" di classe1
  C1=new classe2();
  if(C1 instanceof classe2)
    ((classe2)C1).funzione();
  else
    System.out.print("NON ISTANZIA");
 }
}

cosi' funziona...
In poche parole come posso far istanziare C1 ai metodi di classe2 solo con il cast... Mentre senza cast farlo indirizzare ai metodi classe1 ?

Grazie ancora

[LeleFT]

Allora... una cosa è ciò che un oggetto può fare... un'altra è come lo fa.

Tu hai una classe che espone un metodo. Poi hai una sottoclasse che lo ridefinisce.

Il fatto di dichiarare un oggetto come oggetto della classe base o della classe figlia impatta solo sul numero di cose che quell'oggetto può fare, ma non dice nulla di come le cose vengano fatte.

Classe1 c1 = new Classe2();

Con l'istruzione precedente, ho solo detto che l'oggetto "c1" può fare tutte e sole le cose previste da "Classe1"... ma non sto dicendo che deve farle allo stesso modo. Infatti, il comportamento è dettato sempre e solo dall'implementazione concreta... e l'implementazione concreta è che "c1" farà le cose come è stato detto di farle da "Classe2" perchè c1 è a tutti gli effetti un oggetto di tale classe.

Non c'è alcun modo per far eseguire ad un oggetto della sottoclasse l'implementazione data dalla superclasse... generalmente, se questo è richiesto, l'oggetto sella sottoclasse lo sa e lo fa da sé usando la keyword "super".

E questo è nelle regole elementari di ereditarietà.
Se una classe sa fare qualcosa e una sua sottoclasse la sa fare in modo diverso, non puoi chiedere a quest'ultima (da una sua istanza) di farla come la fa la sua superclasse... perchè lei "lo fa a suo modo".

Questo è ciò che si può fare:

class Classe1 {
   public void metodo() { System.out.println("Sono il metodo di Classe1"); }
}

class Classe2 extends Classe1 {
   public void metodo() {
      super.metodo();   // Invoco il metodo della superclasse
      System.out.println("Sono il metodo di Classe2");
   }
}

Se necessiti di far eseguire alla tua sottoclasse, qualcosa che fa la sua superclasse, allora dovrai riprogettare la sottoclasse, in modo che fornisca un metodo che lo faccia... del resto è proprio questo il principio dell'ereditarietà: una sottoclasse, generalmente, fa qualcosa in più rispetto alla superclasse... e questo qualcosa in più può essere benissimo un "faccio anche quello che fa la mia superclasse".


Ciao.

[chad9]

ok grazie.
Infatti con "super" posso far riferimento ad un metodo di identico nome nella superclasse...

Dichiarando

Classe1 C1= new Classe2();

riesco con l'object-id di Classe1 C1 ad accedere a metodi e funzioni di sia di Classe1 che Classe2...

Quello che volevo sapere era se facendo il cast era come fare quello che per una sottoclasse è la keyword "super"... Cioe' con super si accede da sottoclasse a superclasse ad un metodo di uguale nome...

E con cast pensavo il contrario... cioè da superclasse a sottoclasse ad un metodo di uguale nome...

Grazie

[LeleFT]

No, un cast fa solo cambiare la visibilità dei metodi, esponendo tutti e soli quelli "previsti" dalla classe a cui lo si casta, ma non modifica l'oggetto (un oggetto non si può trasformare: come nasce, muore).

Tra l'altro, "super" serve ad accedere a tutti i metodi (costruttori compresi) della superclasse, non necessariamente quelli ridefiniti. Supponiamo di avere questa classe base

public class Classe1 {
   public void metodo1() { ... }
   public void metodo2() { ... }
}

Quando io scrivo una cosa del genere

public class Classe2 extends Classe1 {
   public void metodoSpecifico() {
      metodo1();
      metodo2();
   }
}

Da dentro il metodo "metodoSpecifico()" sto richiamando i due metodi della superclasse... questo è perfettamente equivalente a:

public class Classe2 extends Classe1 {
   public void metodoSpecifico() {
      super.metodo1();
      super.metodo2();
   }
}

Non cambia proprio nulla... il "super" è esattamente come il "this".
"this" è il puntatore all'oggetto corrente (per cui qualunque invocazione di metodi e/o campi della classe è come se fosse preceduta da un "this."), mentre "super" è il puntatore all'oggetto della classe base. Ove non ci sono ambiguità il "super" si può omettere (come per il this)... dove ci sono le ambiguità (come per i metodi ridefiniti, che hanno appunto lo stesso nome) esso va opportunamente esplicitato.


Ciao.