Earlier modules have touched briefly on the topic of variables. This module discusses Java variables in depth.

The first step

The first step in learning to use a new programming language is usually to learn the foundation concepts such as

This and several future modules concentrate on that foundation.

A sample program

The module begins with a sample Java program named simple1 . The user is asked to enter some text and to terminate with the # character.

(This program contains a lot of code that you are not yet prepared to understand. For the time being, just concentrate on the use of variables in the program. You will learn about the other aspects of the program in future modules.)

The program loops, saving individual characters until encountering the # character. When it encounters the # character, it terminates and displays the character entered immediately prior to the # character.

A complete listing of the program named simple1 is provided in Listing 1 . Discussions of selected portions of the program are presented later in the module.

/*File simple1.java Copyright 1997, R.G.Baldwin
This Java application reads bytes from the keyboard until
encountering the integer representation of '#'.  At 
the end of each iteration, it saves the byte received and 
goes back to get the next byte.

When the '#' is entered, the program terminates input and
displays the character which was entered before the #.
**********************************************************/

class simple1 { //define the controlling class

  //It is necessary to declare that this method 
  // can throw the exception shown below (or catch it).
  public static void main(String[] args) //define main 
                        throws java.io.IOException {

    //It is necessary to initialize ch2 to avoid a compiler
    // error (possibly unitialized variable) at the 
    // statement which displays ch2.
    int ch1, ch2 = '0';

    System.out.println(
                      "Enter some text, terminate with #");

    //Get and save individual bytes
    while( (ch1 = System.in.read() ) != '#') 
      ch2 = ch1;

    //Display the character immediately before the #
    System.out.println(
          "The char before the # was " + (char)ch2);
  }//end main
}//End simple1 class.

Program output

The output produced by compiling and running this program is shown in Image 1 . The second line of text in Image 1 ending with the # character was typed by the user.

Enter some text, terminate with #
abcde#
The char before the # was e

Declaring a variable

To use a variable, you must first notify the compiler of the name and the type of the variable. This is known as declaring a variable .

The syntax for declaring a variable is to precede the name of the variable with the name of the type of the variable as shown in Listing 2 . It is also possible (but not required) to initialize a variable in Java when it is declared as shown in Listing 2 .

int ch1, ch2 = '0';

The statement in Listing 2 declares two variables of type int , initializing the second variable (ch2) to the value of the zero character (0). (Note that I didn't say initialized to the value zero.)

Initialization of the variable

Initialization of the variable named ch2 in this case was necessary to prevent a compiler error. Without initialization of this variable, the compiler would recognize and balk at the possibility that an attempt might be made to execute the statement shown in Listing 3 with a variable named ch2 that had not been initialized

System.out.println("The char before the # was " 
                                       + (char)ch2);

Error checking by the compiler

The strong error-checking capability of the Java compiler would refuse to compile this program until that possibility was eliminated by initializing the variable.

Using the cast operator

You should also note that the contents of the variable ch2 is being cast as type char in Listing 3 .

(A cast is used to change the type of something to a different type.)

Recall that ch2 is a variable of type int , containing the numeric value that represents a character.

We want to display the character that the numeric value represents and not the numeric value itself. Therefore, we must cast it (purposely change its type for the evaluation of the expression) . Otherwise, we would not see the character on the screen. Rather, we would see the numeric value that represents that character.

Why declare the variables as type int?

It was necessary to declare these variables as type int becausethe statement in Listing 4 (more specifically, the call to the System.in.read method) returns a value of type int .

while( (ch1 = System.in.read() ) != '#') ch2 = ch1;

Java provides very strict type checking and generally refuses to compile statements with type mismatches.

(There is a lot of complicated code in Listing 4 that I haven't previously explained. I will explain that code later in this and future modules.)

Another variable declaration

The program in Listing 1 also makes another variable declaration shown by the statement in Listing 5 .

public static void main(String[] args) //define main method

An array of String references

In Listing 5 , the formal argument list of the main method declares an argument named args (first cousin to a variable) as a reference to an array object of type String .

Capturing command-line arguments in Java

As you learned in an earlier module, this is the feature of Java that is used to capture arguments entered on the command line, and is required whether arguments are entered or not. In this case, no command-line arguments were entered, and the variable named args is simply ignored by the remainder of the program.

The purpose of the type of a variable

For example, the int type can only contain whole numbers (integers) . A whole host of operations are possible with an int variable including add, subtract, divide, etc.

Signed vs. unsigned variables

Unlike C++, all variables of type int in Java contain signed values. In fact, with the exception of type char , all primitive numeric types in Java contain signed values.

Platform independence

At this point in the history of Java, a variable of a specified type is represented exactly the same way regardless of the platform on which the application or applet is being executed.

This is one of the features that causes compiled Java programs to be platform-independent.

Type       Size/Format                 Description
byte      8-bit two's complement     Byte-length integer
short    16-bit two's complement     Short integer
int      32-bit two's complement     Integer               
long     64-bit two's complement     Long Integer
float    32-bit IEEE 754 format      Single-precision 
                                     floating point
double   64-bit IEEE 754 format      Double-precision 
                                     floating point
char     16-bit Unicode character    Single character
boolean  true or false               True or False

/*File wrapper1.java Copyright 1997, R.G.Baldwin
This Java application illustrates the use of wrappers 
for the primitive types.

This program produces the following output:

My wrapped double is 5.5
My primitive double is 10.5

**********************************************************/
class wrapper1 { //define the controlling class
  public static void main(String[] args){//define main

    //The following is the declaration and instantiation of 
    // a Double object, or a double value wrapped in an 
    // object. Note the use of the upper-case D.
    Double myWrappedData = new Double(5.5);

    //The following is the declaration and initialization 
    // of a primitive double variable. Note the use of the
    // lower-case d.
    double myPrimitiveData = 10.5;

    //Note the call to the doubleValue() method to obtain 
    // the value of the double wrapped in the Double 
    // object.
    System.out.println(
      "My wrapped double is " + myWrappedData.doubleValue());
    System.out.println(
             "My primitive double is " + myPrimitiveData );
  }//end main
}//End wrapper1 class.

Double myWrappedData = new Double(5.5);

//Code deleted for brevity

//Note the use of the doubleValue() method to obtain the
// value of the double wrapped in the Double object.
System.out.println
  ("My wrapped double is " + myWrappedData.doubleValue() );

What is the scope of a Java variable?

The scope of a Java variable is defined by the block of code within which the variable is accessible.

(Briefly, a block of code consists of none, one, or more statements enclosed by a pair of matching curly brackets.)

The scope also determines when the variable is created (memory set aside to contain the data stored in the variable) and when it possibly becomes a candidate for destruction (memory returned to the operating system for recycling and re-use) .

Scope categories

The scope of a variable places it in one of the four categories shown in Image 5 .

Member variable

A member variable is a member of a class (class variable) or a member of an object instantiated from that class (instance variable) . It must be declared within a class, but not within the body of a method or constructor of the class.

Local variable

A local variable is a variable declared within the body of a method or constructor or within a block of code contained within the body of a method or constructor.

Method parameters

Method parameters are the formal arguments of a method. Method parameters are used to pass values into and out of methods. The scope of a method parameter is the entire method for which it is a parameter.

Exception handler parameters

Exception handler parameters are arguments to exception handlers. Exception handlers will be discussed in a future module.

Illustrating different types of variables in Java

The Java program shown in Listing 8 illustrates

An illustration of exception handler parameters will be deferred until exception handlers are discussed in a future module.

/*File member1.java Copyright 1997, R.G.Baldwin
Illustrates class variables, instance
variables, local variables, and method parameters.

Output from this program is:

Class variable is 5
Instance variable is 6
Method parameter is 7
Local variable is 8

**********************************************************/
class member1 { //define the controlling class
  //declare and initialize class variable
  static int classVariable = 5;
  //declare and initialize instance variable
  int instanceVariable = 6;

  public static void main(String[] args){ //main method
    System.out.println("Class variable is "
                                          + classVariable);

    //Instantiate an object of the class to allow for
    // access to instance variable and method.
    member1 obj = new member1();
    System.out.println("Instance variable is "
                                   + obj.instanceVariable);
    obj.myMethod(7); //call the method

    //declare and intitialize a local variable
    int localVariable = 8;
    System.out.println("Local variable is "
                                          + localVariable);

  }//end main

  void myMethod(int methodParameter){
    System.out.println("Method parameter is "
                                        + methodParameter);
  }//end myMethod
}//End member1 class.

Declaration of local variables

In Java, local variables are declared within the body of a method or within a block of code contained within the body of a method.

Scope of local variables

The scope of a local variable extends from the point at which it is declared to the end of the block of code in which it is declared.

What is a "block" of code?

A block of code is defined by enclosing it within curly brackets as in { ... }.

Therefore, the scope of a local variable can be the entire method, or can reduced by declaring it within a block of code within the method.

Initializing primitive local variables

Local variables of primitive types can be initialized when they are declared using statements such the one shown in Listing 9 .

int MyVar, UrVar = 6, HisVar;

Initializing member variables

Member variables can also be initialized when they are declared.

In both cases, the type of the value used to initialize the variable must match the type of the variable.

Initializing method parameters and exception handler parameters

Method parameters and exception handler parameters are initialized by the values passed to the method or exception handler by the calling program.

I encourage you to copy the code from Listing 1 , Listing 6 , and Listing 8 . Compile the code and execute it. Experiment with the code, making changes, and observing the results of your changes. Make certain that you can explain why your changes behave as they do.

This section contains a variety of miscellaneous information.

-end-