En esta sección, discutiremos sobre interfaz de marcador en Java , es usos, incorporado ( Serializable , Clonable e interfaces remotas) y interfaz de marcador personalizada con ejemplos.
¿Qué es la interfaz de marcador?
Un interfaz que no contiene métodos, campos y constantes se conoce como interfaz de marcador . En otras palabras, una interfaz vacía se conoce como interfaz de marcador o interfaz de etiqueta. Proporciona información del tipo de tiempo de ejecución sobre un objeto. Es la razón por la que el JVM y el compilador tienen información adicional sobre un objeto. El Serializable y Clonable Las interfaces son el ejemplo de interfaz de marcador. En resumen, indica una señal o comando a la JVM.
La declaración de la interfaz del marcador es la misma que la de la interfaz en Java, pero la interfaz debe estar vacía. Por ejemplo:
public interface Serializable { } Existen dos alternativas de interfaz de marcador que produce el mismo resultado que la interfaz de marcador.
Usos de la interfaz de marcador
La interfaz de marcador se utiliza como una etiqueta que informa al compilador de Java mediante un mensaje para que pueda agregar algún comportamiento especial a la clase que lo implementa. La interfaz de marcador de Java es útil si tenemos información sobre la clase y esa información nunca cambia; en tales casos, usamos la interfaz de marcador para representar la misma. La implementación de una interfaz vacía le dice al compilador que realice algunas operaciones.
Se utiliza para dividir lógicamente el código y es una buena forma de categorizar el código. Es más útil para desarrollar API y en marcos como Spring.
Interfaz de marcador incorporada
En Java , las interfaces de marcador integradas son las interfaces que ya están presentes en el JDK y listas para usar. Hay muchas interfaces de marcadores integradas, algunas de ellas son:
- Interfaz clonable
- Interfaz serializable
- Interfaz remota
Analicemos uno por uno en detalle.
Interfaz clonable
Interfaz limpiable en Java también es una interfaz de marcador que pertenece a java.lang paquete. Genera réplica (copia) de un objeto con nombre diferente. Podemos implementar la interfaz en la clase de qué objeto de clase se va a clonar. Indica el clon() método de la clase Objeto. Si no implementamos la interfaz Cloneable en la clase e invocamos el método clone(), arroja el ClassNotSupportedException.
Tenga en cuenta que una clase que implementa la interfaz Cloneable debe anular el método clone() con un método público. Veamos un ejemplo.
Product.java
import java.util.Scanner; public class Product implements Cloneable { int pid; String pname; double pcost; //Product class constructor public Product (int pid, String pname, double pcost) { this.pid = pid; this.pname = pname; this.pcost = pcost; } //method that prints the detail on the console public void showDetail() { System.out.println('Product ID: '+pid); System.out.println('Product Name: '+pname); System.out.println('Product Cost: '+pcost); } public static void main (String args[]) throws CloneNotSupportedException { //reading values of the product from the user Scanner sc = new Scanner(System.in); System.out.print('Enter product ID: '); int pid = sc.nextInt(); System.out.print('Enter product name: '); String pname = sc.next(); System.out.print('Enter product Cost: '); double pcost = sc.nextDouble(); System.out.println('-------Product Detail--------'); Product p1 = new Product(pid, pname, pcost); //cloning the object of the Product class using the clone() method Product p2 = (Product) p1.clone(); //invoking the method to print detail p2.showDetail(); } } Producción:
Enter product ID: 139872 Enter product name: Printer Enter product Cost: 3459.67 -------Product Detail-------- Product ID: 139872 Product Name: Printer Product Cost: 3459.67
Interfaz serializable
Es una interfaz de marcador en Java que se define en el java.io paquete. Si queremos que la clase sea serializable, debemos implementar el Serializable interfaz. Si una clase implementa la interfaz Serializable, podemos serializar o deserializar el estado de un objeto de esa clase.
La serialización (convertir un objeto en un flujo de bytes) es un mecanismo en el que El estado del objeto se lee de la memoria y se escribe en un archivo o base de datos. . La deserialización (convertir un flujo de bytes en un objeto) es lo opuesto a la serialización, lo que significa que Lectura del estado del objeto de un archivo o base de datos y escritura de nuevo en la memoria. se llama deserialización del objeto.
La serialización (escritura) se puede lograr con el flujo de salida de objetos clase y la deserialización (lectura) se puede lograr con el flujo de entrada de objetos clase.
Veamos un ejemplo de serialización y deserialización.
Ejemplo de serialización
Employee.java
reemplazo de cadena javascript
import java.io.Serializable; public class Employee implements Serializable { int empid; String empname; public Employee(int empid, String empname) { this.empid = empid; this.empname = empname; } } SerializationExample.java
import java.io.*; class SerializationExample { public static void main(String args[]) { try { //Creating the object Employee emp =new Employee(1187345,'Andrew'); //Creating stream and writing the object FileOutputStream fout=new FileOutputStream('employee data.txt'); ObjectOutputStream out=new ObjectOutputStream(fout); out.writeObject(emp); out.flush(); //closing the stream out.close(); System.out.println('Data has been read from the file.'); } catch(Exception e) { e.printStackTrace(); } } } Producción:
Data has been read from the file.
Ejemplo de deserialización
Deserialicemos el estado del objeto.
DeserializationExample.java
import java.io.*; class DeserializationExample { public static void main(String args[]) { try { //Creating stream to read the object ObjectInputStream in=new ObjectInputStream(new FileInputStream('employee data.txt')); Employee emp=(Employee)in.readObject(); //printing the data of the serialized object System.out.println(emp.empid+' '+emp.empname); //closing the stream in.close(); } catch(Exception e) { e.printStackTrace(); } } } Producción:
1187345 Andrew
Interfaz remota
Interfaz remota es una interfaz de marcador que pertenece a java.rmi paquete. Marca un objeto como remoto al que se puede acceder desde otra máquina (host). Debemos implementar la interfaz Remota si queremos que un objeto sea remoto. Identifica las interfaces cuyos métodos se pueden invocar desde una JVM no local. Cualquier objeto remoto debe implementar la interfaz directa o indirectamente.
Definamos una interfaz remota e implementémosla en un programa Java.
Definición de interfaz remota
import java.rmi.*; public interface AddAll extends Remote { public int add(int r, int s)throws RemoteException; } Implementar la interfaz remota
Existen dos formas siguientes de implementar la interfaz remota:
- Ampliando la clase UnicastRemoteObject
- Usando el método exportObject() de la clase UnicastRemoteObject
AddAllRemote.java
import java.rmi.*; import java.rmi.server.*; public class AddAllRemote extends UnicastRemoteObject implements Adder { AddAllRemote()throws RemoteException { super(); } public int add(int r, int s) { return r+s; } Cree e inicie la aplicación remota
Server.java
import java.rmi.*; import java.rmi.registry.*; public class Server { public static void main(String args[]) { try { AddAll stub=new AddAllRemote(); Naming.rebind('rmi://localhost:5000/sak',stub); } catch(Exception e) { System.out.println(e); } } } Crear e iniciar la aplicación cliente
Client.java
import java.rmi.*; public class Client { public static void main(String args[]) { try { AddAll stub=(AddAll)Naming.lookup('rmi://localhost:5000/sak'); System.out.println(stub.add(29,18)); } catch(Exception e) { } } } Interfaz de marcador personalizada
Además de la interfaz de marcador incorporada, Java también nos permite crear nuestra propia interfaz de marcador. Veamos un ejemplo.
CustomMarkerInterfaceExample.java
//custom marker interface interface Car { } //custom marker interface interface Engine { } //class that implements the Car marker interface class Vehicle implements Car { static void isVehicle() { System.out.println('Car is a vehicle.'); } } //class that implements the Engine marker interface class Status implements Engine { static void isWorking() { System.out.println('Yes, engine is working.'); } } //main class public class CustomMarkerInterfaceExample { public static void main(String args[]) { //invoking the methods of the class Vehicle.isVehicle(); Status.isWorking(); } } Producción:
Car is a vehicle. Yes, engine is working.