8

so I've tried to search for answer, but for this error message I'm founding irelevant answers to my problem.

Here it is. Why this code:

Case 1)

public class A { private final String A; private final String B; private final String C = A + B; public A(String A, String B) { this.A = A; this.B = B; } }

for line private final String C = A + B; it says these errors:

java: variable A might not have been initialized java: variable B might not have been initialized

But this works like a charm:

Case2)

public class K { private final String K; private final String L; private final String M = kPlusL(); public K(final String K, final String L) { this.K = K; this.L = L; } private String kPlusL() { return K + L; } }

Or also this works like a charm:

Case 3)

public class O { protected final String O; protected final String P; public O(final String O, final String P) { this.O = O; this.P = P; } } public class Q extends O { private final String Q = O + P; Q (final String O, final String P) { super(O, P); } }

Can somebody explain me why please? I'm using IntelliJ IDEA and Java 1.8.0_151.

All three cases are doing exact same thing (puts two Strings together), but one is doing it directly and second and third "indirectly".

Improve this question
9
  • 6
    believe it or not, the IDE you use has zero impact on any of this Commented Jan 18, 2018 at 7:36
  • I doubt it works like a charm. The result in Q and M will not be as you expected. Commented Jan 18, 2018 at 7:40
  • 2
    Hint: consider when the field initializers run vs when the body of your constructor runs. Commented Jan 18, 2018 at 7:40
  • The three cases are not comparable. In case 1, you access uninitialized fields while initializing the object. In case 2, you access the fields in a method (therefore, after the object has been created). In case 3, you access the fields in the subclass, i.e. after an instance of the super class has been created. Commented Jan 18, 2018 at 7:41
  • CoronA - won't be as I expected? But I'll access Q or M only after they have been initialized. Never before. So it will join two Strings together - as expected - or not? Commented Jan 18, 2018 at 7:53

6 Answers 6

Reset to default
4

When you try to initialize C in your first case, A and B are still uninitialized at this point, so private final String C = A + B; will fail.

Try initializing C inside of your constructor:

public class A { private final String A; private final String B; private final String C; public A(String A, String B) { this.A = A; this.B = B; this.C = A + B; } }

Here's the relevant bit from the JLS

For every access of a local variable or blank final field x, x must be definitely assigned before the access, or a compile-time error occurs.

Improve this answer
Sign up to request clarification or add additional context in comments.

2 Comments

The question wasn't how to fix it, but why does the compiler disallow the first way but allow the second and third way. This is the kind of question where you answer with a quote from the JLS to show why the compiler does this (or make a bug report out of it).
@QBrute indeed, this does not answer the question (may be just only very partially)... stackoverflow.com/a/48322068/1059372
2

In case 2 you are setting value of M using kPlusL() which will cast the null into string during concatenation. Hence it will have value as "nullnull".

In case 3 you are inheriting a class so super class constructor will be invoked before child class instantiation. Hence it will have the values for O and P to be assigned in Q.

Improve this answer

3 Comments

Have you tried out the code? In case 2, M gets initialized with "nullnull" (because it's call to kPlusL is invoked before the class is properly initialized).
You are right daniu. It will return "nullnull" due to string contcatenation
daniu - I've just tried and it return indeed "nullnull". If I remove in case 1) the "final" from A and B variables, I'm also getting "nullnull". Thanks!
1

Apart from the first case which the compiler complains to, the other two cases are easily explained by the java object initialization detail.

I suggest you read this article, you will find all of your answers.

https://www.javaworld.com/article/2076614/core-java/object-initialization-in-java.html?page=2

Improve this answer

4 Comments

Can you explain why the "getting around the forward reference rule" mechanism (ie case 2) works?
"getting around the forward reference rule" just states that compiler is unable (or don't want) to detect such cases. I think it so because such data flow analysis isn't so simple or maybe sometimes you desire a such behavior
I don't know... I'd expect it to be reasonable to just disallow any call to an instance method for an initialisation.
@daniu I'll agree, it does not make sense for final fields at all. It might make some sense for non-final ones, but allowing this for final fields is stupid
1

The JLS parts are relevant indeed (since you already got them, not going to link that again), the byte code is a little bit more interesting.

For the first example (slightly modified):

private String A; private String B; private final String C = A + B; public FirstExample(String A, String B) { this.A = A; this.B = B; } System.out.println(new FirstExample("a", "b").C);

This will print nullnull and it makes sense if you look at the generated byte code (only the relevant parts). This btw is correct according to JLS, as instance fields are initialized before the rest of the constructor body.

getfield // Field A:Ljava/lang/String; getfield // Field B:Ljava/lang/String; // this is just concat the two Strings with java-9 invokedynamic // InvokeDynamic #0:makeConcatWithConstants .... putfield // Field C:Ljava/lang/String; putfield // Field A:Ljava/lang/String; putfield // Field B:Ljava/lang/String;

The point to get is that instance variables are initialized before the rest of the constructor (basically C before A and B). It makes sense now why adding final to A and B would not compile.

The second example is a bit more interesting. These are called Forward references and are allowed by the spec (actually it is correct to say they are not disallowed) For example, this:

String x = y; String y = "a";

is not allowed, but this on the other hand is:

String x = getIt(); String y = "a"; public String getIt() { return y; }

The downside is that y will be initialized with null and not a first time; thus x is going to be null.

The last example is yet again in conformation with JLS. The super constructor runs first, thus initializing those fields; only after that the Q variable is initialized via the inherited (already with values from constructor) fields, thus producing the expected value.

Improve this answer

Comments

0

As the first two cases are pretty much clear and answered, I would like to focus on the third case where you have inheritance. According to the initialization sequence is specified in JLS:

Just before a reference to the newly created object is returned as the result, the indicated constructor is processed to initialize the new object using the following procedure:

  1. Assign the arguments for the constructor to newly created parameter variables for this constructor invocation.

  2. If this constructor begins with an explicit constructor invocation (§8.8.7.1) of another constructor in the same class (using this), then evaluate the arguments and process that constructor invocation recursively using these same five steps. If that constructor invocation completes abruptly, then this procedure completes abruptly for the same reason; otherwise, continue with step 5.

  3. This constructor does not begin with an explicit constructor invocation of another constructor in the same class (using this). If this constructor is for a class other than Object, then this constructor will begin with an explicit or implicit invocation of a superclass constructor (using super). Evaluate the arguments and process that superclass constructor invocation recursively using these same five steps. If that constructor invocation completes abruptly, then this procedure completes abruptly for the same reason. Otherwise, continue with step 4.

  4. Execute the instance initializers and instance variable initializers for this class, assigning the values of instance variable initializers to the corresponding instance variables, in the left-to-right order in which they appear textually in the source code for the class. If execution of any of these initializers results in an exception, then no further initializers are processed and this procedure completes abruptly with that same exception. Otherwise, continue with step 5.
  5. Execute the rest of the body of this constructor. If that execution completes abruptly, then this procedure completes abruptly for the same reason. Otherwise, this procedure completes normally.

Example 12.5-1. Evaluation of Instance Creation given in the link clearly explains the initialization order.

So, as per your third example(look at points 3 and 4), the execution order would be:

  1. Instance variable initializers in class O (since you did not specify any intializers, they will be initialized to null)
  2. Class O constructor -- public O(final String O, final String P) which assigns O and P with the given values
  3. Instance variable initializers in class Q -- private final String Q = O + P; which contatenates O and P and assigns the result to Q
  4. Class Q constructor -- public Q(final String O, final String P) ends So, by the completion of class Q constructor, the object has been initialized properly.
Improve this answer

3 Comments

I still find case 3 much more clear-cut than case 2. Why is it allowed for an initializer to refer to an instance method if it can't be guaranteed that it works properly? You can't call those inside of a super call in a constructor either.
docs.oracle.com/javase/tutorial/java/javaOO/initial.html Please have a look at this, only final methods can be used in instance variable initializers, this is especially useful if subclasses might want to reuse the initialization method. Hope this clarifies your concern It's a better practice not to use other non-initialized instance variables in these methods since they may cause in inconsistent state.
@daniu you are right, the actual formatting of this should be this is not disallowed by the forward references rule... stackoverflow.com/a/48322068/1059372
0

Because First, it Defines A and B, and Defines and Initialize C with the value of A and B, And then goes to the constructor and initialize A and B. So as you can see there are no values for A and B Until the calling of the constructor. Look at the code below:

public class A { private final String A; // = Null private final String B; // = Null private final String C = A + B; // Error Cause There is no value for A and B public A(String A, String B) { this.A = A; this.B = B; } }

Just Place C = A + B inside the constructor.

Improve this answer

Comments

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.