Interfaces in Java

An interface in Java is a contract: a list of methods a class promises to provide. Code that depends on the contract works with any class that signs it. This is what makes Java programs easy to extend and test. You'll learn how to write and implement interfaces, what default and static methods are, and how lambdas fit in.

What is an interface in Java?

Think of a power socket. Your laptop charger, phone charger, and kettle are completely different devices, but they all fit the same socket shape. The socket doesn't care what's plugged in, only that the plug matches. An interface is the socket shape for code.

public interface Discount {
    double apply(double price);   // the contract: no body
}

A class "signs" the contract with implements and must provide every abstract method:

public class PercentOff implements Discount {
    private final double percent;

    public PercentOff(double percent) {
        this.percent = percent;
    }

    @Override
    public double apply(double price) {
        return price * (1 - percent / 100);
    }
}

public class FlatOff implements Discount {
    private final double amount;

    public FlatOff(double amount) {
        this.amount = amount;
    }

    @Override
    public double apply(double price) {
        return Math.max(0, price - amount);
    }
}

Why use interfaces?

Because code can depend on the contract instead of a specific class:

static double checkout(double price, Discount discount) {
    return discount.apply(price);
}

System.out.println(checkout(80.0, new PercentOff(25)));  // 60.0
System.out.println(checkout(80.0, new FlatOff(10)));     // 70.0

60.0
70.0

checkout never mentions PercentOff or FlatOff. Tomorrow you can add a BuyOneGetOneFree discount and checkout keeps working unchanged. That's polymorphism and loose coupling.

What can go inside a Java interface?

Older tutorials say interfaces contain "only abstract methods". That has been out of date since Java 8 (2014). Modern interfaces can hold five kinds of members:

double apply(double price);

default String describe() {
    return "Discount";
}

static Discount none() {
    return price -> price;
}

private double round(double v) {
    return Math.round(v * 100) / 100.0;
}

double MAX_PERCENT = 90.0;

Here's our interface using all of them together:

public interface Discount {
    double MAX_PERCENT = 90.0;                    // constant

    double apply(double price);                   // abstract

    default String describe() {                   // default (Java 8+)
        return "Saves " + round(100 - apply(100)) + "%";
    }

    static Discount none() {                      // static (Java 8+)
        return price -> price;
    }

    private double round(double v) {              // private (Java 9+)
        return Math.round(v * 100) / 100.0;
    }
}

Discount d = new PercentOff(15);
System.out.println(d.describe());
System.out.println(Discount.none().apply(49.99));

Saves 15.0%
49.99

Functional interfaces and lambdas

Our Discount interface has exactly one abstract method. That makes it a functional interface, and Java lets you implement it with a short lambda expression instead of a whole class:

Discount blackFriday = price -> price * 0.5;
Discount loyalty    = price -> price - 5;

System.out.println(checkout(80.0, blackFriday));   // 40.0
System.out.println(checkout(80.0, loyalty));       // 75.0

• price -> price * 0.5 — read it as "given a price, return half of it". Java figures out this is the body of apply.
• Add @FunctionalInterface above the interface so the compiler warns you if someone adds a second abstract method.

Java ships with many ready-made functional interfaces in java.util.function, such as Function, Predicate, and Supplier. Sorting with a Comparator lambda is shown in the ArrayList guide.

Interface vs abstract class: which should you use?

Full comparison: abstract class in Java.

Interfaces you'll use every day

• List, Set, Map — the Collections Framework is built on interfaces. You write List<String> names = new ArrayList<>().
• Comparable and Comparator — define how objects are ordered for sorting.
• Runnable — a task to run, often on another thread.
• AutoCloseable — lets an object be used in try-with-resources so it's closed automatically.

Quick recap

What's next?

Now that you know the building blocks, explore the Java keywords that tie them together, starting with this.