final

It says in this article that: Making a class final because it is immutable is a good reason to do so. I'm a bit puzzled by this... I understand that immutability is a good thing from the POV of thread-safety and simplicity, but it seems that these concerns are somewhat orthogonal to extensibility. So, why is immutability a good reason for making a class final? The explanation for this is given in the book 'Effective Java' Consider BigDecimal and BigInteger classes in Java . It was not widely understood that immutable classes had to be effectively final when BigInteger and BigDecimal were

class Foo{ public static void main(String args[]){ final int x=101; int y; if(x>100){ y=-1; } System.out.println(y); } } Java compiler understands the condition of the if statement is always true and therefore y will always be initialized. No compile error, as expected. class Bar{ public static void main(String args[]){ final int x; x=101; int y; if(x>100){ y=-1; } System.out.println(y); } } But when I break the declaration and initialization of x into two lines, the compiler does not seem to get that the condition is always true and y will always be initialized. final int x; x=101; byte b; b

Which advantages/disadvantages we can get by making ArrayList (or other Collection) final? I still can add to ArrayList new elements, remove elements and update it. But what is effect making it's final? But what is effect making it's final? This means that you cannot rebind the variable to point to a different collection instance : final List<Integer> list = new ArrayList<Integer>(); list = new ArrayList<Integer>(); // Since `list' is final, this won't compile As a matter of style, I declare most references that I don't intend to change as final . I still can add to ArrayList new elements,

Could anyone please tell me what is the meaning of the following line in context of Java: final variable can still be manipulated unless it's immutable As far as I know, by declaring any variable as final, you can't change it again, then what they mean with the word immutable in above line? It means that if your final variable is a reference type (i.e. not a primitive like int), then it's only the reference that cannot be changed. It cannot be made to refer to a different object, but the fields of the object it refers to can still be changed, if the class allows it. For example: final

I used to think that private val and private final val are same, until I saw section 4.1 in Scala Reference: A constant value definition is of the form final val x = e where e is a constant expression (§6.24). The final modifier must be present and no type annotation may be given. References to the constant value x are themselves treated as constant expressions; in the generated code they are replaced by the definition’s right-hand side e. And I have written a test: class PrivateVal { private val privateVal = 0 def testPrivateVal = privateVal private final val privateFinalVal = 1 def