AhmadLang / Java, How To Program, 2004

[Page 233 (continued)]

6.3. static Methods, static Fields and Class Math

As you know, every class provides methods that perform common tasks on objects of the class. For example, to input data from the keyboard, you have called methods on a Scanner object that was initialized in its constructor to obtain input from the standard input stream (System.in). As you will learn in Chapter 14, Files and Streams, you can initialize a Scanner to obtain input from other sources, such as a file on disk. One program could have a Scanner object that inputs information from the standard input stream and a second Scanner that inputs information from a file. Each input method called on the standard input stream Scanner would obtain input from the keyboard, and each input method called on the file Scanner would obtain input from the specified file on disk.

Although most methods execute in response to method calls on specific objects, this is not always the case. Sometimes a method performs a task that does not depend on the contents of any object. Such a method applies to the class in which it is declared as a whole and is known as a static method or a class method. It is not uncommon for a class to contain a group of convenient static methods to perform common tasks. For example, recall that we used static method pow of class Math to raise a value to a power in Fig. 5.6.

[Page 234]

To declare a method as static, place the keyword static before the return type in the method's declaration. You can call any static method by specifying the name of the class in which the method is declared, followed by a dot (.) and the method name, as in

ClassName.methodName( arguments )

We use various Math class methods here to present the concept of static methods. Class Math provides a collection of methods that enable you to perform common mathematical calculations. For example, you can calculate the square root of 900.0 with the static method call

Math.sqrt( 900.0 )

The preceding expression evaluates to 30.0. Method sqrt takes an argument of type double and returns a result of type double. To output the value of the preceding method call in the command window, you might write the statement

System.out.println( Math.sqrt( 900.0 ) );

In this statement, the value that sqrt returns becomes the argument to method println. Note that there was no need to create a Math object before calling method sqrt. Also note that all Math class methods are statictherefore, each is called by preceding the name of the method with the class name Math and a dot (.) separator.

Software Engineering Observation 6.4

Class Math is part of the java.lang package, which is implicitly imported by the compiler, so it is not necessary to import class Math to use its methods.

Method arguments may be constants, variables or expressions. If c = 13.0, d = 3.0 and f = 4.0, then

[Page 236 (continued)]

6.4. Declaring Methods with Multiple Parameters

Chapters 35 presented classes containing simple methods that had at most one parameter. Methods often require more than one piece of information to perform their tasks. We now consider how programmers write their own methods with multiple parameters.

The application in Fig. 6.3 and Fig. 6.4 uses a programmer-declared method called maximum to determine and return the largest of three double values that are input by the user. When the application begins execution, class MaximumFinderTest's main method (lines 711 of Fig. 6.4) creates one object of class MaximumFinder (line 9) and calls the object's determineMaximum method (line 10) to produce the program's output. In class MaximumFinder (Fig. 6.3), lines 1418 of method determineMaximum prompt the user to enter three double values and read them from the user. Line 21 calls method maximum (declared in lines 2841) to determine the largest of the three double values passed as arguments to the method. When method maximum returns the result to line 21, the program assigns maximum's return value to local variable result. Then line 24 outputs the maximum value. At the end of this section, we'll discuss the use of operator + in line 24.

Figure 6.3. Programmer-declared method maximum that has three double parameters.

(This item is displayed on page 237 in the print version)

1// Fig. 6.3: MaximumFinder.java

2// Programmer-declared method maximum.

3import java.util.Scanner;

4

5public class MaximumFinder

6{

7 // obtain three floating-point values and locate the maximum value

8public void determineMaximum()

9{

10// create Scanner for input from command window

11Scanner input = new Scanner( System.in );

12

13// obtain user input

14System.out.print(

15"Enter three floating-point values separated by spaces: " );

16double number1 = input.nextDouble(); // read first double

17double number2 = input.nextDouble(); // read second double

18double number3 = input.nextDouble(); // read third double

19

20// determine the maximum value

21double result = maximum( number1, number2, number3 );

23// display maximum value

24System.out.println( "Maximum is: " + result );

25} // end method determineMaximum

27// returns the maximum of its three double parameters

28public double maximum( double x, double y, double z )

32// determine whether y is greater than maximumValue

33if ( y > maximumValue )

34maximumValue = y;

35

36// determine whether z is greater than maximumValue

37if ( z > maximumValue )

38maximumValue = z;

39

40return maximumValue;

41} // end method maximum

42 } // end class MaximumFinder

Figure 6.4. Application to test class MaximumFinder.

(This item is displayed on page 238 in the print version)

1// Fig. 6.4: MaximumFinderTest.java

2// Application to test class MaximumFinder.

4public class MaximumFinderTest

5{

6// application starting point

7public static void main( String args[] )

8{

9MaximumFinder maximumFinder = new MaximumFinder();

10maximumFinder.determineMaximum();

11} // end main

12} // end class MaximumFinderTest

Enter three floating-point values separated by spaces: 9.35 2.74 5.1 Maximum is: 9.35

Enter three floating-point values separated by spaces: 5.8 12.45 8.32 Maximum is: 12.45

Enter three floating-point values separated by spaces: 6.46 4.12 10.54 Maximum is: 10.54

Consider the declaration of method maximum (lines 2841). Line 28 indicates that the method returns a double value, that the method's name is maximum and that the method requires three double parameters (x, y and z) to accomplish its task. When a method has more than one parameter, the parameters are specified as a comma-separated list. When maximum is called from line 21, the parameter x is initialized with the value of the argument number1, the parameter y is initialized with the value of the argument number2 and the parameter z is initialized with the value of the argument number3. There must be one argument in the method call for each parameter (sometimes called a formal parameter) in the method declaration. Also, each argument must be consistent with the type of the corresponding parameter. For example, a parameter of type double can receive values like 7.35, 22 or 0.03456, but not Strings like "hello". Section 6.7 discusses the argument types that can be provided in a method call for each parameter of a primitive type.

[Page 237]

To determine the maximum value, we begin with the assumption that parameter x contains the largest

value, so line 30 declares local variable maximumValue and initializes it with the value of parameter x. Of course, it is possible that parameter y or z contains the actual largest value, so we must compare each of these values with maximumValue. The if statement at lines 3334 determines whether y is greater than maximumValue. If so, line 34 assigns y to maximumValue. The if statement at lines 3738 determines whether z is greater than maximumValue. If so, line 38 assigns z to maximumValue. At this point the largest of the three values resides in maximumValue, so line 40 returns that value to line 21. When program control returns to the point in the program where maximum was called, maximum's parameters x, y and z no longer exist in memory. Note that methods can return at most one value, but the returned value could be a reference to an object that contains many values.

[Page 238]

Note that result is a local variable in determineMaximum because it is declared in the block that represents the method's body. Variables should be declared as fields of a class only if they are required for use in more than one method of the class or if the program should save their values between calls to the class's methods.

Common Programming Error 6.1

Declaring method parameters of the same type as float x, y instead of float x, float y is a syntax errora type is required for each parameter in the parameter list.

Software Engineering Observation 6.5

A method that has many parameters may be performing too many tasks. Consider dividing the method into smaller methods that perform the separate tasks. As a guideline, try to fit the method header on one line if possible.

Implementing Method maximum by Reusing Method Math.max

Recall from Fig. 6.2 that class Math has a max method that can determine the larger of two values. The entire body of our maximum method could also be implemented with two calls to Math.max, as follows:

return Math.max( x, Math.max( y, z ) );

[Page 239]

The first call to Math.max specifies arguments x and Math.max( y, z ). Before any method can be called, all its arguments must be evaluated to determine their values. If an argument is a method call, the method call must be performed to determine its return value. So, in the preceding statement, Math.max( y, z ) is evaluated first to determine the maximum of y and z. Then the result is passed as the second argument to the other call to Math.max, which returns the larger of its two arguments. Using Math.max in this manner is a good example of software reusewe find the largest of three values by reusing Math.max, which finds the largest of two values. Note how concise this code is compared to lines 3040 of Fig. 6.3.

Assembling Strings with String Concatenation

[Page 240]

6.5. Notes on Declaring and Using Methods

There are three ways to call a method:

1.Using a method name by itself to call another method of the same classsuch as maximum( number1, number2, number3 ) in line 21 of Fig. 6.3.

2.Using a variable that contains a reference to an object, followed by a dot (.) and the method name to call a method of the referenced objectsuch as the method call in line 10 of Fig. 6.4, maximumFinder.determineMaximum(), which calls a method of class MaximumFinder from the main method of MaximumFinderTest.

3.Using the class name and a dot (.) to call a static method of a classsuch as Math.sqrt( 900.0 ) in Section 6.3.

Note that a static method can call only other static methods of the same class directly (i.e., using the method name by itself) and can manipulate only static fields in the same class directly. To access the class's non-static members, a static method must use a reference to an object of the class. Recall that static methods relate to a class as a whole, whereas non-static methods are associated with a specific instance (object) of the class and may manipulate the instance variables of that object. Many objects of a class, each with its own copies of the instance variables, may exist at the same time. Suppose a static method were to invoke a non-static method directly. How would the method know which object's instance variables to manipulate? What would happen if no objects of the class existed at the time the non-static method was invoked? Clearly, such a situation would be problematic. Thus, Java does not allow a static method to access non-static members of the same class directly.

There are three ways to return control to the statement that calls a method. If the method does not return a result, control returns when the program flow reaches the method-ending right brace or when the statement

return;

is executed. If the method returns a result, the statement

return expression;

evaluates the expression, then returns the result to the caller.

Common Programming Error 6.4

Declaring a method outside the body of a class declaration or inside the body of another method is a syntax error.

Common Programming Error 6.5

Omitting the return-value-type in a method declaration is a syntax error.