Introduction to Java Programming
Chapter 5
Week 3
Why Write Methods?
• Methods are commonly used to break a problem down into small
manageable pieces. This is called divide and conquer.
• Methods simplify programs. If a specific task is performed in several
places in the program, a method can be written once to perform that
task, and then be executed anytime it is needed. This is known as
code reuse.
void Methods and Value-Returning
Methods
• A void method is one that simply performs a task
and then terminates.
System.out.println("Hi!");
• A value-returning method not only performs a task,
but also sends a value back to the code that called it.
int number = Integer.parseInt("700");
Defining a void Method
• To create a method, you must write a definition, which consists of a
header and a body.
• The method header, which appears at the beginning of a method
definition, lists several important things about the method, including
the method’s name.
• The method body is a collection of statements that are performed
when the method is executed.
Two Parts of Method Declaration
Header
public static void displayMesssage()
{
System.out.println("Hello");
}
Body
Parts of a Method Header
Method Return Method
Modifiers Type Name Parentheses
public static void displayMessage ()
{
System.out.println("Hello");
}
Parts of a Method Header
• Method modifiers
• public—method is publicly available to code outside the class
• static—method belongs to a class, not a specific object.
• Return type—void or the data type from a value-returning method
• Method name—name that is descriptive of what the method does
• Parentheses—contain nothing or a list of one or more variable
declarations if the method is capable of receiving arguments.
Calling a Method
• A method executes when it is called.
• The main method is automatically called when a program starts,
but other methods are executed by method call statements.
displayMessage();
• Notice that the method modifiers and the void return type are
not written in the method call statement. Those are only written
in the method header.
• Examples: SimpleMethod.java, LoopCall.java, CreditCard.java,
DeepAndDeeper.java
Documenting Methods
• A method should always be documented by writing comments that
appear just before the method’s definition.
• The comments should provide a brief explanation of the method’s
purpose.
• The documentation comments begin with /** and end with */.
Passing Arguments to a Method
• Values that are sent into a method are called arguments.
System.out.println("Hello");
number = Integer.parseInt(str);
• The data type of an argument in a method call must correspond to the variable
declaration in the parentheses of the method declaration. The parameter is the
variable that holds the value being passed into a method.
• By using parameter variables in your method declarations, you can design your
own methods that accept data this way. See example: PassArg.java
Passing 5 to the displayValue
Method
displayValue(5); The argument 5 is copied into the
parameter variable num.
public static void displayValue(int
num)
{
System.out.println("The value is " + num);
} The method will display The value is 5
Argument and Parameter Data Type Compatibility
• When you pass an argument to a method, be sure that the
argument’s data type is compatible with the parameter variable’s data
type.
• Java will automatically perform widening conversions, but narrowing
conversions will cause a compiler error.
double d = 1.0;
Error! Can’t convert
displayValue(d); double to int
Passing Multiple Arguments
The argument 5 is copied into the num1 parameter.
The argument 10 is copied into the num2 parameter.
showSum(5, 10); NOTE: Order matters!
public static void showSum(double num1, double num2)
{
double sum; //to hold the sum
sum = num1 + num2;
System.out.println("The sum is " + sum);
}
Arguments are Passed by Value
• In Java, all arguments of the primitive data types are passed by value,
which means that only a copy of an argument’s value is passed into a
parameter variable.
• A method’s parameter variables are separate and distinct from the
arguments that are listed inside the parentheses of a method call.
• If a parameter variable is changed inside a method, it has no affect on
the original argument.
• See example: PassByValue.java
Passing Object References to a Method
• Recall that a class type variable does not hold the actual data item
that is associated with it, but holds the memory address of the object.
A variable associated with an object is called a reference variable.
• When an object such as a String is passed as an argument, it is
actually a reference to the object that is passed.
Passing a Reference as an Argument
Both variables reference the same object
showLength(name); “Warren”
address
The address of the object is address
copied into the str parameter.
public static void showLength(String str)
{
System.out.println(str + " is " + str.length() + " characters
long.");
str = "Joe" // see next slide
}
@param Tag in Documentation Comments
• You can provide a description of each parameter in your
documentation comments by using the @param tag.
• General format
@param parameterName Description
• See example: TwoArgs2.java
• All @param tags in a method’s documentation comment must appear
after the general description. The description can span several lines.
More About Local Variables
• A local variable is declared inside a method and is not accessible to statements
outside the method.
• Different methods can have local variables with the same names because the
methods cannot see each other’s local variables.
• A method’s local variables exist only while the method is executing. When the
method ends, the local variables and parameter variables are destroyed and
any values stored are lost.
• Local variables are not automatically initialized with a default value and must
be given a value before they can be used.
• See example: LocalVars.java
Returning a Value from a Method
• Data can be passed into a method by way of the parameter
variables. Data may also be returned from a method, back to the
statement that called it.
int num = Integer.parseInt("700");
• The string “700” is passed into the parseInt method.
• The int value 700 is returned from the method and assigned to the
num variable.
Defining a Value-Returning Method
public static int sum(int num1, int num2)
{
Return type
int result;
The return statement
result = num1 + num2;
causes the method to end
return result; execution and it returns a
} value back to the
This expression must be of the statement that called the
same data type as the return type method.
Calling a Value-Returning
Method
total = sum(value1, value2);
20 40
public static int sum(int num1, int num2)
{
60 int result;
result = num1 + num2;
return result;
}
@return Tag in Documentation Comments
• You can provide a description of the return value in your
documentation comments by using the @return tag.
• General format
@return Description
• See example: ValueReturn.java
• The @return tag in a method’s documentation comment must
appear after the general description. The description can span several
lines.
Returning a booleanValue
• Sometimes we need to write methods to test
arguments for validity and return true or false
public static boolean isValid(int number)
{
boolean status;
if(number >= 1 && number <= 100)
status = true;
else
status = false;
return status;
}
Calling code:
int value = 20;
If(isValid(value))
System.out.println("The value is within range");
else
System.out.println("The value is out of range");
Returning a Reference to a String
Object
customerName = fullName("John", "Martin");
public static String fullName(String first, String last)
{
address String name;
Local variable name holds
name = first + " " + last;
the reference to the object.
return name; The return statement sends
} a copy of the reference
“John Martin” back to the call statement
and it is stored in
See example: customerName.
ReturnString.java
Problem Solving with Methods
• A large, complex problem can be solved a piece at a time by methods.
• The process of breaking a problem down into smaller pieces is called
functional decomposition.
