Is there any difference between nested assignment and normal assignment?

I have a code

final int a, b;
a = b = 10;

while (a <= b) {
	System.out.println("this is in while loop");
}
System.out.println("this is out of while loop");

in this case my while block is executing infinite times.

In have another code

final int a=10;
final int b = 10;

while (a <= b) {
	System.out.println("this is in while loop");
}
System.out.println("this is out of while loop");

in this case i am getting compilation error mentioning unreachable code for the statement outside while loop

even though they are final variables.I tried to reassign the values for variables a and b respectively in both cases,But i could not re -assign the values in both cases as it is final variable.
but in the first case i mentioned they are not considering as constants that is the reason loop is repeating.

While in both cases the variables are final, the variables in the second case are also constant variables:

> A constant variable is a final variable of primitive type or type String that is initialized with a constant expression (§15.29). Whether a variable is a constant variable or not may have implications with respect to [...] reachability (§14.22) [...].

The variables in the first case are not constant variables, because they are not initialised. They are assigned in the next statement. Note that final variables don't have to be initialised = they just need to be definitely assigned.

This makes a <= b in the second code a constant expression, with the constant value true. And this affects whether a statement is reachable. See the relevant quotes in this section.

> It is a compile-time error if a statement cannot be executed because
> it is unreachable.
>
> The first statement in a non-empty block that is not a switch block is reachable iff the block is reachable.
>
> Every other statement S in a non-empty block that is not a switch
> block is reachable iff the statement preceding S can complete
> normally.
>
> - A while statement can complete normally iff at least one of the following is true:
>
> - The while statement is reachable and the condition expression is not a constant expression (§15.29) with value true.
>
> - There is a reachable break statement that exits the while statement.

In this case, since the while statement does have a constant true condition, and there is no breaks, the while statement cannot complete normally. This causes the statement after the while loop to be unreachable.

I explain this phenomenon in an unprofessional way, the test class is as follows:

package com;                                                                                                       
                                                                                                                   
public class Assignment {                                                                                          
    public static void main(String[] args) { }                                                                           
    public int m1() {                                                           
        final int a, b;                                                         
        a = b = 10;                                                             
        return a + b;                                                                                              
    }                                                                           
    public int m2() {                                                           
        int a, b;                                                               
        a = b = 10;                                                             
        return a + b;                                                                                              
    }                                                                                                              
    public int m3() {                                                           
        final int a = 10;                                                                                          
        final int b = 10;                                                       
        return a + b;                                                           
    }                                                                           
}

After compiling with javac, the result of decompiling with javap is as follows：

Compiled from "Assignment.java"
public class com.Assignment {
  public com.Assignment();
    Code:
       0: aload_0
       1: invokespecial #1                  // Method java/lang/Object."<init>":()V
       4: return

  public static void main(java.lang.String[]);
    Code:
       0: return

  public int m1();
    Code:
       0: bipush        10
       2: dup
       3: istore_2
       4: istore_1
       5: iload_1
       6: iload_2
       7: iadd
       8: ireturn

  public int m2();
    Code:
       0: bipush        10
       2: dup
       3: istore_2
       4: istore_1
       5: iload_1
       6: iload_2
       7: iadd
       8: ireturn

  public int m3();
    Code:
       0: bipush        20
       2: ireturn
}

Pay attention to m3, the value of return is directly replaced with 20！

Both m1 and m2 are calculated, that is, the specific values ​​are not known until the running phase.

So...., the next conclusion can be drawn，The value in m3 can actually be determined during the compilation phase. If you put it in while as a condition, then you can know the result during the compilation phase.