[JAVA] Eccezioni

[centro]

Ciao a tutti,
mi sto avvicinando a java e proprio non mi entrano in mente le eccezioni.
Qualcuno sarebbe così gentile da dirmi in poche parole (se possibile) che differezza c'è tra questo tipo di gestire un'eccezione:

public void myMethod (String str) throws Exception{


}


e questo:


try {
myMethod("ciao");
}
catch(Exception e){
//fai qualcos'altro....
}



Ciao a tutti
Giuseppe

[Angelo1974]

Ciao.
Allora, nel primo caso tu dici: state attenti myMethod solleva una eccezione; deleghi ci utilizzerà questo metodo a gestire l'eccezione; nel secondo caso sei tu a gestire l'eccezione, nel senso che col try catturi la possibile eccezione e col catch effettui tutte le operazioni necessarie per porvi rimedio oppure per poter fare quello che vuoi.
Ciao

[mauri@como]

ciao stai attento alle differenze tra eccezioni checked vs. uncheked!
la differenza e' fondamentale!!!

:adhone:

[LeleFT]

Originariamente inviato da mauri@como
ciao stai attento alle differenze tra eccezioni checked vs. uncheked!
la differenza e' fondamentale!!!

:adhone:

Beh... io ho vissuto finora senza nemmeno sapere della loro esistenza, quindi non direi che sia di essenziale importanza conoscerne la differenza. Mi sono documentato sul sito della Sun e ne parlano (pochissimo!) solo quando parlano di proxy... (mi è parso di capire che le checked exceptions sono delle eccezioni che non possono essere fatte discendere da Error o da RuntimeException (???), cosa del tutto lecita e priva di fastidi, tanto sono sempre figlie di Throwable).

Mah... :master:


Ciao.

[mauri@como]

il fatto che debbano essere intercettate obbligatoriamente o meno non mi sembra cosa da poco!!

[centro]

Angelo1974 sei stato molto chiaro.. ma forse per capirlo meglio mi tocchera proprio fare un'esempio..(cioè vederlo applicato...)
Per quanto riguarda le differenze tra eccezioni checked vs. uncheke anche io.. mai sentite... ma sono solo agli inizi sto studiando.
Ciao e grazie

[LeleFT]

Originariamente inviato da mauri@como
il fatto che debbano essere intercettate obbligatoriamente o meno non mi sembra cosa da poco!!

Io non mi porrei il problema: le eccezioni si intercettano tutte, anche quelle che possono essere non intercettate. Io prendo alla lettera le parole di chi ne sa più di me e che scrisse:

"Se qualcosa può andare storto, andrà storto" [Murphy]

Soprattutto per la programmazione Java secondo la folosofia per cui è stato scritto questo linguaggio.

Ciao.

[Nosferatu]

Originariamente inviato da centro
public void myMethod (String str) throws Exception {

}

e questo:

try {
myMethod("ciao");
} catch(Exception e) {
//fai qualcos'altro....
}

Mah... a me non sembrano chiarissime le spiegazioni che hai ottenuto (tranne Angelo, forse). Io sono tutt'altro che un drago in Java, ma per farti capire il concetto, ti direi che hai esposto due facce della stessa medaglia. Sono soluzioni complementari, non surrogate.

Nel primo pezzo dichiari un metodo myMethod, e dichiari che al suo interno potrebbe scatenarsi un'eccezione che esso non è in grado di gestire.
In pratica è come dire: "Occhio a chi chiama myMethod(): questo potrebbe generare una situazione per lui ingestibile, e che quindi verrà rimandata al punto di invocazione."

Nel secondo pezzo chiami il metodo che hai appena dichiarato, e gestisci correttamente l'eventualità che il metodo sollevi un'Exception non gestita internamente da lui.

Semmai i dubbi a volte vengono tra quel che hai scritto tu e questo:
public void myMethod (String str) {
try {
// codice, codice
} catch (Exception e) {
// altro codice
}
}



myMethod("ciao");


...e cioè i dubbi potrebbero venirti nella scelta tra gestire le eccezioni internamente o esternamente ai metodi.




PS: chiedo conferme o smentite a chi ne sa più di me...

[Angelo1974]

Ciao. Allora, considera questo pezzo di codice:

import java.util.*;

import javax.mail.*;
import javax.mail.internet.*;

public class ReceiveEMail {

/**
* Oggetto Store
*/
private Store conserva;

/**
* Oggetto properties
*/
private Properties prop;

/**
* Oggetto Sessione
*/
private Session sessione;

/**
* Oggetto Folder simile
* alla casella di posta elettronica
*/
private Folder folder;

/**
* Oggetto messaggio
*/
private Message messaggio;

/**
* Array di messaggi contenuti in quel folder
*/
private Message[] elencoMessaggio;

/**
* Indirizzo mittente
*/
private InternetAddress daChi;

/**
* Indirizzo destinatario
*/
private InternetAddress aChi;

/**
* Oggetto stringa
* contenete l'indirizzo
* del mittente
*/
private String da;

/**
* Costruttore della classe
*/
public ReceiveEMail( ) {

prop = System.getProperties();
sessione = Session.getDefaultInstance( prop, null );
}

/**
* Metodo che si occupa di settare lo Sotre in base a:
* 1) tipo di protocollo ( Se POP3 o IMAP )
* 2) l'host cui connettersi
* 3) l'username
* 4) la password
* @param provider -specifica se s i usa POP3 oppure IMAP o qualsiasi altro
* @param host -l'host cui connettersi
* @param userName -l'username del client
* @param password -la password del client
*/
private void setStore( String provider, String host, String userName, String password ){

try {
conserva = sessione.getStore( provider );
conserva.connect( host, userName, password );
}
catch (NoSuchProviderException ex) {

ex.printStackTrace();
}
catch( MessagingException me ){

me.printStackTrace();
}
}
............
}

Come vedi nel metodo setStore c'è un blocco try/catch Questo serva a fare in modo che se capita una certa eccezione ( nel mio caso NoSuchProviderException e MessagingException ) il controllo passa al blocco catch che la gestisce secondo come il programmatore ( cioè noi ) ha deciso; nel mio caso semplicemente gli faccio stampare l'errore. Se non avessi voluto usare ciò avrei potuto fare:

import java.util.*;

import javax.mail.*;
import javax.mail.internet.*;

public class ReceiveEMail {

/**
* Oggetto Store
*/
private Store conserva;

/**
* Oggetto properties
*/
private Properties prop;

/**
* Oggetto Sessione
*/
private Session sessione;

/**
* Oggetto Folder simile
* alla casella di posta elettronica
*/
private Folder folder;

/**
* Oggetto messaggio
*/
private Message messaggio;

/**
* Array di messaggi contenuti in quel folder
*/
private Message[] elencoMessaggio;

/**
* Indirizzo mittente
*/
private InternetAddress daChi;

/**
* Indirizzo destinatario
*/
private InternetAddress aChi;

/**
* Oggetto stringa
* contenete l'indirizzo
* del mittente
*/
private String da;

/**
* Costruttore della classe
*/
public ReceiveEMail( ) {

prop = System.getProperties();
sessione = Session.getDefaultInstance( prop, null );
}

/**
* Metodo che si occupa di settare lo Sotre in base a:
* 1) tipo di protocollo ( Se POP3 o IMAP )
* 2) l'host cui connettersi
* 3) l'username
* 4) la password
* @param provider -specifica se s i usa POP3 oppure IMAP o qualsiasi altro
* @param host -l'host cui connettersi
* @param userName -l'username del client
* @param password -la password del client
*/
private void setStore( String provider, String host, String userName, String password ) throws NoSuchProviderException, MessagingException{

conserva = sessione.getStore( provider );
conserva.connect( host, userName, password );
}
............
}

In questo caso chiunque avesse chiamato il metodo setStore avrebbe dovuto occuparsi di gestire le due possibili eccezioni o inserendo try/catch oppure, nel caso fosse un altro metodo a chiamare setStore, con throws.......
In tal caso c'è una cosiddetta "propagazione" dell'eccezione che, se non gestita,potrebbe giungere al main e far terminare il programma anomalamente. Spero di essere stato più chiaro di prima.
Ciao

[LeleFT]

Effettivamente il codice postato da centro porta ad una ambiguità nell'interpretazione:
1) differenza fra gestione dell'eccezione interna al metodo e gestione esterna

2) gestione dell'eccezione nel caso del codice postato.

Credo sia il caso di riformulare il problema con del codice diverso:

Differenza fra:

public void myMethod(String arg) throws Exception {
   ... //codice metodo
}

e

public void myMethod(String arg) {
   try {
      ... //istruzioni
   } catch (Exception e) {
      ... // altre istruzioni
   }
}

Gran parte di quello che si poteva dire è già stato detto correttamente da Nosferatu e da Angelo1974: nel primo codice tu dichiari il metodo in modo che il metodo stesso non si preoccupi della gestione delle possibili eccezioni, avvertendo chi usa quel metodo di gestirsele; nel secondo caso, invece, è il metodo stesso a gestire le possibili eccezioni, in modo del tutto trasparente a chi usa quel metodo: chi usa quel metodo può benissimo ignorare l'esistenza delle possibili eccezioni.

Nel caso del codice postato da centrino, invece, sorge un dubbio: pensi che le due parti di codice svolgano la stessa funzione (è quello che diceva Nosferatu quando parlava di soluzioni complementari e non surrogate)? Ebbene no, appunto! La prima parte del tuo codice dichiara un metodo avvertendo chi lo usa che si potrebbe generare un'eccezione al suo interno, "obbligandolo" a gestirla. Nella seconda parte del tuo codice, il metodo viene effettivamente usato e, come da "obbligo" nell'intestazione del metodo, deve essere racchiuso in un blocco try/catch per catturare una possibile eccezione da lui lanciata.

Spero di aver fugato i dubbi.


Ciao.