feat(OperatorInterfaceDemo): add demo using UnaryOperator and BinaryOperator with apply()

What
- Added OperatorInterfaceDemo class demonstrating usage of java.util.function.UnaryOperator and BinaryOperator.
- Defined:
  - UnaryOperator<Integer> a → multiplies input by 2.
  - BinaryOperator<Integer> b → adds two integers.
- Executed both with apply():
  - a.apply(5) → 10.
  - b.apply(5, 5) → 10.
- Printed results with descriptive messages.

Why
- Shows how to execute lambda expressions stored in operator interfaces.
- Clarifies difference between printing operator reference vs executing with apply().
- Educational example highlighting the purpose of UnaryOperator and BinaryOperator as specializations of Function and BiFunction.

How
- Declared lambdas for arithmetic operations.
- Invoked apply() method on both operator instances.
- Printed results to stdout.

Logic
- Inputs: integer 5 for unary; integers 5 and 5 for binary.
- Outputs:
  - "Unary result (2 * 5): 10".
  - "Binary result (5 + 5): 10".
- Flow:
  1. a.apply(5) → 2 * 5 → 10.
  2. b.apply(5, 5) → 5 + 5 → 10.
  3. Print results.
- Edge cases: trivial arithmetic; no exceptions expected.
- Complexity / performance: O(1).
- Concurrency / thread-safety: lambdas are stateless, safe across threads.
- Error handling: not applicable.

Real-life applications
- UnaryOperator: transformations like scaling numbers, normalizing data, incrementing values.
- BinaryOperator: aggregation (sum, min, max), often used with Stream.reduce().
- Useful in mathematical pipelines, configuration merging, or data combination scenarios.

Notes
- Demonstrates execution with apply(); without it, only the object reference prints.
- Cleaner than earlier version since no unused methods present.
- Method references (Integer::sum, x -> x * 2 as inline) can further simplify usage in production code.

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

Author: Someshdiwan

JAVA8/Operator/src/OperatorInterfaceDemo.java renamed to Java 8 Crash Course/Unary operators and Binary operators/src/OperatorInterfaceDemo.java

@@ -12,19 +12,21 @@ public static void main(String[] args) {
         // BinaryOperator: adds two integers
         BinaryOperator<Integer> b = (x, y) -> x + y;
 
-        // actual results, call apply() on the operators.
+        // for actual results, call apply() on the operators.
         System.out.println("Unary result (2 * 5): " + a.apply(5));
         System.out.println("Binary result (5 + 5): " + b.apply(5, 5));
     }
 }
 
 /*
 Lambda Expression Execution:
-Use the apply method (for both UnaryOperator and BinaryOperator) to execute the lambda and obtain a result.
+Use the apply method (for both UnaryOperator and BinaryOperator) to execute the lambda and obtain a
+result.
 
-Simply printing the lambda variable (e.g., System.out.println(a);) shows the reference, not the computed value.
+Simply printing the lambda variable (e.g., System.out.println(a);) shows the reference,
+not the computed value.
 
 Unused Methods:
 In Version 1, the sum method is defined but not used.
 Version 2 is a cleaner example if you want to focus only on lambda expressions.
-*/
+*/