Methods

Methods are also called functions. Functions

are broadly classified into two categories:
1.Built-in- functions
2. user defined functions
Built-in-functions: are provided
by java compiler for specific
function.For example:
Math.pow()
Math.sqrt()
CountTokens()
Date() etc etc.
 User Defined-functions: are
designed or written by a
programmer to solve a particular
task.
For example:
void inputnum()
void checkdata(int x)
boolean isfound( int a , int b)
int sum()
void printdata()
 What is a method/function ?

A function is a group of statements

[ executable instructions] designed inside or
outside of the main function , to solve a
particular task.
 Why we use functions
???
-> it allow us to cope with complex problems
because we can break the big complex
problems into smaller functions. So we can
say that functions lessen the complexity of
programs.
-> functions hide the implementation details
-> functions enhance reusability of code. to
reuse portions of code .
-> to create conceptual units
 Defining Classes
A class contains data declarations (static and
instance variables) and method declarations
(behaviors)
class Month
int month;
int year Data declarations

Method declarations
 Methods

a method takes input, performs actions,

and produces output
In Java, each method is defined within specific class
 Method Declaration: Header
A method declaration begins with a method header

class MyClass
{
static int min ( int num1, int num2 )

method parameter list

name
The parameter list specifies the type
return and name of each parameter
type
The name of a parameter in the method
properties declaration is called a formal argument
 Method Declaration: Body
The header is followed by the method body:

class MyClass
{

static int min(int num1, int num2)
{
int minValue = num1 < num2 ? num1 : num2;
return minValue;
}

}
 The return Statement
The return type of a method indicates the
type of value that the method sends back to
the calling code.
An immediate exit from the function is
caused as soon as a return statement is
encountered.

10
 A function may contain several return
statements, however only one of them
gets executed because the execution
of the function terminates as soon as a
return is encountered.

The return statement specifies the

value that will be returned. A method
that does not return a value has a
void return type
 Data type void
Void data type specifies an empty set of values
and it is used as the return type for functions
that do not return a value.
For eg:
void cal_per( parameter list )

due to void data type this function will

not have return statement but it returns the
control to the caller function.
 Calling a Method
Each time a method is called, the values of the actual
arguments in the invocation are assigned to the formal
arguments

int num = min (2, 3);

static int min (int num1, int num2)

{
int minValue = (num1 < num2 ? num1 : num2);
return minValue;
}
 Method Control Flow
A method can call another method, who
can call another method,
main
min(num1, num2, num3) println()

min(1, 2, 3);
println()
 More Examples
double tryMe ( int x )
{
return x + 5;
Which tryMe will be called?
}
tryMe( 1 );
double tryMe ( double x )
{ tryMe( 1.0 );
return x * .375;
} tryMe( 1.0, 2);

tryMe( 1, 2);
double tryMe (double x, int y)
{ tryMe( 1.0, 2.0);
return x + y;
}
Variable Scoping
 Variables
At a given point, the variables that a statement can
access are determined by the scoping rule
the scope of a variable is the section of a program in which
the variable can be accessed (also called visible or in scope)

There are two types of scopes in Java

class scope
a variable defined in a class but not in any
method
block scope
a variable defined in a block {} of a method; it is
also called a local variable
 Pure Function

Pure
functions are those that do not
change the state of their parameters.
Pure function takes objects and/or
primitives as arguments but does not
modify the objects
 Impure Function
Impure functions are those that
change/ modify the state of their
parameters. Impure functions are
also called modifier functions.
 Java Scoping Rule
class/static variable: a variable defined in
class scope and has the static property
it is associated with the class
and thus can be accessed (in scope) in all
methods in the class
instance variable: a variable defined in class
scope but not static
it is associated with an instance of an
object of the class,
and thus can be accessed (in scope) only
in instance methods, i.e., those non-static
methods
Actual Parameters: The values
are passed with the defined
parameters in a function , called
actual parameters.

Formal Parameters: It is refer to

the parameters in the definition
of the method.
For Eg.
// defining a method
int addnum( int a , int b)
{ int s=a+b;
return s; ( Formal parameters)
}
Class hello
{
psvm
{
int x =20 , y = 90;
creation of an object
hello ob = new hello();
// calling function
int ans = addnum( x , y);
{ int s=a+b;
return s; ( Actual parameters)

}
 A variable with a block scope
can be accessed in the enclosing block;
also called local variable
a local variable can shadow a variable in a
class scope with the same name

Do not confuse scope with duration

a variable may exist but is not accessible in
a method,
e.g., method A calls method B, then the variables
declared in method A exist but are not accessible
in B.
 Scoping Rules (cont.):
Variables in a method
There are can be three types of variables
accessible in a method :
class and instance variables
static and instance variables of the class

local variables
those declared in the method

formal arguments
 Example1:
public class Box
{
private int length, width;

public int widen (int extra_width) instance variables

{
private int temp1;
formal arguments
size += extra_width; local variables

}
public int lenghten (int extra_lenth)
{
private int temp2;
size += extra_length;

}

}
 Scope of Variables
public class Box
{ Instance variables
private int length, width;
are accessible in all
methods of the class
public int widen (int extra_width)
{ formal arguments
private int temp1;
size += extra_width; are valid within
}
their methods
public int lenghten (int extra_lenth) Local variables are
{
private int temp2; valid from the point
size += extra_length;

of declaration to the
} end of the enclosing
block
}
 Two Types of
Parameter Passing
If a modification of the formal argument
has no effect on the actual argument,
it is call by value

If a modification of the formal argument

can change the value of the actual
argument,
it is call by reference
 Call-By-Value and
Call-By-Reference in Java
Depend on the type of the formal argument
If a formal argument is a primitive data type, a modification on the formal argument has no effect on the actual
argument
this is call by value, e.g. num1 = min(2, 3);
num2 = min(x, y);
This is because primitive data types variables contain their values, and procedure call trigger an assignment:
<formal argument> = <actual argument>

int x = 2; int y = 3; int x = 2;

int num = min (x, y); int y = 3;
int num1 = x;
static int num( int num1, int num2) int num2 = y;
{ } { }
 Call-By-Value and
Call-By-Reference in Java
If a formal argument is not a primitive data type, an operation on the formal argument can change the actual
argument
this is call by reference
This is because variables of object type contain pointers to the data that represents the object
Since procedure call triggers an assignment
<formal argument> = <actual argument>
it is the pointer that is copied, not the object itself!

MyClass x = new MyClass(); x = new MC();

MyClass y = new MyClass(); y = new MC();
MyClass.swap( x, y);
x1 = x;

static void swap( MyClass x1, MyClass x2)
x2 = y;
{ } { }
 Function prototype: is also called a
function definition or Header.It contains ,
access specifiers, return type, name of the
function and parameter(s) or arguments.
Eg:
public static int printsum(int a , int b)
{
Int c= a+b; ( function Header/ prototype)
return c;
}
 Function Signature: contains
function name and order and
type of parameters.
Eg:
public void sum( int a , float b)

This is function signature.

 Classes define Objects
In object-oriented design, we group methods together according
to objects on which they operate
An object has:
state - descriptive characteristics
behaviors - what it can do (or be done to it), may depend on the state, and
can change the state

For example, a calendar program needs Month objects:

the state of a Month object is a (month,year) pair of numbers
these are stored as instance variables of the Month class
the Month class can also have class variables, e.g. the day of the week that
Jan 1, 2000 falls on
some behaviors of a month object are:
get name, get first weekday, get number of days,
print
set month index, set year

34
 Defining Classes
A class contains data declarations (state)
and method declarations (behaviors)
class Month
int month;
int year Data declarations

Method declarations
 Method Overloading
A class may define multiple methods with the same
name-, but different parameters ,this is called method
overloading
usually perform the same task on different data types

Example: The PrintStream class defines multiple println

methods, i.e., println is overloaded:
println (String s)
println (int i)
println (double d)

The following lines use the System.out.print method for
different data types:
System.out.println ("The total is:");
double total = 0;
System.out.println (total); 36
 Method Overloading: Signature
The compiler must be able to determine which
version of the method is being invoked
This is by analyzing the parameters, which form the
signature of a method
the signature includes the type and order of the
parameters
if multiple methods match a method call, the compiler picks the
best match
if none matches exactly but some implicit conversion can be done
to match a method, then the method is invoke with implicit
conversion.
the return type of the method is not part of the signature
37
For Example: --
void sum(int a , int b)
void sum(float a , float b)
void sum(double a , double b)
void sum( float a , double b)
In the above examples function name is
same i.e sum but parameter list is
different in all the functions, thus it is
implementing function overloading.
 Method Overloading
Version 1 Version 2

double tryMe (int x) double tryMe (int x, double y)

{ {
return x + .375; return x * y;
} }

Invocation

result = tryMe (25, 4.32)

Function/Method Overloading
Version 1 Version 2

double tryMe (int x) double tryMe (int x, double y)

{ {
return x + .375; return x * y;
} }

Invocation

result = tryMe (25) // because int data type

 There can be various types of methods
(behavior declarations)
access methods : read or display states (or
those that can be derived)
predicate methods : test the truth of some
conditions
action methods, e.g., print
constructors: is a special member function
of the class which is used to initialize the
object of the class.
Properties:
- they have the same name as the class
- there may be more then one constructor per class
(overloaded constructors)
- they do not return any value
- it has no return type, not even void
- they initialize objects of the class, using the new
construct:
e.g. stu ob = new stu( );

( you do not have to define a default constructor

the value of the state variables have default value, but if asked in the question then
defined default constructor )
 Constructor Overloading
When more than one constructor is used in program , is called
constructor overloading.
Class hello
{
int x , y;
Hello()
{ x=0; y =0;
}
Hello( int a , int b)
{
x=a;
y=b;
}