Lambda Expressions and Functional Interfaces

For most of its history Java was strictly object-oriented: to pass behaviour around, you wrapped it in an object, typically a verbose anonymous class. Java 8 changed this profoundly by adding lambda expressions, a concise syntax for treating a piece of behaviour as a value you can pass to methods, store in variables, and return. A lambda is essentially an anonymous function: parameters, an arrow, and a body.

Lambdas work hand in hand with functional interfaces, interfaces with exactly one abstract method, which are the types lambdas implement. The standard library provides a rich set in java.util.function (Predicate, Function, Consumer, Supplier, and more), and these together are the foundation of the Streams API and the functional style that dominates modern Java.

Understanding lambdas and functional interfaces matters because they are the vocabulary of contemporary Java: stream pipelines, event handlers, and countless library APIs are expressed in terms of them. Grasping that a lambda is just a compact implementation of a single-method interface, and learning the standard functional types, unlocks the declarative, behaviour-as-data style that makes modern Java code shorter and clearer.

Analogy🏏Cricket

🏏 Think of it like cricket: a team sheet does not just list players, it assigns each to a precise, declared role, opener, spinner, wicketkeeper, and the laws and the captain enforce that a player operates within their declared role: you cannot send a designated bowler to keep wicket without an official change. Just as each player's role is fixed and checked before play, each Java variable's type is fixed at compile time and checked by the compiler. Just as trying to use a player outside their role is caught by the officials before it disrupts the match, using a variable in a type-incompatible way is caught by the compiler before the program runs. Just as clear role assignments prevent on-field confusion, clear type declarations prevent runtime errors. The insight is that declaring and enforcing roles up front, for players or for data, catches mistakes early rather than mid-match.