Questions d'entretien Java - exceptions

Questions d'entretien sur les anomalies en Java

Les questions d'entretien sont les suivantes :

1. Que sont les exceptions en Java ?

Les exceptions sont des événements d'erreur qui peuvent survenir lors de l'exécution d'un programme et interrompre son déroulement normal. Des exceptions peuvent survenir en raison de différents types de situations telles que des données incorrectes saisies par l'utilisateur, une panne matérielle, une panne de connexion réseau, etc.

(Partage de vidéo d'apprentissage : vidéo d'enseignement Java )

Chaque fois qu'une erreur se produit lors de l'exécution d'une instruction Java, un objet d'exception sera créé, puis le JRE essaiera pour trouver un programme de gestion des exceptions pour gérer les exceptions. Si un gestionnaire d'exception approprié est trouvé, l'objet d'exception est transmis au code du gestionnaire pour gérer l'exception, appelé capture de l'exception. Si le gestionnaire n'est pas trouvé, l'application lève une exception à l'environnement d'exécution et le JRE termine le programme.

Le framework de gestion des exceptions Java est uniquement utilisé pour gérer les erreurs d'exécution. Les erreurs de compilation ne sont pas gérées par le framework de gestion des exceptions.

2. Quel est le mot-clé de gestion des exceptions en Java ?

Quatre mots-clés sont utilisés dans la gestion des exceptions Java.

throw : Parfois, nous créons explicitement un objet d'exception, puis le lançons pour arrêter le traitement normal du programme. Le mot-clé throw est utilisé pour lever une exception au runtime afin de la gérer.

throws : lorsque nous lançons une exception vérifiée dans une méthode sans la gérer, nous devons utiliser le mot-clé throws dans la signature de la méthode pour informer le programme appelant de l'exception que la méthode peut lever. La méthode appelante peut gérer ces exceptions ou les propager à sa méthode appelante à l'aide du mot-clé throws. Nous pouvons fournir plusieurs exceptions dans la clause throws et également avec la méthode main().

try-catch : Nous utilisons des blocs try-catch dans notre code pour la gestion des exceptions. try est le début du bloc et catch gère l'exception à la fin du bloc try. Nous pouvons avoir plusieurs blocs catch en utilisant try, et les blocs try-catch peuvent également être imbriqués. Le bloc catch nécessite un paramètre qui doit être de type Exception.

finally : le bloc final est facultatif et ne peut être utilisé que dans les blocs try-catch. Étant donné que les exceptions suspendent le processus d'exécution, nous pouvons ouvrir certaines ressources qui ne seront pas fermées, nous pouvons donc utiliser le bloc final. Le bloc final est toujours exécuté, qu'une exception se produise ou non.

3. Expliquer la hiérarchie des exceptions Java ?

Les exceptions Java sont hiérarchiques et l'héritage est utilisé pour classer différents types d'exceptions. Throwable est la classe parent de la hiérarchie des exceptions Java et elle a deux objets enfants : Error et Exception. Les exceptions sont divisées en exceptions vérifiées et exceptions d'exécution.

Les erreurs sont des circonstances particulières qui dépassent la portée de l'application et ne peuvent pas être prédites ni récupérées, telles qu'une panne matérielle, un crash de la JVM ou une erreur de mémoire insuffisante.

Les exceptions vérifiées sont des situations spéciales auxquelles nous pouvons nous attendre et essayer de récupérer dans nos programmes, telles que FileNotFoundException. Nous devrions intercepter cette exception, fournir un message utile à l'utilisateur et le consigner correctement pour le débogage. Exception est la classe parent de toutes les exceptions vérifiées.

Les exceptions d'exécution sont causées par une mauvaise programmation, comme la tentative de récupération d'éléments d'un tableau. Nous devons vérifier la longueur du tableau avant d'essayer de récupérer des éléments, sinon il pourrait lancer une exception ArrayIndexOutOfBoundException au moment de l'exécution. RuntimeException est la classe parent de toutes les exceptions d'exécution.

4. Quelles sont les méthodes importantes de la classe d'exception Java ?

Exception et toutes ses sous-classes ne fournissent aucune méthode spécifique, et toutes les méthodes sont définies dans la classe de base Throwable.

String getMessage（） - 此方法返回消息String of Throwable，并且可以在通过构造函数创建异常时提供消息。
String getLocalizedMessage（） - 提供此方法，以便子类可以覆盖它以向调用程序提供特定于语言环境的消息。此方法getMessage()的可抛出类实现只是使用方法来返回异常消息。
synchronized Throwable getCause（） - 此方法返回异常的原因或null id，原因未知。
String toString（） - 此方法以String格式返回有关Throwable的信息，返回的String包含Throwable类和本地化消息的名称。
void printStackTrace（） - 此方法将堆栈跟踪信息打印到标准错误流，此方法已重载，我们可以将PrintStream或PrintWriter作为参数传递，以将堆栈跟踪信息写入文件或流。

5. Expliquer les fonctionnalités de Java 7 ARM et les blocs multi-catch ?

Si vous détectez beaucoup d'exceptions dans un bloc try, vous constaterez que le code du bloc catch a l'air très moche et se compose principalement de code redondant pour enregistrer les erreurs, rappelez-vous que l'une des fonctionnalités de Java 7 est multi - bloc de capture. Nous pouvons intercepter plusieurs exceptions dans un seul bloc catch. Un bloc catch avec cette fonctionnalité ressemble à ceci :

catch(IOException | SQLException | Exception ex){
logger.error(ex);
throw new MyException(ex.getMessage());
}

La plupart du temps, nous utilisons le bloc final pour fermer les ressources, parfois nous oublions de les fermer et obtenons une exception d'exécution lorsque la ressource est épuisée. Ces exceptions sont difficiles à déboguer et nous devrons peut-être examiner chaque endroit où nous utilisons ce type de ressource pour nous assurer de la fermer. Ainsi, l'une des améliorations de Java 7 est le try-with-resources, nous pouvons créer une ressource dans l'instruction try et l'utiliser dans le bloc try-catch. Lorsque l'exécution provient d'un bloc try-catch, l'environnement d'exécution ferme automatiquement ces ressources. Un exemple de bloc try-catch avec cette amélioration est :

try (MyResource mr = new MyResource()) {
System.out.println("MyResource created in try-with-resources");
} catch (Exception e) {
e.printStackTrace();
}

(Plus de questions d'entretien connexes partagées : questions et réponses d'entretien Java)

6. Vérifié en Java Qu'est-ce que la différence entre l'exception non vérifiée ?

Les exceptions vérifiées doivent être gérées dans le code à l'aide de blocs try-catch, sinon les méthodes doivent utiliser le mot-clé throws pour informer l'appelant des exceptions vérifiées qui peuvent être générées par la méthode. Les exceptions non vérifiées n'ont pas besoin d'être gérées dans le programme ou mentionnées dans la clause throws de la méthode.

Exception est la superclasse de toutes les exceptions vérifiées, RuntimeException, et la superclasse de toutes les exceptions non vérifiées. Veuillez noter que RuntimeException est une sous-classe d'Exception.

已检查的异常是需要在代码中处理的错误方案，否则您将收到编译时错误。例如，如果您使用FileReader读取文件，它会抛出FileNotFoundException，我们必须在try-catch块中捕获它或将其再次抛给调用方法。

未经检查的异常主要是由编程不良引起的，例如在对象引用上调用方法时的NullPointerException，而不确保它不为null。例如，我可以编写一个方法来从字符串中删除所有元音。确保不传递空字符串是调用者的责任。我可能会改变方法来处理这些场景，但理想情况下，调用者应该处理这个问题。

7、Java中throw和throws关键字有什么区别？

throws关键字与方法签名一起用于声明方法可能抛出的异常，而throw关键字用于破坏程序流并将异常对象移交给运行时来处理它。

8、如何在Java中编写自定义异常？

我们可以扩展Exception类或其任何子类来创建我们的自定义异常类。自定义异常类可以拥有自己的变量和方法，我们可以使用它们将错误代码或其他与异常相关的信息传递给异常处理程序。

自定义异常的一个简单示例如下所示。

package com.journaldev.exceptions;
import java.io.IOException;
public class MyException extends IOException {
private static final long serialVersionUID = 4664456874499611218L;
private String errorCode="Unknown_Exception";
public MyException(String message, String errorCode){
super(message);
this.errorCode=errorCode;
}
public String getErrorCode(){
return this.errorCode;
}
}

9、Java中的OutOfMemoryError是什么？

Java中的OutOfMemoryError是java.lang.VirtualMachineError的子类，当JVM用完堆内存时，它会抛出它。我们可以通过提供更多内存来通过java选项运行java应用程序来修复此错误。

$>java MyProgram -Xms1024m -Xmx1024m -XX:PermSize=64M -XX:MaxPermSize=256m

10、“主线程中的异常”有哪些不同的情况？

一些常见的主线程异常情况是：

主线程java.lang.UnsupportedClassVersionError中的异常：

当您的java类是从另一个JDK版本编译并且您尝试从另一个Java版本运行它时，会出现此异常。

主线程java.lang.NoClassDefFoundError中的异常：

此异常有两种变体。第一个是您提供类全名和.class扩展名的地方。第二种情况是找不到Class。

主线程java.lang.NoSuchMethodError中的异常：

main：当您尝试运行没有main方法的类时会出现此异常。

线程“main”中的异常java.lang.ArithmeticException：

每当从main方法抛出任何异常时，它都会打印异常是控制台。第一部分解释了从main方法抛出异常，第二部分打印异常类名，然后在冒号后打印异常消息。

11、Java中的final，finally和finalize有什么区别？

final和finally是java中的关键字，而finalize是一种方法。

final关键字可以与类变量一起使用，以便它们不能被重新分配，类可以避免按类扩展，并且使用方法来避免子类覆盖。

finally关键字与try-catch块一起使用，以提供始终执行的语句即使出现一些异常，通常最终也会用来关闭资源。

finalize（）方法由垃圾收集器在销毁对象之前执行，这是确保关闭所有全局资源的好方法。

在三者之中，最后只涉及到java异常处理。

12、当main方法抛出异常时会发生什么？

当main（）方法抛出异常时，Java Runtime终止程序并在系统控制台中打印异常消息和堆栈跟踪。

13、我们可以有一个空的catch块吗？

我们可以有一个空的catch块，但它是最差编程的例子。我们永远不应该有空的catch块，因为如果异常被该块捕获，我们将没有关于异常的信息，并且它将成为调试它的噩梦。应该至少有一个日志记录语句来记录控制台或日志文件中的异常详细信息。

14、提供一些Java异常处理最佳实践？

与Java异常处理相关的一些最佳实践是：

使用特定异常以便于调试。

在程序中尽早抛出异常（Fail-Fast）。

在程序后期捕获异常，让调用者处理异常。

使用Java 7 ARM功能确保资源已关闭或使用finally块正确关闭它们。

始终记录异常消息以进行调试。

使用multi-catch块清洁关闭。

使用自定义异常从应用程序API中抛出单一类型的异常。

遵循命名约定，始终以Exception结束。

记录在javadoc中使用@throws的方法抛出的异常。

异常是昂贵的，所以只有在有意义的时候抛出它。否则，您可以捕获它们并提供空或空响应。

相关推荐：java入门教程

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!