Example

This lesson teaches interfaces through complete worked examples: one interface with many implementing classes, constants inside an interface, a class that implements two interfaces, and an interface used as a parameter type.

Knowing the rules of interfaces is not the same as using them. Here we read four complete Java programs and trace their output. You will see a Shape interface drive an array of different shapes, an interface constant used in a volume formula, a SmartPhone class that is both a Camera and a MusicPlayer, and a billing method that works with any Payment class. Each example shows how the reference type decides which methods may be called, while the actual object decides which method body runs.

Interfaces Through Worked Examples

The earlier lessons defined an interface, listed its features and showed its syntax. This lesson puts those rules to work. Every program below is complete, so you can run it and compare the output with the output shown.

Three rules are used in every example:

• A method declared in an interface without a body is automatically public and abstract. A field declared in an interface is automatically public, static and final, so it must be given a value.
• A class adopts an interface with implements and must define every abstract method of that interface as public. If it leaves any method undefined, the class must itself be declared abstract.
• An interface cannot be instantiated (new Shape() is a compile-time error), but a variable of the interface type can refer to an object of any class that implements it.

Worked Example 1: One Interface, Many Shapes

The interface Shape promises three methods. Rectangle and Circle keep that promise in their own ways, and the main() method treats them all simply as shapes.

interface Shape {
    double area();
    double perimeter();
    String name();
}

class Rectangle implements Shape {
    private double length, breadth;

    Rectangle(double length, double breadth) {
        this.length = length;
        this.breadth = breadth;
    }

    public double area() {
        return length * breadth;
    }

    public double perimeter() {
        return 2 * (length + breadth);
    }

    public String name() {
        return "Rectangle";
    }
}

class Circle implements Shape {
    private double radius;

    Circle(double radius) {
        this.radius = radius;
    }

    public double area() {
        return Math.PI * radius * radius;
    }

    public double perimeter() {
        return 2 * Math.PI * radius;
    }

    public String name() {
        return "Circle";
    }
}

public class ShapeDemo {
    static double round2(double x) {
        return Math.round(x * 100) / 100.0;
    }

    public static void main(String[] args) {
        Shape[] shapes = { new Rectangle(8, 5), new Circle(7), new Rectangle(4, 4) };
        double total = 0;
        for (Shape s : shapes) {
            System.out.println(s.name() + ": area = " + round2(s.area())
                    + ", perimeter = " + round2(s.perimeter()));
            total = total + s.area();
        }
        System.out.println("Total area = " + round2(total));
    }
}

Output:

Rectangle: area = 40.0, perimeter = 26.0
Circle: area = 153.94, perimeter = 43.98
Rectangle: area = 16.0, perimeter = 16.0
Total area = 209.94

How it works: the array has the interface type Shape[], yet it holds Rectangle and Circle objects, because each of them is a Shape. The single line s.area() runs the rectangle formula (8 × 5 = 40) for the first object, the circle formula (π × 7 × 7 ≈ 153.94) for the second and the rectangle formula again (4 × 4 = 16) for the third. Java chooses the body at run time from the actual object. This is called dynamic method dispatch. To add a triangle later, you would write a Triangle class that implements Shape and put a Triangle object in the array; the loop would not change.

Worked Example 2: A Constant Inside an Interface

ISC questions often describe an interface with a data member and a method. The data member is a constant that every implementing class can use.

interface Data {
    double PI = 3.142;      // a constant: public, static and final
    double volume();        // an abstract method: public and abstract
}

class Cylinder implements Data {
    double radius, height;

    Cylinder(double radius, double height) {
        this.radius = radius;
        this.height = height;
    }

    public double volume() {
        return PI * radius * radius * height;
    }
}

public class VolumeDemo {
    public static void main(String[] args) {
        Cylinder c = new Cylinder(7, 10);
        System.out.println("PI read through the interface = " + Data.PI);
        System.out.println("Volume of the cylinder = " + c.volume());
    }
}

Output:

PI read through the interface = 3.142
Volume of the cylinder = 1539.58

How it works: PI was written without static or final, but the compiler adds them, so PI is a constant that belongs to the interface. That is why main() can read it as Data.PI without creating any object. The volume is 3.142 × 7 × 7 × 10 = 1539.58. A statement such as PI = 3.14; inside Cylinder would not compile, because a final variable cannot be given a new value.

Worked Example 3: One Class, Two Interfaces

A Java class can extend only one class, but it can implement any number of interfaces, listed after implements and separated by commas.

interface Camera {
    void takePhoto();
}

interface MusicPlayer {
    void playSong(String title);
}

class SmartPhone implements Camera, MusicPlayer {
    private String model;

    SmartPhone(String model) {
        this.model = model;
    }

    public void takePhoto() {
        System.out.println(model + " clicks a photo");
    }

    public void playSong(String title) {
        System.out.println(model + " plays " + title);
    }
}

public class PhoneDemo {
    public static void main(String[] args) {
        SmartPhone phone = new SmartPhone("Phone X");
        Camera cam = phone;           // the same object, seen as a Camera
        MusicPlayer player = phone;   // the same object, seen as a MusicPlayer
        cam.takePhoto();
        player.playSong("Raag Yaman");
        System.out.println(phone instanceof Camera);
        System.out.println(phone instanceof MusicPlayer);
    }
}

Output:

Phone X clicks a photo
Phone X plays Raag Yaman
true
true

How it works: one SmartPhone object is referred to by three variables of three different types. Through cam you may call only takePhoto(), and through player only playSong(), because the compiler checks calls against the reference type. The instanceof operator confirms that the object is both a Camera and a MusicPlayer. This is how interfaces give Java the benefit of multiple inheritance: each interface only promises methods, and the class supplies exactly one body for each.

Worked Example 4: An Interface as a Parameter Type

When a method's parameter has an interface type, the method works with every class that implements the interface, including classes written later.

interface Payment {
    boolean pay(double amount);
}

class UpiPayment implements Payment {
    private double balance;

    UpiPayment(double balance) {
        this.balance = balance;
    }

    public boolean pay(double amount) {
        if (amount <= balance) {
            balance = balance - amount;
            System.out.println("Paid Rs " + amount + " by UPI");
            return true;
        }
        System.out.println("UPI payment failed: low balance");
        return false;
    }
}

class CashPayment implements Payment {
    public boolean pay(double amount) {
        System.out.println("Received Rs " + amount + " in cash");
        return true;
    }
}

public class Checkout {
    // bill() knows only the Payment interface, not the classes behind it
    static void bill(Payment p, double amount) {
        if (p.pay(amount)) {
            System.out.println("Bill closed");
        } else {
            System.out.println("Bill still open");
        }
    }

    public static void main(String[] args) {
        bill(new UpiPayment(500), 350);
        bill(new UpiPayment(100), 350);
        bill(new CashPayment(), 120);
    }
}

Output:

Paid Rs 350.0 by UPI
Bill closed
UPI payment failed: low balance
Bill still open
Received Rs 120.0 in cash
Bill closed

How it works: bill() depends only on the interface, so it never needs to know how a payment is made. This is loose coupling. If the shop starts accepting cards, a new CardPayment class that implements Payment can be passed to bill() without changing a single line of bill().

Since Java 8 an interface may also contain default and static methods that have bodies. The examples here use the classic form, with abstract methods and constants, which is the form ISC questions use.