Interfaces

• What is it?

  • An interface is a category of items. Each item in the category can do the same basic things, but do them slightly differently.
  • Interfaces let you group classes under a category, based on the common methods they have.
  • By grouping classes under an interface, you can:
    • Inherit its methods and reimplement them instead of copy-paste-editing. You ca
    • Reference any class in the category by referencing the category.

• How to implement

  // interface
  interface Animal {
    public void animalSound(); // interface method (does not have a body)
    public void sleep(); // interface method (does not have a body)
  }
  
  // Pig "implements" the Animal interface
  class Pig implements Animal {
    public void animalSound() {
      // The body of animalSound() is provided here
      System.out.println("The pig says: wee wee");
    }
    public void sleep() {
      // The body of sleep() is provided here
      System.out.println("Zzz");
    }
  }
  
  class MyMainClass {
    public static void main(String[] args) {
      Pig myPig = new Pig();  // Create a Pig object
      myPig.animalSound();
      myPig.sleep();
    }
  }
  
  // Implementing multiple
  

  • Interfaces only have methods
    • Each method is abstract, it has no body
    • Used to implement different versions of the same base abstract method
  • Can be implemented (similar to inheritance extends) to other classes
    • Each extended class has a unique implementation of the interface method
    • Interface method body is defined under each extended class

• Benefits

  • Abstraction: hide essential data from users
  • Reuse the same methods several times in different ways per (make less methods)
    • Can implement methods from multiple interfaces into a single class (multiple inheritance alternative)

Interface vs Abstract Class

• Interfaces support multiple inheritance, but are usually only used to inherit methods. Abstract classes only support single inheritance, but can inherit methods.
• Similarities
  • Both are abstract.
    • This means they can have both abstract methods (methods with an empty body) or concrete methods
• Differences
  • Multiple inheritance
    • You can have a subclass implement multiple interfaces, but you can’t have it inherit multiple abstract classes. No multiple inheritance in Java.
  • Fields
    • An interface’s fields must be static and final. This means you can assign an interface fields and access them, but they’ll be constances. You can’t change them.
    • An abstract class can have normal fields, like a standard class

Use Cases

1. Use an interface when:
   1. You want to give some Metadata to a class describing it.
      • Serializable, Feedable.
   2. You have multiple classes in the same general category, with similar operations, but each one does it slightly differently.
   3. You want to have a subclass inherit from multiple parent classes.
2. Use an abstract class for inheritance if:
   • You don’t want to have to implement every method in the parent.
   • And you want to inherit fields that aren’t constants and modify them.