The Purpose of the Marker Interface

One of the “clean” features of the Java programming language is that it
mandates a separation between interfaces (pure behavior) and classes (state and
behavior). Interfaces are used in Java to specify the behavior of derived
classes.
Often you will come across interfaces in Java that have no behavior. In other
words, they are just empty interface definitions. These are known as marker
interfaces. Some examples of marker interfaces in the Java API include:

– java,lang.Cloneable
– java,io.Serializable
– java.util.EventListener

Marker interfaces are also called “tag” interfaces since they tag all the
derived classes into a category based on their purpose. For example, all
classes that implement the Cloneable interface can be cloned (i.e., the clone()
method can be called on them). The Java compiler checks to make sure that if
the clone() method is called on a class and the class implements the Cloneable
interface. For example, consider the following call to the clone() method on an
object o:

SomeObject o = new SomeObject();
SomeObject ref = (SomeObject)(o.clone());

If the class SomeObject does not implement the interface Cloneable (and
Cloneable is not implemented by any of the superclasses that SomeObject
inherits from), the compiler will mark this line as an error. This is because
the clone() method may only be called by objects of type “Cloneable.” Hence,
even though Cloneable is an empty interface, it serves an important purpose.

Leave a Reply

Fill in your details below or click an icon to log in:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out / Change )

Twitter picture

You are commenting using your Twitter account. Log Out / Change )

Facebook photo

You are commenting using your Facebook account. Log Out / Change )

Google+ photo

You are commenting using your Google+ account. Log Out / Change )

Connecting to %s