Exception Handling · Intermediate

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

public class Main {
    static int value() {
        try {
            return 1;
        } finally {
            return 2;
        }
    }

    static int counter() {
        int x = 10;
        try {
            return x;
        } finally {
            x = 99;
        }
    }

    public static void main(String[] args) {
        System.out.println(value() + " " + counter());
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

public class Main {
    static void work() {
        try {
            throw new IllegalStateException("from try");
        } finally {
            throw new RuntimeException("from finally");
        }
    }

    public static void main(String[] args) {
        try {
            work();
        } catch (RuntimeException e) {
            System.out.println(e.getMessage() + " / suppressed=" + e.getSuppressed().length);
        }
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13

public class Main {
    static class Conn implements AutoCloseable {
        @Override public void close() { throw new IllegalStateException("close failed"); }
    }

    public static void main(String[] args) {
        try (Conn c = new Conn()) {
            throw new RuntimeException("query failed");
        } catch (RuntimeException e) {
            System.out.println(e.getMessage() + " | suppressed: " + e.getSuppressed()[0].getMessage());
        }
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13

class ConfigError(Exception):
    pass

def load(text):
    try:
        return int(text)
    except ValueError as e:
        raise ConfigError(f"bad port: {text}") from e

try:
    load("80x")
except ConfigError as e:
    print(e, "|", type(e.__cause__).__name__)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

#include <iostream>
#include <stdexcept>

struct Guard {
    const char* n;
    Guard(const char* s) : n(s) { std::cout << "+" << n << ' '; }
    ~Guard() { std::cout << "-" << n << ' '; }
};

void inner() {
    Guard g("inner");
    throw std::runtime_error("boom");
}

void outer() {
    Guard g("outer");
    inner();
}

int main() {
    try {
        outer();
    } catch (const std::exception& e) {
        std::cout << "caught:" << e.what() << '\n';
    }
}

1
2
3
4
5
6
7
8
9
10
11
12

#include <iostream>

struct Base { virtual const char* name() const { return "base"; } virtual ~Base() = default; };
struct Derived : Base { const char* name() const override { return "derived"; } };

void copyRethrow()  { try { throw Derived(); } catch (const Base& e) { throw e; } }
void plainRethrow() { try { throw Derived(); } catch (const Base& e) { throw; } }

int main() {
    try { copyRethrow(); }  catch (const Base& e) { std::cout << e.name() << ' '; }
    try { plainRethrow(); } catch (const Base& e) { std::cout << e.name() << '\n'; }
}

1
2
3
4
5
6
7

def risky():
    try:
        raise ValueError("lost")
    finally:
        return "finally wins"

print(risky())

1
2
3
4
5
6
7
8
9
10
11
12
13
14

#include <iostream>
#include <stdexcept>

void parse() noexcept {
    throw std::runtime_error("bad input");
}

int main() {
    try {
        parse();
    } catch (const std::exception& e) {
        std::cout << "caught\n";
    }
}

1
2
3
4
5
6
7

try:
    try:
        {}["missing"]
    except KeyError:
        raise RuntimeError("handler failed")
except RuntimeError as e:
    print(type(e.__context__).__name__, e.__cause__, e.__suppress_context__)

1
2
3
4
5
6
7
8
9
10
11
12
13
14

public class Main {
    static int depth = 0;
    static void dive() { depth++; dive(); }

    public static void main(String[] args) {
        try {
            dive();
        } catch (Exception e) {
            System.out.println("exception");
        } catch (StackOverflowError e) {
            System.out.println("error, deep=" + (depth > 1000));
        }
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

#include <iostream>
#include <stdexcept>

struct Member {
    Member()  { std::cout << "+member "; }
    ~Member() { std::cout << "-member "; }
};

struct Widget {
    Member m;
    Widget()  { std::cout << "+widget "; throw std::runtime_error("fail"); }
    ~Widget() { std::cout << "-widget "; }
};

int main() {
    try {
        Widget w;
    } catch (const std::exception&) {
        std::cout << "caught\n";
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

import java.util.Objects;

public class Main {
    record Email(String value) {
        Email {
            Objects.requireNonNull(value, "value");
            if (!value.contains("@")) throw new IllegalArgumentException("invalid: " + value);
            value = value.toLowerCase();
        }
    }

    public static void main(String[] args) {
        System.out.print(new Email("Asha@LF.dev").value() + " ");
        try {
            new Email("no-at-sign");
        } catch (IllegalArgumentException e) {
            System.out.print(e.getMessage() + " ");
        }
        try {
            new Email(null);
        } catch (NullPointerException e) {
            System.out.println("NPE:" + e.getMessage());
        }
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

public class Main {
    static class OutOfStockException extends RuntimeException {
        OutOfStockException(String item) { super(item + " out of stock"); }
    }

    static void reserve(String item, int stock) {
        if (stock == 0) throw new OutOfStockException(item);
    }

    public static void main(String[] args) {
        try {
            reserve("pen", 3);
            reserve("ink", 0);
            reserve("pad", 0);
        } catch (OutOfStockException e) {
            System.out.println(e.getMessage() + " " + (e instanceof RuntimeException));
        }
    }
}