Java implements Keyword
Usage and Examples

implements Keyword in Java

In Java, the implements keyword is used when a class wants to implement an interface. Unlike classes that are extended using the extends keyword, interfaces define a contract of abstract methods that any implementing class must fulfill.

Why Use implements?

Java does not support multiple inheritance with classes, but it allows a class to implement multiple interfaces. This offers a flexible and clean way to achieve abstraction and polymorphism.

Basic Syntax

class ClassName implements InterfaceName {
    // Implementation of methods from the interface
}

Example: Implementing a Single Interface

interface Animal {
    void makeSound();
}

class Dog implements Animal {
    public void makeSound() {
        System.out.println("Bark!");
    }
}

public class Main {
    public static void main(String[] args) {
        Dog dog = new Dog();
        dog.makeSound();
    }
}

Bark!

Explanation

The Animal interface declares a method makeSound(). The Dog class uses implements to declare that it will provide its own definition of makeSound(). When we call the method on the object, it prints Bark!.

Implementing Multiple Interfaces

Java allows a class to implement more than one interface by separating them with commas.

interface Flyable {
    void fly();
}

interface Swimmable {
    void swim();
}

class Duck implements Flyable, Swimmable {
    public void fly() {
        System.out.println("Duck is flying!");
    }

    public void swim() {
        System.out.println("Duck is swimming!");
    }
}

public class Main {
    public static void main(String[] args) {
        Duck duck = new Duck();
        duck.fly();
        duck.swim();
    }
}

Duck is flying!
Duck is swimming!

What Happens If You Don’t Implement All Methods?

If a class does not implement all the abstract methods of the interface, it must be declared as abstract. Otherwise, the compiler will throw an error.

interface Shape {
    void draw();
    void resize();
}

abstract class AbstractShape implements Shape {
    public void draw() {
        System.out.println("Drawing shape...");
    }
    // resize() is not implemented here
}

Common Use Case: Polymorphism with Interfaces

interface Printer {
    void print();
}

class TextPrinter implements Printer {
    public void print() {
        System.out.println("Printing text...");
    }
}

class ImagePrinter implements Printer {
    public void print() {
        System.out.println("Printing image...");
    }
}

public class Main {
    public static void main(String[] args) {
        Printer p1 = new TextPrinter();
        Printer p2 = new ImagePrinter();

        p1.print();
        p2.print();
    }
}

Printing text...
Printing image...

Key Points to Remember

• The implements keyword is used by classes to adopt an interface.
• All methods in the interface must be implemented unless the class is abstract.
• Interfaces only contain abstract methods (until Java 8, after which default and static methods are allowed).
• You can implement multiple interfaces, separated by commas.

When to Use implements

Use implements when:

• You want to define a contract that multiple classes can follow.
• You want to achieve multiple inheritance behavior without class-based complexity.
• You want your code to be more modular, testable, and reusable.