Skip to main content

Methods

✔ Definition​

  • A method provides the functionality / operation / behavior of an object

Syntax of a Method​

[modifiers]<return Type><methodName>(params) {
// Method implementation
}

✔ Notes:​

  • modifiers → optional (public, private, static, etc.)
  • returnType → mandatory
  • methodName → mandatory
  • params → optional

Types of Methods

  1. Instance Methods
  2. Static Methods

1) Instance Methods​

✔ Methods defined inside a class without using static modifier

class Hello {

  void m1() {
    // instance method
  }
}

2) Static Methods​

✔ Methods defined inside a class using static modifier

class Hello {

  static void m2() {
    // static method
  }
}

Example (Instance vs Static Method)

class Hello {

  void m1() {}

  static void m2() {}
}

Method Calls​

✔ Using Object Reference​

Hello h=new Hello();
h.m1();// VALID (instance method)
h.m2();// VALID (static method)

Using Class Name​

Hello.m1();// INVALID (instance method)
Hello.m2();// VALID (static method)

✔ Using Null Reference​

Hello h=null;
h.m1();// INVALID (instance method → runtime error)
h.m2();// VALID (static method)

Key Rules

✔ Instance Methods​

  • Must be called using object reference
  • Cannot be accessed using class name

✔ Static Methods​

Can be called in 3 ways:

  1. Using class name

    Hello.m2();

  2. Using reference variable (even if null)

    Hello h=null;
    h.m2();

  3. Using object reference

    Hello h=new Hello();
    h.m2();

🧠 Important Concept

👉 Static methods belong to class, not object

👉 Instance methods belong to object

⚡ Interview Quick Points

✔ Can we call static method using null reference?

👉 Yes

✔ Can we call instance method using class name?

👉 No

✔ Can static method be called using object?

👉 Yes (but not recommended)

Method Invocation Examples

Lab347.java​

class Lab347 {

  public static void main(String[] args) {
    Hello h = new Hello();
    h.show();
  }
}

class Hello {

  void show() {
    System.out.println("show()");
  }
}

Output:​

show()

✔ Instance method called using object → Valid

Lab348.java​

class Lab348 {

  public static void main(String[] args) {
    Hello.show();
  }
}

class Hello {

  void show() {
    System.out.println("show()");
  }
}

Result:​

  • Compilation Error

✔ Instance method cannot be called using class name

Lab349.java​

class Lab349 {

  public static void main(String[] args) {
    Hello h = null;
    h.show();
  }
}

class Hello {

  void show() {
    System.out.println("show()");
  }
}

Result:​

  • Runtime Exception (NullPointerException)

✔ Instance method needs object → null reference fails

Lab350.java​

class Lab350 {

  public static void main(String[] args) {
    Hello.show();
  }
}

class Hello {

  static void show() {
    System.out.println("show()");
  }
}

Output:​

show()

✔ Static method called using class name → Valid

Lab351.java​

class Lab351 {

  public static void main(String[] args) {
    Hello h = null;
    h.show();
  }
}

class Hello {

  static void show() {
    System.out.println("show()");
  }
}

Output:​

show()

✔ Static method works even with null reference

Lab352.java​

class Lab352 {

  public static void main(String[] args) {
    Hello h = new Hello();
    h.show();
  }
}

class Hello {

  static void show() {
    System.out.println("show()");
  }
}

Output:​

show()

✔ Static method can be called using object (but not recommended)

Summary of Concepts

ScenarioResult
Instance method via objectValid
Instance method via class nameCompile error
Instance method via nullRuntime error
Static method via class nameValid
Static method via null referenceValid
Static method via objectValid

🧠 Important Understanding

👉 Instance method → requires actual object

👉 Static method → belongs to class, not object

⚡ Interview Traps

✔ h.show() where h = null

  • Works only if method is static

✔ ClassName.method()

  • Works only if method is static

Method Examples (Continuation)

Lab353.java​

class Lab353 {

  public static void main(String[] args) {
    Hello h = new Hello();
    h.show();
  }
}

class Hello {

  int a;
  static int b;

  void show() {
    System.out.println(a);
    System.out.println(b);
  }
}

Output:​

0
0

✔ Instance method can access:

  • Instance variables (a)
  • Static variables (b)

Lab354.java​

class Lab354 {

  public static void main(String[] args) {
    Hello.show();
  }
}

class Hello {

  int a;
  static int b;

  static void show() {
    System.out.println(a);
    System.out.println(b);
  }
}

Result:​

  • Compilation Error

✔ Static method cannot access instance variable directly

Lab355.java​

class Lab355 {

  public static void main(String[] args) {
    Hello.show();
  }
}

class Hello {

  static int b;

  static void show() {
    System.out.println(b);
  }
}

Output:​

0

✔ Static method can access static variables

3.4.5.1 Methods Return Type

✔ Key Concepts​

1) Method Execution Result​

  • When a method performs an operation:
    • It may or may not produce a result

2) Ways to Use Method Result​

✔ Two ways:

  1. Use the result inside the method
  2. Return the result to the caller

3) Returning a Value​

👉 If you want to return a value:

  • You must specify a return type

Examples:

int
boolean
String

4) No Return Value​

👉 If you don’t want to return anything:

  • Use:
void

Key Rules Summary

✔ Instance method → can access both instance & static variables

✔ Static method → can access only static variables directly

✔ Return type:

  • Required when returning value
  • void when nothing is returned

🧠 Interview Quick Points

👉 Can static method access instance variable?

No (without object)

👉 Can instance method access static variable?

✔ Yes

👉 What is default value of int?

✔ 0

👉 What if no return value?

✔ Use void

Method Return Type – Examples

Lab356.java​

class Lab356 {

  public static void main(String[] args) {
    Student st = new Student();
    st.show();
  }
}

class Student {

  show() {
    //  INVALID
    System.out.println("show()");
  }
}

Result:​

  • Compilation Error

✔ Method must have a return type

Lab357.java​

class Lab357 {

  public static void main(String[] args) {
    Student st = new Student();
    st.setAge(-12);
    System.out.println(st.age);
  }
}

class Student {

  int age;

  void setAge(int age) {
    this.age = age;
  }
}

Output:​

-12

✔ void method → does not return value

✔ It updates instance variable

Lab358.java​

class Lab358 {

  public static void main(String[] args) {
    Student st = new Student();
    st.setAge(-12);
    System.out.println(st.age);
  }
}

class Student {

  int age = 18;

  void setAge(int age) {
    if (age < 18) return;
    this.age = age;
  }
}

Output:​

18

✔ return; → exits method early

✔ Age remains unchanged

Lab359.java​

class Lab359 {

  public static void main(String[] args) {
    Student st = new Student();
    st.setAge(-12);
    System.out.println(st.age);
  }
}

class Student {

  int age = 18;

  void setAge(int age) {
    if (age < 18) return 0; //  INVALID
    this.age = age;
  }
}

Result:​

  • Compilation Error

✔ Cannot return value in void method

Lab360.java​

class Lab360 {

  public static void main(String[] args) {
    Hello h = new Hello();
    int a = h.show(10);
    System.out.println(a);
  }
}

class Hello {

  int show(int x) {
    return x + 1;
  }
}

Output:​

11

✔ Method returns value → assigned to variable

Lab361.java​

class Lab361 {

  public static void main(String[] args) {
    Hello h = new Hello();
    System.out.println(h.show(10));
  }
}

class Hello {

  int show(int x) {
    return x + 1;
  }
}

Output:​

11

✔ Returned value used directly

Key Concepts

✔ Return Type Rules​

CaseResult
No return typeCompile error
void method with return;Valid
void method with return value;Error
Non-void method without returnError

✔ return Statement​

  • return; → exits method (void)
  • return value; → returns value (non-void)

🧠 Interview Quick Points

👉 Is return type mandatory?

✔ Yes

👉 Can void method return value?

No

👉 Can void method use return;?

✔ Yes

👉 What happens if return missing in non-void method?

Compile error

Lab362.java​

class Lab362 {

  public static void main(String[] args) {
    Hello h = new Hello();
    h.show(10);
    System.out.println("Hello Guys");
  }
}

class Hello {

  int show(int x) {
    return x + 1;
  }
}

Output:​

Hello Guys

✔ Return value is ignored

✔ Method executes, but result not used

Lab363.java​

class Lab363 {

  public static void main(String[] args) {
    Hello h = new Hello();
    System.out.println(h.show(10));
  }
}

class Hello {

  void show(int x) {
    System.out.println("show()");
  }
}

Result:​

  • Compilation Error

✔ Cannot use void method inside println()

Lab364.java​

class Lab364 {

  public static void main(String[] args) {
    Hello h = new Hello();
    h.show(10);
    System.out.println("Hello Guys");
  }
}

class Hello {

  int show(int x) {
    System.out.println("show()");
  }
}

Result:​

  • Compilation Error

✔ Missing return statement in non-void method

Lab365.java​

class Lab365 {

  public static void main(String[] args) {
    Hello h = new Hello();
    h.show(10);
    System.out.println("Hello Guys");
  }
}

class Hello {

  int show(int x) {
    System.out.println("show()");
    return;
  }
}

Result:​

  • Compilation Error

✔ Cannot use empty return in non-void method

Lab366.java​

class Lab366 {

  public static void main(String[] args) {
    Hello h = new Hello();
    h.show(10);
    System.out.println("Hello Guys");
  }
}

class Hello {

  int show(int x) {
    System.out.println("show()");
    return 12L;
  }
}

Result:​

  • Compilation Error

✔ Cannot return long (12L) for int method

Lab367.java​

class Lab367 {

  public static void main(String[] args) {
    Hello h = new Hello();
    System.out.println(h.show(10));
  }
}

class Hello {

  long show(int x) {
    System.out.println("show()");
    return 'A';
  }
}

Output:​

show()
65

✔ 'A' → converted to ASCII value → 65

✔ char can be promoted to long

Key Takeaways

✔ Using Return Values​

  • You can ignore return value → valid
  • You can use return value → valid

✔ Compile-Time Errors​

CaseReason
Using void in printlnNo return value
Missing return in non-voidMandatory
return; in non-voidInvalid
Wrong return typeType mismatch

✔ Type Conversion Rules​

  • char → can convert to int, long
  • long → cannot convert to int (without cast)

🧠 Interview Quick Points

👉 Can you ignore a return value?

✔ Yes

👉 Can void method be used in expression?

No

👉 Is return mandatory in non-void method?

✔ Yes

👉 Can return type be different?

Must match (or be compatible)

Lab368.java​

class Lab368 {

  public static void main(String[] args) {
    Hello h = new Hello();
    System.out.println(h.show(10));
  }
}

class Hello {

  long show(int x) {
    System.out.println("show()");
    return x + 1;
  }
}

Output:​

show()
11

✔ int → automatically promoted to long

Lab369.java​

class Lab369 {

  public static void main(String[] args) {
    Hello h = new Hello();
    System.out.println(h.show(10));
  }
}

class Hello {

  boolean show(int x) {
    System.out.println("show()");
    return true;
  }
}

Output:​

show()
true

✔ Boolean return works correctly

Lab370.java​

class Lab370 {

  public static void main(String[] args) {
    Hello h = new Hello();
    System.out.println(h.show(10));
  }
}

class Hello {

  boolean show(int x) {
    System.out.println("show()");
    return 0;
  }
}

Result:​

  • Compilation Error

✔ Cannot return int for boolean

Lab371.java​

class Lab371 {

  public static void main(String[] args) {
    Hello h = new Hello();
    System.out.println(h.show(10));
  }
}

class Hello {

  boolean show(int x) {
    System.out.println("show()");
    return false;
    return false;
  }
}

Result:​

  • Compilation Error

✔ Unreachable code (second return never executes)

Lab372.java​

class Lab372 {

  public static void main(String[] args) {
    Hello h = new Hello();
    System.out.println(h.isDigit('A'));
    System.out.println(h.isDigit('8'));
  }
}

class Hello {

  boolean isDigit(char ch) {
    System.out.println("isDigit(): " + ch);
    boolean b = ch >= 48 && ch <= 57;
    return b;
  }
}

Output:​

isDigit(): A
false
isDigit(): 8
true

✔ ASCII range check for digits (0–9 → 48 to 57)

Lab373.java​

class Lab373 {

  public static void main(String[] args) {
    Hello h = new Hello();
    System.out.println(h.isDigit('A'));
    System.out.println(h.isDigit('8'));
  }
}

class Hello {

  boolean isDigit(char ch) {
    System.out.println("isDigit(): " + ch);
    if (ch >= 48 && ch <= 57) return true;
    else return false;
  }
}

Output:​

isDigit(): A
false
isDigit(): 8
true

✔ Multiple return statements are allowed ✔ But only one executes per path

Key Takeaways

✔ Return Type Rules​

  • Must match method return type
  • Implicit widening allowed (int → long)
  • Not allowed: int → boolean

✔ Boolean Return​

  • Only true or false
  • Cannot use numeric values

✔ Return Statements​

  • Multiple returns allowed ✔
  • But unreachable code not allowed

✔ Condition-Based Return​

Two styles:

return condition;

OR

if(condition) return true;
else return false;

🧠 Interview Quick Points

👉 Can int be returned in boolean method?

No

👉 Can we have multiple return statements?

✔ Yes

👉 What is unreachable code?

Code after return

👉 Can int return into long?

✔ Yes (widening)

3.4.5.2 Method Parameters

There are two types of arguments:​

  1. Formal Arguments
  2. Actual Arguments

Formal Arguments (Parameters)​

  • Arguments specified in the method definition/declaration
  • Also called Parameters

Example:​

void show(int a,int b) {
// a, b → Formal Arguments
}

Actual Arguments​

  • Arguments specified in the method call

Example:​

Hello h=new Hello();
h.show(10,20);// 10, 20 → Actual Arguments

Lab374.java​

class Lab374 {

  public static void main(String[] args) {
    Hello h = new Hello();
    System.out.println(h.show());
  }
}

class Hello {

  int show(int x) {
    System.out.println("show()");
    return x + 1;
  }
}

Result:​

  • Compilation Error

✔ Method requires 1 parameter, but none provided

Lab375.java​

class Lab375 {

  public static void main(String[] args) {
    Hello h = new Hello();
    System.out.println(h.show(10, 20));
  }
}

class Hello {

  int show(int x) {
    System.out.println("show()");
    return x + 1;
  }
}

Result:​

  • Compilation Error

✔ Method expects 1 argument, but 2 provided

Lab376.java​

class Lab376 {

  public static void main(String[] args) {
    Hello h = new Hello();
    h.show(12);
  }
}

class Hello {

  void show(byte x) {
    System.out.println("show(byte)");
  }
}

Result:​

  • Compilation Error

✔ int (12) cannot be passed to byte parameter directly

✔ Requires explicit casting

Lab377.java​

class Lab377 {

  public static void main(String[] args) {
    Hello h = new Hello();
    byte b = 12;
    h.show(b);
  }
}

class Hello {

  void show(byte x) {
    System.out.println("show(byte)");
  }
}

Output:​

show(byte)

✔ Correct type match (byte → byte)

Key Takeaways

✔ Argument Matching Rules​

  • Number of arguments must match
  • Type of arguments must match

✔ Type Conversion​

CaseResult
byte → int✔ Allowed
int → byteNot allowed (needs cast)

✔ Errors You Must Remember​

  • Missing arguments
  • Extra arguments
  • Wrong data type

🧠 Interview Quick Points

👉 What are formal arguments?

✔ Defined in method

👉 What are actual arguments?

✔ Passed during method call

👉 Can int go into byte parameter?

No (needs casting)

👉 Must argument count match?

✔ Yes

Lab378.java​

class Lab378 {

  public static void main(String[] args) {
    Hello h = new Hello();
    h.show((byte) 12);
  }
}

class Hello {

  void show(byte x) {
    System.out.println("show(byte)");
  }
}

Output:​

show(byte)

✔ Explicit type casting (int → byte) works

Lab379.java​

class Lab379 {

  public static void main(String[] args) {
    Hello h = new Hello();
    h.show(65);
  }
}

class Hello {

  void show(char x) {
    System.out.println("show(char)");
  }
}

Result:​

  • Compilation Error

✔ int cannot be automatically converted to char

Lab380.java​

class Lab380 {

  public static void main(String[] args) {
    Hello h = new Hello();
    h.show('A');
  }
}

class Hello {

  void show(char x) {
    System.out.println("show(char)");
  }
}

Output:​

show(char)

✔ Direct char value works

Lab381.java​

class Lab381 {

  public static void main(String[] args) {
    Hello h = new Hello();
    h.show((char) 65);
  }
}

class Hello {

  void show(char x) {
    System.out.println("show(char)");
  }
}

Output:​

show(char)

✔ Explicit casting (int → char) works

3.4.5.3 Method Overloading

Definition​

You can define multiple methods in the same class with the same name but different parameters.

👉 This is called METHOD OVERLOADING

Rules of Method Overloading​

✔ Must:​

  • Method name should be same

✔ Must change parameters:​

  1. Number of parameters
  2. Type of parameters
  3. Order of parameters

❗ Important:​

  • Return type alone is NOT enough to overload a method

Lab382.java​

class Lab382 {

  public static void main(String[] args) {
    Hello h = new Hello();
    int a = h.add(10, 20);
    System.out.println(a);
    h.add(10, 20);
  }
}

class Hello {

  int add(int a, int b) {
    System.out.println("add(int,int)");
    return a + b;
  }

  void add(int a, int b) {
    System.out.println("add(int,int)");
  }
}

Result:​

  • Compilation Error

✔ Duplicate method

✔ Only return type is different → NOT valid overloading

Key Takeaways

✔ Type Casting​

CaseResult
int → byte(needs cast)
int → char(needs cast)
(byte) / (char) casting✔ allowed

✔ Method Overloading Rules​

  • Same method name ✔
  • Different parameters ✔
  • Only return type change

🧠 Interview Quick Points

👉 Can we overload methods with only return type?

No

👉 What defines method signature?

✔ Method name + parameters

👉 Is casting required for narrowing?

✔ Yes

👉 Is char compatible with int?

✔ Only with explicit cast

Lab383.java​

class Lab383 {

  public static void main(String[] args) {
    Hello h = new Hello();

    int a = h.add(10, 20);
    System.out.println(a);

    int b = h.add(10, 20, 30);
    System.out.println(b);
  }
}

class Hello {

  int add(int a, int b) {
    System.out.println("add(int,int)");
    return a + b;
  }

  int add(int a, int b, int c) {
    System.out.println("add(int,int,int)");
    return a + b + c;
  }
}

Output:​

add(int,int)
30
add(int,int,int)
60

✔ Overloading by number of parameters

Lab384.java​

class Lab384 {

  public static void main(String[] args) {
    Hello h = new Hello();

    int a = h.add(10, 20);
    System.out.println(a);

    String b = h.add("JavaWorld", 99);
    System.out.println(b);
  }
}

class Hello {

  int add(int a, int b) {
    System.out.println("add(int,int)");
    return a + b;
  }

  String add(String a, int b) {
    System.out.println("add(String,int)");
    return a + b;
  }
}

Output:​

add(int,int)
30
add(String,int)
JavaWorld99

✔ Overloading by type of parameters

Lab385.java​

class Lab385 {

  public static void main(String[] args) {
    Hello h = new Hello();

    String a = h.add(99, "JavaWorld");
    System.out.println(a);

    String b = h.add("JavaWorld", 99);
    System.out.println(b);
  }
}

class Hello {

  String add(int b, String a) {
    System.out.println("add(int,String)");
    return a + b;
  }

  String add(String a, int b) {
    System.out.println("add(String,int)");
    return a + b;
  }
}

Output:​

add(int,String)
JavaWorld99
add(String,int)
JavaWorld99

✔ Overloading by order of parameters

Lab386.java​

class Lab386 {

  public static void main(String[] args) {
    Hello h = new Hello();

    byte b = 20;
    h.add(10, b);
    h.add(b, b);
  }
}

class Hello {

  void add(int a, byte b) {
    System.out.println("add(int,byte)");
  }
}

Output:​

add(int,byte)
add(int,byte)

✔ byte → int (widening) works

✔ Both calls resolve to same method

Lab387.java​

class Lab387 {

  public static void main(String[] args) {
    Hello h = new Hello();

    byte b = 20;
    h.add(b, 10);
    h.add(b, b);
  }
}

class Hello {

  void add(byte a, int b) {
    System.out.println("add(byte,int)");
  }
}

Result:​

  • Compilation Error

✔ h.add(b, b) fails

✔ Because second byte cannot automatically match int in this context (no exact match)

Key Takeaways

✔ Method Overloading Variations​

VariationExample
Number of paramsadd(a,b) vs add(a,b,c)
Type of paramsadd(int,int) vs add(String,int)
Order of paramsadd(int,String) vs add(String,int)

✔ Type Conversion Priority​

  1. Exact match
  2. Widening (byte → int)
  3. Otherwise → Error

✔ Important Rules​

  • Compiler chooses best match
  • Automatic widening works ✔
  • Narrowing needs casting

🧠 Interview Quick Points

👉 How does Java choose overloaded method?

✔ Best match (exact > widening)

👉 Can order change method signature?

✔ Yes

👉 Is byte → int allowed?

✔ Yes

👉 Is int → byte allowed automatically?

No

Lab388.java​

class Lab388 {

  public static void main(String[] args) {
    Hello h = new Hello();
    byte b = 20;

    h.add(b, 10);
    h.add(10, b);
  }
}

class Hello {

  void add(byte a, int b) {
    System.out.println("add(byte,int)");
  }

  void add(int a, byte b) {
    System.out.println("add(int,byte)");
  }
}

Output:​

add(byte,int)
add(int,byte)

✔ Method selected based on parameter order & type

Lab389.java​

class Lab389 {

  public static void main(String[] args) {
    Hello h = new Hello();
    byte b = 20;

    h.add(b, b);
  }
}

class Hello {

  void add(byte a, int b) {
    System.out.println("add(byte,int)");
  }

  void add(int a, byte b) {
    System.out.println("add(int,byte)");
  }
}

Result:​

  • Compilation Error (Ambiguity)

✔ Both methods are possible after widening

✔ Compiler cannot decide → ambiguous call

Lab390.java​

class Lab390 {
    public static void main(String[] args) {
        Hello h=new Hello();

        h.show(null);
        h.show("JavaWorld");
        h.show(h);
    }
}

class Hello {
    void show(String str) {
        System.out.println("show(String)");
    }

    void show(Objectstr) {
        System.out.println("show(Object)");
    }
}

Output:​

show(String)
show(String)
show(Object)

✔ String is more specific than Object

✔ null prefers most specific reference type

Lab391.java​

class Lab391 {
    public static void main(String[] args) {
        Hello h=new Hello();

        h.show("JavaWorld");
        h.show(h);
    }
}

class Hello {
    void show(String str) {
        System.out.println("show(String)");
    }

    void show(Hellostr) {
        System.out.println("show(Hello)");
    }
}

Output:​

show(String)
show(Hello)

✔ Exact type match is chosen

Lab392.java​

class Lab392 {
    public static void main(String[] args) {
        Hello h=new Hello();

        h.show(null);
    }
}

class Hello {
    void show(String str) {
        System.out.println("show(String)");
    }

    void show(Hellostr) {
        System.out.println("show(Hello)");
    }
}

Result:​

  • Compilation Error (Ambiguity)

✔ null matches both String and Hello

✔ No clear "most specific" → ambiguity

Key Takeaways

✔ Ambiguity in Overloading​

Occurs when:

  • Multiple methods match equally well
  • Compiler cannot choose best method

✔ Method Selection Priority​

  1. Exact match
  2. Most specific type
  3. Widening

✔ Special Case: null​

ScenarioResult
String vs ObjectString chosen ✔
Two unrelated typesAmbiguity

🧠 Interview Quick Points

👉 What is ambiguity in Java?

✔ When compiler can't decide method

👉 Which is more specific: String or Object?

✔ String

👉 What happens with null?

✔ Chooses most specific OR gives error

👉 Can ambiguity happen with primitives?

✔ Yes (due to widening)

3.4.5.4 Recursion

✔ Recursion is the process of calling one method from itself.

Lab393.java​

class C {

  void m3(int x) {
    System.out.println("m3 Begins :" + x);
    System.out.println("m3 Ends :" + x);
  }
}

class B {

  void m2(int x) {
    System.out.println("m2 Begins :" + x);
    new C().m3(x + 10);
    System.out.println("m2 Ends :" + x);
  }
}

class A {

  void m1(int x) {
    System.out.println("m1 Begins :" + x);
    new B().m2(x + 10);
    System.out.println("m1 Ends :" + x);
  }
}

class Lab393 {

  public static void main(String[] args) {
    int x = 10;
    System.out.println("main begins :" + x);
    new A().m1(x + 10);
    System.out.println("main ends :" + x);
  }
}

Execution Flow (Call Stack Explanation)

Step-by-step calls:​

  1. main()

    x = 10
    calls m1(20)

  2. m1(20)

    calls m2(30)

  3. m2(30)

    calls m3(40)

  4. m3(40)

    executes and return s

  5. Control returns back:

    m3 → m2 → m1 → main

🧾 Output

main begins :10
m1 Begins :20
m2 Begins :30
m3 Begins :40
m3 Ends :40
m2 Ends :30
m1 Ends :20
main ends :10

🧠 Call Stack Visualization

MethodValue of x
main10
m120
m230
m340

👉 Stack grows top-down (calls)

👉 Stack shrinks bottom-up (returns)

Key Concepts

✔ Each method call creates a new stack frame

✔ Execution is Last-In-First-Out (LIFO)

✔ Control always returns to the caller

✔ Recursion uses the same stack behavior

⚠️ Important Note

👉 This example shows method chaining, not true recursion

(True recursion = method calling itself)

Example of real recursion:

void m(int x) {
  if (x == 0) return;
  System.out.println(x);
  m(x - 1);
}

Lab394.java​

class Hello {

  void m1(int x) {
    System.out.println("m1 Begins :" + x);
    if (x != 0) m1(x / 10);
    System.out.println("m1 Ends :" + x);
  }
}

class Lab394 {

  public static void main(String[] args) {
    int x = 98;
    System.out.println("main begins :" + x);
    new Hello().m1(x);
    System.out.println("main ends :" + x);
  }
}

Execution Flow

Initial call:​

main → m1(98)

Recursive calls:​

m1(98)
 → m1(9)
   → m1(0)

Return phase:​

m1(0) return s
m1(9) return s
m1(98) return s
main ends

🧾 Output

main begins :98
m1 Begins :98
m1 Begins :9
m1 Begins :0
m1 Ends :0
m1 Ends :9
m1 Ends :98
main ends :98

🧠 Stack Behavior

Call Stack (Top → Bottom during execution)​

Method CallValue of x
m10
m19
m198
main98

✔ Calls go downward (stack grows)

✔ Returns go upward (stack shrinks)

Key Concept

✔ Base Condition​

if (x!=0)
  • Stops recursion when x == 0

✔ Recursive Step​

m1(x/10);
  • Reduces problem size (98 → 9 → 0)

⚠️ Important Note

👉 If the condition was missing:

m1(x/10);

It would cause StackOverflowError

💡 Insight

This program:

  • Breaks a number digit by digit
  • Shows how recursion unwinds (reverse order execution)

Lab395.java​

class Hello {

  long factorial(int n) {
    if (n == 0 || n == 1) return 1;
    else return n * factorial(n - 1);
  }
}

class Lab395 {

  public static void main(String[] args) {
    Hello h = new Hello();
    int n = 4;
    long fac = h.factorial(n);
    System.out.println("Factorial is : " + fac);
  }
}

Execution Flow (Recursive Calls)

Calls:​

factorial(4)
 → 4 * factorial(3)
     → 3 * factorial(2)
         → 2 * factorial(1)
             → 1 (base case)

🔁 Return Phase (Unwinding)

factorial(1) = 1
factorial(2) = 2 * 1 = 2
factorial(3) = 3 * 2 = 6
factorial(4) = 4 * 6 = 24

🧾 Output

Factorial is : 24

🧠 Call Stack Visualization

Call Leveln value
factorial4
factorial3
factorial2
factorial1

✔ Stack grows while calling

✔ Stack shrinks while returning

Key Concepts

✔ Base Condition​

if (n==0||n==1)
return1;

✔ Recursive Case​

return n*factorial(n-1);

⚠️ Important Notes

  • Without base condition → StackOverflowError
  • Each recursive call creates a new stack frame
  • Execution follows LIFO (Last In First Out)

💡 Insight

👉 This is a classic recursion problem used in:

  • Interviews
  • Algorithm design
  • Understanding stack behavior

3.4.5.5 Call by Value / Call by Reference

🔹 Call by Value​

✔ When you invoke a method by passing primitive data types, it is called CALL BY VALUE.

✔ In call by value:

  • Changes made inside the called method will NOT affect the original value in the caller method.
Lab396.java​
class Lab396 {

  public static void main(String[] args) {
    int a = 99;
    Hello h = new Hello();

    System.out.println("main begin : " + a);
    h.m1(a);
    System.out.println("main ends : " + a);
  }
}

class Hello {

  void m1(int a) {
    System.out.println("m1 begin : " + a);
    a = a + 10;
    System.out.println("m1 ends : " + a);
  }
}

Output​

main begin : 99
m1 begin : 99
m1 ends : 109
main ends : 99

👉 Original value not changed → because of call by value

🔹 Call by Reference​

✔ When you invoke a method by passing reference types (objects), it is called CALL BY REFERENCE (conceptually in Java).

✔ Behavior:​

  1. Modifying object properties
    • Changes ARE reflected in caller
  2. Modifying reference itself
    • Changes ARE NOT reflected in caller
Lab397.java​
class Lab397 {
    public static void main(String[] args) {
        Hai hai=new Hai();
        hai.a=99;

        Hello hello=new Hello();

        System.out.println("main begin : "+hai.a);
        hello.m1(hai);
        System.out.println("main ends : "+hai.a);
    }
}

class Hello {
    void m1(Haihai) {
        System.out.println("m1 begin : "+hai.a);
        hai.a=hai.a+10;
        System.out.println("m1 ends : "+hai.a);
    }
}

class Hai {
    int a;
}

Output​

main begin : 99
m1 begin : 99
m1 ends : 109
main ends : 109

👉 Object property changed globally → behaves like reference sharing

🧠 Important Interview Insight

👉 Java is strictly Call by Value

  • For primitives → value copied
  • For objects → reference value copied (not actual object)

✔ That’s why:

  • You can modify object state
  • But cannot change the reference itself

Quick Comparison

FeatureCall by ValueCall by Reference (Java behavior)
Data TypePrimitiveObject
Value ChangeNot reflectedReflected
Reference ChangeNot applicableNot reflected

Lab398.java​

class Lab398 {
    public static void main(String[] args) {
        Hai hai=new Hai();
        hai.a=99;

        Hello hello=new Hello();

        System.out.println("main begin : "+hai.a);
        hello.m1(hai);
        System.out.println("main ends : "+hai.a);
    }
}

class Hello {
    void m1(Haihai) {
        System.out.println("m1 begin : "+hai.a);

        hai=new Hai();// new object created
        hai.a=hai.a+10;// default value 0 + 10 = 10

        System.out.println("m1 ends : "+hai.a);
    }
}

class Hai {
    int a;
}

Output​

main begin : 99
m1 begin : 99
m1 ends : 10
main ends : 99

🧠 Concept Explained​

👉 Inside method:

hai=new Hai();
  • A new object is created
  • Reference is changed locally only

👉 So:

  • Original object in main() remains unchanged
  • Changes inside method are NOT reflected

✔ This proves:

Java passes reference value (copy), not actual reference

🔹 3.4.5.6 Var-Args (Variable Arguments)

✔ What is Var-Args?​

  • Introduced in Java 5
  • Used when a method needs to accept multiple values of same type

🔁 Before Var-Args (Traditional Approaches)​

1. Method Overloading​

class Hello {
void sum(int a,int b) { }
void sum(int a,int b,int c) { }
void sum(int a,int b,int c,int d) { }
}

2. Using Array​

class Hello {
void sum(int[]arr) { }
}

👉 These approaches become complex and less flexible

✔ Using Var-Args​

✔ Advantage:​

  • Accepts any number of arguments
  • Cleaner and flexible

🧾 Syntax​

<return Type><methodName>(<dataType>fixedArg,<dataType>...varArgs) {
// method body
}

Examples​

void sum(int...values) { }

void sum(String str,int...values) { }

Key Rules​

✔ Var-args must be last parameter

✔ Only one var-args allowed per method

✔ Internally treated as an array

💡 Example Usage​

void sum(int... values) {
  int total = 0;
  for (int v : values) {
    total += v;
  }
  System.out.println(total);
}

Call:

sum(10,20);
sum(10,20,30,40);

⚠️ Important Insight

👉 Var-args = syntactic sugar over arrays

sum(1,2,3)

👉 internally becomes:

sum(new int[]{1,2,3})

Lab399.java​

class Lab399 {

  public static void main(String[] args) {
    Hello h = new Hello();
    h.sum(12, 23);
  }
}

class Hello {

  void sum(int a, int b) {
    System.out.println("-- sum(int,int) --");
    System.out.println(a + b);
  }
}

Output​

-- sum(int,int) --
35

Lab400.java​

class Lab400 {

  public static void main(String[] args) {
    Hello h = new Hello();
    h.sum(12, 23);
    h.sum(12, 32, 43);
  }
}

class Hello {

  void sum(int a, int b) {
    System.out.println("-- sum(int,int) --");
    System.out.println(a + b);
  }

  void sum(int a, int b, int c) {
    System.out.println("-- sum(int,int,int) --");
    System.out.println(a + b + c);
  }
}

Lab401.java​

class Lab401 {

  public static void main(String[] args) {
    Hello h = new Hello();

    h.sum(new int[0]);
    h.sum(new int[] { 12, 34, 54 });
    h.sum(new int[] { 10, 20, 50, 30 });

    // Not allowed directly:
    // h.sum(12, 34, 54);
    // h.sum(10, 20, 50, 30);
  }
}

class Hello {

  void sum(int arr[]) {
    System.out.println("-- sum(int[]) --");
    System.out.println("Length : " + arr.length);

    int s = 0;
    for (int a : arr) {
      s = s + a;
    }

    System.out.println("Sum is : " + s);
  }
}

Lab402.java​

class Lab402 {

  public static void main(String[] args) {
    Hello h = new Hello();

    h.sum(new int[0]);
    h.sum(new int[] { 12, 34, 54 });
    h.sum(new int[] { 10, 20, 50, 30 });

    h.sum(); // allowed
    h.sum(12, 34, 54); // allowed
    h.sum(10, 20, 50, 30); // allowed
  }
}

class Hello {

  void sum(int... arr) {
    System.out.println("-- sum(int...) --");
    System.out.println("Length : " + arr.length);

    int s = 0;
    for (int a : arr) {
      s = s + a;
    }

    System.out.println("Sum is : " + s);
  }
}

🧠 Concept Summary

🔹 Array Parameter​

  • Must pass array explicitly
sum(new int[]{1,2,3});
  • Cannot pass values directly

🔹 Var-Args​

  • Flexible input
sum(1,2,3);
sum();
  • ✔ Accepts zero or more values
  • Internally treated as array

Key Differences

FeatureArray ParameterVar-Args
Syntaxint[] arrint... arr
Call styleNeed arrayDirect values allowed
FlexibilityLessMore
Zero argumentsNot allowed✔ Allowed

💡 Important Insight

👉 Var-args makes method calls cleaner and more readable

Instead of:

sum(new int[]{10,20,30});

You can write:

sum(10,20,30);

Lab403.java​

class Lab403 {

  public static void main(String[] args) {
    Hello h = new Hello();
    h.show();
  }
}

class Hello {

  void show(int a, int... arr) {
    System.out.println("\nshow(int,int...)");
  }
}

Lab404.java​

class Lab404 {

  public static void main(String[] args) {
    Hello h = new Hello();
    h.show(10);
    h.show(10, 20);
    h.show(10, 20, 30);
  }
}

class Hello {

  void show(int a, int... arr) {
    System.out.println("\nshow(int,int...)");
  }
}

Lab405.java​

class Lab405 {

  public static void main(String[] args) {
    Hello h = new Hello();
    h.m1(); //  Ambiguity
  }
}

class Hello {

  void m1(int... a) {
    System.out.println("m1(int...)");
  }

  void m1(String... a) {
    System.out.println("m1(String...)");
  }
}

⚠️ Result:​

  • Compilation Error → Ambiguous method call
  • Because no arguments → both methods match

Lab406.java​

class Lab406 {

  public static void main(String[] args) {
    Hello h = new Hello();
    h.show(10);
  }
}

class Hello {

  void show(int... arr1, int... arr2) {
    //  INVALID
    System.out.println("\nshow(int...,int...)");
  }
}

Rule:​

  • Only one var-args parameter allowed
  • It must be last parameter

Lab407.java​

class Lab407 {

  public static void main(String[] args) {
    Hello h = new Hello();
    h.show(10);
  }
}

class Hello {

  void show(int... arr1) {
    System.out.println("\nshow(int...)");
  }

  void show(int[] arr1) {
    System.out.println("\nshow(int[])");
  }
}

⚠️ Result:​

  • Compilation Error → Duplicate method
  • Because: 
    int...  ≡int[]

🧠 Concept Summary

🔹 1. Var-Args with Fixed Parameter​

void show(int a,int...arr)

✔ First argument mandatory

✔ Remaining optional

🔹 2. Allowed Calls​

show(10);
show(10,20);
show(10,20,30);

🔹 3. Ambiguity Problem​

m1(int...)
m1(String...)
m1();//  ambiguous

🔹 4. Restrictions​

  • Only one var-args allowed
  • Must be last parameter
  • Cannot overload with array of same type

Interview Tips

👉 int... is internally treated as int[]

👉 Var-args improves readability but can create ambiguity

👉 Always avoid overloading with multiple var-args

Lab408.java​

class Lab408 {

  public static void main(String[] args) {
    Hello h = new Hello();
    h.show(10); //  Cannot pass single int directly
  }
}

class Hello {

  void show(int[]... arr) {
    System.out.println("\nshow(int[]...)");
  }
}

Note:​

  • int[]... means var-args of arrays (2D concept)
  • You cannot pass a single int
  • You must pass arrays

Lab409.java​

class Lab409 {

  public static void main(String[] args) {
    Hello h = new Hello();
    h.show();

    int arr1[] = new int[] { 10 };
    int arr2[] = new int[] { 20, 30, 12 };

    h.show(arr1, arr2); //  Valid
  }
}

class Hello {

  void show(int[]... arr) {
    System.out.println("\nshow(int[]...)");
  }
}

Valid Usage:​

  • Passing multiple arrays
  • Passing zero arguments also allowed