Marker Interface in Java – Tagging Classes with Empty Interfaces

public interface Serializable { }      // the entire declaration in java.io

class Customer implements Serializable { ... }   // "Customer objects may be serialized"

import java.io.*;
import java.util.*;

public class JdkMarkers {
    static class Plain { int x = 1; }
    static class Saveable implements Serializable { int x = 1; }

    static class Sheep implements Cloneable {
        String name = "Dolly";
        @Override public Sheep clone() throws CloneNotSupportedException { return (Sheep) super.clone(); }
    }
    static class Goat {
        String name = "Billy";
        public Goat copy() throws CloneNotSupportedException { return (Goat) super.clone(); }
    }

    static void serialize(Object o) {
        try (ObjectOutputStream out = new ObjectOutputStream(new ByteArrayOutputStream())) {
            out.writeObject(o);
            System.out.println("Serializable: " + o.getClass().getSimpleName() + " OK");
        } catch (IOException e) {
            System.out.println("Serializable: " + e);
        }
    }

    public static void main(String[] args) {
        serialize(new Saveable());
        serialize(new Plain());

        try { System.out.println("Cloneable: cloned " + new Sheep().clone().name); }
        catch (CloneNotSupportedException e) { System.out.println("Cloneable: " + e); }
        try { new Goat().copy(); }
        catch (CloneNotSupportedException e) { System.out.println("Cloneable: " + e); }

        // RandomAccess tells algorithms that get(i) is fast
        System.out.println("ArrayList is RandomAccess:  " + (new ArrayList<>() instanceof RandomAccess));
        System.out.println("LinkedList is RandomAccess: " + (new LinkedList<>() instanceof RandomAccess));
    }
}

import java.util.List;

public class CustomMarker {
    // Custom marker interface: no methods, just a type tag
    interface Auditable { }

    record Payment(String id, double amount) implements Auditable { }
    record Login(String user) implements Auditable { }
    record PageView(String url) { }

    static void process(Object event) {
        if (event instanceof Auditable) {                 // check the marker
            System.out.println("AUDIT  -> " + event);
        }
        System.out.println("handled  " + event.getClass().getSimpleName());
    }

    // Unlike an annotation, the marker is a TYPE: the compiler can enforce it
    static void archive(Auditable record) {
        System.out.println("ARCHIVE -> " + record);
    }

    public static void main(String[] args) {
        List<Object> events = List.of(new Payment("P-1", 999.0), new PageView("/java"), new Login("asha"));
        events.forEach(CustomMarker::process);
        archive(new Login("ravi"));
        // archive(new PageView("/x"));   // compile error: PageView is not Auditable
    }
}

import java.lang.annotation.*;
import java.util.List;

public class MarkerAnnotation {
    // Annotation-based alternative: a marker annotation
    @Retention(RetentionPolicy.RUNTIME)
    @Target(ElementType.TYPE)
    @interface Cacheable { }

    @Cacheable static class ProductService { }
    static class OrderService { }

    public static void main(String[] args) {
        for (Class<?> c : List.of(ProductService.class, OrderService.class)) {
            boolean cache = c.isAnnotationPresent(Cacheable.class);
            System.out.println(c.getSimpleName() + " cacheable? " + cache);
        }
    }
}