Finally block : Exception Handling in Java

1. Finally Block in always executed irrespective of exception is handled or not
2. Finally is not a function, It is keyword in java
3. Finally performs the functions such as closing the stream or file and closing connections.
4. Finally block always gets executed before terminating the program by JVM.
5. Finally block should be after try and catch and is optional
6. Each try block has minimum 0 and maximum 1 finally block.

Flowchart for finally block -

Finally block : Syntax

try {
-------
-------
} catch(Exception e) {
-------
-------
}
finally {

}

Tip 1 : Finally block is optional

In the program we can have minimum zero and maximum one finally block.

public class MyExceptionExample {
    public static void main(String[] a){
        
        try{
            int i = 10/0;
        } catch(Exception ex){
            System.out.println("Inside 1st catch Block");
        }
        

        try{
            int i = 10/10;
        } catch(Exception ex){
            System.out.println("Inside 2nd catch Block");
        } finally {
            System.out.println("Inside 2nd finally block");
        }
    }
}

In the 1st try block we can see that we don’t have finally block but in the 2nd try block we have finally block. So finally block is always optional.

finally {
    System.out.println("Inside 2nd finally block");
}

2nd try block does not throw any exception but still after the execution of try block code executes finally block

Output :

Inside 1st catch Block
Inside 2nd finally block

Tip 2 : Finally block is not executed in below two cases

1. If following statement is included in the try block (Terminating code using system exit)

System.exit(0);

2. If the thread executing the try or catch code is interrupted or killed, the finally block may not execute [For more info]

The post Finally block : Exception Handling in Java Programming appeared first on Learn Java Programming.

public class ExceptionExample {

    public static void main(String argv[]) {

     int result = 0;
     int arr[] = new int[5];

     arr[5] = 5;

     result = 100 / 0;
     System.out.println("Result of Division : " + result);

  }
}

In this example we can see that

arr[5] = 5;
result = 100 / 0;

both these lines will generate exception.If we put both these codes in same try block then it will generate one exception and the next code won’t be executed.

public class ExceptionExample {

    public static void main(String argv[]) {

     int num1 = 10;
     int num2 = 0;
     int result = 0;
     int arr[] = new int[5];

	try {
	     try {
	     arr[5] = 5;
	}catch (ArrayIndexOutOfBoundsException e) {
	System.out.println("Err: Array Out of Bound");
	}    

	try {
	     result = num1 / num2;
	}catch (ArithmeticException e) {
	     System.out.println("Err: Divided by Zero");
	}
	System.out.println("Result of Division : " + result);

   }catch (Exception e) {
        System.out.println("Exception Occured !");
   }

  }
}

In the above code each and every exception is handled. In order to handle each exception we need to use try block.

The post Nested Try Block Statement : Exception Handling in Java appeared first on Learn Java Programming.

Catching Multiple Exception in single catch :

Whenever try block will thrown any exception of these type then and then only we can handle the exception.

catch (IOException ex) {
     System.out.println("IO Exception");
     throw ex;
} catch (SQLException ex) {
     System.out.println("SQL Exception");
     throw ex;
}

1. If in a try block we need to handle multiple exceptions then we need to write exception handler for each type of exception.
2. We can combine the multiple exceptions in catch block using Pipe (|) Operator.

catch (IOException|SQLException ex) {
    System.out.println("Exception thrown");
    throw ex;
}

above single catch block can handle IO as well as SQL exceptions. So it is better to use Pipe Operator to handle multiple exceptions instead of writing individual catch block for each exception. Also Refer this oracle guide for more information.

Parameter Accepted by Catch Block is Final :

1. If a catch block handles more than one exception type, then the catch parameter is implicitly final.
2. In this example, the catch parameter ex is final.
3. We cannot assign any values to it within the catch block.

The post Catching multiple exception types using single catch block appeared first on Learn Java Programming.

Multiple Catch Blocks : Catching Multiple Exceptions

public class ExceptionExample {

    public static void main(String argv[]) {

     int num1 = 10;
     int num2 = 0;
     int result = 0;
     int arr[] = new int[5];

     try {
	 arr[0] = 0;
	 arr[1] = 1;
	 arr[2] = 2;
	 arr[3] = 3;
	 arr[4] = 4;
	 arr[5] = 5;

    result = num1 / num2;
    System.out.println("Result of Division : " + result);

    }catch (ArithmeticException e) {
	     System.out.println("Err: Divided by Zero");

    }catch (ArrayIndexOutOfBoundsException e) {
	     System.out.println("Err: Array Out of Bound");
    }

  }
}

Output :

Err: Array Out of Bound

In the above example we have two lines that might throw an exception i.e

arr[5] = 5;

above statement can cause array index out of bound exception and

result = num1 / num2;

this can cause arithmetic exception. To Handle these two different types of exception we have included two catch blocks for single try block.

}catch (ArithmeticException e) {
	 System.out.println("Err: Divided by Zero");

}catch (ArrayIndexOutOfBoundsException e) {
	 System.out.println("Err: Array Out of Bound");
}

Now Inside the try block when exception is thrown then type of the exception thrown is compared with the type of exception of each catch block.

If type of exception thrown is matched with the type of exception from catch then it will execute corresponding catch block.

Notes :

1. At a time only single catch block can be executed. After the execution of catch block control goes to the statement next to the try block.
2. At a time Only single exception can be handled.
3. All the exceptions or catch blocks must be arranged in order. [Refer the Exception Hierarchy]

Catch Block must be arranged from Most Specific to Most General :

If we wrote catch block like this -

}catch (Exception e) {
	 System.out.println("Err: Exception Occurred");

}catch (ArrayIndexOutOfBoundsException e) {
	 System.out.println("Err: Array Out of Bound");
}

1. All the exceptions will be catched in the First Catch block because Exception is superclass of all the exceptions.
2. In the above program ArrayIndexOutOfBoundsException is an subclass of Exception Class.

Writing above code will throw following error message after compiling it -

The post Multiple Catch Blocks : Exception Handling in Java appeared first on Learn Java Programming.

Try Catch Block :

We need to put code inside try block that might throw an exception. Try block must be within a method of a java class.

try { 
      //Statement 1;
      //Statement 2;
      //Statement 3;
    }catch(Exception e) {
      //Exception Handling Code
    }

above is the syntax of try catch block in java. If an exception occurred during the execution of Statement 1..3 then it will call exception handling code.

Tips for Try-Catch Block :

1. The code within try block may or may not raise an exception. If Try block does not throw any exception then catch block gets executed.
2. The catch block contains an exception handler and some statements used to overcome that exception
3. Each and every Try Block must have catch or finally statement associated with it.

Explanation with Example :

public class ExceptionExample {
    public static void main(String[] args) {
       int number1 = 50;
       int number2 = 0;
       int result;
       try { 
   	    result = number1 / number2;
	    System.out.println("Result of Division : " + ans);
	} catch(ArithmeticException e) {
	    System.out.println("Divide by Zero Error");
	}   
   }
}

Consider the above example – We know that division of any number with zero is not possible.If we attempt to divide any number by zero in java then it may cause an error.

result = number1 / number2;

above statement may cause an exception so we need to put that code inside try block. Whenever an exception occures the catch block gets executed.

} catch(ArithmeticException e) {
	    System.out.println("Divide by Zero Error");
	}

Inside catch we have simply displayed an error message i.e “Divide by Zero Error”.

Exception thrown and Type of Exception Object :

Exception thrown by try block is of type Arithmetic Exception so it can be catched inside the catch block because we have provided the handler of same type.

try { 
       result = number1 / number2;
       System.out.println("Result of Division : " + ans);
}catch(FileNotFoundException e) {
      System.out.println("Divide by Zero Error");
}

If we execute the above code instead then thrown exception is of type Arithmetic Exception and Exception Type provided into Catch block is of type FileNotFoundException then exception may not be catched. Thus above code can cause compile time error.

try { 
       result = number1 / number2;
       System.out.println("Result of Division : " + ans);
}catch(Exception e) {
      System.out.println("Divide by Zero Error");
}

In the above code we can catch all types of exception because Exception is superclass of all the exceptions. [Refer the Exception Hierarchy]

The post Try-Catch Block : Exception Handling in Java Programming appeared first on Learn Java Programming.

Types of Exceptions in Java :

A. Checked exceptions :

1. A checked exception is an exception which is error or a problem occurred because of code written by programmer
2. Checked Exception cannot be neglected by the programmer.
3. Suppose we are opening the file and file is not present then exception occurred during the compile time can be considered as checked exception.
4. These exceptions cannot be ignored at the time of compilation.
5. Class that extend throwable class except RuntimeException and Error is considered as Checked exception.

B. Runtime exceptions:

1. Classes that extent RuntimeException class is called as Runtime Exception.
2. Runtime exceptions are ignored at the time of compliation.

C. Errors :

1. These are not exceptions but the problems that are beyond the control of the user or the programmer.
2. For example, Stack overflow, Virtual Machine Memory,AssertionError

Exception Hierarchy :

The post Types of Exception and Exception Hierarchy : Java Programming appeared first on Learn Java Programming.

1. An exception is an event.
2. Exception occurs during the execution of a program when normal flow of the program is Interrupted or disturbed.
3. Exception Handling is machanism to handle the exceptions.

How Exception Handling Works in Java ?

1. When any error occures in a method then new object (i.e Exception Object) is created by a method
2. Exception Object contain information about error such as type of error and state of the program.
3. Newly created exception object is passed to the Runtime System.
4. Runtime system will handle the exception to keep system stable

Advantages of Exception Handling :

In the previous programming languages, whenever any illegal condition is executed then program flow gets disturbed. In java programming exception handling ensures that program should run smoother. Consider the following example -

public class ExceptionExample {
    public static void main(String[] args) {
       int num1 = 50;
       int num2 = 0;
       int ans;

       ans = num1 / num2;
       System.out.println("Result of Division : " + ans);
   }
}

In this example, we know that any number divided by 0 will cause program to go into unexpected situation. If program contain such unexpected statements then its better to handle these unexpected results. Below is the unexpected error output -

Exception in thread "main" java.lang.ArithmeticException: / by zero
      at DivideByZeroNoExceptionHandling.main(
           DivideByZeroNoExceptionHandling.java:7)

Now we have done slight modification in the program by providing exception handling code in the program -

public class ExceptionExample {
    public static void main(String[] args) {
       int num1 = 50;
       int num2 = 0;
       int ans;
       try { 
   	    ans = num1 / num2;
	    System.out.println("Result of Division : " + ans);
	} catch(ArithmeticException e) {
	    System.out.println("Divide by Zero Error");
	}   
   }
}

so the output of the above code will be -

Divide by Zero Error

The post Exception Handling in Java Programming appeared first on Learn Java Programming.

Joining two Strings [Concatenate Strings] in Java :

Consider the following example -

public class ConcatenateString {
    public static void main(String[] args) {
       String Str1 = "I love";
       String Str2 = "my country";
       String Str3 = "India";

       String myString; 
       myString = Str1 + Str2 + Str3;
       System.out.println("Complete Statement : " + myString);

       myString = Str3 + 10 + 10;
       System.out.println("Complete Statement : " + myString);

       myString = 10 + 10 + Str3;
       System.out.println("Complete Statement : " + myString);
   }
}

Output :

Complete Statement : I love my country India
Complete Statement : India1010
Complete Statement : 20India

Explanation of the Program :

In Java Programming when two strings will be combined together then it will create another object of string. Below are some thumb rules while adding or combining two strings.

Operand 1	Operand 2	Result of Concatenation
Integer	String	String
String	String	String
Integer	Integer	Integer

1. ‘+’ operator has associtivity from left to right.
2. Each time + operator will check the type of operands and then decide which operation to perform.
3. If any of the operand is of type String then another type will converted to String using respective wrapper classes.

First Concatenation :

myString = Str1 + Str2 + Str3;
         = "I love " + "my country " + "India"
         = "I love my country " + "India"
         = "I love my country India"

Second Concatenation :

myString = Str3 + 10 + 10;
         = "India" + 10 + 10
         = "India10" + 10
         = "India1010"

Third Concatenation :

myString = 10 + 10 + Str3;
         = 10 + 10 + "India"
         = 20 + "India"
         = "20India"

The post Java Concatenate Strings : [String Operations] appeared first on Learn Java Programming.

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

	String myString = new String("I am living in India");
	System.out.println( myString );

	myString.replaceAll( "India" , "USA" );
	System.out.println( myString );

	}
}

Output of Program :

I am living in India
I am living in India

Explanation : Immutable String Objects

In the above example, we can see that

myString.replaceAll( "India" , "USA" );

it will create another string i.e -

I am living in USA

though object is created for “I am living in USA” string but reference variable “myString” is still not referring to new string. We need to specify the reference explicitly using following assignment -

myString = myString.replaceAll( "India" , "USA" );

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

    String myString = new String("I am living in India");
    System.out.println( myString );

    myString = myString.replaceAll( "India" , "USA" );
    System.out.println( myString );

    }
}

and output will be like this -

I am living in India
I am living in USA

The post Immutable String Objects : String Handling Java Tutorials appeared first on Learn Java Programming.

In Java we can create String in two ways – One by using String Literals and another using new operator.

Way 1 : Creating String Objects using Literals

Consider the following Code Statement -

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

   String myName = "PRASHAN";
   System.out.println("Hello " + myName);

   myName = "PRABHU";
   System.out.println("Hello " + myName);
   }
}

Explanation :

String myName = "PRASHAN";

The above Statement will be pictorially represented below -

Now when we assign another string literal to String Object then earlier string will be discarded.

myName = "PRABHU";

Actual String can be stored anywhere in the heap but String Object – “myName” will locate the position of the String – “PRABHU” and stores the reference to that actual string.

Way 2 : Using new Operator

String name = new String("AKASH");

Consider the above code line –

Entity	Object/Variable	Memory Location
AKASH	Object	String Constant Pool
new String("AKASH")	Object	Non Heap Memory
myName	Reference Variable	-

*Reference Variable is Pointing to a String Object – new String(“AKASH”)

The post Creating String Objects in Java Programming appeared first on Learn Java Programming.