La última colección de preguntas de la entrevista de JAVA (6)

anormal

74. ¿La diferencia entre lanzamientos y lanzamientos?

Throws se usa para declarar toda la información de excepción que puede arrojar un método. Throws es declarar la excepción pero no manejarla, pero cargar la excepción, quienquiera que la llame, yo la manejaré. Y lanzar se refiere a un tipo específico de excepción lanzada.

75. ¿Cuál es la diferencia entre finalizar, finalmente y finalizar?

• Final puede modificar clases, variables y métodos. Las clases modificadas indican que la clase no se puede heredar, los métodos modificados indican que el método no se puede anular y las variables modificadas indican que la variable es una constante y no se puede reasignar.

• Finalmente se usa generalmente en el bloque de código try-catch. Cuando se trata de excepciones, generalmente debemos ejecutar el método de código en el bloque de código finalmente, lo que significa que el bloque de código se ejecutará independientemente de si hay una excepción o no, y generalmente se usa para almacenar algunos recursos de código cerrados.

• Finalize es un método que pertenece a un método de la clase Object, y la clase Object es la clase padre de todas las clases. Este método es generalmente llamado por el recolector de basura. Cuando llamamos al método gc () del Sistema, la basura el recolector llama a finalize (), recicla la basura.

76. ¿Qué parte de try-catch-finalmente se puede omitir?

Respuesta: la captura se puede omitir

la razón:

En realidad, una declaración más estricta es: try solo es adecuado para manejar excepciones en tiempo de ejecución, try + catch es adecuado para manejar excepciones en tiempo de ejecución + excepciones ordinarias. En otras palabras, si solo usa tratar de manejar excepciones ordinarias sin procesamiento de captura, la compilación no pasará, porque el compilador tiene una regla rígida de que si elige capturar excepciones ordinarias, debe usar catch para mostrar la declaración para su procesamiento posterior . La excepción de tiempo de ejecución no está tan especificada en tiempo de compilación, por lo que se puede omitir catch y agregarle el compilador de catch.

En teoría, el compilador mira cualquier código que no sea agradable a la vista y siente que puede haber problemas potenciales, por lo que incluso si agrega try a todo el código, el código es solo una capa de piel sobre la base del funcionamiento normal. durante el tiempo de ejecución. Pero una vez que agrega try a un fragmento de código, es equivalente a una promesa explícita al compilador de detectar las excepciones que este fragmento de código puede generar en lugar de hacerlo hacia arriba. Si se trata de una excepción normal, el compilador requiere que se capture por captura para su procesamiento posterior; si es anormal en tiempo de ejecución, se captura y luego se descarta y procesa con + finalmente, o se agrega una captura para su procesamiento posterior.

En cuanto a la adición, finalmente, es el procesamiento de "finalización" el que debe realizarse independientemente de si la excepción se detecta o no.

77. En try-catch-finalmente, si se devuelve la captura, ¿finalmente se ejecutará?

Respuesta: Se ejecutará y se ejecutará antes de regresar.

Ejemplo de código 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;
    }
}

Resultados de implementación: 30

Ejemplo de código 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;
    }
}

Resultados de implementación: 40

78. ¿Cuáles son las clases de excepción comunes?

• NullPointerException: esta excepción se lanza cuando la aplicación intenta acceder a un objeto nulo.

• SQLException: proporciona excepciones sobre errores de acceso a la base de datos u otra información de error.

• IndexOutOfBoundsException: se lanza cuando indica que un índice de clasificación (por ejemplo, la clasificación de una matriz, cadena o vector) está fuera de rango.

• NumberFormatException: esta excepción se produce cuando la aplicación intenta convertir una cadena en un tipo numérico, pero la cadena no se puede convertir a un formato apropiado.

• FileNotFoundException: esta excepción se lanza cuando falla un intento de abrir el archivo indicado por el nombre de ruta especificado.

• IOException: cuando se produce una determinada excepción de E / S, se lanza esta excepción. Esta clase es una clase general de excepciones generadas por operaciones de E / S fallidas o interrumpidas.

• ClassCastException: esta excepción se produce cuando se intenta convertir un objeto en una subclase que no es una instancia.

• ArrayStoreException: una excepción lanzada al intentar almacenar un objeto del tipo incorrecto en una matriz de objetos.

• IllegalArgumentException: la excepción lanzada indica que se pasó un parámetro ilegal o incorrecto al método.

• ArithmeticException: esta excepción se lanza cuando se produce una condición de funcionamiento anormal. Por ejemplo, cuando un número entero se "divide por cero", se lanza una instancia de esta clase.

• NegativeArraySizeException: si la aplicación intenta crear una matriz con un tamaño negativo, se lanza esta excepción.

• NoSuchMethodException: esta excepción se produce cuando no se puede encontrar un método específico.

• SecurityException: una excepción lanzada por el administrador de seguridad, que indica que hay una violación de seguridad.

• UnsupportedOperationException: esta excepción se lanza cuando la operación solicitada no es compatible.

• RuntimeException RuntimeException: es la superclase de excepciones que pueden producirse durante el funcionamiento normal de la máquina virtual Java.