What to write in catch block in Java?

What to write in catch block in Java?

The eternal question!

In Java, a catch block is used to handle exceptions that occur during the execution of your code. Think of it like a safety net that catches any unexpected issues and allows you to respond to them in a meaningful way.

Here's what you typically write inside a catch block:

try {
// Code that might throw an exception
} catch (ExceptionType e) {
// Code to handle the exception
}

Let's break it down further:

Now, let me illustrate what you might write inside a catch block:

Suppose you're trying to read a file, and it doesn't exist:

try {
FileReader reader = new FileReader("non-existent-file.txt");
} catch (FileNotFoundException e) {
System.out.println("Error: The file does not exist!");
}

In this example:

When you catch an exception, you can choose to:

Some common exceptions in Java include:

In summary, a catch block is like a "rescue mission" that helps your program recover from unexpected errors. By writing code inside the catch block, you can provide meaningful error handling and make your program more robust!

Now, go forth and write some catch blocks!

Try catch exception handling in java w3schools

Here's an example of using try-catch exception handling in Java as described on W3Schools:

public class Main {
public static void main(String[] args) {
try {
int myInt = Integer.parseInt("Hello");
System.out.println(myInt);
} catch (NumberFormatException e) {
System.out.println("Error: " + e.getMessage());
} finally {
System.out.println("This will always be executed, whether an exception was thrown or not.");
}
}
}

In this example, we're trying to convert a string to an integer using the Integer.parseInt() method. However, if the string is not in the correct format (in this case, a numerical value), a NumberFormatException will be thrown.

The try block contains the code that might throw an exception. In this case, it's the call to Integer.parseInt(). If any exceptions occur within the try block, they'll be caught by the catch block(s).

In this example, we're catching only one type of exception: NumberFormatException. We can specify multiple types of exceptions in a single catch block like this:

try {
// code that might throw an exception
} catch (ExceptionType1 e) {
// handle ExceptionType1
} catch (ExceptionType2 e) {
// handle ExceptionType2
}

The finally block is optional but can be very useful. It contains code that should always be executed, regardless of whether an exception was thrown or not. This could include releasing system resources like closing files or connections.

Here's how you can use the try-catch-finally structure with multiple catch blocks and multiple exceptions:

try {
// code that might throw a DivisionByZeroException
int i = 1 / 0;
} catch (ArithmeticException e) {
// handle ArithmeticException (which includes DivisionByZeroException)
System.out.println("Error: " + e.getMessage());
} catch (IOException e) {
// handle IOException
System.out.println("I/O Error: " + e.getMessage());
}
finally {
// this will always be executed
System.out.println("This will always be executed, whether an exception was thrown or not.");
}

You can also use try-catch-finally with multiple catch blocks and single exceptions:

try {
// code that might throw a DivisionByZeroException
int i = 1 / 0;
} catch (ArithmeticException e) {
System.out.println("Error: " + e.getMessage());
throw e;  // re-throw the exception
}
catch (IOException e) {
System.out.println("I/O Error: " + e.getMessage());
}
finally {
// this will always be executed
System.out.println("This will always be executed, whether an exception was thrown or not.");
}

Remember that exceptions should be used to handle exceptional conditions and not for general program control.