Top 30 des questions et réponses d'entretien sur la gestion des exceptions [Pour les débutants et les expérimentés]

La gestion des exceptions est un concept qui est implémenté dans des algorithmes pour gérer les éventuelles erreurs d'exécution, qui peuvent perturber le déroulement normal d'un programme. Certaines des erreurs qui peuvent être traitées à l'aide de ce concept sont :

• ClassNotFoundExceptionClassNotFoundException
• IOException
• SQLException
• RemoteException
• Exception d'exécution :
  • ArithmeticException
  • NullPointerException
  • NumberFormatException
  • IndexOutOfBoundsExceptionIndexOutOfBoundsException
    • ArrayIndexOutOfBoundsExceptionArrayIndexOutOfBoundsException
    • StringIndexOutOfBoundsException

Le mérite de cette implémentation est d'éviter un plantage du programme s'il y a une exception lors de l'exécution du programme. Sans gestion des exceptions, le programme génère une erreur lorsqu'il rencontre une exception et le reste du programme ne sera pas exécuté. Cependant, la mise en œuvre de ce concept donnera une solution de contournement dans laquelle le reste du programme est exécuté s'ils sont indépendants par rapport à l'exception encourue. Pour en savoir plus, consultez nos cours de science des données.

Lire : Doit lire 30 questions et réponses d'entrevue avec Selenium : Guide ultime

Questions et réponses de l'entrevue sur la gestion des exceptions

1. Qu'entendez-vous par une exception ?

C'est une condition anormale que l'on rencontre parfois lors de l'exécution d'un programme. Cela perturbe le déroulement normal du programme. Il est nécessaire de gérer cette exception ; sinon, cela peut entraîner l'arrêt brutal du programme.

2. Expliquez comment les exceptions peuvent être gérées en Java. Quel est le mécanisme de gestion des exceptions derrière le processus ?

Le mécanisme de gestion des exceptions comporte trois parties. Ceux-ci sont appelés :

• Bloc d'essai : La section du code qui est d'abord tentée d'être exécutée et surveillée pour toute exception qui pourrait se produire.
• Bloc catch : si une exception est levée par le bloc 'try', elle est interceptée par cette section de code.
• Bloc final : le code de cette section est toujours exécuté, quelles que soient les exceptions détectées dans le bloc 'try', le cas échéant. Même s'il n'y a pas d'exception, le code sous ce bloc sera exécuté.

3. Est-il possible de conserver d'autres instructions entre les blocs 'try', 'catch' et 'finally' ?

Il n'est pas recommandé d'inclure des déclarations entre les sections de Les blocs 'try', 'catch' et 'finally', puisqu'ils forment une unité entière du mécanisme de gestion des exceptions.

essayer

{

//Code qui est surveillé pour les exceptions.

}

//Vous ne pouvez pas conserver les instructions ici

catch(Exception ex)

{

// Attrape les exceptions levées par le bloc try, le cas échéant.

}

//Vous ne pouvez pas conserver les instructions ici

finalement

{

//Ce bloc est toujours exécuté indépendamment des exceptions.

}

4. Sera-t-il possible d'inclure uniquement un bloc 'try' sans les blocs 'catch' et 'finally' ?

Cela donnerait une erreur de compilation. Il est nécessaire que le bloc 'try' soit suivi d'un bloc 'catch' ou d'un bloc 'finally', sinon des deux. L'un des blocs 'catch' ou 'finally' est nécessaire pour que le flux de gestion des exceptions ne soit pas interrompu.

5. Sera-t-il possible de conserver les instructions après le bloc 'finally' si le contrôle revient du bloc finally lui-même ?

Cela entraînera une erreur de bloc catch inaccessible. C'est parce que le contrôle reviendra du bloc 'finally' lui-même. Le compilateur ne parviendra pas à exécuter le code après la ligne avec l'exception. C'est pourquoi l'exécution affichera une erreur de code inaccessible.

6. Expliquez une erreur de bloc catch inaccessible.

Dans le cas de plusieurs blocs catch, l'ordre dans lequel les blocs catch sont placés va du plus spécifique au plus général. Autrement dit, les sous-classes d'une exception doivent venir en premier, puis les super classes suivront. Dans le cas où les super classes sont conservées en premier, suivies des sous-classes après, le compilateur affichera une erreur de bloc catch inaccessible.

classe publique ExceptionHandling

{

public static void main(String[] args)

{

essayer

{

int je = Entier.parseInt("test");

//Cette instruction lèvera une NumberFormatException //parce que l'entrée donnée est une chaîne, tandis que le //format spécifié est un entier.

}

catch(Exception ex)

{

System.out.println("Ce bloc gère tous les types d'exceptions");

//Toutes sortes d'exceptions peuvent être gérées dans ce //bloc puisqu'il s'agit d'une super classe d'exceptions.

}

catch(NumberFormatException ex)

{

// Cela donnera une erreur de temps de compilation

//Ce bloc deviendra inaccessible car le

//l'exception serait déjà interceptée par le //bloc catch ci-dessus

}

}

}

7. Considérez trois instructions dans un bloc 'try' : instruction1, instruction2 et instruction3. Il est suivi d'un bloc 'catch' pour intercepter les exceptions survenues lors de l'exécution du bloc 'try'. Supposons que l'exception est levée à instruction2. Pensez-vous que l'instruction3 sera exécutée ?

Statement3 ne sera pas exécuté. Si une exception est lancée par le bloc 'try' à tout moment, le code restant après l'exception ne sera pas exécuté. Au lieu de cela, le contrôle de flux viendra directement au bloc 'catch'.

8. Différencier erreur et exception en Java.

le différence clé entre erreur et exception est que, bien que l'erreur soit causée par l'environnement dans lequel la JVM (Java Virtual Machine) s'exécute, les exceptions sont causées par le programme lui-même. Par exemple, OutOfMemory est une erreur qui se produit lorsque la JVM épuise sa mémoire.

Mais NullPointerException est une exception rencontrée lorsque le programme tente d'accéder à un objet nul. La récupération d'une erreur n'est pas possible. Par conséquent, la seule solution à une erreur est de terminer l'exécution. Cependant, il est possible de contourner les exceptions en utilisant des blocs try et catch ou en renvoyant des exceptions à la fonction appelante.

Doit lire: Questions et réponses d'entrevue Java

9. Quels sont les types d'exceptions ? Expliquez-les.

Il existe deux types d'exceptions :

Exceptions vérifiées

Type d'exceptions connues et reconnues par le compilateur. Ces exceptions ne peuvent être vérifiées qu'au moment de la compilation. Par conséquent, elles sont également appelées exceptions de temps de compilation. Ceux-ci peuvent être gérés en utilisant des blocs try et catch ou en utilisant une clause throw. Si ces exceptions ne sont pas gérées correctement, elles produiront des erreurs de compilation. Les exemples incluent les sous-classes de java.lang.Exception à l'exception de RunTimeException.

Exceptions non contrôlées

Le type d'exceptions qui ne sont pas reconnues par le compilateur. Ils se produisent uniquement au moment de l'exécution. Par conséquent, elles sont également appelées exceptions d'exécution. Ils ne sont pas vérifiés au moment de la compilation. Par conséquent, même après une compilation réussie, ils peuvent entraîner l'arrêt prématuré du programme s'ils ne sont pas gérés correctement. Les exemples incluent les sous-classes de java.lang.RunTimeException et java.lang.Error.

10. Quelle est la hiérarchie des exceptions en Java ?

Le java.lang.Throwable est une super classe de toutes les erreurs et exceptions en Java. Cette classe étend la classe java.lang.Object. L'argument du bloc catch doit être son type ou son type de sous-classe uniquement. La classe Throwable comprend deux sous-classes :

1. java.lang.Error : Il s'agit d'une super classe pour tous les types d'erreurs en Java. Les erreurs courantes incluses dans ce cadre sont -
   1. java.lang.VirtualMachineError : Sous ceci -
      1. StackOverFlowError
      2. OutOfMemoryError
   2. java.lang.AssertionError
   3. java.lang.LinkageError : Sous ceci -
      1. NoClassDefFoundError
      2. IncompatibleClassChangeError
2. java.lang.Exception : il s'agit d'une super classe de tous les types d'exceptions en Java. Les exceptions courantes en vertu de cela sont -
   1. RunTimeException
      1. ArithmeticException
      2. NumberFormatException
      3. NullPointerException
      4. ArrayIndexOutOfBoundsExceptionArrayIndexOutOfBoundsException
      5. ClassCastException
   2. java.lang.InterruptedException
   3. java.lang.IOException
   4. java.lang.SQLException
   5. java.lang.ParseException

11. Que sont les exceptions d'exécution en Java ? Donnez quelques exemples.

Les exceptions qui se produisent au moment de l'exécution sont appelées exceptions d'exécution. Le compilateur ne peut pas reconnaître ces exceptions, comme les exceptions non contrôlées. Il inclut toutes les sous-classes de java.lang.RunTimeException et java.lang.Error. Les exemples incluent, NumberFormatException, NullPointerException, ClassCastException, ArrayIndexOutOfBoundException, StackOverflowError etc.

12. Définissez OutOfMemoryError en Java.

C'est la sous-classe de java.lang.Error qui est rencontrée lorsque la JVM manque de mémoire.

13. Différencier NoClassDefFoundError et ClassNotFoundException en Java.

NoClassDefFoundError et ClassNotFoundException se produisent lorsqu'une classe particulière est introuvable au moment de l'exécution. Cependant, ils se produisent dans différents scénarios. NoClassDefFoundError se produit lorsqu'une erreur se produit parce qu'une classe particulière était présente au moment de la compilation mais qu'elle manquait au moment de l'exécution. ClassNotFoundException se produit lorsqu'une exception est rencontrée pour une application essayant de charger une classe au moment de l'exécution qui n'est pas mise à jour dans le classpath.

14. Le bloc 'finally' est-il exécuté si l'un des blocs 'try' ou 'catch' renvoie le contrôle ?

Le bloc 'finally' est toujours exécuté, que les blocs try ou catch renvoient le contrôle ou non.

15. Est-il possible de lever une exception manuellement ? Si oui, expliquez comment.

Il est possible de lever une exception manuellement. Cela se fait à l'aide du mot clé 'throw'. La syntaxe pour lever une exception manuellement est

lancer InstanceOfThrowableType ;

Voici un exemple d'utilisation du mot clé 'throw' pour lever une exception manuellement.

essayer

{

NumberFormatException ex = new NumberFormatException(); // Ici, nous créons explicitement un objet pour NumberFormatException

jeter ex; // lancer explicitement l'objet NumberFormatException à l'aide du mot-clé throw

}

catch(NumberFormatException ex)

{

System.out.println("Dans ce bloc, l'objet NumberFormatException explicitement lancé peut être intercepté.");

}

Lire : Top 35 des questions et réponses des entretiens de printemps : Guide ultime

16. Qu'entendez-vous par relancer une exception en Java ?

Les exceptions levées dans le bloc 'try' sont gérées dans le bloc 'catch'. Si le bloc 'catch' est incapable de gérer cette exception, il est possible qu'il puisse relancer la même exception en utilisant le mot clé 'throw'. Ce mécanisme s'appelle relancer une exception. La mise en œuvre est la suivante :

essayer

{

Chaîne s = null ;

System.out.println(s.length()); //Cette instruction lève une NullPointerException

}

catch(NullPointerException ex)

{

System.out.println("Ici l'exception NullPointerException est interceptée");

jeter ex; //Relancer l'exception NullPointerException

}

17. Pourquoi utilisez-vous le mot clé 'throws' en Java ?

S'il est possible pour une méthode de lever une exception si elle n'a pas pu être gérée, elle doit spécifier cette exception à l'aide du mot clé 'throws'. Cela sera utile aux fonctions appelantes de cette méthode pour gérer cette exception. La syntaxe pour utiliser le mot-clé 'throws' est,

return_type method_name(parameter_list) lève exception_list

{

//code

}

Ici, exception_list est la liste des exceptions qui peuvent être levées par la méthode. Ces exceptions doivent être séparées par des virgules. Un exemple de code :

classe publique ExceptionHandling

{

public static void main(String[] args)

{

essayer

{

methodWithThrows();

}

catch(NullPointerException ex)

{

System.out.println("L'exception NullPointerException lancée par la méthode methodWithThrows() sera interceptée ici");

}

}

static void methodWithThrows() lève NullPointerException

{

Chaîne s = null ;

System.out.println(s.length()); // Cette instruction lève NullPointerException

}

}

18. Il est souvent recommandé de conserver les opérations de nettoyage telles que la fermeture des ressources de la base de données à l'intérieur du bloc 'finally'. Pourquoi est-ce nécessaire ?

Le bloc 'finally' est toujours exécuté indépendamment du fait que des exceptions sont levées dans le bloc 'try' ou si les exceptions levées sont interceptées dans le bloc 'catch' ou non. Le maintien des opérations de nettoyage dans le bloc « enfin » garantit le fonctionnement de ces opérations dans tous les cas, et ne sera pas affecté par des exceptions, qui peuvent ou non augmenter.

19. Comment feriez-vous la différence entre final, finally et finalize en Java ?

Premièrement, 'final' est un mot-clé qui peut être utilisé pour rendre une variable ou une méthode ou une classe inchangeable. Pour faire simple, si une variable est déclarée comme final, une fois qu'elle est initialisée, sa valeur ne peut plus être modifiée. Si une méthode est déclarée finale, elle ne peut pas être remplacée ou modifiée dans la sous-classe. Si une classe est déclarée finale, elle ne peut pas être étendue à d'autres classes.

Deuxièmement, 'finally' est un bloc qui est utilisé dans la gestion des exceptions avec les blocs 'try' et 'catch'. Ce bloc est toujours exécuté indépendamment d'une exception levée ou si l'exception levée est gérée. Habituellement, ce bloc est utilisé pour effectuer des opérations de nettoyage afin de fermer les ressources telles que la connexion à la base de données, les ressources d'E/S, etc.

Troisièmement, la méthode finalize() est une méthode protégée. Il appartient à la classe java.lang.Object. Chaque classe créée en Java hérite de cette méthode. Le thread du ramasse-miettes appelle cette méthode avant qu'un objet ne soit supprimé de la mémoire. Avant qu'un objet ne soit supprimé de la mémoire, cette méthode est utilisée pour effectuer certaines des opérations de nettoyage.

protected void finalize() lance Throwable

{

//Opérations de nettoyage

}

20. Que sont les exceptions personnalisées en Java ?

Les classes d'exception peuvent être levées en Java selon les exigences du déroulement du programme. Ces exceptions sont appelées exceptions définies par l'utilisateur. Elles sont également appelées exceptions personnalisées. Ces exceptions doivent étendre l'une des classes de la hiérarchie des exceptions.

21. Comment expliqueriez-vous une ClassCastException en Java ?

Lorsque la JVM est incapable de convertir un objet d'un type en un autre type, cette exception est déclenchée. Il s'agit d'une RunTimeException.

22. Faites la différence entre jeter, jeter et jeter en Java.

Tout d'abord, le mot clé 'throw' est utilisé pour lever une exception manuellement en Java. En utilisant ce mot-clé, il est possible de lever une exception à partir de n'importe quelle méthode ou bloc. Cependant, il est essentiel que l'exception soit de type classe java.lang.Throwable ou qu'elle appartienne à l'une des sous-classes de la classe java.lang.Throwable.

Deuxièmement, le mot clé 'throws' est utilisé dans la signature de la méthode en Java. Si la méthode est capable de lever des exceptions, cela est indiqué par cette méthode. Les exceptions mentionnées sont gérées par leurs fonctions d'appelant respectives. Cela se fait soit en utilisant des blocs try et catch, soit en utilisant le mot-clé throws.

Troisièmement, la super classe pour tous les types d'erreurs et d'exceptions en Java s'appelle Throwable. Il fait partie du package java.lang. La JVM ou l'instruction throw ne déclenche que des instances de cette classe ou de ses sous-classes. Le bloc catch ne doit contenir qu'un seul argument et il doit être de ce type ou de ses sous-classes. Si des exceptions personnalisées sont créées, elles doivent également étendre cette classe.

23. Expliquez StackOverflowError en Java.

Il s'agit d'une erreur générée par la JVM lorsque la pile déborde lors de l'exécution.

24. Est-il possible de remplacer une méthode de super classe qui lève une exception non vérifiée avec des exceptions vérifiées dans la sous-classe ?

Ce n'est pas possible car si une méthode de super classe lève une exception non vérifiée, elle sera remplacée dans la sous-classe avec la même exception ou toute autre exception non vérifiée. Mais, il ne peut pas être remplacé par des exceptions vérifiées.

25. Définissez des exceptions chaînées en Java.

Dans un programme, une exception peut déclencher plusieurs exceptions en induisant un effet domino. Cela provoque une chaîne d'exceptions. Il est utile de connaître l'emplacement de la cause réelle de l'exception. Cela est possible avec la fonctionnalité d'exceptions chaînées de Java. Cela a été introduit depuis JDK 1.4. Pour l'implémentation d'exceptions chaînées en Java, deux nouveaux constructeurs et deux nouvelles méthodes sont inclus dans la classe Throwable. Ceux-ci sont,

Constructeurs de la classe Throwable :

1. 1. Throwable(Throwable cause) : la cause est l'exception qui déclenche l'exception actuelle.
   2. Throwable(String msg, Throwable cause) : la chaîne msg est le message d'exception. L'exception qui déclenche l'exception actuelle est la cause ici.

Méthodes de la classe Throwable :

1. 1. Méthode getCause() : La cause réelle d'une exception déclenchée est renvoyée par cette méthode.
   2. Méthode initCause(Throwable cause) : La cause de l'exception d'appel est définie par cette méthode.

26. Quelle classe est définie comme une super classe pour tous les types d'erreurs et d'exceptions en Java ?

La super classe pour tous les types d'erreurs et d'exceptions est java.lang.Throwable en Java.

27. Qu'est-ce qui peut être classé comme une combinaison correcte de blocages try, catch et finally ?

Une combinaison de bloc try et catch.

essayer

{

// essayer de bloquer

}

catch(Exception ex)

{

// bloc de capture

}

Une combinaison d'essayer et de bloquer enfin.

essayer

{

// essayer de bloquer

}

finalement

{

// enfin bloquer

}

Une combinaison des trois : essayer, bloquer, enfin bloquer.

essayer

{

// essayer de bloquer

}

catch(Exception ex)

{

// bloc de capture

}

finalement

{

// enfin bloquer

}

28. Pourquoi utilisez-vous la méthode printStackTrace() ?

Cette méthode est utilisée pour imprimer des informations détaillées sur l'exception qui s'est produite.

29. Quels sont quelques exemples d'exceptions vérifiées ?

Certains exemples d'exceptions vérifiées incluent ClassNotFoundException, SQLException et IOException.

30. Quels sont quelques exemples d'exceptions non contrôlées ?

Quelques exemples d'exceptions non vérifiées incluent NullPointerException, ArrayIndexOutOfBoundsException et NumberFormatException.

Lisez aussi: Doit lire 47 questions et réponses d'entrevue OOPS pour les débutants et les expérimentés

Emballer

Si vous souhaitez en savoir plus sur le Big Data, consultez le diplôme PG upGrad & IIIT-B en développement de logiciels à pile complète, conçu pour les professionnels en activité et offrant plus de 500 heures de formation rigoureuse, plus de 9 projets et missions, IIIT -B Statut d'ancien, projets de synthèse pratiques et aide à l'emploi avec les meilleures entreprises.

Si vous êtes intéressé à apprendre la science des données et optez pour une carrière dans ce domaine, consultez le programme exécutif PG de l'IIIT-B et upGrad en science des données qui est créé pour les professionnels en activité et propose plus de 10 études de cas et projets, des ateliers pratiques pratiques , mentorat avec des experts de l'industrie, 1-on-1 avec des mentors de l'industrie, plus de 400 heures d'apprentissage et d'aide à l'emploi avec les meilleures entreprises.

Préparez-vous à une carrière d'avenir

Postuler pour un Master of Science en Data Science