Marker Interfaces


What is a Marker Interface?

A marker interface is an empty interface in Java (it has no methods or fields). Its purpose is not to define behavior but to mark a class with metadata so that the JVM or frameworks can treat objects of that class differently.

Definition:

public interface MarkerInterface {
    // no methods or fields
}
Classes that implement this interface are tagged and can be given special treatment.

Why Marker Interfaces?

  • They existed before Java 5, when annotations did not exist.

  • A simple way to provide metadata about a class.

  • Used by JVM and libraries for special behavior. 

Built-in Marker Interfaces in Java

Marker Interface

Package

Purpose

Serializable

java.io

Marks a class as serializable (objects can be converted into byte stream).

Cloneable

java.lang

Marks a class as cloneable using Object.clone().

Remote

java.rmi

Marks an object for Remote Method Invocation (RMI).

EnterpriseBean

javax.ejb

Marks a class as an Enterprise JavaBean (legacy).

SingleThreadModel (deprecated)

javax.servlet

Ensures servlet instance is accessed by only one thread at a time (legacy).


Real-time Examples

(a) Serializable

import java.io.*;

class Employee implements Serializable {
    int id;
    String name;
    
    Employee(int id, String name) {
        this.id = id;
        this.name = name;
    }
}

public class MarkerExample {
    public static void main(String[] args) throws Exception {
        Employee e = new Employee(101, "Amit");

        FileOutputStream fos = new FileOutputStream("emp.ser");
        ObjectOutputStream oos = new ObjectOutputStream(fos);
        oos.writeObject(e);  // Works because Employee implements Serializable
        oos.close();

        System.out.println("Serialization done successfully!");
    }
}

(b) Cloneable

class Student implements Cloneable {
    int rollNo;
    String name;

    Student(int rollNo, String name) {
        this.rollNo = rollNo;
        this.name = name;
    }

    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();  // Works because Student implements Cloneable
    }
}

public class CloneDemo {
    public static void main(String[] args) throws Exception {
        Student s1 = new Student(1, "Raj");
        Student s2 = (Student) s1.clone();

        System.out.println("Cloned Student: " + s2.name);
    }
}

(c) Remote

import java.rmi.Remote;
import java.rmi.RemoteException;

public interface MyService extends Remote {
    String sayHello() throws RemoteException;
}

Custom Marker Interface Example
interface PermissionRequired {}  // custom marker interface

class SecureOperation implements PermissionRequired {
    public void perform() {
        System.out.println("Performing a secure operation...");
    }
}

public class CustomMarker {
    public static void main(String[] args) {
        SecureOperation op = new SecureOperation();

        if (op instanceof PermissionRequired) {
            System.out.println("Allowed: Permission granted.");
            op.perform();
        } else {
            System.out.println("Denied: Permission not granted.");
        }
    }
}

Output:

Allowed: Permission granted.
Performing a secure operation...

Marker Interfaces vs Marker Annotations

Feature

Marker Interface

Marker Annotation

Definition

Empty interface

Annotation without elements

Introduced

Java 1.0

Java 5

Examples

Serializable, Cloneable, Remote

@Override, @Deprecated, @FunctionalInterface

Checked by

instanceof or Class.isAssignableFrom()

Reflection (isAnnotationPresent())

Flexibility

Only a tag, no metadata

Can carry metadata, attributes

Usage Today

Legacy APIs

Preferred in modern frameworks (Spring, Hibernate, JPA)


Custom Marker Annotation Example (Modern Approach)
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;

// Marker Annotation
@Retention(RetentionPolicy.RUNTIME)
@interface PermissionRequired {}

@PermissionRequired   // Apply annotation
class SecureOperation {
    public void perform() {
        System.out.println("Performing a secure operation...");
    }
}

public class CustomAnnotationDemo {
    public static void main(String[] args) {
        SecureOperation op = new SecureOperation();

        if (op.getClass().isAnnotationPresent(PermissionRequired.class)) {
            System.out.println("Allowed: Permission granted.");
            op.perform();
        } else {
            System.out.println("Denied: Permission not granted.");
        }
    }
}

Output:

Allowed: Permission granted.
Performing a secure operation...

Why Annotations Are Better in Modern Java

  • More flexible → Can add attributes & default values.

  • Metadata-rich → Useful for frameworks (Spring, Hibernate, JPA).

  • Cleaner syntax → No need for dummy interfaces.

  • Runtime Retention → Behavior can be customized at runtime using reflection.

  • Multiple annotations can be applied to the same class (a class can implement many interfaces too, but annotations are more expressive).


Final Summary

  • Marker Interface → Empty interface, used as a tag. Examples: Serializable, Cloneable, Remote.

  • Marker Annotation → Modern replacement, introduced in Java 5. Examples: @Override, @Deprecated.

  • Custom Markers can be created both ways, but annotations are preferred today because they are more powerful, flexible, and metadata-driven.

By