[Risolto] [Java] Eccezioni

[smile8]

Salve,
ho scritto la seguente cosa in un metodo e non mi dà problemi:

Codice: Seleziona tutto

     try{
         file.read();
      }
      catch (IOException ex)
      {
         throw new MyException("....");
       }

tuttavia, mi chiedo se questo sia logicamente corretto. Cioè io catturo una eccezione per lanciarne una di un tipo che ho definito io, in modo tale da poter distinguere poi nel main l'eccezione che è stata lanciata da questo metodo da una altra eccezione di IO lanciata dalla invocazione di un altro metodo. Quindi, vorrei sapere se è buona norma catturare le eccezioni solo quando si è in grado di gestirle (in questo caso lasciare che l'eccezione venga lanciata e gestita poi nel main) e se c'è un modo diverso per fare ciò che ho precedentemente scritto nel blocco try-catch!

[pier_IP]

Se il problema e' capire quale metodo abbia lanciato l'eccezione IO, puoi semplicemente creare piu' blocchi try-catch per catturarle. Ti suggerisco questo:

Codice: Seleziona tutto

public class MyClass{
    /*.....*/

    public void myRead() throws IOException{
         file.read();
    }
}

public static void main (String args[]) {
    MyClass ogg = new MyClass();
    try{
        ogg.myRead();
    }catch(IOException e){
        //gestisci l' eccezione
    }
    try{
        //altro metodo che puo' sollevare una IOException
        ogg.altroMetodo();
    }catch(IOException e){
        //gestisci l' eccezione
    }
}

A meno che non sei in grado di gestire la IOException lanciata nel metodo, a quel punto inserisci il try-catch direttamente nel metodo, cosi' che dal main non devi gestire nulla.

[smile8]

In effetti è una soluzione che avevo adottato ma se faccio così mi ritrovo un file difficile (a mio avviso) da leggere ed è per questo che ho deciso di catturare l'eccezione nel metodo e lanciarne una (se così si può dire) più specializzata...

[Arcovoltaico77]

concordo anch'io con Pier. meglio che il metodo sollevi la "sua" IOException ; spetta a chi userà tale metodo, se vorrà, intercettarla e gestirla come meglio crede. Così non specializzi la funzione per uno specifico caso, ma puoi riutilizzarla , tra l' altro.

Per la leggibilità, è solo questione di un minimo di pratica, fidati  (b2b)

[pygimi]

concordo anch'io con Pier. meglio che il metodo sollevi la "sua" IOException ; spetta a chi userà tale metodo, se vorrà, intercettarla e gestirla come meglio crede. Così non specializzi la funzione per uno specifico caso, ma puoi riutilizzarla , tra l' altro.

Per la leggibilità, è solo questione di un minimo di pratica, fidati  (b2b)

Concorde 

[Manaphy91]

In effetti è una soluzione che avevo adottato ma se faccio così mi ritrovo un file difficile (a mio avviso) da leggere ed è per questo che ho deciso di catturare l'eccezione nel metodo e lanciarne una (se così si può dire) più specializzata...

In effetti questo metodo, a lungo andare, su una classe medio grande non è agevole alla lettura/revisione della classe stessa.
Se quello che vuoi fare è differenziare e specializzare la gestione delle eccezioni a seconda del metodo da cui esse sono state lanciate puoi ovviare a tale scrittura, corretta ma alla volte confusionaria, mediante lo Stack Unwinding(o srotolamento dello Stack) che consiste nell'ottenere informazioni dai record di attivazione che hanno lanciato l'eccezione, ad esempio, basandoti sul nome del metodo, potresti procedere in questo modo:
Classe Prova:

Codice: Seleziona tutto

import java.util.Scanner;
public class Prova{
	public static void metodo1()throws MyException{
		throw new MyException();	
	}
	public static void metodo2()throws MyException{
		throw new MyException();	
	}
	public static void main(String [] args){
		try{
			System.out.println("Inserisci di seguito il nome del metodo che dovrà lanciare l'eccezione:");
                        Scanner tastiera=new Scanner(System.in);
			String input=tastiera.next();
			if(input.equals("metodo1"))
				metodo1();
			else if(input.equals("metodo2"))
				metodo2();
			else
				throw new MyException();	
		}catch(MyException e){
			StackTraceElement[] element=e.getStackTrace();
			if(element[0].getMethodName().equals("metodo1"))
				System.out.println("Eccezione sollevata dal metodo1");
			else if(element[0].getMethodName().equals("metodo2"))
				System.out.println("Eccezione sollevata dal metodo2");
			else
				System.out.println("Eccezione sollevata dal main");
		}
	}	
}

Classe MyException:

Codice: Seleziona tutto

public class MyException extends Exception{
	public MyException(){
		super("MyException");
	}	
	public MyException(String string){
		super(string);
	}
}

In questo modo con un solo costrutto try ed un solo catch(in questo caso specifico) gestisci tutte le possibili eccezioni lanciate con la capacità di differenziare la loro gestione a seconda di attributi quali il nome del metodo, il numero della linea di codice relativa al lancio(utile magari in fase di debug) ed altri attributi ottenibili grazie ai metodi getter della classe StackTraceElement.
Un altra procedura utilizzata al fine di ottenere informazioni in merito all'eccezione lanciata è quella di associare delle stringhe di testo, come peraltro permette già la superclasse Exception e tutte le sue sottoclassi, al momento del lancio dell'eccezione in modo da avere poi un riscontro sul motivo del lancio dell'eccezione verificabile poi con il metodo getMessage().
E' infine possibile rilanciare un'eccezione grazie agli appositi costruttori che accettano un argomento di tipo Throwable in modo da passare da un'eccezione all'altra lasciando una traccia sullo Stack.

[smile8]

Grazie a tutti per le vostre opinioni! 
la soluzione di Manaphy91 mi sembra quella più adatta al mio caso...
Grazie ancora! (b2b)