Implementing Java Interfaces

The Interface as a Contract

At its heart, an interface is a contract. It declares what a class can do, without specifying how it does it. Imagine a contract for a "drivable" vehicle. The contract would state that any drivable vehicle must be able to startEngine(), accelerate(), and brake(). It doesn't care if it's a gasoline car, an electric car, or a hovercraft; as long as a class implements these capabilities, it fulfills the "drivable" contract.

This separation of "what" (the interface) from "how" (the implementation) is a form of abstraction, a core principle of good software design.

The following video from JavaTutorialTV provides an excellent analogy for this concept.

Defining and Implementing an Interface

Now, let's translate this concept into Java code. You define an interface using the interface keyword. Inside, you declare methods without a body (these are implicitly public and abstract). You can also define constants (which are implicitly public, static, and final—a direct link to our previous lessons!).

A class then uses the implements keyword to agree to this contract. When it does, the Java compiler enforces the contract: the class must provide a concrete implementation for every method declared in the interface.

Let's look at the syntax and a simple example.

To see this process in a more dynamic way, let's return to the Vehicle example from the video. The following segment shows the programmer defining the Vehicle interface and then creating a HondaAccord class that implements it. Notice how the development environment (Eclipse) flags an error until all the methods from the interface are implemented.

The Power of Interfaces: Multiple Inheritance

Here we arrive at a crucial feature. In Java, a class can only extend one other class (single inheritance). This can be limiting. What if an object needs to have behaviors from multiple, unrelated sources?

Interfaces solve this problem. A class can implement multiple interfaces. This allows a class to inherit different "contracts" or behaviors, a powerful form of multiple inheritance of type.

The diagram below visualizes these relationships. A class extends another class, an interface extends another interface, but a class implements an interface.

The "Bro Code" channel has a creative and effective video explaining this with Prey and Predator interfaces. A Rabbit might only be prey, and a Hawk only a predator, but a Fish could be both.

Let's recap what you saw in the video with a code snippet:

// Contract for things that can be hunted
interface Predator {
    void hunt();
}

// Contract for things that run away
interface Prey {
    void flee();
}

// This class implements BOTH contracts
class Fish implements Prey, Predator {

    @Override
    public void hunt() {
        System.out.println("This fish is hunting smaller fish");
    }

    @Override
    public void flee() {
        System.out.println("This fish is fleeing from a larger fish");
    }
}

// This class only implements one contract
class Rabbit implements Prey {
    @Override
    public void flee() {
        System.out.println("The rabbit is fleeing!");
    }
}

This ability to mix and match behaviors is fundamental to many design patterns, allowing you to create components that are both specialized and flexible.

Conclusion

In this lesson, we've established the critical role of interfaces in Java. They are the primary mechanism for defining abstract contracts that concrete classes can then implement.

Here are the key takeaways:

• An interface is a blueprint or contract that defines a set of abstract methods and constants.
• A class uses the implements keyword to agree to this contract and must provide a concrete implementation for all the interface's methods.
• Interfaces allow for a form of multiple inheritance, as a single class can implement multiple interfaces, adopting several distinct contracts.
• This mechanism is key to achieving abstraction, separating what a component does from how it does it.

You might be thinking, "This sounds a bit like what an abstract class does." You're right, there are similarities! However, they have distinct purposes and use cases. In our next lesson, we will dive into abstract classes, compare them directly with interfaces, and learn how to decide when to use each one. This will complete our foundational understanding of polymorphism in Java.