feat: demonstrate method references (static, instance, and predefined) in Java

WHAT was done:
- Created a functional interface `MyRefrences` with a single abstract method `display(String str)`.
- Implemented three variations of method references:
  1. **Static method reference** → `MethodRefrences::reverse`
     - Points to a static method that reverses a string using `StringBuffer.reverse()`.
  2. **Instance method reference** → `MD::reverse1`
     - Points to a non-static method of a specific object.
  3. **Predefined method reference** → `System.out::println`
     - Refers to Java’s built-in `println` method to directly print strings.

KEY LEARNINGS:
1. Method Reference Basics:
   - Syntax: `ClassName::methodName` (static) or `object::methodName` (instance).
   - They provide a shorthand for writing simple lambda expressions.
   - Example: `str -> System.out.println(str)` ≡ `System.out::println`.

2. Types of Method References:
   - Static method reference → `ClassName::staticMethod`.
   - Instance method reference (specific object) → `object::instanceMethod`.
   - Instance method reference (arbitrary object) → `ClassName::instanceMethod`.
   - Constructor reference → `ClassName::new`.

3. Advantage:
   - Improves readability by eliminating boilerplate.
   - Useful when lambda just calls an existing method.

EXAMPLE EQUIVALENCE:
- Lambda: `(s) -> System.out.println(s)`
- Method reference: `System.out::println`

REAL-LIFE APPLICATIONS:
- ✅ Printing collections with `forEach(System.out::println)`.
- ✅ Sorting with comparators (`String::compareToIgnoreCase`).
- ✅ Stream API transformations where existing methods suffice.
- ✅ Reusing existing utility methods (e.g., `Integer::parseInt` in a mapping function).

RULE OF THUMB:
- If your lambda only calls an existing method, prefer method references.
- Keeps code concise and more expressive.

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

Author: Someshdiwan

Section22Lambda Expressions/src/MethodRefrences.java

@@ -1,29 +1,25 @@
-interface MyRefrences
-{
+interface MyRefrences {
     public void display(String str);
 }
 
-public class MethodRefrences
-{
-    public static void reverse (String str)
-    {
-        StringBuffer sb=new StringBuffer(str);
-        sb.reverse(); //Reverse method inside string buffer
+public class MethodRefrences {
+    public static void reverse(String str) {
+        StringBuffer sb = new StringBuffer(str);
+        sb.reverse(); //Reverse method inside string buffer.
         System.err.println(sb);
     }
 
     //If the method is not static.
-    public void reverse1(String str)
-    {
-        StringBuffer sb=new StringBuffer(str);
-        sb.reverse(); //Reverse method inside string buffer
+    public void reverse1(String str) {
+        StringBuffer sb = new StringBuffer(str);
+        sb.reverse(); //Reverse method inside string buffer.
         System.err.println(sb);
     }
 
-    public static void main(String[] args)
-    {
+    public static void main(String[] args) {
         MethodRefrences MD = new MethodRefrences();
-        MyRefrences R3=MD::reverse1;
+
+        MyRefrences R3 = MD::reverse1;
 
         MyRefrences R2=MethodRefrences::reverse;
         //This is a like Scope resolution in C++.
@@ -32,9 +28,7 @@ public static void main(String[] args)
         //System = Class and Out = is an object inside that class and println = is static.
 
         R1.display("Hello");
-
         R2.display("Hello");
-
         R3.display("Non Static Method");
     }
-}
+}