PracticU

Function Overloading

בלי כתוביותעם כתוביות
PracticU › קורס יסודות התכנות - שפת JAVA - קורס ג'אווה למתחילים › Function Overloading
Function Overloading

בשיעור זה לומדים את טכניקת העמסת הפונקציות, כתיבת מספר פונקציות בשם זהה, מבינים מתי Java יודעת לבחור את הפונקציה הנכונה, מגלים למה אי אפשר להבחין בין פונקציות לפי הערך המוחזר, ורואים איך ההמרה מסוגים משפיעה על הבחירה.
נושאי הסיכום המוצגים בשיעור:
1. השאלה שפותחת את השיעור: האם אפשר לבנות מספר פונקציות עם אותו השם, ובהתחלה ניסיון לכתוב שתי פונקציות בשם print עם אותה חתימה מקבל שגיאה, כי כשקוראים לפונקציה Java לא יודעת לאיזה מהן לקפוץ, ועם שמות שונים כמובן אין שום בעיה.
2. מתי זה מתאפשר: מיד כשאחת הפונקציות מקבלת פרמטר שונה אין יותר שגיאה, וזאת טכניקה מוכרת בהרבה שפות תכנות שנקראת function overloading, בעברית העמסת פונקציות, מצב שבו רוצים לכתוב מספר פונקציות שעושות את אותו הדבר ולכן רוצים לתת להן את אותו השם, אבל כל אחת מקבלת מספר אחר של פרמטרים או סוג אחר של פרמטרים.
3. בחירת הפונקציה לפי הקריאה: כשקוראים לפונקציה בלי פרמטרים Java קופצת לפונקציה בלי פרמטרים, כששולחים פרמטר מספרי היא קופצת לפונקציה שמקבלת מספר, וכששולחים פרמטר מחרוזתי היא קופצת לפונקציה המתאימה, ובהדגמה עם סימון של הודעות שונות רואים שכל אחת מהפונקציות מתבצעת לפי הפרמטר ששלחנו.
4. העמסה לפי מספר הפרמטרים: ההפרדה נעשתה פעם על פי סוג הפרמטר ופעם על פי מספר הפרמטרים, ובהדגמה נוספת פונקציה שמקבלת שני פרמטרים מספריים, וכששולחים שני ערכים המערכת קופצת לפונקציה הרביעית, כך שאפשר לכתוב פונקציות באותו שם עם מספר שונה של פרמטרים ואו סוג שונה של פרמטרים.
5. לא ניתן להבדיל לפי הערך המוחזר: עולה השאלה אם אפשר להפריד בין פונקציות על פי הערך המוחזר, ובהדגמה פונקציה חדשה עם אותו פרמטר אבל ערך מוחזר שונה אינה מתקבלת, וזאת לא העמסת פונקציות בכלל, כי אי אפשר לבצע הפרדה כזאת, רק סוג הפרמטרים או מספר הפרמטרים או תשלובת ביניהם מבדילים.
6. ההסבר לאיסור: אפשר לחשוב שהמערכת תדע לזהות לפי הצבת הערך המוחזר במשתנה איזו פונקציה רוצים, אבל זוכרים שבשום מקום לא חייבים לקבל את הערך המוחזר, ולכן יש כאן בעיה, כי המערכת לא תדע האם לקפוץ לפונקציה שלא מחזירה שום דבר או לקפוץ לפונקציה שמחזירה ערך מבלי לקבל אותו, ולכן לא ניתן לבצע העמסה רק לפי ערך מוחזר, חובה שסוג או מספר הפרמטרים ישתנו.
7. עוד פונקציה עם סוג אחר: מוסיפים פונקציה שמקבלת פרמטר מסוג long והכל בסדר, ומסמנים אותה כפונקציה החמישית להדגמה.
8. ההמרה שמשנה את היעד: כשקוראים לפונקציה ושולחים שלושה מספרים שלמים Java קופצת לפונקציה שמקבלת מספרים שלמים, אבל אם רוצים בכל זאת להגיע לפונקציה של ה-long הפתרון הוא המרה, ובהדגמה משתמשים בסימון מספרי שלומדים בעולם ההמרות, ואז כן מתבצעת קפיצה לפונקציה שמציגה את הפונקציה החמישית, כי הערך השלם יכול להיות גם long.
9. השימוש המרכזי בהעמסה: השימוש המרכזי ביכולת הזאת הוא כשהפונקציות באמת עושות את אותה הפעולה אבל רוצים שכל פעם תתקבל משהו אחר בתור פרמטרים, וכך אפשר לקרוא לפונקציה באותו השם כשמספר הפרמטרים או הסוג שלהם שונה.
סיכום:
בשיעור זה הכרנו את העמסת הפונקציות ב-Java, למדנו ששני פונקציות בשם זהה מותרות רק כשמספר או סוג הפרמטרים שונה, ראינו איך המהדר בוחר את הפונקציה המתאימה לפי הקריאה, הבנו למה הערך המוחזר אינו קריטריון להעמסה בגלל שאין חובה לקבל אותו, וראינו איך המרת סוגים יכולה לכוון את הקריאה לפונקציה אחרת, ובשיעור הבא נעסוק בפרמטרים משתנים באורך.
בשיעור הבא נעסוק בנושא The varargs Argument.
מילון מושגים:
פונקציה – קטע קוד בעל שם שמבצע משימה מוגדרת, מקבל ערכי קלט (פרמטרים) ויכול להחזיר תוצאה. מאפשרת לארגן קוד ולהשתמש בו שוב.
Java – שפת תכנות עילית ומונחית עצמים, הרצה על מכונה וירטואלית (JVM) ומשמשת לפיתוח מגוון יישומים.
פרמטר – ערך שמועבר לפונקציה או לפקודה כקלט, ומשפיע על אופן פעולתן ועל התוצאה שהן מחזירות.
משתנה – שם שמפנה למקום בזיכרון שבו נשמר ערך שיכול להשתנות במהלך ריצת התוכנית, כמו מספר, טקסט או אובייקט.
קומפיילר – תוכנה שממירה קוד מקור שנכתב בשפת תכנות לקוד שהמחשב יכול להריץ, ומדווחת על שגיאות תחביר.
SR11150HE

פרקי ההרצאה: Function Overloading

  1. 00:00

    שתי פונקציות באותו שם: מה קורה

  2. 00:59

    מהי העמסת פונקציות (Function Overloading)

  3. 01:36

    העמסה לפי סוג הפרמטר

  4. 02:33

    העמסה לפי מספר הפרמטרים

  5. 03:16

    למה אי אפשר להעמיס לפי ערך מוחזר

תמלול ההרצאה: Function Overloading

הטקסט המלא של הדקות הראשונות בהרצאה «Function Overloading» בקורס הווידאו של PracticU – כתוביות בעברית עם זמן התחלה לכל פסקה. כך תוכלו לקרוא ולחפש את הנושאים לפני שמתחילים ללמוד.

  1. 00:02

    האם אנחנו יכולים לבנות מספר פונקציות עם אותו השם? בואו נראה האם הדבר הזה אפשרי. בואו נניח שיש לנו כאן איזושהי פונקציה, נניח נקרא לה print, ואנחנו מציגים כאן printing some message.

  2. 00:24

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

  3. 00:45

    כמובן שעם שמות שונים אין שום בעיה, אבל מה קורה אם פונקציה אחת מקבלת פרמטר? לדוגמה int a, printing some message ובואו נדפיס פה כמה זה a.

  4. 01:01

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

  5. 01:16

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

  6. 01:31

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

  7. 01:52

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

  8. 02:08

    בואו נריץ את זה, והנה יש לנו עכשיו קפיצה לכל אחת משלושת הפונקציות. נעשה פה איזשהו הבדל printing some message 1, זה יהיה 2 וזה יהיה 3. נריץ שוב ונראה באמת שכל אחת מהפונקציות מתבצעת לפי הפרמטר ששלחנו.

  9. 02:31

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

  10. 02:42

    אם אנחנו ניקח ונבצע שוב פעם printing some message 4 אבל נשלח a ו-b גם זה חוקי לגמרי בואו נדפיס פה רק את b ויאפשר לנו לבצע שוב פעם העמסה לפי מספר הפרמטרים בואו נשלח print ונשלח 10 ו-20 ואז המערכת תקפוץ לפונקציה הרביעית הנה אנחנו רואים את זה כאן אז יש לנו אפשרות לכתוב פונקציות עם אותו השם אבל עם מספר שונה של פרמטרים ו/או סוג שונה של פרמטרים.

  11. 03:19

    האם אנחנו יכולים לעשות את ההפרדה הזאת על פי הערך המוחזר של הפונקציה? בואו ניקח את הפונקציה הזאת. יש לנו פה פונקציה שמקבלת String a ופונקציה שמקבלת Int a. אוקיי, בואו ניקח עוד פונקציה שגם תקבל Int, כמובן אנחנו רואים פה שגיאה, אבל לא נחזיר void אלא נחזיר, בואו נניח, ריטרן 1.2 אז אנחנו רואים שהמערכת לא מסכימה לקבל את ההעמסה הזאת ולמעשה זאת לא העמסה

  12. 03:55

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

  13. 04:16

    אתם יכולים להגיד רגע אבל המערכת יכולה לדעת בעצם

לקורס המלא: קורס ג'אווה למתחילים אונליין

ההרצאה הקודמת: תרגילים על Returning a Value from a Function

ההרצאה הבאה: The varargs Argument

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

  • methods overloading
  • פונקציה - Function
  • העמסת אופרטור-Operator Overloading
  • Stored Procedure vs Function

קורסים נוספים במסלול

  • קורס מבוא ל-QA - מידע חשוב לבודק תוכנה
  • קורס פוסטמן - Postman - בדיקות לאתרי אינטרנט - API
  • קורס Robot Framework - בדיקות QA ממשק גרפי
  • קורס סלניום בסיסי - בדיקות אוטומטיות - Selenium
  • קורס סלניום מתקדם - CI/CD - Continues Integration
  • קורס מייבן - Maven