with each iteration of the loop, it is actually redeclared each iteration, allowing the same token (i.e. obj) to be used to represent multiple variables. Final variables in nested objects Final variables can be used to construct trees of immutable objects. Once constructed, these objects are guaranteed not to change anymore. To achieve this, an immutable class must only have final fields, and these final fields may only have immutable types themselves. Java's primitive types are immutable, as are strings and several other classes. If the above construction is violated by having an object in the tree that is not immutable, the expectation does not hold that anything reachable via the final variable is constant. For example, the following code defines a coordinate system whose origin should always be at (0, 0). The origin is implemented using a java.awt.Point though, and this class defines its fields as public and modifiable. This means that even when reaching the origin object over an access path with only final variables, that object can still be modified, as the below example code demonstrates. import java.awt.Point; public class FinalDemo { static class CoordinateSystem { private final Point origin = new Point(0, 0); public Point getOrigin() { return origin; } } public static void main(String[] args) { CoordinateSystem coordinateSystem = new CoordinateSystem(); coordinateSystem.getOrigin().x = 15; assert coordinateSystem.getOrigin().getX() == 0; } } The reason for this is that declaring a variable final only means that this variable will point to the same object at any time. The object that the variable points to is not influenced by that final variable though. In the above example, the origin's x and y coordinates can be freely modified. To prevent this undesirable situation, a common requirement is that all fields of an immutable object must be final, and that the types of these fields must be immutable themselves. This disqualifies java.util.Date and java.awt.Point and several other classes from being used in such immutable objects. Final and inner classes When an anonymous inner class is defined within the body of a method, all variables declared final in the scope of that method are accessible from within the inner class. For scalar values, once it has been assigned, the value of the final variable cannot change. For object values, the reference cannot change. This allows the Java compiler to "capture" the value of the variable at run-time and store a copy as