What is a marker interface?

Q: What are the three classic examples?

// Serializable: zero methods, marks class for byte stream conversion public interface Serializable { } public class Account implements java.io.Serializable { private String accountId; private java.math.BigDecimal balance; } // With Serializable: serialization works java.io.ObjectOutputStream oos =

Q: How does the JVM use marker interfaces internally?

// Inside ObjectOutputStream (simplified): public void writeObject(Object obj) throws java.io.IOException { if (!(obj instanceof java.io.Serializable)) { throw new java.io.NotSerializableException(obj.getClass().getName()); } // proceed with serialization } // Inside Object.clone() (simplified): pro

Q: How do you create a custom marker interface?

// Custom marker: this account type supports international transfers public interface InternationalTransferCapable { } public class NRIAccount extends Account implements InternationalTransferCapable { } public class SavingsAccount extends Account { } // no marker public void transferInternational(Ac

Definition

A marker interface has zero methods. It marks a capability. The JVM checks instanceof at runtime. Serializable allows byte stream conversion. Cloneable allows clone(). Remote allows RMI. Modern designs prefer annotations.

A marker interface (tag interface) is an interface with zero methods that tags a class with a capability.

Serializable: marks a class as safe to convert to and from byte streams. ObjectOutputStream checks instanceof Serializable before serializing. Without it: NotSerializableException.
Cloneable: marks that Object.clone() should work. Without it: CloneNotSupportedException. Considered a broken design; prefer copy constructors.
Remote: marks that an object can be invoked remotely via RMI.
Advantage over annotations: marker interfaces define a type that can be used in generics () and variable declarations.
Modern guideline: prefer annotations for new tagging needs (@Entity, @Component). Marker interfaces remain in the JDK for backward compatibility.

A marker interface is like a stamp on a bank document at National Bank of India: Certified for International Transfer (Serializable), Certified for Duplication (Cloneable), Certified for Remote Access (Remote). The stamp has no instructions, it just says this document is approved for X. The system checks for the stamp before allowing the operation.

Understanding the Concepts

A marker interface has no abstract methods. It is completely empty but communicates a capability to the JVM or framework.

What are the three classic examples?

JAVA

// Serializable: zero methods, marks class for byte stream conversion
public interface Serializable { }

public class Account implements java.io.Serializable {
    private String accountId;
    private java.math.BigDecimal balance;
}

// With Serializable: serialization works
java.io.ObjectOutputStream oos = new java.io.ObjectOutputStream(
    new java.io.FileOutputStream("account.dat"));
oos.writeObject(account); // works

// Without Serializable: NotSerializableException

// Cloneable: zero methods, marks class for clone()
public class Trade implements Cloneable {
    @Override
    public Trade clone() {
        try { return (Trade) super.clone(); }
        catch (CloneNotSupportedException e) { throw new RuntimeException(e); }
    }
}
// Without Cloneable: CloneNotSupportedException
// Note: Cloneable is considered broken design. Prefer copy constructors.

// Remote: zero methods, marks class for RMI
public interface TradingService extends java.rmi.Remote {
    TradeResult executeTrade(String symbol, int qty) throws java.rmi.RemoteException;
}

How does the JVM use marker interfaces internally?

JAVA

// Inside ObjectOutputStream (simplified):
public void writeObject(Object obj) throws java.io.IOException {
    if (!(obj instanceof java.io.Serializable)) {
        throw new java.io.NotSerializableException(obj.getClass().getName());
    }
    // proceed with serialization
}

// Inside Object.clone() (simplified):
protected Object clone() throws CloneNotSupportedException {
    if (!(this instanceof Cloneable)) {
        throw new CloneNotSupportedException();
    }
    // perform shallow copy
}

How do marker interfaces compare to annotations?

| Aspect | Marker Interface | Annotation |
|--------|-----------------|------------|
| Methods | Zero | N/A |
| Type constraint | Yes: | No: cannot use in generics |
| instanceof | Yes | No (use reflection) |
| Metadata | Cannot carry | Can: @Cacheable(ttl = 60) |
| Target | Classes only | Methods, fields, parameters |
| Hierarchy | Pollutes class hierarchy | Does not |

How do you create a custom marker interface?

JAVA

// Custom marker: this account type supports international transfers
public interface InternationalTransferCapable { }

public class NRIAccount extends Account implements InternationalTransferCapable { }
public class SavingsAccount extends Account { } // no marker

public void transferInternational(Account account, java.math.BigDecimal amount) {
    if (!(account instanceof InternationalTransferCapable)) {
        throw new UnsupportedOperationException(
            account.getClass().getSimpleName() + " does not support international transfers");
    }
    // proceed
}

What should a senior engineer know?

Modern designs prefer annotations for new tagging needs because annotations carry metadata and do not pollute the type hierarchy.
Marker interfaces are still useful when you need a type constraint in generics: cannot be done with annotations.
In Spring, @Component is an annotation, not a marker interface, because it needs metadata like scope and name.

Visual Overview

DIAGRAM

  MARKER INTERFACE PATTERN
  ──────────────────────────────────────────

  Interface: zero methods
  ┌────────────────────────────┐
  │ public interface Serializable { } │
  └────────────────────────────┘

  Class implements marker:
  ┌────────────────────────────┐
  │ Account implements Serializable │
  └────────────────────────────┘

  JVM checks at runtime:
  ┌────────────────────────────┐
  │ if (obj instanceof Serializable) │
  │   serialize                │
  │ else                       │
  │   throw NotSerializableException │
  └────────────────────────────┘

Key Takeaway

A marker interface is an interface with zero methods that tags a class with a capability. The JVM or framework checks instanceof at runtime to decide whether to allow specific operations. Serializable marks that ObjectOutputStream can serialize the object. Cloneable marks that Object.clone() should work (though it is considered broken; prefer copy constructors). Remote marks that an object can be invoked via RMI.

Modern Java prefers annotations for tagging (@Entity, @Component, @Cacheable) because they carry metadata and do not pollute the type hierarchy. But marker interfaces still have one advantage: they define a type that can be used in generics () and variable declarations (Serializable obj = account). Annotations cannot be used as types.

Remember one sentence: a marker interface has zero methods, tags a class with a capability checked via instanceof at runtime, and modern designs prefer annotations unless a type constraint in generics is needed.

---