• Chennai, Bangalore & Online: 93450 45466Coimbatore: 95978 88270Madurai: 97900 94102Pondicherry: 93635 21112

  • Mastering Try-Catch Blocks: A Guide to Exception Handling in Java


    Exception Handling in Java is a valuable approach for managing runtime errors and ensuring the smooth execution of an application. It involves handling various runtime errors such as ClassNotFoundException, IOException, SQLException, RemoteException, and others.

    An exception refers to an unexpected or undesired occurrence that prevents a programme from running normally during its execution. These exceptions can be caught and managed within the program. When an exception occurs within a method, it gives rise to an object known as the exception object. This object contains pertinent information about the exception, including its name, description, and the program’s state at the time of the exception occurrence.

    Join FITA academy‘s Java training in Chennai and start your journey to becoming a pro!

    Major reasons why an Exception Occurs

    There are several scenarios that can lead to errors in a program:

    • Invalid user input: When a user provides incorrect or unexpected input, it can result in errors during program execution.
    • Device failure: Errors can occur if there is a failure or malfunction of a hardware device on which the program relies.
    • Loss of network connection: When a program depends on network connectivity, errors may arise if the connection is lost or disrupted.
    • Physical limitations (out of disk memory): If a program exhausts the available disk memory, it can lead to errors and affect its proper functioning.
    • Code errors: Mistakes or bugs in the program’s code can cause errors during runtime.
    • Opening an unavailable file: If a program attempts to access a file that is unavailable or inaccessible, it can result in errors.

    Errors represent conditions that are usually beyond the programmer’s control and are considered irrecoverable. Examples of such errors include the Running out of memory, memory leaks, stack overflow issues, library incompatibility, and infinite recursion are all problems with the Java virtual machine (JVM). It is generally not advisable to handle these types of errors in the program.

    Distinguishing between Errors and Exceptions is crucial. Here are the key differences:

    Error: An Error signifies a severe issue that it is generally not advisable for an application to attempt to handle or catch.

    Exception: Exception denotes situations where it is reasonable for an application to try catching and handling the exceptional condition.

    Exception Hierarchy

    In the class hierarchy of Java, all exception and error types are derived from the base class Throwable. The hierarchy branches into two categories. The first branch is led by the Exception class, which is utilized for exceptional conditions that should be caught by user programs. For instance, NullPointerException is an example of such an exception.

    The second branch consists of the Error class, which is employed by the Java run-time system (JVM) to indicate errors related to the runtime environment itself (JRE). An example of such an error is StackOverflowError.

    Types of Exceptions 

    Java provides various types of exceptions that are related to its class libraries, and it also allows users to create their own exceptions.

    Exceptions can be classified into two categories:

    A. Built-in Exceptions

    Built-in exceptions are exceptions that are already defined in Java libraries. These exceptions are designed to handle specific error situations.

    Checked Exceptions: Checked exceptions are referred to as compile-time exceptions because they are checked by the compiler during compilation.

    Unchecked Exceptions: On the other hand, unchecked exceptions are not checked by the compiler at compile time. If a program throws an unchecked exception and it is not handled or declared, the program will not generate a compilation error.

    B. User-Defined Exceptions:

    In certain cases, the built-in exceptions in Java may not be suitable to describe a specific situation. In such scenarios, users can create their own exceptions, known as “user-defined exceptions.”

    Advantages of Exception Handling in Java 

    • Ensuring completion of program execution.
    • Facilitating easy identification of program code and error-handling code.
    • Propagating errors in a controlled manner.
    • Enabling meaningful error reporting.
    • Identifying different types of errors.

    Learn Java training in Bangalore from One of the most recognised training centres in Bangalore

    There are several ways to display exception information:

    1. Using the `printStackTrace()` method: This method prints the exception information in a specific format that includes the name of the exception, a description of the exception, and the stack trace.
    
    //program to print the exception information using printStackTrace() method
    
    import java.io.*;
    
    class GFG {
    
    public static void main (String[] args) {
    
    int a=5;
    
    int b=0;
    
    try{
    
    System.out.println(a/b);
    
    }
    
    catch(ArithmeticException e){
    
    e.printStackTrace();
    
    }
    
    }
    
    }
    

    Output:

    
    java.lang.ArithmeticException: / by zero
    
    at GFG.main(File.java:10)
    
    1. Utilizing the `toString()` method: With this approach, the exception information is displayed in a format that includes the name of the exception and a description of the exception without the stack trace.
    
    //program to print the exception information using toString() method
    
    import java.io.*;
    
    class GFG1 {
    
    public static void main (String[] args) {
    
    int a=5;
    
    int b=0;
    
    try{
    
    System.out.println(a/b);
    
    }
    
    catch(ArithmeticException e){
    
    System.out.println(e.toString());
    
    }
    
    }
    
    }
    

    Output:

    
    java.lang.ArithmeticException: / by zero
    
    1. Employing the `getMessage()` method: This method allows you to print only the description of the exception, omitting the stack trace and other details.
    
    //program to print the exception information using getMessage() method
    
    import java.io.*;
    
    class GFG1 {
    
    public static void main (String[] args) {
    
    int a=5;
    
    int b=0;
    
    try{
    
    System.out.println(a/b);
    
    }
    
    catch(ArithmeticException e){
    
    System.out.println(e.getMessage());
    
    }
    
    }
    
    }
    

    Output:

    
    / by zero
    

    If you want to design your own application, there are many resources available online, including tutorials. You may also check out Java Tutorial for learning about Java.

    How Does JVM Handle an Exception?

    In default exception handling, when an exception occurs with an exception object is created within a method. and passed to the runtime system (JVM). This Exception Object contains the exception’s name, description, and the current state of the program at the point of occurrence. The steps involved in creating the Exception Object and transferring it to the runtime system is known as throwing an exception. The call stack is a sequential list of methods that have been invoked leading up to the method where the exception was encountered.

    During exception handling, the runtime system scans the call stack in reverse order, starting from the method where the exception originated. It searches for a method that contains a code block capable of handling the specific exception. This code block is referred to as an exception handler. If an appropriate handler is found, the exception is passed to it for handling.

    However, if the runtime system exhaustively traverses the entire call stack without locating a suitable exception handler, the Exception Object is handed over to the default exception handler, which is an integral part of the runtime system. This default handler prints the exception information in a specific format and abruptly terminates the program

    To comprehend how the call stack flows, look at the diagram below.

    
    Illustration
    
    // Java Program to Demonstrate How Exception Is Thrown
    
    // Class
    
    // ThrowsExecp
    
    class GFG {
    
    // Main driver method
    
    public static void main(String args[])
    
    {
    
    // Taking an empty string
    
    String str = null;
    
    // Getting length of a string
    
    System.out.println(str.length());
    
    }
    
    }
    

    Output:

    Let’s look at an example that demonstrates how a run-time system examines the call stack for appropriate exception handling code.

    
    // Java Program to Demonstrate Exception is Thrown
    
    // How the runTime System Searches Call-Stack
    
    // to Find Appropriate Exception Handler
    
    // Class
    
    // ExceptionThrown
    
    class GFG {
    
    // Method 1
    
    // It throws the Exception(ArithmeticException).
    
    // Appropriate Exception handler is not found
    
    // within this method.
    
    static int divideByZero(int a, int b)
    
    {
    
    // this statement will cause ArithmeticException
    
    // (/by zero)
    
    int i = a / b;
    
    return i;
    
    }
    
    // The runTime System searches the appropriate
    
    // Exception handler in method also but couldn't have
    
    // found. So looking forward on the call stack
    
    static int computeDivision(int a, int b)
    
    {
    
    int res = 0;
    
    // Try block to check for exceptions
    
    try {
    
    res = divideByZero(a, b);
    
    }
    
    // Catch block to handle NumberFormatException
    
    // exception Doesn't matches with
    
    // ArithmeticException
    
    catch (NumberFormatException ex) {
    
    // Display message when exception occurs
    
    System.out.println(
    
    "NumberFormatException is occurred");
    
    }
    
    return res;
    
    }
    
    // Method 2
    
    // Found appropriate Exception handler.
    
    // i.e. matching catch block.
    
    public static void main(String args[])
    
    {
    
    int a = 1;
    
    int b = 0;
    
    // Try block to check for exceptions
    
    try {
    
    int i = computeDivision(a, b);
    
    }
    
    // Catch block to handle ArithmeticException
    
    // exceptions
    
    catch (ArithmeticException ex) {
    
    // getMessage() will print description
    
    // of exception(here / by zero)
    
    System.out.println(ex.getMessage());
    
    }
    
    }
    
    }
    

    Output

    
    / by zero
    

    Learn Java training in Pune from One of the most recognised training centres in Pune

    How do Programmers Handle an Exception?

     

    In Java, customized exception handling is facilitated through the usage of five essential keywords: try, catch, throw, throws, and finally. Here’s a brief overview of their functionality.

    The try block is used to enclose program statements that are prone to raise exceptions. The exception is thrown if it happens within the try block. To handle such exceptions, your code can catch them using a catch block and provide appropriate handling mechanisms. The Java run-time system itself generates system-defined exceptions. However, you can manually throw an exception using the throw keyword when needed.

    When an exception is thrown out of a method, it must be declared using the throws clause to specify the exceptional scenarios that can occur. This ensures proper handling of the exception by the caller of the method.

    Finally, the final block is utilised to include code that must be executed regardless of whether an exception occurs or not. It guarantees the execution of critical code that must be run once the try block has been completed.

    Try-catch clause (customised exception handling) is required.

    To further understand the try-catch clause, take a look at the programme below.

    Example:

    
    // Java Program to Demonstrate
    
    // Need of try-catch Clause
    
    // Class
    
    class GFG {
    
    // Main driver method
    
    public static void main(String[] args)
    
    {
    
    // Taking an array of size 4
    
    int[] arr = new int[4];
    
    // Now this statement will cause an exception
    
    int i = arr[4];
    
    // This statement will never execute
    
    // as above we caught with an exception
    
    System.out.println("Hi, I want to execute");
    
    }
    
    }
    

    Output: 

    output justification

    In the aforementioned example, an array is constructed with a size, and the only indexes that can access its elements are 0 and 3. However, the reason it is raising an exception is because you are mistakenly attempting to access the components at index 4. JVM terminates the programme abnormally in this situation. System.out.println(“Hi, I want to execute”); will never actually take effect. We must use try-catch to handle the exception in order to execute it. Hence, a try-catch clause is required in order to maintain the program’s usual flow.

    How to Use the try-catch Clause?

    attempt {
    
    // code block to monitor for errors
    
    // the code that may potentially raise an exception
    
    } catch (ExceptionType1 exObj) {
    
    // exception handler for ExceptionType1
    
    } catch (ExceptionType2 exObj) {
    
    // exception handler for ExceptionType2
    
    }
    
    // optional
    
    finally { // code block to be executed after the attempt block ends
    
    }
    

    Join FITA academy’s Java training in Marathahalli and start your journey to becoming a pro!

    Here are some important points to remember regarding exception handling

    • To handle multiple statements that may throw exceptions within a method, place each statement in its own try block and provide a separate catch block for each of them.
    • If an exception occurs within a try block, it is handled by the corresponding catch block associated with that try block. To handle various error kinds, multiple catch blocks can be utilised. Each catch block specifies the exception type it can handle, which must be a class inheriting from the Throwable class.
    • A try block can have No catch blocks or more, but just one final block.
    • The finally block is optional but important. It always gets executed, regardless of whether an exception occurred in the try block or not. After the try block, the finally block is invoked if an exception arises and catch blocks. If no exception occurs, it is executed after the try block. The finally block is typically used for crucial tasks like cleaning up resources, such as closing files or connections.
    • If a System.exit statement is present within the try block, the finally block will not be executed.

    Remember these key points while working with exception handling in Java.






    Quick Enquiry

    Please wait while submission in progress...


    Contact Us

    Chennai

      93450 45466

    Bangalore

     93450 45466

    Coimbatore

     95978 88270

    Online

    93450 45466

    Madurai

    97900 94102

    Pondicherry

    93635 21112

    For Hiring

     93840 47472
     hr@fita.in

    Corporate Training

     90036 23340


    FITA Academy Branches

    Chennai
    Bangalore
    Coimbatore
    Other Locations
    FITA Academy - Velachery
    Plot No 7, 2nd floor,
    Vadivelan Nagar,
    Velachery Main Road,
    Velachery, Chennai - 600042
    Tamil Nadu

        :   93450 45466

    FITA Academy - Anna Nagar
    No 14, Block No, 338, 2nd Ave,
    Anna Nagar,
    Chennai 600 040, Tamil Nadu
    Next to Santhosh Super Market

        :   93450 45466

    FITA Academy - T Nagar
    05, 5th Floor, Challa Mall,
    T Nagar,
    Chennai 600 017, Tamil Nadu
    Opposite to Pondy Bazaar Globus

        :   93450 45466

    FITA Academy - Tambaram
    Nehru Nagar, Kadaperi,
    GST Road, West Tambaram,
    Chennai 600 045, Tamil Nadu
    Opposite to Saravana Jewellers Near MEPZ

        :   93450 45466

    FITA Academy - Thoraipakkam
    5/350, Old Mahabalipuram Road,
    Okkiyam Thoraipakkam,
    Chennai 600 097, Tamil Nadu
    Next to Cognizant Thoraipakkam Office and Opposite to Nilgris Supermarket

        :   93450 45466

    FITA Academy - Porur
    17, Trunk Rd,
    Porur
    Chennai 600116, Tamil Nadu
    Above Maharashtra Bank

        :   93450 45466

    FITA Academy Marathahalli
    No 7, J J Complex,
    ITPB Road, Aswath Nagar,
    Marathahalli Post,
    Bengaluru 560037

        :   93450 45466

    FITA Academy - Saravanampatty
    First Floor, Promenade Tower,
    171/2A, Sathy Road, Saravanampatty,
    Coimbatore - 641035
    Tamil Nadu

        :   95978 88270

    FITA Academy - Singanallur
    348/1, Kamaraj Road,
    Varadharajapuram, Singanallur,
    Coimbatore - 641015
    Tamil Nadu

        :   95978 88270

    FITA Academy - Madurai
    No.2A, Sivanandha salai,
    Arapalayam Cross Road,
    Ponnagaram Colony,
    Madurai - 625016, Tamil Nadu

        :   97900 94102

    FITA Academy - Pondicherry
    410, Villianur Main Rd,
    Sithananda Nagar, Nellitope,
    Puducherry - 605005
    Near IG Square

        :   93635 21112

  • Trending Courses

    JAVA Training In Chennai Core Java Training in Chennai Software Testing Training In Chennai Selenium Training In Chennai Python Training in Chennai Data Science Course In Chennai C / C++ Training In Chennai PHP Training In Chennai AngularJS Training in Chennai Dot Net Training In Chennai DevOps Training In Chennai German Classes In Chennai Spring Training in ChennaiStruts Training in Chennai Web Designing Course In Chennai Android Training In Chennai

    iOS Training In Chennai SEO Training In Chennai Oracle Training In Chennai RPA Training In Chennai Cloud Computing Training In Chennai Big Data Hadoop Training In Chennai Digital Marketing Course In Chennai UNIX Training In Chennai Placement Training In Chennai Artificial Intelligence Course in Chennai AWS Training in Chennai Javascript Training in ChennaiHibernate Training in ChennaiHTML5 Training in ChennaiPhotoshop Classes in ChennaiMobile Testing Training in ChennaiQTP Training in ChennaiLoadRunner Training in ChennaiDrupal Training in ChennaiManual Testing Training in ChennaiWordPress Training in ChennaiSAS Training in ChennaiClinical SAS Training in ChennaiBlue Prism Training in ChennaiMachine Learning course in ChennaiMicrosoft Azure Training in ChennaiSelenium with Python Training in ChennaiUiPath Training in ChennaiMicrosoft Dynamics CRM Training in ChennaiUI UX Design course in ChennaiSalesforce Training in ChennaiVMware Training in ChennaiR Training in ChennaiAutomation Anywhere Training in ChennaiTally course in ChennaiReactJS Training in ChennaiCCNA course in ChennaiEthical Hacking course in ChennaiGST Training in ChennaiIELTS Coaching in ChennaiSpoken English Classes in ChennaiSpanish Classes in ChennaiJapanese Classes in ChennaiTOEFL Coaching in ChennaiFrench Classes in ChennaiInformatica Training in ChennaiInformatica MDM Training in ChennaiBig Data Analytics courses in ChennaiHadoop Admin Training in ChennaiBlockchain Training in ChennaiIonic Training in ChennaiIoT Training in ChennaiXamarin Training In ChennaiNode JS Training In ChennaiContent Writing Course in ChennaiAdvanced Excel Training In ChennaiCorporate Training in ChennaiEmbedded Training In ChennaiLinux Training In ChennaiOracle DBA Training In ChennaiPEGA Training In ChennaiPrimavera Training In ChennaiTableau Training In ChennaiSpark Training In ChennaiGraphic Design Courses in ChennaiAppium Training In ChennaiSoft Skills Training In ChennaiJMeter Training In ChennaiPower BI Training In ChennaiSocial Media Marketing Courses In ChennaiTalend Training in ChennaiHR Courses in ChennaiGoogle Cloud Training in ChennaiSQL Training In Chennai CCNP Training in Chennai PMP Training in Chennai OET Coaching Centre in Chennai

  • Are You Located in Any of these Areas

    Adyar, Adambakkam, Anna Salai, Ambattur, Ashok Nagar, Aminjikarai, Anna Nagar, Besant Nagar, Chromepet, Choolaimedu, Guindy, Egmore, K.K. Nagar, Kodambakkam, Koyambedu, Ekkattuthangal, Kilpauk, Meenambakkam, Medavakkam, Nandanam, Nungambakkam, Madipakkam, Teynampet, Nanganallur, Navalur, Mylapore, Pallavaram, Purasaiwakkam, OMR, Porur, Pallikaranai, Poonamallee, Perambur, Saidapet, Siruseri, St.Thomas Mount, Perungudi, T.Nagar, Sholinganallur, Triplicane, Thoraipakkam, Tambaram, Vadapalani, Valasaravakkam, Villivakkam, Thiruvanmiyur, West Mambalam, Velachery and Virugambakkam.

    FITA Velachery or T Nagar or Thoraipakkam OMR or Anna Nagar or Tambaram or Porur branch is just few kilometre away from your location. If you need the best training in Chennai, driving a couple of extra kilometres is worth it!