Java Advanced OOP: Interfaces and Abstract Classes Tutorial

An interface is a reference type in Java that contains only abstract methods (methods without a body) and constants. It defines a contract that implementing classes must follow.

• Key Features:
  • All methods in an interface are public and abstract by default.
  • All fields in an interface are public, static, and final by default.
  • A class can implement multiple interfaces.
• Example:
  Edit Copy

  interface Animal {
      void makeSound(); // Abstract method
  }
  
  class Dog implements Animal {
      public void makeSound() {
          System.out.println("Bark");
      }
  }
  
  public class Main {
      public static void main(String[] args) {
          Animal myDog = new Dog();
          myDog.makeSound(); // Output: Bark
      }
  }

An abstract class is a class that cannot be instantiated and may contain both abstract methods (without a body) and concrete methods (with a body). It serves as a blueprint for other classes to extend.

• Key Features:
  • Abstract classes can have constructors, fields, and methods (both abstract and concrete).
  • A class can extend only one abstract class.
  • Abstract classes are useful for providing a common base implementation for subclasses.
• Example:
  Edit Copy

  abstract class Shape {
      abstract void draw(); // Abstract method
  
      void display() { // Concrete method
          System.out.println("Displaying shape");
      }
  }
  
  class Circle extends Shape {
      void draw() {
          System.out.println("Drawing a circle");
      }
  }
  
  public class Main {
      public static void main(String[] args) {
          Shape myCircle = new Circle();
          myCircle.draw(); // Output: Drawing a circle
          myCircle.display(); // Output: Displaying shape
      }
  }

Here are the key differences between interfaces and abstract classes:

• Interfaces:
  • Support multiple inheritance (a class can implement multiple interfaces).
  • Cannot have constructors or instance fields.
  • All methods are abstract by default (prior to Java 8).
• Abstract Classes:
  • Do not support multiple inheritance (a class can extend only one abstract class).
  • Can have constructors, instance fields, and concrete methods.
  • Can have abstract methods (methods without a body).

Starting from Java 8, interfaces can have default and static methods with a body.

• Default Methods:
  • Provide a default implementation for methods in an interface.
  • Can be overridden by implementing classes.
• Static Methods:
  • Belong to the interface and cannot be overridden by implementing classes.
  • Can be called using the interface name.
• Example:
  Edit Copy

  interface Vehicle {
      void start(); // Abstract method
  
      default void stop() { // Default method
          System.out.println("Vehicle stopped");
      }
  
      static void honk() { // Static method
          System.out.println("Honk honk!");
      }
  }
  
  class Car implements Vehicle {
      public void start() {
          System.out.println("Car started");
      }
  }
  
  public class Main {
      public static void main(String[] args) {
          Car myCar = new Car();
          myCar.start(); // Output: Car started
          myCar.stop(); // Output: Vehicle stopped
          Vehicle.honk(); // Output: Honk honk!
      }
  }

Choosing between interfaces and abstract classes depends on your design requirements:

• Use Interfaces:
  • When you want to define a contract for multiple unrelated classes.
  • When you need to support multiple inheritance.
  • When you want to provide default behavior using default methods.
• Use Abstract Classes:
  • When you want to provide a common base implementation for related classes.
  • When you need to define non-static or non-final fields.
  • When you want to share code among multiple subclasses.