1. Introduction to Modular Programming
Lecture 4 Methods
Introduction to Modular Programming

2. Methods Concept
A method is a collection of statements that are grouped together to perform a task
A method is a program module that contains a series of statements that perform a task.
To execute a method, it has to be invoked or called from another method
The calling method makes the method call, and this call invokes the called method
When the System.out.println method is called, the system executes other statements in order to display a message on the console

3. Method Features Every method must include the following features:
A declaration (header or definition)
An opening curly bracket
A body
A closing curly bracket
The method declaration is the first line of the method
It is also known as the method header and includes
Optional access modifier (i.e. public, private, protected)
The return/data type of the method (void, int, double, String etc)
The name of the method
An opening parenthesis
An optional list of arguments(comma separated if more than one)
A closing parenthesis

4. Method Syntax In general a method has the following syntax
modifier returnValueType methodName(param1, param2, ..paramN) {
// method body }

5. Access Modifiers
The access modifiers for Java methods include public, private and protected
The access modifier tells the compiler how to call the method
Methods are most often defined to be public
Defining methods as public means that any class can use it
Any method that can be used without creating an object must be defined as static
Methods declared as static are known as class methods

6. Return Value Types
Some methods may return values after they have completed their tasks
The value returned has the same data type as the return value type of the method
Some methods do not return values after they complete their tasks.
The return value types for methods that do not return data are always void
As noted earlier, the main method for every Java application has the void return type

7. The return Statement
The return statement is used in nearly all methods except those methods declared as void
The return statement is usually not required in methods declared as void
The return statement is usually the last statement in the method
An attempt to use more than one return statement in a method can result in a compile time error
The return statement can be used to return a value at the end of the method execution

8. Method Parameter List
The parameter list is contained in the parenthesis that follows the method name in a method declaration
The variables defined in the method header are known as formal parameters or simply parameters
The parameter list refers to the data type, the order and number of variables declared in the parenthesis
Each parameter must be declared with its own data type and must be separated from others by a comma
The method name and the parameter list form the method signature or method header
Parameters are optional; that is, some methods may not contain parameters

9. Java methods example
In java, methods are housed within a program unit called classes
Classes can contain one or more methods for performing various tasks belonging to the class
As an example, a class that represents a bank account may have various methods
A method to deposit some amount to the account
A method to withdraw some money from the account
A method to check the current balance of the account
Each method is invoked by an object to perform an action through a method call

10. Method Call Any class can contain any number of methods
Each method in a class can be called an unlimited number of times
Some methods require some data items (known as arguments or parameters) in order to perform their tasks
Other methods do not require arguments to perform their tasks
Some other methods send back data (known as returning values) to the calling methods
Other methods do not return values to the calling methods

11. Method call Illustrated
Pass the value of a to n1
Pass the value of b to n2
public static void main(String[ ] arg) { int a = 7; int b = 9; int c = min( a, b ); System.out.println( “The smallest of ” + a + “ and ” + b + “ is ” + c ); }
public static int min( int n1, int n2 ) { int small ; if( n1 < n2 ) small = n1; else small = n2; return small; }

12. Methods as Behaviours
Recall that main is a special method that is always called automatically by the Java Virtual Machine (JVM) at execution
Unlike main, most methods do not get called automatically
Methods must be called by objects to tell them to perform their tasks
The name of the object or class is followed by a period and the name of the method as in firstName.toUpperCase() and Integer.parseInt()
Methods determine the behaviour or actions performed by an object or a class as a whole unit

13. Methods Declaration
A method whose declaration is preceded by the keyword public indicates that the method is available to the public
Methods declared as public can be called from within the same class and by objects or methods of other classes
Methods declared as void do not return (give back) any value after completing their tasks
Methods that have return types other than void can return values after completing their tasks
The values returned can be one of simple types such as int, double, String, boolean or an object of a class

14. Methods Declaration continued
By convention method names begin with lowercase letters and all subsequent words in the name begin with uppercase letters – camel notation
The name of the method follows the return type
Method names are followed by a set of parentheses
Methods with empty set of parenthesis indicate that the methods do not require additional information to complete their task
The body of the method contains the statements that perform the task of the method
Every method’s body is enclosed in a set of left and right braces ( { and } – a set of curly brackets )

15. Declaring Methods
Consider the following parts in the method below: the return type, the name, the arguments, and the body:
public void displayJobs( void ) {
// set of statements that perform the tasks of method
System.out.println(“Cooks wanted”); }
As noted earlier, the type, name and arguments together form the signature of the method or method header
Access modifier
name
arguments
type
Body

16. Sample Method Declaration
Note the use of the 4 method parts below
The return type, the name, the arguments, and the body:
public void setAge( int age ) {
// statements that perform the task of the method
int itsAge = age; }
The type, name and arguments together is referred to as the signature of the method, or the method header

17. static Methods, static Fields, class Math
Most methods execute in response to method calls by some specific objects
Other methods do not require the call from an object in order to perform their tasks
Such methods apply to the class in which they are declared
They are therefore known as static methods or class methods
Methods declared as static can be called without creating an instance of the class that creates them
All static methods are declared by placing the keyword static before the return type

18. static Methods continued
Static methods can be called by specifying the name of the class in which they are declared, followed by a dot (.) and the name of the method
ClassName.methodName( arguments )
The Math class contains a number of static methods for most common mathematical calculations
The square root method is a good example of a static method in class Math
As an example, a static method call can evaluate the square root of as follows
Math.sqrt( ) will produce 20.0

19. static Fields The term field is used to describe class variables
Class variables are also know as instance variables
Instance variables are tied to specific instances of a class
Instance variables are not shared among objects of the same class
Instance variables are stored in different locations in the computer memory
Static variables store values in a common memory location
Static fields allow data sharing among class members
If one class member changes the value of a static variable all other objects of the class are affected

20. class StaticFieldDemo { int a; static int b; // any change to b affects all other class object values public static void main( String[ ] args ) StaticFieldDemo aVar = new StaticFieldDemo(); StaticFieldDemo bVar = new StaticFieldDemo(); aVar.a = 5; // assign aVar variable a to 5 bVar .a = 8; // assign bVar variable a to 8 independent of a aVar.b = 15; // assign aVar variable b to 15 bVar.b = 18; // is automatically assigned the value 18 }

21. The Square Root Method
Method sqrt takes an argument of type double and returns a result of type double
The method can be invoked by the standard output method as follows
System.out.println( Math.sqrt( ) );
In this case the value returned by method sqrt() becomes the argument to method println()
Please note that the call to method sqrt() did not require the creation of a Math object
Also all Math class methods are static – therefore each method is called by preceding the method name by the class name Math followed by the dot operator

22. Class Math Methods
Class Math is part of the java.lang package which is implicitly imported by the compiler
Therefore we do not need to import class Math in order to use its methods
Some common class Math methods include
Math.pow( x, y ) evaluates x raised to the power y (i.e., xy)
Math.max( x , y ) determines larger value of x and y
Math.min( x, y ) determines smaller value of x and y
Math.sqrt( x ) evaluates square root of x
Math.exp( x ) exponential method ex
Math.log( x ) natural logarithm of x (base e)
Math.floor( x ) rounds x to the largest integer not greater than x
Math.ceil( x ) rounds x to the smallest integer not
Math.abs( x ) absolute value of x
Math.sin( x ) trigonometric sine of x (x in radians)

23. Method Overloading
It is possible to define two or more methods with the same name but have different parameter list
The methods can have the same name but the number of parameters may vary
Such methods are known as overloaded methods
Overloaded methods must have different parameter lists
Different return types or modifiers are not enough for overloading a method
Methods that perform closely related tasks should be given the same name
This concept can be applied to different Constructors in a class definition

24. Overloaded Methods Method with int arguments
Method with double arguments
int sum( int a, int b ) {
return a + b; }
If the method sum is called with int parameters, the sum method that expects int parameters will be invoked.
The java interpreter determines which method is used based on parameter list
double sum( double a, double b) {
return a + b; }
If the method sum is called with double parameters, the sum method that expects double parameters will be invoked.
Method overloading refers to two or more methods with the same name, but different parameter list.

25. The Scope of a Variable
The scope of a variable is the part of the program where the variable can be referenced
Any variable declared inside a method is referred to as a local variable of the method
The scope of a local variable starts from the point of its declaration to the end of the block that contains the variable
A local variable must be declared before it can be used in a program
Parameters of a method are also local variables of the method

26. More on scope of Variables
The scope of method parameters covers the entire method
Any variable declared in the initial part of a for loop header has its scope in the entire loop
A variable declared inside a for loop body has its scope limited in the loop body from its declaration to the end of the block that contains the variable
A variable can be declared a number of times in different non-nesting blocks in a method or a loop

27. Access Modifiers
Java provides several modifiers that control access to data, methods and classes
The public, private and default modifiers are discussed below
The public modifier makes classes, methods and fields accessible from any class
The private modifier makes methods and fields accessible from only within the class that declares or creates them
If public or private is not specified, the default access is within package level. It is therefore known as package –private or package access
The protected modifier gives access to same package or subclass level access

28. The Return Type of a Method
The return type of a method may be any data type.
The type of a method indicates the datatype of the output it produces.
Some methods return nothing in which case they are declared as void.

29. The return Statements
The return statement is used in a method to output the result of the methods computation.
It has the form: return expression_value;
The type of the expression_value must be the same as the type of the method:
double calcCube(double aNumber) {
double answer;
// Compute the cube of aNumber and assign
// the result to the variable answer
answer = aNumber * aNumber * anumber;
return answer ; }

30. The return Statement continued
A method exits immediately after it executes the return statement
Therefore, the return statement is usually the last statement in a method
A method may have multiple return statements. Can you think of an example of such a case?

31. Sample Example: int absoluteValue(int anyNumber) {
if (anyNumber < 0)
return –anyNumber;
else
return anyNumber; }

32. void Methods
A method of return type void does not require the return statement in its body of statements.
A good example is when a method’s task is only to print to the screen.
Other situations in which methods are declared void is when the method is used to set or assign a value to an expression
If no return statement is used in a method of type void, it automatically exits at the end of the method

33. Method Arguments Methods can accept input in the form of arguments.
Arguments can be used as variables inside the method body.
Like variables, arguments, must have their type specified.
Arguments are specified inside the parentheses that follow the name of the method.

34. Example of a Method
Here is an example of a method that divides two doubles:
double divide(double a, double b) {
double answer;
answer = a / b;
return answer; }

35. Method Arguments Multiple method arguments are separated by commas:
double Math.pow(double x, double y)
Arguments may be of different types
String studentInfo( String name, int age )

36. The Method Body
The body of a method is a block specified by curly brackets. The body defines the actions of the method.
The method arguments can be used anywhere inside of the body.
All methods must have curly brackets to specify the body even if the body contains only one or no statement.

37. main - A Special Method
The only method that we have used in lab up until this point is the main method.
The main method declared in java applications as
public static void main(String [] arg )
is the starting point of every java application
The java command executes the Java Virtual Machine (JVM) as in
java ClassName arg1 arg2 …
The JVM in turn loads the class specified by ClassName and uses that class name to invoke the method main
Declaring the method main as static allows the JVM to invoke main without creating an instance of the specified class

38. main continued
class SayHello {
public static void main(String[] args)
System.out.println("Hello, " + args[0]); }
When a java Program arg1 arg2 … argN is typed on the command line, anything after the name of the class file is automatically entered into the args array as in:
java SayHello Sam
In this example args[0] will contain the String "Sam ", and the output of the program will be Hello, Sam .

39. Example main method After compiling, if you type
class Greetings {
public static void main( String[] args )
String greeting = "";
for (int i=0; i < args.length; i++) {
greeting += "Jambo " + args[i] + "! "; }
System.out.println(greeting);
After compiling, if you type
java Greetings Alice Bob Charlie
prints out "Jambo Alice! Jambo Bob! Jambo Charlie!"

40. Recursive Example
class Factorial {
public static void main (String[] args)
int num = Integer.parseInt(args[0]));
System.out.println( fact( num ) ); }
static int fact( int n )
if ( n <= 1 )
return 1;
else
return n * fact( n – 1 );
After compiling, if you type java Factorial 5 the program will print out 120

41. Another Example
class MaxNum {
public static void main( String[ ] args )
if ( args.length == 0 )
return;
int maxNum = Integer.parseInt( args[0] );
for ( int i = 1; i < args.length; i++ )
if(Integer.parseInt( args[ i ] ) > maxNum )
maxNum = Integer.parseInt(args[i]); }
System.out.println( maxNum );
After compiling, if you type java MaxNum the program will print out 9

42. Summary Methods perform all the tasks required of the program
Methods describe all the mechanisms to be performed
Methods in Java have 4 parts: return type, method name, arguments, and method body.
The return type and arguments may be either primitive data types or complex data types (Objects)
Declaring the method main as static allows the JVM to invoke main without creating an instance of the specified class
main is a special Java method which the java interpreter looks for when you try to run a class file
Methods must be called by objects to tell them to perform their tasks