Methods & Recursion
Method parameters leta hai, kaam karta hai, aur (chahe to) ek value return karta hai — isse code repeat nahi karna padta.
Java "pass by value" follow karta hai — method ko values ki copy milti hai, original variable change nahi hota (objects ke case mein reference ki copy milti hai).
Recursion mein ek method khud ko call karta hai — jaise factorial(5) = 5 * factorial(4)... jab tak base case (factorial(1)=1) na aaye.
int factorial(int n) {
if (n <= 1) return 1;
return n * factorial(n - 1);
}Method signature uska naam + parameter types/order hota hai (return type signature ka part NAHI hota — isi wajah se do methods sirf return type se differ nahi kar sakte, overloading ke liye parameters hi differ karne chahiye).
void matlab method kuch return nahi karta. Agar method kuch return karta hai (jaise int, String, ya koi object), to return statement zaroori hai har possible code path mein — compiler check karta hai ki koi bhi path bina return ke method khatam na ho jaaye, warna "missing return statement" error.
... (three dots) se ek method variable number of arguments le sakta hai — internally ye ek array ki tarah treat hota hai method ke andar. Caller flexibility se 0, 1, ya jitne chaho utne arguments de sakta hai.
Ek method mein sirf ek varargs parameter ho sakta hai, aur wo hamesha sabse *last* parameter hona chahiye (agar aur normal parameters bhi hain). System.out.printf() aur String.format() jaise built-in methods varargs hi use karte hain.
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 = 0Java hamesha pass-by-value hai, chahe primitive ho ya object — ye ek bahut common interview trick question hai. Primitive ke case mein value ki copy milti hai (original change nahi hota, method ke andar kuch bhi karo).
Object ke case mein "reference" (heap address) ki copy milti hai — matlab dono (original variable aur parameter) ek hi object ko point karte hain. Isliye object ke andar ke fields change kar sakte ho (dikhega bahar bhi), lekin agar tum parameter ko naye object se reassign karo (s = new Student()), to sirf local copy update hoti hai — original reference change nahi hota.
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
}Factorial aur Fibonacci classic recursion examples hain. Har recursive method mein do cheezein zaroori hain: base case (jaha recursion ruke) aur recursive case (jo problem ko chhota karke khud ko call kare).
Bina base case ke method infinite baar khud ko call karta rahega, jab tak StackOverflowError na aa jaaye — har recursive call ek "stack frame" leta hai, aur JVM ka call stack fixed size ka hota hai.
Fibonacci ka naive recursive version (jaisa niche hai) bahut inefficient hai bade n ke liye — kyunki same values baar-baar calculate hoti hain (fibonacci(5) do baar fibonacci(3) calculate karta hai). Isko fix karne ke tareeke hain "memoization" (results cache karna) ya 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);
}