docs(functional-interfaces): add in-depth explanation of functional interfaces and their role in lambdas

What
- Added documentation covering the concept of Functional Interfaces in Java.
- Detailed explanation includes:
  1. Definition → interface with exactly one abstract method.
  2. Annotation → use of @FunctionalInterface for compiler enforcement.
  3. Purpose → enabling lambda expressions by providing a single abstract target.
  4. Built-in examples from `java.util.function` (Runnable, Callable, Comparator, Function, Predicate, Consumer, Supplier).
  5. Relation with lambda expressions → lambdas as concise implementations of single abstract methods.
  6. Benefits → reduced boilerplate, improved readability, functional programming support.
- Included a Quick Recap section for concise review.

Why
- Clarifies how Functional Interfaces serve as the foundation for Java’s functional programming model introduced in Java 8.
- Provides both theoretical understanding and practical examples of their necessity.
- Highlights their central role in APIs like Streams and concurrency utilities.

Logic
1. Functional Interface = only one abstract method.
2. Can still contain default and static methods (do not count toward abstract method restriction).
3. Lambdas require a functional interface to bind to; compiler uses the interface’s abstract method signature as the contract.
4. Built-in interfaces (Predicate, Function, Supplier, Consumer, etc.) demonstrate common functional patterns.
5. Annotation `@FunctionalInterface` is optional but ensures compile-time safety.
6. Benefits include:
   - Less boilerplate (compared to anonymous classes).
   - Contract-based lambda usage.
   - Cleaner APIs in functional-style programming.

Real-life applications
- Stream API operations (`map`, `filter`, `forEach`) rely on functional interfaces like Predicate, Function, Consumer.
- Concurrency (`Runnable`, `Callable`) simplified with lambdas for background tasks.
- Event-driven programming (listeners, callbacks) implemented concisely.
- APIs designed with extensibility: adding default/static methods without breaking existing implementations.

Notes
- Adding more than one abstract method breaks functional interface contract.
- Default methods can provide backward compatibility in evolving APIs.
- Static methods in interfaces are utility methods, called via the interface name.

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

Author: Someshdiwan

Java 8 Crash Course/Functional Interface/src/Functional Interface.txt

@@ -0,0 +1,40 @@
+🔹 Functional Interface in Java:
+	1.	Definition
+	•	A Functional Interface is an interface that contains exactly one abstract method.
+	•	It can have multiple default or static methods, but only one abstract method.
+	•	They are the foundation for Lambda Expressions.
+
+	2.	Annotation
+	•	Marked with @FunctionalInterface annotation (optional, but recommended).
+	•	Compiler enforces that only one abstract method is present.
+
+	3.	Why Functional Interface?
+	•	Lambda expressions need a target type (something to map them to).
+	•	Functional Interfaces provide that single abstract method → so lambda knows what to implement.
+
+	4.	Examples of Built-in Functional Interfaces (from java.util.function package):
+	•	Runnable → void run()
+	•	Callable<T> → T call()
+	•	Comparator<T> → int compare(T a, T b)
+	•	Function<T, R> → R apply(T t)
+	•	Predicate<T> → boolean test(T t)
+	•	Consumer<T> → void accept(T t)
+	•	Supplier<T> → T get()
+
+	5.	Relation with Lambdas
+	•	A lambda expression is just a shorter way of implementing the single abstract method of a functional interface.
+	•	Example: Instead of writing an anonymous class for Runnable, you just write a lambda.
+
+	6.	Benefits
+	•	Reduces boilerplate code (no need for long anonymous class definitions).
+	•	Provides a contract for lambda expressions.
+	•	Improves readability, especially in APIs like Streams, where behavior (functions) is passed around.
+
+⸻
+
+Quick Recap:
+•	Functional Interface = exactly one abstract method.
+•	Marked with @FunctionalInterface.
+•	Used as the target type for lambdas.
+•	Java provides many built-in ones (Predicate, Function, Supplier, Consumer).
+•	Enables functional programming style in Java.