It is fundamentally important to understand the issue of scope if you ever hope to write programs well. Where you declare things, and what keywords you use when you do so, have a huge effect on the visibility of your variables.
For instance, I often see issues that boil down to an attempt at doing this:
void multiplyTwoNumbers(int numberOne, int numberTwo) {
int numberThree = numberOne * numberTwo;
}
"It doesn't work" they say, or "it doesn't do anything". My friends, it does exactly what you told it to. It's just that you didn't tell it to do anything particularly useful. When this method is finished, it will have multiplied numberOne by numberTwo and assigned its value to numberThree. Then it's done.
Some folks go a bit further:
void callingMethod() {
int numberThree;
multiplyTwoNumbers(5,10);
System.out.println("See? It didn't work! " + numberThree);
}
And they're right, it didn't.
The reason is that the two variables named 'numberThree' are entirely independent of each other. One of them is really 'callingMethod->numberThree' and the other one is 'multiplyTwoNumbers->numberThree' and they have never met.
Naming things the same is meaningless. It might help us to understand our code better, but as far as Java is concerned the variables might as well be called Ben and Jerry. Mmmm, Ben and Jerry.
If you really want callingMethod->numberThree to take on the value you calculated in 'multiplyTwoNumbers' you need to explicitly lay it out. Just as you can't expect your sink to drain properly into the sewer system if you don't actually provide a continuous connection, you can't expect what one method does to just be known by another method.
So make sure you declare multiplyTwoNumbers as an int. Make sure you actually return the value of numberThree at when it's done:
int multiplyTwoNumbers(int numberOne, int numberTwo) {
int numberThree = numberOne * numberTwo;
return numberThree;
}
That will help. You've now installed the pop-up drain thingie in the bottom of the sink bowl. Let's finish the job:
void callingMethod() {
int numberThree;
numberThree = multiplyTwoNumbers(5,10);
System.out.println("It verks! " + numberThree);
}
This is so important to understand. Local variables go away as soon as the local block (code between { and }) comes to and end. If you don't provide a method for the value to escape the block, it's going to go to the big heap in the sky.
Perhaps part of the problem is that people get confused by the fact that they can do this:
public class Wizz {
int wizzLevel = 0;
public void bumpWizzLevel() {
wizzLevel = wizzLevel + 1;
}public void displayWizzLevel() {
System.out.println("Current level: " + wizzLevel);
}
}
Yes, that's perfect valid. In this case, 'wizzLevel' is an instance variable of the class Wizz. Every copy of Wizz you create has its own wizzLevel, and all methods within Wizz can reference or change it.
The key of course, is to look at the brackets. Note that 'int wizzLevel' is inside the brackets for the class as a whole, so it's in scope everywhere within the class.
The key takeaway is that when you want to understand where a variable is available to you, you need to understand that so long as you are still inside the same set of brackets where it was declared you should be good to go.
{
int outside;
{
int inside; //outside is still available
{
int wayInside; //inside and outside are still available
}
//wayInside is gone
}
//inside is gone
}
//outside is gone
