public class Ex
{
int a;
public Ex()
{
System.out.println("a is "+a);
}
}
output is:a is 0
where a gets initialized...
i know that default values for int is zero..my question is that where it gets initialied ..through default constructor ?(i heard that default constructor is created when we don't mention any constructor in the class)
If you didn't initalize a yourself (it's a primitive value), it gets initialized automatically to it's default value, 0 in this case.
Read section 4.5.5. (Initial Values of Variables) in this document.
No, there is no default constructor when you write a specific on. But fields get initialized before any constructor is called. After initialization of fields initializers ({.. some code .. } blocks)are run and finally the constructor is executed.
super(...) line, then initializers are executed after that line.
null for object references.Its default value is 0.
From The Java™ Tutorials - Primitive Data Types - 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.
╔══════════════════════════╦════════════════════════════╗ ║ 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 ║ ╚══════════════════════════╩════════════════════════════╝
The reason why a has an initial value is written in the Java language specification (4.12.5):
Each class variable, instance variable, or array component is initialized with a default value when it is created
a is an instance variable (a non static field) and so it has an initial value. The value itself is specified too:
For type int, the default value is zero, that is, 0.
It may be interesting to know that this is different for local variables (variables declared in a method body):
A local variable must be explicitly given a value before it is used, by either initialization or assignment, in a way that can be verified by the compiler using the rules for definite assignment.
So if you read a local variable that has not been initialized or "set" in your code yet, the compiler will give an error.
Definitely not in the default constructor. According to the JLS, it happens as a part of evaluation of a class instance creation expression (when you do new ClassName...), before any constructor call. From the JLS, Java SE 8 Edition, 15.9.4:
Next, space is allocated for the new class instance. If there is insufficient space to allocate the object, evaluation of the class instance creation expression completes abruptly by throwing an OutOfMemoryError.
The new object contains new instances of all the fields declared in the specified class type and all its superclasses. As each new field instance is created, it is initialized to its default value (§4.12.5).
Next, the actual arguments to the constructor are evaluated, left-to-right. If any of the argument evaluations completes abruptly, any argument expressions to its right are not evaluated, and the class instance creation expression completes abruptly for the same reason.
Next, the selected constructor of the specified class type is invoked. This results in invoking at least one constructor for each superclass of the class type. This process can be directed by explicit constructor invocation statements (§8.8) and is specified in detail in §12.5.
a isn't being initialized so it's giving a zero value because the default value of an int is 0.
a has a primitive type int. In your code, a is uninitialized with a default value of 0.
To clear your head, if you had not declared a zero-argument constructor and your class had no constructor(s), java creates a default zero-argument constructor for you.
As for your primitive types, once declared, its initialized (if uninitialized) with default values before use.
In java instance variables will be initialised from the constructor ( default if you don't have one).
public class TestFile {
String x = null;
int y = x.length();
public TestFile() {
// TODO Auto-generated constructor stub
}
/**
* @param args
*/
public static void main(String[] args) {
TestFile tf = new TestFile();
}
}
you will get a stacktrace
Exception in thread "main" java.lang.NullPointerException
at TestFile.<init>(TestFile.java:7)
at TestFile.main(TestFile.java:16)
is called within the constructor.
For static fields, initialisation during class loading
primitives are initialized before constructor is called
it occurs when Java allocates memory for a class. It fils all fields with default values;
§ JLS - 8.8.9 Default Constructor
In your code you have supplied constructor if you haven't then .
If a class contains no constructor declarations, then a default constructor that takes no parameters is automatically provided: If the class being declared is the primordial class Object, then the default constructor has an empty body. Otherwise, the default constructor takes no parameters and simply invokes the superclass constructor with no arguments
