feat(static-methods-in-interfaces): demonstrate static main method in class and interface

What
- Added `MyClass` with a standard `public static void main` method that prints "Hello".
- Added `MyInterface` containing its own `public static void main` method:
  - Proves that static methods (including `main`) are allowed inside interfaces (Java 8+).
- Both can be executed independently:
  - `MyClass.main()` → prints "Hello".
  - `MyInterface.main()` → prints "Hello".

Why
- Java 8 introduced static methods in interfaces to support utility-like behaviors.
- Demonstrates that interfaces are no longer restricted to abstract contracts only; they can now also:
  - Host reusable helper methods.
  - Contain entry points (main method) for testing or running logic.

Logic
1. `MyClass`:
   - Regular class with `main` method → standard entry point.
2. `MyInterface`:
   - Declares a static `main` method.
   - Unlike default methods, static methods in interfaces are **not inherited** by implementing classes.
   - They must be called via the interface name.

Real-life applications
- Interfaces can define **static utility methods** (e.g., `Comparator.naturalOrder()`, `Collections.emptyList()`).
- Useful for grouping helper logic directly inside the interface, avoiding separate utility classes.
- Adding `main` inside an interface is occasionally used for:
  - Quick testing/demo of interface behavior.
  - Running small examples without creating extra classes.

Notes
- Static methods in interfaces:
  - Cannot be overridden by implementing classes.
  - Must be called with the interface name, not via instance.
- Demonstrates flexibility added in Java 8 for backward compatibility and reducing boilerplate.

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

Author: Someshdiwan

Java 8 Crash Course/Functional Interface/Static Methods/src/Package/MyInterface.java

@@ -0,0 +1,7 @@
+package Package;
+
+public interface MyInterface {
+    public static void main(String[] args) {
+        System.out.println("Hello");
+    }
+}