What are marker interfaces and why are they not created nowadays?

Marker interface — an interface without methods and constants. It is used to mark classes, indicating their special nature or functionality for the JVM or frameworks.

Examples of built-in marker interfaces:

• java.io.Serializable: indicates that an object can be serialized.
• java.lang.Cloneable: indicates that the Object.clone() method can be called on the object.
• java.util.RandomAccess: indicates that lists implementing this interface support fast (O(1)) random access to elements.

Example of creating your own marker interface:

// Interface for marking classes that require special processing
public interface SpecialProcessing {
    // Empty interface
}

The reason why new marker interfaces are rarely created is due to their drawbacks and the emergence of more flexible alternatives:

1. Inability to pass information: Marker interfaces only mark a class but cannot pass additional data or parameters related to this marking.
2. Limited applicability: Marking applies only to classes, not to methods or fields.
3. Dependence on inheritance: The class must explicitly implement the interface. If you need to mark multiple classes across different hierarchies, this can become burdensome.
4. Alternatives:
   • Annotations: Provide a similar marking mechanism but more flexible. They can be applied to classes, methods, fields, parameters, and other elements. Annotations can also have attributes (key-value), allowing to pass additional information.
   • Abstract classes with marker methods: Although less "lightweight," abstract classes can contain methods (even empty ones) that serve as a sign of certain functionality.

Example of using an annotation instead of a marker interface:

// Annotation for marking classes that require special processing
@Retention(RetentionPolicy.RUNTIME) // Annotation available at runtime
@Target(ElementType.TYPE)       // Annotation applied to types (classes, interfaces, etc.)
public @interface SpecialProcessingTag {
    String description() default ""; // Ability to add a description
}

// Using the annotation
@SpecialProcessingTag(description = "This class requires additional validation")
public class MyDataClass {
    // ...
}

Annotations provide better readability, flexibility, and the ability to pass metadata, making them the preferred choice in modern Java applications for solving tasks previously handled by marker interfaces.