The Marker interface is an interface in Java without methods or constants. Its function is to mark a class with certain characteristics or behavior. They are used as tags for JVM or other code to check at runtime, such as Serializable means that the object of the class is serializable, Cloneable means that the clone() method can be safely called, and Remote is used for RMI remote access. Reasons for using the Marker interface include runtime checking, framework integration and design clarity, such as determining whether it is serializable through instanceof. The custom Marker interface is suitable for scenarios where marking classes require special processing, separation of concerns, or automated inspections of large systems. Although Java post-5 annotations provide a more flexible alternative, they still work in legacy systems and specific frameworks.

Marker interfaces in Java are interfaces that don't have any methods or constants in them. Their sole purpose is to indicate, or "mark," a class as having a certain property or behavior. Think of them like a label or flag the JVM or other code can check at runtime.

They're not about what a class can do —they're more about signaling something about the class.

Common Examples of Marker Interfaces

Java has a few built-in marker interfaces that you might already be familiar with:

• Serializable – Marks a class as being serializable, meaning its objects can be converted into a byte stream.
• Cloneable – Indicates that it's safe to call Object.clone() on an instance of this class.
• Remote – Used in RMI (Remote Method Invocation) to indicate that an object can be accessed remotely.

These interfaces don't define any methods, but they carry meaning for the system or framework using them.

Why Use a Marker Interface?

You might wonder: why use an empty interface instead of just adding a comment or annotation?

Well, marker interfaces offer a few practical benefits:

• Runtime checking : You can use instanceof to see if a class implements the marker interface.
• Framework integration : Some libraries and APIs rely on marker interfaces to alter behavior dynamically.
• Clarity in design : They make your intent explicit to both developers and tools.

For example:

 if (obj instanceof Serializable) {
    // Safe to serialize
}

This kind of check helps avoid errors and supports conditional logic based on class capabilities.

When to Create Your Own Marker Interface

While most marker interfaces are part of the standard library, there are cases where defining your own makes sense:

• When you want to tag certain classes for special handling in your app.
• To separate concerns—like distinguishing between types of domain objects.
• In large systems where automated checks or processors look for these tags.

Just keep in mind that since Java 5, annotations have become a more flexible alternative for some of these use cases.

Still, marker interfaces remain relevant, especially in legacy systems and when working with frameworks that expect them.

So, basically, marker interfaces are a way to tell the system “this class has something special” without needing to add behavior right away — and sometimes, that's exactly what you need.

The above is the detailed content of What are marker interfaces in Java?. For more information, please follow other related articles on the PHP Chinese website!