feat: demonstrate lambda expressions with parameters and return values

WHAT was done:
- Defined a functional interface `MyLambda2` with a method `add(int x, int y)` returning an int.
- Implemented the interface using a lambda expression `(a, b) -> a + b`.
- Executed the lambda in `main()` to add two numbers (20 + 30) and printed the result.

KEY LEARNINGS:
1. Functional Interface:
   - `@FunctionalInterface` ensures only one abstract method.
   - This single abstract method can be represented with a lambda.

2. Lambda with Parameters and Return Value:
   - Syntax: `(parameters) -> expression`.
   - Example: `(a, b) -> a + b`.
   - If the body is a single expression, `return` and braces `{}` are optional.

3. Simplification:
   - Traditional anonymous class implementation:
     ```
     MyLambda2 m = new MyLambda2() {
         public int add(int a, int b) {
             return a + b;
         }
     };
     ```
   - Equivalent lambda: `MyLambda2 m = (a, b) -> a + b;`.

4. Benefits:
   - Less boilerplate, concise, readable.
   - Directly focuses on *what* to compute, not *how* to declare.

REAL-LIFE APPLICATIONS:
- ✅ Arithmetic operations (sum, product, etc.) in functional pipelines.
- ✅ Passing custom behavior into APIs (e.g., comparators in sorting).
- ✅ Stream API usage (`map`, `reduce`, `filter`) where operations involve transformations.
- ✅ Replacing anonymous classes in concurrency (`Callable`, `Runnable`).

RULE OF THUMB:
- Use lambdas whenever a functional interface implementation is short and inline.
- Prefer concise form `(a, b) -> a + b` for simple logic.
- Use block form `{ return ...; }` when multiple statements are needed.

Signed-off-by: https://github.com/Someshdiwan <[email protected]>

Author: Someshdiwan

Section22Lambda Expressions/src/LamdaDemo.java

@@ -1,25 +1,19 @@
-package lamdademo1;
-
 @FunctionalInterface
-interface MyLambda
-{
+interface MyLambda2 {
     //public void display(String str);
     public int add(int x,int y);
 }
 
 public class LamdaDemo {
-
     public static void main(String[] args) {
-
         /*MyLambda m=(s)->{System.out.println(s);};
         m.display("Hello World");*/
 
         /*MyLambda m=(a,b)->{return a+b;};
         System.out.println(m.add(20,30));*/
 
-        MyLambda m=(a,b)->a+b;
-        int r=m.add(20, 30);
+        MyLambda2 m = (a,b) -> a + b;
+        int r = m.add(20, 30);
         System.out.println(r);
     }
-
-}
+}