In a previous episode,
we have discussed control structures; they are
Java instructions making it possible for data to influence,
choose or repeat, different parts of the program.
We have seen that these control
structures are closely related to the block notion.
This block notion will impact
the use of variables. We call this
the "scope of variables",
and this will be the subject of this episode.
In Java, instructions can be regrouped
in blocks, and this intependently of any control structure.
To this end, one simply needs to regroup
the instructions in braces.
For example, here, we have a block, starting with
an opening brace and ending with a closing brace. Inside, we have declared a Scanner-type
variable keyb, an int-type variable i and a double-type variable x. We can use
them, for example, to read the value of i, the value of x
or to print the value of x, the value of i.
These variables belong to the block where they have been declared.
You can see that, in Java, blocks have great
autonomy, meaning that they can contain their own variables.
Now to a simpler example: we have a block controlled by an "if" instruction.
The block thus begins here and ends
with the closing brace here. In this block, we
declare an int-type variable j, which we
can then use inside this block.
Once we have exited the block,
starting from this point,
we cannot use the variable j anymore, since it belonged to the block.
Variables declared in a block, like this, are only accessible
within this block, we say that they
are variables local to this block.
We can also declare variables outside any block, inside the class
we are currently working with.
We call those, variables
global to the class.
In the object-oriented programming course
we will differentiate "instance variables" from
"class variables". However, this would now take us a little too far.
One advice we can give you is to declare
your variables the closest possible to their utilization.
What does it mean? Let us take an example.
Let us reuse the previous example with the block here controlled
by an "if" instruction. Inside it, we use the variable j and we
suppose that we have no use for the variable j after this block.
In this case, we will write
the declaration the closest from its utilization,
namely just when we need it,
just before the first line where we will use the variable j.
In this same situation where we need here
a variable j, which is not used anymore after the block
controlled by the "if" instruction,
if we declared this variable here, before the block,
it would be valid. However, it would not have been
in accordance with the principle of declaring variables the closest to their utilization.
Since this variable j, would have been declared outside the block, it could
still be used later. The idea is to declare it as close as possible to the place where we use it.
This notion of a place where we use a variable
or rather of a place where we can use the variable,
is what we called the "scope".
The scope of a variable is all the lines of code
where this variable accessible, where it can be used.
Let us take an example. We have here a first "if" instruction,
controlling its own block of instructions.
Then, we have a second "if" instruction
controlling its block of instructions aswell.
In the higher level block, we will declare a variable j.
In the deeper block, we will declare a variable k, which we will use.
The scope of k, that is, all the lines where k
is defined will be the block of the second
"if" instruction.
In the meantime, the scope of j, that is all the lines of code
where j is defined, usable, is this block here, where j has been defined.
Here, you can see that j and k
have different scopes, indicated by these two blocks.
A question we could ask is,
what would happen if we had declared a variable
j inside this block?
In Java, such a thing is not allowed; it is not valid
to have two variables with the same name in the same scope.
For example, if we had declared, in the second
block, a variable j. we would encounter
a compiler error informing us that
it is forbidden, that there is name ambuiguity.
Therefore,
in Java, it is forbidden.
You cannot have, in the same scope.
two different objects with the same name.
However, it is possible in other programming languages.
A particular scope case, which you should definitely be familiar with,
is the scope of variables in iterative loops, "for" loops.
Let us take an example. We have here a "for" loop,
declaring an int-type variable i. This variable can of course be
used inside the block. the scope of i will indeed
be the block controlled by the "for" instruction, including the
condition and the increment statement. However, this variable i
will be local to the "for" loop, to the iterative loop.
After the end of the block controlled by
the "for" instruction, we won't be allowed to use
this variablle; it is local to the "for" iteration.
