feat: demonstrate constructor reference using functional interface

WHAT was done:
- Created a functional interface `MyConstructor` with a single abstract method `display(String str)`.
- Implemented a class `ConstructerAsMethodReference` with a constructor that takes a `String` and prints it in uppercase.
- Used a method reference (`ConstructerAsMethodReference::new`) to map the interface method `display()` to the class constructor.
- Invoked the functional interface method to trigger object creation and execution.

KEY LEARNINGS:
1. Constructor References:
   - Syntax: `ClassName::new`
   - Used to map a constructor to a functional interface method.
   - Acts like a bridge between a functional interface and object instantiation.

2. Functional Interface:
   - `MyConstructor` defines `display(String str)` as a SAM (Single Abstract Method).
   - Compatible with the constructor of `ConstructerAsMethodReference` which takes a `String`.

3. Flow:
   - `m1 = ConstructerAsMethodReference::new` → Assigns constructor reference.
   - `m1.display("...")` → Invokes the constructor indirectly via the functional interface.

4. Benefits:
   - Cleaner, more expressive code than using `new` directly inside lambda expressions.
   - Improves readability in functional programming and stream pipelines.

REAL-LIFE APPLICATIONS:
- ✅ Object creation in Java Streams (`map(ClassName::new)`).
- ✅ Factory patterns where constructors can be passed as parameters.
- ✅ Dependency injection frameworks to decouple object instantiation logic.

RULE OF THUMB:
- Use constructor references when a functional interface method matches a constructor signature.
- Prefer `ClassName::new` over verbose lambdas `(str -> new ClassName(str))` for cleaner code.

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

Author: Someshdiwan

Section22Lambda Expressions/src/ConstructerAsMethodReference.java

@@ -1,17 +1,49 @@
-interface MyConstructor
-{
-    public void display(String str);  //You can assign the more than one Parameters.
+interface MyConstructor {
+    public void display(String str);
+    //You can assign the more than one Parameters.
 }
+
 public class ConstructerAsMethodReference {
-    public ConstructerAsMethodReference(String s)
-    {
+    public ConstructerAsMethodReference(String s) {
         System.out.println(s.toUpperCase());
     }
 
-    public static void main(String[] args)
-    {
+    public static void main(String[] args) {
         MyConstructor m1=ConstructerAsMethodReference::new;
         //Constructor new along with the class name
         m1.display("print the upper case letters");
     }
-}
+}
+
+/*
+1. Functional Interface:
+   - `MyConstructor` ek functional interface hai (sirf ek abstract method: display).
+   - Iska purpose hai ki us method ko kisi method reference / lambda se map kara sake.
+
+2. Constructor Reference Syntax:
+   - `ClassName::new`
+   - Ye ek special type ka method reference hai jo constructor ko call karta hai.
+   - Yahan `ConstructerAsMethodReference::new` ka matlab hai:
+     -> Jab bhi `display(String s)` call hoga, ek naya object banega
+     -> Aur us object ke constructor me wahi string pass ho jaayegi.
+
+3. Flow in this program:
+   - `MyConstructor m1 = ConstructerAsMethodReference::new;`
+   - Matlab: "display(String)" ko map kar diya hai `ConstructerAsMethodReference(String s)` constructor pe.
+   - Jab `m1.display("print the upper case letters");` call hota hai:
+       → Constructor call hoga
+       → String ko uppercase me convert karke print karega
+
+4. Output:
+   PRINT THE UPPER CASE LETTERS
+
+5. Key Point:
+   - Method references sirf tabhi work karte hain jab functional interface ka method signature
+     constructor/method ke signature ke saath compatible ho.
+   - Yahan `display(String)` perfectly match hota hai constructor `ConstructerAsMethodReference(String)` se.
+
+- Constructor references ko functional programming ke saath use karke object creation ko simplify kar sakte ho.
+- Example: Streams me mapping:
+  list.stream().map(ConstructerAsMethodReference::new).collect(Collectors.toList());
+  (Har element ke liye ek naya object ban jayega.)
+*/