I denne delen vil vi diskutere om markørgrensesnitt i Java , det er bruker, innebygd ( Serialiserbar , Klonbar , og eksterne grensesnitt) og tilpasset markørgrensesnitt med eksempler.
Hva er markørgrensesnitt?
An grensesnitt som ikke inneholder metoder, felt og konstanter er kjent som markørgrensesnitt . Med andre ord er et tomt grensesnitt kjent som markørgrensesnitt eller tag-grensesnitt. Den leverer kjøretidstypeinformasjon om et objekt. Det er grunnen til at JVM og kompilatoren har tilleggsinformasjon om et objekt. De Serialiserbar og Klonbar grensesnitt er eksempelet på markørgrensesnitt. Kort sagt, det indikerer et signal eller kommando til JVM.
Deklarasjonen av markør-grensesnitt er det samme som grensesnitt i Java, men grensesnittet må være tomt. For eksempel:
public interface Serializable { } Det er de to alternativene for markørgrensesnitt som gir samme resultat som markørgrensesnittet.
Bruk av Marker Interface
Marker-grensesnitt brukes som en kode som informerer Java-kompilatoren med en melding slik at den kan legge til spesiell oppførsel til klassen som implementerer den. Java markørgrensesnitt er nyttig hvis vi har informasjon om klassen og den informasjonen aldri endres, i slike tilfeller bruker vi markørgrensesnitt representere for å representere det samme. Implementering av et tomt grensesnitt forteller kompilatoren å gjøre noen operasjoner.
Den brukes til å logisk dele koden og en god måte å kategorisere kode på. Det er mer nyttig for å utvikle API og i rammeverk som Spring.
Innebygd Marker Interface
I Java , innebygde markørgrensesnitt er grensesnittene som allerede er til stede i JDK og klare til bruk. Det er mange innebygde markørgrensesnitt, noen av dem er:
- Klonbart grensesnitt
- Serialiserbart grensesnitt
- Eksternt grensesnitt
La oss diskutere en etter en i detalj.
hva er desktop ini
Klonbart grensesnitt
Rengjørbart grensesnitt i Java er også et markørgrensesnitt som hører til java.lang pakke. Den genererer replika (kopi) av et objekt med et annet navn. Vi kan implementere grensesnittet i klassen for hvilket klasseobjekt som skal klones. Det indikerer klone() metoden til Object-klassen. Hvis vi ikke implementerer Cloneable-grensesnittet i klassen og påkaller clone()-metoden, kaster den ClassNotSupportedException.
Merk at en klasse som implementerer Cloneable-grensesnittet må overstyre clone()-metoden med en offentlig metode. La oss se et eksempel.
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(); } } Produksjon:
javascript window.open
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
Serialiserbart grensesnitt
Det er et markørgrensesnitt i Java som er definert i java.io pakke. Hvis vi ønsker å gjøre klassen serialiserbar, må vi implementere Serialiserbar grensesnitt. Hvis en klasse implementerer Serializable-grensesnittet, kan vi serialisere eller deserialisere tilstanden til et objekt i den klassen.
Serialisering (konvertering av et objekt til bytestrøm) er en mekanisme der objekttilstand leses fra minnet og skrives inn i en fil eller database . Deserialisering (konvertere bytestrøm til et objekt) er det motsatte av serialisering betyr det objekttilstand lesing fra en fil eller database og skrevet tilbake til minnet kalles deserialisering av objekt.
Serialisering (skriving) kan oppnås med ObjectOutputStream klasse og deserialisering (lesing) kan oppnås med ObjectInputStream klasse.
La oss se eksempler på serialisering og deserialisering.
Eksempel på serialisering
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(); } } } Produksjon:
Data has been read from the file.
Eksempel på deserialisering
La oss deserialisere objekttilstanden.
DeserialiseringEksempel.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(); } } } Produksjon:
1187345 Andrew
Eksternt grensesnitt
Eksternt grensesnitt er et markørgrensesnitt som tilhører java.rmi pakke. Den markerer et objekt som eksternt som kan nås fra en annen maskin (vert). Vi må implementere Remote-grensesnittet hvis vi ønsker å gjøre et objekt som eksternt. Den identifiserer grensesnittene hvis metoder kan påkalles fra en ikke-lokal JVM. Ethvert eksternt objekt må implementere grensesnittet direkte eller indirekte.
La oss definere et eksternt grensesnitt og implementere det i et Java-program.
Definere eksternt grensesnitt
import java.rmi.*; public interface AddAll extends Remote { public int add(int r, int s)throws RemoteException; } Implementer det eksterne grensesnittet
Det er følgende to måter å implementere det eksterne grensesnittet på:
- Ved å utvide UnicastRemoteObject-klassen
- Ved å bruke exportObject()-metoden til UnicastRemoteObject-klassen
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; } Opprett og start den eksterne applikasjonen
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); } } } Opprett og start klientapplikasjonen
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) { } } } Custom Marker Interface
Bortsett fra innebygd markørgrensesnitt, lar Java oss også lage eget markørgrensesnitt. La oss se et eksempel.
CustomMarkerInterfaceExample.java
haug og haug sortering
//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(); } } Produksjon:
Car is a vehicle. Yes, engine is working.