Data Structure
Networking
RDBMS
Operating System
Java
MS Excel
iOS
HTML
CSS
Android
Python
C Programming
C++
C#
MongoDB
MySQL
Javascript
PHP
Physics
Chemistry
Biology
Mathematics
English
Economics
Psychology
Social Studies
Fashion Studies
Legal Studies
- Selected Reading
- UPSC IAS Exams Notes
- Developer's Best Practices
- Questions and Answers
- Effective Resume Writing
- HR Interview Questions
- Computer Glossary
- Who is Who
What is a marker or tagged interface in Java?
This article will help you understand what a Marker or Tagged Interface in Java is. Before understanding marker interface, let’s revise on Interface.
INTERFACE
Similar to an object, an Interface is a blueprint of a class. It consists of static constants and abstract methods. It is a mechanism to achieve abstraction and multiple inheritance in Java. It is declared using the interface keyword. It provides total abstraction, meaning all methods in an interface must be declared with empty body, and all fields must be public, static and final by default.
Syntax
interface <interface_name>{
// constant fields declaration
// abstract methods declaration
// by default
}
Marker Interface
An interface without methods, fields and constants is known as marker or tagged interface. This type oi interface is an empty interface. It delivers runtime information about an object. This information is delivered to both the JVM and the compiler. Two examples of marker interface are Serializable and Cloneable Interfaces.
Syntax
interface Serializable
{
}
Uses of Marker Interface
The Java compiler is informed by a message by the marker interface so that it adds some special characteristics to the class implementing it. If there is an information about a class which remains constant, then one can use marker interface to represent that information. It is mostly used for API development and in frameworks like Spring.
Types of Marker Interface
There exists many built-it marker or tagged interfaces in the JDK. The 3 most used interfaces are shown below −
Serializable Interface
Cloneable Interface
Remote Interface
Let us see each of these interfaces in details.
Serializable Interface
Serializable interface is a marker interface which is defined in java.io package. To make a class serializable, one must implement the Serializable interface. Then that object of that class can be serialized or deserialized according to requirement.
Serialization in Java is a way to convert the state of an object into a byte-stream. Its main usage is to travel object’s state on the network. Deserialization is the reverse process of Serialization where the object is reconstructed from the serialized state. One must have the object definition to successfully recreate it.
Syntax
ObjectInputStream in = new ObjectInputStream(inputStream); Student s = (MyObject)in.readObject();
Example
Student.java import java.io.Serializable; // importing java.io package for serializable interface public class Student implements Serializable { // class declaration for implementing serializable interface int studentId; // variable declaration String studentName; // variable declaration public Student(int studentId, String studentName){ this.studentId = studentId; this.studentName = studentName; } } StudentSerialization.java import java.io.*;// java.io package imported class StudentSerialization{ // class declaration public static void main(String[] args) { // main function declaration try { // try block Student std = new Student(64,"JohnWick"); // creating object using Student class FileOutputStream fout=new FileOutputStream("Student File.txt"); // creating stream and writing the object ObjectOutputStream out=new ObjectOutputStream(fout); out.writeObject(std); out.flush(); out.close(); // closing the stream System.out.println("Data read from the file"); } catch(Exception e) { // catch block e.printStackTrace(); } } }
Output
Data read from the file
Cloneable Interface
Cloneable interface is a marker interface which is defined in java.lang package. It clones the object using a different name. The clone() method of the object class is supported by this interface. If this interface is not implemented in the class irrespective of invoking the clone() method, it will throw the ClassNotSupportedException.
Example
import java.util.Scanner; // java.util package imported public class Clone implements Cloneable { // class declaration along with cloneable interface int studentId; String studentName; int studentClass; public Clone (int studentId, String studentName, int studentClass) { //Clone class constructor this.studentId = studentId; this.studentName = studentName; this.studentClass = studentClass; } public void printList() { // function to print details System.out.println("Student ID: "+studentId); System.out.println("Student Name: "+studentName); System.out.println("Student Class: "+studentClass); } public static void main (String args[]) throws CloneNotSupportedException { // main function declaration Scanner sc = new Scanner(System.in); // Scanner class object created System.out.print("Enter Student ID: "); // Reading user given values int studentId = sc.nextInt(); System.out.print("Enter Student name: "); String studentName = sc.next(); System.out.print("Enter Student Class: "); int studentClass = sc.nextInt(); System.out.println("-------Student Detail--------"); Clone p1 = new Clone(studentId, studentName, studentClass); Clone p2 = (Clone) p1.clone(); //cloning the object of the Student class using the clone() method p2.printList(); // invoking the method to print detail } }
Output
Enter Student ID: 64 Enter Student name: JohnWick Enter Student Class: 1 -------Student Detail-------- Student ID: 64 Student Name: JohnWick Student Class: 1
Remote Interface
Remote Interface is a marker interface which is defined in java.rmi package. It marks an object as remote, which is accessible by another machine (host machine). An object can be used as a remote after implementing this interface. It also identifies interfaces whose functions can be invoked from JVM. The interface must be directly or indirectly implemented by any remote object.
Syntax
import java.rmi.*;
public interface Multiply extends Remote{
public int mul(int p, int r, int t)throws RemoteException'
}
Custom Interface
Custom Interface can be created by user, i.e. it is not a built in interface like that of the above three.
Syntax
interface <interface_name>
{
}
Example
interface Bullet720 { // custom marker interface } class Train implements Bullet720 { // class that implements the Bullet720 marker interface static void isTrain() {// static function to display System.out.println("Bullet720 is a Train."); } } public class CustomInterface { // main class declaration public static void main(String args[]) { // main function declaration Train.isTrain(); // invoking methods of the class Train } }
Output
Bullet720 is a Train.
2K+ Views
