User-defined Methods

Why Decompose Programs into Methods?

In software engineering, monolithic programs where all code resides inside a single main() method suffer from poor readability, high bug density, and zero reusability. User-defined methods resolve these bottlenecks by embodying the principle of Modularity (divide and conquer).

• Code Reusability: Write logic once (e.g., tax calculation, prime number check) and invoke it thousands of times with different inputs.
• Abstraction & Information Hiding: Callers use a method by knowing what it does without needing to inspect how it accomplishes the task internally.
• Manageability & Debugging: Isolating logic into discrete methods enables targeted unit testing, rapid error localization, and clean code maintenance.

The Complete Anatomy of a Method Header:

public static int calculateGCD(int a, int b) { ... }

Actual vs Formal Parameters:

In method communication, data travels from the caller to the callee across two distinct parameter representations:

• Actual Parameters (Arguments): The concrete expressions, variables, or literal constants supplied inside parentheses at the point of method invocation (e.g., in int res = obj.add(x, 25);, x and 25 are actual parameters).
• Formal Parameters: The placeholder variables declared in the method definition header that receive incoming data (e.g., in public int add(int num1, int num2), num1 and num2 are formal parameters).

The Universal Truth: Java is Strictly 'Pass-by-Value':

A classic misconception among students is that Java supports both pass-by-value and pass-by-reference. In reality, Java passes EVERYTHING by value. However, the value passed differs fundamentally between primitives and reference types:

void swap(int x, int y) {
    int temp = x; x = y; y = temp;
}
// Caller: int a = 5, b = 10;
// swap(a, b);
// Output: a remains 5, b remains 10!

void mutate(int[] arr) {
    arr[0] = 999;
}
// Caller: int[] nums = {10, 20};
// mutate(nums);
// Output: nums[0] becomes 999!

Pure Methods vs Impure Methods:

Rules Governing the 'return' Statement in Java:

1. Immediate Transfer of Control: When a return statement executes, the method terminates immediately, popping its frame off the Call Stack and returning control to the caller.
2. Type Compatibility: The data type of the expression following return must match or be implicitly convertible to the declared return type in the method header (e.g., returning an int in a method declared to return double is valid due to widening).
3. Unreachable Code Error: Any statement written immediately after an unconditional return causes a fatal compile-time error: "unreachable code".
4. Multiple Conditional Returns: A method may contain multiple return statements within conditional branches (if-else), but EVERY possible execution path must guarantee a return value, or compilation fails with "missing return statement".
5. Void Methods: In methods declared with a void return type, a bare return; statement without an expression is legal and used for early exit.

Rules of Method Overloading:

Method Overloading is a mechanism allowing a class to declare multiple methods sharing the exact same name, provided their parameter lists are distinct. It is an implementation of Compile-Time (Static) Polymorphism because the compiler resolves which method to invoke during compilation based on the argument list.

Three Valid Methods of Varying Method Signatures:

int compute(int x) { return x * 2; }
double compute(int x) { return x * 2.0; } // COMPILE ERROR: method already defined!

Model Program 1: Overloaded Polygon Drawing Class

public class OverloadedPolygon {

    // 1. Overloaded method: draws a square of character ch of size n x n
    public void polygon(int n, char ch) {
        System.out.println("Polygon Type 1: Square of " + n + "x" + n + " using '" + ch + "':");
        for (int i = 1; i <= n; i++) {
            for (int j = 1; j <= n; j++) {
                System.out.print(ch + " ");
            }
            System.out.println();
        }
    }

    // 2. Overloaded method: draws a rectangle of size x by y using '@'
    public void polygon(int x, int y) {
        System.out.println("Polygon Type 2: Rectangle of " + x + " rows x " + y + " columns:");
        for (int i = 1; i <= x; i++) {
            for (int j = 1; j <= y; j++) {
                System.out.print("@ ");
            }
            System.out.println();
        }
    }

    // 3. Overloaded method: draws a right-angled triangle of 3 lines using '*'
    public void polygon() {
        System.out.println("Polygon Type 3: Right-Angled Triangle of 3 rows:");
        for (int i = 1; i <= 3; i++) {
            for (int j = 1; j <= i; j++) {
                System.out.print("* ");
            }
            System.out.println();
        }
    }

    public static void main(String[] args) {
        OverloadedPolygon obj = new OverloadedPolygon();
        obj.polygon(4, '#'); // Invokes polygon(int, char)
        System.out.println();
        obj.polygon(3, 5);   // Invokes polygon(int, int)
        System.out.println();
        obj.polygon();       // Invokes polygon()
    }
}

Model Program 2: Overloaded Mathematical Series Generator

public class SeriesComputation {

    // 1. Series 1: S = 1/1 + 1/2 + 1/3 + ... + 1/n
    public double series(double n) {
        double sum = 0.0;
        for (int i = 1; i <= n; i++) {
            sum += 1.0 / i;
        }
        return sum;
    }

    // 2. Series 2: S = 1/a^2 + 4/a^5 + 7/a^8 + ... to n terms
    public double series(double a, double n) {
        double sum = 0.0;
        double numerator = 1.0;
        double power = 2.0;

        for (int i = 1; i <= n; i++) {
            sum += numerator / Math.pow(a, power);
            numerator += 3.0; // Numerator increment: 1, 4, 7, 10...
            power += 3.0;     // Exponent increment: 2, 5, 8, 11...
        }
        return sum;
    }

    public static void main(String[] args) {
        SeriesComputation sc = new SeriesComputation();
        System.out.println("Series 1 Sum (n=5): " + sc.series(5.0));
        System.out.println("Series 2 Sum (a=2, n=4): " + sc.series(2.0, 4.0));
    }
}