Play Store Application link – https://play.google.com/store/apps/details?id=com.ideepro.java25hours

Learn with youtube video-

💡Definition-

Generally, Exception disturbs the normal flow of program.
In java, Exception is an object, which is created when exceptional condition occurs.

– it contains all the information about the exception(type/class of exception and location in the code)

Note- Java includes default handler.

💡Exceptions hierarchy-

More Detailed diagram of Exception hierarchy-

Throwable
+-- Exception
|   +-- IOException
|   +-- SQLException
|   +-- ClassNotFoundException
|   +-- NoSuchMethodException
|   +-- CloneNotSupportedException
|   +-- InterruptedException
|   +-- IllegalAccessException
|   +-- InstantiationException
|   +-- NoSuchFieldException
|   +-- SecurityException
|   +-- UnsupportedOperationException
|   +-- ArithmeticException
|   +-- NumberFormatException
|   +-- StringIndexOutOfBoundsException
|   +-- RuntimeException
|       +-- IllegalArgumentException
|       +-- NullPointerException
|       +-- IndexOutOfBoundsException
|       +-- ArrayStoreException
|       +-- ClassCastException
|       +-- IllegalStateException
|       +-- EnumConstantNotPresentException
|       +-- UnsupportedOperationException
|       +-- ConcurrentModificationException
|       +-- ArithmeticException
|       +-- ArrayIndexOutOfBoundsException
+-- Error
    +-- VirtualMachineError
    |   +-- OutOfMemoryError
    |   +-- StackOverflowError
    +-- AssertionError
    +-- LinkageError
    |   +-- ClassCircularityError
    |   +-- ClassFormatError
    |   +-- ExceptionInInitializerError
    |   +-- IncompatibleClassChangeError
    |   +-- NoClassDefFoundError
    +-- ThreadDeath
    +-- InternalError
    +-- UnknownError

Here is a basic comparison of Throwable, Error, and Exception in Java:

💡-[TYPES OF EXCEPTIONS]-

💡1-CHECKED EXCEPTION:–

💡2-UNCHECKED EXCEPTION:–

Here is a table comparing errors, checked exceptions, and unchecked exceptions in Java:

Note – Examples of Error include:

OutOfMemoryError: Indicates that the Java Virtual Machine (JVM) has run out of memory.

import java.util.ArrayList;

public class OutOfMemoryErrorExample {
  public static void main(String[] args) {
    ArrayList<Integer> list = new ArrayList<>();
    while (true) {
      list.add(1);  // keep adding elements to the list
    }
  }
}

StackOverflowError: Indicates that the stack has overflowed because of an infinite recursion.

public class StackOverflowErrorExample {
  public static void main(String[] args) {
    infiniteRecursion();  // call the method that causes the error
  }

  public static void infiniteRecursion() {
    infiniteRecursion();  // call itself indefinitely
  }
}

💡-[5 KEYWORDS USED IN EXCEPTION HANDLING]-

Here is a tabular comparison of the try, catch, throw, throws, and finally keywords in Java:

-[scenarios]-

Here is a comparison of the four different ways to handle exceptions in Java:

NOTE– Finally block will not be executed if program exits (either by calling System.exit() or by causing a fatal error that causes the process to abort).

NOTE– Try with Resource – This is introduced in Java 7 –

Here is an example of how to manage a resource using the try statement in Java 6 or earlier:

FileReader fr = null;
try {
    fr = new FileReader("file.txt");
    int c;
       while ((c = fr.read()) != -1) {
         System.out.print((char) c);
         }
} catch (IOException e) {
    e.printStackTrace();
} finally {
    if (fr != null) {
        try {
            fr.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

This can be rewritten using the try-with-resources statement in Java 7 or later as follows:

try (FileReader fr = new FileReader("file.txt")) {
            int c;
            while ((c = fr.read()) != -1) {
                System.out.print((char) c);
            }

        } catch (IOException e) {
            e.printStackTrace();
        }

💡Avoiding a Exception using throws keyword–

💡#Throws-

Its a keyword, used to declare the exception with method signature.
It can be applied on multiple exceptions at a time.
Example-

import java.io.IOException;

public class ThrowsExample {
   public static void main(String[] args) throws IOException {
       readFile();
   }

   public static void readFile() throws IOException {
       throw new IOException("Error reading file");
   }
}

💡Throwing a Exception using throw keyword-

💡#Throw-

Its a keyword, used to generate an exception inside the method.
It can only be applied on 1 exception at a time.
Example-

public class Example {
public static void main(String[] args) {
String name= "Kuldeep56";
if (!name.equals("Kuldeep")) {
throw new IllegalArgumentException("name must contain only word Kuldeep");
}
}
}

💡Creating Custom exception class –

To create a custom exception in Java, you can follow these steps:

1- Create a new class that extends the Exception class or one of its subclasses.
For example:

public class MyCustomException extends Exception { 
    // ... 
} 

2- Add a constructor to the custom exception class. The constructor should accept a string message as an argument, which can be used to provide more information about the exception. You can also add additional constructors as needed.
For example:

public class MyCustomException extends Exception {
    public MyCustomException(String message) {
        super(message);
    }
}

Note- You can add additional methods or fields to the custom exception class as needed. For example, you might want to add a method that returns the error code associated with the exception.

4- To throw the custom exception, you can use the throw keyword followed by a new instance of the exception class, like this:

try {
    // code that might throw the exception
    throw new MyCustomException("There was an error processing the request");
} catch (MyCustomException e) {
    // handle the exception
}

5- To catch and handle the custom exception, you can use a try-catch block as shown above. In the catch block, you can perform any necessary actions, such as logging the error or displaying an error message to the user.

Complete Example –

public class Main {
    public static void main(String[] args) {
        try {
            // code that might throw the exception
            throw new MyCustomException("There was an error processing the request");
        } catch (MyCustomException e) {
            // handle the exception
            System.out.println(e.getMessage());
        }
    }
}

class MyCustomException extends Exception {
    public MyCustomException(String message) {
        super(message);
    }
}

More code samples are here-

1- Checked exception handling with try catch

package exceptionHandling;

import java.io.FileInputStream;
import java.io.FileNotFoundException;

public class ExChkdEx1 {
public static void main(String[] args) {

try {
FileInputStream f = new FileInputStream("c://a.txt");
} catch (FileNotFoundException e) {
e.printStackTrace();
}
}
}

2-Checked exception handling with try and multiple catch blocks

package exceptionHandling;

import java.io.*;

public class Extc1 {

public static void main(String[] args) {

try {
Class.forName("Array.A");
FileReader fr = new FileReader("D://h.txt");
} catch (ClassNotFoundException e) {

} catch (FileNotFoundException e) {

}

}

}

package exceptionHandling;

import java.io.*;

public class Extc2 {

public static void main(String[] args) {

try {
Class.forName("Array.A");
FileReader fr = new FileReader("D://h.txt");
} catch (ClassNotFoundException | FileNotFoundException e) {

}
}

}

package exceptionHandling;

import java.io.FileInputStream;
import java.io.FileNotFoundException;

public class ExChkdEx2 {
public static void main(String[] args) {

try {
FileInputStream f = new FileInputStream("c://a.txt");
} catch (FileNotFoundException e) {
e.printStackTrace();
} finally{
System.out.println("abc");
}
}

package exceptionHandling;
import java.io.FileInputStream;
import java.io.FileNotFoundException;

public class ExChkdEx3 {
public static void main(String[] args) throws FileNotFoundException {
FileInputStream f = new FileInputStream("c://a.txt");
}
}

package exceptionHandling;
public class UnChkdEx {
public static void main(String[] args) {
int a=10;
int b=0;
int c;
c = a / b;
System.out.println(c);
}
}

Interview Questions —

• What is difference between checked and unchecked exceptions?
• What is difference between throw and throws?