Java throws keyword

• When developing a program, it is essential to anticipate and address potential exceptions. The compiler acts as a proactive guard, alerting us to any potential issues and mandating the handling of checked exceptions. Failure to handle such exceptions properly will lead to a compile-time error message, insisting on either catching the unreported exception X or declaring it to be thrown.To avoid this compile-time error, we can handle the exception in two ways.
  • By using try catch
  • By using throws keyword






• To handle Java exceptions effectively, one can utilize the "throws" keyword to transfer the responsibility of exception handling to the caller, be it a method or the Java Virtual Machine (JVM). By employing this approach, the caller method assumes the duty of appropriately managing the encountered exception.

Syntax of Java throws block

returnType methodName() throws exceptionClassName{  
    //method 
} 

Problem without Java throws block

package DockerTpoint;
public class Main {	
    public static void main(String args[]){    	  		  
        Thread.sleep(1000);
        System.out.println("Hello DockerTpoint");
   } 
}

Exception in thread "main" java.lang.Error: Unresolved compilation problem: 
	Unhandled exception type InterruptedException

	at HELLO/DockerTpoint.Main.main(Main.java:5) 

In the above program, we are getting a compile time error because there is a chance of an exception if the main thread goes to sleep, which allows other threads to execute the main() method, which causes an InterruptedException.

Java throws block

package DockerTpoint;
public class Main {	
    public static void main(String args[])throws InterruptedException{    	  		  
        Thread.sleep(1000);
        System.out.println("Hello DockerTpoint");
   } 
}

Hello DockerTpoint 

We successfully managed the InterruptedException in the previous program by employing the throws keyword, resulting in the output message "Hello DockerTpoint."

Exception handle using try-catch block

public class Main {	
    void fun() throws IllegalAccessException{
        System.out.println("fun() method ");
        throw new IllegalAccessException();
  }
  public static void main(String args[]){
    try{
        Main main=new Main();
        main.fun();
    }
    catch(IllegalAccessException e){
        System.out.println("Exception handled");
    }
  }
}

fun() method 
Exception handled 

Important points about throws keyword

• The "throws" keyword serves a vital role in handling checked exceptions, while its usage for unchecked exceptions is irrelevant.
• The presence of the "throws" keyword is necessary to inform the compiler about potential checked exceptions, but it does not guarantee prevention of abnormal program termination.
• By utilizing the "throws" keyword, we can provide relevant details about the exception to the method's caller, enhancing communication and error handling.

Example of Declare Exception

package DockerTpoint;
import java.io.IOException;
class check{  
  void method()throws IOException{  
   throw new IOException("check method");  
  }  
}  
public class Main {	
   public static void main(String args[])throws IOException{ // exception declared 
	   check ch=new check();  
	   ch.method();  
  }
}

Exception in thread "main" java.io.IOException: check method
	at HELLO/DockerTpoint.check.method(Main.java:7)
	at HELLO/DockerTpoint.Main.main(Main.java:13)