In deze sectie zullen we erover praten markerinterface in Java , zijn toepassingen, ingebouwd ( Serialiseerbaar , Kloonbaar en externe interfaces) En aangepaste markerinterface met voorbeelden.
Wat is een markerinterface?
Een koppel dat geen methoden, velden en constanten bevat, staat bekend als marker-interface . Met andere woorden, een lege interface staat bekend als marker-interface of tag-interface. Het levert informatie over het runtimetype over een object. Het is de reden dat de JVM en compiler hebben aanvullende informatie over een object. De Serialiseerbaar En Kloonbaar interfaces zijn het voorbeeld van een markerinterface. Kortom, het geeft een signaal of commando aan de JVM aan.
De declaratie van de markerinterface is hetzelfde als de interface in Java, maar de interface moet leeg zijn. Bijvoorbeeld:
public interface Serializable { } Er zijn twee alternatieven voor de markerinterface die hetzelfde resultaat opleveren als de markerinterface.
Java-array dynamisch
Gebruik van de markerinterface
De Marker-interface wordt gebruikt als een tag die de Java-compiler via een bericht informeert, zodat deze een speciaal gedrag kan toevoegen aan de klasse die deze implementeert. De Java-markeringsinterface is handig als we informatie over de klasse hebben en die informatie nooit verandert. In dergelijke gevallen gebruiken we de markerinterface-represent om hetzelfde weer te geven. Het implementeren van een lege interface vertelt de compiler dat hij een aantal bewerkingen moet uitvoeren.
Het wordt gebruikt om de code logisch te verdelen en een goede manier om code te categoriseren. Het is nuttiger voor het ontwikkelen van API's en in frameworks zoals Spring.
Ingebouwde markeerinterface
In Java Ingebouwde markerinterfaces zijn de interfaces die al aanwezig zijn in de JDK en klaar zijn voor gebruik. Er zijn veel ingebouwde markerinterfaces, waarvan sommige:
- Kloonbare interface
- Serialiseerbare interface
- Externe interface
Laten we één voor één in detail bespreken.
gooi de afhandeling van Java-uitzonderingen in
Kloonbare interface
Reinigbare interface in Java is er ook een marker-interface die erbij hoort java.lang pakket. Het genereert een replica (kopie) van een object met een andere naam. We kunnen de interface implementeren in de klasse van welk klasseobject moet worden gekloond. Het geeft de kloon() methode van de Object-klasse. Als we de Cloneable-interface niet in de klasse implementeren en de clone()-methode aanroepen, gooit deze de ClassNotSupportedException.
Houd er rekening mee dat een klasse die de Cloneable-interface implementeert de methode clone() moet overschrijven met een openbare methode. Laten we een voorbeeld bekijken.
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(); } } Uitgang:
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
Serialiseerbare interface
Het is een markerinterface in Java die is gedefinieerd in de java.io pakket. Als we de klasse serialiseerbaar willen maken, moeten we de Serialiseerbaar koppel. Als een klasse de Serializable-interface implementeert, kunnen we de status van een object van die klasse serialiseren of deserialiseren.
Serialisatie (het omzetten van een object in een bytestroom) is een mechanisme waarbij de objectstatus wordt uit het geheugen gelezen en naar een bestand of database geschreven . Deserialisatie (het omzetten van bytestromen in een object) is het tegenovergestelde van serialisatie, wat betekent dat objectstatus lezen uit een bestand of database en terugschrijven naar het geheugen wordt deserialisatie van een object genoemd.
os versus stier
Serialisatie (schrijven) kan worden bereikt met de ObjectOutputStream klasse en deserialisatie (lezen) kunnen worden bereikt met de ObjectInputStream klas.
Laten we een voorbeeld bekijken van serialisatie en deserialisatie.
Voorbeeld van serialisatie
Werknemer.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; } } SerialisatieVoorbeeld.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(); } } } Uitgang:
Data has been read from the file.
Voorbeeld van deserialisatie
Laten we de objectstatus deserialiseren.
DeserialisatieExample.java
st downloaden
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(); } } } Uitgang:
1187345 Andrew
Externe interface
Externe interface is een markerinterface die erbij hoort java.rmi pakket. Het markeert een object als extern en toegankelijk vanaf een andere machine (host). We moeten de externe interface implementeren als we een object op afstand willen maken. Het identificeert de interfaces waarvan de methoden kunnen worden aangeroepen vanuit een niet-lokale JVM. Elk object op afstand moet de interface direct of indirect implementeren.
Laten we een externe interface definiëren en deze in een Java-programma implementeren.
Externe interface definiëren
import java.rmi.*; public interface AddAll extends Remote { public int add(int r, int s)throws RemoteException; } Implementeer de externe interface
Er zijn twee manieren om de externe interface te implementeren:
hoe je een map Linux kunt hernoemen
- Door de klasse UnicastRemoteObject uit te breiden
- Door de methode exportObject() van de klasse UnicastRemoteObject te gebruiken
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; } Maak en start de externe toepassing
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); } } } Maak en start de clienttoepassing
Klant.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) { } } } Aangepaste markeerinterface
Naast de ingebouwde markerinterface biedt Java ons ook de mogelijkheid om een eigen markerinterface te creëren. Laten we een voorbeeld bekijken.
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(); } } Uitgang:
Car is a vehicle. Yes, engine is working.