7.3 Method References: Static, Bound, Unbound, and Constructor References

7.3 Method References: Static, Bound, Unbound, and Constructor References

Method references provide a compact, highly readable alternative to lambda expressions when an expression does nothing more than invoke an existing method or constructor by name. Using the double colon separator (::), method references allow developers to treat existing methods as first-class functional targets. For the 1Z0-829 exam, you must clearly distinguish between the four categories of method references, understand how the compiler differentiates bound from unbound references, and navigate constructor reference mechanics.

---

Syntax and Target Typing

A method reference consists of a target reference or type name, the double colon operator (::), and the method identifier or the new keyword:

$\text{Target} :: \text{MethodOrConstructor}$

Like lambda expressions, method references have no intrinsic standalone type. The compiler infers whether a method reference is compatible with a given target based on the expected functional interface's abstract method descriptor:

// Legal: compiler infers Consumer<String> from assignment context
Consumer<String> printer = System.out::println;

// COMPILE ERROR: Cannot infer type for method reference using var
// var ref = System.out::println;

// COMPILE ERROR: Object is not a functional interface
// Object obj = System.out::println;

// Legal: explicit cast establishes target functional interface context
Object obj = (Consumer<String>) System.out::println;

---

The Four Categories of Method References

The Java Language Specification defines four distinct forms of method references based on how the target method is invoked and whether an instance receiver is bound:

                                +--------------------------+
                                | Method Reference Types   |
                                +--------------------------+
                                              |
         +--------------------+---------------+--------------------+--------------------+
         |                    |                                    |                    |
         v                    v                                    v                    v
  [Static Reference]   [Bound Instance]                    [Unbound Instance]   [Constructor Reference]
  ClassName::method    instance::method                    ClassName::method    ClassName::new / Type[]::new
  args -> Class.m(args) args -> instance.m(args)           (inst, args)->inst.m(args) args -> new Class(args)

1. Static Method References

Refers to a static method of a class. The parameters supplied to the functional interface are passed directly as the arguments to the static method in identical order:

// Static method taking 1 argument: Function<String, Integer>
Function<String, Integer> parser = Integer::parseInt; // s -> Integer.parseInt(s)
Integer val = parser.apply("123"); // 123

// Static method taking 2 arguments: BinaryOperator<Double>
BinaryOperator<Double> maxFinder = Math::max; // (a, b) -> Math.max(a, b)
Double greater = maxFinder.apply(10.5, 20.2); // 20.2

2. Bound Instance Method References

A bound instance method reference binds to a specific object instance that is evaluated when the method reference expression is created. The functional interface parameters do not include the target instance:

String prefix = "USER_";
// Bound reference: 'prefix' is evaluated now and captured
Function<String, String> tagger = prefix::concat; // s -> prefix.concat(s)
System.out.println(tagger.apply("42")); // "USER_42"

// Bound reference with zero arguments: Supplier<Integer>
Supplier<Integer> lenSupplier = prefix::length; // () -> prefix.length()
System.out.println(lenSupplier.get()); // 5

3. Unbound Instance Method References

An unbound instance method reference specifies a class name rather than an existing instance. The first parameter of the target functional interface serves as the receiver object on which the instance method is invoked. Any subsequent parameters map to the method's arguments:

// Single parameter becomes the invocation target: Function<String, Integer>
Function<String, Integer> lengthFunc = String::length; // s -> s.length()
System.out.println(lengthFunc.apply("OpenJDK")); // 7

// Unbound reference matching Predicate<String>
Predicate<String> blankChecker = String::isBlank; // s -> s.isBlank()
System.out.println(blankChecker.test("   ")); // true

// Two parameters: 1st is target, 2nd is method argument: BiPredicate<String, String>
BiPredicate<String, String> startsWithChecker = String::startsWith; // (s1, s2) -> s1.startsWith(s2)
System.out.println(startsWithChecker.test("Java 17", "Java")); // true

// Two parameters: 1st is target, 2nd is method argument: BiFunction<String, String, String>
BiFunction<String, String, String> concatFunc = String::concat; // (s1, s2) -> s1.concat(s2)
System.out.println(concatFunc.apply("Open", "JDK")); // "OpenJDK"

Comparing Bound vs. Unbound Syntax

Consider the method String.concat(String str):

• Bound: "Hello"::concat binds to "Hello". It accepts 1 parameter (String) and returns String. Target: Function<String, String>.
• Unbound: String::concat has no bound instance. It requires 2 parameters (target String and argument String) and returns String. Target: BiFunction<String, String, String>.

Notice that both static method references and unbound instance method references use the syntax ClassName::methodName. The compiler resolves whether it is static or unbound by checking if methodName is static or instance, and comparing the arity of the target functional interface.

---

Constructor References

Constructor references instantiate new objects or arrays using the new keyword.

Class Constructor References (ClassName::new)

The compiler selects the appropriate constructor based on the functional interface's abstract method parameters:

// Zero arguments: Supplier<List<String>> invokes new ArrayList<>()
Supplier<List<String>> listFactory = ArrayList::new;
List<String> list = listFactory.get();

// One argument: Function<String, StringBuilder> invokes new StringBuilder(String)
Function<String, StringBuilder> sbFactory = StringBuilder::new;
StringBuilder sb = sbFactory.apply("Initial");

// Two arguments: BiFunction<String, Integer, CustomRecord>
record Employee(String name, int id) {}
BiFunction<String, Integer, Employee> empFactory = Employee::new;
Employee emp = empFactory.apply("Alice", 101);

Array Constructor References (Type[]::new)

Array constructor references allow creating arrays of specified lengths. The functional interface must accept a single integer argument representing the array length and return the array type, matching IntFunction<Type[]>:

// Array constructor reference: size -> new String[size]
IntFunction<String[]> stringArrayFactory = String[]::new;
String[] words = stringArrayFactory.apply(10); // Array of length 10

// Primary use case: Stream.toArray(IntFunction<A[]> generator)
List<String> fruits = List.of("Apple", "Banana", "Cherry");
String[] fruitArray = fruits.stream().toArray(String[]::new);

---

Overload Resolution and Compiler Disambiguation

When a class contains overloaded methods, the compiler inspects the target functional interface to identify a unique matching method:

public class OverloadDemo {
    public static void print(String s) { System.out.println("String: " + s); }
    public static void print(Integer i) { System.out.println("Integer: " + i); }
}

// Disambiguated by target parameter type:
Consumer<String> strConsumer = OverloadDemo::print;   // Calls print(String)
Consumer<Integer> intConsumer = OverloadDemo::print; // Calls print(Integer)

Ambiguity Errors

If the compiler cannot uniquely identify a single most specific method, compilation fails with an ambiguity error:

// Integer declares a static toString(int) AND an instance toString().
// For Function<Integer, String>, both fit: toString(int) as a static reference,
// and toString() as an unbound reference whose receiver is the Integer argument.
// COMPILE ERROR: incompatible types: invalid method reference
//                reference to toString is ambiguous
// Function<Integer, String> f = Integer::toString;

To resolve the ambiguity, use an explicit lambda such as i -> Integer.toString(i) or i -> i.toString(). A different failure occurs with a raw target such as Function rawFunc = SomeClass::process; when the only overloads accept String and Integer: the raw function type passes an Object, so javac reports that no suitable method is found.

---

Restrictions on Method References

1. No Explicit Arguments: You cannot pass arguments directly inside method reference syntax: Math::max(10, 20) is invalid syntax.
2. Target Interface Required: Method references cannot be used with var or assigned to Object without an explicit cast.
3. Generics Type Witnesses: If a method is generic, type witnesses appear after the :: operator: Collections::<String>emptyList.