5.2. Parameters & Return Values

Parameters allow methods to receive input data, while return values allow methods to provide output data. Understanding how to work with parameters and return values is crucial for writing flexible and reusable methods.

Parameter Types

Value Parameters (Primitive Types)

public class ValueParameters {

    // Primitive parameters are passed by value
    public void modifyPrimitive(int x) {
        x = x * 2;  // Changes only the local copy
        System.out.println("Inside method: x = " + x);
    }

    public void swap(int a, int b) {
        int temp = a;
        a = b;
        b = temp;
        System.out.println("Inside swap: a = " + a + ", b = " + b);
    }

    public static void main(String[] args) {
        ValueParameters demo = new ValueParameters();

        int number = 5;
        demo.modifyPrimitive(number);
        System.out.println("Outside method: number = " + number);
        // Output:
        // Inside method: x = 10
        // Outside method: number = 5

        int x = 10, y = 20;
        demo.swap(x, y);
        System.out.println("Outside swap: x = " + x + ", y = " + y);
        // Output:
        // Inside swap: a = 20, b = 10
        // Outside swap: x = 10, y = 20
    }
}

Reference Parameters (Object Types)

public class ReferenceParameters {

    // Object references are passed by value, but objects are mutable
    public void modifyArray(int[] arr) {
        if (arr != null && arr.length > 0) {
            arr[0] = 999;  // Modifies the original array
        }
    }

    public void modifyStringBuilder(StringBuilder sb) {
        sb.append(" World!");  // Modifies the original StringBuilder
    }

    public void reassignReference(StringBuilder sb) {
        sb = new StringBuilder("New value");  // Only affects local reference
    }

    public static void main(String[] args) {
        ReferenceParameters demo = new ReferenceParameters();

        int[] numbers = {1, 2, 3};
        demo.modifyArray(numbers);
        System.out.println("Array after modification: " + Arrays.toString(numbers));
        // Output: Array after modification: [999, 2, 3]

        StringBuilder text = new StringBuilder("Hello");
        demo.modifyStringBuilder(text);
        System.out.println("StringBuilder: " + text); // Output: StringBuilder: Hello World!

        StringBuilder text2 = new StringBuilder("Original");
        demo.reassignReference(text2);
        System.out.println("After reassignment: " + text2); // Output: After reassignment: Original
    }
}

Return Values

Returning Primitive Types

public class PrimitiveReturns {

    public int findMax(int a, int b) {
        return Math.max(a, b);
    }

    public double calculateAverage(int[] numbers) {
        if (numbers == null || numbers.length == 0) {
            return 0.0;
        }

        int sum = 0;
        for (int num : numbers) {
            sum += num;
        }
        return (double) sum / numbers.length;
    }

    public boolean isPalindrome(String text) {
        if (text == null) return false;
        String clean = text.replaceAll("\\s+", "").toLowerCase();
        String reversed = new StringBuilder(clean).reverse().toString();
        return clean.equals(reversed);
    }
}

Returning Objects

public class ObjectReturns {

    public String createGreeting(String name) {
        return "Hello, " + name + "! Welcome to Java programming.";
    }

    public int[] generateFibonacci(int count) {
        if (count <= 0) return new int[0];
        if (count == 1) return new int[]{0};

        int[] sequence = new int[count];
        sequence[0] = 0;
        if (count > 1) sequence[1] = 1;

        for (int i = 2; i < count; i++) {
            sequence[i] = sequence[i-1] + sequence[i-2];
        }
        return sequence;
    }

    public List<String> filterLongWords(String[] words, int minLength) {
        List<String> result = new ArrayList<>();
        for (String word : words) {
            if (word != null && word.length() >= minLength) {
                result.add(word);
            }
        }
        return result;
    }
}

Multiple Return Values

Using Arrays

public class MultipleReturns {

    public int[] minMax(int[] numbers) {
        if (numbers == null || numbers.length == 0) {
            return new int[]{0, 0};
        }

        int min = numbers[0];
        int max = numbers[0];

        for (int num : numbers) {
            if (num < min) min = num;
            if (num > max) max = num;
        }

        return new int[]{min, max};
    }
}

Using Custom Objects

class CalculationResult {
    private final double sum;
    private final double average;
    private final double product;

    public CalculationResult(double sum, double average, double product) {
        this.sum = sum;
        this.average = average;
        this.product = product;
    }

    // Getters
    public double getSum() { return sum; }
    public double getAverage() { return average; }
    public double getProduct() { return product; }

    @Override
    public String toString() {
        return String.format("Sum: %.2f, Average: %.2f, Product: %.2f", sum, average, product);
    }
}

public class MultipleReturnsWithObject {

    public CalculationResult calculateStats(double[] numbers) {
        if (numbers == null || numbers.length == 0) {
            return new CalculationResult(0, 0, 0);
        }

        double sum = 0;
        double product = 1;

        for (double num : numbers) {
            sum += num;
            product *= num;
        }

        double average = sum / numbers.length;
        return new CalculationResult(sum, average, product);
    }
}

Varargs (Variable Arguments)

public class VarargsExamples {

    // Method with varargs parameter
    public static int sum(int... numbers) {
        int total = 0;
        for (int num : numbers) {
            total += num;
        }
        return total;
    }

    // Mixed parameters with varargs (varargs must be last)
    public static String concatenate(String separator, String... strings) {
        if (strings == null || strings.length == 0) {
            return "";
        }

        StringBuilder result = new StringBuilder();
        for (int i = 0; i < strings.length; i++) {
            if (i > 0) {
                result.append(separator);
            }
            result.append(strings[i]);
        }
        return result.toString();
    }

    public static void main(String[] args) {
        // Calling varargs methods
        System.out.println("Sum: " + sum(1, 2, 3));           // Output: Sum: 6
        System.out.println("Sum: " + sum(1, 2, 3, 4, 5));     // Output: Sum: 15
        System.out.println("Sum: " + sum());                  // Output: Sum: 0

        System.out.println(concatenate(", ", "Apple", "Banana", "Cherry"));
        // Output: Apple, Banana, Cherry
    }
}

Complete Example: Student Grade Calculator

public class GradeCalculator {

    public static class GradeResult {
        private final double average;
        private final char grade;
        private final boolean passed;

        public GradeResult(double average, char grade, boolean passed) {
            this.average = average;
            this.grade = grade;
            this.passed = passed;
        }

        // Getters
        public double getAverage() { return average; }
        public char getGrade() { return grade; }
        public boolean isPassed() { return passed; }

        @Override
        public String toString() {
            return String.format("Average: %.2f, Grade: %c, Passed: %s",
                               average, grade, passed);
        }
    }

    public GradeResult calculateGrade(double... scores) {
        if (scores == null || scores.length == 0) {
            throw new IllegalArgumentException("No scores provided");
        }

        double sum = 0;
        for (double score : scores) {
            if (score < 0 || score > 100) {
                throw new IllegalArgumentException("Scores must be between 0 and 100");
            }
            sum += score;
        }

        double average = sum / scores.length;
        char grade = calculateLetterGrade(average);
        boolean passed = average >= 60.0;

        return new GradeResult(average, grade, passed);
    }

    private char calculateLetterGrade(double average) {
        if (average >= 90) return 'A';
        if (average >= 80) return 'B';
        if (average >= 70) return 'C';
        if (average >= 60) return 'D';
        return 'F';
    }

    public static void main(String[] args) {
        GradeCalculator calculator = new GradeCalculator();

        GradeResult result1 = calculator.calculateGrade(85.5, 92.0, 78.5, 88.0);
        System.out.println("Student 1: " + result1);

        GradeResult result2 = calculator.calculateGrade(45.0, 52.5, 48.0);
        System.out.println("Student 2: " + result2);
    }
}

Best Practices

1. Validate parameters: Check for null and valid ranges
2. Use meaningful return types: Return objects that make sense
3. Document parameters and returns: Use Javadoc
4. Prefer immutability: Return immutable objects when possible
5. Use varargs judiciously: When the number of arguments is variable

/**
 * Calculates the area of a rectangle
 * @param length the length of the rectangle (must be positive)
 * @param width the width of the rectangle (must be positive)
 * @return the area of the rectangle
 * @throws IllegalArgumentException if length or width is not positive
 */
public static double calculateRectangleArea(double length, double width) {
    if (length <= 0 || width <= 0) {
        throw new IllegalArgumentException("Length and width must be positive");
    }
    return length * width;
}