Methods & Functions

What is a Method?

A method is a named, reusable block of code that performs a specific task. You define it once and call it as many times as needed — from anywhere that has access to it. Without methods, every program would be a single unbroken sequence of instructions: impossible to read, impossible to test, impossible to maintain.

In Java, methods always live inside a class — there are no standalone functions like in Python or JavaScript. Every method has a clear contract: what it receives (parameters), what it does (body), and what it gives back (return type). The compiler enforces that contract at every call site.

// Without methods: repeated logic, no structure
            double total1 = 99.99 * 1.21;  // apply 21% VAT
            double total2 = 49.50 * 1.21;  // same logic repeated
            double total3 = 15.00 * 1.21;  // change the rate? update 3 places. miss one? bug.
            
            // With a method: defined once, called everywhere, change in one place
            public double applyVat(double price) {
                return price * 1.21;
            }
            
            double total1 = applyVat(99.99);
            double total2 = applyVat(49.50);
            double total3 = applyVat(15.00);

Methods are also the unit of testing. You can write a test that calls applyVat(100.0) and verifies the result is 121.0 — independently of the rest of the program. That's only possible because the logic is isolated in a method with a clear input and output.

Method Anatomy

In Java, methods live inside classes — no standalone functions. Every method has a signature (name + parameter types), a return type, and a body. The signature is what uniquely identifies a method for overloading and overriding.

/*
 *  access   modifiers    return    name          parameters            throws
 *    │           │         │         │                │                   │
 *    ▼           ▼         ▼         ▼                ▼                   ▼
 */
public static String formatCurrency(double amount, String symbol)
        throws IllegalArgumentException {
    if (amount < 0) throw new IllegalArgumentException("Negative amount");
    return String.format("%s%.2f", symbol, amount);
}

Access modifiers

How Method Calls Work: The Call Stack

Every method call pushes a new stack frame onto the thread's call stack. The frame holds local variables, parameters, and the return address. When the method returns, the frame is popped and memory is reclaimed immediately.

/*
 *  CALL STACK — calculateTotal(100.0, 5) example
 *  ================================================
 *
 *  ┌───────────────────────────────────────────────────┐
 *  │  calculateTotal(double price, int quantity)        │  ← active frame
 *  │    price    = 100.0  (argument copied)             │
 *  │    quantity = 5      (argument copied)             │
 *  │    subtotal = 500.0  (local variable)              │
 *  │    → return 500.0                                  │
 *  ├───────────────────────────────────────────────────┤
 *  │  main()                                            │  ← waiting
 *  │    double result = calculateTotal(100.0, 5);       │
 *  └───────────────────────────────────────────────────┘
 *
 *  After return: calculateTotal frame is gone.
 *  result = 500.0 in main's frame.
 *
 *  StackOverflowError = stack ran out of space
 *  (infinite recursion is the usual cause)
 */

Pass by value — always

Java is always pass-by-value. What gets copied depends on the type:

// PRIMITIVE: copy of the value — caller is unaffected
public void tryToChange(int x) {
    x = 999;  // local copy only
}
int n = 10;
tryToChange(n);
System.out.println(n);  // Still 10

// OBJECT: copy of the REFERENCE — mutations to the object ARE visible
public void addItem(List<String> list) {
    list.add("new");         // ← modifies the shared object ✅
    list = new ArrayList<>(); // ← only changes local reference ❌ caller unaffected
}
List<String> items = new ArrayList<>();
addItem(items);
System.out.println(items);  // [new] — mutation visible, reassignment not

Parameters: varargs and final

Varargs — variable number of arguments

// int... is treated as int[] internally
public int sum(int... numbers) {
    int total = 0;
    for (int n : numbers) total += n;
    return total;
}

sum();                  // 0  — zero args allowed
sum(1, 2, 3);           // 6
sum(new int[]{10, 20}); // 30 — can pass array directly

// Varargs MUST be last — mixing with other params
public String format(String template, Object... args) {
    return String.format(template, args);
}

Effectively final parameters

// Parameters used in lambdas or anonymous classes must be effectively final
public void schedule(String message, int delayMs) {
    // message and delayMs cannot be reassigned after this point
    Executors.newSingleThreadScheduledExecutor()
        .schedule(() -> System.out.println(message), delayMs, TimeUnit.MILLISECONDS);
}

// ❌ This breaks it:
public void broken(String message) {
    message = message.trim();  // reassignment — now NOT effectively final
    Runnable r = () -> System.out.println(message);  // ERROR
}

// ✅ Fix: use a new local variable
public void fixed(String message) {
    final var trimmed = message.trim();
    Runnable r = () -> System.out.println(trimmed);
}

Method Overloading

Same name, different parameter list. The compiler resolves which overload to call at compile time based on argument types — this is static dispatch, not polymorphism.

// Compiler picks the MOST SPECIFIC match
public void process(Object obj)  { System.out.println("Object"); }
public void process(String str)  { System.out.println("String"); }
public void process(int n)        { System.out.println("int");    }
public void process(long n)       { System.out.println("long");   }

process("hello");              // "String"  — String more specific than Object
process(10);                   // "int"     — exact match
process(10L);                  // "long"    — exact match
short s = 5;
process(s);                    // "int"     — short widens to int
process(Integer.valueOf(10));   // "Object"  — Integer autoboxed, then → Object

Static vs Instance Methods

public class Counter {
    private int count = 0;               // instance state
    private static int totalCreated = 0;  // class-level state

    public Counter() { totalCreated++; }

    // INSTANCE — reads/writes this object's state
    public void increment()  { count++; }
    public int  getCount()   { return count; }

    // STATIC — no access to instance state, no 'this'
    public static int  getTotalCreated() { return totalCreated; }
    public static int  add(int a, int b) { return a + b; }
}

// Usage
Counter c1 = new Counter();
Counter c2 = new Counter();
c1.increment(); c1.increment();

c1.getCount();             // 2  — this counter only
c2.getCount();             // 0  — different object
Counter.getTotalCreated(); // 2  — shared across all instances

Method Design Best Practices

// ❌ BAD: one method doing too many things
public void processUserData(String data) {
    // validates, parses, saves, emails, logs, updates stats...
}

// ✅ GOOD: Single Responsibility — compose focused methods
public void registerUser(String data) {
    if (!validateUserData(data)) return;
    User user = parseUserData(data);
    saveUser(user);
    notifyUser(user);
}
private boolean validateUserData(String data) { ... }
private User    parseUserData(String data)    { ... }
private void    saveUser(User user)            { ... }
private void    notifyUser(User user)          { ... }

// ❌ BAD: too many parameters (hard to read, hard to test)
public Order createOrder(String product, int qty, double price,
        String customer, String address, boolean express) { ... }

// ✅ GOOD: group into an object (record in Java 16+)
record OrderRequest(String product, int qty, double price,
                    String customer, String address, boolean express) {}

public Order createOrder(OrderRequest req) { ... }

// ✅ GOOD: or Builder pattern for optional parameters
Order order = Order.builder()
    .product("Widget").quantity(5).customer(customer).express(true)
    .build();

Senior Topics: Method Design Patterns

Return Optional instead of null (Java 8+)

// ❌ Forces callers to remember null checks — NPE waiting to happen
public User findById(long id) {
    return db.find(id);  // null if not found
}

// ✅ Contract is explicit: caller knows this may be absent
public Optional<User> findById(long id) {
    return Optional.ofNullable(db.find(id));
}

// Caller is forced to handle the absence
findById(42L)
    .map(User::getEmail)
    .ifPresent(emailService::send);

Method references — methods as values (Java 8+)

// Lambdas calling a single method can be replaced with method references
List<String> names = List.of("Alice", "Bob", "Charlie");

// Lambda
names.forEach(name -> System.out.println(name));
// Method reference — cleaner when intent is obvious
names.forEach(System.out::println);

// Static method reference
names.stream().map(String::toUpperCase).toList();

// Instance method reference on a specific object
names.stream().filter(emailValidator::isValid).toList();

// Constructor reference
names.stream().map(User::new).toList();

Default methods in interfaces (Java 8+)

// Default methods add behaviour to interfaces without breaking existing implementations
public interface Notifiable {
    void sendNotification(String message);  // abstract — must implement

    default void sendUrgent(String message) {  // default — can override
        sendNotification("[URGENT] " + message);
    }
}

// Common real-world use: Comparator.comparing()
List<User> sorted = users.stream()
    .sorted(Comparator.comparing(User::lastName)
                       .thenComparing(User::firstName))
    .toList();

Covariant return types

// Overriding method can return a MORE SPECIFIC type (Java 5+)
public class Animal {
    public Animal create() { return new Animal(); }
}

public class Dog extends Animal {
    @Override
    public Dog create() { return new Dog(); }  // ✅ Dog is a subtype of Animal
}
// This is used extensively in the Builder pattern to return 'this' as the concrete type

Interview Questions