This is addressed explicitly in the specification, and they are automatically final: Members of final classes or objects are implicitly also final, so the final modifier is generally redundant for them, too. Note, however, that constant value definitions (§4.1) do require an explicit final modifier, even if they are defined in a final class or … Read more
You can change the declaration of your mixin to: mixin Salt { int get pitches; } And then define the field inside the implementation class class Meat with Salt { final int pitches; Meat(this.pitches); }
They will be exactly the same. The literal is interned (any compile time constant expression that results in that string shares the same instance as all other constants/literals) in both cases and a smart compiler+runtime should have no trouble reducing both to the most optimized example. The advantage comes more in maintainability. If you want … Read more
No, the final keyword does not make the list, or its contents immutable. If you want an immutable List, you should use: List<Synapse> unmodifiableList = Collections.unmodifiableList(synapses); What the final keyword does is prevent you from assigning a new value to the ‘synapses’ variable. I.e., you cannot write: final List<Synapse> synapses = createList(); synapses = createNewList(); … Read more
Firstly, the part about variables being “overridden” – final has two very different meanings. For classes and methods, it’s about inheritance; for variables it’s about being read-only. There’s one important “feature” of final local variables: they can be used in local (typically anonymous) inner classes. Non-final local variables can’t be. That’s the primary use of … Read more
I’ve put some thoughts on how to implement the things you requested and came to a totally different conclusion. The problem at hand is very interesting: How do I check whether a class implements a hidden interface. Unfortunately the problem is a contradiction to the liskov substitution principle; one of the core object oriented principles. … Read more
The point is that method-local variables from the enclosing type are actually copied to instances of anonymous classes (this is because of activation frame issues, but I won’t go further into detail as this is not really relevant to the question), which is why they need to be final, because the variable in the nested … Read more
Yes, they are initialized in the order in which they appear in the source. You can read all of the gory details in The Java Language Specification, §12.4.2. See step 9, which reads: … execute either the class variable initializers and static initializers of the class, or the field initializers of the interface, in textual … Read more
The JLS has predefined rules for assignment conversion. If the expression is a constant expression (§15.28) of type byte, short, char, or int: A narrowing primitive conversion may be used if the type of the variable is byte, short, or char, and the value of the constant expression is representable in the type of the … Read more
I use Checkstyle with Eclipse, which results in a warning if the declaration is in a different order to the one you’ve specified, citing the Java Language Specification (JLS). For example, private final static String filename = “filename.txt”; results in ‘static’ modifier out of order with the JLS suggestions. They have this page which lists … Read more