Exceptions<\/h3>\n
An exception (or exceptional event) is a problem that arises during the execution of a program. When an\u00a0Exception<\/b>\u00a0occurs the normal flow of the program is disrupted and the program\/Application terminates abnormally, which is not recommended, therefore, these exceptions are to be handled.<\/p>\n
An exception can occur for many different reasons. The following are some scenarios where an exception occurs.<\/p>\n
- \n
- A user has entered invalid data.<\/li>\n
- A file that needs to be opened cannot be found.<\/li>\n
- A network connection has been lost in the middle of communications or the JVM has run out of memory.<\/li>\n<\/ul>\n
Errors<\/strong><\/h3>\n
Errors are mostly caused by the environment in which the program is running. Errors occur at runtime and not known to the compiler. All exceptions occur at runtime but checked exceptions are known to the compiler while unchecked is not. They are defined in java.lang.Error package.<\/p>\n
Exceptions vs Errors<\/h3>\n
Error:<\/strong> An Error indicates a serious problem that a reasonable application should not try to catch.
\nException:<\/strong>\u00a0Exception indicates conditions that a reasonable application might try to catch.<\/p>\nExceptions Hierarchy<\/h3>\n
The possible exceptions in a Java program are organized in a hierarchy of exception classes. The Throwable class, which is an immediate subclass of Object, is at the root of the exception hierarchy. Throwable has two immediate subclasses: Exception and Error.<\/p>\n
![\"\"](\"https:\/\/bcisnotes.com\/secondsemester\/wp-content\/uploads\/2019\/08\/Exception-in-java1.png\")
<\/p>\nTypes of Exceptions<\/h3>\n
Checked exceptions<\/strong> \u2212 A checked exception is an exception that occurs at the compile time, these are also called as compile-time exceptions. These exceptions cannot simply be ignored at the time of compilation, the programmer should take care of (handle) these exceptions.<\/p>\n
Unchecked exceptions<\/strong>\u00a0\u2212 An unchecked exception is an exception that occurs at the time of execution. These are also called as\u00a0Runtime Exceptions. These include programming bugs, such as logic errors or improper use of an API. Runtime exceptions are ignored at the time of compilation.<\/p>\n
Catching Exceptions<\/h3>\n
A method catches an exception using a combination of the try and catches keywords. A try\/catch block is placed around the code that might generate an exception. Code within a try\/catch block is referred to as protected code, and the syntax for using try\/catch looks like the following \u2212
\nSyntax,<\/p>\ntry {
\n\/\/ Protected code
\n} catch (ExceptionName e1) {
\n\/\/ Catch block
\n}<\/p>\nExamples<\/strong><\/p>\n
\/\/ File Name : ExcepTest.java
\nimport java.io.*;<\/p>\npublic class ExcepTest {<\/p>\n
public static void main(String args[]) {
\ntry {
\nint a[] = new int[2];
\nSystem.out.println(“Access element three :” + a[3]);
\n} catch (ArrayIndexOutOfBoundsException e) {
\nSystem.out.println(“Exception thrown :” + e);
\n}
\nSystem.out.println(“Out of the block”);
\n}
\n}<\/p>\nMultiple Catching<\/h3>\n
A try block can be followed by one or more catch blocks. Each catch block must contain a different exception handler. So, if you have to perform different tasks at the occurrence of different exceptions, use java multi-catch block.<\/p>\n
Syntax<\/strong><\/p>\n
try {
\n\/\/ Protected code
\n} catch (ExceptionType1 e1) {
\n\/\/ Catch block
\n} catch (ExceptionType2 e2) {
\n\/\/ Catch block
\n} catch (ExceptionType3 e3) {
\n\/\/ Catch block
\n}<\/p>\nExample<\/strong><\/p>\n
try {
\nfile = new FileInputStream(fileName);
\nx = (byte) file.read();
\n} catch (IOException i) {
\ni.printStackTrace();
\nreturn -1;
\n} catch (FileNotFoundException f) \/\/ Not valid! {
\nf.printStackTrace();
\nreturn -1;
\n}<\/p>\nFinally Clause<\/h3>\n
The finally block follows a try block or a catch block. A finally block of code always executes, irrespective of occurrence of an Exception.
\nUsing a final block allows you to run any cleanup-type statements that you want to execute, no matter what happens in the protected code.<\/p>\nSyntax<\/strong><\/p>\n
try {
\n\/\/ Protected code
\n} catch (ExceptionType1 e1) {
\n\/\/ Catch block
\n} catch (ExceptionType2 e2) {
\n\/\/ Catch block
\n} catch (ExceptionType3 e3) {
\n\/\/ Catch block
\n}finally {
\n\/\/ The finally block always executes.
\n}<\/p>\nExample<\/strong><\/p>\n
public class ExcepTest {<\/p>\n
public static void main(String args[]) {
\nint a[] = new int[2];
\ntry {
\nSystem.out.println(“Access element three :” + a[3]);
\n} catch (ArrayIndexOutOfBoundsException e) {
\nSystem.out.println(“Exception thrown :” + e);
\n}finally {
\na[0] = 6;
\nSystem.out.println(“First element value: ” + a[0]);
\nSystem.out.println(“The finally statement is executed”);
\n}
\n}
\n}<\/p>\nThrowing An Exception<\/h3>\n
You can throw an exception in Java by using the throw keyword. This action will cause an exception to be raised and will require the calling method to catch the exception or throw the exception to the next level in the call stack.<\/p>\n
Throw And Throws<\/strong><\/p>\n
the throw keyword is used to throw an exception explicitly from any method or static block while throws keyword is used in a method declaration, denoted which exception can possibly be thrown by this method.
\nthe throw is followed by an instance while throws are followed by exception class name.
\nthe throw is used within the method whereas throws are used with the method signature.
\nYou cannot throw multiple exceptions using throw but you can declare multiple exceptions using throws one of which may or may not throw by the method.
\neg. public void method() throws IOException, SQLException{}
\nthrow statement will create an exception object but throws statement will not create an exception object.
\nthrows keyword is used to make an exception to be propagated explicitly to parent method(caller method) but when we use throw keyword and throw the exception, then it is not necessary that exception will be propagated. It may propagate if it is the unchecked exception and it may not propagate if it is checked exception.
\nthrows keyword not needed to be used for an unchecked exception to make it propagate to parent method(caller method) because they can be propagated by default but throws keyword should and must be used to handle exception in parent method if it is checked exception because checked exception can not be propagated by default.
\nUsing throw keyword you can also break a switch statement or a loop without using break keyword which cannot be performed using throws.<\/p>\nAnalyzing Track Trace Elements<\/strong><\/p>\n
Trace elemental analysis can tell you. Determining trace and ultra-trace level chemical impurities, either with or without a full elemental survey analysis can address this question. Trace concentrations are typically categorized as mass fractions from 1 part per million (ppm) to 100 ppm.<\/p>\n
Java’s Built-in Exceptions<\/strong><\/p>\n
Java – Built-in Exceptions. Java defines several exception classes inside the standard package java.lang. The most general of these exceptions are subclasses of the standard type RuntimeException. … Java defines several other types of exceptions that relate to its various class libraries.<\/p>\n
<\/p>\n
Creating an Exception Subclasses<\/strong><\/p>\n
Although Java\u2019s built-in exceptions handle most common errors, Java\u2019s exception handling mechanism is not limited to these errors. In fact, part of the power of Java\u2019s approach to exceptions is its ability to handle exceptions that you create which correspond to errors in your own code. Creating an exception is easy. Just define a subclass of Exception (which is, of course, a subclass of Throwable). Your subclasses don\u2019t need to actually implement anything\u2014it is their existence in the type system that allows you to use them as exceptions.<\/p>\n
You may also like\u00a0Introduction to Multithreading || Exception Handling and Multithreading || Bcis Notes<\/a><\/p>\n
<\/div>