Java: What is the difference between final, finally, and finalize?

1final int MAX_SIZE = 100;
2// MAX_SIZE = 200; // COMPILE ERROR
3
4// Final reference: reference can't change, but object can
5final List<String> list = new ArrayList<>();
6list.add("item");        // OK — modifying object contents
7// list = new ArrayList<>(); // COMPILE ERROR — can't reassign
8
9// Final in constructor/initializer pattern
10class Config {
11    final String databaseUrl;
12
13    Config(String url) {
14        this.databaseUrl = url; // Must be set exactly once
15    }
16}

1class PaymentProcessor {
2    final void validatePayment(double amount) {
3        if (amount <= 0) throw new IllegalArgumentException("Amount must be positive");
4    }
5}
6
7class CreditCardProcessor extends PaymentProcessor {
8    // void validatePayment(double amount) { } // COMPILE ERROR: can't override final
9}

1final class ImmutablePoint {
2    private final int x;
3    private final int y;
4
5    public ImmutablePoint(int x, int y) {
6        this.x = x;
7        this.y = y;
8    }
9    // No setters — truly immutable
10}
11// String, Integer, Math are all final classes in Java

1Connection conn = null;
2try {
3    conn = dataSource.getConnection();
4    // execute queries...
5    return result; // finally STILL runs before this return!
6} catch (SQLException e) {
7    System.err.println("Database error: " + e.getMessage());
8    throw e; // Re-throw after finally
9} finally {
10    // Always clean up
11    if (conn != null) {
12        try {
13            conn.close();
14        } catch (SQLException e) {
15            System.err.println("Error closing connection");
16        }
17    }
18    System.out.println("Cleanup complete");
19}
20
21// Modern: try-with-resources (no finally needed)
22try (Connection conn2 = dataSource.getConnection();
23     Statement stmt = conn2.createStatement()) {
24    ResultSet rs = stmt.executeQuery("SELECT * FROM users");
25    // process results...
26} catch (SQLException e) {
27    System.err.println("Error: " + e.getMessage());
28}
29// conn2 and stmt closed automatically — cleaner than finally

1// OLD, BAD approach:
2class OldResource {
3    @Override
4    protected void finalize() throws Throwable {
5        try {
6            System.out.println("Finalize called - too late!");
7            // cleanup...
8        } finally {
9            super.finalize();
10        }
11    }
12}
13
14// MODERN approach: AutoCloseable + try-with-resources
15class ModernResource implements AutoCloseable {
16    private boolean open = true;
17
18    public void use() {
19        if (!open) throw new IllegalStateException("Already closed");
20        System.out.println("Using resource");
21    }
22
23    @Override
24    public void close() {
25        open = false;
26        System.out.println("Resource closed deterministically");
27    }
28}
29
30// Clean, reliable cleanup:
31try (ModernResource resource = new ModernResource()) {
32    resource.use();
33}
34// close() called immediately and predictably