Quand utiliser jette dans une déclaration de méthode Java?

StackOverflow https://stackoverflow.com/questions/4392446

  •  10-10-2019
  •  | 
  •  

Question

Je pensais avoir une bonne compréhension de base de gestion des exceptions en Java, mais je lisais récemment un code qui m'a donné une certaine confusion et des doutes. Mon principal doute que je veux aborder est ici quand devrait une utilisation personne jette dans une déclaration de méthode Java comme suit: 

    public void method() throws SomeException
    {
         // method body here
    }

De la lecture des messages similaires Je suppose que lance est utilisé comme une sorte de déclaration UneException pourrait être jeté lors de l'exécution de la méthode.

Ma confusion vient de code qui ressemblait à ceci: 

     public void method() throws IOException
     {
          try
          {
               BufferedReader br = new BufferedReader(new FileReader("file.txt"));
          }
          catch(IOException e)
          {
               System.out.println(e.getMessage());
          }
     }

Y at-il des raisons que vous voulez utiliser lance dans cet exemple? Il semble que si vous êtes en train de faire de base gestion des exceptions de quelque chose comme un IOException que vous auriez tout simplement besoin du bloc try / catch et c'est tout.

Était-ce utile?

La solution

Si vous attrapez un type d'exception, vous n'avez pas besoin de le jeter, à moins que vous allez réémettre il. Dans l'exemple que vous publiez, le développeur aurait dû faire un ou l'autre, pas les deux.

En règle générale, si vous n'allez faire quoi que ce soit à l'exception, vous ne devriez pas l'attraper.

La chose la plus dangereuse que vous pouvez faire est attraper une exception et rien faire.

Une bonne discussion quand il convient de lancer des exceptions est ici

Quand jeter une exception?

Autres conseils

Vous ne devez inclure une clause throws sur une méthode si la méthode renvoie une exception vérifiée. Si la méthode renvoie une exception d'exécution alors il n'y a pas besoin de le faire.

Voir ici pour des renseignements généraux sur vérifiés vs exceptions non vérifiées: http: / /download.oracle.com/javase/tutorial/essential/exceptions/runtime.html

Si la méthode attire l'exception et traite en interne (comme dans votre deuxième exemple), alors il n'y a pas besoin d'inclure une clause throws.

Le code que vous avez regardé est pas idéal. Vous devez soit:

  1. Intercepter l'exception et le manipuler; auquel cas le throws est unnecesary.

  2. Supprimer le try/catch; dans quel cas l'Exception sera assurée par un méthode d'appel.

  3. Intercepter l'exception, peut-être effectuer une action, puis réémettre l'exception (et pas seulement le message)

Vous avez raison, dans cet exemple, le throws est superflu. Il est possible qu'il ait été laissé là d'une mise en œuvre précédente -. Peut-être l'exception a été jeté au lieu de pris dans le bloc catch

Dans l'exemple que vous avez donné, la méthode ne sera jamais jeter un IOException, par conséquent, la déclaration est erronée (mais valide). Je pense que la méthode originale a lancé le IOException, mais il a ensuite été mis à jour pour gérer l'exception dans la déclaration mais n'a pas été modifiée.

Le code affiché est erroné, il doit lancer une exception si est interceptant une exception spécifique pour gestionnaire IOException mais lancer des exceptions non attrapées.

Quelque chose comme: 

public void method() throws Exception{
   try{
           BufferedReader br = new BufferedReader(new FileReader("file.txt"));
   }catch(IOException e){
           System.out.println(e.getMessage());
   }
}

ou 

public void method(){
   try{
           BufferedReader br = new BufferedReader(new FileReader("file.txt"));
   }catch(IOException e){
           System.out.println("Catching IOException");
           System.out.println(e.getMessage());
   }catch(Exception e){
           System.out.println("Catching any other Exceptions like NullPontException, FileNotFoundExceptioon, etc.");
           System.out.println(e.getMessage());
   }

}

Ce n'est pas une réponse, mais un commentaire, mais je ne pouvais pas écrire un commentaire avec un code formaté, alors voici le commentaire.

Permet de dire qu'il ya 

public static void main(String[] args) {
  try {
    // do nothing or throw a RuntimeException
    throw new RuntimeException("test");
  } catch (Exception e) {
    System.out.println(e.getMessage());
    throw e;
  }
}

La sortie est 

test
Exception in thread "main" java.lang.RuntimeException: test
    at MyClass.main(MyClass.java:10)

Cette méthode ne déclare pas « lance » exceptions, mais les jette! L'astuce est que les exceptions sont jetés RuntimeExceptions (non vérifiées) qui ne sont pas nécessaires pour être déclaré sur la méthode. Il est un peu trompeur pour le lecteur de la méthode, elle voit puisque tout est un « jet e; » déclaration, mais aucune déclaration de la lance exception

Maintenant, si nous avons 

public static void main(String[] args) throws Exception {
  try {
    throw new Exception("test");
  } catch (Exception e) {
    System.out.println(e.getMessage());
    throw e;
  }
}

Nous devons déclarer la « lancers francs » exceptions dans la méthode sinon nous obtenons une erreur de compilation.

Licencié sous: CC-BY-SA avec attribution
Non affilié à StackOverflow
scroll top