בחלק זה, נדון בנושא ממשק סמן ב-Java , שלה שימושים, מובנה ( ניתן להסדרה , ניתן לשחזור , וממשקים מרוחקים ) ו ממשק סמן מותאם אישית עם דוגמאות.

מהו ממשק סמן?

א מִמְשָׁק שאינו מכיל שיטות, שדות וקבועים ידוע בשם ממשק סמן . במילים אחרות, ממשק ריק ידוע בשם ממשק סמן אוֹ ממשק תג. הוא מספק מידע על סוג זמן הריצה על אובייקט. זו הסיבה ש- JVM ולקומפיילר יש מידע נוסף על אובייקט. ה ניתן להסדרה ו ניתן לשחזור ממשקים הם הדוגמה של ממשק סמן. בקיצור, זה מציין אות או פקודה ל-JVM.

ממשק ההצהרה של סמן זהה לממשק ב-Java אך הממשק חייב להיות ריק. לדוגמה:

 public interface Serializable { } 

ישנן שתי חלופות של ממשק סמן שמייצר את אותה תוצאה כמו ממשק הסמן.

דגלים פנימיים:ניתן להשתמש בו במקום ממשק סמן כדי לציין כל פעולה ספציפית.הערות:מאז Java 5, ממשקי סמן נשמטים . במקום ממשק סמן, Java 5 מספק את הערות כדי להגיע לאותן תוצאות. זה מאפשר יכולת מטא נתונים גמישה. לכן, על ידי החלת הערות על כל מחלקה, אנו יכולים לבצע פעולה ספציפית.

שימושים בממשק מרקר

ממשק Marker משמש כתג המודיע למהדר Java באמצעות הודעה, כך שהוא יכול להוסיף התנהגות מיוחדת לכיתה המיישמת אותו. ממשק סמן Java שימושי אם יש לנו מידע על המחלקה והמידע הזה לעולם לא משתנה, במקרים כאלה, אנו משתמשים בממשק מרקר כדי לייצג אותו. הטמעת ממשק ריק מורה למהדר לבצע פעולות מסוימות.

הוא משמש לחלוקה לוגית של הקוד ודרך טובה לסווג קוד. זה שימושי יותר לפיתוח API ובמסגרות כמו Spring.

פיתון חיפוש בינארי

ממשק סמן מובנה

ב Java , ממשקי סמן מובנים הם הממשקים שכבר קיימים ב-JDK ומוכנים לשימוש. ישנם ממשקי סמנים מובנים רבים, חלקם:

• ממשק שניתן לשבוט
• ממשק שניתן לסידרה
• ממשק מרוחק

בואו נדון בזה אחר זה בפירוט.

ממשק שניתן לשבוט

ממשק ניתן לניקוי ב-Java הוא גם ממשק סמן ששייך java.lang חֲבִילָה. זה יוצר העתק (עותק) של אובייקט עם שם שונה. אנחנו יכולים ליישם את הממשק במחלקה של איזה אובייקט מחלקה יש לשבט. זה מציין את clone() שיטה של ​​המחלקה Object. אם אנחנו לא מיישמים את הממשק Cloneable במחלקה ומפעילים את שיטת clone() הוא זורק את ClassNotSupportedException.

שימו לב שמחלקה המיישמת את הממשק Cloneable חייבת לעקוף את שיטת clone() בשיטה ציבורית. בואו נראה דוגמה.

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(); } } 

תְפוּקָה:

למידת מכונה מפוקחת

 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 

ממשק שניתן לסידרה

זהו ממשק סמן בג'אווה שמוגדר ב- java.io חֲבִילָה. אם ברצוננו להפוך את המחלקה לניתנת לסידרה, עלינו ליישם את ניתן להסדרה מִמְשָׁק. אם מחלקה מיישמת את ממשק ה-Serializable, נוכל לעשות סדרה או דה-סריאליזציה של המצב של אובייקט של אותה מחלקה.

סריאליזציה (המרת אובייקט לזרם בתים) היא מנגנון שבו מצב האובייקט נקרא מהזיכרון ונכתב לתוך קובץ או מסד נתונים . דה-סריאליזציה (המרת זרם בתים לאובייקט) היא ההיפך מ-Serialization כלומר קריאת מצב אובייקט מקובץ או מסד נתונים ונכתב חזרה לזיכרון נקרא דה-סריאליזציה של אובייקט.

ניתן להשיג סדרה (כתיבה) עם ה ObjectOutputStream ניתן להשיג מחלקה וסידריאליזציה (קריאה) עם ה ObjectInputStream מעמד.

בוא נראה דוגמה של סריאליזציה וסריאליזציה.

דוגמה לסריאליזציה

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

שינה ב-javascript

 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(); } } } 

תְפוּקָה:

 Data has been read from the file. 

דוגמה לדה-סריאליזציה

הבה נדמיין את מצב האובייקט.

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(); } } } 

תְפוּקָה:

 1187345 Andrew 

ממשק מרוחק

ממשק מרוחק הוא ממשק סמן ששייך ל java.rmi חֲבִילָה. הוא מסמן אובייקט כמרוחק שניתן לגשת אליו ממחשב אחר (מארח). עלינו ליישם את ממשק ה-Remote אם ברצוננו להפוך אובייקט לרחוק. הוא מזהה את הממשקים שניתן להפעיל את השיטות שלהם מ-JVM לא מקומי. כל אובייקט מרוחק חייב ליישם את הממשק באופן ישיר או עקיף.

מחרוזת למספר שלם ב-java

בואו נגדיר ממשק מרוחק וניישם אותו בתוכנת Java.

הגדרת ממשק מרחוק

 import java.rmi.*; public interface AddAll extends Remote { public int add(int r, int s)throws RemoteException; } 

יישם את הממשק המרוחק

ישנן שתי דרכים להטמיע את הממשק המרוחק:

מחרוזת הוספה של java

• על ידי הרחבת המחלקה UnicastRemoteObject
• על ידי שימוש בשיטת exportObject() של המחלקה 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; } 

צור והפעל את היישום המרוחק

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); } } } 

צור והפעל את יישום הלקוח

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) { } } } 

ממשק סמן מותאם אישית

מלבד ממשק סמן מובנה, Java גם מאפשרת לנו ליצור ממשק סמן משלו. בואו נראה דוגמה.

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(); } } 

תְפוּקָה:

 Car is a vehicle. Yes, engine is working.