תוכנה 1 בשפת Java שיעור מספר 1: מתחילים מחדש דן הלפרין עמירם יהודאי בית הספר למדעי המחשב אוניברסיטת תל אביב

מטרות הקורס עקרונות נשארים, שפות וכלי פיתוח משתנים ומתחלפים הבנת מתודולוגיות שמסייעות בפיתוח תוכנה בקנה מידה גדול: תכנות מונחה עצמים, תיכון בעזרת חוזים, ביצוע מקסימום בדיקות בזמן קומפילציה, ניהול זיכרון אוטומטי היכרות עם שפת ג'אווה הקניית מיומנויות תכנות היכרות עם כלי פיתוח מתקדמים (Eclipse) עקרונות נשארים, שפות וכלי פיתוח משתנים ומתחלפים תוכנה 1 בשפת Java אוניברסיטת תל אביב תוכנה 1 בשפת Java אוניברסיטת תל אביב 2

מוטיבציה Java היא שפה פופולרית בעולם התוכנה כיום את עקרונות ה-Object Oriented שתלמדו ניתן ליישם בהרבה שפות תכנות מודרניות דומות תוכנה 1 בשפת Java אוניברסיטת תל אביב תוכנה 1 בשפת Java אוניברסיטת תל אביב 3

נושאים שהוצגו/תורגלו (חלקית) עד כה יסודות התכנות בג'אווה: טיפוסים, מזהים, משתנים, ביטויים, השמה, מבני בקרה, פרוצדורות (מתודות). סביבת העבודה: מהדר (קומפילר), מפרש (אינטרפרטר), סביבת פיתוח שלובה. מודל הזכרון של ג'אווה. עקרונות יסוד: מודולריות, מניעת שכפול קוד. לימוד ראשוני של תכנות מונחה עצמים: מחלקות, עצמים, מנשקים. הכרה ושימוש ב eclipse המחלקות String ו StringBuffer הכרת Java Collections נסתמך על הידע שנצבר, אבל נחזור עליו, לא באותו הסדר תוכנה 1 בשפת Java אוניברסיטת תל אביב תוכנה 1 בשפת Java אוניברסיטת תל אביב 4

מה בתכנית? מבוא קצר על שפת ג'אוה תכנות מונחה עצמים, מוטיבציה ועקרונות עצמים ומחלקות בג'אוה העמסה תוכנה 1 בשפת Java אוניברסיטת תל אביב

שלום עולם Write Once – Run Anywhere ! compile Run on Solaris HelloWorld.class HelloWorld.java Run on Windows Run on Solaris Run on Mac Write Once – Run Anywhere ! תוכנה 1 בשפת Java אוניברסיטת תל אביב תוכנה 1 בשפת Java אוניברסיטת תל אביב 6

יבילות (portability) מדוע אנו מסתפקים בפורמט "נוח יותר"? מדוע אין המהדר יוצר קובץ בפורמט התואם בדיוק לחומרת המחשב, וכך היה נחסך בזמן ריצה גם שלב ה"הבנה" של הקוד? זאת מכיוון שאיננו יודעים מראש על איזה מחשב בדיוק תרוץ תוכנית ה- Java שכתבנו תוכניות Java חוצות סביבות cross platform)) סביבה = חומרה + מערכת הפעלה תוכנית שנכתבה והודרה במחשב מסוים, תוכל לרוץ בכל מחשב אשר מותקן בו מפרש ל- Java תוכנה 1 בשפת Java אוניברסיטת תל אביב

המכונה המדומה (Java Virtual Machine) הקובץ המהודר מכיל הוראות ריצה ב"מחשב כללי" – הוא אינו עושה הנחות על ארכיטקטורת המעבד, מערכת ההפעלה, הזיכרון וכו'... עבור כל סביבה (פלטפורמה) נכתב מפרש מיוחד שיודע לבצע את התרגום מהמחשב הכללי, המדומה, למחשב המסוים שעליו מתבצעת הריצה את המפרש לא כותב המתכנת! דבר זה כבר נעשה ע"י ספקי תוכנה שזה תפקידם, עבור רוב סביבות הריצה הנפוצות תוכנה 1 בשפת Java אוניברסיטת תל אביב 8

תלות בסביבה (platform specific) בשפות אחרות (C/C++) אין הדבר כך: שלב הפיתוח שלב הריצה תוכנה 1 בשפת Java אוניברסיטת תל אביב 9

עצמאות סביבתית (platform independence) ב Java תכונה זו אפשרית הודות לרעיון "שפת הביניים" וה JVM הנפרד לכל סביבה שלב הפיתוח שלב הריצה תוכנה 1 בשפת Java אוניברסיטת תל אביב 10

"משבר התוכנה" כתיבת תוכנית קטנה אינה משימה קשה הקושי בהנדסת תוכנה נעוץ בבניית מערכות תוכנה גדולות (1,000,000< שורות קוד), ע"י מספר אנשים הדורשות תחזוקה לאורך זמן רב (כמה שנים) מאז סוף שנות ה-60 של המאה ה-20 ברור לעולם התוכנה, כי בשביל להתגבר על הקושי שבכתיבת מערכות גדולות יש צורך להלביש על שפת התכנות עקרונות פיתוח נכונים אשר ישפרו את היכולת לכתוב מערכות תוכנה מורכבות ידיעת קרוא וכתוב לא הופכת אותך לסופר לימודי ארכיטקטורה לא הופכים אותך לארכיטקט מוצלח תוכנה 1 בשפת Java אוניברסיטת תל אביב

תכנות מונחה עצמים אחד מאוספי העקרונות האלה מכונה "תכנות מונחה עצמים" (Object Oriented Programming) שעיקריו (כפי שיבואו לידי ביטוי בקורס): שימוש חוזר בקוד הפשטה מודולריות תיכון בעזרת חוזים (design by contract) ביצוע מקסימום בדיקות תקינות בזמן קומפילציה ניהול זיכרון אוטומטי חלק משפות התכנות המודרניות מקדמות עקרונות אלו ע"י הגדרת מבנים בשפה שיתמכו בהם בצורה ישירה או עקיפה שפת Java היא שפה כזו כשם שלולאת for הוסיפה לתחביר את מרכיבי הלולאה תוכנה 1 בשפת Java אוניברסיטת תל אביב

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

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

מודולריות בתכנות מונחה עצמים בתכנות מונחה עצמים המודולים הם המחלקות מתברר שארכיטקטורת מערכת שמבוססת על הנתונים מאפשרת מודולריות טובה יותר מארכיטקטורה שמבוססת על הפונקציונליות מכיוון שהישויות העיקריות של המערכת נשארות יותר יציבות לאורך חיי המערכת מאשר הפעולות שרוצים שהמערכת תעשה מכאן היתרון של פיתוח תוכנה מונחה עצמים תוכנה 1 בשפת Java אוניברסיטת תל אביב

לקוח וספק במערכת תוכנה ספק (supplier) – הוא מי שקוראים לו (לפעמים נקרא גם שרת, server) לקוח (client) הוא מי שקרא לספק או מי שמשתמש בו (לפעמים נקרא גם משתמש, user). דוגמא: public class Two { ... One obj = new One(..); obj.action(..); } public class One { ... public void action(..) { // doing... } בדוגמא זו המחלקה Two היא לקוחה של המחלקה One One היא ספקית של Two יחס בין מחלקות, אבל גם בין שרותים וכו' תוכנה 1 בשפת Java אוניברסיטת תל אביב

עצמים ומחלקות עצם (object) הוא יחידת תוכנה שמספקת שירותים (methods) מסוימים ושיש לה בכל נקודת זמן מצב רגעי מסוים (state). מחלקה (class) היא קבוצה של עצמים מאותו סוג, כלומר שמספקים את אותם שירותים באותה צורה העצמים הם מופעים (instances) של המחלקה עצמים שונים מאותה מחלקה נמצאים במצבים רגעיים שונים המחלקה היא הישות הסטטית בקוד המקור העצם הוא הישות הדינמית בזמן הריצה תוכנה 1 בשפת Java אוניברסיטת תל אביב

מחלקה הגדרת מחלקה (בינתיים) public class ClassName { <list of class members> } רכיבי המחלקה: מספר כלשהו של שדות, שרותים (מתודות) ובנאים. קשורים זה לזה (חוזק פנימי גבוה). שדות/שרותי מחלקה (מלת המפתח static) לעומת שדות/שרותי מופע. ניראות ( private או public או ....) השרות המיוחד public static void main(String[] args) תוכנה 1 בשפת Java אוניברסיטת תל אביב

שדות/שרותי מופע ושדות/שרותי מחלקה לכל עצם יש עותק של שדות המופע. ערכי השדות ברגע נתון מהווים את מצבו של העצם. שרותי מופע פועלים על עצם. שדות מחלקה (מוגדרים עם מילת המפתח static) משותפים לכל העצמים של המחלקה. הם קיימים גם כאשר לא קיים אף עצם מופע של המחלקה. שרותי מחלקה (מוגדרים עם מילת המפתח static) אינם מתייחסים לעצם מסויים. תוכנה 1 בשפת Java אוניברסיטת תל אביב

נראות כותב המחלקה קובע איפה ניתן לראות (ולגשת) לרכיבים השונים של המחלקה. public ידוע מחוץ למחלקה – לשימוש על ידי הלקוח private מוכר רק בתוך המחלקה (בהמשך נראה אפשרויות נוספות) הלקוח צריך לדעת רק את השרותים שמיועדים לו; השדות משמשים למימוש, ולכן יהיו בדרך כלל פרטיים לעתים יהיו גם שרותים פרטיים – מספקים שרות לשרותים אחרים במחלקה, אך לא ללקוח כך מקטינים את הצימוד שינוי במימוש (שינוי הייצוג, שינוי אלגוריתם של שרות) אינם משפיעים על הלקוח תוכנה 1 בשפת Java אוניברסיטת תל אביב

הגדרת שרות התחביר של הגדרת שרות הוא: <modifiers> <type> <method-name> ( <paramlist> ) { <statements> } <modifiers> הם 0 או יותר מילות מפתח מופרדות ברווחים (למשל public static) <type> מציין את טיפוס הערך שהשרות מחזיר void מציין שהשרות אינו מחזיר ערך <paramlist> רשימת הפרמטרים הפורמליים, מופרדים בפסיק, כל אחד מורכב מטיפוס הפרמטר ושמו תוכנה 1 בשפת Java אוניברסיטת תל אביב

דוגמא – מחלקה פשוטה שדות מופע פרטיים שדה מחלקה פרטי בנאי public class Pair { private int val; private Pair next; static private int count = 0; public Pair(int v, Pair n) { val = v; next = n; count++; } public int value () { return val; שדות מופע פרטיים שדה מחלקה פרטי בנאי שרות מופע מיוצא תוכנה 1 בשפת Java אוניברסיטת תל אביב

המשך דוגמא public Pair nextPair ( ) { return next; } public void changeVal(int v) { val = v; public static int howMany ( ) { return count; תוכנה 1 בשפת Java אוניברסיטת תל אביב

דוגמת שימוש מה הפלט? public class TestPairs { public static void main(String[] args) { Pair one = new Pair(1,null); Pair two = new Pair(2,one); one = new Pair(3,new Pair(4,one)); System.out.println(Pair.howMany() + " pairs created"); for (Pair tmp = one; tmp != null; tmp = tmp.nextPair()) { System.out.print(tmp.value() + " "); } System.out.println(); מה הפלט? 4 pairs created 3 4 1 תוכנה 1 בשפת Java אוניברסיטת תל אביב

הערות לדוגמה הלקוח (במקרה זה המחלקה TestPairs) יכול לקרוא לשרותים המיוצאים, ואינו יכול לגשת לשדות הפרטיים. הלקוח יכול גם להפעיל את הבנאי כדי ליצור עצמים. קריאה לשרות מחלקה בתחביר <ClassName>.<method>(<parameters>) לדוגמא Pair.howMany( ) קריאה לשרות מופע בתחביר <Target>.<method>(<parameters>) לדוגמא tmp.nextPair( ) כאשר <Target> הוא משתנה (או כל ביטוי) שהוא התייחסות לעצם מהטיפוס המתאים – יעד הקריאה תוכנה 1 בשפת Java אוניברסיטת תל אביב

פניה לעצם המוצבע (dereference) ב tmp.nextPair( ) השתמשנו באופרטור '.' (הנקודה) שאפשר גישה לעצם המוצבע (dereference) כך קוראים לשרות מיוצא של העצם באופן דומה נגשים לשדה מיוצא של העצם <Target>.<field> קריאה לשרות (או גישה לשדה) ללא יעד – כלומר <method>(<parameters>) משמעותה היא התייחסות לעצם הנוכחי, כלומר כאילו נכתב this.<method>(<parameters>) כך גם לגבי גישה לשדה קריאה לשרות (או גישה לשדה) בעצם הנוכחי לא דורשת שהוא יהיה מיוצא תוכנה 1 בשפת Java אוניברסיטת תל אביב

גוף השרות גוף השרות מכיל הצהרות על משתנים מקומיים (variable declaration) ופסוקים ברי ביצוע (כולל return) משתנים מקומיים נקראים גם משתנים זמניים, משתני מחסנית או משתנים אוטומטיים הצהרות יכולות להכיל פסוק איתחול בר ביצוע (ולא רק אתחול ע"י ליטרלים) public void doSomething(String str) { int length = str.length(); ... הגדרת משתנה מקומי צריכה להקדים את השימוש בו תחום הקיום של המשתנה הוא גוף השרות חייבים לאתחל או לשים ערך באופן מפורש במשתנה לפני השימוש בו בניגוד לשדות (מופע או מחלקה) שעבורם יש אתחול לערך ברירת מחדל! תוכנה 1 בשפת Java אוניברסיטת תל אביב

גוף השרות גוף השרות יכול להתייחס למשתנים מקומיים וגם לשדות של המחלקה. שרות מופע רשאי להתייחס הן לשדות מופע (של העצם הנוכחי) והן לשדות מחלקה. שרות מחלקה רשאי להתייחס רק לשדות מחלקה ולא לשדות מופע. מדוע? תוכנה 1 בשפת Java אוניברסיטת תל אביב

יש צורך באתחול מפורש קטע הקוד הבא, לדוגמא, אינו עובר קומפילציה: int i; int one = 1; if (one == 1) i = 0; System.out.println("i=" + i); הקומפיילר צועק ש- i עלול שלא להיות מאותחל לפני השימוש בו תוכנה 1 בשפת Java אוניברסיטת תל אביב

החזרת ערך משרות ומשפט return return <optional-expression>; ביצוע משפט return מחשב את הביטוי (אם הופיע), מסיים את השרות המתבצע כרגע וחוזר לנקודת הקריאה אם המשפט כולל ביטוי ערך מוחזר, ערכו הוא הערך שהקריאה לשרות תחזיר לקורא טיפוס הביטוי צריך להיות תואם לטיפוס הערך המוחזר של השרות אם טיפוס הערך המוחזר מהשרות הוא void , משפט ה- return לא יכלול ביטוי, או שלא יופיע משפט return כלל, והשרות יסתיים כאשר הביצוע יגיע לסופו תוכנה 1 בשפת Java אוניברסיטת תל אביב

דוגמא לשרות המחזיר ערך public int total(int [] arr) { int sum = 0; for (int i : arr) { sum += i; } return sum; אם שרות מחזיר ערך, כל המסלולים האפשריים של אותו שרות (flows) צריכים להחזיר ערך איך נתקן את השרות הבא: public int returnZero() { int one = 1; int two = 2; if (two > one) return 0; תוכנה 1 בשפת Java אוניברסיטת תל אביב

קריאה לשרות (method call) קריאה לשרות (לפעמים מכונה – "זימון מתודה") שאינו מחזיר ערך (טיפוס הערך המוחזר הוא void) תופיע בתור משפט (פקודה), ע"י ציון שמו וסוגריים עם או בלי ארגומנטים קריאה לשרות שמחזיר ערך תופיע בדרך כלל כביטוי (למשל בצד ימין של השמה, כחלק מביטוי גדול יותר, או כארגומנט המועבר בקריאה אחרת לשרות) קריאה לשרות שמחזיר ערך יכולה להופיע בתור משפט, אבל יש בזה טעם רק אם לשרות תוצאי לוואי, כי הערך המוחזר הולך לאיבוד גם אם השרות אינו מקבל ארגומנטים, יש חובה לציין את הסוגריים אחרי שם השרות תוכנה 1 בשפת Java אוניברסיטת תל אביב

סוגי שרות ישנם 3 סוגי שירותים (מתודות, פונקציות, פרוצדורות) שאילתות (queries, accessors) מחזירות ערך ללא שינוי המצב הפנימי כגון: בירור יתרה פקודות (commands, transformers, mutators) מבצעות שינוי במצב הפנימי של העצם כגון: משיכה, הפקדה בנאים (constructors) - טכנית זה אינו שרות! יצירת עצם חדש כגון: יצירת חשבון חדש תוכנה 1 בשפת Java אוניברסיטת תל אביב

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

יצירת עצם הלקוח יוצר עצם ממחלקה C ע"י הביטוי new C (<parameters>) הביטוי יכול להופיע בכל מקום בו מצפים לעצם כזה: בצד ימין של השמה או אתחול, כפרמטר בקריאה, וכו' לחישוב הביטוי שני שלבים: ראשית מוקצה גוש זיכרון שכולל בתוכו את כל שדות המופע של המחלקה, ואתחול לערכי ברירת המחדל על פי הטיפוס של כל שדה (0 , 0.0 , false לטיפוסים פרימיטיביים, null להתייחסויות) השלב השני הוא אופציונלי, אם למחלקה נכתב בנאי. תוכנה 1 בשפת Java אוניברסיטת תל אביב

בנאי כאמור, מחלקה אינה חייבת להגדיר בנאי. אם אין בנאי, כל עצם שנוצר, שדותיו יאותחלו לערכי המחדל בנאי הוא פונקצית אתחול הנקראת ע"י אופרטור ה new מיד אחרי שהוקצה מקום לעצם החדש. התחביר של הגדרת בנאי דומה להגדרת שרות, אבל לא מופיע טיפוס השם הוא כשם המחלקה בין ה <modifiers> לא יכול להיות static <modifiers> <class-name> ( <paramlist> ) { <statements> } תוכנה 1 בשפת Java אוניברסיטת תל אביב

לקוח וספק - שוב הספק והלקוח עשויים להיכתב בזמנים שונים, במקומות שונים וע"י אנשים שונים ואז, כמו בדוגמא, לא יופיעו באותו קובץ (באותה מחלקה) חלק נכבד בתעשיית התוכנה עוסק בכתיבת ספריות – מחלקות המכילות אוסף שרותים שימושיים בנושא מסוים כותב הספרייה נתפס כספק שרותים בתחום (domain) מסוים לדוגמא: Java Collections אוסף של מחלקות למבני נתונים שונים. תוכנה 1 בשפת Java אוניברסיטת תל אביב

המחלקה כספריה של שרותים ניתן לראות במחלקה ספריה של שרותים: אוסף של פונקציות עם מכנה משותף המחלקות ב Java Collections כמו רוב המחלקות ב Java, משמשות כטיפוס נתונים. ואולם קיימות ב- Java גם כמה מחלקות המשמשות כספריות בלבד. אלה מחלקות שיש להן רק שרותי מחלקה. בין השימושיות שבהן: java.lang.Math java.util.Arrays java.lang.System תוכנה 1 בשפת Java אוניברסיטת תל אביב

שם מלא (qualified name) אם אנו רוצים לקרוא לשרות או שדה מתוך שרות של מחלקה אחרת (למשל main), יש להשתמש בשמו המלא של השרות שם מלא כולל את שם המחלקה שבה הוגדר השרות ואחריו נקודה לדוגמא System.out.println("Hello” ); out הוא שדה (מיוצא) במחלקה System תוכנה 1 בשפת Java אוניברסיטת תל אביב

שם מלא (qualified name) במחלקה המגדירה ניתן להשתמש בשם המלא של השרות, או במזהה הפונקציה בלבד (unqualified name) בצורה זו ניתן להגדיר במחלקות שונות פונקציות עם אותו השם (מכיוון שהשם המלא שלהן שונה אין התלבטות – no ambiguity) public class CallingFromAnotherClass { public static void main(String[] args) { MethodCallExamples.printMultipleTimes("Hello", 5); int[] primes = { 2, 3, 5, 7, 11 }; System.out.println("Sum of primes is: " + MethodCallExamples.arraySum(primes)); } בדוגמא הזאת אלו שרותי מחלקה ממש כפי שיכולים להיות לי שני קבצים בשם grades.txt בתיקיות שונות תוכנה 1 בשפת Java אוניברסיטת תל אביב

מה קורה בזמן ריצה? כפי שאמרנו, עצמים הם הישויות הדינמיות בזמן ריצה. נתייחס כרגע לתכנית שאין בה שרותי מחלקה (למעט המתודה main של המחלקה הראשונה). בכל רגע בזמן ריצה קיימים מספר (אולי גדול מאד) של עצמים. אחד מהם הוא "העצם הנוכחי" ומתבצע עליו שרות מסוים. השרות יכול ליצור עצם חדש ממחלקה כלשהי (הפעלת בנאי). השרות יכול לקרוא לשרות אחר (על אותו עצם או על עצם אחר – במקרה זה משתנה העצם הנוכחי). כשהשרות מסתיים, חוזרים לשרות שקרא לו, והעצם שהיה נוכחי. כאשר התכנית מתחילה להתבצע, עדיין אין עצמים, ומתחילה להתבצע המתודה main של המחלקה הראשונה. תוכנה 1 בשפת Java אוניברסיטת תל אביב

העמסת שרותים (method overloading) לשתי פונקציות ב Java יכול להיות אותו שם (מזהה) גם אם הן באותה מחלקה, ובתנאי שהחתימה שלהן שונה כלומר הם שונות בטיפוס ו\או מספר הארגומנטים שלהם לא כולל ערך מוחזר! הגדרת שתי פונקציות באותו שם ובאותה מחלקה נקראת העמסה כבר השתמשנו בפונקציה מועמסת – println עבדה גם כשהעברנו לה משתנה פרימיטיבי וגם כשהעברנו לה מחרוזת נציג שלוש סיבות לשימוש בתכונת ההעמסה נוחות ערכי ברירת מחדל לארגומנטים תאימות אחורה תוכנה 1 בשפת Java אוניברסיטת תל אביב

העמסת פונקציות (שיקולי נוחות) נממש את max המקבלת שני ארגומנטים ומחזירה את הגדול מביניהם ללא שימוש בתכונת ההעמסה (בשפת C למשל) היה צורך להמציא שם נפרד עבור כל אחת מהמתודות: public class MyUtils { public static double max_double(double x, double y) { ... } public static long max_long(long x, long y) } השמות מלאכותיים ולא נוחים תוכנה 1 בשפת Java אוניברסיטת תל אביב

העמסת פונקציות (פחות נוחות) בעזרת מנגנון ההעמסה ניתן להגדיר: public static double max(double x, double y) public static long max(long x, long y) בחלק מהמקרים, אנו משלמים על הנוחות הזו באי בהירות למשל, איזו מהפונקציות תופעל במקרים הבאים: max(1L , 1L); max(1.0 , 1.0); max(1L , 1.0); max(1 , 1); // max(long,long) // max(double,double) // max(double,double) // max(long,long) תוכנה 1 בשפת Java אוניברסיטת תל אביב

העמסה והקומפיילר המהדר מנסה למצוא את הגרסה המתאימה ביותר עבור כל קריאה לפונקציה על פי טיפוסי הארגומנטים של הקריאה אם אין התאמה מדויקת לאף אחת מחתימות השרותים הקיימים, המהדר מנסה המרות (casting) שאינן מאבדות מידע אם לא נמצאת התאמה או שנמצאות שתי התאמות "באותה רמת סבירות" או שפרמטרים שונים מתאימים לפונקציות שונות המהדר מודיע על אי בהירות (ambiguity) תוכנה 1 בשפת Java אוניברסיטת תל אביב

העמסה וערכי ברירת מחדל לארגומנטים נתאר מצב שבו פונקציה המקבלת מספר ארגומנטים, מרבה לקבל את אותם ערכים עבור חלק מהארגומנטים כדי לחסוך ממי שקורא לפונקציה את הצורך לציין את כל הארגומנטים (אולי הם רבים, אולי ערכיהם איזוטרים), נעמיס גרסה שבה יש לציין רק את הארגומנטים "החשובים באמת" תוכנה 1 בשפת Java אוניברסיטת תל אביב

העמסה וערכי ברירת מחדל לארגומנטים לדוגמא: פונקציה לביצוע ניסוי פיזיקלי מורכב: public static void doExperiment(double altitude, double presure, double volume, double mass){ ... } אם ברוב הניסויים המתבצעים הגובה, הלחץ והנפח אינם משתנים, יהיה זה מסורבל לציין אותם בכל קריאה לפונקציה לשם כך, נגדיר עוד גרסה יותר קומפקטית המקבלת כארגומנט רק את המסה: public static void doExperiment(double mass){ תוכנה 1 בשפת Java אוניברסיטת תל אביב

העמסה ותאימות לאחור נניח כי כתבת את הפונקציה השימושית : public static int compute(int x) המבצעת חישוב כלשהו על הארגומנט x לאחר זמן מה, כאשר הקוד כבר בשימוש במערכת (גם מתוך מחלקות אחרות שלא אתה כתבת), עלה הצורך לבצע חישוב זה גם בבסיסי ספירה אחרים (החישוב המקורי בוצע בבסיס עשרוני) בשלב זה לא ניתן להחליף את חתימת הפונקציה להיות: public static int compute(int x, int base) מכיוון שקטעי הקוד המשתמשים בפונקציה יפסיקו להתקמפל תוכנה 1 בשפת Java אוניברסיטת תל אביב

העמסה, תאימות לאחור ושכפול קוד על כן במקום להחליף את חתימת השרות נוסיף פונקציה חדשה כגירסה מועמסת משתמשי הפונקציה המקורית לא נפגעים משתמשים חדשים יכולים לבחור האם לקרוא לפונקציה המקורית או לגרסה החדשה ע"י העברת מספר ארגומנטים מתאים בעיה – קיים דמיון רב בין המימושים של הגרסאות המועמסות השונות (גוף המתודות compute) דמיון רב מדי - שכפול קוד זה הינו בעייתי מכמה סיבות שנציין מיד תוכנה 1 בשפת Java אוניברסיטת תל אביב

הנורא ביותר בעולם (התוכנה) ! שכפול קוד הוא הדבר הנורא ביותר בעולם (התוכנה) ! תוכנה 1 בשפת Java אוניברסיטת תל אביב

העמסה, שכפול קוד ועקביות חסרונות שכפול קוד: קוד שמופיע פעמיים, יש לתחזק פעמיים – כל שינוי, שדרוג או תיקון עתידי יש לבצע בצורה עקבית בכל המקומות שבהם מופיע אותו קטע הקוד כדי לשמור על עקביות שתי הגרסאות של compute נממש את הגרסה הישנה בעזרת הגרסה החדשה: public static int compute(int x, int base){ // complex calcultion... } public static int compute(int x){ return compute(x, 10); תוכנה 1 בשפת Java אוניברסיטת תל אביב

העמסת מספר כלשהו של ארגומנטים ב Java5 התווסף תחביר להגדרת שרות עם מספר לא ידוע של ארגומנטים (vararg) נניח שברצוננו לכתוב פונקציה שמחזירה את ממוצע הארגומנטים שקיבלה: public static double average(double x){ return x; } public static double average(double x1, double x2){ return (x1 + x2) / 2; public static double average(double x1, double x2, double x3){ return (x1 + x2 + x3) / 3; למימוש 2 חסרונות: שכפול קוד לא תומך בממוצע של 4 ארגומנטים תוכנה 1 בשפת Java אוניברסיטת תל אביב

העמסת מספר כלשהו של ארגומנטים רעיון: הארגומנטים יועברו כמערך public static double average(double [] args) { double sum = 0.0; for (double d : args) { sum += d; } return sum / args.length; יתרון: שכפול הקוד נפתר חסרון: הכבדה על הלקוח - כדי לקרוא לפונקציה יש ליצור מערך public static void main(String[] args) { double [] arr = {1.0, 2.0, 3.0}; System.out.println("Average is:" + average(arr)); תוכנה 1 בשפת Java אוניברסיטת תל אביב

ג'אווה באה לעזרה תחביר מיוחד של שלוש נקודות (...) יוצר את המערך מאחורי הקלעים: public static double average(double ... args) { double sum = 0.0; for (double d : args) { sum += d; } return sum / args.length; ניתן כעת להעביר לשרות מערך או ארגומנטים בודדים: double [] arr = {1.0, 2.0, 3.0}; System.out.println("Average is:" + average(arr)); System.out.println("Average is:" + average(1.0, 2.0, 3.0)); הדוגמאות להעמסה היו שרותי מחלקה, אבל זה רלבנטי גם לשרותי מופע ובנאים תוכנה 1 בשפת Java אוניברסיטת תל אביב

שדות מחלקה לעומת משתנים מקומיים שדות מחלקה שונים ממשתנים מקומיים בכמה מאפיינים: תחום הכרות: מוכרים בכל הקוד (ולא רק מתוך פונקציה מסוימת) משך קיום: אותו עותק של משתנה נוצר בזמן טעינת הקוד לזיכרון ונשאר קיים בזיכרון התוכנית כל עוד המחלקה בשימוש אתחול: משתנים גלובליים מאותחלים בעת יצירתם. אם המתכנת לא הגדיר להם ערך אתחול - יאותחלו לערך ברירת המחדל לפי טיפוסם (0, false, null) הקצאת זיכרון: הזיכרון המוקצה להם נמצא באזור ה Heap (ולא באזור ה- Stack). שדות מחלקה נקראים גם משתנים גלובליים (global variables), אברי מחלקה (class members), משתני מחלקה (class fields), מאפייני מחלקה (class properties/attributes), שדות סטטיים (static fields/members) דוגמת שימוש שראינו: כמה עצמים מהמחלקה נוצרו? תוכנה 1 בשפת Java אוניברסיטת תל אביב

זה סופי ניתן לקבע ערך של משתנה ע"י ציון המשתנה כ final דוגמא: public final static long uniqueID = ++counter; מוסכמה מקובלת היא שמות משתנים המציינים קבועים ב- UPPERCASE כגון: public final static double FOOT = 0.3048; public final static double PI = 3.1415926535897932384; תוכנה 1 בשפת Java אוניברסיטת תל אביב

טיפוסים בשפת Java בג'אווה יש שתי משפחות של טיפוסים, ובהתאם לכך שני סוגי משתנים: הטיפוסים היסודיים – 8 טיפוסים שהם חלק משפת התכנות byte, short, int, long float, double,char, boolean טיפוסי הפנייה – למערכים ומחלקות קשירת טיפוסים חזקה (strong typing) תוכנה 1 בשפת Java אוניברסיטת תל אביב 57

משפטים וביטויים משפט (statement) מבצע פעולה כגון: משפט השמה, משפט תנאי, משפט לולאה, קריאה לפונקציה שאינה מחזירה ערך (void) ביטוי (expression) הוא מבנה תחבירי שניתן לחשב את ערכו כגון: הפעלת אופרטור, קריאה לפונקציה המחזירה ערך, משפט השמה פונקציות ב-Java (מתודות) הן סדרה של משפטים משפט מבצע פעולה על ביטויים (expression) ההפרדה אינה מלאה - ישנם משפטים אשר ניתן לחשב את ערכם (כגון משפט השמה, או אופרטור הקידום) תוכנה 1 בשפת Java אוניברסיטת תל אביב

משתנים שאינם יסודיים (non primitive variables) פרט ל-8 הטיפוסים שסקרנו עד כה, כל שאר הטיפוסים ב Java אינם פרימיטיבים הספריה התקנית של Java מכילה יותר מ- 3000 טיפוסים (!) ואנו כמתכנתים נשתמש בהם ואף ניצור טיפוסים חדשים מערכים ומחרוזות אינם טיפוסים יסודיים משתנה מטיפוס שאינו יסודי נקרא הפנייה (reference type) לעיתים נשתמש בכינויים שקולים כגון: התייחסות, מצביע, מחוון, פוינטר בשפות אחרות (למשל C++) יש הבדל בין המונחים השונים, אולם ב Java כולם מתייחסים למשתנה שאינו יסודי תוכנה 1 בשפת Java אוניברסיטת תל אביב

שיתוף (sharing, aliasing) אם שתי הפניות מצביעות לאותו עצם, העצם הוא משותף לשתיהן. אין עותק נפרד לכל הפנייה כל אחת מההפניות יכולה לשנות את העצם המשותף המוצבע בצורה בלתי תלויה int [] arr1 = {1,2,3}; int [] arr2 = arr1; arr2[0] = 10; System.out.println(arr1[0]); 10 1 arr1 2 100,014 350,000 3 350,000 arr2 // מה יודפס ? 100,018 350,000 תוכנה 1 בשפת Java אוניברסיטת תל אביב

הפרוטקציה של מערכים ומחרוזות מכיוון שמחרוזות ומערכים הם טיפוסים מאוד שכיחים ושימושיים בשפה, הם קיבלו "יחס מועדף", שתי תכונות שאין לאף טיפוס אחר בשפה: פטור מ- new לא ניתן ב Java לייצר עצם ללא שימוש מפורש באופרטור new אבל ניתן ליצור עצם מחרוזת ע"י שימוש בסימן המרכאות ("hello"), ניתן ליצור עצם מערך ע"י שימוש במסולסליים ({1,2,3}) הפניות ואופרטורים על משתנה מטיפוס הפניה אפשר לבצע רק השמה (אופרטור '='), השוואה (אופרטור '==') או גישה לעצם (אופרטור '.') על מערך ניתן גם לבצע גישה לאיבר ([ ]), על מחרוזת ניתן לבצע גם שרשור (+) תוכנה 1 בשפת Java אוניברסיטת תל אביב