docs(functional-interfaces): explain functional interfaces and demonstrate Function<T,R> usage

What
- Added documentation explaining the concept of functional interfaces:
  - Interface with exactly one abstract method.
  - Can include any number of default and static methods.
  - Typically annotated with @FunctionalInterface for compiler enforcement.
- Included step-by-step guide:
  1. How to create a functional interface.
  2. General syntax with abstract, default, and static methods.
  3. Example of a custom functional interface with lambda usage.
- Added example of built-in `Function<T,R>`:
  - Demonstrates mapping String → Integer by computing string length.
  - Showcased use of `apply()` method.

Why
- Functional interfaces are the foundation of Java 8’s functional programming model.
- Enables usage of lambdas and method references as concise implementations.
- Clarifies the role of built-in functional interfaces (`Function`, `Predicate`, `Consumer`, `Supplier`).

Logic
1. Created custom functional interface `MyFunctionalInterface` with a single abstract method:
   - `void sayMessage(String msg)`
   - Used lambda `(msg) -> System.out.println("Hello, " + msg)` to provide implementation.
2. Demonstrated `Function<String,Integer>`:
   - `Function<String, Integer> func = str -> str.length();`
   - Invoked `func.apply("Java 8")`, output: `6`.

Real-life applications
- Functional interfaces are widely used in:
  - Stream API (e.g., `.map`, `.filter`, `.forEach`).
  - Event handling (callbacks, listeners).
  - Utility abstractions where behavior is passed as a parameter.
- `Function<T,R>` commonly used for:
  - Data transformations (DTO mapping).
  - String/number parsing and conversions.
  - Extracting derived fields in collections.

Notes
- Only **one abstract method** is allowed; default/static methods do not violate the rule.
- `@FunctionalInterface` is optional but recommended for compiler-level validation.
- Built-in functional interfaces in `java.util.function` (Function, Predicate, Consumer, Supplier) cover most functional programming scenarios.

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

Author: Someshdiwan

Java 8 Crash Course/Functional Interface/src/How to Create a Functional Interface.txt

@@ -0,0 +1,69 @@
+🔹 What is a Functional Interface?
+	•	An interface with exactly one abstract method.
+	•	Can have any number of default or static methods.
+	•	Acts as a contract for lambda expressions or method references.
+	•	Annotated with @FunctionalInterface (optional but recommended).
+⸻
+
+🔹 How to Create a Functional Interface?
+	1.	Use the interface keyword.
+	2.	Define only one abstract method inside it.
+	3.	(Optional) Add @FunctionalInterface annotation to enforce compiler checks.
+
+⸻
+
+🔹 General Syntax:
+@FunctionalInterface
+interface InterfaceName {
+    ReturnType methodName(ParameterType parameters);
+
+    // You may also define default/static methods
+    default void helperMethod() { ... }
+    static void utilityMethod() { ... }
+}
+
+⸻
+
+🔹 Short Example:
+@FunctionalInterface
+interface MyFunctionalInterface {
+    void sayMessage(String msg); // Single Abstract Method
+}
+
+public class Package.Package2.Test {
+    public static void main(String[] args) {
+        // Using lambda expression
+        MyFunctionalInterface message = (msg) -> System.out.println("Hello, " + msg);
+        message.sayMessage("Java");
+    }
+}
+
+⸻
+
+Quick Recap:
+•	What? Interface with one abstract method.
+•	How? Use @FunctionalInterface, define one abstract method.
+•	Syntax: ReturnType methodName(ParameterType parameters);
+•	Usage: Ideal with lambda expressions for cleaner, concise code.
+
+
+Example of `Function<T, R>` in Java 8:
+
+- `Function<T, R>` is a functional interface from `java.util.function` package.
+- `T` is the input type (`String` in this case).
+- `R` is the return type (`Integer` in this case).
+- The lambda expression (`str -> str.length()`) defines the function body.
+- `.apply("Java 8")` executes the function.
+
+
+Function<String, Integer> func = str -> str.length();
+System.out.println(func.apply("Java 8")); // Output: 6
+
+Other Useful Java 8 Functional Interfaces:
+
+| Functional Interface| Description                             |
+|---------------------|-----------------------------------------|
+| `Function<T, R>`    | Takes an argument `T` and returns `R`.  |
+| `Predicate<T>`      | Returns `boolean` (used for filtering). |
+| `Consumer<T>`       | Consumes `T` without returning a value. |
+| `Supplier<T>`       | Supplies a value of `T` (no input).     |