Java 关于jls中某一点的澄清

直接由此：

带有ResourceSpecification子句的try with resources语句 声明多个资源的属性将被视为是多个 尝试使用resources语句，每个语句都有一个 声明单个资源的ResourceSpecification子句。当 try with resources语句，其中n个资源n>1已翻译， 结果是使用n-1个资源的try-with-resources语句。之后 n个这样的翻译，有n个嵌套的try-catch-finally语句， 整个翻译已经完成了

对我来说，上述声明的最后一部分非常清楚。为什么如果我声明了n个资源，那么正如他们所说，结果是一个使用n-1个资源的try-with-resources语句

为什么不使用n资源

---

提前感谢。

JLS想说的是，如果您有：

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

它将被反复分解为：

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

---

这会重复更长的时间，因为try中有多个资源。这只是一个示例，因为我假设它被分解为用于资源试用的实际字节码。

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

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

它将被反复分解为：

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

---

这会重复更长的时间，因为try中有多个资源。这只是一个示例，因为我假设它被分解为用于try with resources的实际字节码。

中或多或少地解释了这一点。以这个片段为例：

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 with resources块嵌套在上面的块中。

中或多或少地解释了这一点。以这个片段为例：

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 with resources块嵌套在上面的一个块中。

我理解为

try (
    resource 1
    resource 2
    resource n
) { 
}

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

try (
    resource 1
) {

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

---

我同意编校不明确。

我理解这是因为一项声明

try (
    resource 1
    resource 2
    resource n
) { 
}

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

try (
    resource 1
) {

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

我同意编校不明确