1. CHAPTER 6 GENERAL-PURPOSE METHODS
This chapter in the book includes:
6.1 Method and Parameter Declarations
6.2 Returning a Single Value
6.3 Variable Scope
6.4 Common Programming Errors
6.5 Chapter Summary
6.6 Chapter Supplement:
Generating Random Numbers
Click the mouse to move to the next page.
Use the ESC key to exit this chapter.

2. Method and Parameter Declarations
Every Java method must be contained within a class just as the main( ) method is.
There are different types of methods
Static – which receives its data as arguments and manipulates a shared variable – it belongs to the class rather than to objects of the class – it is a class method
Non-static – has access to both instance (without static) and static fields – most methods are non-static or instance methods
The key word public mean that the method can be used outside its own class; private indicates that the method is used only within the class

3. Instance methods- are associated with individual objects
Java Methods
Instance methods- are associated with individual objects
Class methods- ( static) methods are associated with a class (like main)
Helper methods- are subprograms within a class that help other methods in the class; they are declared privately within a class
Constructor methods- are used with the new operator to prepare an object for use.

4. General Purpose Methods
We will be concerned with the method itself and how it interacts with other methods, such as
main( )
Passing data to a general purpose method
Having the method correctly receive, store and process the data
A method is called by using its name and passing data (or arguments) in parenthesis

5. Figure 6.1: Calling and Passing Data to a Method

6. Figure 6.2: Calling and Passing Two Values to findMaximum()

7. import javax.swing.*;
public class ShowTheCall
{ public static void main(String[] args) {
String s1;
double firstnum, secnum;
s1 = JOptionPane.showInputDialog("Enter number:");
firstnum = Double.parseDouble(s1);
s1 = JOptionPane.showInputDialog("Great! Please enter a second number: ");
secnum = Double.parseDouble(s1);
findMaximum(firstnum, secnum); // the method is called here
System.exit(0);
} // end of method
} // end of class

8. Figure 6.3: findMaximum() Receives Actual Values

9. Figure 6.4: General Format of a Method
Method signature
Header – specifies access privileges (where method can be called), data type of returned value, gives method a name and specifies number, order and type of its arguments

10. Figure 6.5: The Structure of a General Purpose Method’s Header
For example:
public static void main (String [] args)

11. Figure 6.6: The Structure of a Method Body

12. Structure of Method Body for findMaximum
// following is the findMaximum() method
public static void findMaximum(double x, double y) // no semicolon here!
{ // start of method body
double maxnum; // variable declaration
if (x >= y) // find the maximum number
maxnum = x;
else
maxnum = y;
JOptionPane.showMessageDialog(null,
"The maximum of " + x + " and " + y + " is " + maxnum,
"Maximum Value", JOptionPane.INFORMATION_MESSAGE);
} // end of method body and end of method

13. secnum = Double.parseDouble(s1);
import javax.swing.*;
public class CompleteTheCall {
public static void main(String[] args)
String s1;
double firstnum, secnum;
s1 = JOptionPane.showInputDialog("Enter a number:");
firstnum = Double.parseDouble(s1);
s1 = JOptionPane.showInputDialog("Great! Please enter a second number:");
secnum = Double.parseDouble(s1);
findMaximum(firstnum, secnum); // the method is called here
System.exit(0);
} // end of main() method
// following is the findMaximum() method
public static void findMaximum(double x, double y)
{ // start of method body
double maxnum; // variable declaration
if (x >= y) // find the maximum number
maxnum = x;
else
maxnum = y;
JOptionPane.showMessageDialog(null,
"The maximum of " + x + " and " + y + " is " + maxnum,
"Maximum Value", JOptionPane.INFORMATION_MESSAGE);
} // end of method body and end of method
} // end of class

14. Figure 6.7: A Sample Display Produced by Program 6.2

15. Point of Information: Isolation Testing

16. Calling a Method
The findMaximum( ) method is the called method, because it is called by its reference in main( )
The method that does the calling (in this case main( ) ) is the calling method
The items within parenthesis are the arguments or parameters:
Formal-the list of values and their data types(or form), that the method expects to receive ( in parenthesis in the method header)
Actual - the actual data values supplied when the call is made ( in the calling method)

17. Method Stubs and Testing
Usually write the main method and add other methods as they are developed
Problem – can’t be run without the methods
Solution – design “empty methods” or stubs, which just contain the header ( and perhaps some comment or print statement to aid in debugging)
Stub is used as a placeholder until the method is written
Calling program is called a “driver” and is used to test each method

18. Empty Parameter Lists and Overloading
Rarely, but sometimes, no parameters are needed – just include empty parenthesis
public static int display ( ) //returns an integer
To call this method use
x = display( );
Using the same method name for more than one method is called overlaoding. The compiler must be able to determine which method to use based on the data types of the parameters. ( eg. square(5); for ints and square (2.5); for doubles)
Method signatures must be unique.

19. Figure 6.8: A Method Directly Returns at Most One Value

20. Returning a Single Value
Pass by value or call by value – copies of the data values contained in the arguments when the method is called are passed to the method.
Method may change the values in its copy as well as any local variables declared in the method
A method returns at most one single value.

21. Void and Value Returning Methods
Void methods are those which manipulate the data within the method. They often contain input or output statements. ( Name with an action word like displayMenu).
Value returning methods ( like mathematical functions) – just compute and return a single value. They DO NOT include input or output statements. They must be part of an expression or assigned to a variable in the calling program. (Usually name with a noun such as square or cube)

22. Another Maximum method
// this one returns the maximum value
public double Maximum(double x, double y)
{ // start of method body
double maxnum; // variable declaration
if (x >= y) // find the maximum number
maxnum = x;
else
maxnum = y;
return maxnum; // return statement }

23. Calling a Value Returning Method
Void methods can stand alone- so they are called just by using the method name:
findMaximum( 5, 8);
Value returning methods must return their value to a variable or be used within an expression (anywhere that data type can be used)
larger = Maximum(5,8); or
if (Maximum(5,8) <10) … or
….2* Maximum(5,8)… or
System.out.println( Maximum(5,8) + “ is the larger number “);

24. Passing a Reference Variable
Java passes both primitive and reference variables in the same way: ( by value) a copy is passed to the method and stored in one of the formal parameters.
Advantages:
Methods can use any variable name without interfering with other methods that might use the same name
Changing the value in the method will not affect the value of that variable in other methods (called a side effect)
Passing a reference variable does have some other implications that passing a primitive does not

25. Figure 6.9: Passing a Reference Value

26. Passing a Reference Variable
Since a reference value gives direct access to the object, any change made within the method is made to the original object’s value.
The ability to alter a referenced object within a method is useful where a method must return more than one value.
Primitive types must first be converted to wrapper types( see p ). Then the reference to this object is passed to the called method.
This will not work with String objects, because they are immutable.

27. Exercises 6.2: Item 9.a.
For Practice:
Write a method named distance that accepts the coordinates of two points (x1,y1) and (x2, y2) and calculates and returns the distance between them according to this formula:

28. Exercises 6.2: Item 11

29. Figure 6.10: A Method Can Be Considered a Closed Box

30. What goes on inside the method are “hidden” from other methods.
Variable Scope
What goes on inside the method are “hidden” from other methods.
Variables declared inside a method are available only to that method and are called local variables.
The section of the program where an identifier is “known” or is visible is its scope – usually the block in which it is declared ( block scope).
A Class variable is any variable declared within a class, but outside a method.

31. Variable “Lifetime” and Duration
Identifiers within the class scope come into being when the class is loaded into memory and remain until the program finishes executing.
Static variables have the same duration as their defining class.
Variables with block scope exist only which the block in which they are defined is in scope, then they are released. If the block comes back into scope later, new storage areas are reserved.

32. Figure 6.11: The Three Storage Areas Created by Program 6.6

33. The local variable takes precedence.
Scope Resolution
Whe a local ( block) variable has the same name as a variable with class scope, all references within the scope of the local variable refer to that local variable.
The local variable takes precedence.
The class variable can be accessed by prefacing it with its class name as shown in the next example.

34. The value of number is 26.4 public class ScopeCover {
private static double number = 42.8; // this variable has class scope
public static void main(String[] args)
double number = 26.4; // this variable has local scope
System.out.println("The value of number is " + number); }
} // end of class
What is the output of this code?
The value of number is 26.4

35. The value of number is 42.5 public class ScopeResolution {
private static double number = 42.8; // this is a static (class scope) variable
public static void main(String[] args)
double number = 26.4; // this is a local variable
System.out.println("The value of number is " + ScopeResolution.number); }
} // end of class
What is the output of this code?
The value of number is 42.5

36. Inner and Outer Blocks
Variables declared in an inner block cannot be acced in any enclosing outside block.
This includes variables declared within the parenthesis of a for statement ( the value of i cannot be accessed once the loop terminates).
The same variable name can be declared and used again after the inner block is out of scope.

37. Common Programming Errors
Attempting to pass incorrect data types
Declaring the same variable locally within both the calling and called methods and assuming that changing one value affects the other.
Ending a method header with a semicolon
Forgetting to include the data type of the method’s parameters within the header.

38. Pseudorandom numbers – sufficiently random.
Random numbers – a series of numbers whose order cannot be predicted, where each has the same likelyhood of occurring.
Pseudorandom numbers – sufficiently random.
General purpos method in the Math class
random( ) – produces double precision numbers from 0.0 up to, but not including 1.0

39. To produce integers use scaling:
More Random Numbers
To produce integers use scaling:
(int)(Math.random( ) * n) // for 0 to n-1
To produce a random integer between 1 and n use
1+ (int)(Math.random( ) * n) // for 1 to n
Example:
1+ (int)(Math.random( ) * 6) // for 1 to 6 (dice game)
or in general use
a+ (int)(Math.random( ) * b+1-a) // for a to b

40. public class RandomNumbers
{ // prints 10 random numbers
public static void main(String[] args) {
final int NUMBERS = 10;
double randValue;
int I, randInt;
for (i = 1; i <= 10; i++)
randValue = Math.random( );
randInt = (int)( Math.random( ) * 100) //integers between 0 and 99
System.out.println(randValue, randInt);
} // end for loop
} // end main
} // end of class