Day 6

Creating Classes and Applications in Java

by Laura Lemay

• Defining Classes
• Creating Instance and Class Variables
  • Defining Instance Variables
  • Constants
  • Class Variables
• Creating Methods
  • Defining Methods
  • The this Keyword
  • Variable Scope and Method Definitions
  • Passing Arguments to Methods
  • Class Methods
• Creating Java Applications
  • Helper Classes
• Java Applications and Command-Line Arguments
  • Passing Arguments to Java Programs
  • Handling Arguments in Your Java Program
• Summary
• Q&A
  

In just about every lesson up to this point you've been creating Java applications-writing classes, creating instance variables and methods, and running those applications to perform simple tasks. Also up to this point, you've focused either on the very broad (general object-oriented theory) or the very minute (arithmetic and other expressions). Today you'll pull it all together and learn how and why to create classes by using the following basics:

• The parts of a class definition
• Declaring and using instance variables
• Defining and using methods
• Creating Java applications, including the main() method and how to pass arguments to a Java program from a command line

Defining Classes

Defining classes is pretty easy; you've seen how to do it a bunch of times in previous lessons. To define a class, use the class keyword and the name of the class:

class MyClassName {
...
}

By default, classes inherit from the Object class. If this class is a subclass of another specific class (that is, inherits from another class), use extends to indicate the superclass of this class:

class myClassName extends mySuperClassName {
...
}

Creating Instance and Class Variables

A class definition with nothing in it is pretty dull; usually, when you create a class, you have something you want to add to make that class different from its superclasses. Inside each class definition are declarations and definitions for variables or methods or both-for the class and for each instance. In this section, you'll learn all about instance and class variables; the next section talks about methods.

Defining Instance Variables

On Day 3, "Java Basics," you learned how to declare and initialize local variables-that is, variables inside method definitions. Instance variables, fortunately, are declared and defined in almost exactly the same way 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. Customarily, however, most instance variables are defined just after the first line of the class definition. For example, Listing 6.1 shows a simple class definition for the class Bicycle, which inherits from the class PersonPoweredVehicle. This class definition contains five instance variables:

• bikeType-The kind of bicycle this bicycle is-for example, Mountain or Street
• chainGear-The number of gears in the front
• rearCogs-The number of minor gears on the rear axle
• currentGearFront and currentGearRear-The gear the bike is currently in, both front and rear

Listing 6.1. The Bicycle class.

1: class Bicycle extends PersonPoweredVehicle {
2:     String bikeType;
3:     int chainGear;
4:     int rearCogs;
5:     int currentGearFront;
6:     int currentGearRear;
7: }

Constants

A constant variable or constant is a variable whose value never changes (which may seem strange given the meaning of the word variable). Constants are useful for defining shared values for all the methods of an object-for giving meaningful names to objectwide values that will never change. In Java, you can create constants only for instance or class variables, not for local variables.

To declare a constant, use the final keyword before the variable declaration and include an initial value for that variable:

final float pi = 3.141592;
final boolean debug = false;
final int maxsize = 40000;

Constants can be useful for naming various states of an object and then testing for those states. For example, suppose you have a test label that can be aligned left, right, or center. You can define those values as constant integers:

final int LEFT = 0;
final int RIGHT = 1;
final int CENTER = 2;

The variable alignment is then also declared as an int:

int alignment;

Then, later in the body of a method definition, you can either set the alignment:

this.alignment = CENTER;

or test for a given alignment:

switch (this.alignment) {
    case LEFT: // deal with left alignment
               ...
               break;
    case RIGHT: // deal with right alignment
                ...
                break;
    case CENTER: // deal with center alignment
                 ...
                 break;
}

Class Variables

As you have learned in previous lessons, class variables are global to a class and to all that class's instances. You can think of class variables as being even more global than instance variables. Class variables are good for communicating between different objects with the same class, or for keeping track of global states among a set of objects.

To declare a class variable, use the static keyword in the class declaration:

static int sum;
static final int maxObjects = 10;

Creating Methods

Methods, as you learned on Day 2, "Object-Oriented Programming and Java," define an object's behavior-what happens when that object is created and the various operations that object can perform during its lifetime. In this section, you'll get a basic introduction to method definition and how methods work; tomorrow, you'll go into more detail about advanced things you can do with methods.

Defining Methods

Method definitions have four basic parts:

• The name of the method
• The type of object or primitive type the method returns
• A list of parameters
• The body of the method

The first three parts of the method definition form what's called the method's signature and indicate the most important information about the method itself.

In other languages, the name of the method (or function, subroutine, or procedure) is enough to distinguish it from other methods in the program. In Java, you can have different methods that have the same name but a different return type or argument list, so all these parts of the method definition are important. This is called method overloading, and you'll learn more about it tomorrow.

Here's what a basic method definition looks like:

returntype methodname(type1 arg1, type2 arg2, type3 arg3..) {
    ...
}

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

Note that if this method returns an array object, the array brackets can go either after the return type or after the parameter list; because the former way is considerably easier to read, it is used in the examples today (and throughout this book):

int[] makeRange(int lower, int upper) {...}

The method's parameter list is a set of variable declarations, separated by commas, inside parentheses. These parameters become local variables in the body of the method, whose values are the objects or values of primitives passed in when the method is called.

Inside the body of the method you can have statements, expressions, method calls to other objects, conditionals, loops, and so on-everything you've learned about in the previous lessons.

If your method has a real return type (that is, it has not been declared to return void), somewhere inside the body of the method you need to explicitly return a value. Use the return keyword to do this. Listing 6.2 shows an example of a class that defines a makeRange() method. makeRange() takes two integers-a lower bound and an upper bound-and creates an array that contains all the integers between those two boundaries (inclusive).

Listing 6.2. The RangeClass class.

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

The array: [ 1 2 3 4 5 6 7 8 9 10 ]

The this Keyword

In the body of a method definition, you may want to refer to the current object-the object in which the method is contained in the first place-to refer to that object's instance variables or to pass the current object as an argument to another method. To refer to the current object in these cases, you can use the this keyword. this can be used anywhere the current object might appear-in dot notation to refer to the object's instance variables, as an argument to a method, as the return value for the current method, and so on. Here's an example:

t = this.x;          // the x instance variable for this object
this.myMethod(this); // call the myMethod method, defined in
                     // this class, and pass it the current
                     // object
return this;         // return the current object

In many cases you may be able to omit the this keyword entirely. You can refer to both instance variables and method calls defined in the current class simply by name; the this is implicit in those references. So the first two examples could be written like this:

t = x          // the x instance variable for this object
myMethod(this) // call the myMethod method, defined in this
               // class

Keep in mind that because this is a reference to the current instance of a class, you should only use it inside the body of an instance method definition. Class methods-that is, methods declared with the static keyword-cannot use this.

Variable Scope and Method Definitions

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

When you refer to a variable within your method definitions, Java checks for a definition of that variable first in the current scope (which may be a block, for example, inside a loop), then in the outer scopes up to the current method definition. If that variable is not a local variable, Java then checks for a definition of that variable as an instance or class variable in the current class, and then, finally, in each superclass in turn.

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 such that a definition of that same variable "hides" the original value of that variable. This can introduce subtle and confusing bugs into your code.

For example, note the small Java program in Listing 6.3.

Listing 6.3. A variable scope example.

 1: class ScopeTest {
 2:     int test = 10;
 3: 
 4:     void printTest () {
 5:         int test = 20;
 6:         System.out.println("test = " + test);
 7:     }
 8:     
 9:     public static void main (String args[]) {
10:        ScopeTest st = new ScopeTest();
11:        st.printTest();
12:     }
13: }

The easiest way to get around this problem is to make sure you don't use the same names for local variables as you do for instance variables. Another way to get around this particular problem, however, is to use this.test to refer to the instance variable, and just test to refer to the local variable. By referring explicitly to the instance variable by its object scope you avoid the conflict.

A more insidious example of this variable naming problem occurs when you redefine a variable in a subclass that already occurs in a superclass. This can create very subtle bugs in your code-for example, you may call methods that are intended to change the value of an instance variable, but that change the wrong one. Another bug might occur when you cast an object from one class to another-the value of your instance variable may mysteriously change (because it was getting that value from the superclass instead of from your class). The best way to avoid this behavior is to make sure that when you define variables in a subclass you're aware of the variables in each of that class's superclasses and you don't duplicate what is already there.

Passing Arguments to Methods

When you call a method with object parameters, the variables you pass into the body of the method are passed by reference, which means that whatever you do to those objects inside the method affects the original objects as well. This includes arrays and all the objects that arrays contain; when you pass an array into a method and modify its contents, the original array is affected. (Note that primitive types are passed by value.)

Listing 6.4 is an example to demonstrate how this works.

Listing 6.4. The PassByReference class.

 1: class PassByReference {
 2:     int onetoZero(int arg[]) {
 3:         int count = 0;
 4: 
 5:         for (int i = 0; i < arg.length; i++) {
 6:             if (arg[i] == 1) {
 7:                 count++;
 8:                 arg[i] = 0;
 9:             }
10:         }
11:         return count;
12:     }
13:     public static void main (String arg[]) {
14        int arr[] = { 1, 3, 4, 5, 1, 1, 7 };
15:        PassByReference test = new PassByReference();
16:        int numOnes;
17:        
18:        System.out.print("Values of the array: [ ");
19:        for (int i = 0; i < arr.length; i++) {
20:           System.out.print(arr[i] + " ");
21:        }
22:        System.out.println("]");
23:     
24        numOnes = test.onetoZero(arr);
25:        System.out.println("Number of Ones = " + numOnes);
26:        System.out.print("New values of the array: [ ");
27:        for (int i = 0; i < arr.length; i++) {
28:            System.out.print(arr[i] + " ");
29:        }
30:        System.out.println("]");
31:     }
32:}

Values of the array: [ 1 3 4 5 1 1 7 ]
Number of Ones = 3
New values of the array: [ 0 3 4 5 0 0 7 ]

• It counts the number of 1s in the array and returns that value.
• If it finds a 1, it substitutes a 0 in its place in the array.

The main() method in the PassByReference class tests the use of the onetoZero() method. Let's go over the main() method line by line so that you can see what is going on and why the output shows what it does.

Lines 14 through 16 set up the initial variables for this example. The first one is an array of integers; the second one is an instance of the class PassByReference, which is stored in the variable test. The third is a simple integer to hold the number of ones in the array.

Lines 18 through 22 print out the initial values of the array; you can see the output of these lines in the first line of the output.

Line 24 is where the real work takes place; this is where you call the onetoZero() method, defined in the object test, and pass it the array stored in arr. This method returns the number of ones in the array, which you'll then assign to the variable numOnes.

Got it so far? Line 25 prints out the number of 1s (that is, the value you got back from the onetoZero() method). It returns 3, as you would expect.

The last bunch of lines print out the array values. Because a reference to the array object is passed to the method, changing the array inside that method changes that original copy of the array. Printing out the values in lines 27 through 30 proves this-that last line of output shows that all the 1s in the array have been changed to 0s.

Class Methods

Just as you have class and instance variables, you also have class and instance methods, and the differences between the two types of methods are analogous. Class methods are available to any instance of the class itself and can be made available to other classes. Therefore, some class methods can be used anywhere, regardless of whether an instance of the class exists.

For example, the Java class libraries include a class called Math. The Math class defines a whole set of math operations that can be used in any program or the various number types:

float root = Math.sqrt(453.0);
System.out.print("The larger of x and y is " + Math.max(x, y));

To define class methods, use the static keyword in front of the method definition, just as you would create a class variable. For example, that max class method might have a signature like this:

static int max(int arg1, int arg2) { ... }

Java supplies "wrapper" classes for each of the primitive data types-for example, classes for Integer, Float, and boolean. Using class methods defined in those classes, you can convert to and from objects and primitive types. For example, the parseInt() class method in the Integer class takes a string and a radix (base) and returns the value of that string as an integer:

int count = Integer.parseInt("42", 10) // returns 42

Most methods that operate on a particular object, or that affect that object, should be defined as instance methods. Methods that provide some general utility but do not directly affect an instance of that class are better declared as class methods.

Creating Java Applications

Now that you know how to create classes, objects, and class and instance variables and methods, all that's left is to put it together into something that can actually run-in other words, to create a Java application.

Applications, to refresh your memory, are Java programs that run on their own. Applications are different from applets, which require a Java-enabled browser to view them. Much of what you've been creating up to this point have been Java applications; next week you'll dive into how to create applets. (Applets require a bit more background in order to get them to interact with the browser and draw and update with the graphics system. You'll learn all of this next week.)

A Java application consists of one or more classes and can be as large or as small as you want it to be. While all the Java applications you've created up to this point do nothing but output some characters to the screen or to a window, you can also create Java applications that use windows, graphics, and user interface elements, just as applets do (you'll learn how to do this next week). The only thing you need to make a Java application run, however, is one class that serves as the "jumping-off" point for the rest of your Java program. If your program is small enough, it may need only the one class.

The jumping-off class for your application needs only one thing: a main() method. When you run your compiled Java class (using the Java interpreter), the main() method is the first thing that gets called. None of this should be much of a surprise to you at this point; you've been creating Java applications with main() methods all along.

The signature for the main() method always looks like this:

public static void main(String args[]) {...}

Here's a run-down of the parts of the main() method:

• public means that this method is available to other classes and objects. The main() method must be declared public. You'll learn more about public and private methods in Week 3.
• static means that this is a class method.
• void means that the main() method doesn't return anything.
• main() takes one parameter: an array of strings. This argument is used for command-line arguments, which you'll learn about in the next section.

The body of the main() method contains any code you need to get your application started: initializing variables or creating instances of any classes you may have declared.

When Java executes the main() method, keep in mind that main() is a class method-the class that holds it is not automatically instantiated when your program runs. If you want to treat that class as an object, you have to instantiate it in the main() method yourself (all the examples up to this point have done this).

Helper Classes

Your Java application can have only one class, or, in the case of most larger programs, it may be made up of several classes, where different instances of each class are created and used while the application is running. You can create as many classes as you want for your program, and as long as they are in the same directory or listed in your CLASSPATH, Java will be able to find them when your program runs. Note, however, that only the one jumping-off class, only the class you use with the Java bytecode interpreter needs a main() method. Remember, main() is used only so that Java can start up the program and create an initial object; after that, the methods inside the various classes and objects take over. While you can include main() methods in helper classes, they will be ignored when the program actually runs.

Java Applications and Command-Line Arguments

Because Java applications are standalone programs, it's useful to be able to pass arguments or options to a program to determine how the program is going to run, or to enable a generic program to operate on many different kinds of input. Command-line arguments can be used for many different purposes-for example, to turn on debugging input, to indicate a filename to read or write from, or for any other information that you might want your Java program to know.

Passing Arguments to Java Programs

How you pass arguments to a Java application varies based on the platform you're running Java on. On Windows and UNIX, you can pass arguments to the Java program via the command line; in the Macintosh, the Java Runner gives you a special window to type those arguments in.

Figure 6.1: Java Runner arguments.

Enter your arguments, separated by spaces, into this box.

In these examples, you've passed three arguments to your program: argumentOne, the number 2, and three. Note that a space separates arguments, so if you use the phrase Java is cool as your arguments, you'll get three of them.

To group arguments, surround them with double-quotes. So, for example, the argument "Java is cool" produces one argument for your program to deal with. The double-quotes are stripped off before the argument gets to your Java program.

Handling Arguments in Your Java Program

How does Java handle arguments? It stores them in an array of strings, which is passed to the main() method in your Java program. Remember the signature for main():

public static void main (String args[]) {...}

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

Inside your main() method, you can then handle the arguments your program was given by iterating over the array of arguments and handling those arguments any way you want. For example, Listing 6.5 is a really simple class that prints out the arguments it gets, one per line.

Listing 6.5. The EchoArgs class.

1: class EchoArgs {
2:     public static void main(String args[]) {
3:         for (int i = 0; i < args.length; i++) {
4:             System.out.println("Argument " + i + ": " + args[i]);
5:         }
6:     }
7: }

The following is some sample input and output from this program:

java EchoArgs 1 2 3 jump

Argument 0: 1
Argument 1: 2
Argument 2: 3
Argument 3: jump

java EchoArgs "foo bar" zap twaddle 5

Argument 0: foo bar
Argument 1: zap
Argument 2: twaddle
Argument 3: 5

Note how the arguments are grouped in the second input example; putting quotes around foo bar causes that argument to be treated as one unit inside the argument array.

An important thing to note about the arguments you pass into a Java program is that those arguments will be stored in an array of strings. This means that any arguments you pass to your Java program are strings stored in the argument array. To treat them as non-strings, you'll have to convert them to whatever type you want them to be.

For example, suppose you have a very simple Java program called SumAverage that takes any number of numeric arguments and returns the sum and the average of those arguments. Listing 6.6 shows a first pass at this program. Don't try compiling this one; just look at the code and see if you can figure out what it does.

Listing 6.6. A first try at the SumAverage class.

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

At first glance, this program seems rather straightforward-a for loop iterates over the array of arguments, summing them, and then the sum and the average are printed out as the last step.

What happens when you try and compile this? You get an error similar to this one:

SumAverage.java:6: Incompatible type for +=. 
Can't convert java.lang.String to int.
    sum += args[i];

You get this error because the argument array is an array of strings. Even though you passed integers into the program from the command line, those integers were converted to strings before they were stored in the array. To be able to sum those integers, you have to convert them back from strings to integers. There's a class method for the Integer class, called parseInt, that does just this. If you change line 6 to use that method, everything works just fine:

sum += Integer.parseInt(args[i]);

Now, compiling the program produces no errors and running it with various arguments returns the expected results. For example, java SumAverage 1 2 3 returns the following output:

Sum is: 6
Average is: 2

Summary

Today you put together everything you've come across in the preceding days of this week about how to create Java classes and use them in Java applications. This includes the following:

• Instance and class variables, which hold the attributes of the class and its instances. You have learned how to declare them, how they are different from regular local variables, and how to declare constants.
• Instance and class methods, which define a class's behavior. You have learned how to define methods, including the parts of a method's signature, how to return values from a method, how arguments are passed in and out of methods, and how to use the this keyword to refer to the current object.
• Java applications-all about the main() method and how it works, as well as how to pass arguments into a Java application from a command line.

Q&A