There are a few more important things to cover in runtime exceptions,explaining them using example questions would give a proper understanding.

• Q)

public class ExceptionEg {

    static void m(){
        try {
            throw new RuntimeException();
        } catch (NullPointerException e) {
           
        } finally {
            System.out.print("Hey");
        }
    }
    public static void main(String[] args) {
        try {
            m();
        } catch (IllegalArgumentException e) {
            }
        }
}

What is the output?
a)prints Hey followed by an exception report
b)prints an exception report followed by Hey
c)prints only Hey
d)compilation fails

At method m,a runtimeException is thrown,but the relevant catch block cannot catch the thrown exception.(Because RuntimeException > NullPointerException).So the runtime exception would be propagated to m method's caller which is the main method.Besides that,since try block was executed,its relevant finally block should definitely executed.So "Hey" would be printed.

Now the exception is at the main methods level.But even its catch block cannot catch this exception because IllegalArgumentException is a subclass of RuntimeException (if it was other way round,it could've caught)

But will a compilation error ocurr? No,because the not handle exception is a runtime exception and hence code will compile fine and would give an exception at runtime.
So the answer is: (a) 

•  Q)

public class A{
    public void method1() {
        B b=new B();
        b.method2();
        System.out.print("A");
    }
}

public class B{
    public void method2(){
        throw new NullPointerException();
    }
}

public class ExceptionEg {

    public static void main(String[] args) {
        try {
            A a=new A();
            a.method1();
          
        } catch (Exception e) {
            System.out.print("an error occured");
    }
      
    }
}
 
 Would "A" and "an error occured" print?
 Here the exception would be propagated to a.method1() line.Then the relevant catch block would catch the exception and print "an error occured".
But "A" would not be printed because at the moment an exception occured,the rest of the code would not run and immediately find a relevant catch block (but if there were a finally block it would run before - we discussed about it in the part I)

• Q)

public class ExceptionEg {
   
    static void test() throws RuntimeException{
        try {
            System.out.print("test");
            throw new RuntimeException();
        } catch (Exception e) {
            System.out.print("exception");
        }
    }

    public static void main(String[] args) {
        try {
            test();
           
        } catch (RuntimeException e) {
            System.out.print("an error occured");
    }System.out.print("end");
       
    }
}

 What would be the output?
First of all,you should notice this,

 Having nets of not matching way would not lead to a compilation failure because these two nets(catch blocks) are in different try blocks.
Immediate matching catch block(Exception e) will catch it.
Since those are runtime exceptions (or even if they were checked exceptions,since there are handled in try - catch block) program would not crash and hence,even the "end" would be printed after catching the exception.

so the answer is:

  "test exception end"
 



 

We'll try to go deep into java exception handling covering tricky things to gather a clear understanding,but first of all we need to understand the hierarchy of java exceptions. From java.lang -> Object -> Throwable.

• Throwables that can be included inside a try-catch can be divided like below.But note that you should only catch java.lang.Error at the highest level,even though catching them doesn't make sense in most of the cases.

 

• Exceptions should handled from narrower to the wider.See a try-catch block as a safe net that tries to catch a bomb which is about to hit the ground and blast.

  

• These are the only 3 legal formats of try - catch - finally,

• If you reach try block,then final block would always execute even if there is return in try block,unless you have system.exit() in try block!

• Q)

public class ExceptionEg {

    int bar() throws NullPointerException{
        throw new IllegalArgumentException();
    }
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        System.out.print(new ExceptionEg().bar());
      
        }
} 

what would be the output?

a)compilation error because method does not handle or declare the thrown exception

b)compilation error due to a missing return statement in bar() method

c)compiles fine,but an exception is thrown at runtime.

There we cover very important two points in java.

 

1)Both NullPointerException and IllegalArgumentException are runtime exceptions which do not need to be handled or declared in throws clauses, but are always implied.You ended up in an exception report and not compilation failure.

But the checked exceptions would give compilation errors if not handled.

So,in this Q,not handling the exception thrown,or throwing an exception(IllegalArgumentException) other than what is specified in throws clause(NullPointerException) would not make any compilation errors.(If it was a checked exception,compilation would fail).

2)Then about not returning an int.

It would also not be an issue,because in java,instead of returning you can throw an error.

So the answer is:(c)

• Under what conditions should actually throw a runtime exception?

When you detect an error with the way your class or method is used, throw a runtime exception.
Generally, there are two categories of situations when you need to throw a runtime exception:

• Passing invalid parameter values - This is the most common cause of runtime exceptions. Most parameter validation exceptions should be runtime exceptions. Java provides several subclasses to signal these specific problems.
• Calling methods in a wrong sequence - This is another common cause. When certain methods cannot be called until a class finishes initialization or some other preparatory steps, calls at the wrong time should cause runtime exceptions

Let's talk more about runtime excepitions in part II :)