feat(interfaces): resolve multiple default method conflict by overriding in implementing class

What
- Added `MyClass` implementing both `A` and `B`, each providing a default `sayHello()`.
- Overrode `sayHello()` directly in `MyClass`, replacing inherited defaults with a custom implementation.
- New output: `"MyClass says Hello (overridden)"`.

Why
- Demonstrates Java’s rule that when multiple interfaces define the same default method, ambiguity must be resolved.
- Shows the **resolution strategy** where the class itself overrides the method, eliminating conflicts by taking full control.
- Reinforces Java’s precedence rule: **class methods > interface defaults**.

Logic
1. **Interface A**: defines default `sayHello()` → prints `"A says Hello"`.
2. **Interface B**: defines default `sayHello()` → prints `"B says Hello"`.
3. **MyClass**:
   - Implements both `A` and `B`, causing conflict on `sayHello()`.
   - Provides its own override of `sayHello()`, printing `"MyClass says Hello (overridden)"`.
   - This override **completely replaces** interface defaults instead of delegating to one of them.
4. **Execution flow**:
   - `new MyClass().sayHello();`
   - Compiler resolves to the class override.
   - Output: `"MyClass says Hello (overridden)"`.

Real-life applications
- **API evolution**: When interfaces evolve to include defaults, implementing classes can override to enforce custom behavior instead of choosing one default.
- **Framework design**: Useful in cases where neither parent default is suitable (e.g., logging strategies, error handling, business rules).
- **Conflict resolution**: Clear example of Java’s design principle where classes take precedence over interfaces in multiple inheritance.

Notes
- If `MyClass` had not overridden `sayHello()`, compilation would fail:
  *"class MyClass inherits unrelated defaults for sayHello() from types A and B"*.
- Three main resolution strategies for multiple default conflicts:
  1. **Override in the class** (this example).
  2. **Delegate to one parent’s default** (`A.super.sayHello()` or `B.super.sayHello()`).
  3. **Combine multiple defaults** (call both, then add extra logic).
- This version demonstrates the cleanest approach: override and redefine, ensuring no ambiguity remains.

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

Author: Someshdiwan

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

@@ -0,0 +1,29 @@
+package Package3;
+
+interface A {
+    default void sayHello() {
+        System.out.println("A says Hello");
+    }
+}
+
+interface B {
+    default void sayHello() {
+        System.out.println("B says Hello");
+    }
+}
+
+/**
+ * Resolution strategy: override the default method in the implementing class.
+ * This removes ambiguity because class implementation takes precedence.
+ */
+public class MyClass implements A, B {
+    // Explicit override: resolves conflict and defines class behavior.
+    @Override
+    public void sayHello() {
+        System.out.println("MyClass says Hello (overridden)");
+    }
+    public static void main(String[] args) {
+        MyClass m = new MyClass();
+        m.sayHello(); // prints: MyClass says Hello (overridden)
+    }
+}