Actually, all variables are labels to some memory address.
And the values stored from there can occupy many extra adjacent memory addresses!
It all depends on their data-types.

Now, this definition of static I don't think is exactly what Java features!
In Java there are 2 main scopes for variables -> field (also called member) and local.

• Field  -> it is a variable bound to a class. They are declared outside methods/functions.
• Local -> it is bound to a method and other inner scopes.

However, Java's field variables can be declared as static.
It means they are created once and aren't instantiated. Only 1 permanent copy exists.
And their stored values are shared throughout all of the instances of the class they belong to!
And even more, static field variables can be accessed directly from their class,
w/o instantiating it 1st!!!  

In short, C-style static local variables don't exist in Java. Their meaning are different!  
Hope I haven't got you too confused! Peace!!!  

//****
Local variables are, by definition, isolated to their own scopes.
And they are destroyed, along w/ their content, once execution exits them.
So they are always internally non-static by nature.
//****

So if I want to have a local variable, but need that variable to be available later on, I can declare a global variable, is there any other way ?

and thanks for the above explanation, looking into field variables right now :-)

Well, global variable is not a Java term, but Processing's!
Actually, once a Processing code passes through Processing's pre-processor,
we can verify in the rendered .java file, that those "global" variables are, in reality, Java's field variables!

Processing has lots of its own terms and syntax sugar for many Java's original & raw methods!

Now, just to clarify something I haven't expressed well enough in my previous post:

• Java's local variables always forget their content after scope ends.
• Java's field variables always remember their contents.

Brilliant
THANKS for explaining

Side note: static variables in Processing are rarely, if ever, used, because all classes defined in a .pde file are nested classes (nested in the sketch's main class, hidden in normal cases).
If you want to have a real static variable (rarely needed, in practice), you have to put the class in a .java file.
Or to declare the class as static too.

Although I mostly declare my "constants" w/ final static, as sketch's "global" fields.
If it happens to some to be intrinsic bound to an object, let's say -> final static ellipseCollor = #0000FF;
sometimes I relocate them inside its own nested class.
And I believe they're real static variables and don't get instantiated, respecting the static declaration!
And I had not the need to put that class in an isolated .java file either!

final static constants are different. We were talking about mutable static variables, that are shared among all the instances of a class.
final static constants are must more used that static variables, of course.