[java] ritorno da eccezione

[citrus]

dopo la gestione di un eccezione l'esecuzione riprende dall'inizio del blocco try giusto?
quindi è a dove metto questa istruzione che devo stare attento
dico bene?

[Lancill]

Originariamente inviato da citrus
dopo la gestione di un eccezione l'esecuzione riprende dall'inizio del blocco try giusto?
quindi è a dove metto questa istruzione che devo stare attento
dico bene?

è normale! a seconda di come devi comportarti con la variabile allora posizioni l'istruzione di aggiornamento!

In pratica se tutto va bene il blocco catch non viene mai eseguito, quindi devi assicurarti che non si vada in un ciclo infinito e quindi aggiornare la variabile prima del while. Nel momento in cui si verifica un'eccezione il catch viene eseguito e finito il blocco catch viene comunque eseguito anche quello che c'è fino al while, quindi dovresti stare attento all'aggiornamento doppio (visto che mi pare di aver capito che vuoi aggiornare 'a' anche nel blocco catch).

[citrus]

eppure mi succede una cosa strana,
ho questo tipo di codice:

do{
char a = in.readchar("seleziona operazione");
try{
switch (a){
case '1':
...
}
}catch (Exception e){
.....
}
}while(flag)

in teoria dopo la gestione dell'eccezione l'esecuzione del codice dovrebbe riprendere dall'inizio del blocco try, e quindi dal case in cui si è generata perchè la variabile a non viene rivalorizzata giusto?
e invece non funziona!
dopo la gestione dell'eccezione l'esecuzione riprende prima del try, cioè quando si chiede di valorizzare a!
come mai?

[patrix03]

l'eccezione genereata all'interno del blocco try-catch

try{ 
   switch (a){ 
       case '1': 
           ... 
   } 
}catch (Exception e){ 
  ..... 
}

provoca l'interruzione del normale flusso del programma, cioè viene eseguito un salto verso il blocco catch che cattura l'eccezione.
Una volta processata questa eccezione, se non vengono eseguite operazioni di ritorno o rilancio di eccezioni, il programma continua la normale elaborazione proseguendo dall'istruzione immediatamente successiva al blocco catch, o eseguendo lo statement finally se presente.
E' normale che, essendo il blocco try-catch racchiuso da un loop, venga eseguito un nuovo ciclo all'interno dell'iterazione.

[patrix03]

for(int i = 0; i < xx.length(); i++){
  operazione0
  try{
     operazione1;
     operazione2;
  }catch(Exception e){
     e.printStackTrace();
  }finally{
     operazione3;
  }
  operazione4
}

viene eseguita operazione0
operazione1 genera un'eccezione:
operazione2 NON viene eseguita
viene eseguito il codice nel blocco catch
viene eseguito il codice nel blocco finally
viene eseguita operazione4
si ripete il tutto come descritto dal for..

[citrus]

Originariamente inviato da patrix03
l'eccezione genereata all'interno del blocco try-catch

try{ 
   switch (a){ 
       case '1': 
           ... 
   } 
}catch (Exception e){ 
  ..... 
}

provoca l'interruzione del normale flusso del programma, cioè viene eseguito un salto verso il blocco catch che cattura l'eccezione.
Una volta processata questa eccezione, [u]se non vengono eseguite operazioni di ritorno[u] o rilancio di eccezioni, il programma continua la normale elaborazione proseguendo dall'istruzione immediatamente successiva al blocco catch, o eseguendo lo statement finally se presente.
E' normale che, essendo il blocco try-catch racchiuso da un loop, venga eseguito un nuovo ciclo all'interno dell'iterazione.

è proprio quello che servirebbe a me, impostare dei punti di ritorno nel codice di modo da non proseguire all'istruzione successiva al catch ma saltare in un punto specifico.
non so magari si possono usare delle etichette, consigliatemi voi.
grazie
citrus

[patrix03]

scusa se te lo chiedo.. ma
a cosa servirebbe esattamente tutto questo giro??
Credo che se si arrivi a cercare soluzioni simili ci sia qualche altro problema a monte.
Spiega bene che vuoi realizzare (forse sono io che non ho ancora ben capito).
Non eseguire l'istruzione successiva è possibile, certo, tutte le volte che in un blocco try-catch sono presenti + istruzioni le successive a quella che ha generato l'eccezione non vengono eseguite.
Saltare a punti diversi è possibile, basta gestire in modo opportuno le eccezioni che vengono generate.
Intanto sarebbe utile capire cosa vuoi realizzare, se la funzione è ricorsiva, se può essere gestita da qualche metodo intercettandone le eccezioni lanciate ecc..

[citrus]

praticamente ho una situazione di questo tipo:

char c;
do{
c=in.readchar("selezionare operazione: ");
try{
go: switch(c){
case '1':
case '2':
...
}
}catch(Exception e){
e.toString();
break go ;
}

così dovrei aver risolto perchè dopo la gestione dell'eccezione invece che rientrare nel ciclo e rivalorizzare la variabile c si rientra nello switch con la variabile c dello stesso valore di prima.
in questo modo dovrebbe venire eseguito di nuovo il case che ha generato l'eccezione.
...
purtroppo però mi da un errore sull'etichetta "undefined labels: go"
come mai?

[Lancill]

devi gestire allora il tutto con 2 cicli e 2 flag, una cosa come questa:

char c; 
do { 
  c = in.readchar("selezionare operazione: "); 
  while(flag2){
     try { 
       switch(c){ 
         case '1': ...;
         case '2': flag = false;... //esempio per uscire dal ciclo esterno
         ... 
        } 
	flag2 = false; //se non ci sono eccezioni flag2 diventa falso
     } catch(Exception e) { e.toString(); }
  }
} while(flag);

ovviamente adattata alle tue esigenze e controllala che l'ho scritta velocemente senza provare!

[citrus]

bella luncill!
ottima soluzione...
però per puntiglio vorrei capire come mai la mia non funziona, sopratutto perchè le etichette mi servono anche per altri motivi e non capisco il perchè di quell'errore!
mi daresti una dritta?
grazie
ciao!