מהו ממשק ב- Java וכיצד ליישם אותו?

' מִמְשָׁק היא רמה מתקדמת של השגת הפשטה בשפת התכנות Java. ממשק Java עוזר ב צמצום המורכבות בקוד ומפשט את קְרִיאוּת . במאמר זה אסביר לכם ממשק Java באמצעות ה- docket הבא.

• מהו ממשק Java?
• מדוע אנו זקוקים לממשק?
• הכרזת ממשק Java: תחביר
• דוגמה לממשק Java
• קינון ממשק Java
• ההבדל בין מעמד לממשק
• יתרונות וחסרונות ממשק
• נקודות מפתח בממשק Java

מהו ממשק Java?

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

הפשטת Java מספקת את הפונקציונליות של שיטה מסוימת על ידי הסתרת לוגיקת היישום הכתובה בתוך השיטה. באופן דומה, ממשק Java הוא גם מחלקה מופשטת הכוללת את הצהרת השיטה אך לא את הגדרתה. כיתה מכשירים ממשק לרשת את השיטות המופשטות. יחד עם שיטות מופשטות, an מִמְשָׁק יכול לכלול גם קבועים, שיטות סטטיות, ממשקים מקוננים ו שיטות ברירת מחדל.

קווי דמיון בין כיתה לממשק.

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

מיין אלגוריתמים c ++

• זהה למחלקה, ממשק יכול להכיל גם מספר רב של שיטות כנדרש.
• בדומה לשיעורים, הממשק כתוב גם עם .java קובץ סיומת.
• באופן מפתיע, קוד הביצוע של ממשק יופיע ב- .מעמד קוֹבֶץ.
• ממשק מוצג בצורה של חבילה וצופן הביצועים שלהם נמצא בספריה שתואמת את שם החבילה.

מדוע אנו זקוקים לממשק?

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

נניח שיש לנו שני מישורים, אחד יכול לשאת רק נוסעים, השני בלבד עמדה. עכשיו, אנחנו צריכים לָרֶשֶׁת את המאפיינים של מטוס המטען ומטוס הנוסעים. ג'אווה לא תתמוך בפתרון זה מכיוון שהוא מסתיים ב דו משמעות בין שני המטוסים.

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

// קוד Class A

חבילה מחלקה מרובה A {void msg () {System.out.println ('שלום')}}

// קוד Class B

חבילה מחלקה B מרובה {void msg () {System.out.println ('ברוך הבא')}}

קוד כיתה ג

חבילה מרובה מחלקה C מרחיבה A, B {// זה לא יתקבל על ידי Java, זה יזרוק שגיאה והקוד לא יבוצע. סטטי ציבורי ריק ריק (מחרוזת טוענת []) {C obj = new C () obj.msg ()}}

תְפוּקָה:

שְׁגִיאָה. גישה מסוימת זו מציגה חריג. Java אינה תומכת בירושות מרובות. שגיאה זו ידועה בשם בעיית יהלום 

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

// קוד ממשק

חבילה של פתרון ממשק ציבורי MIS {public void Hello () public void Welcome ()}

// קוד כיתה

החבילה MIS class classA מיישמת פיתרון {public void Hello () {java.lang.System.out.println ('Hello world')} Public void Welcome () {java.lang.System.out.println ('ברוך הבא לאדוריקה) ')} ציבורי סטטי ריק (String [] args) {classA Edureka = new classA () Edureka.Hello () Edureka.Welcome ()}}

תְפוּקָה:

שלום עולם

ברוך הבא לאדוריקה

הכרזת ממשק Java: תחביר

ממשק ממשק_שם {// להכריז על שדות קבועים // להכריז על שיטות () // שיטות ברירת מחדל}

בואו נעבור דוגמה בממשק Java

דוגמה לממשק Java

בואו ניצור מחשבון פשוט המבוסס על ממשק Java.

// קוד ממשק

חבילה בסיסית פעולות ממשק ציבורי מתמטיקה {public void add () public void sub () public void mul () public void div ()}

// קוד כיתה

חבילת פעולות בסיסיות מייבאת java.util.Scanner מחלקה ציבורית תלמיד 1 מיישמת מתמטיקה {@ ביטול ריק ריק להוסיף () {סורק kb = חדש סורק (System.in) System.out.println ('הזן כל שני ערכים שלמים כדי לבצע תוספת') int a = kb.nextInt () int b = kb.nextInt () int s = a + b System.out.println ('סכום של' + a + 'ו-' + b + 'הוא' + s)} @ ביטול משנה משנה ריק () {סורק kb = סורק חדש (System.in) System.out.println ('הזן שני ערכי מספרים שלמים לביצוע הסברה') int a = kb.nextInt () int b = kb.nextInt () int s = ab System.out.println ('ההבדל בין' + a + 'ו-' + b + 'הוא' + s)} @ ביטול ציבורי ריק ריק () {סורק kb = סורק חדש (System.in) System.out.println ('Enter כל שני כפל ערכי שלם ') int a = kb.nextInt () int b = kb.nextInt () int s = a * b System.out.println (' מוצר של '+ a +' ו- '+ b +' הוא '+ s)} @Override חלל חלל ציבורי () {סורק kb = סורק חדש (System.in) System.out.println ('הזן כל חלוקה של שני ערכי שלם') int a = kb.nextInt () int b = kb.nextInt () int s = a / b System.out.p rintln ('Quotient of' + a + 'ו-' + b + 'is' + s)} public main static public (String [] args) {student1 Edureka1 = new student1 () Edureka1.add () Edureka1.sub () Edureka1. mul () Edureka1.div ()}}

תְפוּקָה:

בהתקדמות נוספת נלמד לקנן ממשק ג'אווה.

קינון ממשק Java

ממשק קינון הוא תהליך של הכרזה על ממשק בתוך ממשק אחר ממשק קיים או להכריז על ממשק בתוך a מעמד. הממשק המקונן ידוע גם בשם ממשק פנימי.

לא ניתן לגשת לממשק המקונן ישירות . לפיכך, קינון מיושם על מנת לפתור את מרחבי השמות על ידי קיבוץם עם קשריהם ממשקים ו שיעורים. לפי נוהל זה,אנחנו יכולים לקרוא ממשק מקונן דרך ה כיתה חיצונית אוֹ ממשק חיצוני שם ואחריו א נקודה (.) , ו שם ממשק.

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

// קוד ממשק

חבילה ממשק ציבורי של Nest OuterInterface {void display () ממשק InnerInterface {void InnerMethod ()}}

// קוד כיתה

חבילה מחלקה של Nest NestedInterfaceDemo מיישמת את OuterInterface.InnerInterface {public void InnerMethod () {int n = 10, t1 = 0, t2 = 1 System.out.print ('First' + n + 'terms:') for (int i = 1 i & lt = n ++ i) {System.out.print (t1 + '+') int sum = t1 + t2 t1 = t2 t2 = sum} System.out.println ('nPrinting from Nested InnerInterface Interface ...! n ')} ציבורי ריק ריק סטטי (מחרוזת טוענת []) {OuterInterface.InnerInterface obj = new NestedInterfaceDemo () obj.InnerMethod ()}}

תְפוּקָה:

מה ההבדל בין html ל- xml

10 מונחים ראשונים: 0 + 1 + 1 + 2 + 3 + 5 + 8 + 13 + 21 + 34 + הדפסה משיטת Nested InnerInterface ...!

עכשיו, בואו ננסה לקנן א ממשק Java בתוך א מחלקת Java.

// קוד ממשק

טרנספורמציות אקטיביות ופסיביות באינפורמטיקה

חבילה Nest2 מחלקה ציבורית EdurekaClass {ממשק EdurekaInterface {void NestedMethod ()}}

// קוד כיתה

חבילה מחלקה Nest2 NestedInterfaceDemo2 מיישמת את EdurekaClass.EdurekaInterface {public void NestedMethod () {String input = 'Edureka' byte [] strAsByteArray = input.getBytes () byte [] result = byte [strAsByteArray.length] for (int i = 0AstrA) .length i ++) תוצאה [i] = strAsByteArray [strAsByteArray.length-i-1] System.out.println (מחרוזת חדשה (תוצאה))} סטטי ציבורי ריק ריק (String args []) {EdurekaClass.EdurekaInterface obj = new NestedInterfaceDemo2 () obj.NestedMethod ()}}

תְפוּקָה:

akerudE

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

ההבדל בין Java Class לבין ממשק Java

יתרונות וחסרונות של ממשק Java

יתרונות:

• ממשק Java תומך ירושה מרובה.
• ממשק Java מאפשר למתכנתים לפרק את גישות התכנות המורכבות ולפשט את תלות בין החפצים.
• ממשק Java הופך את חברי נתונים ו שיטות ביישום שיש לשלב באופן רופף.

חסרונות:

• השימוש בממשק Java מוריד את מהירות ביצוע של הבקשה.
• ממשקי Java ביישום משמשים שוב ושוב במידה רבה או כמעט ולא משתמשים בהם כלל.

נקודות מפתח בממשק Java

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

// קוד ממשק

חבילה extInterface ממשק ציבורי extInterface {שיטת חלל ציבורית 1 () שיטת חלל ציבורית 2 ()}

// קוד כיתה

חבילה extInterface לייבא java.util.Scanner מחלקה Edureka מיישמת extInterface {public void method1 () {System.out.println ('יישום שיטה 1') סורק סורק = סורק חדש (System.in) System.out.println ('הזן מספר כדי למצוא שורש ריבועי בג'אווה: ') ריבוע כפול = סורק.נאקסטכפול () כפול ריבוע שורש = Math.sqrt (ריבוע) System.out.printf (' שורש ריבועי של מספר:% f הוא:% f% n ', ריבוע, squareRoot)} שדה ריק חלל ציבורי 2 () {System.out.println ('יישום של שיטה 2')} חלל סטטי ציבורי ראשי (String arg []) {extInterface obj = new Edureka () obj.method1 ()}}

תְפוּקָה:

יישום שיטה 1 הזן מספר כדי למצוא שורש ריבועי בג'אווה: 16 שורש ריבועי של מספר: 16.0 הוא: 4.0

• מחלקה יכולה ליישם מספר ירושות במופע אחד. הבה נבין זאת באמצעות הקוד הבא.

// קוד ממשק 1

חבילה ממשק ציבורי ExtendInt ממשק 1 {public void armstrong ()}

// קוד ממשק 2

חבילה ממשק ציבורי ExtendInt ממשק 2 {פריים ריק ריק ()} // חבילת קוד מחלקה מחלקה ציבורית ExtendInt Edureka2 מיישם ממשק 1, ממשק 2 {חלל ציבורי armstrong () {int c = 0, a, temp int n = 153 // temp input = n ואילו (n & gt0) {a = n% 10 n = n / 10 c = c + (a * a * a)} אם (temp == c) System.out.println ('מספר זרוע') אחר System.out.println ('לא מספר זרוע') System.out.println ('הרחבה לממשק 1')} פריים ריק ריק () {int i, m = 0, flag = 0 int n = 3 // input m = n / 2 if (n == 0 || n == 1) {System.out.println (n + 'אינו מספר ראשוני')} אחר {עבור (i = 2i & lt = mi ++) {אם (n% i == 0) {מערכת .out.println (n + 'אינו מספר ראשוני') דגל = הפסקה אחת}} אם (דגל == 0) {System.out.println (n + 'הוא מספר ראשוני')}} System.out.println ('הרחבה לממשק 2 ')} ראשי ריק סטטי ציבורי (String args []) {Interface2 obj = new Edureka2 () obj.prime () Interface1 obj1 = new Edureka2 () obj1.armstrong ()}}

תְפוּקָה:

3 הוא המספר הראשוני המשתרע לממשק 2 המספר הארוגי המשתרע לממשק 1

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

// קוד ממשק

מבחן חבילה ממשק ציבורי נסה {// public int a = 10 // public static final int a = 10 // static int a = 0 // final int a = 10 // int a = 10}

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

// קוד ממשק

חבילה אותו ממשק ציבורי A {תצוגת חלל ציבורי ()} // חבילת קוד ממשק אותו ממשק ציבורי B {צג חלל ציבורי ()} // חבילת קוד מחלקה אותה מחלקה אותה יישומים A, B {תצוגה ריקה ציבורית () {System.out .println ('הצגת נתונים')} ראשי ריק סטטי ציבורי (מחרוזת [] טענות) {אותה הדפסה = חדש אותו () print.display ()}}

תְפוּקָה:

ברוך הבא ללימוד אלקטרוני של אדוריקה

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

עכשיו שהבנתם את היסודות של ג'אווה, עיינו ב מאת אדוריקה, חברת למידה מקוונת מהימנה עם רשת של יותר מ -250,000 לומדים מרוצים הפרוסים ברחבי העולם. קורס ההכשרה וההסמכה של Java J2EE ו- SOA של אדוריקה מיועד לסטודנטים ואנשי מקצוע שרוצים להיות מפתח Java. הקורס נועד לתת לך התחלה בתכנות ג'אווה ולהכשיר אותך למושגי הליבה והמתקדמים של ג'אווה יחד עם מסגרות Java שונות כמו Hibernate & אביב .

יש לך שאלה עבורנו? הזכיר זאת בקטע ההערות בבלוג 'ממשק Java' ונחזור אליך בהקדם האפשרי.