A class implements an interface using the implements keyword.

All methods in an interface are implicitly public abstract (before Java 8).

All fields in an interface are implicitly public static final.

Cannot be instantiated.

A class can implement multiple interfaces (achieves multiple inheritance of type).

An interface can extend other interfaces.

3.2. Java 8+ Enhancements

Default Methods: Methods with an implementation. Allows adding new methods to interfaces without breaking existing implementing classes.
```
public default void log(String msg) {
  System.out.println("Log: " + msg);
}
```

Static Methods: Utility methods that belong to the interface itself, not instances.

public static void showInfo() {
  System.out.println("This is an interface utility.");
}

Private Methods (Java 9+): Helper methods for default/static methods within the interface.

3.3. Use Cases

When you want to define a contract for what a class can do, without specifying "how".
When you need to achieve multiple inheritance of type (a class can implement multiple interfaces).
To decouple components and promote loose coupling.
To define common behavior that unrelated classes might share.

3.4. Practice: Interface Example

Consider a Flyable interface for objects that can fly.

// Interface
interface Flyable {
  // Implicitly public static final
  int MAX_ALTITUDE = 10000;

  // Implicitly public abstract
  void takeOff();
  void land();
  void fly();

  // Default method (Java 8+)
  default void reportStatus() {
    System.out.println("Current status: Flying or on ground.");
  }

  // Static method (Java 8+)
  static void displayFlightRules() {
    System.out.println("All flying objects must follow air traffic rules.");
  }
}

// Class implementing the interface
class Airplane implements Flyable {
  @Override
  public void takeOff() {
    System.out.println("Airplane taking off.");
  }

  @Override
  public void land() {
    System.out.println("Airplane landing.");
  }

  @Override
  public void fly() {
    System.out.println("Airplane flying at " + MAX_ALTITUDE + " feet.");
  }
}

// Another class implementing the interface
class Bird implements Flyable {
  @Override
  public void takeOff() {
    System.out.println("Bird flapping wings and taking off.");
  }

  @Override
  public void land() {
    System.out.println("Bird gliding to land.");
  }

  @Override
  public void fly() {
    System.out.println("Bird flying freely.");
  }

  // Can override default methods if needed
  @Override
  public void reportStatus() {
    System.out.println("Bird status: Chirping and soaring.");
  }
}

// Main class to test
public class InterfaceDemo {
  public static void main(String[] args) {
    Airplane a = new Airplane();
    Bird b = new Bird();

    a.takeOff();
    a.fly();
    a.land();
    a.reportStatus(); // Using default method

    System.out.println("---");

    b.takeOff();
    b.fly();
    b.land();
    b.reportStatus(); // Using overridden default method

    // Using static method
    Flyable.displayFlightRules();

    // Polymorphism with interface
    Flyable f1 = new Airplane();
    Flyable f2 = new Bird();

    System.out.println("--- Polymorphic calls ---");
    f1.fly();
    f2.fly();
  }
}

4. Abstract Class vs. Interface

Feature	Abstract Class	Interface
Type	Class (can have state and behavior)	Blueprint (contract for behavior)