Newsgroup: it.comp.java
Titolo: throws vs catch

Che differenza c'č tra
class A {
    ....
    public void f () throws NullPointerException {
        ....
        if (....) {
            throw new NullPointerException ("...");
        }
    }
}
class B {
    ....
    public void f (){
        ....
        try { 
            ....
        }catch (NullPointerException npe) {
            ....
        }
}
Quando si usa un metodo o l'altro? E se fosse indifferente uno dei due č
piů veloce?
Grazie
    }
}
-- 
Posted via Mailgate.ORG Server - 
http://www.Mailgate.ORG

Ciao, Aieie!
Il giorno 04/06/2004 alle ore 11:18 hai scritto:
 AB> Quando si usa un metodo o l'altro? E se fosse indifferente uno dei due
 AB> è più veloce?
Sono due cose completamente differenti, un'occhiata ad un po' di
documentazione non farebbe cosi' male...
Il throws/throw serve per generare un'eccezione, cioe' serve per segnalare
un errore di qualche genere al programma, mentre il blocco try/catch (come
dice anche la traduzione letterale) serve per catturare gli errori generati
dai metodi chiamati e agire di conseguenza.
Bye
-- 
There is no passion; There is serenity.
http://www.maccasoft.com

Quindi se faccio una mia classe uso throws/throw, mentre quando richiamo
il metodo uso try/catch


Ciao, Aieie!
Il giorno 04/06/2004 alle ore 13:44 hai scritto:
Il quoting !!!
 AB> Quindi se faccio una mia classe uso throws/throw, mentre quando
 AB> richiamo il metodo uso try/catch
Si, ma non e' una regola. try/catch lo usi solo quando vuoi catturare le
eccezioni, se le vuoi far passare basta dichiarare il metodo con throws
Exception (o la classe specifica).
Ripeto, studiare un po' non fa mai male.
Bye
-- 
There is no emotion; There is peace.
http://www.maccasoft.com

 il metodo uso try/catch
Non ti è chiaro alle basi la gestione delle eccezioni.
Intanto l'esempio che hai postato è ambiguo, infatti 
NullPointerException è una RuntimeException ovvero un caso di eccezione 
che il linguaggio non obbliga a catturare.
Ma a prescindere da questo, la differenza è sostanziale: try/catch è lo 
statement che gestisce l'eccezione, quando invece dichiari l'eccezione 
nel metodo con la clause throws indichi che la gestione dell'eccezione è 
a carico del chiamante (a sua volta con una try/catch).

 Che differenza c'è tra
Come ti hanno gia detto, la differenza sostanziale è che throws indica
quale tipo di eccezione può lanciare un metodo, throw viene usato per
mettere in atto il lancio dell'eccezione, mentre il blocco try/catch serve
per catturare e gestire gli errori.
Quando scrivi un metodo, è buona norma prevedere i possibili errori che
possono essere lanciati. Per esempio, un metodo che accede ad un database
può trovarsi in una situazione in cui la query lanciata non trova nessun
risultato. In questo caso potrebbe essere una soluzione (non l'unica, of
course, dipende dalle esigenze...) lanciare una NotFoundException, che
dice che la query non ha restituito alcun record.
Es.
trovaQualcosa() throws NotFoundException
{
	//vario codice di connessione
	if(rs.next())
	{
		//se trovo un risultato, lo inserisco il dato trovato in un oggetto
		oggettoVO.setProprieta(rs.getString(1));
	}
	else
	{
		//se non ci sono risultati, rs.next() restituisce false
		//quindi lancio una eccezione, con un messaggio personalizzabile.
		throw new NotFoundException("No data found for the given parameter");
	}
}
Una volta implementato il metodo, si passa alla chiamata. Bisogna sempre
catturare le eccezioni che vengono lanciate dal metodo, indipendentemente
da cosa si decide di farne. Volendo si può addirittura non gestirle, ma
non è mai una buona idea.
Le strade possono essere due: gestire subito l'eccezione, oppure
rilanciarla.
Nel primo caso, nel blocco catch bisogna inserire del codice che gestisca
il problema che ha causato l'eccezione, o eventualmente anche solo codice
di debug e log, nel caso si tratti di problemi legati a potenziali errori
di programmazione.
In questo caso avremo qualcosa del tipo
try
{
	trovaQualcosa();
}
catch(NotFoundException ex)
{
	System.out.println(ex.getMessage());
}
differente è il caso in cui si preveda di avere più livelli, ovvero si
prevede che la chiamata al nostro metodo si trovi a sua volta in un'altro
metodo, o situazioni simili. In questo caso si potrebbe voler delegare la
gestione dell'eccezione al livello superiore, mantenendo lo stesso tipo di
errore, oppure generalizzandolo (es, al client non importa che ci sia un
errore di connessione o di timeout, gli basta sapere che qualcosa non
funziona con il db)
In questo caso si fa:
try
{
	trovaQualcosa();
}
catch(NotFoundException ex)
{
	throw ex;
	//oppure:
	//throw new GenericDatabaseException("Si è verificato di DB");
}
Spero di essere stato abbastanza comprensibile, e di non aver detto
strafalcioni.
Ah, piccola aggiunta:
ci sono alcune eccezioni che vengono rilanciate automaticamente, come ad
esempio le NullPointerException, o le NumberFormatException, e altre
invece che NON POSSONO essere recuperate, come le OutOfMemory.
Nel primo caso, il compilatore non ti avvertirà di implementare il catch
dell'eccezione, mentre invece fa con gli altri tipi.
Mi unisco comunque al consiglio di leggere qualche buon manuale di Java,
come il "thinking in Java" o il "Java 2 developer handbook", o qualcosa di
simile.
Saluti
Raffaele