User-defined methods

Modularisation – process of dividing longer and complex programs into a number of smaller units

A Method – a named block of code in a class, containing a set of instructions to be executed

*Improves the readability of code

*Can be reused as many times as wanted ( provides reusability feature )

*Reduces the complexity of the program

*Makes the program easy to troubleshoot

Method/procedure/function/module/subroutine/sub-program

Types of Methods –

System-defined Methods: predefined in java, cannot be modified, e.g. – sqrt() , round() of Math class

User-defined Methods: defined by the programmer, can be modified, e.g. – main()

Access Modifiers or Access Specifiers: if not present = default

Specify the scope of access or accessibility of a method (or a class, variable, constructor)

‘public’ – widest scope of access – least security

Can be accessed from – anywhere

Inside the class

Outside the class but inside the same package

Outside the class, outside the package, from a sub class (inheritance)

Outside the class, outside the package

‘protected’ –

Can be accessed from –

Inside the same class

Outside the class but inside the same package

Outside the class, outside the package but form a sub class

default –

Can be accessed from –

Inside the same class

Outside the class but inside the same package

Can be accessed from –

Inside the same class only

Non-Access Modifiers: may or may not be present

Do not define the scope of access of methods but give special properties to them

e.g. – ‘final’, ‘static’, ‘abstract’, ‘synchronised’, ‘transient’, ‘native’ and ‘volatile’

final – cannot be overridden

static – can be called without using an object

Return Type:

Specifies what type of data is to be returned by a method on a method call

Can be any of the 8 primitive data types or ‘void’

void – no value to be returned by the method

‘return’ statement is given at the end of the method block

Each method can have only one ‘return’ statement

If more than 1 => 1st one is accepted and executed

Method Name: the unique name given to a method,

must correspond to the method’s functionality (guideline)

Parameter List: a list of comma-separated variables enclosed within the parentheses of a method

Method Body: block of statement enclosed within curly brackets

Method Prototype or Header: the entire 1st line of the method definition

Method Signature: The method name along with the parameter list in a method prototype

Parameters provide a mechanism for passing data items to methods

Actual Parameters – (arguments)

Parameters which appear in the method call or method reference ( generally in the main() method )

They pass data to Formal Parameters

Parameters which appear in the method prototype or method definition

They receive data from Actual Parameters

A method doesn’t get executed until it is invoked or called

Methods can be invoked or called in two ways –

1. Call by Value or Pass by Value – Normal Calling

*A copy of the Actual Parameters is passed to the Formal Parameters

*Any change made in the Formal Parameters is not reflected in the Actual Parameters

*All the primitive data types (int,byte,short,char,double,etc.) are passed by value

2. Call by Reference or Pass by Reference –

*The reference of the Actual Parameters is passed to the Formal Parameters

*Any change made in the Formal Parameters is reflected in the Actual Parameters

*NonPrimitive data types like objects,Strings,interfaces,classes,enum,arrays are passed by reference

1. Pure Methods –

*On returning a value to their caller method, they do not change the original state of an object

*Always give the same result on passing the same arguments

*Do not cause unwanted side effects

e.g. – Math.sin(), Math.round(), etc.

2. Impure Methods –

*On returning a value to their caller method, they may change the original state of an object

*May give different results on passing the same arguments

*May cause some unwanted side effects

e.g. – Math.random(), System.out.println(), etc.

*Can access only static variables and not instance variable(non-static variables)

*Uses compile time binding or early binding

*Occupies less memory and memory allocation happens only once

*Declared using the keyword ‘static’

*Can be invoked without the use of an instance, can be called by class name also and even without
that

2. Non-Static Method –

*Can access both static and non-static variables

*Uses run time or dynamic binding

*May occupy more memory and memory allocation happens when it is called and it is deallocated
later

*Declared without using any special keyword

*Can only be invoked with the use of an object/instance

Method Overloading (POLYMORPHISM) –

The concept of using the same method name multiple times with different sets of parameters

It is by virtue of Method Overloading that Java implements polymorphism

* Implements polymorphism

* Reduces the number of comparisons in a program

* Increases the readability of the program

* Makes the program run faster

Determining Method Overloading –

If a method’s signature matches that of a prior method, that method is considered a redeclaration

If the return type of the two methods differs but signatures are similar => syntax error
Method Overloading => only if – Method Name is same and –

Type of parameters differ

Or

Number of parameters differ

Or

Both

Even if a method lacks ‘main’ method but has static method, the static method can be executed
smoothly