Search⌘ K
AI Features
Home
Courses
Modern Java: From Fundamentals to Advanced Architecture

Overloading and Parameter Passing

Explore how Java supports method overloading to use single method names for different data types, improving code clarity. Understand Java's pass-by-value parameter passing model, differentiating how primitives and object references behave when passed to methods. This lesson helps you avoid common bugs by mastering argument matching, type promotion, and the distinction between modifying object state versus reference reassignment.

We'll cover the following...

As our programs grow in complexity, we often encounter situations where we need to perform the same logical operation on different types of data. Imagine writing a function to print data to the screen. Without a flexible support, we might be forced to create method with different names, one for each data type like printString, printInt, and printBoolean. This approach clutters our code and forces us to remember multiple method names.

Java solves this with method overloading, allowing us to use a single, intuitive name for related behaviors. Beyond naming, we must also understand exactly what happens to our data when we pass it into these methods. Does the method receive the original data or a copy? Understanding this distinction is vital for preventing bugs where data is modified unexpectedly or, conversely, fails to update when intended.

The power of method overloading

In Java, we can define multiple methods with the same name within the same class, provided they have different parameter lists. This is called method overloading.

The compiler distinguishes between these methods based on their method signatures. A method signature consists of the method’s name and the ordered list of its parameter types. Crucially, the return type is not part of the signature. We cannot define two methods that differ only by their return type, as the compiler would not know which one to call.

Overloading makes our code more readable and easier to use. We can expose a single interface (like print) while handling the underlying complexity of different data types internally.

Java 25
public class Printer {
    // Signature: print(String)
    public static void print(String text) {
        System.out.println("Printing string: " + text);
    }
    // Signature: print(int)
    public static void print(int number) {
        System.out.println("Printing integer: " + number);
    }
    // Signature: print(double)
    public static void print(double number) {
        System.out.println("Printing double: " + number);
    }
    public static void main(String[] args) {
        print("Hello World");
        print(100);
        print(99.9);
    }
}

  • ...