Dans cette section, nous discuterons de interface de marqueur en Java , c'est utilisations, intégré ( Sérialisable , Clonable et interfaces distantes) et interface de marqueur personnalisée avec des exemples.
Qu'est-ce que l'interface des marqueurs ?
Un interface qui ne contient pas de méthodes, de champs et de constantes est appelé interface de marqueur . En d’autres termes, une interface vide est appelée interface de marqueur ou interface de balise. Il fournit les informations de type d'exécution sur un objet. C'est la raison pour laquelle le JVM et le compilateur ont des informations supplémentaires sur un objet. Le Sérialisable et Clonable les interfaces sont l’exemple d’interface de marqueur. En bref, cela indique un signal ou une commande à la JVM.
Kat Timpf soeur
La déclaration de l'interface du marqueur est la même que celle de l'interface en Java mais l'interface doit être vide. Par exemple:
public interface Serializable { } Il existe deux alternatives d'interface de marqueur qui produisent le même résultat que l'interface de marqueur.
Utilisations de l'interface des marqueurs
L'interface Marker est utilisée comme une balise qui informe le compilateur Java par un message afin qu'il puisse ajouter un comportement spécial à la classe qui l'implémente. L'interface de marqueur Java est utile si nous avons des informations sur la classe et que ces informations ne changent jamais. Dans de tels cas, nous utilisons l'interface de marqueur pour représenter la même chose. L'implémentation d'une interface vide indique au compilateur d'effectuer certaines opérations.
Il est utilisé pour diviser logiquement le code et constitue un bon moyen de catégoriser le code. Il est plus utile pour développer des API et dans des frameworks comme Spring.
Interface de marqueur intégrée
Dans Java , les interfaces de marqueurs intégrées sont les interfaces déjà présentes dans le JDK et prêtes à l'emploi. Il existe de nombreuses interfaces de marqueurs intégrées, dont :
- Interface clonable
- Interface sérialisable
- Interface à distance
Discutons un par un en détail.
Interface clonable
Interface nettoyable en Java est également une interface de marqueur qui appartient à java.lang emballer. Il génère une réplique (copie) d'un objet avec un nom différent. Nous pouvons implémenter l'interface dans la classe de quel objet de classe être cloné. Il indique le cloner() méthode de la classe Object. Si nous n'implémentons pas l'interface Cloneable dans la classe et invoquons la méthode clone(), elle renvoie le ClassNotSupportedException.
Notez qu'une classe qui implémente l'interface Cloneable doit remplacer la méthode clone() par une méthode publique. Voyons un exemple.
Produit.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(); } } Sortir:
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
Interface sérialisable
Il s'agit d'une interface de marqueur en Java définie dans le java.io emballer. Si nous voulons rendre la classe sérialisable, nous devons implémenter le Sérialisable interface. Si une classe implémente l'interface Serialisable, nous pouvons sérialiser ou désérialiser l'état d'un objet de cette classe.
La sérialisation (conversion d'un objet en flux d'octets) est un mécanisme dans lequel l'état de l'objet est lu dans la mémoire et écrit dans un fichier ou une base de données . La désérialisation (conversion du flux d'octets en objet) est l'opposé de la sérialisation, ce qui signifie que lecture de l'état d'un objet à partir d'un fichier ou d'une base de données et réécriture en mémoire s'appelle la désérialisation de l'objet.
La sérialisation (écriture) peut être réalisée avec le ObjetOutputStream la classe et la désérialisation (lecture) peuvent être réalisées avec le ObjetInputStream classe.
Voyons un exemple de sérialisation et de désérialisation.
Exemple de sérialisation
Employé.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(); } } } Sortir:
Data has been read from the file.
Exemple de désérialisation
Désérialisons l'état de l'objet.
DésérialisationExample.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(); } } } Sortir:
1187345 Andrew
Interface à distance
Interface à distance est une interface de marqueur appartenant à java.rmi emballer. Il marque un objet comme distant accessible depuis une autre machine (hôte). Nous devons implémenter l'interface Remote si nous voulons rendre un objet distant. Il identifie les interfaces dont les méthodes peuvent être invoquées à partir d'une JVM non locale. Tout objet distant doit implémenter l'interface directement ou indirectement.
Définissons une interface distante et implémentons-la dans un programme Java.
Définir l'interface distante
import java.rmi.*; public interface AddAll extends Remote { public int add(int r, int s)throws RemoteException; } Implémenter l'interface distante
Il existe deux manières suivantes d'implémenter l'interface distante :
comment ouvrir un fichier en java
- En étendant la classe UnicastRemoteObject
- En utilisant la méthode 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; } Créer et démarrer l'application distante
Serveur.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); } } } Créer et démarrer l'application 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) { } } } Interface de marqueur personnalisée
Outre l'interface de marqueur intégrée, Java nous permet également de créer notre propre interface de marqueur. Voyons 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(); } } Sortir:
Car is a vehicle. Yes, engine is working.