Variables

Variables - Back to Musings

by Nicholas Duchon

Java has a variety of different treatments of variables which are related to where they are declared.

The following table summarizes the different variable treatments:

Name	Nature	Scope	Lifetime	Initialization	Example
Class instance variables	one copy of each variable for each instance of that class - declared in class, outside any method	generally, the class and its children	as long as the instance is alive	Yes - default values given for primitive data types, numbers are 0 or 0.0 and booleans are false	a, b, c, sa, sb, sc, tt, ft
Class variables	only one copy of each variable for the whole class - declared "static" in class, outside any method	generally, the class and its children	from the time that any identifier of that class is referenced, i.e., the class is loaded at run time, until the program quits, generally	As class instance	classCount
Class final variables	may be "class instance" or just "class variable", generally should be "static", may not be changed or redefined by any children of the class, normally all uppper case for easy identification	as any class variable or class instance variable, as declared	as class or class instance, as declared	Yes, but normally explicity initialized, may not be changed after initialization in initial declaration	(none here)
Method local variables	declared inside a method	only within the method, may be passed to other methods in parameter lists	as long as the original method is active	No	(main): left, top, dd, ff, ig, tx (mySum): sum
Method formal parameters	declared inside a method, as method variables	as method variables	as method variables	Initialized by caller	(main): args - array of String (mySum): n, m
Block variables	declared inside a block or in the "For Init" part of a for loop (pg 608)	from when the variable is declared until the block ends with a curly bracket	ends when the block ends	No	ty in for loop ty in block

Special notes:

No variable may exist outside some class, same as methods.

This is one aspect of Java that makes it quite different from other programming languages - there are no "global" variables or methods.
This makes writing a simple Java program quite complex, because the programmer MUST start with a class and method.

All class data structures eventually resolve to the Object base class with additional primitive data types and the special class String.

This means that all class and class instance variable are given default values, with String being intialized to "null".
Note that "null" is not the empty string "".

"null" is a special value of Java Object (class, as opposed to primitive data type) variables meaning that the variable is currently not pointing at any instance of the class type it has been declared to point at.
"null" is a testable value, as in "if (th == null)" or "if (th != null)", meaning that the variable th is currently not pointing at any instantiated class, or that it is in the second if.
Note that there are 4 compiler errors in the code listing below.
Until the "new" statement in main, there is no copy of the variables (a, b, c, sa, sb, sc, tt or ft) around.

If another "new" were executed, there would be two copies of each of these variables, one set associated with each "new"ed instance.
This is why they are called "instance" variable - each instance of a class has its own copy of them.

Example:

public class TestOne { int a, b, c = 3; String sa, sb="", sc="some string"; static int classCount = 0; public static void main (String[] args) { int left, top; double dd = 17.5; float ff = (float) 17.5; // error without the (float) cast int ig = 3; static int methodCount = 0; // illegal inside a method if (dd < 30) ig = 3; ig = ig + 3; for (left = 0; left < 10; left++) { top = top = 5; System.out.println ("Top: " + top); } // end for for (int ty = 0; ty < 10; ty++) { top = ty - 7; } // end for { int ty = 7; top = ty + 3; } // end block top = ty + 7; // this is an error, ty not defined here // the following tests static vs non-static references // since main is static // generally, tx indicates the class context below TestOne tx = new TestOne (); tx.tt = 37.3; // ok because tx gives instance reference tt = 49.6; // error, static reference toinstance variable mySum (5, 7); // error, static reference toinstance method tx.mySum (5,7); // ok becuase tx givesinstance reference TestOne.classCount++; // class context explicit } // end method main double tt = 3.7; float ft = 4.6f; // error without the f public int mySum (int n, int m) { int sum; if ((m>0) && (n>0)) { sum = 0; while (n != 0) { sum = sum + n*m; n--; } // end while return sum; } // end if else return 0; } // end method mySum } // end class TestOne

Updated: Mar 17, 2017