Question

直接来自jls：

带有ResourceSpecification子句的try-with-resources语句宣布多个资源被视为多个资源 try-with-resources语句，每个语句都有一个 ResourceSpecification子句，声明单个Resource。当一个使用n资源（n> 1）的try-with-resources语句被翻译，结果是带有n-1个资源的try-with-resources语句。后在这样的翻译中，有n个嵌套的try-catch-finally语句，整体翻译完成。

对我而言，上面引用的陈述的最后部分非常清楚。为什么如果我已经声明了n资源，那么他们会说the result is a try-with-resources statement with n-1 Resources？

为什么不使用n资源？

提前致谢。

Answer 1

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

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

它将被反复分解为：

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

只要try中有多个资源，就会重复此操作。这只是一个例子，因为我认为它被分解为用于try-with-resources的实际字节码。

Answer 2

在Better Resource Management with Java SE 7: Beyond Syntactic Sugar中或多或少地解释了这一点。拿这个片段，例如：

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 3

我理解这是一个声明

的事实

try (
    resource 1
    resource 2
    resource n
) { 
}

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

try (
    resource 1
) {

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

我同意编辑不清楚。

关于jls点的澄清

3 个答案: