On Day 2, “The ABCs of Programming,” you learned how to declare and initialize local variables, which are variables inside method definitions.

Instance variables are declared and defined in almost the same manner as local variables. The main difference is their location in the class definition.

Variables are considered instance variables if they are declared outside a method definition and are not modified by the static keyword.

By programming custom, most instance variables are defined right after the first line of the class definition, but they could just as permissibly be defined at the end.

Listing 5.1 contains a simple class definition for the class VolcanoRobot, which inherits from the superclass ScienceRobot.

 1: class VolcanoRobot extends ScienceRobot {
 2:
 3:     String status;
 4:     int speed;
 5:     float temperature;
 6:     int power;
 7: }

This class definition contains four variables. Because these variables are not defined inside a method, they are instance variables. The variables are as follows:

As you learned in previous days, class variables apply to a class as a whole, rather than a particular object of that class.

Class variables are good for sharing information between different objects of the same class or for keeping track of classwide information among a set of objects.

The static keyword is used in the class declaration to declare a class variable, as in the following example:

static int sum;
static final int maxObjects = 10;

In Java, a method definition has four basic parts:

The first two parts of the method definition form the method’s signature.

In other languages, the name of the method (which might be called a function, subroutine, or procedure) is enough to distinguish it from other methods in the program.

In Java, you can have several methods in the same class with the same name but different signatures. This practice is called method overloading, and you learn more about it tomorrow.

Here’s what a basic method definition looks like:

returnType methodName(type1 arg1, type2 arg2, type3 arg3 ...) {
    // body of the method
}

The returnType is the primitive type or class of the value returned by the method. It can be one of the primitive types, a class name, or void if the method does not return a value at all.

The method’s parameter list is a set of variable declarations separated by commas and set inside parentheses. These parameters become local variables in the body of the method, receiving their values when the method is called.

Note that if this method returns an array object, the array brackets can go after either the returnType or the closing parenthesis of the parameter list. Because the former way is easier to read, it is used in this book’s examples as in the following, which declares a method that returns an integer array:

int[] makeRange(int lower, int upper) {
    // body of this method
}

You can have statements, expressions, method calls on other objects, conditionals, loops, and so on inside the body of the method.

Unless a method has been declared with void as its return type, the method returns some kind of value when it is completed. This value must be explicitly returned at some exit point inside the method, using the return keyword.

Listing 5.2 shows RangeLister, a class that defines a makeRange() method. This method takes two integers—a lower boundary and an upper boundary—and creates an array that contains all the integers between those two boundaries. The boundaries themselves are included in the array of integers.

 1: class RangeLister {
 2:     int[] makeRange(int lower, int upper) {
 3:         int[] range = new int[(upper-lower) + 1];
 4:
 5:         for (int i = 0; i < range.length; i++) {
 6:             range[i] = lower++;
 7:         }
 8:         return range;
 9:     }
10:
11:     public static void main(String[] arguments) {
12:         int[] range;
13:         RangeLister lister = new RangeLister();
14:
15:         range = lister.makeRange(4, 13);
16:         System.out.print("The array: [ ");
17:         for (int i = 0; i < range.length; i++) {
18:             System.out.print(range[i] + " ");
19:         }
20:         System.out.println("]");
21:     }
22:
23: }

The output of the application is the following:

The array: [ 4 5 6 7 8 9 10 11 12 13 ]

The main() method in this class tests the makeRange() method by calling it with the arguments of 4 and 13. The method creates an empty integer array and uses a for loop to fill the new array with values from 4 through 13 in lines 5–7.

In the body of a method definition, there are times you might need to refer to the object to which the method belongs. This can be done to use that object’s instance variables and to pass the current object as an argument to another method.

To refer to the object in these cases, use the this keyword where you normally would refer to an object’s name.

The this keyword refers to the current object, and you can use it anywhere a reference to an object might appear: in dot notation, as an argument to a method, as the return value for the current method, and so on. The following are some examples of using this:

t = this.x;           // the x instance variable for this object

this.resetData(this); // call the resetData method, defined in
                      // this class, and pass it the current
                      // object

return this;          // return the current object

In many cases, you might not need to explicitly use the this keyword because it is assumed. For instance, you can refer to both instance variables and method calls defined in the current class simply by name because the this is implicit in those references. Therefore, you could write the first two examples as the following:

t = x;           // the x instance variable for this object

resetData(this); // call the resetData method, defined in this
                 // class

Because this is a reference to the current instance of a class, use it only inside the body of an instance method definition. Class methods—which are declared with the static keyword—cannot use this.

One thing you must know to use a variable is its scope.

Scope is the part of a program in which a variable or another type of information exists, making it possible to use the variable in statements and expressions. When the part defining the scope has completed execution, the variable ceases to exist.

When you declare a variable in Java, that variable always has a limited scope. A variable with local scope, for example, can be used only inside the block in which it was defined. Instance variables have a scope that extends to the entire class, so they can be used by any of the instance methods within that class.

When you refer to a variable, Java checks for its definition outward, starting with the innermost scope.

The innermost scope could be a block statement, such as the contents of a while loop. The next scope could be the method in which the block is contained.

If the variable hasn’t been found in the method, the class itself is checked.

Because of the way Java checks for the scope of a given variable, it is possible for you to create a variable in a lower scope that hides (or replaces) the original value of that variable and introduces subtle and confusing bugs into your code.

For example, consider the following Java application:

class ScopeTest {
    int test = 10;

    void printTest() {
        int test = 20;
        System.out.println("Test: " + test);
    }

    public static void main(String[] arguments) {
        ScopeTest st = new ScopeTest();
        st.printTest();
    }
}

In this class, you have two variables with the same name, test. The first, an instance variable, is initialized with the value 10. The second is a local variable with the value 20.

The local variable test within the printTest() method hides the instance variable test. When the printTest() method is called from within the main() method, it displays that test equals 20, even though there’s a test instance variable that equals 10. You can avoid this problem by using this.test to refer to the instance variable and simply using test to refer to the local variable, but a better solution might be to avoid the duplication of variable names and definitions.

A more insidious example occurs when you redefine a variable in a subclass that already occurs in a superclass. This can create subtle bugs in your code; for example, you might call methods that are intended to change the value of an instance variable, but the wrong variable is changed. Another bug might occur when you cast an object from one class to another; the value of your instance variable might mysteriously change because it was getting that value from the superclass instead of your class.

The best way to avoid this behavior is to be aware of the variables defined in the superclass of your class. This awareness prevents you from duplicating a variable used higher in the class hierarchy.

When you call a method with an object as a parameter, the object is passed into the body of the method by reference. Any change made to the object inside the method will persist outside of the method.

Keep in mind that such objects include arrays and all objects contained in arrays. When you pass an array into a method and modify its contents, the original array is affected. Primitive types, on the other hand, are passed by value.

The Passer class in Listing 5.3 demonstrates how this works.

 1: class Passer {
 2:
 3:     void toUpperCase(String[] text) {
 4:         for (int i = 0; i < text.length; i++) {
 5:             text[i] = text[i].toUpperCase();
 6:         }
 7:     }
 8:
 9:     public static void main(String[] arguments) {
10:         Passer passer = new Passer();
11:         passer.toUpperCase(arguments);
12:         for (int i = 0; i < arguments.length; i++) {
13:             System.out.print(arguments[i] + " ");
14:        }
15:        System.out.println();
16:     }
17: }

This application takes one or more command-line arguments and displays them in all uppercase letters. Here’s an example of running the program and the resulting output:

java Passer Athos Aramis Porthos

ATHOS ARAMIS PORTHOS

The Passer application uses command-line arguments stored in the arguments array of strings.

The application creates a Passer object and calls its toUpperCase() method with the arguments array as an argument (lines 10–11).

Because a reference to the array object is passed to the method, changing the value of each array element in line 5 changes the actual element (rather than a copy of it). Displaying the array with lines 12–14 demonstrates this.

The relationship between class and instance variables is directly comparable to how class and instance methods work.

Class methods are available to any instance of the class itself and can be made available to other classes. In addition, unlike an instance method, a class does not require an instance of the class for its methods to be called.

For example, the Java class library includes the System class, which defines a set of methods that are useful when displaying text, retrieving configuration information, and accomplishing other tasks. Here are two statements that use its class methods:

System.exit(0);

int now = System.exit();

The exit(int) method closes an application with a status code that indicates success (0) or failure (any other value). The currentTimeMillis() method returns a long holding the number of milliseconds since midnight on Jan. 1, 1970, the numeric representation of the current date and time.

To define class methods, use the static keyword in front of the method definition as you would in front of a class variable. For example, the class method currentTimeMillis() in the preceding example might have the following signature:

static void exit(int arg1) {
    // body of the method
}

As you have learned, Java supplies wrapper classes such as Integer and Float for each of the primitive types. By using class methods defined in those classes, you can convert objects to primitive types and convert primitive types to objects.

For example, the parseInt() class method in the Integer class can be used with a string argument, returning an int representation of that string.

The following statement shows how the parseInt() method can be used:

int count = Integer.parseInt("42");

In the preceding statement, the String value “42” is returned by parseInt() as an integer with a value of 42, and this is stored in the count variable.

The lack of a static keyword in front of a method name makes it an instance method. Instance methods operate in a particular object, rather than a class of objects. On Day 1, “Getting Started with Java,” you created an instance method called checkTemperature() that checked the temperature in the robot’s environment.

Your Java application may consist of a single class—the one with the main() method—or several classes that use each other. (In reality, even a simple tutorial program is actually using numerous classes in the Java class library.) You can create as many classes as you want for your program.

As long as Java can find the class, your program uses it when it runs. Note, however, that only the starting-point class needs a main() method. After it is called, the methods inside the various classes and objects used in your program take over. Although you can include main() methods in helper classes, they are ignored when the program runs.

How you pass arguments to a Java application varies based on the computer and virtual machine on which Java is being run.

To pass arguments to a Java program with the java interpreter included with the JDK, the arguments should be appended to the command line when the program is run. For example:

java EchoArgs April 450 -10

In the preceding example, three arguments were passed to a program: April, 450, and -10. Note that a space separates each of the arguments.

To group arguments that include spaces, the arguments should be surrounded with quotation marks. For example, note the following command line:

java EchoArgs Wilhelm Niekro Hough "Tim Wakefield" 49

Putting quotation marks around Tim Wakefield causes that text to be treated as a single argument. The EchoArgs application would receive five arguments: Wilhelm, Niekro, Hough, Tim Wakefield, and 49. The quotation marks prevent the spaces from being used to separate one argument from another; they are not included as part of the argument when it is sent to the program and received using the main() method.

When an application is run with arguments, Java stores the arguments as an array of strings and passes the array to the application’s main() method. Take another look at the signature for main():

public static void main(String[] arguments) {
    // body of method
}

Here, arguments is the name of the array of strings that contains the list of arguments. You can call this array anything you want.

Inside the main() method, you then can handle the arguments your program was given by iterating over the array of arguments and handling them in some manner. For example, Listing 5.4 is a simple Java program that takes any number of numeric arguments and returns the sum and the average of those arguments.

 1: class Averager {
 2:     public static void main(String[] arguments) {
 3:         int sum = 0;
 4:
 5:         if (arguments.length > 0) {
 6:             for (int i = 0; i < arguments.length; i++) {
 7:                 sum += Integer.parseInt(arguments[i]);
 8:             }
 9:             System.out.println("Sum is: " + sum);
10:             System.out.println("Average is: " +
11:                 (float)sum / arguments.length);
12:         }
13:     }
14: }

The Averager application makes sure that in line 5 at least one argument was passed to the program. This is handled through length, the instance variable that contains the number of elements in the arguments array.

You must always do things like this when dealing with command-line arguments. Otherwise, your programs crash with ArrayIndexOutOfBoundsException errors whenever the user supplies fewer command-line arguments than you were expecting.

If at least one argument is passed, the for loop iterates through all the strings stored in the arguments array (lines 6–8).

Because all command-line arguments are passed to a Java application as String objects, you must convert them to numeric values before using them in any mathematical expressions. The parseInt() class method of the Integer class takes a String object as input and returns an int (line 7).

If you can run Java classes on your system with a command line, type the following:

java Averager 1 4 13

You should see the following output:

Sum is: 18
Average is: 6.0

Constructors look a lot like regular methods, with three basic differences:

For example, the following class uses a constructor method to initialize its instance variables based on arguments for new:

class VolcanoRobot {
    String status;
    int speed;
    int power;

    VolcanoRobot(String in1, int in2, int in3) {
        status = in1;
        speed = in2;
        power = in3;
    }
}

You could create an object of this class with the following statement:

VolcanoRobot vic = new VolcanoRobot("exploring", 5, 200);

The status instance variable would be set to exploring, speed to 5, and power to 200.

If you have a constructor method that duplicates some of the behavior of an existing constructor method, you can call the first constructor from inside the body of the second constructor. Java provides a special syntax for doing this. Use the following code to call a constructor method defined in the current class:

this(arg1, arg2, arg3);

The use of this with a constructor method is similar to how this can be used to access a current object’s variables. In the preceding statement, the arguments with this() are the arguments for the constructor method.

For example, consider a simple class that defines a circle using the (x,y) coordinate of its center and the length of its radius. The class, Circle, could have two constructors: one where the radius is defined and one where the radius is set to a default value of 1:

class Circle {
    int x, y, radius;

    Circle(int xPoint, int yPoint, int radiusLength) {
        this.x = xPoint;
        this.y = yPoint;
        this.radius = radiusLength;
    }

    Circle(int xPoint, int yPoint) {
        this(xPoint, yPoint, 1);
    }
}

The second constructor in Circle takes only the x and y coordinates of the circle’s center. Because no radius is defined, the default value of 1 is used—the first constructor is called with the arguments xPoint, yPoint, and the integer literal 1.

Like regular methods, constructor methods also can take varying numbers and types of parameters. This capability enables you to create an object with exactly the properties you want it to have or lets the object calculate properties from different kinds of input.

For example, the buildBox() methods that you defined in the Box class earlier today would make excellent constructor methods because they are being used to initialize an object’s instance variables to the appropriate values. So instead of the original buildBox() method that you defined (which took four parameters for the coordinates of the corners), you could create a constructor.

Listing 5.6 shows a new class, Box2, that has the same functionality of the original Box class, except that it uses overloaded constructor methods instead of overloaded buildBox() methods.

 1: import java.awt.Point;
 2:
 3: class Box2 {
 4:     int x1 = 0;
 5:     int y1 = 0;
 6:     int x2 = 0;
 7:     int y2 = 0;
 8:
 9:     Box2(int x1, int y1, int x2, int y2) {
10:         this.x1 = x1;
11:         this.y1 = y1;
12:         this.x2 = x2;
13:         this.y2 = y2;
14:     }
15:
16:     Box2(Point topLeft, Point bottomRight) {
17:         x1 = topLeft.x;
18:         y1 = topLeft.y;
19:         x2 = bottomRight.x;
20:         y2 = bottomRight.y;
21:     }
22:
23:     Box2(Point topLeft, int w, int h) {
24:         x1 = topLeft.x;
25:         y1 = topLeft.y;
26:         x2 = (x1 + w);
27:         y2 = (y1 + h);
28:     }
29:
30:     void printBox() {
31:         System.out.print("Box: <" + x1 + ", " + y1);
32:         System.out.println(", " + x2 + ", " + y2 + ">");
33:     }
34:
35:     public static void main(String[] arguments) {
36:         Box2 rect;
37:
38:         System.out.println("Calling Box2 with coordinates "
39:             + "(25,25) and (50,50):");
40:         rect = new Box2(25, 25, 50, 50);
41:         rect.printBox();
42:
43:         System.out.println("
Calling Box2 with points "
44:             + "(10,10) and (20,20):");
45:         rect= new Box2(new Point(10, 10), new Point(20, 20));
46:         rect.printBox();
47:
48:         System.out.println("
Calling Box2 with 1 point "
49:             + "(10,10), width 50 and height 50:");
50:         rect = new Box2(new Point(10, 10), 50, 50);
51:         rect.printBox();
52:
53:      }
54: }

This application produces the same output as the Box application in Listing 5.5.

To override a method, all you have to do is create a method in your subclass that has the same signature (name and argument list) as a method defined by your class’s superclass. Because Java executes the first method definition it finds that matches the signature, the new signature hides the original method definition.

Here’s a simple example; Listing 5.7 contains two classes: Printer, which contains a method called printMe() that displays information about objects of that class, and SubPrinter, a subclass that adds a z instance variable to the class.

 1: class Printer {
 2:     int x = 0;
 3:     int y = 1;
 4:
 5:     void printMe() {
 6:         System.out.println("x is " + x + ", y is " + y);
 7:         System.out.println("I am an instance of the class " +
 8:         this.getClass().getName());
 9:     }
10: }
11:
12: class SubPrinter extends Printer {
13:     int z = 3;
14:
15:     public static void main(String[] arguments) {
16:         SubPrinter obj = new SubPrinter();
17:         obj.printMe();
18:      }
19: }

Compiling this file produces two class files rather than one, as you might expect from previous projects. Because the source file defines the Printer and SubPrinter classes, both are produced by the compiler. Run SubPrinter with the Java interpreter to see the following output:

x is 0, y is 1
I am an instance of the class SubPrinter

A SubPrinter object was created, and the printMe() method was called in the main() method of SubPrinter. Because the SubPrinter does not define this method, Java looks for it in the superclasses of SubPrinter, starting with Printer. Printer has a printMe() method, so it is executed. Unfortunately, this method does not display the z instance variable, as you can see from the preceding output.

To correct the problem, you could override the printMe() method of Printer in SubPrinter, adding a statement to display the z instance variable:

void printMe() {
    System.out.println("x is " + x + ", y is " + y +
        ", z is " + z);
    System.out.println("I am an instance of the class " +
        this.getClass().getName());
}

Usually, there are two reasons why you want to override a method that a superclass already has implemented:

Overriding a method and giving the method a new definition hides the original method definition. There are times, however, when behavior should be added to the original definition instead of replacing it completely, particularly when behavior is duplicated in both the original method and the method that overrides it. By calling the original method in the body of the overriding method, you can add only what you need.

Use the super keyword to call the original method from inside a method definition. This keyword passes the method call up the hierarchy, as shown in the following:

void doMethod(String a, String b) {
    // do stuff here
    super.doMethod(a, b);
    // do more stuff here
}

The super keyword, similar to the this keyword, is a placeholder for the class’s superclass. You can use it anywhere that you use this, but super refers to the superclass rather than the current object.

Technically, constructor methods cannot be overridden. Because they always have the same name as the current class, new constructor methods are created instead of being inherited. This system is fine much of the time; when your class’s constructor method is called, the constructor method with the same signature for all your superclasses also is called. Therefore, initialization can happen for all parts of a class that you inherit.

However, when you are defining constructor methods for your own class, you might want to change how your object is initialized, not only by initializing new variables added by your class, but also by changing the contents of variables that are already there. To do this, explicitly call the constructor methods of the superclass and subsequently change whatever variables need to be changed.

To call a regular method in a superclass, you use super.methodname(arguments). Because constructor methods don’t have a method name to call, the following form is used:

super(arg1, arg2, ...);

Note that Java has a specific rule for the use of super(): It must be the first statement in your constructor definition. If you don’t call super() explicitly in your constructor, Java does it for you—automatically calling super() with no arguments before the first statement in the constructor.

Because a call to a super() method must be the first statement, you can’t do something like the following in your overriding constructor:

if (condition == true)
    super(1,2,3); // call one superclass constructor
else
    super(1,2); // call a different constructor

Similar to using this() in a constructor method, super() calls the constructor method for the immediate superclass (which might, in turn, call the constructor of its superclass, and so on). Note that a constructor with that signature has to exist in the superclass for the call to super() to work. The Java compiler checks this when you try to compile the source file.

You don’t have to call the constructor in your superclass that has the same signature as the constructor in your class; you have to call the constructor only for the values you need initialized. In fact, you can create a class that has constructors with entirely different signatures from any of the superclass’s constructors.

Listing 5.8 shows a class called NamedPoint, which extends the class Point from the java.awt package. The Point class has only one constructor, which takes an x and a y argument and returns a Point object. NamedPoint has an additional instance variable (a string for the name) and defines a constructor to initialize x, y, and the name.

 1: import java.awt.Point;
 2:
 3: class NamedPoint extends Point {
 4:     String name;
 5:
 6:     NamedPoint(int x, int y, String name) {
 7:         super(x,y);
 8:         this.name = name;
 9:     }
10:
11:     public static void main(String[] arguments) {
12:         NamedPoint np = new NamedPoint(5, 5, "SmallPoint");
13:         System.out.println("x is " + np.x);
14:         System.out.println("y is " + np.y);
15:         System.out.println("Name is " + np.name);
16:     }
17: }

The output of the program is as follows:

x is 5
y is 5
Name is SmallPoint

The constructor method defined here for NamedPoint calls Point’s constructor method to initialize the instance variables of Point (x and y). Although you can just as easily initialize x and y yourself, you might not know what other things Point is doing to initialize itself. Therefore, it is always a good idea to pass constructor methods up the hierarchy to make sure that everything is set up correctly.

The following question is the kind of thing you could expect to be asked on a Java programming certification test. Answer it without looking at today’s material or using the Java compiler to test the code.

Given:

public class BigValue {
    float result;

    public BigValue(int a, int b) {
        result = calculateResult(a, b);
    }

    float calculateResult(int a, int b) {
        return (a * 10) + (b * 2);
    }

    public static void main(String[] arguments) {
        BiggerValue bgr = new BiggerValue(2, 3, 4);
        System.out.println("The result is " + bgr.result);
    }
}

class BiggerValue extends BigValue {

    BiggerValue(int a, int b, int c) {
        super(a, b);
        result = calculateResult(a, b, c);
    }

   // answer goes here
       return (c * 3) * result;
   }
}

The answer is available on the book’s website at http://www.java21days.com. Visit the Day 5 page and click the Certification Practice link.