Why does the local variable of an enhanced for loop have to be local? [duplicate]

Answer 1

Maybe because in this way, it guarantees that state will be empty and has no initial value assigned to it.

Answer 2

A lot of decisions in Java are more based on the concept of why "Wouldn't" you remove x. Why on earth allow your code to be confused by moving the scope outside the loop? If you really needed access to the last element afterwards there are cleaner ways.

I suppose some may argue one way or another as to protecting programmers from themselves, I look at it more as Java protects me from people who like to take advantage of things like this.

It's not really a great hobby language, it is a great team development language where the point is to make it as easy as possible for the next guy to understand your code.

For instance, I saw in a comment above that many people break out of a for loop at a certain point with a value. How clear is that when you are scanning through code trying to find a bug? It's people using neat tricks like this that I really want to be protected from, not myself.

If you wish to execute some code mid-loop, put it in a method and call it from within the loop.

The lack of cute tricks often makes me re-think my code and work a little harder--but the results are always more readable/maintainable.

If you are just a single programmer (Not on a team) I'd advise against Java, It doesn't do neat tricks and you won't see cool yearly feature updates--and it is fairly slow to program in (It moves a lot of time catching and fixing bugs into time spent coding, frustrating people with it's strict rules (One of the biggest advantages of the language IMO)

If you want something javaish try Scala instead. If you are "Forced" to learn it because of a classroom decision then you might want to attempt to appreciate it from the "team" point of view and with the mindset that you won't be forced to use it in the future.

Answer 3

They might have wanted to remove a possible difference in semantics between the simple for and the enhanced for.

If you had, say, a regular for loop:

int i;
for (i=0; i<4; i++)
    ;

then if you let the loop execute normally, you get that i==4 after the loop, which is not valid for the iteration variable.

What then, if you could have:

int i;
for (i : myArray)
    ;

I suppose from an implementation standpoint, it would be easiest if at the end i were equal to the last element in the array. But should it behave like that or should there be some invalid value, and if so, what could that be? What if you break out of the last iteration?

Another possibility is that it makes it more clear what that loop is about and what the element type of the collection is. By contrast, the simple for is a "legacy" construct in some sense, so they couldn't have applied a similar logic without "breaking" it or limiting its flexibility.

I'm obviously speculating, and it could turn out to have just been a random design choice.

Answer 4

One benefit/rationale is local variables dont pollute your code. Let me give a normal loop example (this is just for analogy not an exact one, so no iterator use):

int i;
for(i=0;i<10;i++)
  do...something

int j;
for(j=0; i<10; j++)
  do...something

Now in the above code if look closely you will find a potential bug. i has been mistakenly used in loop which iterates over j.

So enhanced loops try to play safe by creating the variables locally, by which you can avoid above problem.

Answer 5

Look at how the for-each loop internally works, see How does the Java 'for each' loop work?

for(Iterator<String> i = someList.iterator(); i.hasNext(); ) {
String item = i.next();
System.out.println(item);
}

Each time it declares the String variable item. Hence in your case its doing essentially

State state;
\\and inside
State state = i.next();

which obviously wont work. Now inside the implementation, they it could rather only do

item = i.next();

but then you always have to define that item outside for-each, which would be pain majority of time.