Many concepts in Java are derived from real-world scenarios. Interfaces as well. If you want to turn on a television, you need to press the power button. This button is the interface between you and the electronics inside the television. Java interfaces have the same behaviour as real-world interfaces (e.g., a television interface): they set strict rules (a blueprint, if you will) on how to interact with objects. As you have already learned, these strict rules can be defined with methods. In fact, Java objects define their interaction with the outside world through the methods that they expose.

In a nutshell, an Interface in Java is an abstract type used to specify how the outside world can interact with the objects that implement the interface.

How to create an Interface?

You create them as you create classes, but you must use the keyword interface instead of class.

Going back to our example with the television, let’s create an Interface called Television with two methods pressOnButton() and pressOffButton()

public interface Television {
    public void pressOnButton();
    public void pressOffButton();
}

The methods pressOnButton(); pressOffButton(); have no body (i.e., no {}), they just end with ;, they are by default abstract. In a nutshell, a Java interface represents a group of (abstract) methods with no bodies.

How to implement an Interface?

Now, we will create a class that implements our interface. Yes, a class does not extends an interface (like we did with classes), it implements it. For example, let’s create a class LCDTelevision.

public class LCDTelevision implements Television {

    @Override
    public void pressOnButton() {
        System.out.println("The television is on");
    }

    @Override
    public void pressOffButton() {
        System.out.println("The television is off");
    }

}

We use the implements keyword in the class declaration. The class gives a compilation error if we do not override the methods declared in the interface Television. The interface Television gives the methods that all the classes that implement a Television must have. In our example, the pressOnButton()and pressOffButton() methods.

The relationship between the interface and the class that implements it can be visualised with a UML-style diagram. The dashed arrow with the open triangle means implements (an interface is drawn with the <<interface>> stereotype above its name):

In UML, a solid arrow with an open triangle means extends (class inheritance), and a dashed arrow with an open triangle means implements (the relationship between a class and an interface it implements). You will see this notation throughout the course and in most Java documentation.

Now, if we want to instantiate an object LCDTelevision we can do:

    public static void main(String[] args) {
        Television lcdTv = new LCDTelevision();
        lcdTv.pressOnButton();
        System.out.println("I am watching TV....");
        lcdTv.pressOffButton();
    }

Note that, interfaces like abstract classes cannot be instantiated (we cannot do Television tv = new Television(); ) we must specify the implementation we want: Television lcdTv = new LCDTelevision()).

    public static void main(String[] args) {
        List<String> names = new ArrayList<String>();
        createNames(names);
    }

    public static void createNames(List<String> names){
        // some code
    }

    public static void main(String[] args) {
        ArrayList<String> names = new ArrayList<String>();
        createNames(names);
    }

    public static void createNames(ArrayList<String> names){
        // some code
    }

What is the difference between an abstract class and an interface?

I believe that right now, you are wondering what is the difference between an abstract class and an interface. You can think about interfaces as being “a really really abstract abstract class. So abstract that it’s no longer a class – it’s now just an interface“. Historically an interface could not contain any implementation at all; since Java 8, interfaces can provide a limited form of implementation via default and static methods (we will see these shortly). A full comparison table is provided at the end of this lecture as a reference, once you have seen interfaces in action.

One of the key differences between interfaces and abstract classes is that you can implement more than one interface in one class (you cannot do this with abstract classes). You just need to separate the interface names with commas in the class declaration. For example, let’s say that we have an interface ElectricalAppliance defined as:

public interface ElectricalAppliance  {
    public void plugIn();
    public void plugOut();
}

Then, our LCDTelevision can implement both interfaces: ElectricalAppliance and Television. Note that in this case, the LCDTelevision class has to provide the implementation of all four methods: pressOnButton, pressOffButton, plugIn, and plugOut.

public class LCDTelevision implements Television, ElectricalAppliance {

    @Override
    public void pressOnButton() {
        System.out.println("The television is on");
    }

    @Override
    public void pressOffButton() {
        System.out.println("The television is off");
    }

    @Override
    public void plugIn() {
        System.out.println("The television is plugged into an electricity supply");
    }

    @Override
    public void plugOut() {
        System.out.println("The television is unplugged from the electricity supply");
    }

}

Why does Java need interfaces to support “multiple inheritance”? Why can’t a class extend multiple classes?

Java does not support “multiple inheritance” (a class can only inherit from one superclass). However, “multiple inheritance” can be achieved with interfaces: a class can implement multiple interfaces.

You might wonder why multiple inheritance is possible with interfaces but not with classes? The answer is because of ambiguity. Two classes might have different implementations of the same method or might have two different functionalities with the same method name. This ambiguity is famously known as the diamond problem: if class D inherited from both B and C, and both B and C inherited the same method from a common parent A (or defined it independently), the JVM would not know which version D should use. The inheritance graph forms a “diamond” shape — hence the name.

For example, let’s assume that Java allows multiple inheritance with classes.

class A {

    public void run() {
        System.out.println("A");
    }

}

class B {

    public void run() {
        System.out.println("B");
    }

}

public class MyClass extends A, B { // ATTENTION extending two classes is not allowed
    // we do it just for making a point :)

    public static void main(String[] args) {
        MyClass obj = new MyClass();
        obj.run(); // Which method should I execute?
    }
}

Should the program print “A” or “B”? The JVM would not be able to decide which method to execute. There is ambiguity. However, there is no ambiguity if we use interfaces. It is because the implementation of the methods is never specified in interfaces. Interfaces specify only what the class is doing, not how it is doing it. How it is doing it must be specified by the class that implements the interface. For example, if we use interfaces, even if two interfaces have the same method names, there is no conflict or ambiguity. This is because it is MyClass that defines the implementation.

interface A {
    public void run();
}

interface B {
    public void run();
}

public class MyClass implements A, B {

    @Override
    public void run() {
        System.out.println("A");
    }

    public static void main(String[] args) {
        MyClass obj = new MyClass();
        obj.run();
    }

}

Can I have an “empty” interface that does not declare any methods?

Yes, you can! Is it something useful? Yes, indeed. For example, let’s say that we want to create a List that contains Vehicles. Vehicles can be very different so I don’t expect that they can share functionalities. So we can use interfaces to just tell the JVM that the List can only contain Vehicle objects.

import java.util.ArrayList;
import java.util.List;

interface Vehicle {
    // empty interface
}

class Car implements Vehicle {
    public void drive(int speed) {
        // some implementation
    }
}

class Airplane implements Vehicle {
    public void fly(int speed, int altitude) {
        // some implementation
    }
}

class Boat implements Vehicle {
    public void sail(int direction, int speed) {
        // some implementation
    }
}

public class MyClass {
    public static void main(String[] args) {
        List<Vehicle> vehicles = new ArrayList<Vehicle>();
        vehicles.add(new Car());
        vehicles.add(new Airplane());
        vehicles.add(new Boat());
    }
}

Can an interface inherit from another interface?

Yes, but instead of using implements you will use extends. In fact: a class extends another class, an interface extends another interface, but a class implements an interface.

For example you can do:

interface A {
    public void funcA();
}

interface B extends A {
    public void funcB();
}

class C implements B {

    @Override
    public void funcA() {
        System.out.println("Implementation function A");
    }

    @Override
    public void funcB() {
        System.out.println("Implementation function B");
    }
}

In this case, the class C must implement both method funcA and funcB.

default methods (Java 8+)

So far, every method declared in an interface has had no body, and every class that implements the interface has been forced to provide an implementation. This is restrictive: if you add a new method to an interface, every existing class that implements it would break (compile error: “does not override abstract method”). This was a real problem when the Java team wanted to add new methods (for example, stream()) to existing interfaces like Collection without breaking the millions of classes that already implemented them.

Since Java 8, an interface can provide a default implementation for a method using the default keyword. Classes that implement the interface can override it, but they don’t have to — they inherit the default for free.

public interface Television {
    public void pressOnButton();
    public void pressOffButton();

    // default method: classes that implement Television get this for free
    default void pressMuteButton() {
        System.out.println("The television is muted (default behaviour)");
    }
}

A class that implements Television does not need to override pressMuteButton() — it can, if it wants to customise the behaviour, but if it doesn’t, the default is used:

public class LCDTelevision implements Television {
    @Override public void pressOnButton()  { System.out.println("The television is on"); }
    @Override public void pressOffButton() { System.out.println("The television is off"); }
    // pressMuteButton() is inherited from the interface's default implementation
}

Key takeaway: default methods let interfaces evolve over time without breaking the code of existing implementers. They are the reason interfaces today are more than just pure “contracts” — they can carry a small amount of shared behaviour, too.

static methods in interfaces (Java 8+)

An interface can also declare static methods — methods that belong to the interface itself, not to any implementing object. These are typically used to provide factory methods or utility helpers related to the interface.

public interface Television {
    public void pressOnButton();
    public void pressOffButton();

    // static factory method: called on the interface, not on an instance
    static Television defaultModel() {
        return new LCDTelevision();
    }
}

// Usage:
Television tv = Television.defaultModel();
tv.pressOnButton();

Note: Since Java 9, interfaces can also declare private methods, used as helpers shared between default methods inside the same interface. You will rarely need them in this course, but it’s useful to know they exist.

Program to an interface, not an implementation

This is one of the most important design principles in object-oriented programming — and you have already seen it in action in the code-style box earlier in this lecture, when we preferred List<String> names = new ArrayList<>(); over ArrayList<String> names = new ArrayList<>();.

“Program to an interface, not an implementation.”

— Design Patterns, Gamma, Helm, Johnson, Vlissides (1994)

The idea is simple: whenever a variable, parameter, or return type could be declared as an interface instead of a concrete class, prefer the interface. This decouples the code that uses an object from the code that produces it: you can swap the implementation later (ArrayList → LinkedList, HashMap → TreeMap, LCDTelevision → OLEDTelevision) without touching any of the surrounding code.

// GOOD — the method works with any List implementation
public void printAll(List<String> items) { ... }

// BAD — the method is tied to ArrayList; a LinkedList cannot be passed in
public void printAll(ArrayList<String> items) { ... }

The same principle applies to the return type of a method: if you return List<String>, you are free to change how the list is built internally without breaking any caller. If you return ArrayList<String>, every caller becomes locked to that choice.

(Summary) Key Facts about Interfaces:

• Interface is a fundamental concept in Java OOP. It is used to achieve abstraction and multiple inheritance.
• An interface typically represents a CAN-DO relationship (a capability), rather than the IS-A relationship expressed by extends. For example, a Bird is a Animal (inheritance), but a Bird can Fly (interface capability — and so can a Plane, which is not an Animal).
• Like abstract classes, interfaces cannot be used to create objects (in the example above, it is not possible to instantiate a “Television” object).
• By default, interface methods have no body — the body is provided by the class that implements the interface.
• Since Java 8, interfaces can also contain default methods (with a body, inherited for free by implementers) and static methods (called on the interface itself). Since Java 9, they can contain private helper methods.
• An interface cannot contain a constructor (as it cannot be used to create objects).
• If a class implements an interface, it must implement all of the interface’s abstract methods (it does not need to override default methods, unless it wants to customise them).
• Interface methods are by default abstract and public.
• Interface attributes are by default public, static and final — i.e. interfaces can only hold constants, never instance state.
• Program to an interface, not an implementation: prefer declaring variables, parameters, and return types using the interface type (e.g. List) rather than the concrete class (ArrayList).

import java.util.ArrayList;
import java.util.List;

public class Mushroom {

 private boolean isPoisonous() {
  System.out.println("check online if it is poisonous...");
  return false; // let's assume it is not
 }

 public void eat() {
  if (!isPoisonous()) {
   System.out.println("eating the mushroom");
  }
 }
}

public class Apple {

 private void peel() {
  System.out.println("peeling the apple");
 }

 public void eat() {
  peel();
  System.out.println("eating the apple");
 }
}

public class Strawberry {

 private void wash() {
  System.out.println("wash the strawberry");
 }

 public void eat() {
  wash();
  System.out.println("eating the strawberry");
 }
}

public class Stone {

 public void examine() {
  System.out.println("examining the stone");
 }

}

public class WoodenStick {

 public void use() {
  System.out.println("use wooden stick to walk");
 }

}

public class Main {

 public static void main(String[] args) {
  List<Object> backpack = new ArrayList<Object>();

  System.out.println("Walking in the forest...");
  System.out.println("I found a beautiful stone...");
  backpack.add(new Stone());
  System.out.println("I found a bush with 10 strawberries");
  for (int i = 0; i < 10; i++) {
   backpack.add(new Strawberry());
  }
  System.out.println("I found a wooden stick");
  backpack.add(new WoodenStick());
  System.out.println("I found 3 mushrooms and 1 apple");
  backpack.add(new Mushroom());
  backpack.add(new Mushroom());
  backpack.add(new Mushroom());
  backpack.add(new Apple());
  System.out.println("another beautiful stone...");
  backpack.add(new Stone());

  System.out.println("I am tired and hungry");
  System.out.println();

  System.out.println(" I want to eat all the eatable items that I found");
  for (Object item : backpack) {
   if (item instanceof Strawberry) {
    ((Strawberry) item).eat();
   } else if (item instanceof Apple) {
    ((Apple) item).eat();
   } else if (item instanceof Mushroom) {
    ((Mushroom) item).eat();
   }
  }
 }

}

Reference: Interface vs. Abstract class

Now that you have used interfaces in the hands-on exercise, the trade-offs with abstract classes should feel more concrete. The table below summarises the key differences (all rows reflect modern Java — Java 21 LTS and later).