关于jls的一点的澄清

Question

直接从这个jls

带有声明多个资源的ResourceSpecification子句的try- with语句被视为是多个具有资源的尝试语句，每个语句都有一个声明单个资源的ResourceSpecification子句。当一个具有n资源(n > 1)的try- with -resources语句被翻译时，结果是一个具有n-1资源的try-语句。在n个这样的翻译之后，有n个嵌套的尝试-捕获-最终语句，并且整个翻译已经完成。

对我来说，上面引述的声明的最后一部分是非常清楚的.为什么我已经声明了n个资源，就像他们所说的the result is a try-with-resources statement with n-1 Resources

为什么没有n种资源呢？

提前谢谢。

Answer 1

这在使用Java 7更好的资源管理:超越语法糖中有或多或少的解释。以这个片段为例：

try(
    FileInputStream fin = new FileInputStream(input);
    FileOutputStream fout = new FileOutputStream(output);
    GZIPOutputStream out = new GZIPOutputStream(fout)
) {
    // ... do work
}

这相当于以下几点：

FileInputStream localFileInputStream = new FileInputStream(paramString1);
Object localObject1 = null;
try {
    FileOutputStream localFileOutputStream = new FileOutputStream(paramString2);
    Object localObject2 = null;
    try {
        GZIPOutputStream localGZIPOutputStream = new GZIPOutputStream(localFileOutputStream);
        Object localObject3 = null;
            try {
                // ... do work
           } catch (Throwable localThrowable6) {
               localObject3 = localThrowable6;
               throw localThrowable6;
           } finally {
               if (localGZIPOutputStream != null) {
                   if (localObject3 != null) {
                       try {
                           localGZIPOutputStream.close();
                       } catch (Throwable localThrowable7) {
                           localObject3.addSuppressed(localThrowable7);
                       }
                   } else {
                       localGZIPOutputStream.close();
                   }
               }
           }
       } catch (Throwable localThrowable4) {
           localObject2 = localThrowable4;
           throw localThrowable4;
       } finally {
           if (localFileOutputStream != null) {
               if (localObject2 != null) {
                   try {
                       localFileOutputStream.close();
                   } catch (Throwable localThrowable8) {
                       localObject2.addSuppressed(localThrowable8);
                   }
               } else {
                   localFileOutputStream.close();
               }
           }
       }
   } catch (Throwable localThrowable2) {
       localObject1 = localThrowable2;
       throw localThrowable2;
   } finally {
       if (localFileInputStream != null) {
           if (localObject1 != null) {
               try {
                   localFileInputStream.close();
               } catch (Throwable localThrowable9) {
                   localObject1.addSuppressed(localThrowable9);
               }
           } else {
               localFileInputStream.close();
           }
       }
   }
}

是的，这是一个令人敬畏的大量代码，但正如您所看到的，它嵌套在上面的每个带有资源的try块中。

Answer 2

JLS试图说的是，如果你有：

try (
   Closable closeable1 = ...;
   Closable closeable2 = ...;
   // ...
   Closable closeablen = ...;
) {
   // ...
}

它将被反复分解为：

try (Closable closeable1 = ...) {
   try (
      Closable closeable2 = ...;
      // ...
      Closable closeablen = ...;
   ) {
      // ...
   }
}

而且，只要try中有多个资源，就会重复这么长时间。这仅仅是一个例子，因为我假设它被分解成用于试用资源的实际字节码。

Answer 3

我把这理解为一个事实

try (
    resource 1
    resource 2
    resource n
) { 
}

在n语句中递归地翻译，第一步是在内部语句中使用n-1资源：

try (
    resource 1
) {

    try ( // n-1 resources here
        resource 2
        resource n
    ) {
    }
 }

我同意这一修正是不明确的。