Finally announcing my next course. The intro price of the upcoming “Learn Spring” course will permanently increase by $50 at end-of-day today:

1. Introduction

In this quick tutorial, we’ll learn about marker interfaces in Java.

2. Marker Interfaces

A marker interface is an interface that has no methods or constants inside it. It provides run-time type information about objects, so the compiler and JVM have additional information about the object.

A marker interface is also called a tagging interface.

Though marker interfaces are still in use, they very likely point to a code smell and should be used carefully. The main reason for this is that they blur the lines about what an interface represents since markers don’t define any behavior. Newer development favors annotations to solve some of the same problems.

3. JDK Marker Interfaces

Java has many built-in marker interfaces, such as Serializable, Cloneable, and Remote.

Let’s take the example of the Cloneable interface. If we try to clone an object that doesn’t implement this interface, the JVM throws a CloneNotSupportedException. Hence, the Cloneablemarker interface is an indicator to the JVM that we can call the Object.clone() method.

In the same way, when calling the ObjectOutputStream.writeObject() method, the JVM checks if the object implements the Serializable marker interface. When it’s not the case, a NotSerializableException is thrown. Therefore, the object isn’t serialized to the output stream.

4. Custom Marker Interface

Let’s create our own marker interface.

For example, we could create a marker that indicates whether an object can be removed from the database:

public interface Deletable {
}

In order to delete an entity from the database, the object representing this entity has to implement our Deletable marker interface:

As we can see, we are giving an indication to the JVM, about the runtime behavior of our objects. If the object implements our marker interface, it can be deleted from the database.

5. Marker Interfaces vs. Annotations

By introducing annotations, Java has provided us with an alternative to achieve the same results as the marker interfaces. Moreover, like marker interfaces, we can apply annotations to any class, and we can use them as indicators to perform certain actions.

So what is the key difference?

Unlike annotations, interfaces allow us to take advantage of polymorphism. As a result, we can add additional restrictions to the marker interface.

For instance, let’s add a restriction that only a Shape type can be removed from the database:

Therefore, all DeletableShape implementations are also Shape implementations. Obviously, we can’t do that using annotations.

However, every design decision has trade-offs and polymorphism can be used as a counter-argument against marker interfaces. In our example, every class extending Rectangle will automatically implement DeletableShape.

6. Marker Interfaces vs. Typical Interfaces

In the previous example, we could get the same results by modifying our DAO’s delete() method to test whether our object is a Shape or not, instead of testing whether it’s a Deletable:

But what if we have more types that we want to remove from the database as well? Obviously, this won’t be a good option because we have to change our method for every new type.

The second option is to makethe Person type implement the Shape interface, which acts as a marker interface. But is a Person object really a Shape? The answer is clearly no, and that makes the second option worse than the first one.

Hence, although we can achieve the same results by using a typical interface as a marker, we’ll end up with a poor design.

7. Conclusion

In this article, we discussed what marker interfaces are and how they can be used. Then we looked at some built-in Java examples of this type of interfaces and how they are used by the JDK.

Next, we created our own marker interface and weighed it against using an annotation. Finally, we end up by seeing why it’s a good practice to use a marker interface in some scenarios instead of a traditional interface.