[JAVA] Eccezioni

[ragnonerodocet]

Sto iniziando a scervellarmi con le eccezioni.

Domanda semplice:

qual'è l'utilizzo corretto delle clausole TROWS e THROW?

Non potrei gestire tutte le eccezioni coi blocchi try e catch?

[andbin]

Originariamente inviato da ragnonerodocet
qual'è l'utilizzo corretto delle clausole TROWS e THROW?

throw serve per lanciare una eccezione mentre throws si mette nella dichiarazione del metodo (prima della graffa di apertura '{') per indicare che il metodo può lanciare certe eccezioni (una o più separate da virgola).

Ma la questione delle eccezioni centra soprattutto con la differenza tra checked e unchecked. Per quelle "checked" vale la regola "handle or declare". O la gestisci (catturi) o la dichiari con il throws affinché il chiamante debba a sua volta tenerne conto. Per quelle unchecked non sei obbligato né a gestirle né a dichiararle.

[morphy79]

supponi di aver 2 classi..
la prima che richiama una funzione di una seconda classe, nella quale si possono generare delle eccezioni..

        // funzione richiamata nella quale si possono generare eccezioni
	public static String getDateFormat(String date, String from, String to){ 
			SimpleDateFormat sdf = new SimpleDateFormat(from); 
			Date d = sdf.parse(date); 
			sdf = new SimpleDateFormat(to); 
			return sdf.format(d); 
	}

con il blocco try e catch le gestisci tranquillamente, ma questo blocco lo devi riportare direttamente nella funzione

	public static String getDateFormat(String date, String from, String to){ 
                 try{
			SimpleDateFormat sdf = new SimpleDateFormat(from); 
			Date d = sdf.parse(date); 
			sdf = new SimpleDateFormat(to); 
			return sdf.format(d); 
                 }catch(Exception e){
                       // gestisci l'eccezione
                       System.out.println("ERRORE");
                 }
	}

invece in questo modo

	public static String getDateFormat(String date, String from, String to) throws ParseException { 
			SimpleDateFormat sdf = new SimpleDateFormat(from); 
			Date d = sdf.parse(date); 
			sdf = new SimpleDateFormat(to); 
			return sdf.format(d); 
	}

l'eccezione viene "trasmessa" alla classe che richiama il metodo e dovrà esser gestita in quel punto con il try e catch..

questo si fa per generalizzare il più possibile la tua funzione e far si che se richiamata da classi diverse possa comportarsi in modi differenti in caso di exception (e non come nell'esempio riportare sempre la scritta "ERRORE"..)

spero di esserti stato di aiuto..

[ragnonerodocet]

Ma la questione delle eccezioni centra soprattutto con la differenza tra checked e unchecked

Allora potresTi spiegarmi le differenze tra le due?

[andbin]

Originariamente inviato da ragnonerodocet
Allora potresTi spiegarmi le differenze tra le due?

La differenza l'ho spiegata sopra, anche se in modo abbastanza conciso.
Se non ti è chiara bene la differenza posso essere più preciso.

[ragnonerodocet]

Ebbene si, non mi è chiara...

O meglio, non so esattamente quando un'eccezione può essere gestita solo con un try/catch, solo con un throws/throw (si può???) o quando invece si deve:

A- implementare un metodo dichiarando la keyword throws dopo il nome del metodo e prima della lista dei parametri
B -lanciare con la keyword throw, il più delle volte dopo un check mediante un if, l'eccezione che si vuole
C- circondare con un try/catch il blocco di codice in cui si richiama il metodo sovracitato...

cioè utilizzare tutti e 2 i costrutti...

Chi mi aiuta?

[morphy79]

...ma te l'ho detto io prima..

se il metodo è generico e richiamato da più parti è consigliabile ( ma non obbligatorio ) utilizzare la clausola throws e gestire l'eccezione nei metodi chiamanti (come nell'esempio che ti ho postat o prima).. se no basta il try e catch...

[ragnonerodocet]

Vorrei allora fare un esempio

public class Metodo {

int bo = 5;

public void metttodo () throws EccezioneMia{

for (int i = 0; i < 20; i++) {

if (i == 16 ) {

throw new EccezioneMia();

}
this.bo++;

}
}



}

---------------------------------------------------------------

public class MaineRoad {

public static void main (String[] args) {

Metodo g = new Metodo();
try {
g.metttodo();
} catch (EccezioneMia e) {
// TODO Auto-generated catch block
System.out.println(e.toString());
}
System.out.println("CIAO");
}

}

In questo caso ho segnalato metttodo() come possibile "lanciatore di eccezioni".
Per la regola handle or declare, dovrò gestire nel corpo del chiamante del metodo l'eccezione: ho eseguito ciò con un try catch, ma avrei potuto fare lo stesso anche con una clausola throws dopo il nome del metodo.
Ho notato una differenza:
se nel metodo main non circondo il codice con un try-catch o se dopo il nome del metodo non metto un throws, il compilatore mi dà errore a causa del mancato trattamento dell'eccezione:
però, mettendo un blocco try - catch, il CIAO alla fine del metodo main è stampato, e tra l'altro viene eseguito il metodo e.toString(), con tanto di stampa a video.
Nel caso in cui io metta solo la clausola throws, non stampa affatto il CIAO perchè l'esecuzione è bloccata prima e il programma termina.

Dunque, domandona finale, la regola handle or declare è valida SOLO nel caso in cui io incontri una checked exception, caso in cui devo per forza gestire l'eccezione?
Nel caso di cui sopra, è il chiamante del metodo stesso a trattare l'eccezione, cioè è il metodo main che si occupa della EccezioneMia col blocco try-catch: ma allora il fatto stesso che dichiari nel metodo metttodo() la clausola throws implica che:

1- tale eccezione DOVRA' essere trattata nel chiamante
2- il fatto che il compilatore segnali un errore se non dichiaro nè try-catch nè throws è CONSEGUENZA LOGICA dell'handle or declare?

[andbin]

Originariamente inviato da ragnonerodocet
se nel metodo main non circondo il codice con un try-catch o se dopo il nome del metodo non metto un throws, il compilatore mi dà errore a causa del mancato trattamento dell'eccezione

Se EccezioneMia è una eccezione checked allora vale appunto la regola "handle or declare" quindi si deve fare così:

public static void main (String[] args) { 
    Metodo g = new Metodo();
    try {
        g.metttodo();
    } catch (EccezioneMia e) {
        System.out.println(e.toString());
    }
    ....
}

(con try-catch)

oppure così:

public static void main (String[] args) throws EccezioneMia { 
    Metodo g = new Metodo();
    g.metttodo();
    ....
}

(o dichiararla con throws)

Originariamente inviato da ragnonerodocet
però, mettendo un blocco try - catch, il CIAO alla fine del metodo main è stampato, e tra l'altro viene eseguito il metodo e.toString(), con tanto di stampa a video.

Ovvio ... se il catch non lancia a sua volta una eccezione, il metodo continua!

Originariamente inviato da ragnonerodocet
Nel caso in cui io metta solo la clausola throws, non stampa affatto il CIAO perchè l'esecuzione è bloccata prima e il programma termina.

Sì, normale.

Originariamente inviato da ragnonerodocet
Dunque, domandona finale, la regola handle or declare è valida SOLO nel caso in cui io incontri una checked exception, caso in cui devo per forza gestire l'eccezione?

Sei obbligato a gestire o dichiarare la eccezione solo per le eccezioni checked.

Originariamente inviato da ragnonerodocet
1- tale eccezione DOVRA' essere trattata nel chiamante

O a sua volta dichiarata.

Originariamente inviato da ragnonerodocet
2- il fatto che il compilatore segnali un errore se non dichiaro nè try-catch nè throws è CONSEGUENZA LOGICA dell'handle or declare?

Se il compilatore "vede" che tu hai invocato un metodo che dichiara una eccezione checked ma non hai gestito o dichiarato a sua volta l'eccezione, allora è un errore.