Methods और Recursion

Reusable Blocks of Code

💡 Method एक reusable machine जैसा है — एक बार बना लो, जब भी ज़रूरत हो बस "call" करो, वही काम हो जाएगा। Recursion एक machine है जो ख़ुद अपने आप को दोबारा call करती है, जब तक stop ना हो।

Method parameters लेता है, काम करता है, और (चाहे तो) एक value return करता है — इससे code repeat नहीं करना पड़ता।

Java "pass by value" follow करता है — method को values की copy मिलती है, original variable change नहीं होता (objects के case में reference की copy मिलती है)।

Recursion में एक method ख़ुद को call करता है — जैसे factorial(5) = 5 * factorial(4)... जब तक base case (factorial(1)=1) ना आए।

int factorial(int n) {
  if (n <= 1) return 1;
  return n * factorial(n - 1);
}

🧩

Method एक reusable machine जैसा है — एक बार बना लो, जब भी ज़रूरत हो बस "call" करो, वही काम हो जाएगा। Recursion एक machine है जो ख़ुद अपने आप को दोबारा call करती है, जब तक stop ना हो।

1 / 6

⚡ झट से Recap

Method = reusable code block
Pass by value — copy मिलती है
Recursion = method ख़ुद को call करता है

इस page में (4 subtopics)

Method signature उसका नाम + parameter types/order होता है (return type signature का part नहीं होता — इसी वजह से दो methods सिर्फ़ return type से differ नहीं कर सकते, overloading के लिए parameters ही differ करने चाहिए)।

void मतलब method कुछ return नहीं करता। अगर method कुछ return करता है (जैसे int, String, या कोई object), तो return statement ज़रूरी है हर possible code path में — compiler check करता है कि कोई भी path बिना return के method ख़त्म ना हो जाए, वरना "missing return statement" error।

💡Tip: Method नाम action-based रखो (calculateTotal, isValid, getName) — ये code को self-documenting बनाता है, comments की ज़रूरत कम पड़ती है।

... (three dots) से एक method variable number of arguments ले सकता है — internally ये एक array की तरह treat होता है method के अंदर। Caller flexibility से 0, 1, या जितने चाहो उतने arguments दे सकता है।

एक method में सिर्फ़ एक varargs parameter हो सकता है, और वो हमेशा सबसे *last* parameter होना चाहिए (अगर और normal parameters भी हैं)। System.out.printf() और String.format() जैसे built-in methods varargs ही use करते हैं।

int sum(int... nums) {
  int total = 0;
  for (int n : nums) total += n;
  return total;
}
sum(1, 2, 3);       // works
sum(1, 2, 3, 4, 5); // works bhi
sum();               // works, total = 0

Java हमेशा pass-by-value है, चाहे primitive हो या object — ये एक बहुत common interview trick question है। Primitive के case में value की copy मिलती है (original change नहीं होता, method के अंदर कुछ भी करो)।

Object के case में "reference" (heap address) की copy मिलती है — मतलब दोनों (original variable और parameter) एक ही object को point करते हैं। इसलिए object के अंदर के fields change कर सकते हो (दिखेगा बाहर भी), लेकिन अगर तुम parameter को नए object से reassign करो (s = new Student()), तो सिर्फ़ local copy update होती है — original reference change नहीं होता।

void modify(Student s) {
  s.name = "Changed";   // ye dikhega original object mein (same reference)
  s = new Student();    // ye NAHI dikhega — sirf local copy reassign hui
}

⚠️Common Mistake: "Java pass-by-reference है" कहना ग़लत है! Java हमेशा pass-by-value है — object के case में "reference की value" pass होती है, जो अलग चीज़ है। ये distinction interviews में बार-बार पूछा जाता है।

Factorial और Fibonacci classic recursion examples हैं। हर recursive method में दो चीज़ें ज़रूरी हैं: base case (जहाँ recursion रुके) और recursive case (जो problem को छोटा करके ख़ुद को call करे)।

बिना base case के method infinite बार ख़ुद को call करता रहेगा, जब तक StackOverflowError ना आ जाए — हर recursive call एक "stack frame" लेता है, और JVM का call stack fixed size का होता है।

Fibonacci का naive recursive version (जैसा नीचे है) बहुत inefficient है बड़े n के लिए — क्योंकि same values बार-बार calculate होती हैं (fibonacci(5) दो बार fibonacci(3) calculate करता है)। इसको fix करने के तरीक़े हैं "memoization" (results cache करना) या iterative approach।

int factorial(int n) {
  if (n <= 1) return 1;               // base case
  return n * factorial(n - 1);        // recursive case
}

int fibonacci(int n) {
  if (n <= 1) return n;
  return fibonacci(n-1) + fibonacci(n-2);
}

💡Tip: जब भी recursive method लिखो, पहले base case सोचो, फिर recursive case। "Base case पहले" ये habit तुम्हे infinite recursion bugs से बचाएगी।

← पिछला🔄 Type Casting और Wrapper Classes अगला →🔀 switch, break और continue

Code10x

Methods और Recursion

Method Signature और Return Types

Varargs — Flexible Arguments

Pass by Value — Deep Dive

Recursion Examples