TOC

Différence entre jets et jets en Java

Différence entre jets et jets en Java

1. introduction

Dans ce didacticiel, nous allons examiner lesthrow etthrows en Java. Nous vous expliquerons quand nous devons utiliser chacun d’eux.

Ensuite, nous montrerons quelques exemples de leur utilisation de base.

2. Throw etThrows

Commençons par une brève introduction. Ces mots clés sont liés à la gestion des exceptions. Exceptions are raised when the normal of flow of our application is disrupted.

Il peut y avoir beaucoup de raisons. Un utilisateur pourrait envoyer les mauvaises données d'entrée. Nous pouvons perdre une connexion ou une autre situation imprévue peut se produire. Une bonne gestion des exceptions est la clé pour que notre application continue à fonctionner après l'apparition de ces moments désagréables.

We use throw keyword to explicitly throw an exception du code. Il peut s'agir d'une méthode ou d'un bloc statique. Cette exception doit être une sous-classe deThrowable. De plus, il peut s'agir d'unThrowable lui-même. Nous ne pouvons pas lancer plusieurs exceptions avec un seulthrow.

Le mot cléThrows peut être placé dans la déclaration de méthode. It denotes which exceptions can be thrown from this method. Nous devons gérer ces exceptions avec try-catch.

Ces deux mots clés ne sont pas interchangeables!

3. Throw en Java

Jetons un coup d'œil à un exemple de base en lançant une exception à la méthode.

Tout d’abord, imaginez que nous écrivons une simple calculatrice. L'une des opérations arithmétiques de base est la division. Pour cette raison, on nous a demandé d'implémenter cette fonctionnalité: 

public double divide(double a, double b) {
    return a / b;
}

Comme nous ne pouvons pas diviser par zéro, nous devons ajouter quelques modifications à notre code existant. Il semble que ce soit un bon moment pour lever une exception.

Faisons cela: 

public double divide(double a, double b) {
    if (b == 0) {
        throw new ArithmeticException("Divider cannot be equal to zero!");
    }
    return a / b;
}

Comme vous pouvez le voir, nous avons utiliséArithmeticException avec parfaitement adapté à nos besoins. Nous pouvons passer un seul paramètre de constructeurString qui est un message d'exception.

3.1. Bonnes pratiques

We should always prefer the most specific exception. Nous devons trouver une classe qui correspond le mieux à notre événement exceptionnel. Par exemple, lancerNumberFormatException à la place deIllegalArgumentException.  Nous devrions éviter de lancer unException non spécifique.

Par exemple, il existe une classeInteger dans le packagejava.lang. Jetons un coup d'œil à celle de la déclaration de méthode de fabrique: 

public static Integer valueOf(String s) throws NumberFormatException

C'est une méthode de fabrique statique qui crée une instance deInteger à partir deString. .

A good idea is to define our own, more descriptive exception. Dans notreCalculator classe qui pourrait être par exempleDivideByZeroException. 

Jetons un coup d'œil à un exemple de mise en œuvre: 

public class DivideByZeroException extends RuntimeException {

    public DivideByZeroException(String message) {
        super(message);
    }
}

3.2. Emballer une exception existante

Parfois, nous voulons inclure une exception existante dans l'exception définie par nous.

Commençons par définir notre propre exception: 

public class DataAcessException extends RuntimeException {

    public DataAcessException(String message, Throwable cause) {
        super(message, cause);
    }
}

Le constructeur prend deux paramètres: un message d'exception et une cause, qui peut être n'importe quelle sous-classe deThrowable. 

Écrivons une fausse implémentation pour la fonctionfindAll() : 

public List findAll() throws SQLException {
    throw new SQLException();
}

Maintenant, dansSimpleService appelons une fonction de référentiel, ce qui peut entraînerSQLException: 

public void wrappingException() {
    try {
        personRepository.findAll();
    } catch (SQLException e) {
        throw new DataAccessException("SQL Exception", e);
    }
}

Nous relançonsSQLException encapsulé dans notre propre exception appeléeDataAccessException.  Tout est vérifié par le test suivant: 

@Test
void whenSQLExceptionIsThrown_thenShouldBeRethrownWithWrappedException() {
    assertThrows(DataAccessException.class,
      () -> simpleService.wrappingException());
}

Il y a deux raisons pour cela. Tout d'abord, nous utilisons le wrapping des exceptions, car le reste du code n'a pas besoin de connaître toutes les exceptions possibles du système.

De plus, les composants de niveau supérieur n'ont pas besoin de connaître les composants de niveau inférieur, ni les exceptions qu'ils émettent.

3.3. Multi-captures avec Java

Parfois, les méthodes que nous utilisons peuvent générer de nombreuses exceptions différentes.

Jetons un coup d'œil à un bloc try-catch plus complet: 

try {
    tryCatch.execute();
} catch (ConnectionException | SocketException ex) {
    System.out.println("IOException");
} catch (Exception ex) {
    System.out.println("General exception");
}

La méthodeexecute peut lever trois exceptions:SocketException, ConnectionException, Exception. Le premier bloc catch captureraConnectionException ouSocketException. Le deuxième bloc catch attraperaitException  ou toute autre sous-classe deException.  Souvenez-vous quewe should always catch a more detailed exception first.

Nous pouvons échanger la commande de nos blocs de capture. Ensuite, nous n'attraperons jamaisSocketException etConnectionException car tout ira à la capture avecException.

4. Throws en Java

Nous ajoutonsthrows à la déclaration de méthode.

Jetons un coup d'œil à l'une de nos précédentes déclarations de méthode: 

public static void execute() throws SocketException, ConnectionException, Exception

The method may throw multiple exceptions. Ils sont séparés par des virgules à la fin d'une déclaration de méthode. Nous pouvons mettre à la fois des exceptions cochées et non cochées dans lethrows.  Nous avons décrit la différence entre elles ci-dessous.

4.1. Exceptions cochées et non cochées

A checked exception means that it’s checked at the compile time. Notez que nous devons gérer cette exception. Sinon, une méthode doit spécifier une exception à l'aide du mot cléthrows.

Les exceptions vérifiées les plus courantes sontIOException, FileNotFoundException, ParseException. FileNotFoundException qui peuvent être levées lorsque nous créonsFileInputStream à partir deFile. 

Voici un petit exemple: 

File file = new File("not_existing_file.txt");
try {
    FileInputStream stream = new FileInputStream(file);
} catch (FileNotFoundException e) {
    e.printStackTrace();
}

Nous pouvons éviter d'utiliser le bloc try-catch en ajoutantthrows à la déclaration de méthode: 

private static void uncheckedException() throws FileNotFoundException {
    File file = new File("not_existing_file.txt");
    FileInputStream stream = new FileInputStream(file);
}

Malheureusement, une fonction de niveau supérieur doit encore gérer cette exception. Sinon, nous devons mettre cette exception dans la déclaration de méthode avecthrows keyword.

Au contraire,unchecked exceptions aren’t checked at the compile time. 

Les exceptions non vérifiées les plus courantes sont:ArrayIndexOutOfBoundsException, IllegalArgumentException, NullPointerException. 

Unchecked exceptions are thrown during runtime. Le code suivant lèvera unNullPointerException. C'est probablement l'une des exceptions les plus courantes en Java.

L'appel d'une méthode sur une référence null entraînera cette exception: 

public void runtimeNullPointerException() {
    String a = null;
    a.length();
}

Vérifions ce comportement lors du test: 

@Test
void whenCalled_thenNullPointerExceptionIsThrown() {
    assertThrows(NullPointerException.class,
      () -> simpleService.runtimeNullPointerException());
}

S'il vous plaît rappelez-vous que ce code et test n'a pas beaucoup de sens. C'est uniquement à des fins d'apprentissage d'expliquer les exceptions d'exécution.

En Java, chaque sous-classe deError etRuntimeException est une exception non vérifiée. Une exception vérifiée est tout le reste sous la classeThrowable .

5. Conclusion

Dans cet article, nous avons discuté de la différence entre deux mots-clés Java:throw etthrows.  Nous avons passé en revue l'utilisation de base et parlé un peu des bonnes pratiques.  Ensuite, nous avons parlé de exceptions cochées et non cochées.

Comme toujours, le code source peut être trouvéon our GitHub.

Si vous souhaitez approfondir la gestion des exceptions en Java, veuillez consulter notre articleabout Java exceptions.

Related