Newsgroup: it.comp.java
Titolo: castin dinamico

esiste la possibilità di fare un casting dinamico ?
solitamente posso far riferimento al tipo interfaccia direttamente a
salire, ma all'inverso devo sempre fare il casting esplicito
es. 	se ho un  	metodo(IOO ioo)
	e una dichiarativa 	OO1 ogg1 = new OO1();
	dove OO1 è una classe che implementa l'interfaccia IOO
	posso invocare il metodo come metodo(ogg1) 
ma l'inverso devo fare il casting
es.: 	se un metodo2() mi torna un tipo IOO 
	devo fare ogg1 = (OO1) metodo2() 
	dove ogg1 è sempre la dichiarativa di OO1 
	che a sua volta implementa IOO
mi chiedo se è possibile fare il casting dinamico chiedendo
all'oggetto ricevente il 
class.name
una cosa del tipo:
	ogg1 = ( ogg1.getClass().getName() ) metodo2()

 	ogg1 = ( ogg1.getClass().getName() ) metodo2()
Dato che hai dichiarato ogg1 sai anche benissimo qual'è il suo tipo, 
quindi fare quello che hai scritto non ti da possibilità in più.
Inoltre risulta meno leggibile e più lungo da scrivere, quindi sarebbe 
una cosa assolutamente inutile.
In ogni caso:
      no, non si può fare.
Andrea



quello che cerchi di fare è chiamato anche Narrowing (letteralmente
"restringimento") perchè a partire da una generica specifica di interfaccia,
sembra che tu voglia poi accedere a metodi e proprietà appartenenti alla
classe OO1.
Il casting è il metodo più corretto: l'operazione di cast funziona per te
(programmatore) come una "nota a latere", che sta a informarti che in quel
punto stai facendo un'operazione rischiosa. Metti il caso che per una futura
modifica del codice, il tuo "metodo2()" possa restituire anche oggetti di
classe Joppy che però implementano sempre l'interfaccia IOO? Un bel
ClassCastException permette di bloccare futuri casini sullo stesso segmento
di codice. Se poi non ti piacciono le eccezioni di sistema, puoi sempre
crearti un wrapper metodo2OO1() che faccia al suo interno i controlli del
caso:
   public OO1 metodo2OO1() {
      IIO res=metodo2();
      if (!(res instanceof OO1)) {
         //Qui ti gestisci il fatto che metodo2() abbia restituito un
         //oggetto NON di classe OO1
      }
      return (OO1)res;
   }
 
Oltre, non si può andare... e penso che nemmeno i Generics di Java 1.5.0 ti
possano aiutare.
-- 
Fermiamo Scientology prima che sia troppo tardi!!!
http://xenu.com-it.net
  ---  
http://xenu.freewinds.cx
(per rispondere personalmente leva IlDitoDalCulo)

...

grazie NSA con il tuo piccolo grande esempio mi hai fatto uscire dal
vicolo cieco
faccio fare il casting a chi deve ricevere; quindi un mio metodo di
servizio non entra più nel merito dei tipi, ma grazie all'interfaccia
richiamo il metodo setTracciato(Tracciato rec) dell'oggetto che deve
ricevere, passandogli il risultato del famoso metodo che torna
l'oggetto istanziato (del quale non so il tipo ma lo incaspulo nel
tipo interfaccia); quindi chi riceve (che è giusto conosca i sottotipi
attesi) si fa il casting.
questa è la classe (è un area dati) a cui mi volevo riferire
dinamicamente:
public class Su_profili implements Tracciato {
    public Fu_profili fuprofilo = new Fu_profili () ;
    public Fprofili profilo = new Fprofili ();
    public Futenti utente = new Futenti();
 public void setTracciato(Tracciato rec) {
  if (rec instanceof Fprofili) profilo = (Fprofili) rec; 
  else if (rec instanceof Fu_profili ) fuprofilo = (Fu_profili ) rec;
  else if (rec instanceof Futenti) utente = (Futenti) rec;
  else System.err.println("errore di programmazione...");	
 }
}
il codice di servizio che fa questi passaggi ha perso di leggibilità
(e probabilmente di performance) ma io ad implementare queste aree ora
ci metto un nanosecondo, che è quello che volevo.