Marker Interfaces in Java

A courier sticks a red "FRAGILE" label on some parcels. The label has no instructions written on it; its presence alone changes how the parcel is handled. A marker interface is that label for a class: an interface with no methods at all. A class implements it only to say "I belong to this category", and other code checks for the marker with instanceof and behaves differently.

Markers in Action

public class Markers {
    interface Fragile { }
 
    static class Parcel {
        final String item;
        Parcel(String item) { this.item = item; }
    }
 
    static class GlassParcel extends Parcel implements Fragile {
        GlassParcel(String item) { super(item); }
    }
 
    static class Sheet implements Cloneable {
        String owner = "Navika";
        Sheet copy() throws CloneNotSupportedException {
            return (Sheet) clone();
        }
    }
 
    static class Note {
        Note copy() throws CloneNotSupportedException {
            return (Note) clone();
        }
    }
 
    public static void main(String[] args) {
        Parcel[] parcels = { new Parcel("Books"), new GlassParcel("Vase") };
        for (Parcel p : parcels) {
            String label = p instanceof Fragile ? " [HANDLE WITH CARE]" : "";
            System.out.println(p.item + label);
        }
        try {
            System.out.println("Sheet copied for " + new Sheet().copy().owner);
            new Note().copy();
        } catch (CloneNotSupportedException e) {
            System.out.println("Not cloneable: " + e.getMessage());
        }
    }
}

Books
Vase [HANDLE WITH CARE]
Sheet copied for Navika
Not cloneable: Markers$Note

How it works

1. Fragile is our own marker: an empty interface. GlassParcel implements it, and the loop checks it with instanceof.
2. Sheet implements Cloneable, a marker from the JDK. Object.clone() checks for it, so copying a Sheet works.
3. Note doesn't implement Cloneable. The very same clone() call throws CloneNotSupportedException. The marker alone changed the behavior.

Try it yourself: make Note implement Cloneable and run it again.

Markers in the JDK

Marker Interface or Annotation?

Annotations (covered later in the course) can also tag classes: @Deprecated, @FunctionalInterface. Which is better?

Common Mistakes

Thinking Cloneable gives you a clone() method. It has none; it only switches on Object.clone(), which you still call and usually override.

Adding methods to a "marker". Then it's an ordinary interface, and every class must implement them.

Forgetting that markers are inherited. A subclass of a Serializable class is serializable too, wanted or not.

Interview Corner

Practice

1. Easy: Create a marker Taxable and classes Medicine and Electronics, where only electronics are taxable. Print 18% tax only for taxable items.
2. Harder: Write static void shipCarefully(Fragile item) and confirm that passing a plain Parcel doesn't compile, while a GlassParcel does.

Key Takeaways