example - my icon java

Prueba con recursos vs Prueba-captura

Question

He estado buscando en el código y he visto probar con recursos. He usado la declaración estándar try-catch antes y parece que hacen lo mismo. Así que mi pregunta es Try With Resources vs Try-Catch cuáles son las diferencias entre esos y cuál es mejor.

Aquí hay un intento con recursos:

objects jar = new objects("brand");
objects can= new objects("brand");

try (FileOutputStream outStream = new FileOutputStream("people.bin")){
    ObjectOutputStream stream = new ObjectOutputStream(outStream);

    stream.writeObject(jar);
    stream.writeObject(can);

    stream.close();
} catch(FileNotFoundException e) {
    System.out.println("sorry it didn''t work out");
} catch(IOException f) {
    System.out.println("sorry it didn''t work out");
}

Answer 1

Cualquier objeto (ya sea la clase o su superclase) que implementa java.lang.AutoCloseable o java.io.Closeable solo se puede usar en la cláusula try-with-resource. La interfaz AutoClosable es la interfaz principal y la interfaz Closable extiende la interfaz AutoClosable. La interfaz AutoClosable tiene un método cerrado que lanza Excepción mientras que la interfaz Closable tiene un método que lanza IOException. También podemos tener captura y finalmente el bloque seguido de try-with-resource como ordinario try, catch y finalmente, pero catch y finalmente block solo se ejecutan una vez que el recurso declarado dentro de la cláusula try-with-resource está cerrado.

Answer 2

El punto principal de try-with-resources es asegurarse de que los recursos estén cerrados, sin requerir que el código de la aplicación lo haga. Sin embargo, hay algunos puntos más finos a considerar.

Cuando no usa la opción de probar con recursos, hay un posible escollo llamado enmascaramiento de excepciones. Cuando el código en un bloque de prueba lanza una excepción, y el método de cierre en la acción también produce una excepción, la excepción lanzada por el bloque de prueba se pierde y la excepción de la secuencia final se propaga. Esto suele ser desafortunado, ya que la excepción lanzada al cerrar es algo que no es útil, mientras que la excepción útil es la informativa. El uso de try-with-resources para cerrar sus recursos evitará que se realicen máscaras de excepción.

Como parte de asegurarse de que el enmascaramiento de excepciones no pierda información importante sobre las excepciones, cuando se desarrolló el método de prueba con recursos, tuvieron que decidir qué hacer con las excepciones generadas por el método de cierre.

Con try-with-resources, si el bloque try lanza una excepción y el método close también lanza una excepción, la excepción del bloque close se agrega a la excepción original :

... hay situaciones en las que se pueden lanzar dos excepciones independientes en bloques de código hermanos, en particular en el bloque try de una instrucción try-with-resources y el bloque finalmente generado por el compilador que cierra el recurso. En estas situaciones, solo una de las excepciones lanzadas puede propagarse. En la declaración try-with-resources, cuando hay dos de estas excepciones, la excepción que se origina en el bloque try se propaga y la excepción del bloque finally se agrega a la lista de excepciones suprimidas por la excepción del bloque try. Como una excepción desenrolla la pila, puede acumular múltiples excepciones suprimidas.

Por otro lado, si su código se completa normalmente, pero el recurso que está utilizando arroja una excepción al cerrarse, esa excepción (que se suprimiría si el código en el bloque de prueba arrojó algo) se lanza. Eso significa que si tiene algún código JDBC en el que se cierra un objeto ResultSet o PreparedStatement con try-with-resources, se puede lanzar una excepción resultante de algún problema de infraestructura cuando se cierra un objeto JDBC y se puede revertir una operación que de otro modo se habría completado con éxito .

Sin try-with-resources, si se lanza la excepción de método close, depende del código de la aplicación. Si se lanza en un bloque finally cuando el bloque try lanza una excepción, la excepción del bloque finally enmascarará la otra excepción. Pero el desarrollador tiene la opción de atrapar la excepción lanzada y no propagarla.

Answer 3

La única diferencia es que try-resource está agregando automáticamente resource.close(); como lo harías en bloque por finally

Answer 4

Te perdiste algo, el bloque finally . El try-with-resouces lo hará algo así como,

FileOutputStream outStream = null;
try {
  outStream = new FileOutputStream("people.bin");
  ObjectOutputStream stream = new ObjectOutputStream(outStream);

  stream.writeObject(jar);
  stream.writeObject(can);

  stream.close();
} catch(FileNotFoundException e) {
    System.out.println("sorry it didn''t work out");
} catch(IOException f) {
    System.out.println("sorry it didn''t work out");
} finally {
  if (outStream != null) { 
    try { 
      outStream.close(); 
    } catch (Exception e) {
    } 
  }
}

Lo que significa que realmente querías algo como ( nunca tragar excepciones),

try (FileOutputStream outStream = new FileOutputStream("people.bin");
     ObjectOutputStream stream = new ObjectOutputStream(outStream);) {
  stream.writeObject(jar);
  stream.writeObject(can);
  // stream.close(); // <-- closed by try-with-resources.
} catch(FileNotFoundException e) {
    System.out.println("sorry it didn''t work out");
    e.printStackTrace();
} catch(IOException f) {
    System.out.println("sorry it didn''t work out");
    e.printStackTrace();
}