בג'אווה, ה' צרכן ממשק ” מייצג פעולה שמקבלת קלט בודד ומבצעת עליו פעולה כלשהי מבלי להחזיר תוצאה. זה גם מציע דרך גמישה להגדיר פעולות מותאמות אישית שניתן להשתמש בהן בתכנות פונקציונלי כמו ביטויי למבדה. בלוג זה ממחיש את היישום של ממשק לצרכן ב-Java.
כיצד להשתמש בממשק לצרכן ב-Java?
ה ' צרכן ממשק 'מציע את האנקפסולציה או ההתנהגות שניתן להעביר ולבצע במקומות שונים בתוכנית. זה מקדם התנהגות לשימוש חוזר שניתן להחיל על כניסות שונות מבלי לשכפל קוד. ממשק הצרכן מורכב משתי שיטות כלומר ' ואז() ' ו' לְקַבֵּל() '.
בקר בדוגמאות שלהלן להבנת שתי הפונקציות יחד עם דוגמאות codec:
דוגמה 1: שימוש בשיטת 'andThen()'.
המפתח יכול לשרשר מספר ' צרכן ' פעולות בסך הכל באמצעות ' ואז() ' שיטה. זה מחזיר ' צרכן ' שמבצע את פעולת ה' הנוכחי צרכן ' למשל. לאחר מכן, ממלא את הפעולות של הקרוב/אחרי ' צרכן ' למשל. זוהי שיטת ברירת המחדל שנמצאת בשימוש נרחב לתהליך של ' הרכב '.
התחביר עבור ' ואז() השיטה 'מוכנסת להלן:
ואז ( צרכן < ? סופר טי > לאחר )
ה ' ואז() שיטת ' משלבת את הצרכן הנוכחי ' סוּפֶּר 'עם צרכן אחר' לאחר '. והוא מבצע תחילה את פעולת הצרכן הנוכחי, ולאחר מכן את פעולת הצרכן המסופק.
הבה נעבור על תוכנית להבנה טובה יותר:
ייבוא java.util.ArrayList;ייבוא java.util.LinkedList;
ייבוא java.util.List;
ייבוא java.util.function.Consumer;
שורש מעמד ציבורי {
ריק סטטי ציבורי ראשי ( מחרוזת ארגומנטים [ ] )
{
// יצירת השיטה העיקרית
צרכן < רשימה < מספר שלם > > כפל = dataEle - >
{
ל ( int j = 0 ; י < dataEle.size ( ) ; j++ ) {
dataEle.set ( י, 5 * dataEle.get ( י ) ) ;
}
} ;
// צרכן כדי להציג רשימה של מספרים שלמים
צרכן < רשימה < מספר שלם > >
prints = dataEle - > dataEle.stream ( ) .לכל אחד ( ק - > מערכת.out.print ( k + '' ) ) ;
רשימה < מספר שלם > dataEle = ArrayList חדש < מספר שלם > ( ) ;
dataEle.add ( 4 ) ;
dataEle.add ( 7 ) ;
dataEle.add ( 12 ) ;
dataEle.add ( 16 ) ;
להכפיל.ואז ( הדפסים ) .לְקַבֵּל ( dataEle ) ;
}
}
הסבר על הקוד לעיל:
- קודם ה ' צרכן ', ' רשימה מקושרת ' וכלי עזר קשורים מיובאים לקובץ Java. לאחר מכן, הכיתה הראשית עם השם ' שורש ' נוצר.
- לאחר מכן, צור ממשק 'צרכן' מסוג רשימה בשם ' לְהַכפִּיל ' והגדר אותו שווה ל' רשימת מערך ' שהולך להיווצר למטה.
- הוא משתמש ב' ל ' לולאה החוזרת עד אורך ' רשימת מערך 'שם' dataEle ', ומכפיל כל רכיב נתונים של ' dataEle ' עם ' 5 '.
- אחרי זה, שנייה' צרכן נוצר ממשק שמדפיס כל אלמנט בקונסולה שאוחזר לאחר תהליך הכפל מזרם.
- כעת, צור והוסף רכיבי נתוני דמה ב' dataEle ' רשימת מערך.
- בסופו של דבר, ה' ואז() 'שיטה נקראת עם ' לְקַבֵּל() 'שיטה שמקבלת' dataEle ' ArrayList ומחזירה את התוצאה של ' לְהַכפִּיל ' ברצף.
לאחר סיום שלב הביצוע:
תמונת המצב מראה שמשימת הכפל הושלמה על ידי שימוש ב' ואז() שיטת ה' צרכן ' ממשק.
דוגמה 2: שימוש בשיטת 'accept()'.
ה ' לְקַבֵּל() שיטת ' היא שיטה פונקציונלית של ' צרכן ' ממשק. הוא מקבל ארגומנט יחיד מסוג ' ט ' ומבצע עליו את הפעולות שצוינו/הדרושות. הערך של ' ריק 'אסור לספק לו כי הוא אינו מקבל' ריק ' ערכים ויוצרים חריג.
התחביר שלו ניתן להלן:
בטל לקבל ( < חָזָק > ט חָזָק > ט )
בתחביר לעיל, ה-' ט ' הוא הטיעון היחיד שעליו מופעלות פעולות מסוימות.
תן לנו לבקר בגוש הקוד למטה להבנה טובה יותר:
ייבוא java.util.ArrayList;ייבוא java.util.LinkedList;
ייבוא java.util.List;
ייבוא java.util.function.Consumer;
// ייבוא כלי עזר ב Java קוֹבֶץ
שורש מעמד ציבורי {
ריק סטטי ציבורי ראשי ( מחרוזת ארגומנטים [ ] ) // יצירת השיטה העיקרית
{
צרכן < מספר שלם > disp = k - > System.out.println ( ק ) ;
disp.accept ( 255 ) ;
צרכן < רשימה < מספר שלם > > כפל = dataEle - >
{
ל ( int k = 0 ; ק < dataEle.size ( ) ; k++ )
dataEle.set ( ק, 5 * dataEle.get ( ק ) ) ;
} ;
צרכן < רשימה < מספר שלם > >
prints = dataEle - > dataEle.stream ( ) .לכל אחד ( י - > מערכת.out.print ( j + '
' ) ) ;
רשימה < מספר שלם > dataEle = ArrayList חדש < מספר שלם > ( ) ;
dataEle.add ( 4 ) ;
dataEle.add ( 7 ) ;
dataEle.add ( 12 ) ;
dataEle.add ( 16 ) ;
// יישם שינוי באמצעות קבל ( )
להכפיל.לקבל ( dataEle ) ;
// יישם dispList באמצעות accept ( )
prints.accept ( dataEle ) ;
}
}
הסבר על הקוד לעיל:
- קודם ה ' צרכן ממשק בשם ' disp ' נוצר אשר מציג פרמטרים שסופקו על המסוף, מבלי לבצע שום פעולה.
- עכשיו ה ' לְקַבֵּל() השיטה נקראת על ידי ' disp 'צרכן, והערך של' 255 ” מועבר לשיטה זו.
- הבא, עוד ' צרכן נוצר ממשק המשתמש ב- ל ' לולאה להחלת כפל על כל רכיב שוכן של ArrayList בשם ' dataEle '.
- לאחר מכן, צור אחד נוסף ' צרכן ממשק כדי להציג את ' dataEle אלמנטים נוצרים לאחר החלת הכפל שמגיע מהזרם.
- לאחר מכן, אתחול ArrayList ' dataEle ' עם רכיבי נתוני דמה והשתמשו ב-' לְקַבֵּל() שיטת ' עם ' לְהַכפִּיל ' ממשק.
- בסופו של דבר, התקשר ל' לְקַבֵּל() שיטת ' באמצעות ' הדפסים ' ממשק להצגת התוצאה לאחר החלת הכפל ביומן המסוף.
לאחר סיום הביצוע:
תמונת המצב לעיל מציגה שממשקי צרכנים מרובים נקראו אחד בכל פעם באמצעות ' לְקַבֵּל() ' שיטה.
דוגמה 3: חריג טיפול עבור פונקציית After
החריג מתעורר כאשר ' לאחר ' הפונקציה של ' ואז() שיטת ' מכילה ' לְקַבֵּל() ' שיטה. זה יוצר ממשק שמכיל נתונים שיעובדו על ידי ממשקים בשיטות ממשק צרכנים כפי שמוצג להלן:
ייבוא java.util.ArrayList;ייבוא java.util.LinkedList;
ייבוא java.util.List;
ייבוא java.util.function.Consumer;
שורש מעמד ציבורי {
ריק סטטי ציבורי ראשי ( מחרוזת ארגומנטים [ ] )
{
צרכן < רשימה < מספר שלם > > לְהַכפִּיל = dataEle - >
{
ל ( int j = 0 ; י < = dataEle.size ( ) ; j++ )
dataEle.set ( י, 5 * dataEle.get ( י ) ) ;
} ;
// צרכן כדי להציג רשימה של מספרים שלמים
צרכן < רשימה < מספר שלם > >
הדפס = dataEle - > dataEle.stream ( ) .לכל אחד ( אני - > מערכת.out.print ( אני + '' ) ) ;
רשימה < מספר שלם > dataEle = ArrayList חדש < מספר שלם > ( ) ;
dataEle.add ( 4 ) ;
dataEle.add ( 7 ) ;
dataEle.add ( 12 ) ;
dataEle.add ( 16 ) ;
לְנַסוֹת {
הדפס.ואז ( לְהַכפִּיל ) .לְקַבֵּל ( dataEle ) ;
}
לתפוס ( חריג ה ) {
System.out.println ( 'יוצא מן הכלל: ' + ו ) ;
}
}
}
הסבר על בלוק הקוד לעיל:
- קודם ה ' צרכן נוצר ממשק אשר פשוט מרובה ' 5 ” מספרים שלמים עם רכיבי הנתונים השוכנים ב- ArrayList שסופק.
- הבא, השני' צרכן 'ממשק נוצר כדי להציג כל רכיב נתונים של ArrayList שמתקבל על ידי הזרם.
- לאחר מכן, ה-ArrayList נוצר ומאוחל עם ערכי סוג מספר שלם דמה.
- אז ה ' לְנַסוֹת נעשה שימוש בגוש שבו ' ואז() השיטה נקראת על ידי ' הדפס ' ממשק.
- זה גורם ל' IndexOutOfBoundsException ' בגלל ה ' ל חריגה ממגבלת איטרציית הלולאה, אשר נפתרת על ידי ' לתפוס ' לחסום.
לאחר סיום שלב הביצוע:
תמונת המצב מראה ש- IndexOutOfBoundsException נוצר על ידי המהדר.
סיכום
ה ' צרכן ממשק ” מספק דרך להגדיר התנהגות ניתנת לשימוש חוזר ולבצע פעולות על נתוני קלט מבלי להחזיר תוצאה. זה מורכב מ ' לְקַבֵּל() ' ו' ואז() ' שיטות. הוא משמש לעתים קרובות למשימות עיבוד נתונים, שבהן המשתמשים צריכים לבצע פעולה על כל רכיב של אוסף או זרם. זה הכל לגבי השימוש והיישום של ממשק הצרכן ב-Java.