En aquesta secció, parlarem sobre interfície de marcador a Java , la seva usos, integrat ( Serialitzable , Clonable , i interfícies remotes) i interfície de marcador personalitzat amb exemples.
Què és la interfície del marcador?
An interfície que no conté mètodes, camps i constants es coneix com interfície del marcador . En altres paraules, una interfície buida es coneix com interfície del marcador o interfície d'etiquetes. Ofereix la informació de tipus en temps d'execució sobre un objecte. És la raó que el JVM i el compilador tenen informació addicional sobre un objecte. El Serialitzable i Clonable les interfícies són l'exemple d'interfície de marcador. En resum, indica un senyal o ordre a la JVM.
La declaració de la interfície del marcador és la mateixa que la interfície a Java, però la interfície ha d'estar buida. Per exemple:
public interface Serializable { } Hi ha dues alternatives de la interfície del marcador que produeix el mateix resultat que la interfície del marcador.
Usos de la interfície del marcador
La interfície del marcador s'utilitza com una etiqueta que informa el compilador Java mitjançant un missatge perquè pugui afegir un comportament especial a la classe que l'implementa. La interfície de marcador de Java és útil si tenim informació sobre la classe i aquesta informació no canvia mai, en aquests casos, fem servir la interfície de marcador per representar la mateixa. La implementació d'una interfície buida indica al compilador que faci algunes operacions.
S'utilitza per dividir lògicament el codi i una bona manera de categoritzar el codi. És més útil per desenvolupar API i en marcs com Spring.
Interfície de marcador integrada
En Java , les interfícies de marcador integrades són les interfícies que ja estan presents al JDK i llestes per utilitzar. Hi ha moltes interfícies de marcador integrades, algunes d'elles són:
- Interfície clonable
- Interfície serializable
- Interfície remota
Parlem un per un amb detall.
Interfície clonable
Interfície netejable en Java també és una interfície de marcador que pertany java.lang paquet. Genera rèplica (còpia) d'un objecte amb un nom diferent. Podem implementar la interfície a la classe de quin objecte de classe es clonarà. Indica el clonar () mètode de la classe Object. Si no implementem la interfície Cloneable a la classe i invoquem el mètode clone(), llançarà el ClassNotSupportedException.
Tingueu en compte que una classe que implementa la interfície Cloneable ha de substituir el mètode clone() amb un mètode públic. Vegem un exemple.
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(); } } Sortida:
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
Interfície serializable
És una interfície de marcador en Java que es defineix a l' java.io paquet. Si volem que la classe sigui serialitzable, hem d'implementar el Serialitzable interfície. Si una classe implementa la interfície Serializable, podem serialitzar o deserialitzar l'estat d'un objecte d'aquesta classe.
pagar amb git
La serialització (convertir un objecte en flux de bytes) és un mecanisme en el qual L'estat de l'objecte es llegeix de la memòria i s'escriu en un fitxer o base de dades . La deserialització (convertir el flux de bytes en un objecte) és el contrari de la serialització lectura de l'estat de l'objecte des d'un fitxer o base de dades i escrit de nou a la memòria s'anomena deserialització de l'objecte.
La serialització (escriptura) es pot aconseguir amb el ObjectOutputStream La classe i la deserialització (lectura) es poden aconseguir amb el ObjectInputStream classe.
Vegem un exemple de serialització i deserialització.
Exemple de serialització
Employee.java
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(); } } } Sortida:
Data has been read from the file.
Exemple de deserialització
Anem a deserialitzar l'estat de l'objecte.
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(); } } } Sortida:
1187345 Andrew
Interfície remota
Interfície remota és una interfície de marcador a la qual pertany java.rmi paquet. Marca un objecte com a remot al qual es pot accedir des d'una altra màquina (amfitrió). Hem d'implementar la interfície Remote si volem fer que un objecte sigui remot. Identifica les interfícies els mètodes de les quals es poden invocar des d'una JVM no local. Qualsevol objecte remot ha d'implementar la interfície directament o indirectament.
Definim una interfície remota i implementem-la en un programa Java.
Definició de la interfície remota
import java.rmi.*; public interface AddAll extends Remote { public int add(int r, int s)throws RemoteException; } Implementar la interfície remota
Hi ha dues maneres d'implementar la interfície remota:
- En estendre la classe UnicastRemoteObject
- Utilitzant el mètode exportObject() de la classe 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; } Creeu i inicieu l'aplicació 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); } } } Creeu i inicieu l'aplicació client
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) { } } } Interfície de marcador personalitzat
A part de la interfície de marcador integrada, Java també ens permet crear una interfície de marcador pròpia. Vegem un exemple.
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(); } } Sortida:
Car is a vehicle. Yes, engine is working.