Lambda Expressions

• Eliminates the need for excessive anonymous inner class declarations
• Enables funtcional programming paradigms in Java

Why Use Lambda Expressions?

• Reduces boilerplate code from anonymous inner classes
• Creates cleaner, more readable code
• Focuses on essential logic rather than ceremony

Understanding Functional Interfaces

A functional interface is any interface containing exactly one abstract method. Such interfaces can be instantiated using lambda expressions, treating methods as first-class citizens.

Derivation Process

The following example demonstrates the evolution from traditional implementation to lambda syntax:

package com.example.functional;

// Define a functional interface with a single abstract method
interface IGreet {
    void sayHello();
}

// Traditional implementation class
class Greeting implements IGreet {
    @Override
    public void sayHello() {
        System.out.println("Hello from class");
    }
}

public class LambdaDemo {
    
    // Static inner class implementation
    static class GreetingImpl implements IGreet {
        @Override
        public void sayHello() {
            System.out.println("Hello from static inner class");
        }
    }
    
    public static void main(String[] args) {
        IGreet greeting = new Greeting();
        greeting.sayHello();
        
        greeting = new GreetingImpl();
        greeting.sayHello();
        
        // Local inner class
        class LocalGreeting implements IGreet {
            @Override
            public void sayHello() {
                System.out.println("Hello from local class");
            }
        }
        greeting = new LocalGreeting();
        greeting.sayHello();
        
        // Anonymous inner class
        greeting = new IGreet() {
            @Override
            public void sayHello() {
                System.out.println("Hello from anonymous class");
            }
        };
        greeting.sayHello();
        
        // Lambda expression - the most concise form
        greeting = () -> {
            System.out.println("Hello from lambda");
        };
        greeting.sayHello();
    }
}

Lambda Expressoins with Parameters

package com.example.functional;

interface IMessage {
    void display(String text);
}

public class LambdaWithParams {
    public static void main(String[] args) {
        IMessage message = (msg) -> {
            System.out.println("Message: " + msg);
        };
        message.display("Hello World");
    }
}

When a functional interface has only one parameter, the paramter type becomes optional, and parentheses can be omitted for even cleaner syntax:

// Equivalent to the above, using implicit typing
IMessage concise = msg -> System.out.println("Message: " + msg);
concise.display("Streamlined!");