מאמר זה ירחיב על השימוש והטמעה של עקיפת שיטה ב-Java.
מהי 'עקיפה של שיטה' ב-Java?
אם מחלקת הילד מכילה שיטה דומה כפי שצוינה במחלקה האב שלה, היא מכונה ' עוקף שיטה ' בג'אווה. על ידי כך, הפונקציונליות של כיתת הילד, כלומר, השיטה המוחלפת, נכנסות לתוקף.
שיקולים לגבי 'עקיפה של שיטה' ב-Java
- המתודה חייבת להכיל את השם הזהה כמו במחלקת האב שלה.
- למתודה צריכה להיות פרמטר זהה כמו במחלקת האב שלה.
- השיטה שהוקצתה כ' סופי ' לא ניתן לעקוף.
דוגמה 1: עקיפה של שיטה ב-Java
בדוגמה זו, המתודולוגיה של דריסת שיטה, כלומר, ' פוּנקצִיָה 'ניתן לבצע באמצעות ירושה:
מעמד הוֹרֶה {
פּוּמְבֵּי בָּטֵל showout ( ) {
מערכת . הַחוּצָה . println ( 'זה Linuxhint!' ) ;
} }
מעמד יֶלֶד משתרע הוֹרֶה {
פּוּמְבֵּי בָּטֵל showout ( ) {
מערכת . הַחוּצָה . println ( 'זו ג'אווה!' ) ;
} }
פּוּמְבֵּי מעמד דוגמא {
פּוּמְבֵּי סטָטִי בָּטֵל רָאשִׁי ( חוּט [ ] args ) {
חפץ ילד = חָדָשׁ יֶלֶד ( ) ;
obj. showout ( ) ;
} }
בהדגמה לעיל, יש ליישם את השלבים הבאים:
- ראשית, צור כיתת הורה (על) בשם ' הוֹרֶה '.
- בתוך מחלקה זו, הגדר פונקציה בשם ' showOut() ' והצג את ההודעה הנתונה בהגדרת (הפונקציה) שלה.
- לאחר מכן, צור כיתת ילד (משנה) בשם ' יֶלֶד יורש את ' הוֹרֶה ' בכיתה באמצעות ' משתרע ' מילת מפתח.
- במחלקה זו, עוקף את הפונקציה שהוגדרה בתוך מחלקת האב שלה על ידי הגדרתה בשם הזהה ' showOut() ' והצג את ההודעה האמורה.
- בעיקרון, צור אובייקט של כיתת הילד באמצעות ' חָדָשׁ ' מילת המפתח וה' יֶלֶד() 'קונסטרוקטור.
- לבסוף, הפעל את הפונקציה ' showOut() ' על ידי התייחסות לאובייקט שנוצר. פעולה זו תפעיל את הפונקציה שנדרסה במקום ברירת המחדל במחלקת האב.
תְפוּקָה
בפלט שלעיל, ניתן לנתח שהפונקציה האחרונה, כלומר, דחופה נכנסת לתוקף.
דוגמה 2: ניצול מילת מפתח 'סופר' בעקיפה של שיטה באמצעות Java
בדוגמה הספציפית הזו, ' סוּפֶּר ' ניתן לשייך מילת מפתח כדי להפעיל את הפונקציונליות של ברירת המחדל, כלומר האב והשיטה שנחרפה:
מעמד הוֹרֶה {פּוּמְבֵּי בָּטֵל showout ( ) {
מערכת . הַחוּצָה . println ( 'זה Linuxhint!' ) ;
} }
מעמד יֶלֶד משתרע הוֹרֶה {
פּוּמְבֵּי בָּטֵל showout ( ) {
סוּפֶּר . showout ( ) ;
מערכת . הַחוּצָה . println ( 'זו ג'אווה!' ) ;
} }
פּוּמְבֵּי מעמד דוגמא {
פּוּמְבֵּי סטָטִי בָּטֵל רָאשִׁי ( חוּט [ ] args ) {
חפץ ילד = חָדָשׁ יֶלֶד ( ) ;
obj. showout ( ) ;
} }
בגוש הקוד שלמעלה:
- באופן דומה, צור כיתת אב בשם ' הוֹרֶה ' ולצבור את הפונקציה ' showOut() ' בו, מציג את ההודעה שסופקה.
- בשלב הבא, צור כיתת ילד בשם ' יֶלֶד יורש את כיתת האב.
- בתוך מחלקה זו, באופן דומה, לעקוף את הפונקציה הזהה. כמו כן, שייך את ' סוּפֶּר ' מילת מפתח עם הפונקציה להפעיל את ברירת המחדל, כלומר, הפונקציות של פונקציית מחלקת האב.
- לבסוף, צור אובייקט של כיתת הילד והפעל את הפונקציה שנדחתה.
- אַלגוֹרִיתְם: הביצוע ייעשה באופן שכאשר הפונקציה שנדחתה מופעלת, וה' סוּפֶּר ' מילת מפתח תתייחס לפונקציית מחלקת האב. זה יביא לרישום הפונקציונליות של כיתות ההורה והילד בו-זמנית על המסוף.
תְפוּקָה
הפלט שלמעלה מסמל שניתן לבטל את ההשפעה של הפונקציה שנדחתה גם באמצעות ה-' סוּפֶּר ' מילת מפתח.
דוגמה 3: עקיפה של שיטת 'הסופית' ב-Java
בדוגמה זו, ניתן להקצות פונקציה כ' סופי ' בכיתת האב ובהמשך מנותח על ידי גישה אליה בכיתת הילד שלה:
מעמד הוֹרֶה {סופי פּוּמְבֵּי בָּטֵל showout ( ) {
מערכת . הַחוּצָה . println ( 'זה Linuxhint!' ) ;
} }
מעמד יֶלֶד משתרע הוֹרֶה {
פּוּמְבֵּי בָּטֵל showout ( ) {
מערכת . הַחוּצָה . println ( 'זו ג'אווה!' ) ;
} }
פּוּמְבֵּי מעמד דוגמא {
פּוּמְבֵּי סטָטִי בָּטֵל רָאשִׁי ( חוּט [ ] args ) {
חפץ ילד = חָדָשׁ יֶלֶד ( ) ;
obj. showout ( ) ;
} }
על פי הקוד שסופק לעיל, יישם את השלבים המפורטים להלן:
- צור את כיתת האב ' הוֹרֶה '.
- בתוך מחלקה זו, הקצו את הפונקציה ' showOut() ' כפי ש ' סופי ', כפי שמצוין במילת המפתח הקודמת.
- כעת, ירשו את כיתת הילד ' יֶלֶד ' מהכיתה המדוברת לשעבר. כאן, תעקוף את 'המוקצים' סופי ' פונקציה במחלקת האב.
- בעיקרון, צור אובייקט של ' יֶלֶד ' מחלקים והפעילו את הפונקציה הנעקבת.
תְפוּקָה
ביצוע הקוד לעיל ירשום את השגיאה המוצגת מאז ' סופי לא ניתן לעקוף את השיטה.
סיכום
אם מחלקת הילד מכילה שיטה דומה כפי שצוינה במחלקה האב שלה, היא תואמת לעקוף מתודה ב-Java. גישה זו עוקפת את השיטות הראשונות ומיישמת את האחרונות. ניתן לטפל בעקיפה באמצעות ' סוּפֶּר ' או ה ' סופי ' מילות מפתח בדרכים שונות. בלוג זה דן ברעיון של עקיפת שיטה ב-Java.