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 {
        @Serial
        private static final long serialVersionUID = 1L;   // version tag for the serialized form
        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 auditable) {       // check the marker (pattern matching, Java 16+)
            System.out.println("AUDIT  -> " + auditable);
        }
        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);
        }
    }
}

import java.util.List;

public class SealedEvents {
    // Sealed interface: only the listed types may implement it (Java 17+)
    sealed interface Event permits Payment, Login, PageView { }

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

    // Exhaustive switch with record patterns (Java 21+): no default branch needed
    static String describe(Event event) {
        return switch (event) {
            case Payment(String id, double amount) when amount > 500 -> "AUDIT large payment " + id;
            case Payment(String id, double amount) -> "payment " + id + " for " + amount;
            case Login(String user) -> "AUDIT login by " + user;
            case PageView(String url) -> "page view " + url;
        };
    }

    public static void main(String[] args) {
        List<Event> events = List.of(new Payment("P-1", 999.0), new Payment("P-2", 45.0),
                                     new Login("asha"), new PageView("/java"));
        events.forEach(e -> System.out.println(describe(e)));
    }
}