Interface in Java

An interface is a contract that classes promise to follow. It defines what a class can do, leaving how to each implementing class. Interfaces enable multiple inheritance of type and form the backbone of frameworks like JDBC, JPA and the Collections API.

• Declare: interface Name { … }
• Implement: class C implements Name { … }
• Multiple: class C implements A, B { … }
• Default method: default void m() { … }

Let's start with a hands-on example. The program below shows the core idea behind Interface in just a few lines of Java. Read it line by line and observe how Java executes each statement in order.

interface Animal
{
    void sound();
}

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

class Main
{
    public static void main(String args[])
    {
        Animal a = new Dog();
        a.sound();
    }
}

The following examples progress from simple to more practical patterns. Try each in your IDE, change the inputs and observe the output. This is the fastest way to internalize the concept.

interface Flyable    { void fly();    }
interface Swimmable  { void swim();   }

class Duck implements Flyable, Swimmable
{
    public void fly()  { System.out.println("Duck flies"); }
    public void swim() { System.out.println("Duck swims"); }
}

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

interface Vehicle
{
    void run();

    default void start() { System.out.println("Starting..."); }
}

class Bike implements Vehicle
{
    public void run() { System.out.println("Bike running"); }
}

class Main
{
    public static void main(String args[])
    {
        Bike b = new Bike();
        b.start();
        b.run();
    }
}

interface Math
{
    static int square(int n) { return n * n; }
}

class Main
{
    public static void main(String args[])
    {
        System.out.println(Math.square(6));
    }
}

interface Greeter
{
    void hello(String name);
}

class Main
{
    public static void main(String args[])
    {
        Greeter g = (name) -> System.out.println("Hi " + name);
        g.hello("Aman");
    }
}

• All interface methods are public by default.
• All interface fields are public static final by default (constants).
• An interface can extend multiple interfaces.
• Default methods enable backward compatibility when adding methods to existing interfaces.
• An interface with exactly one abstract method is a functional interface — lambda compatible.

Reading is not enough — practice solidifies knowledge. Try every question below in your own editor before peeking at any solution.

• Q1. Create a Shape interface with area() and implement Circle and Square.
• Q2. Define a Drawable and a Resizable interface, and a class that implements both.
• Q3. Add a default method to an interface and override it in one class.
• Q4. Use a functional interface with a lambda to filter numbers.
• Q5. Show why an interface cannot have a constructor.

These are the most common questions asked in Java interviews on this topic. Memorize the concept, not just the answer — interviewers often follow up with edge cases.

Even experienced developers slip on the same pitfalls. Watch out for these classic mistakes while working with Interface in Java:

• Forgetting the semicolon ; at the end of statements while using Interface.
• Mixing up similar method names — read Java docs before using new APIs related to Interface.
• Ignoring compiler warnings — they often hint at bugs that will appear later in production.
• Hard-coding values that should come from configuration files or environment variables.
• Not handling edge cases: empty inputs, very large inputs, negative numbers and null references.
• Skipping unit tests — small tests prevent big regressions, especially around control flow.