Exceptions - Basics

[Esther Kak]

I think I have to get my basics right with Exceptions. Please help and correct if I am not right.
Example code

 public class ExceptionBasics
{
	public void riskyMethod() throws Exception{
		throw new Exception();
	}
	public void duckingMethod(){
		riskyMethod();
	}
	
	public static void main(String args[]){
		ExceptionBasics eb = new ExceptionBasics();
		eb.duckingMethod();
	}
}
   

If a riskymethod() throws a CheckedException, duckingmethod() calls the riskymethod() and does not "handle&declare" the exception, ---compile time error occures(JVM says unreported exception...)

If a riskymethod() throws a uncheckedException, duckingmethod() calls the riskymethod(() and does not "handle&declare" the exception thrown by the riskymethod() --- compiles fine---but run time error occurs

If a riskymethod() throws an Error, duckingmethod() passes the Error to the main() and does not "handle&declare" the Error thrown by the riskymethod() - compiles fine --but runtime error occurs

[Siva Masilamani]

Yes you are right.

If any of the method contains code that may throw checked exception then those codes should be inside try/catch block or the method itself should duck that checked exception.

Similarly if you are calling a method which may throw checked exception then the calling code should be inside try/catch block or the caller method itself should duck that exception.

But it is not necessary to catch or duck unchecked exception or Error even if you declare statement like throw new RuntimeException();

One more thing if you are either using try/catch block or ducking checked exception then that method should contain some code that throws checked exception.(method disp)

But Exception and the above classes are little bit different ,they are partially checked and unchecked exception.

That is it can contain try/catch block inside a method even though the method does not throw Exception.See disp1.

E.g

 public class TestException {
    public static void main(String[] args) throws Exception{
        try{
            disp();
        }catch(Exception e){
            System.out.println("main");
            throw e;
        }
    }

    static void disp() {
               try{
               throw new IOException(); //If you uncomment this you will get compile time error.
               }catch(IOException ioe){ }
            }


    static void disp1() throws Exception {
        try {   //even though this block doesnot contain any code that throws Exception or Throwbale it will compile.But if you throw Exception using throw new Exception() then you should either catch or duck that because now it acts as Checked Exception.
        } catch (Exception e) {
        } catch (Throwable t) {
        }
    }
}
   

Hope it should have cleared your doubt

[Esther Kak]

I really appreciate your response. But I have one more question before I close with exceptions.
As you said that we have two options
1. use try-catch code for exception
2. duck the checked exception

Here is the example for option1. In this example ---filenotfound is a checked exception.
Can you please help me modify the handlingMethod() to duck the checked exception (that means to use option2)

 import java.io.*;
public class HandleAndDeclareException{
    public void riskyMethod() throws FileNotFoundException
    {
        System.out.println("You are in risky method");

            throw new FileNotFoundException();

    }
    public void handlingMethod() {
        System.out.println("calling risky method now");

        // handling the risky part
        try{
        riskyMethod();
        }catch(FileNotFoundException fe){
            System.out.println("caught a FileNotFoundException");
        }

        System.out.println("just finished calling risky method");
    }
    public static void main(String args[])
    {
        HandleAndDeclareException a = new HandleAndDeclareException();
        a.handlingMethod();

    }
}   

[Ankit Garg]

 import java.io.*;
public class HandleAndDeclareException{
    public void riskyMethod() throws FileNotFoundException
    {
        System.out.println("You are in risky method");

            throw new FileNotFoundException();

    }
    public void handlingMethod() throws FileNotFoundException {     //let the caller handle the exception
        System.out.println("calling risky method now");
        riskyMethod();

        System.out.println("just finished calling risky method");
    }
    public static void main(String args[])
    {
        HandleAndDeclareException a = new HandleAndDeclareException();
        try {
            a.handlingMethod();
        } catch(Exception e) {}

    }
}   

[Siva Masilamani]

OK you already ducked that exception in the riskyMethod so you need not to catch that exception in the riskyMethod since you are ducking that exception, in the handling method you should put the calling code inside try/catch which you did already or declare the handling method itself to duck that exception using throws clause.

If you do this then you have to put the calling code in the main method inside try/catch or declare main itself to duck that exception in which case JVM will handle that exception and terminate the program.

So if you are ducking an exception it will fall through the calling stack until it is either handle by trt/catch block or by JVM itself.

[Esther Kak]

Thanks.

[avi sinha]

one more thing and of course an important point related to it.

polymorphism works for the overridden method but it is resolved at runtime.
so in case when the superclass method declares a checked exception and the overridden method in subclass doesn't declare it
if we polymorphically call the subclass method using superclass reference , despite the method in subclass will be called we will have to handle or declare it to
get the code compiled sucessfully

example code

   
import java.io.*;
 class SuperClass {
	
	// risky method
	public void riskyMethod() throws Exception{
		
		throw new FileNotFoundException() ;
	}
		
	}
	
	 class SubClass extends SuperClass{
		
		//overridding riskyMethod
		public void riskyMethod() {
			System.out.println("in subclss");
		}
			
			public static void main(String args[]){
				
				SuperClass a1=new SubClass();
				
				// either handle it or declare
				try{
					a1.riskyMethod();
				}catch(Exception e){}
			
			
			}
			
	}
 

avi sinha