feat(interfaces): add example demonstrating static methods, default methods, and conflict resolution

What
- Created `interface A` and `interface B`:
  - Both declare a static utility method `util()` with unique implementations.
  - Both provide a default instance method `sayHello()`.
- Implemented `MyClass` that implements both A and B:
  - Overrides `sayHello()` to resolve the diamond problem (conflicting defaults).
  - Defines its own class-level static method `util()` (distinct from interface static methods).
- In `main`:
  - Invokes static methods from `A.util()` and `B.util()`.
  - Invokes `MyClass.util()` to show class-level static.
  - Creates an instance of `MyClass` and calls the overridden `sayHello()`.

Why
- Demonstrates key Java 8+ interface enhancements:
  - **Static methods in interfaces**: callable via `InterfaceName.method()`, never inherited.
  - **Default methods**: provide reusable behavior but require resolution if multiple interfaces define the same method.
  - **Conflict resolution rule**: class must override when two interfaces provide the same default method.
- Clarifies the separation:
  - Interface static methods ≠ Class static methods (no overriding).
  - Default methods can be inherited but must be disambiguated in case of collisions.

Logic
1. Static methods in interfaces:
   - Invoked using `InterfaceName.util()`.
   - Not accessible through implementing class instances.
2. Default methods:
   - Inherited if no conflict.
   - If conflict exists (A.sayHello vs B.sayHello), implementing class **must** override.
3. Class static method in `MyClass`:
   - Independent of interface static methods.
   - Demonstrates namespace separation.
4. Execution flow in `main`:
   - Prints messages from A.util, B.util, MyClass.util.
   - Instance call prints the resolved overridden method.

Real-life applications
- **Library evolution**: default methods allow adding new behaviors to interfaces without breaking existing implementations.
- **Utility methods**: static interface methods are a clean way to package helper logic (like `Comparator.comparing()`).
- **Conflict handling**: common in mixin-style design where multiple interfaces provide reusable methods.

Notes
- Interface static methods are hidden, not overridden by implementing classes.
- Default methods can call `InterfaceName.super.method()` if partial delegation is desired.
- Since Java 9, interfaces can also have private static and **private instance methods for internal reuse.

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

Author: Someshdiwan

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

@@ -0,0 +1,54 @@
+interface A {
+    // static helper method on interface A
+    static void util() {
+        System.out.println("A.util(): interface static method");
+    }
+
+    // default instance method (for comparison)
+    default void sayHello() {
+        System.out.println("A says Hello (default)");
+    }
+}
+
+interface B {
+    static void util() {
+        System.out.println("B.util(): interface static method");
+    }
+
+    default void sayHello() {
+        System.out.println("B says Hello (default)");
+    }
+}
+
+public class MyClass implements A, B {
+    // override required for conflicting default instance methods
+    @Override
+    public void sayHello() {
+        System.out.println("MyClass: resolved default method conflict");
+    }
+
+    // This is a class static method, not an override of A.util()
+    // (You can define one, but it's separate.)
+    public static void util() {
+        System.out.println("MyClass.util(): class static method");
+    }
+
+    public static void main(String[] args) {
+        // Call interface static methods using the interface name
+        A.util(); // prints: A.util(): interface static method
+        B.util(); // prints: B.util(): interface static method
+
+        // Call class static method
+        MyClass.util(); // prints: MyClass.util(): class static method
+
+        // Instance default method (overridden)
+        MyClass obj = new MyClass();
+        obj.sayHello(); // prints: MyClass: resolved default method conflict
+
+        // Trying to call interface static via instance is NOT idiomatic and not allowed:
+        // obj.util(); // <-- compile-time error: cannot find symbol (util on instance)
+        // You must use InterfaceName.util()
+
+        // If an interface provides a private static helper (Java 9+), it's internal and not visible outside.
+    }
+}