Implements vs. Extends in Java

1. Overview

In this tutorial, we’ll discuss inheritance, one of the crucial concepts of Object-Oriented Programming. In Java, the two main keywords used for inheritance are extends and implements.

2. extends vs. implements

Let’s discuss the differences between both the keywords.

We use the extends keyword to inherit properties and methods from a class. The class that acts as a parent is called a base class, and the class that inherits from this base class is called a derived or a child class. Mainly, the extends keyword is used to extend the functionality of a parent class to the derived classes. Also, a base class can have many derived classes, but a derived class can have only one base class because Java doesn’t support multiple inheritance.

On the other hand, we use the implements keyword to implement an interface. An interface consists only of abstract methods. A class will implement the interface and define these abstract methods as per the required functionality. Unlike extends, any class can implement multiple interfaces.

Although both the keywords align with the concept of inheritance, the implements keyword is primarily associated with abstraction and used to define a contract, and extends is used to extend a class’s existing functionality.

3. Implementation

Let’s jump to the implementation and have look at extends, implements, and multiple inheritance one by one, in detail.

3.1. extends

Let’s start by creating a class called Media that has id, title, and artist. This class will act as a base class. VideoMedia and AudioMedia will extend the functionality of this class:

public class Media {

    private int id;
    private String title;
    private String artist;
    // standard getters and setters
}

Now, let’s create another class called VideoMedia that extends the class Media, inheriting its properties. Additionally, it has its own properties like resolution and aspectRatio:

public class VideoMedia extends Media {

    private String resolution;
    private String aspectRatio;
    // standard getters and setters
}

Similarly, the class AudioMedia also extends the class Media and will have its own additional properties like bitrate and frequency:

public class AudioMedia extends Media {

    private int bitrate;
    private String frequency;
    // standard getters and setters

    @Override
    public void printTitle() {
        System.out.println("AudioMedia Title");
    }
}

Let’s create objects for the base and derived classes to look at the inherited properties:

Media media = new Media();
media.setId(001);
media.setTitle("Media1");
media.setArtist("Artist001");

AudioMedia audioMedia = new AudioMedia();
audioMedia.setId(101);
audioMedia.setTitle("Audio1");
audioMedia.setArtist("Artist101");
audioMedia.setBitrate(3500);
audioMedia.setFrequency("256kbps");

VideoMedia videoMedia = new VideoMedia();
videoMedia.setId(201);
videoMedia.setTitle("Video1");
videoMedia.setArtist("Artist201");
videoMedia.setResolution("1024x768");
videoMedia.setAspectRatio("16:9");

System.out.println(media);
System.out.println(audioMedia);
System.out.println(videoMedia);

All three classes print the associated properties:

Media{id=1, title='Media1', artist='Artist001'}
AudioMedia{id=101, title='Audio1', artist='Artist101', bitrate=3500, frequency='256kbps'} 
VideoMedia{id=201, title='Video1', artist='Artist201'resolution='1024x768', aspectRatio='16:9'} 

3.2. implements

In order to understand abstraction and interfaces, we’ll create an interface MediaPlayer that has two methods called play and pause. As mentioned before, all the methods in this interface are abstract. In other words, the interface contains only method declarations.

In Java, interfaces don’t need to explicitly declare a method as abstract or public. The classes that implement the interface MediaPlayer will define these methods:

public interface MediaPlayer {

    void play();

    void pause();
}

The AudioMediaPlayer class implements MediaPlayer, and it’ll define the play and pause methods for audio media:

public class AudioMediaPlayer implements MediaPlayer {

    @Override
    public void play() {
        System.out.println("AudioMediaPlayer is Playing");
    }

    @Override
    public void pause() {
        System.out.println("AudioMediaPlayer is Paused");
    }
}

Similarly, VideoMediaPlayer implements MediaPlayer and provides a method definition to play and pause video media:

public class VideoMediaPlayer implements MediaPlayer {

    @Override
    public void play() {
        System.out.println("VideoMediaPlayer is Playing");
    }

    @Override
    public void pause() {
        System.out.println("VideoMediaPlayer is Paused");
    }
}

Further, let’s create an instance of AudioMediaPlayer and VideoMediaPlayer and call play and pause methods for both of them:

AudioMediaPlayer audioMediaPlayer = new AudioMediaPlayer();
audioMediaPlayer.play();
audioMediaPlayer.pause();

VideoMediaPlayer videoMediaPlayer = new VideoMediaPlayer();
videoMediaPlayer.play();
videoMediaPlayer.pause();

AudioMediaPlayer and VideoMediaPlayer call their respective implementations of play and pause:

AudioMediaPlayer is Playing
AudioMediaPlayer is Paused

VideoMediaPlayer is Playing
VideoMediaPlayer is Paused

3.3. Multiple Inheritance

Java doesn’t support multiple inheritance directly due to ambiguity issues. An ambiguity issue occurs when a class inherits from more than one parent class, and both the parent classes have a method or property with the same name. Hence, the child class cannot resolve the conflict of the method or property to be inherited. However, a class can inherit from multiple interfaces. Let’s create an interface AdvancedPlayerOptions:

public interface AdvancedPlayerOptions {

    void seek();

    void fastForward();
}

Class MultiMediaPlayer implements MediaPlayer and AdvancedPlayerOptions and defines the methods declared in both the interfaces:

public class MultiMediaPlayer implements MediaPlayer, AdvancedPlayerOptions {

    @Override
    public void play() {
        System.out.println("MultiMediaPlayer is Playing");
    }

    @Override
    public void pause() {
        System.out.println("MultiMediaPlayer is Paused");
    }

    @Override
    public void seek() {
        System.out.println("MultiMediaPlayer is being seeked");
    }

    @Override
    public void fastForward() {
        System.out.println("MultiMediaPlayer is being fast forwarded");
    }
}

Now, we’ll create an instance of MultiMediaPlayer class and call all the implemented methods:

MultiMediaPlayer multiMediaPlayer = new MultiMediaPlayer();
multiMediaPlayer.play();
multiMediaPlayer.pause();
multiMediaPlayer.seek();
multiMediaPlayer.fastForward();

As expected, MultiMediaPlayer calls its implementations of play and pause:

MultiMediaPlayer is Playing
MultiMediaPlayer is Paused 
MultiMediaPlayer is being seeked 
MultiMediaPlayer is being fast forwarded

4. Conclusion

In this tutorial, we discussed the significant differences between extends and implements. Furthermore, we created classes and interfaces to demonstrate the concepts of extends and implements. Also, we discussed multiple inheritance and how we can achieve it using interfaces.