- Java has 4 different kinds
of variables
(See:
click here)
- Class variables
- Instance variables
- Local variables
- Parameter variables
We have just learned about:
- local variables
- parameter variables
In this webpage, we will discuss the class variables
Specifically:
- Purpose of
class variables
- How to
identify (and define)
class variables
- The life time of
parameter variables
- The scope of parameter variables
- Class variables:
- A class variable is used to to store long term information that are used by many different methods in the program.
-
How to the define
(and recognize)
a class variable:
- A class variable is
defined:
- Can have the
public access specifier
- It is very rare to have private access class variables
- We will only use public access class variables in this course.
- Must use the
keyword
static
- If you omits the keyword static , then you have defined an instance variable !!!
- inside the braces { ... } of a class (in fact, everything in Java must be contained inside a class), and
- outside the
braces { ... } of
every method
Illustrated:
- Can have the
public access specifier
- The variable a
in the class ClassVar1 is
a class variable
Its type is double
- Notice that the
definition of
a class variable:
public static double a;
and the definition of a class method
public static double min ( double a, double b);
is identical upto the brackets ( .... )
- The Java compiler can tell that the identifier a is a class variable because it is not followed by brackets ( ... )
|
|
Example:
public class ClassVar1
{
public static double a; // <----- Class variable
************* Skip the rest of the program for now **************
public static void main(String[] args)
{ // Body of method "main"
ClassVar1.a = 3.1415;
System.out.println( ClassVar1.a );
}
}
|
Comments:
|
|
- A class variable is
accessed using its
complete name:
nameOfClass.nameOfClassVariable
- Example:
public class ClassVar1 { public static double a; // <----- Class variable public static void main(String[] args) { // Body of method "main" ClassVar1.a = 3.1415; // Accessing a class variable System.out.println(a); } }
- Example Program:
(Demo above code)
- Prog file: click here
How to run the program:
- Right click on link and
save in a scratch directory
- To compile: javac ClassVar1.java
- To run: java ClassVar1
- Recall:
- We can invoke methods
from another method inside
the same class
without
using the class name
See: click here
- We can invoke methods
from another method inside
the same class
without
using the class name
- Short hand notation to access
class variables:
- We can reference a class variable defined inside the same class without using the class name
Example:
public class ClassVar2 { public static double a; // <----- Class variable public static void main(String[] args) { // Body of method "main" a = 3.1415; // We can omit the classname in this method System.out.println(a); } }
- Example Program:
(Demo above code)
- Prog file: click here
How to run the program:
- Right click on link and
save in a scratch directory
- To compile: javac ClassVar2.java
- To run: java ClassVar2
- Class variables are probably the easiest kind of variables to understand compared to the other kinds of variables.....
- Life time of class variables:
- Class variables are
created
when the Java program
begins its execution
- Class variables are destroyed when the Java program terminates
In other words:
- Class variables exist
for the entire execution of
the Java program
(That's why they are used to store long term information)
- Class variables are
created
when the Java program
begins its execution
- Scope of class variables:
- Class variables are accessible in every method of every class
- In other words:
- (Public) class variables can be used anywhere in any Java program
- Example:
public class ClassVar3x { public static void print() { System.out.println( ClassVar3x.a ); // Can be access here, even though // the definition appears below ! } public static double a = 3.1415; // Class variable "ClassVar3x.a" }
public class ClassVar3 { public static void main(String[] args) { System.out.println( ClassVar3x.a ); // Can be accessed here ClassVar3x.print(); // Invoke ClassVar3x.print to show that // it too can access the class variable } }
- Example Program:
(Demo above code)
- ClassVar3.java Prog file: click here
- ClassVar3x.java Prog file: click here
How to run the program:
- Right click on links and
save in a scratch directory
- To compile: javac ClassVar3.java
- To run: java ClassVar3
- Recall
the short hand notation to access
class variables:
- We can reference a class variable defined inside the same class without using the class name
Example:
public class ClassVar2 { public static double a; // <----- Class variable public static void main(String[] args) { // Body of method "main" a = 3.1415; // We can omit the classname in this method System.out.println(a); } }
- Shadowing a class variable:
- When
the method has a
local variable or
a parameter variable
defined in a scope
whose name is
equal
to the name of the class variable,
then:
- The class variable with the same name can no longer accessible with the short hand notation in that scope !!!
- When
the method has a
local variable or
a parameter variable
defined in a scope
whose name is
equal
to the name of the class variable,
then:
- Example:
public class ClassVar4 { public static double a = 3.1415; public static void main(String[] args) { System.out.println( a ); // prints 3.1415 ... (1) { String a = "abc"; // Class var a is not accessible ...(2) // inside inner scope System.out.println( a ); // prints "abc" ...(3) System.out.println( ClassVar4.a ); // prints 3.1415 ...(4) } ...(5) System.out.println( a ); // prints 3.1415 ...(6) boolean a = true; // Class var a is not accessible ...(7) // in main any longer !!! System.out.println( a ); // prints true ...(8) System.out.println( ClassVar4.a ); // prints 3.1415 ...(9) } }Explanation:
- Location (1):
- There are
no local/parameter variables
defined with the name
a
- Therefore, the name a refers to the class variable double a
- There are
no local/parameter variables
defined with the name
a
- Location (2):
- We have defined a
local variable
with the name
a
- Therefore, the name a from now on will refer to the local variable String a
- We have defined a
local variable
with the name
a
- Location (3):
- Will print "abc"
Because, the name a refers to the local variable String a
- Will print "abc"
- Location (4):
- We can still access the class variable using its full name ClassVar4.a
- Location (5):
- The scope of the
local variable String a
ends
(I.e.: the local variable String a does not exist anymore)
- Therefore, the name a will refer back to the class variable double a
- The scope of the
local variable String a
ends
- Location (6):
- There are
no local/parameter variables
defined with the name
a
- Therefore, the name a refers to the class variable double a
- There are
no local/parameter variables
defined with the name
a
- Location (7):
- We have defined a
(new) local variable
with the name
a
- Therefore, the name a from now on will refer to the local variable boolean a
- We have defined a
(new) local variable
with the name
a
- Location (8):
- Will print true
Because, the name a refers to the local variable boolean a
- Will print true
- Location (9):
- We can still access the class variable using its full name ClassVar4.a
- Location (1):
- Example Program:
(Demo above code)
- Prog file: click here
How to run the program:
- Right click on link and
save in a scratch directory
- To compile: javac ClassVar4.java
- To run: java ClassVar4
- Recall:
Java has 4 different kinds
of variables
(See:
click here)
- Class variables
- Instance variables
- Local variables
- Parameter variables
- You have now learned about 3 of them:
- Class variables
(this webpage)
- Local variables --- click here
- Parameter variables --- click here
The instance variables will be discussed under the Section User-defined types.
- Class variables
(this webpage)