What is Exceptions in Java?
While writing your programs, you would have encountered many errors. It is indeed very irritating to encounter such errors. If a user is using your program and encounters such errors, he/she may lose trust in it.
Let’s say you were loading a website page. The page didn’t load, but you got a simple message saying “Page not found”. Although there was an error, the website program was able to identify the error, mask the original error message, and send out a simple readable message — “Page not found”. But what if you got the entire technical message? You would lose trust in the creators of the website. Thus, you have to handle errors in a program.
You may download the code used in the video from below:
Now, let’s look at some of the common exceptions that you see when you write your program and how to deal with them.
Video Transcript
In the last lectures you learned about using inbuilt functions. In this lecture you will learn about handling errors in your program. Let's see what happens. When you run a program. The program is first compiled, then the program is run. That is, it is executed. However, when the program is running, it may run into problems or errors and stop execution. These problems are called exceptions. An exception, by definition occurs when the flow of a program is disrupted and ends abnormally. You don't want the program to end abnormally. You need it to tell you what error occurred. If any example exceptions may occur when the user enters invalid data or a file cannot be found. The exceptions may be caused by a user input or a flaw in the program logic. Let's look at an example. In here I have my data variable which is the result of 67 divided by zero. And then I simply want to print rest of the code goes here. Let's run this code over here. You can see that I just came across an exception. The exception in this thread reads arithmetic exception divided by zero. It states that there is some mathematical or arithmetic error and it is due to an attempted division by zero. Here you knew what the source of the error could be. The code following the source of the exception will not always be dependent on the source. It's not fair to stop the execution of the entire code just because there is an error. In a small independent part. The code should be able to identify what the error is and then move on to run the code following the error. Let's look at how to do this. Here we have made a small modification. Suppose that when the exception occurs, the compiler returns and prints the detail of the exception. Let's call the exception statement e. So the catch block catches the exception and prints it first. Let's execute this code to understand it better. As you can see, we are first printing out the exception, which you can see in the first line athematic exception divided by zero. And then we printed out the rest of the code is here. String, let's see what is happening here. At first, this code would try to divide 67 by zero. Now, since you can't divide by zero, the program would throw an Arseymatic exception. However, because you're using the try and catch block, the program will not crash like you saw earlier. Instead, it will actually execute this line. So the exception was stored in the variable E and it was printed in the print statement. Once it finishes executing the cache block, it will execute what comes after the try and catch block, which is system out print Ln. And you could see that the rest of the code is here statement was printed at the end. So to catch the error and not stop the code from executing altogether, you used a try catch feature in Java. This is how a try catch block would look like. You'd first have a try statement, and inside the parenthesis, you'd have your code statements that may cause exception followed by a catch block. A try block is always followed by a catch block. A try block contains a code where the exception may arise. If the exception occurs, it is caught by the catch block. The program doesn't stop altogether. Instead, the rest of the code is executed. In other words, the cache protects your program from ending abruptly. You may modify the code in the cache block to instead display a user friendly error message. This would help them to understand the exact error. So in here, instead of directly printing the exception, let's say I want to print a user friendly message saying error, do not divide number by zero and let's run this program again. As you can see, instead of printing the exception, the code simply printed out the user friendly message that we just typed. Trycatch helps you identify the part of the program where the error occurred. A catch block Catches Exception You can have multiple catch blocks that catch different exceptions. You can refer to the links below to learn more about multiple catches.
Video Recap
This segment is about handling errors in Java programming
When a program runs, it may encounter problems or errors called exceptions
Exceptions can be caused by invalid user input or flaws in program logic
It is important to catch exceptions and display user-friendly error messages instead of allowing the program to end abruptly
A try-catch block in Java can be used to catch exceptions and continue executing the code
The try block contains the code where the exception may occur and the catch block catches the exception and handles it
Multiple catch blocks can be used to catch different types of exceptions
It is possible to modify the catch block to display a user-friendly error message
The video provides an example of how to use a try-catch block in Java to handle an arithmetic exception caused by dividing by zero
Note: In JAVA, when you try to print 67/0, or store 67/0 into an int variable, Java throws an Arithmetic Exception. However, when you try to store 67/0 into a float or a double variable, it returns Infinity instead of an exception.
You learnt how you can handle exceptions using the try and catch blocks. Here’s how a Try and Catch block looks:
try {
// code that can throw exceptions
} catch (Exception e) {
System.out.println(e);
}The try block contains the code where exceptions may arise. If an exception occurs, it is caught by the catch block, and the statement inside the block is executed.
You can download the code used in the video from below :
Let us now learn more about different kinds of exceptions and how to deal with them so your program runs smoothly.
A compile-time error is any type of error that prevents a java program from compiling, e.g. syntax error, incorrect data-types etc. Checked exceptions cause compile time errors if left unhandled.
A runtime error on the other hand arises while the program is running. This could happen due to unexpected user input or an incorrect logic etc.
So, now you know why you used “throws FileNotFoundException” when you were writing the code to read text from an external file. The throws keyword specifies that an exception may arise in the particular method. It is different from try and catch in that it has no provision to handle the exception and thus, it can’t catch the error and execute the corresponding action, e.g. displaying a different simplified message to the user
In this lecture, you learnt about the various kinds of exceptions that may arise in your codes. You learnt about checked and unchecked exceptions. Checked exceptions are those that are checked while a program is being compiled. A program will not compile if there is no provision to handle these exceptions in your code. On the other hand, for unchecked exceptions, the program may compile even if there is no provision to handle them. But as a good practice, you should have a provision for handling these exceptions as well.