I dette afsnit vil vi diskutere om markørgrænseflade i Java , dens bruger, indbygget ( Serialiserbar , Kan klones og fjerngrænseflader) og brugerdefineret markørgrænseflade med eksempler.
Hvad er markørgrænseflade?
An interface der ikke indeholder metoder, felter og konstanter er kendt som markørgrænseflade . Med andre ord er en tom grænseflade kendt som markørgrænseflade eller tag interface. Det leverer runtime type information om et objekt. Det er grunden til, at JVM og compiler har yderligere information om et objekt. Det Serialiserbar og Kan klones grænseflader er eksemplet på markørgrænseflade. Kort sagt indikerer det et signal eller en kommando til JVM.
Deklarationen af markørgrænseflade er den samme som grænseflade i Java, men grænsefladen skal være tom. For eksempel:
public interface Serializable { } Der er to alternativer til markørgrænseflade, der giver det samme resultat som markørgrænsefladen.
Brug af Marker Interface
Markør-grænseflade bruges som et tag, der informerer Java-kompileren med en besked, så den kan tilføje en speciel adfærd til klassen, der implementerer den. Java-markørgrænseflade er nyttige, hvis vi har information om klassen, og den information ændres aldrig, i sådanne tilfælde bruger vi markørgrænseflade repræsentere til at repræsentere det samme. Implementering af en tom grænseflade fortæller compileren at udføre nogle operationer.
Det bruges til logisk at opdele koden og en god måde at kategorisere kode på. Det er mere nyttigt til udvikling af API og i rammer som Spring.
Indbygget Marker Interface
I Java , indbyggede markørgrænseflader er de grænseflader, der allerede er til stede i JDK og klar til brug. Der er mange indbyggede markørgrænseflader, nogle af dem er:
- Klonbar grænseflade
- Serialiserbar grænseflade
- Fjerngrænseflade
Lad os diskutere en efter en i detaljer.
hvad er desktop ini
Klonbar grænseflade
Rengørbar grænseflade i Java er også en markørgrænseflade, der hører til java.lang pakke. Det genererer replika (kopi) af et objekt med et andet navn. Vi kan implementere grænsefladen i klassen for hvilket klasseobjekt, der skal klones. Det angiver klone() metoden i klassen Object. Hvis vi ikke implementerer den Cloneable-grænseflade i klassen og kalder clone()-metoden, kaster den ClassNotSupportedException.
Bemærk, at en klasse, der implementerer Cloneable-grænsefladen, skal tilsidesætte clone()-metoden med en offentlig metode. Lad os 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(); } } Produktion:
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
Serialiserbar grænseflade
Det er en markørgrænseflade i Java, der er defineret i java.io pakke. Hvis vi ønsker at gøre klassen serialiserbar, skal vi implementere Serialiserbar interface. Hvis en klasse implementerer Serializable-grænsefladen, kan vi serialisere eller deserialisere tilstanden for et objekt i den klasse.
Serialisering (konvertering af et objekt til bytestrøm) er en mekanisme, hvori objekttilstand læses fra hukommelsen og skrives ind i en fil eller database . Deserialisering (konvertering af bytestrøm til et objekt) er det modsatte af serialisering betyder det objekttilstand læser fra en fil eller database og skrives tilbage i hukommelsen kaldes deserialisering af objekt.
Serialisering (skrivning) kan opnås med ObjectOutputStream klasse og deserialisering (læsning) kan opnås med ObjectInputStream klasse.
Lad os 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; } } SerialiseringEksempel.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(); } } } Produktion:
Data has been read from the file.
Eksempel på deserialisering
Lad os deserialisere objekttilstanden.
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(); } } } Produktion:
1187345 Andrew
Fjerngrænseflade
Fjerngrænseflade er en markørgrænseflade, der hører til java.rmi pakke. Det markerer et objekt som fjerntliggende, der kan tilgås fra en anden maskine (vært). Vi skal implementere Remote-grænsefladen, hvis vi vil lave et objekt som remote. Den identificerer de grænseflader, hvis metoder kan påberåbes fra en ikke-lokal JVM. Ethvert fjernobjekt skal implementere grænsefladen direkte eller indirekte.
Lad os definere en fjerngrænseflade og implementere den i et Java-program.
Definition af fjerngrænseflade
import java.rmi.*; public interface AddAll extends Remote { public int add(int r, int s)throws RemoteException; } Implementer fjerngrænsefladen
Der er følgende to måder at implementere fjerngrænsefladen på:
- Ved at udvide UnicastRemoteObject-klassen
- Ved at bruge metoden exportObject() i 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; } Opret og start fjernapplikationen
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); } } } Opret og start klientapplikationen
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) { } } } Brugerdefineret markørgrænseflade
Udover den indbyggede markørgrænseflade giver Java os også mulighed for at oprette egen markørgrænseflade. Lad os se et eksempel.
CustomMarkerInterfaceExample.java
grundlæggende 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(); } } Produktion:
Car is a vehicle. Yes, engine is working.