What is the difference between Array and ArrayList is the quite common question for the Java interview and for the beginners who are learning Java programming. I have started writing the Java best practices series, this is one of the post for clearing the air on misconception about popular Java classes Array and ArrayList.

1. Flexible Storage

One of the major difference between Array and ArrayList is that, Array has the fixed length and it can not be extended once it is initialized. Here is the simple construct for initializing the arrays which I have taken from Java Arrays Example:

[code lang=”java”]
int weight[ ]= new int[5];
weight[0]=36;
weight[1]=42;
weight[2]=24;
weight[3]=10;
weight[4]=50;
[/code]

If you look at the above example, array variable weight is initialized with the length 5, it can not accommodate more than 5 elements.
Whereas ArrayList can dynamically increase the size when new elements are added. Look at the following code:

[code lang=”java”]
ArrayList<String> list = new ArrayList<String>();
[/code]

When you create the above object, the default size of 10 is internally assigned for storing the values. However, when you add the eleventh element, the ArrayList size will be extended to another 10 elements. This impacts the performance of your programming if it has to increase multiple times for accommodating more elements.

2. Generics

Arrays can not use the Generics programming introduced in Java 5. Array knows the type which it can hold, otherwise it will throw the ArrayStoreException when you try to store the wrong data type.

Whereas one of the great advantages of the collections programming is to use the generics for specifying the type of the objects an ArrayList can store. This provides the type-safety for your code at compile time itself.

3. Length / Size

Arrays provide the method length for accessing the size of an array. Even though you have not stored any elements in the array, this method will always returns the capacity of the array.

ArrayList or any other collections APIs that implements List interface defines the method size accessing the size of the object. Note that size method of ArrayList returns only the number of elements currently stored, to know the maximum elements that can be stored in the ArrayList can be accessed using the method capacity.

4. Primitives and Objects

Arrays can be created for either primitives or objects. It can store primitive types as well as objects.

ArrayList can hold only the objects using the add method. Since the Java 5 version, though you store the primitive types to an ArrayList, it silently converts (autoboxing in Java 5) the primitive value to corresponding wrapper class and stores it. All the collection APIs support only storing of the objects and not the primitive values.

5. Iterator

One of the greatest advantage of storing the objects in the collections API is use of iterator for iterating the elements. But, this feature is not available with the Arrays, we have to do the manual iteration using for loop or while loop constructs.

6. Performance

There is no difference in terms of performance between Array and ArrayList classes. They both offer the similar performance for storing and retrieving the objects. If you are storing the thousands of objects in your application, you can measure the performance difference between Array and ArrayList. ArrayList internally uses the Array for storing the objects.

If you are performing the resize() operation or automatic resizing of the ArrayList, the it will impact the performance.

Best Practice

The recommendation is only my opinion and not to be taken as universal best practice for the use of Array vs ArrayList in your projects. I would recommend using the ArrayList every where because it offers the lot of flexibility for storing the objects. If you want thread safety, choose Vector instead of ArrayList.

 

 

If you are a Java programmer, then one of the common question comes into mind is How do I compile for compatibility with older versions of Java?. When you run your Java  program with an older version of the Java runtime environment, you may get the following Java exception if you have not compiled with the right version of Java language:

[code]
Exception in thread "main" java.lang.UnsupportedClassVersionError: Bad version number in .class file
[/code]

In one of my previous example, I have explained about how to check the version number of the Java from the class file. In this tutorial I am going to explain the two parameters, target and source which are used for cross compilation and runtime requirements of your Java application.

If you want to ensure the application has to support the minimum runtim environment, then you have to fully understand how to use the source and target parameter for javac.  Java compiler javac have the option to set the target runtime environment supported for your application by using the command line arguments target while compiling the source code.

Javac Source and Target Parameters

Source parameter tells the compiler that the source code will be compiled with the specific version. The official documentation says the source parameter provides source compatibility with specified release. If you are compiling the source code with Java 1.6, but if the code is having some specific features in the Java 7, then compilation fails. In that case you have to set the source parameter as the Java 1.7.

The following are the accepted parameter value for the release:

• 1.3 – The compiler does not support assertions, generics, or other language features introduced after JDK 1.3.
• 1.4 – The compiler accepts code containing assertions, which were introduced in JDK 1.4.
• 1.5 – The compiler accepts code containing generics and other language features introduced in JDK 5.
• 5 – Synonym for 1.5.
• 1.6 – This is the default value if you are compiling with JDK 6. No language changes were introduced in Java SE 6. However, encoding errors in source files are now reported as errors, instead of warnings, as previously.
• 6 – Synonym for 1.6.
• 1.7 – This is the default value. The compiler accepts code with features introduced in Java SE 7.
• 7 – Synonym for 1.7.

Target parameter tells the compiler that what is the minimum targeted JVM that can run the class files. If you pass the target parameter as 1.5, then the class files compatible to run 1.5 and above version of JVM. But, it can not run below 1.5 JVM.

The default for -target depends on the value of -source:

• If -source is not specified, the value of -target is 1.6
• If -source is 1.2, the value of -target is 1.4
• If -source is 1.3, the value of -target is 1.4
• For all other values of -source, the value of -target is the value of -source.

Let’s look at the below example command:

[code]
% javac -source 1.6 -target 1.5
[/code]

The above code conveys the message that, the code base will be compiled with the Java 1.6 version, but the targeted minimum environment support is Java 1.5. In other words, converted class files are compatible to with 1.6 JVM.

Ant – Source and Target

How to use the source and target parameter of javac can be used in the apache ant script?. Let’s look at the below code snippet of ant script:

[code lang=”xml”]
<target name="compile">
<javac source="1.5" target="1.5" srcdir=…/>
</target>
[/code]

Maven – Source and Target

This section provides the sample code snippet for using the source and target parameters of javac in the maven’s pom.xml file.

[code lang=”xml”]
<project>
[…]
<build>
[…]
<plugins>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-compiler-plugin</artifactId>
<version>3.5.1</version>
<configuration>
<source>1.5</source>
<target>1.5</target>
</configuration>
</plugin>
</plugins>
[…]
</build>
[…]
</project>
[/code]

Removing Support for the older versions

There is a JEP 182 which talks about retiring the old version from the support to reduce the cost to maintain multiple versions.

Oracle wants reduce the maintenance costs of javac, so the new JEP 182 defines a policy for retiring old -source and -target options. From JDK 8, use of a source or target of 1.5 or earlier is deprecated and in JDK 9, support for a source or target of 1.5 or earlier will be completely removed.

From JDK 9 and going forward, javac will use a “one + three back” policy of supported source and target options. Under this policy, javac will still be able to recognize and process class files of all previous JDKs, going back to version 45.3 class files generated by JDK 1.0.2, which first shipped in 1996.

One of the basic Java interview question is what is the difference between abstract class and interface. If you are a beginner in Java, you can not avoid this question in any Java interview to test your knowledge on Java OOPs concepts. In this short tutorial I will write down the difference between abstract class and interface in Java. Also there is few simple examples for abstract class and interface.

The below table presents the key differences:

	Abstract Class in Java	Interface in Java
1	An abstract class can have instance methods that would have default implementation	Interface is implicitly abstract and can not have any default method implementation. But, with Java 8, interfaces can have method implementation using the default keyword.
2	Abstract class doesn’t support multiple inheritance.	Interface supports multiple inheritance.
3	Abstract class can have constructors.	Interfaces can not declare a constructor.
4	Abstract class can extend only one class or one abstract class at a time	Interface can extend any number of interfaces at a time
5	abstract  class  can extend from a class or from an abstract class	interface can extend only from an interface
6	abstract  class  can  have  both  abstract and concrete methods	interface can  have only abstract methods
7	A class can extend only one abstract class	A class can implement any number of interfaces
8	In abstract class keyword ‘abstract’ is mandatory to declare a method as an abstract	In an interface keyword ‘abstract’ is optional to declare a method as an abstract
9	Abstract  class can have  protected , public and public abstract methods. There is no implicit behavior for the members.	Interface can have only public abstract methods. The members of interface are implicitly public by default. Also interfaces can not have static methods.
10	Abstract class can have  static, final  or static final  variable with any access specifier	Interface members are implicitly static and final by default.

Abstract Class Example

[code lang=”java”]
public abstract class AbstractClass{
public int i = 10;
public void abstract abstractMethod();
public void methodImpl(){
System.out.println("Default Method Implementation");
}
}

class ClassImpl extends AbstractClass{
public void abstractMethod(){
System.out.println("Method Implementation in Sub Class");
}
}
[/code]

Interface Example

[code lang=”java”]
public class InterfaceExample{
public static final i = 10; //public, static, final keywords are optional.
public void abstractMethod(); //This method is implicitly abstract
public void methodImpl(){ // This method is not legal. Method implementation not allowed in interfaces.

}
}
[/code]

In this tutorial I am going to explain Java exceptions in details and how to use them in the real applications. One of the important measure to assess the quality of your Java code is to review the exception handling and how exceptions scenarios are handled.

If you have to write an efficient exception handling, then you should have good understanding on the exception hierarchy and different categories of the exception. Let’s read this tutorial and share your feedback at the comments section.

What is an Exception?

Exceptions are events that occurs when executing the programs that will disrupt or terminate the normal flow of the program. In Java, an exception is an object that contains the type of the exception and details of the root cause for that exception.

• The exception can be JDK library exception (built-in with JDK API) or user defined custom exception.
• In general practice, we can use theprintStackTrace() for printing the complete details of the exception. This method will be print the origin of the exception and path of the exception propagation.
• The exceptions can be thrown because of programmatic errors or environment issues.

Exception Hierarchy

It is very important to understand the basic exception hierarchy of Java exception classes.

• Throwable is root class for the exception hierarchy.
• Error and Exception classes are inherited from the Throwable class.
• RuntimeException exception is the subclass of Exception class.

Exception Categories

There are three types of exception categories:

1. Checked exceptions
2. Runtime exceptions (unchecked exceptions)
3. Errors

Checked Exceptions

A checked exception is an unacceptable condition foreseen by the author of the code but that would not occur immediately at the compile time. The exception probably may occur at the runtime in certain scenarios. For example : FileNotFountException is a checked exception. This exception is thrown only when the file could not be found.

Look at the following code:

[code lang=”java”]
File file = new File("test.txt");
try{
FileInputStream fin = new FileInputStream(file);
}catch (FileNotFoundException e){
e.printStackTrace();
}
[/code]

In the above code, the author of the code knows that at runtime there is a chance for missing the file. This is anticipated and could be nice to handle those scenarios while writing the code. That is the reason handling the checked exceptions are compulsory and code will not compile if you are not handling the checked exceptions in your code.

• Checked exceptions extend the class java.lang.Exception.
• Checked exceptions must be handled by the developer
• If you want to write your own checked exception, extend the class java.lang.Exception from your custom exception class.

Some of the example for the checked exceptions are:

• FileNotFoundException
• ParseException
• ClassNotFoundException
• CloneNotSupportedException
• InstantiationException
• InterruptedException
• NoSuchMethodException
• NoSuchFieldException

Runtime Exceptions

Runtime exceptions are the exceptions that are caused by the programming mistakes and not an expected one in the application. For example: Handling the null check for the objects before invoking any of its members are responsibility of developers. If you are not handling the null checks, you would encounter NullPointerException while running the application. Note that you should not handle these exceptions in the code. Because, these exceptions has to be handled by the code itself.

Look at the bellow code snippet:

[code lang=”java”]
private static StringBuilder sb;
public static void main(String args[]) {
System.out.println(sb.toString());
}
[/code]

In the above code, the variable sb is not initialized after its declaration. Since it will have the default value of null, it will throw NullPointerException while accessing the methods. There will not be any compiler error at the compile, these errors are thrown only at the runtime. Hence, the developer should not handle these exceptions in code.

• All the runtime exceptions are the type of java.lang.RuntimeException. If you want to write your custom runtime exception, extend your custom class with java.lang.RuntimeException

Few of the runtime exceptions are :

• ArrayStoreException
• BufferOverflowException
• BufferUnderflowException
• CannotRedoException
• CannotUndoException
• ClassCastException
• CMMException
• ConcurrentModificationException
• DOMException
• EmptyStackException
• IllegalArgumentException
• IllegalMonitorStateException
• IllegalPathStateException
• IllegalStateException
• ImagingOpException
• IndexOutOfBoundsException
• MissingResourceException
• NegativeArraySizeException
• NoSuchElementException
• NullPointerException
• ProfileDataException
• ProviderException
• RasterFormatException
• SecurityException
• SystemException
• UndeclaredThrowableException
• UnmodifiableSetException
• UnsupportedOperationException

Errors

An error is a serious exception thrown by the JVM as a result of an error in your application environment. This error is not controlled by your code. For example :NoClassDefFoundError is thrown by JVM when it is not able to locate the class file that it is suppose to load for running your application. Another example is StackOverflowError when JVM running out of memory in for stack for the Java program. These conditions are related to the environment (JVM, JRE, etc.) hence nowhere in control of your code. When your application encounters this kind of errors, your application will be immediately terminated.

Look at the below code:

[code lang=”java”]
public class ExceptionExample {
public ExceptionExample(){
ExceptionExample example = new ExceptionExample();
}
public static void main(String args[]) {
ExceptionExample example = new ExceptionExample();
}
}
[/code]

If you are running the above code, you will be getting the following error and the program will be terminated. Your class can catch and handle the errors, but it shouldn’t handle the errors. Let JVM itself handle the errors.

[code]
Exception in thread "main" java.lang.StackOverflowError
at org.ExceptionExample.&amp;amp;amp;lt;init&amp;amp;amp;gt;(ExceptionExample.java:7)
at org.ExceptionExample.&amp;amp;amp;lt;init&amp;amp;amp;gt;(ExceptionExample.java:7)
at org.ExceptionExample.&amp;amp;amp;lt;init&amp;amp;amp;gt;(ExceptionExample.java:7)
[/code]

How to Handle Exceptions?

This section going to walk through the exception handling in Java. We all know that handling of exception is good practice for applications. But, how to do that?. Java provides keywords try,catch,finally,throw and throws for handling the exceptions. We will go through each one in detail and how to use them in your Java program.

• Also Read : Exceptions in JSP

try and catch

The try and catch block is used for writing the code that might throw an exception. In simple words, put the code that would throw exceptions inside the try and catch block. Every try block must be followed by a catch or finally block. It is perfectly valid for a try block to ignore catch and have only a finally block. A try block may have more than one catch or finally block. There are many other rules and best practices to use the try and catch block, you would be learning those only when you are working with real applications.

• Also Read : Exception Handling in Spring Applications

Here is the example of a try and catch block:

[code lang=”java”]
public void method(){
try{
//statements here
}catch (Exception e){
e.printStackTrace();
}
[/code]

finally

Finally blocks are executed always even there is exception thrown by the applications. It is good practice to put the code which must be executed for cleaning up the resources, etc. For example : If you want to close the database connection or close the file operations, finally block is the right place to write that code.

Finally block appears after the try or catch block. The syntax for the finally block looks like this:

[code lang=”java”]
try
{
//Protected code
}catch(Exception e1)
{
//Catch block
}catch(Exception e2)
{
//Catch block
}catch(Exception e3)
{
//Catch block
}finally
{
//The finally block always executes.
}
[/code]

throw

throw is used for invoking the exception explicitly. When throw statement is encountered in your program, the next statement is not executed. The control is immediatlely transferred to catch block to see if the thrown exception is handled there. If none of the catch block is handling the exception, the thrown exception will be shown to the user. We can use throw keyword for throwing new exception or re-throwing the exception caught in the catch block.

Let’s look at the simple example for throw:

[code lang=”java”]
public class ExceptionExample {
public static void main(String args[]) {
try {
new ExceptionExample().method2();
} catch (IOException e) {
System.out.println("Exception handled in this method : "
+ e.getMessage());
}
}

public void method1(){
File file = new File("wrongfile.txt");
try {
FileInputStream fin = new FileInputStream(file);
System.out.println(fin.read());
} catch (FileNotFoundException e) {
throw e;
} catch (IOException e) {
throw e;
}
}

public void method2() throws IOException {
method1();
}
}
[/code]

In the above example exceptions are re-thrown from the catch block and handled in another method. It is good practice to re-throw exceptions only when we are not handling in that particular method and handling in the caller method.

throws

throws is used for postponing the exception handling and can be used as the alternative for try and catch block. Throws is declared at the end of method signature.If the method might throw multiple exceptions, all the exception can be declared in the method signature with coma separated.
Suppose, one method is declaring the throws clause in the method signature, then calling method must handle those exceptions.

Here is the simple example for using throws clause:

[code lang=”java”]
public void method2() throws IOException {
method1();
}
[/code]

Using the throws clause is that we are just avoiding the try and catch but the actual handling is propagated to caller method. If you declare an exception in the throws clause, then the caller method muse handle the exception. Otherwise code will not compile.

Custom Exceptions

Custom exceptions are the exceptions that are application specific exceptions. These exceptions are not part of the Java’s built-in exception hierarchy. If you are working on a Java application, there would be a requirement to write your own custom exceptions to handle the application specific errors which will be more convenient for the application to understand and interpret the messages to the users in-case of any error.

Note that if you want to write checked exception, please extend your exception class with java.lang.Exception or if you want to write runtime exception, then please extend your exception class with java.lang.RuntimeException.

I have written a very simple custom exception that would explain you the real purpose for writing our own exception. Let’s look at the below code:

InSufficientFundException.java

[code lang=”java”]
package net.javabeat.exception;

public class InSufficientFundException extends Exception {
private int id;

public int getId() {
return id;
}

public void setId(int id) {
this.id = id;
}

public InSufficientFundException() {
super();
}

public InSufficientFundException(String message, int id) {
super(message);
this.id = id;
}

public InSufficientFundException(String message, Throwable t) {
super(message, t);
}

@Override
public String toString() {
return super.toString();
}

@Override
public String getMessage() {
return super.getMessage() + "for account : " + id;
}
}
[/code]

ExceptionExample.java

[code lang=”java”]
package net.javabeat.exception;

public class ExceptionExample {
public static void main(String args[]) throws InSufficientFundException {
throw new InSufficientFundException(
"There is not enough fund in this account ", 100);
}
}
[/code]

When you run the above program you will get the following exception message:

[code]
Exception in thread "main" net.javabeat.exception.InSufficientFundException: There is not enough fund in this account for account : 100
at net.javabeat.exception.ExceptionExample.main(ExceptionExample.java:5)
[/code]

Above example implements a custom exception InSufficientFundException to throw error message when there is not enough fund in the bank account, probably there will be a check in the application and then this exception will be thrown. I felt it is irrelevant to write more code for account operations and that is not our goal here. We have to understand how to write a custom exception class.

When you create a custom exception instance, you can pass the message and Throwable object to the super class exception. Also you can override the getMessage method to customize the error message shown in the exception.

Improvements in Java 7

1. Multiple Exceptions in Catch Block:

There are lot of new features introduces as part of the Java 7 release (some more). One of them is the catching multiple exceptions in the single catch block. Prior to Java 7, a catch block can catch only one exception at a time. With the Java 7 release, developers can add multiple exceptions using the “|” symbol.

Let’s look at a simple example:

[code lang=”java”]
public void method1() throws IOException {
File file = new File("wrongfile.txt");
try {
FileInputStream fin = new FileInputStream(file);
System.out.println(fin.read());
} catch (IOException | NullPointerException e) {
throw e;
}
}
[/code]

• But, you can not declare the same exception hierarchy in the same catch block. For example, IOException and FileNotFoundException can not be in the same catch block since both are of the same type. You would get the error message something like : The exception FileNotFoundException is already caught by alternative exception IOException.
• Another point is that when you handle more than one exception in single catch block, the exception variable used in the catch block is implicitly final. You can not assign any value to the variable e.

2. Try with Resources statement:

Another improvement in Java 7 is introduction of try-with-resource statement for auto-closing the resource instances. A resource is an object, that must be closed after it finished the operation. Any object that implements the class java.lang.AutoCloseable or java.io.Closeable can be used as a resource.

This classes will override the method close that will be invoked automatically at the time of closing the operation. Prior to java 7, this method will be invoked in the finally block. But, if there is any exception in the finally block, that also has to be handle. This handling become much easier in Java 7.

Let’s look at the example snippet:

[code lang=”java”]

try ( Resource myResource2 = new Resource("TRY-WITH-RESOURCE")){
myResource2.useResource();
}catch ( SomeException | IOException ex){
ex.printStackTrace();
}
[/code]

If you want to read more about this feature, please our previous tutorial on try-with-resource block or official documentation.

3. Suppressed Exceptions Handling in Java 7

Another nice feature introduced in the Java 7 release is the handling of suppressed exception while using the try-with-resource block. Prior to java 7, second exception thrown while closing the resource was suppressed and not shown to the user.

With the improvements, lot of code has been reduced and Java itself handles the suppressed exception. Here is the more detailed tutorial on suppressed exceptions used in Java 7 with multiple scenarios.

Java Exception Handling Best Practices

1. Never suppress the exceptions in the catch block

2. Always catch the specific exception class in the catch block instead of just catching the java.lang.Exception class.

Let’s look at the following sample code:

[code lang=”java”]
public void method(){
try{
//statements here
}catch (FileNotFoundException e){
//handle here
}catch (IOException e){
//handle here
}
}
[/code]

3. Don’t throw exception from the finally block. If finally throws exception, it will be lost forever. If there is a case that finally would thrown an exception, either you handle it or log the error message. Don’t allow the exception to be un-handled.
4. Always catch the exceptions that you can handle. This is one of the important best practice to be remembered. If you look at many of the applications, there will be a catch block and there won’t be any statements for handling the exceptions. For the worst case, missing any log statements. This becomes very difficult to trace the issue if you suppress the errors.
5. Use finally blocks instead of catch blocks if you are not going to handle the exceptions.

Summary

This tutorial explained the basic idea behind writing the exceptions, different categories of exceptions, exception handling, how to write custom exceptions and finally the best practices for writing the efficient exceptions for your application. If you have any questions please write it in the comments section.

Upcasting is assigning the sub class reference object to the parent class which is allowed in Java. Downcasting is assigning parent class reference object to the sub class which is not allowed in Java. However, if you do downcasting, there will not be any compiler error. But, there will be runtime exception java.lang.ClassCastException. Then why downcasting is permitted without any compiler error?. Downcasting is legal in some scenarios where the actual object referred by the parent class is of sub class.

Look at this example to understand when downcasting works without any exception.

DownCastingExample.java

[code lang=”java”]
package javabeat.net.core;

/**
* Java DownCasting Example
*
* @author Krishna
*
*/
public class DownCastingExample {

public static void main(String[] args) {
SuperClass superClass1 = new SuperClass();
SuperClass superClass2 = new SubClass();

//Valid down casting
SubClass subClass1 = (SubClass)superClass2;
subClass1.method();

//Invalid down casting
SubClass subClass2 = (SubClass)superClass1;
}
}

class SuperClass{

}

class SubClass extends SuperClass{
public void method(){
System.out.println("Subclass Method Called");
}
}
[/code]

Output…

[code]
Exception in thread "main" java.lang.ClassCastException: infosys.net.core.SuperClass cannot be cast to infosys.net.core.SubClass
at javabeat.net.core.DownCastingExample.main(DownCastingExample.java:20)
Subclass Method Called
[/code]

Static Nested classes are inner classes which are declared inside another class and also declared with static keyword. The main difference between inner class and static nested classes is that inner classes are non-static and static nested classes are static. Also known as static classes.

• Static nested classes can be accessed using the enclosing class name.
• It can access static data members of outer class including private.
• static nested class cannot access non-static (instance) data member on method.
• static nested class can access static data member of another nested class within the outer class.
• By making a nested classes can be static, you can use the nested class without having an instance of the outer class.

Lets look at the simple example.

StaticClassExample.java

[code lang=”java”]
package javabeat.net.core;

/**
* Static Nested Class Example
*
* @author Krishna
*
*/
public class StaticClassExample {
static int i = 10;
public static void main(String[] args) {
//Access static nested class
new StaticClassExample.NestedClass().method();
}

public static class NestedClass{
public void method(){
System.out.println("Method in Static / Nested Class");
//Outer class static
System.out.println(StaticClassExample.i);

//Another nested class static
System.out.println(StaticClassExample.NestedClass1.j);
}
}

public static class NestedClass1{
static int j = 20;
}

}
[/code]

Output…

[code]
Method in Static / Nested Class
10
20
[/code]

This example show the order of the Java initialization blocks. Java has static initializer, instance initializer and constructor for initializing the variables. These blocks are used for the different purposes and leads to confusion among the programmers.

Order of the execution of these blocks are as follows:

• All Static Initializers executed in the same order how it is declared
• All the instance initializers executed in the same same order how it is declared
• After the above two execution, finally constructor is called.

static/instance initializers can be used to set the value of “final” static/instance variables whereas a constructor cannot.

Anonymous inner classes can’t have a constructor (as they’re anonymous), so they’re a pretty natural fit for instance initializers.

I have written a simple program which demonstrates the order of execution for static initializer, instance initializer and constructor.

JavaInitializationExample.java

[code lang=”java”]
package javabeat.net.core;

/**
* Java Initialization Example
*
* @author Krishna
*
*/
public class JavaInitializationExample {

//Static variable
static int j = 0;

//Instance variable
int i = 0;

//Instance Block
{
System.out.println("Instance Initializer Called");
i = 0; // instance variable can be initialized
j = 10; //Initialize static variable
instanceMethod();
}

//Static block
static{
System.out.println("Static Initializer Called");
testMethod();//Can invoke static method, not instance methods
}

//Constructor
public JavaInitializationExample(){
System.out.println("Constructor Called");
j = 20;
}
public static void main(String[] args) {
System.out.println("J Value Before Instance Initializer Called : "+j);
new JavaInitializationExample();
System.out.println("J Value After Instance Initializer Called : "+j);
}

//Static method
public static void testMethod(){
System.out.println("Static ‘testMethod()’ called");
}
//Static method
public static void instanceMethod(){
System.out.println("Instance ‘instanceMethod()’ called");
}

}
[/code]

Output…

[code]
Static Initializer Called
Static ‘testMethod()’ called
J Value Before Instance Initializer Called : 0
Instance Initializer Called
Instance ‘instanceMethod()’ called
Constructor Called
J Value After Instance Initializer Called : 20
[/code]

In my previous example I have explained how to use static initializer in Java.This example shows how to use the instance initializer block in Java. The following are the few features of instance blocks.

• Instance initializers are block of code with out any keyword keyword. The code which needs to be initialized will be put inside the braces {}. These are executed when the instance is created for the first time by any application.
• Static and instance variables can be initialized inside instance blocks.
• Any number of instance blocks can be defined, that will be executed in the order of definition. Instance initializer blocks will be executed after the static initializer blocks.
• Instance and static methods can be called from the instance initializers.
• Instance blocks are used for initializing the instance variables at the time of creating the instance of that class.

Lets look at the simple example snippet shows how to use the instance initializer.

JavaInstanceInitializerExample.java

[code lang=”java”]
package javabeat.net.core;

/**
* Java Instance Initializer Example
*
* @author Krishna
*
*/
public class JavaInstanceInitializerExample {

//Static variable
static int j = 0;

//Instance variable
int i = 0;

{
System.out.println("Instance Initializer Called");
i = 0; // instance variable can be initialized
j = 10; //Initialize static variable
instanceMethod();
}
static{
System.out.println("Static Initializer Called");
testMethod();//Can invoke static method, not instance methods
}

//Static method
public static void testMethod(){
System.out.println("Static ‘testMethod()’ called");
}
//Static method
public static void instanceMethod(){
System.out.println("Instance ‘instanceMethod()’ called");
}

public static void main(String[] args) {
System.out.println("J Value Before Instance Initializer Called : "+j);
new JavaInstanceInitializerExample();
System.out.println("J Value After Instance Initializer Called : "+j);
}
}

[/code]

Output…

If you look at the above code, the order of executing the blocks are clear. Also note that variable “j” is not initialized untill the instance initializer is invoked.

[code]
Static Initializer Called
Static ‘testMethod()’ called
J Value Before Instance Initializer Called : 0
Instance Initializer Called
Instance ‘instanceMethod()’ called
J Value After Instance Initializer Called : 10
[/code]

This example shows how to use the static initializer in Java. The following are the few features of static blocks.

1. Static initializers are block of code with static keyword. These are executed when the class is loaded or accessed first time by any application.
2. Only static variables can be initialized inside static blocks. Instance variables are not allowed inside static blocks.
3. Any number of static blocks can be defined, that will be executed in the order of definition.
4. Static methods can be called from the static initializers.
5. Static blocks are used for initializing the static or class level variables.

Lets look at the simple example snippet shows how to use the static initializer.

JavaStaticInitializerExample.java

[code lang=”java”]
package javabeat.net.core;

/**
* Java Static Initializer Example
*
* @author Krishna
*
*/
public class JavaStaticInitializerExample {

//Instance variable
int i = 0;

//Static variable
static int j =0;
static{
System.out.println("Static Initializer 1 Called");
//i = 0; – instance variable can not be initialized
j = 10; //Initialize static variable
testMethod();//Can invoke static method, not instance methods
}
static{
System.out.println("Static Initializer 2 Called");
}

//Static method
public static void testMethod(){
System.out.println("Static ‘testMethod()’ called");
}
public static void main(String[] args) {
System.out.println(j);
}
}
[/code]

Output…

[code]
Static Initializer 1 Called
Static ‘testMethod()’ called
Static Initializer 2 Called
10
[/code]