Will Java Final variables have default values?

http://docs.oracle.com/javase/tutorial/java/javaOO/initial.html, chapter "Initializing Instance Members":

The Java compiler copies initializer blocks into every constructor.

That is to say:

{
printX();
}


Test() {
System.out.println("const called");
}

behaves exactly like:

Test() {
printX();
System.out.println("const called");
}

As you can thus see, once an instance has been created, the final field has not been definitely assigned, while (from http://docs.oracle.com/javase/specs/jls/se7/html/jls-8.html#jls-8.3.1.2):

A blank final instance variable must be definitely assigned at the end of every constructor of the class in which it is declared; otherwise a compile-time error occurs.

While it does not seem to be stated explitely in the docs (at least I have not been able to find it), a final field must temporary take its default value before the end of the constructor, so that it has a predictable value if you read it before its assignment.

Default values: http://docs.oracle.com/javase/specs/jls/se7/html/jls-4.html#jls-4.12.5

On your second snippet, x is initialized on instance creation, so the compiler does not complain:

Test() {
printX();
x = 7;
printX();
System.out.println("const called");
}

Also note that the following approach doesn't work. Using default value of final variable is only allowed through a method.

Test() {
System.out.println("Here x is " + x); // Compile time error : variable 'x' might not be initialized
x = 7;
System.out.println("Here x is " + x);
System.out.println("const called");
}

As far as I'm aware, the compiler will always initialize class variables to default values (even final variables). For example, if you were to initialize an int to itself, the int would be set to its default of 0. See below:

class Test {
final int x;


{
printX();
x = this.x;
printX();
}


Test() {
System.out.println("const called");
}


void printX() {
System.out.println("Here x is " + x);
}


public static void main(String[] args) {
Test t = new Test();
}
}

The above would print the following:

Here x is 0
Here x is 0
const called

If you don't initialize x you'll get a compile-time error since x is never initialized.

Declaring x as final means that it can be initialized only in the constructor or in initializer-block (since this block will be copied by the compiler into every constructor).

The reason that you get 0 printed out before the variable is initialized is due to the behavior defined in the manual (see: "Default Values" section):

Default Values

It's not always necessary to assign a value when a field is declared. Fields that are declared but not initialized will be set to a reasonable default by the compiler. Generally speaking, this default will be zero or null, depending on the data type. Relying on such default values, however, is generally considered bad programming style.

The following chart summarizes the default values for the above data types.

Data Type   Default Value (for fields)
--------------------------------------
byte        0
short       0
int         0
long        0L
float       0.0f
double      0.0d
char        '\u0000'
String (or any object)      null
boolean     false

All non-final fields of a class initialize to a default value (0 for nummeric data types, false for boolean and null for reference types, sometimes called complex objects). These fields initialize before a constructor (or instance initialization block) executes independent of whether or not the fields was declared before or after the constructor.

Final fields of a class has no default value and must be explicitly initialized just once before a class constructor has finished his job.

Local variables on the inside of an execution block (for example, a method) has no default value. These fields must be explicitly initialized before their first use and it doesn't matter whether or not the local variable is marked as final.

JLS is saying that you must assign the default value to blank final instance variable in constructor (or in initialization block which is pretty the same). That is why you get the error in the first case. However it doesn't say that you can not access it in constructor before. Looks weird a little bit, but you can access it before assignment and see default value for int - 0.

UPD. As mentioned by @I4mpi, JLS defines the rule that each value should be definitely assigned before any access:

Each local variable (§14.4) and every blank final field (§4.12.4, §8.3.1.2) must have a definitely assigned value when any access of its value occurs.

However, it also has an interesting rule in regards to constructors and fields:

If C has at least one instance initializer or instance variable initializer then V is [un]assigned after an explicit or implicit superclass constructor invocation if V is [un]assigned after the rightmost instance initializer or instance variable initializer of C.

So in second case the value x is definitely assigned at the beginning of the constructor, because it contains the assignment at the end of it.

Let me put it in the simplest words I can.

final variables need to be initialized, this is mandated by the Language Specification. Having said that, please note that it is not necessary to initialize it at the time of declaration.

It is required to initialize that before the object is initialized.

We can use initializer blocks to initialize the final variables. Now, initializer blocks are of two types static and non-static

The block you used is a non-static initializer block. So, when you create an object, Runtime will invoke constructor and which in turn will invoke the constructor of the parent class.

After that, it will invoke all the initializers (in your case the non-static initializer).

In your question, case 1: Even after the completion of initializer block the final variable remains un-initialized, which is an error compiler will detect.

In case 2: The initializer will initialize the final variable, hence the compiler knows that before the object is initialized, the final is already initialized. Hence, it will not complain.

Now the question is, why does x takes a zero. The reason here is that compiler already knows that there is no error and so upon invocation of init method all the finals will be initialized to defaults, and a flag set that they can change upon actual assignment statement similar to x=7. See the init invocation below:

The first error is the compiler complaining that you have a final field, but no code to initialize it - simple enough.

In the second example, you have code to assign it a value, but the sequence of execution means you reference the field both before and after assigning it.

The pre-assigned value of any field is the default value.

If I try to execute it, i am getting compiler error as : variable x might not have been initialized based on java default values i should get the below output right??

"Here x is 0".

No. You are not seeing that output because you are getting a compile-time error in the first place. Final variables do get a default value, but the Java Language Specification (JLS) requires you to initialize them by the end of the constructor (LE: I'm including initialization blocks here), otherwise you'll get a compile-time error which will prevent your code to be compiled and executed.

Your second example respects the requirement, that's why (1) your code compiles and (2) you get the expected behaviour.

In the future try to familiarize yourself with the JLS. There's no better source of information about the Java language.