feat: Demonstrate multiple inheritance in Java using interfaces Walkable and Swimmable with Duck implementation

WHAT the code does:
- Declares interface Walkable with abstract method walk().
- Declares interface Swimmable with abstract method swim().
- Defines class Duck:
  - Implements both Walkable and Swimmable.
  - Provides concrete implementations of walk() and swim(), printing duck-specific behavior.
- In MultipleInheritanceUsingInterfaces.main():
  - Creates a Duck object.
  - Calls walk() and swim() to demonstrate the behavior.

WHY this matters:
- Java does not support multiple class inheritance (a class can extend only one class), but it does support multiple interface inheritance.
- This pattern allows a class to inherit multiple capabilities, promoting flexible and modular design.
- Interfaces represent “abilities” or “roles” (e.g., walk, swim), while the implementing class ties them together into a concrete entity.
- Encourages composition of behaviors without introducing ambiguity or the diamond problem found in multiple class inheritance.

HOW it works:
1. Interfaces Walkable and Swimmable define capabilities (walking and swimming).
2. Duck implements both, making it contractually obliged to define walk() and swim().
3. At runtime, Duck objects can be used wherever Walkable or Swimmable references are required, enabling polymorphism.
4. In main(), duck.walk() and duck.swim() trigger the Duck’s implementations.

Tips and gotchas:
- Always use interface names as abilities or roles (Walkable, Swimmable, Flyable) — it improves readability.
- A class can implement any number of interfaces but extend only one class.
- Interfaces define contracts, not state — fields should be avoided except for constants.
- Use polymorphism: Duck can be referenced as Walkable w = new Duck(); w.walk(); — this limits the reference to the walk() ability only.

Use-cases / analogies:
- Animals in biology: ducks can both walk and swim, dolphins swim but don’t walk, humans walk but can’t naturally swim well — different classes can combine interfaces differently.
- Vehicles: an AmphibiousCar could implement both Drivable and Swimmable.
- Game design: characters may implement multiple roles (Attackable, Healable, Movable) simultaneously.

Short key: java-interfaces multiple-inheritance duck walkable-swimmable polymorphism.

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

Author: Someshdiwan

Section14Interfaces/src/MultipleinheritanceUsingInterfaces.java

@@ -1,40 +1,37 @@
 /*
-Multiple Inheritance is a feature of an object-oriented concept, where a class can inherit properties of more than one parent class. The problem occurs when methods with the same signature exist in both the superclasses and subclass.
+Multiple Inheritance is a feature of an object-oriented concept, where a class can inherit properties of more than one
+parent class.
+The problem occurs when methods with the same signature exist in both the superclasses and subclass.
 On calling the method, the compiler cannot determine which class method to be called and even on calling which
 class method gets the priority.
 
 Declare the interfaces
 */
-interface Walkable
-{
+
+interface Walkable {
     void walk();
 }
 
-interface Swimmable
-{
+interface Swimmable {
     void swim();
 }
 
 // Implement the interfaces in a class
-class Duck implements Walkable, Swimmable
-{
-    public void walk()
-    {
+class Duck implements Walkable, Swimmable {
+    public void walk() {
         System.out.println("Duck is walking.");
     }
-    public void swim()
-    {
+
+    public void swim() {
         System.out.println("Duck is swimming.");
     }
 }
 
 // Use the class to call the methods from the interfaces
-class MultipleInheritanceUsingInterfaces
-{
-    public static void main(String[] args)
-    {
+class MultipleInheritanceUsingInterfaces {
+    public static void main(String[] args) {
         Duck duck = new Duck();
         duck.walk();
         duck.swim();
     }
-}
+}