Questions d'entretien sur les nouvelles Java 2020 - Exception-JavaQuestions d'entretien-php.cn

Questions d'entretien sur les nouvelles Java 2020 - Exception

1. Quelle est la différence entre lancer et lancer ?

throws est utilisé pour déclarer toutes les informations d'exception qu'une méthode peut lancer, c'est déclarer l'exception mais ne pas la gérer. Au lieu de cela, il téléchargera l'exception et laissera celui qui l'appelle la gérer. Throw fait référence à un type d’exception spécifique lancé.

2. Quelle est la différence entre final, enfin et finaliser ?

Final peut modifier les classes, les variables et les méthodes. La classe modifiée signifie que la classe ne peut pas être héritée, la méthode modifiée signifie que la méthode ne peut pas être remplacée et la variable modifiée signifie que la variable est une constante et ne peut pas être réaffecté.

finally fonctionne généralement dans le bloc de code try-catch. Lors de la gestion des exceptions, nous mettons généralement la méthode de code qui doit être exécutée dans le bloc de code final, ce qui signifie que le bloc de code sera exécuté indépendamment du fait qu'un une exception se produit. Généralement utilisé pour stocker du code pour la fermeture des ressources.

(Tutoriel vidéo recommandé : Tutoriel vidéo Java )

finalize est une méthode qui appartient à la classe Object, et la classe Object est la classe parent de toutes les classes. La méthode est généralement appelée par le garbage collector. Lorsque nous appelons la méthode gc() du système, le garbage collector appelle finalize() pour collecter les garbage.

3. Quelle partie de try-catch-finally peut être omise ?

Réponse : catch peut être omis

Raison :

Une déclaration plus stricte est en fait : try ne convient que pour gérer les exceptions d'exécution, try+catch convient pour gérer les exceptions d'exécution Exception temporelle + exception ordinaire. En d'autres termes, si vous utilisez uniquement try pour gérer les exceptions ordinaires sans utiliser catch, la compilation ne réussira pas, car le compilateur stipule de manière rigide que si vous choisissez d'intercepter les exceptions ordinaires, vous devez utiliser catch pour les déclarer explicitement pour un traitement ultérieur. Il n'existe aucune disposition de ce type pour les exceptions d'exécution au moment de la compilation, donc catch peut être omis, et il n'y a rien de mal à ajouter le compilateur catch.

Théoriquement, le compilateur n'est pas satisfait de tout code et pense qu'il peut y avoir des problèmes potentiels, donc même si vous ajoutez try à tout le code, le code ne s'exécutera normalement que pendant l'exécution. Ajoutez une couche de skin. Mais une fois que vous avez ajouté try à un morceau de code, vous promettez explicitement au compilateur d'intercepter les exceptions qui peuvent être générées par ce morceau de code au lieu de les lancer vers le haut. S'il s'agit d'une exception normale, le compilateur exige qu'elle soit interceptée avec catch pour un traitement ultérieur ; s'il s'agit d'une exception d'exécution, elle est interceptée et rejetée et +finalement traitée, ou un catch est ajouté pour un traitement ultérieur.

Quant à l'ajout final, il s'agit d'un processus de "nettoyage" qui doit être effectué indépendamment du fait qu'une exception soit interceptée ou non.

(Tutoriels associés recommandés : programme d'entrée Java)

4 Dans try-catch-finally, s'il y a un retour dans catch, le sera finalement quand même. être exécuté ?

Réponse : Elle sera exécutée avant le retour.

Exemple de code 1 :

 
/*
 * java面试题--如果catch里面有return语句，finally里面的代码还会执行吗？
 */
public class FinallyDemo2 {
    public static void main(String[] args) {
        System.out.println(getInt());
    }
 
    public static int getInt() {
        int a = 10;
        try {
            System.out.println(a / 0);
            a = 20;
        } catch (ArithmeticException e) {
            a = 30;
            return a;
            /*
             * return a 在程序执行到这一步的时候，这里不是return a 而是 return 30；这个返回路径就形成了
             * 但是呢，它发现后面还有finally，所以继续执行finally的内容，a=40
             * 再次回到以前的路径,继续走return 30，形成返回路径之后，这里的a就不是a变量了，而是常量30
             */
        } finally {
            a = 40;
        }
 
//      return a;
    }
}

Copier après la connexion

Résultat de l'exécution : 30

Exemple de code 2 :

 
package com.java_02;
 
/*
 * java面试题--如果catch里面有return语句，finally里面的代码还会执行吗？
 */
public class FinallyDemo2 {
    public static void main(String[] args) {
        System.out.println(getInt());
    }
 
    public static int getInt() {
        int a = 10;
        try {
            System.out.println(a / 0);
            a = 20;
        } catch (ArithmeticException e) {
            a = 30;
            return a;
            /*
             * return a 在程序执行到这一步的时候，这里不是return a 而是 return 30；这个返回路径就形成了
             * 但是呢，它发现后面还有finally，所以继续执行finally的内容，a=40
             * 再次回到以前的路径,继续走return 30，形成返回路径之后，这里的a就不是a变量了，而是常量30
             */
        } finally {
            a = 40;
            return a; //如果这样，就又重新形成了一条返回路径，由于只能通过1个return返回，所以这里直接返回40
        }
 
//      return a;
    }
}

Copier après la connexion

Résultat de l'exécution : 40

5. Quels sont les types d'exceptions courants ?

NullPointerException : cette exception est levée lorsque l'application tente d'accéder à un objet nul.
SQLException : Exception qui fournit des informations sur les erreurs d'accès à la base de données ou d'autres erreurs.
IndexOutOfBoundsException : levée lors de l'indication qu'un index de tri (tel que le tri d'un tableau, d'une chaîne ou d'un vecteur) est hors de portée.
NumberFormatException : cette exception est levée lorsque l'application tente de convertir une chaîne en un type numérique, mais que la chaîne ne peut pas être convertie au format approprié.
FileNotFoundException : cette exception est levée lorsqu'une tentative d'ouverture du fichier représenté par le nom de chemin spécifié échoue.
IOException : cette exception est levée lorsqu'une sorte d'exception d'E/S se produit. Cette classe est une classe générale pour les exceptions générées par des opérations d'E/S échouées ou interrompues.
ClassCastException : cette exception est levée lorsqu'une tentative est effectuée pour convertir un objet en une sous-classe qui n'est pas une instance.
ArrayStoreException : Exception levée lors de la tentative de stocker un objet du mauvais type dans un tableau d'objets.
IllegalArgumentException : une exception levée indiquant qu'un paramètre illégal ou incorrect a été transmis à la méthode.
ArithmeticException : cette exception est levée lorsque des conditions de fonctionnement anormales se produisent. Par exemple, lorsqu'un entier est « divisé par zéro », une instance de cette classe est levée.
NegativeArraySizeException : Cette exception est levée si l'application tente de créer un tableau avec une taille négative.
NoSuchMethodException : cette exception est levée lorsqu'une méthode spécifique est introuvable.
SecurityException : Exception levée par le responsable de la sécurité pour indiquer une violation de sécurité.
UnsupportedOperationException : cette exception est levée lorsque l'opération demandée n'est pas prise en charge.
RuntimeExceptionRuntimeException : est la super classe d'exceptions qui peuvent être levées lors du fonctionnement normal de la machine virtuelle Java.