Création d'exceptions Java personnalisées

Introduction

En Java, les exceptions sont levées pour indiquer des événements anormaux qui se produisent pendant l'exécution d'un programme. Bien que Java fournisse une gamme d'exceptions intégrées, parfois, nous devons définir nos propres exceptions personnalisées pour des situations spécifiques. Il existe deux types d'exceptions personnalisées : les exceptions vérifiées et les exceptions non vérifiées. Les exceptions vérifiées sont celles qui doivent être gérées pendant la compilation, tandis que les exceptions non vérifiées ne sont détectées que pendant l'exécution. Dans ce laboratoire, nous allons créer les deux types d'exceptions personnalisées et apprendre à les utiliser.

Skills Graph

Créez une classe Java nommée MyArray

Tout d'abord, nous allons créer une classe Java nommée MyArray pour implémenter un tableau avec la méthode get(), qui peut lever une exception si l'index est invalide.

public class MyArray {
    int[] array;

    public MyArray(int size) {
        array = new int[size];
        for (int i = 0; i < size; i++) {
            array[i] = i * 5;
        }
    }

    // Méthode get qui peut lever une exception
    public int get(int index) {
        if (index >= array.length) {
            throw new IndexOutOfBoundsException("Index " + index + " est invalide.");
        } else {
            return array[index];
        }
    }
}

Créez une exception vérifiée personnalisée

Nous pouvons créer une exception vérifiée personnalisée en étendant la classe Exception. Dans cet exemple, nous allons créer une IndexNotValidException lorsque l'index est invalide. Cette exception sera levée par la méthode get() dans la classe MyArray.

public class IndexNotValidException extends Exception {
    public IndexNotValidException(String message) {
        super(message);
    }
}

Nous pouvons maintenant mettre à jour la méthode get() dans la classe MyArray pour lever cette exception personnalisée.

public int get(int index) throws IndexNotValidException {
    if (index >= array.length) {
        throw new IndexNotValidException("Index " + index + " est invalide.");
    } else {
        return array[index];
    }
}

Gérer l'exception vérifiée personnalisée

Pour gérer l'exception vérifiée personnalisée, nous devons la capturer ou la déclarer à l'aide du mot clé throws lorsque la méthode get() est appelée dans la classe Demo.

public class Demo {
    public static void main(String[] args) {
        MyArray arr = new MyArray(5);
        try {
            System.out.println(arr.get(10)); // Lance IndexNotValidException
        } catch (IndexNotValidException e) {
            System.err.println(e.getMessage());
        }
    }
}

Créez une exception non vérifiée personnalisée

Nous pouvons créer une exception non vérifiée personnalisée en étendant la classe RuntimeException au lieu de la classe Exception. Dans l'exemple suivant, nous allons créer une IndexNotValidRuntimeException lorsque l'index est invalide, qui sera levée par la méthode get() dans la classe MyArray.

public class IndexNotValidRuntimeException extends RuntimeException {
    public IndexNotValidRuntimeException(String message, Throwable cause) {
        super(message, cause);
    }
}

De plus, nous définissons une exception jetable qui définit l'exception sous-jacente ou la cause de notre exception. Dans notre cas, l'exception sous-jacente est ArrayIndexOutOfBounds. Nous pouvons mettre à jour la méthode get() dans la classe MyArray pour lever l'exception non vérifiée personnalisée.

public int get(int index) {
    if (index >= array.length) {
        Throwable cause = new ArrayIndexOutOfBoundsException();
        throw new IndexNotValidRuntimeException("Index " + index + " est invalide.", cause);
    } else {
        return array[index];
    }
}

Gérer l'exception non vérifiée personnalisée

Nous n'avons pas besoin de capturer ou de déclarer l'exception non vérifiée personnalisée. Dans l'exemple suivant, lorsque la méthode get() est appelée avec un index invalide dans la classe Demo, une IndexNotValidRuntimeException sera levée.

public class Demo {
    public static void main(String[] args) {
        MyArray arr = new MyArray(5);
        System.out.println(arr.get(10)); // Lance IndexNotValidRuntimeException
    }
}

Récapitulatif

Les exceptions Java personnalisées peuvent nous aider à gérer efficacement les erreurs ou les exceptions spécifiques dans notre application en créant des exceptions adaptées à nos besoins. Dans ce laboratoire, nous avons appris comment créer nos propres exceptions personnalisées pour gérer les erreurs dans notre logique métier ou notre flux de travail. Nous avons également discuté de la création d'exceptions vérifiées et non vérifiées, avec des exemples de chacune.