feat(interfaces): add DefaultMethodExample showcasing abstract, default, and static methods in interfaces

What
- Introduced `Vehicle` interface with:
  - `start()` → abstract method requiring implementation.
  - `fuel()` → default method providing a base implementation.
  - `service()` → static utility method accessible via interface name.
- Added `Car` and `Bike` classes:
  - Both override `start()` with class-specific logic.
  - `Car` reuses default `fuel()` method.
  - `Bike` overrides `fuel()` to provide custom behavior.
- Added `DefaultMethodExample` main driver class to demonstrate usage.

Why
- Default methods (introduced in Java 8) allow adding new functionality to interfaces without breaking existing implementations.
- Static methods in interfaces provide utility-like behavior tied to the interface itself.
- Example demonstrates how to:
  1. Implement abstract methods in classes.
  2. Use or override default methods flexibly.
  3. Call static methods directly from the interface.

Logic
1. **Interface structure**:
   - `start()` = abstract, must be implemented in all classes.
   - `fuel()` = default method, can be inherited as-is or overridden.
   - `service()` = static, called via `Vehicle.service()`.
2. **Class Car**:
   - Implements `start()` with ignition logic.
   - Inherits default `fuel()` behavior from `Vehicle`.
3. **Class Bike**:
   - Implements `start()` with self-start logic.
   - Overrides `fuel()` to define petrol-specific behavior.
4. **Main flow**:
   - Demonstrates polymorphism (`Vehicle` reference calling concrete methods).
   - Shows default method reuse vs. override.
   - Calls static method using interface name.

Real-life applications
- API evolution: Adding new methods to interfaces (e.g., Java Collections API methods like `forEach`, `removeIf`).
- Reducing code duplication: Shared logic (e.g., logging, resource checks) can be defined once in a default method.
- Providing common utilities: Static methods inside interfaces (e.g., `Comparator.comparing()`).

Notes
- Default methods resolve backward compatibility problems in evolving APIs.
- If two interfaces provide the same default method, implementing classes must override to resolve ambiguity.
- Static methods in interfaces are **not inherited** and must be called with the interface name.

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

Author: Someshdiwan

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

@@ -0,0 +1,67 @@
+// Interface with the default method.
+interface Vehicle {
+    void start();
+    // abstract method
+
+    // Default method with implementation
+    default void fuel() {
+        System.out.println("Vehicle needs fuel");
+    }
+
+    // Static method also allowed in interface (Java 8+)
+    static void service() {
+        System.out.println("Vehicle service check");
+    }
+}
+
+class Car implements Vehicle {
+    @Override
+    public void start() {
+        System.out.println("Car starts with key ignition");
+    }
+}
+
+class Bike implements Vehicle {
+    @Override
+    public void start() {
+        System.out.println("Bike starts with self start button");
+    }
+
+    // Overriding the default method (optional)
+    @Override
+    public void fuel() {
+        System.out.println("Bike runs on petrol (default overridden)");
+    }
+}
+
+public class DefaultMethodExample {
+    public static void main(String[] args) {
+        Vehicle car = new Car();
+        car.start();  // Calls abstract method from Car
+        car.fuel();   // Calls default method from Vehicle
+
+        Vehicle bike = new Bike();
+        bike.start(); // Calls abstract method from Bike
+        bike.fuel();  // Calls overridden version in Bike
+
+        // Static method called from the interface itself
+        Vehicle.service();
+    }
+}
+
+/*
+1.	Abstract Method:
+•	void start(); → must be implemented by every class.
+
+2.	Default Method:
+•	default void fuel() → already has a body.
+•	Implementing classes can either use it directly OR override it.
+
+3.	Static Method:
+•	static void service() → called using the interface name (Vehicle.service()), not on objects.
+
+4.	Classes Car & Bike:
+•	Both override start() (abstract method).
+•	Car uses the default fuel() directly.
+•	Bike overrides fuel() to provide its own behavior.
+*/