Uninitialized class members in Java do not issue any compiler errors. local variables however do. Why?

Question

Consider the following code snippet in Java. It won\'t compile.

package temppkg;

final public class Main
{
    private String x;
    private int y;

    pri         


        

Answer 1

In general the compiler couldn't know for sure if a class member has or has not been initialized before. For example, you could have a setter method that sets the value for a class member, and another method which accesses that member. The compiler can't issue a warning when accessing that variable because it can't know whether the setter has been called before or not.

I agree that in this case (the member is private and there is no single method that writes the variable) it seems it could raise a warning from the compiler. Well, in fact you are still not sure that the variable has not been initialized since it could have been accessed via reflexion.

Thins are much easier with local variables, since they can't be accessed from outside the method, nor even via reflexion (afaik, please correct me if wrong), so the compiler can be a bit more helpful and warn us of uninitialized variables.

I hope this answer helps you :)

Answer 2

Why would they issue a compile warning?, as instance variables String will get a default value of null, and int will get a default value of 0.

The compiler has no way to know that x.toString(), will cause a runtime exception, because the value of null is not actually set till after runtime.

Answer 3

Member variables are automatically initialized to their default values when you construct (instantiate) an object. That holds true even when you have manually initialized them, they will be initialized to default values first and then to the values you supplied.

This is a little little lengthy article but it explains it: Object initialization in Java

Whereas for the local variables (ones that are declared inside a method) are not initialized automatically, which means you have to do it manually, even if you want them to have their default values.

You can see what the default values are for variables with different data types here.

The default value for the reference type variables is null. That's why it's throwing NullPointerException on the following:

System.out.println(x.toString()); // Causes a NullPointerException but doesn't issue a compiler error.

In the following case, the compiler is smart enough to know that the variable is not initialized yet (because it's local and you haven't initialized it), that's why compilation issue:

System.out.println(z.toString()); // "Cuases a compile-time error - variable z might not have been initialized.

Answer 4

When in doubt, check the Java Language Specification (JLS).

In the introduction you'll find:

Chapter 16 describes the precise way in which the language ensures that local variables are definitely set before use. While all other variables are automatically initialized to a default value, the Java programming language does not automatically initialize local variables in order to avoid masking programming errors.

The first paragraph of chapter 16 states,

Each local variable and every blank final field must have a definitely assigned value when any access of its value occurs....A Java compiler must carry out a specific conservative flow analysis to make sure that, for every access of a local variable or blank final field f, f is definitely assigned before the access; otherwise a compile-time error must occur.

The default values themselves are in section 4.12.5. The section opens with:

Each class variable, instance variable, or array component is initialized with a default value when it is created.

...and then goes on to list all the default values.

The JLS is really not that hard to understand and I've found myself using it more and more to understand why Java does what it does...after all, it's the Java bible!

Answer 5

Class members could have been initialized elsewhere in your code, so the compiler can't see if they were initialized at compilation time.