Catching an Exception from a called Method

Question

This is something that's been bugging me for a while with regards to Program Flow.

I wanted to know if it's possible to catch an error from a Method in order to stop it from executing the Method that would normally follow it like the example bellow that I can't get to work.

public class MyClass {

   public static void main(String[] args) {

      // this method catches an exception and stops running
      method01();

      // this method will continue anyway which I don't want
      method02();

   };

};

I would normally have a static int variable that will initialize as 0 when the program is run and then if a method ever catches an exception it will increment that int and each method will only run if the int is 0.

This works but I was just wondering if I could replace the int shindig with exception handling.

Answer 1

Can you try:

try {
    method01()
} catch (final Exception e) {
    // do something
    return; ///stop processing exit
}

the method01 will throw Exception:

private void method01() throws Exception {
// something
}

Answer 2

Depends on what your method really does.

If your program should continue working also when an exception arise (eg NumberFormatException when parsing an input or in general a checked exception ) a lot of people will suggest you to not use exception for flow control , but IMHO in very well defined cases (like NumberFormatException ) the flow CAN be controlled by try catch statements and exceptions, it's really up to you.

A way to do so is to use the method returned parameter (also @Nikola answer works in this way, the point is to use the catch part of a try catch as flow control):

public class MyClass {

   public static void main(String[] args) {

      if(method01()) method02();

   };
};

public boolean method01(){
    try{
        //some business
    }catch(MyCheckedException e){
        e.printStackTrace();
        return false;
    }
    return true;
}

NB: You should use this approach only in well defined situations! If a file CAN be absent in a directory while opening it (checked FileNotFoundException ), you COULD use this approach. If the file SHOULD be there and its not, the exception MUST stop the program.

Answer 3

If you only want to terminate the whole program in case of an exception you just need to throw a RuntimeException without any further declaration. There are also specialized sub classes for explicit types of exceptions, like NullPointerException or IllegalStateException . See the "Direct Known Subclasses" section in the JavaDoc .

public class MyClass {

    public static void main(String[] args) {
        method01();
        method02(); //method02 won't be called in case of an exception
    }

    private static void method01() {
        // ...
        if (true) // something goes wrong
            throw new RuntimeException();
        // further code won't be executed in case of an exception
    }

    private static void method02() {
        System.out.println("method02 called");
    }
}

Optionally it is possible to handle the exception with a try-catch-block :

    public static void main(String[] args) {
        try {
            method01();
            method02(); // method02 won't be called in case of an exception
        } catch (Exception e) {
            System.err.println("something went wrong");
        }
    }

    // other code keeps unchanged...

If you want to enforce exception handling, you have to throw a subclass of Exception that is not derived from RuntimeException . But those exceptions have to be declared within the method Signature.

    private static void method01() throws IOException {
            throw new IOException();
    }

Answer 4

You put method01 and method02 in to same try block:

public class MyClass {

    public static void main(String[] args) {
        try {
            // This method catches an exception and stops running.
            method01();
            // This method will not continue if method01 have exception.
            method02();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

// declare method01, method02, others...

}

Notice: You have mistakes at the end of code block ( }; }; )