In questa sezione parleremo di interfaccia marcatore in Java , suo utilizza, integrato ( Serializzabile , Clonabile e interfacce remote) E interfaccia marcatore personalizzata con esempi.
Cos'è l'interfaccia marcatore?
UN interfaccia che non contiene metodi, campi e costanti è noto come interfaccia marcatore . In altre parole, un'interfaccia vuota è nota come interfaccia marcatore O interfaccia dell'etichetta. Fornisce le informazioni sul tipo di runtime su un oggetto. È il motivo per cui il JVM e il compilatore hanno informazioni aggiuntive su un oggetto. IL Serializzabile E Clonabile le interfacce sono l'esempio di interfaccia marcatore. In breve, indica un segnale o un comando alla JVM.
La dichiarazione dell'interfaccia marcatore è la stessa dell'interfaccia in Java ma l'interfaccia deve essere vuota. Per esempio:
public interface Serializable { } Esistono due alternative dell'interfaccia marcatore che produce lo stesso risultato dell'interfaccia marcatore.
Usi dell'interfaccia Marker
L'interfaccia Marker viene utilizzata come tag che informa il compilatore Java tramite un messaggio in modo che possa aggiungere un comportamento speciale alla classe che lo implementa. L'interfaccia marcatore Java è utile se disponiamo di informazioni sulla classe e tali informazioni non cambiano mai, in questi casi utilizziamo l'interfaccia marcatore rappresenta per rappresentare la stessa. L'implementazione di un'interfaccia vuota indica al compilatore di eseguire alcune operazioni.
Viene utilizzato per dividere logicamente il codice e rappresenta un buon modo per classificarlo. È più utile per lo sviluppo di API e in framework come Spring.
Interfaccia marcatore incorporata
In Giava , le interfacce marcatore integrate sono le interfacce già presenti nel JDK e pronte per l'uso. Esistono molte interfacce marker integrate, alcune di esse sono:
- Interfaccia clonabile
- Interfaccia serializzabile
- Interfaccia remota
Discutiamo uno per uno in dettaglio.
oggetto Java su JSON
Interfaccia clonabile
Interfaccia pulibile in Java è anche un'interfaccia marcatore che appartiene a java.lang pacchetto. Genera replica (copia) di un oggetto con nome diverso. Possiamo implementare l'interfaccia nella classe di cui oggetto classe da clonare. Indica il clone() metodo della classe Object. Se non implementiamo l'interfaccia Cloneable nella classe e invochiamo il metodo clone(), lancia il file ClassNotSupportedException.
Tieni presente che una classe che implementa l'interfaccia Cloneable deve sovrascrivere il metodo clone() con un metodo pubblico. Vediamo un esempio.
Prodotto.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(); } } Produzione:
coppia Java
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
Interfaccia serializzabile
È un'interfaccia marcatore in Java definita nel file java.io pacchetto. Se vogliamo rendere serializzabile la classe dobbiamo implementare il file Serializzabile interfaccia. Se una classe implementa l'interfaccia Serializable, possiamo serializzare o deserializzare lo stato di un oggetto di quella classe.
La serializzazione (conversione di un oggetto in flusso di byte) è un meccanismo in cui lo stato dell'oggetto viene letto dalla memoria e scritto in un file o database . La deserializzazione (conversione del flusso di byte in un oggetto) è l'opposto della serializzazione lettura dello stato dell'oggetto da un file o database e riscrittura in memoria si chiama deserializzazione dell'oggetto.
La serializzazione (scrittura) può essere ottenuta con il file OggettoOutputStream class e la deserializzazione (lettura) possono essere ottenute con il file OggettoInputStream classe.
Vediamo un esempio di serializzazione e deserializzazione.
Esempio di serializzazione
Dipendente.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(); } } } Produzione:
Data has been read from the file.
Esempio di deserializzazione
Deserializziamo lo stato dell'oggetto.
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(); } } } Produzione:
1187345 Andrew
Interfaccia remota
Interfaccia remota è un'interfaccia marcatore che appartiene a java.rmi pacchetto. Contrassegna un oggetto come remoto a cui è possibile accedere da un'altra macchina (host). Dobbiamo implementare l'interfaccia Remote se vogliamo rendere un oggetto remoto. Identifica le interfacce i cui metodi possono essere richiamati da una JVM non locale. Qualsiasi oggetto remoto deve implementare l'interfaccia direttamente o indirettamente.
Definiamo un'interfaccia remota e implementiamola in un programma Java.
Definizione dell'interfaccia remota
import java.rmi.*; public interface AddAll extends Remote { public int add(int r, int s)throws RemoteException; } Implementare l'interfaccia remota
Esistono due modi seguenti per implementare l'interfaccia remota:
- Estendendo la classe UnicastRemoteObject
- Utilizzando il metodo exportObject() della 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; } Creare e avviare l'applicazione 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); } } } Creare e avviare l'applicazione 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) { } } } Interfaccia marcatore personalizzata
Oltre all'interfaccia marcatore incorporata, Java ci consente anche di creare la propria interfaccia marcatore. Vediamo un esempio.
CustomMarkerInterfaceExample.java
formattare una data in 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(); } } Produzione:
Car is a vehicle. Yes, engine is working.