Functions in Java

In Java, a function is called a method. Methods break code into reusable, named blocks that accept inputs (parameters), do work, and optionally return a result. Methods improve readability, testability and reuse.

• Syntax: returnType name(params) { body; return value; }
• Use void when no value is returned.
• Use static for methods that don't depend on an object.
• Call: name(arg1, arg2);

Let's start with a hands-on example. The program below shows the core idea behind Functions in just a few lines of Java. Read it line by line and observe how Java executes each statement in order.

class Main
{
    static int add(int a, int b)
    {
        return a + b;
    }

    public static void main(String args[])
    {
        int result = add(10, 25);
        System.out.println("Sum = " + result);
    }
}

The following examples progress from simple to more practical patterns. Try each in your IDE, change the inputs and observe the output. This is the fastest way to internalize the concept.

class Main
{
    static void greet(String name)
    {
        System.out.println("Hello, " + name);
    }

    public static void main(String args[])
    {
        greet("Aman");
        greet("Riya");
    }
}

class Main
{
    static int fact(int n)
    {
        if (n <= 1) return 1;
        return n * fact(n - 1);
    }

    public static void main(String args[])
    {
        System.out.println("5! = " + fact(5));
    }
}

class Main
{
    static boolean isEven(int n)
    {
        return n % 2 == 0;
    }

    public static void main(String args[])
    {
        System.out.println(isEven(10));
        System.out.println(isEven(7));
    }
}

class Main
{
    static int max3(int a, int b, int c)
    {
        int max = a;
        if (b > max) max = b;
        if (c > max) max = c;
        return max;
    }

    public static void main(String args[])
    {
        System.out.println(max3(7, 12, 9));
    }
}

class Calc
{
    int square(int n) { return n * n; }
}

class Main
{
    public static void main(String args[])
    {
        Calc c = new Calc();
        System.out.println(c.square(6));
    }
}

• A method must be declared inside a class.
• Use static for utility methods that don't need an instance.
• Java is pass-by-value — primitives are copied, but object references are passed by value too.
• Use descriptive method names that start with a verb: calculateTax, printReport.
• Keep methods short and focused — one task per method.

Reading is not enough — practice solidifies knowledge. Try every question below in your own editor before peeking at any solution.

• Q1. Write a method to find the cube of a number.
• Q2. Write a method that returns true if a number is prime.
• Q3. Implement Fibonacci using recursion.
• Q4. Write a method to swap two values (using arrays).
• Q5. Write a method that reverses a string using recursion.

These are the most common questions asked in Java interviews on this topic. Memorize the concept, not just the answer — interviewers often follow up with edge cases.

Even experienced developers slip on the same pitfalls. Watch out for these classic mistakes while working with Functions in Java:

• Forgetting the semicolon ; at the end of statements while using Functions.
• Mixing up similar method names — read Java docs before using new APIs related to Functions.
• Ignoring compiler warnings — they often hint at bugs that will appear later in production.
• Hard-coding values that should come from configuration files or environment variables.
• Not handling edge cases: empty inputs, very large inputs, negative numbers and null references.
• Skipping unit tests — small tests prevent big regressions, especially around control flow.