Les exceptions vérifiées sont un outil puissant en Java, car elles obligent le programmeur à gérer des conditions exceptionnelles, augmentant ainsi la fiabilité du code. Cependant, une utilisation excessive peut rendre les API difficiles à utiliser. Pour qu'une exception vérifiée soit justifiée, la situation doit être véritablement exceptionnelle et susceptible d'une action utile de la part du programmeur. Sinon, une exception non vérifiée peut être plus appropriée.

Java 8 a apporté un défi supplémentaire à l'utilisation des exceptions vérifiées, car les méthodes qui les lancent ne peuvent pas être utilisées directement dans les flux, ce qui nécessite une gestion supplémentaire dans le code. Pour éviter cette complexité, des alternatives peuvent être envisagées, comme renvoyer un objet facultatif au lieu de lever une exception vérifiable, ou diviser la méthode en deux, une qui vérifie la possibilité d'une erreur et une autre qui effectue l'opération.

Les exceptions cochées doivent être utilisées avec parcimonie : si la récupération n'est pas possible, utilisez des exceptions non cochées. Lorsque la récupération est possible, envisagez le retour en option. Si cela ne fournit pas suffisamment d'informations, une exception vérifiée peut être justifiée.

Plus:
Voici quelques exemples pour illustrer l'utilisation appropriée des exceptions vérifiées et des alternatives telles que Facultatif et l'utilisation des méthodes de vérification.

Utiliser les exceptions vérifiées avec parcimonie
Disons que nous avons une méthode qui charge les données à partir d'un fichier. Si le fichier n'est pas trouvé, nous souhaitons lever une exception pour informer l'appelant du problème. Dans ce cas, une exception vérifiée est appropriée car le développeur peut prendre des mesures pour résoudre le problème (par exemple en fournissant le chemin d'archive correct).

public class FileLoader {
    public String loadFile(String filePath) throws FileNotFoundException {
        File file = new File(filePath);
        if (!file.exists()) {
            throw new FileNotFoundException("Arquivo não encontrado: "   filePath);
        }
        // Código para carregar o arquivo
        return "Conteúdo do arquivo";
    }
}

Ici, l'appelant doit gérer l'exception FileNotFoundException, car il peut résoudre le problème en fournissant un chemin correct vers le fichier.

Utilisation d'exceptions facultatives au lieu d'exceptions cochées
Si le fichier manquant est une condition qui ne doit pas interrompre l'exécution normale, nous pouvons utiliser Facultatif pour indiquer que le résultat peut être manquant sans lever d'exception. Cela rend l'API plus fluide pour les cas où une absence de valeur peut être tolérée.

import java.util.Optional;

public class FileLoader {
    public Optional loadFile(String filePath) {
        File file = new File(filePath);
        if (!file.exists()) {
            return Optional.empty();
        }
        // Código para carregar o arquivo
        return Optional.of("Conteúdo do arquivo");
    }
}

Dans le code de l'appelant :

FileLoader loader = new FileLoader();
Optional content = loader.loadFile("caminho/para/arquivo.txt");
content.ifPresentOrElse(
    System.out::println,
    () -> System.out.println("Arquivo não encontrado.")
);

Dans cet exemple, l'appelant n'a pas besoin de gérer les exceptions et facultatif lui permet de gérer plus facilement le contenu manquant.

Diviser la méthode en deux : vérification et action
Dans certains cas, nous pouvons diviser la méthode en deux : une qui vérifie la condition et une autre qui effectue l’action. Cela permet à l'appelant de gérer la condition exceptionnelle avant d'appeler la méthode principale, ce qui rend l'API plus flexible.

public class FileLoader {
    // Verifica se o arquivo está disponível
    public boolean isFileAvailable(String filePath) {
        File file = new File(filePath);
        return file.exists();
    }

    // Carrega o conteúdo do arquivo
    public String loadFile(String filePath) {
        if (!isFileAvailable(filePath)) {
            throw new IllegalStateException("Arquivo não encontrado: "   filePath);
        }
        // Código para carregar o arquivo
        return "Conteúdo do arquivo";
    }
}

Dans le code de l'appelant :

FileLoader loader = new FileLoader();
String filePath = "caminho/para/arquivo.txt";

if (loader.isFileAvailable(filePath)) {
    String content = loader.loadFile(filePath);
    System.out.println(content);
} else {
    System.out.println("Arquivo não encontrado.");
}

Ici, nous utilisons IllegalStateException, une exception non vérifiée, dans le cas où l'appelant tente de charger le fichier sans vérifier au préalable s'il est disponible.

Résumé
Exception vérifiée : à utiliser pour les conditions que l'appelant peut corriger directement, telles que FileNotFoundException pour les fichiers.
Facultatif : à utiliser lorsque l'absence d'une valeur ne doit pas interrompre le déroulement du programme.

Division des méthodes : séparez les méthodes de vérification et d'exécution lorsque l'erreur peut être prédite et évitée, ce qui rend l'API plus flexible et plus simple à utiliser.