What are the forms of writing try/catch blocks in…

In Java, the following forms of writing try/catch/finally blocks exist:

Basic try-catch form: Handles exceptions that occur within the try block.

try {
    // Code that may throw an exception
} catch (ExceptionType e) {
    // Code to handle ExceptionType
}

Multiple catch blocks: Allows handling different types of exceptions differently. catch blocks are executed from top to bottom, and the first one that matches or is a parent of the thrown exception will be handled.

try {
    // Code that may throw different types of exceptions
} catch (SpecificExceptionType1 e1) {
    // Handling first type of exception
} catch (SpecificExceptionType2 e2) {
    // Handling second type of exception
} catch (Exception e) {
    // Handling other types of exceptions (should be last if present)
}

Multi-catch (Java 7+): Allows handling multiple exception types in one catch block if the handling logic is the same. Exception types are separated by |.

try {
    // Code that may throw ExceptionType1 or ExceptionType2
} catch (ExceptionType1 | ExceptionType2 e) {
    // Handling both exception types
}

finally block: Used to execute code that should run regardless of whether an exception occurred or not (e.g., resource cleanup). The finally block executes after the try block and all relevant catch blocks.
```
try {
    // Code that may throw an exception
} catch (ExceptionType e) {
    // Handle exception
} finally {
    // Code that always executes
}
```
There is also a combination of try-finally without a catch block if the exception is not handled locally but cleanup code is needed.
```
try {
    // Code
} finally {
    // Code that always executes
}
```

Try-with-resources (Java 7+): Automatically closes resources that implement AutoCloseable or Closeable. Resources are declared in parentheses after the try keyword.

try (ResourceType resource1 = new ResourceType(...);
     AnotherResourceType resource2 = new AnotherResourceType(...)) {
    // Code using resource1 and resource2
} catch (ExceptionType e) {
    // Handle exception
}
// Resources resource1 and resource2 are automatically closed

This form can be used with catch and/or finally blocks.

try (ResourceType resource = new ResourceType(...)) {
    // Code using resource
} finally {
    // Code executed after automatic resource closing
}

What are the forms of writing try/catch blocks in Java?