1. Methods(Methods)
Methods, Command Line Arguments, Aliasing and Recursion

2. Introduction
 Method is a part of class
 Contains particular set of instructions
 One method in one class of program
 Main Method
 Classes can contain many methods
 A method should perform a single well defined task
 Two parts to be done in a program
 Declare and Define a method
 Call a Method
 Program jumps to execute instructions written in program and after
executing them in sequential manner, comes back to the calling
instruction

3. Introduction
 Have you ever invoke (call) a method?
Scanner sc = new Scanner(System.in);
int x = sc.nextInt();
System.out.println(“Hello”);

4. Method definition

5. Method concept

6. Methods – Without Arguments
public class xyz
{
public static void main(String[] args)
{
foo(); // Method call
}
static void foo() // Method definition
{ // start of Method body
System.out.println("Hello World");
// Method body
}// end of Method body
}

7. Methods – With Arguments
public class xyz
{
public static void main(String[] args)
{
int x;
x=15;
foo(x); // passing x as parameter
}
static void foo(int a) // creating a alias of x
{
System.out.println("value is: "+a);
}
}

8. Methods – with multiple arguments
public class xyz
{
public static void main(String[] args)
{
int x = 15, y= 20;
double z= 20.5;
foo(x, y, z);
}
static void foo(int a, int y, double c)
{
System.out.println("x or a: "+a);
System.out.println("y: "+y);
System.out.println("z or c:"+c);
}
}

9. Methods with shared data
public class xyz
{
static int z= 20; // shared by all Methods of class xyz
public static void main(String[] args)
{
int x;
x=15;
foo(x);
System.out.println("Z=: "+z);
}
static void foo(int a)
{
System.out.println("value is: "+a);
System.out.println("value is: "+z);
}
}

10. Methods – return Value
public class xyz
{
public static void main(String[] args)
{
int x = 15, y= 20;
int result = foo(x, y); //outcome is received in variable
System.out.println("result is: "+result);
}
static int foo(int a, int b) // data type of return is defined
{
int sum;
sum= a+b;
return sum; // return a variable or value
}
}

11. The type of the expression in the
return statement must match the
return type in the Method header.

12. • Formal parameters are variables that are
declared in the header of the Method
definition.
• Actual parameters are the expressions in
the calling statement.
• The formal and actual parameters must
match exactly in type, order, and number.
Their names, however, do not need to be
the same.

13. It is the nature of the task to be
performed, not the amount of code,
that determines if a Method
should be used.

14. Variables are in scope from their point
of definition until the end of their
Method or block.

15. ACCESSING Method Defined in some other
class
CLASS A CLASS B
class ABC public class B
{ {
static void func1() public static void main(String[] args)
{ {
System.out.println(“hello”); ABC a1 = new ABC();
} a1.func1();
} }
}

16. class ABC
{
static void func1()
{
System.out.println("Hello");
}
}
public class xyz
{
public static void main(String[] args)
{
ABC a1 = new ABC();
a1.func1();
}
}

17. Command-Line Arguments

18. Command-Line Arguments
 A Java application can accept any number of arguments
from the command line.
 This allows the user to specify configuration information
when the application is launched.
 The user enters command-line arguments when invoking
the application and specifies them after the name of the
class to be run
 While running the program any things written after the
name of the class are the command line arguments.
 Arguments are delimited by the space.

19. String Command-Line Arguments
public class Echo
{
public static void main (String[] args)
{
for (String s: args)
{
System.out.println(s);
}
}
}
javac Echo.java
java Echo Hello to the World
Output:

20. String Command-Line Arguments
public class Echo
{
public static void main (String[] args)
{
for (int i=0; i<args.length; i++)
{
System.out.println(args[i]);
}
}
}
javac Echo.java
java Echo Hello to the World
Output:

21. Integer Command-Line Arguments
public class Echo
{
public static void main (String[] args)
{
int argument;
for (int i=0; i<args.length; i++)
{
argument = Integer.parseInt(args[i]);
System.out.println(argument);
}
}
}
javac Echo.java

22. RecuRsion

23. Factorial (3) recursively

24. Fibonacci numbers

25. Every recursive call must either solve
part of the problem or reduce the size
of the problem.

26. Towers of Hanoi—start position

27. Towers solution for two disks

28. Towers solution for three disks

29. Towers solution for three disks (continued)

30. Recursive program of factorial
public class recursive
{
public static void main (String[] args)
{
int n=5;
int factorial=fact(n);
System.out.println("factorial is: "+factorial);
}
static int fact(int number)
{
if(number == 1)
{
return 1;
}
else
{
return (number * fact(number-1));//self calling Methods
}
}
}