FINAL VARIABLE

[Karu Raj]

Cosidering the following -

byte a = 10 ;
final int x = 10 ;

Which of the following assigments are valid ?

a)byte y = x ;
b)char ch = a ;
c)char c = x ;
d)short j = a = x ;

here the answer is a,c,d

when the x is declared as final then how can you assign the value of x to y ,c,j

[marc weber]

Originally posted by Karthik Rajashekaran:
...when the x is declared as final then how can you assign the value of x to y, c, j

You can't assign a new value to x because it's final. But y, c, and j are not final, so you can assign them any valid value.

[Karu Raj]

ok thanks

[Layne Lund]

I think there is a little more to it than that. What about

final long l = 10;
int x = l;

Although, 10 is within the range of an int, this should throw a compiler error.

The difference between this and the example given by Karthik is that byte has some special rules. That is an implicit narrowing conversion takes place when assigning an int to a byte if the value is within the range that is allowed for a byte. I guess a similar rule applies for char, although I am unfamiliar with it.

Layne

[shan Iyer]

If implicit casting occurrs for answers a.),c.),d.), then answer b.) also should be correct .

rgrds,
Shankar

[Andreas Sandberg]

Actually, 'char ch = a' fails at compile time with 1.4 and the compile complains that there is a possible loss of precision.

 int x = 10;
    short y = 1;
    byte z = 1;
    
    char a = x;  //1
    char b = y;  //2
    char c = z; //3 
    char d = 10; //4
    char e = 1;  //5

Here lines 1,2,3 all fail at compile time as well, yet lines 4 and 5 are ok. Since characters are unsigned 16 bit primatives, it appears that initializing them with numbers that fits in the range is ok but when when referencing a char to any other primative a cast is needed. Perhaps this is because all other primatives are signed (except boolean). Could those out there please enlighten us (me). Thanks!

cheers, Andreas

[saran sadaiyappan]

what is the reason for this strange behaviour as pointed?I mean downcasting is not allowed in Java without explicit casting.But how come its working here?

[marc weber]

A literal int value or a final int variable can be assigned to a narrower primitive type (byte, short, or char) without explicit cast if it falls within range. However, a non-final int variable requires an explict cast or a compiler error will result.

Despite being "narrower," a non-final byte or short is not convertible to a char without an explicit cast. (Consider that a byte or short could be negative, but a char cannot.)

class PrimTest {
  public static void main(String[] args) {
    //literal ints okay if within range...
    byte b1 = 10;
    short s1 = 10;
    char c1 = 10;
 
    //final int variables okay if within range...
    final int i2 = 15;
    byte b2 = i2;
    short s2 = i2;
    char c2 = i2;
 
    //but non-final int variables require cast...
    int i3 = 20;
    //byte b3 = i3; //possible loss of precision
    //short s3 = i3; //possible loss of precision
    //char c3 = i3; //possible loss of precision
    byte b4 = (byte)i3;
    short s4 = (short)i3;
    char c4 = (char)i3;
 
    //final byte or short okay for char if within range...
    final byte b5 = 25;
    final short s5 = 30;
    char c5 = b5;
    char c6 = s5;
 
    //but non-final byte or short requires cast...
    byte b6 = 30;
    short s6 = 35;
    //char c7 = b6; //possible loss of precision
    //char c8 = s6; //possible loss of precision
    char c9 = (char)b6;
    char c10 = (char)s6;
  }
}

[ September 21, 2005: Message edited by: marc weber ]

[Andreas Sandberg]

Thank you for explaining that so clearly. I'm curious as to what the thought is behind not forcing the cast for 'final int'. From testing this out a bit it does appear however that:

 
final int x = 10;
byte b = x; //ok
 
final int y = 2000000; //greater than (2^7 - 1)
byte c = y; //Not ok, now we get a possible loss of precision and cast is req.
 

What's the thought process behind this? Thanks!

Andreas
[ September 21, 2005: Message edited by: Andreas Sandberg ]

[Karu Raj]

Wow great explaination

thanks a lot

[sarang bharambe]

I found some strang thing ...

If i remove final keyword in the original code posted by Karthik as:

byte a = 10 ;
int x = 10 ;

byte y = x ;//1
char ch = a ;//2
char c = x ;//3
short j = a=x ;//4

then compiler giver error as:
possible loss of precision at 1,2,3,4.

so why is this different behaviour with and without final keyword?



also

an implicit narrowing conversion takes place when assigning an int to a byte if the value is within the range that is allowed for a byte.

In this case also the behaviour is different with and without final keyword

Can anyone explain this???

[marc weber]

It's actually a little more complicated than I explained above, because I left out an important detail: In order to be implicitly cast to a narrower type, the value of the final variable must be known at compile time. It can then be treated essentially as a literal.

In the code below, there are 2 final int variables. The value of one is known at compile time, but the other value is not known until runtime. The one with a compile-time value can be assigned without explicit cast to a byte (if within range), but the one that does not have a known compile-time value cannot.

class FinalValues {
  static final int i1 = 10;
  static final int i2 = (int)(Math.random() * 100);
 
  public static void main(String[] args) {
    System.out.println("i1 is " + i1);
    System.out.println("i2 is " + i2);
    byte b1 = i1;
    //byte b2 = i2; //possible loss of precision
  }
}

[Lalitha Joshi]

Thank you so much for that explaination about the "final" variable and "narrowing" process. Even I had got stuck with this and was not able to understand the thought process of the compiler.