[Java] Différence entre fermable et fermable automatiquement

Interface fermable automatiquement

package java.lang;

 * An object that may hold resources (such as file or socket handles)
 * until it is closed. The {@link #close()} method of an {@code AutoCloseable}
 * object is called automatically when exiting a {@code
 * try}-with-resources block for which the object has been declared in
 * the resource specification header. This construction ensures prompt
 * release, avoiding resource exhaustion exceptions and errors that
 * may otherwise occur.
 * @apiNote
 * <p>It is possible, and in fact common, for a base class to
 * implement AutoCloseable even though not all of its subclasses or
 * instances will hold releasable resources.  For code that must operate
 * in complete generality, or when it is known that the {@code AutoCloseable}
 * instance requires resource release, it is recommended to use {@code
 * try}-with-resources constructions. However, when using facilities such as
 * {@link java.util.stream.Stream} that support both I/O-based and
 * non-I/O-based forms, {@code try}-with-resources blocks are in
 * general unnecessary when using non-I/O-based forms.
 * @author Josh Bloch
 * @since 1.7
public interface AutoCloseable {
     * Closes this resource, relinquishing any underlying resources.
     * This method is invoked automatically on objects managed by the
     * {@code try}-with-resources statement.
     * <p>While this interface method is declared to throw {@code
     * Exception}, implementers are <em>strongly</em> encouraged to
     * declare concrete implementations of the {@code close} method to
     * throw more specific exceptions, or to throw no exception at all
     * if the close operation cannot fail.
     * <p> Cases where the close operation may fail require careful
     * attention by implementers. It is strongly advised to relinquish
     * the underlying resources and to internally <em>mark</em> the
     * resource as closed, prior to throwing the exception. The {@code
     * close} method is unlikely to be invoked more than once and so
     * this ensures that the resources are released in a timely manner.
     * Furthermore it reduces problems that could arise when the resource
     * wraps, or is wrapped, by another resource.
     * <p><em>Implementers of this interface are also strongly advised
     * to not have the {@code close} method throw {@link
     * InterruptedException}.</em>
     * This exception interacts with a thread's interrupted status,
     * and runtime misbehavior is likely to occur if an {@code
     * InterruptedException} is {@linkplain Throwable#addSuppressed
     * suppressed}.
     * More generally, if it would cause problems for an
     * exception to be suppressed, the {@code AutoCloseable.close}
     * method should not throw it.
     * <p>Note that unlike the {@link java.io.Closeable#close close}
     * method of {@link java.io.Closeable}, this {@code close} method
     * is <em>not</em> required to be idempotent.  In other words,
     * calling this {@code close} method more than once may have some
     * visible side effect, unlike {@code Closeable.close} which is
     * required to have no effect if called more than once.
     * However, implementers of this interface are strongly encouraged
     * to make their {@code close} methods idempotent.
     * @throws Exception if this resource cannot be closed
    void close() throws Exception;

Interface fermable

package java.io;

import java.io.IOException;

 * A {@code Closeable} is a source or destination of data that can be closed.
 * The close method is invoked to release resources that the object is
 * holding (such as open files).
 * @since 1.5
public interface Closeable extends AutoCloseable {

     * Closes this stream and releases any system resources associated
     * with it. If the stream is already closed then invoking this
     * method has no effect.
     * <p> As noted in {@link AutoCloseable#close()}, cases where the
     * close may fail require careful attention. It is strongly advised
     * to relinquish the underlying resources and to internally
     * <em>mark</em> the {@code Closeable} as closed, prior to throwing
     * the {@code IOException}.
     * @throws IOException if an I/O error occurs
    public void close() throws IOException;

Exemple d'utilisation

import java.io.Closeable;
import java.io.IOException;

class AutoCloseableSample implements AutoCloseable {
    public void close() throws Exception {

class CloseableSample implements Closeable {
    public void close() throws IOException {

public class ExceptionSample {
    public static void main(String[] args) {
        try (CloseableSample closeableSample = new CloseableSample();  // IOException
              AutoCloseable autoCloseable = new AutoCloseableSample()   // Exception
        ) {
        } catch (IOException e) {} 
          catch (Exception e) {}


Il est fermé dans l'ordre inverse de l'ouverture avec try-with-resource.


Recommended Posts

[Java] Différence entre fermable et fermable automatiquement
[Java] Différence entre == et égal
[JAVA] Différence entre abstrait et interface
[Java] Différence entre array et ArrayList
[Java] Différence entre StringBuffer et StringBuilder
[Java] Différence entre longueur, longueur () et taille ()
Différence entre final et immuable en Java
[Pour les débutants] Différence entre Java et Kotlin
Différence entre int et Integer en Java
Différence entre vh et%
[Java] Comprendre la différence entre List et Set
Différence entre next () et nextLine () dans Java Scanner
[Java] Différence entre "variable finale" et "objet immuable"
Différence entre produit et variante
Différence entre redirect_to et render
Différence entre redirect_to et render
Différence entre CUI et GUI
Différence entre les variables et les variables d'instance
Différence entre mockito-core et mockito-all
Différence entre classe et instance
Différence entre l'installation de bundle et de bundle
Différence entre ArrayList et LinkedList
Différence entre render et redirect_to
Différence entre List et ArrayList
java Generics T et? Différence
Différence entre .bashrc et .bash_profile
Différence entre StringBuilder et StringBuffer
Différence entre render et redirect_to
[Java] Différence entre statique final et final dans les variables membres
[JAVA] Quelle est la différence entre interface et abstract? ?? ??
[Java débutant] Différence entre la longueur et la longueur () ~ Je ne sais pas ~
[Ruby] Différence entre obtenir et publier
Différence entre la méthode d'instance et la méthode de classe
Différence entre interface et classe abstraite
Différence entre l'opérateur == et la méthode égale
Différences entre Java "débutant" et Kotlin
[Terminal] Différence entre irb et pry
JavaServlet: différence entre executeQuery et executeUpdate
Différence entre l'opérateur == et la méthode eqals
Différence entre Java et JavaScript (comment trouver la moyenne)
Différence approximative entre RSpec et minitest
[Rails] Différence entre find et find_by
Différence entre la variable d'instance et la variable de classe
[Java] Relation entre H2DB et JDBC
Différence entre Thymeleaf @RestController et @Controller
Différence entre Stream map et flatMap
[Java] Différence entre l’affectation d’une variable de type de base et l’affectation d’une variable de type de référence
[Java] Vérifiez la différence entre orElse et orElseGet avec IntStream
Différence entre le type primitif et le type de référence
Différence entre string.getByte () et Hex.decodeHex (string.toCharaArray ())
Différences entre Java et .NET Framework
[Java] Différence entre l'erreur de débordement de pile et l'erreur de mémoire insuffisante
L'évaluation des courts-circuits est-elle vraiment rapide? Différence entre && et & en Java
[rails] Différence entre redirect_to et render
[Android] Différence entre finish () et return;