‫אבני היסוד של תוכנית ב‪JAVA -‬‬
‫קרן כליף‬
?‫למה חשוב ללמוד מחשבים‬
http://i728.photobucket.com/albums/ww282/vistamike_bucket/mouse-3.jpg
2
© Keren Kalif
‫תיאום ציפיות‬
http://www.1stwebdesigner.com/wp-content/uploads/2011/10/tan_lines_of_a_programmer2.jpg
3
© Keren Kalif
‫ביחידה זו נלמד‪:‬‬
‫‪ ‬בסיסי מספרים‪:‬‬
‫‪ ‬בינארי (‪ ,)2‬אוקטאלי (‪ ,)8‬הקסה‪-‬דצימאלי (‪)16‬‬
‫‪ ‬הדפסה למסך‬
‫‪ ‬קבלת נתונים מהמשתמש‬
‫‪ ‬קבועים‬
‫‪ ‬מבנה זיכרון התוכנית‬
‫‪ ‬הגדרת משתנים‬
‫‪ ‬טיפוסי משתנים‬
‫‪ ‬השמת ערך למשתנים‬
‫‪ ‬קימפול והרצת תוכניות בקונסול‬
‫‪ ‬הצגת נתונים בחלון‬
‫‪4‬‬
‫‪© Keren Kalif‬‬
‫בסיס עשרוני (דצימלי)‬
‫‪ ‬בסיס הינו שיטת ספירה‬
‫‪ ‬בבסיס בייצוג עשרוני (השיטה הטבעית לנו) קיימות ‪ 10‬ספרות‪ 0 :‬עד ‪9‬‬
‫‪ ‬לכן אנו אומרים שהן מיוצגות בבסיס ‪10‬‬
‫‪ ‬נקרא גם בסיס דצימלי‬
‫‪ ‬כל מספר שלם ניתן לייצג כסכום של ערכים בחזקות של ‪10‬‬
‫‪ ‬דוגמא‪:‬‬
‫‪2857= 2*103 + 8* 102 + 5*101 + 7* 100‬‬
‫‪5‬‬
‫‪© Keren Kalif‬‬
‫ייצוג מספרים בבסיס בינארי ‪ -‬הגדרות‬
‫‪ ‬בבסיס הבינארי קיימות ‪ 2‬ספרות בלבד‪ :‬הספרות ‪ 0‬ו‪1-‬‬
‫‪ ‬לכן גם נקרא בסיס ‪2‬‬
‫‪ ‬דוגמאות למספרים בבסיס בינארי‪1110010 ,1010 :‬‬
‫‪ ‬נמספר את מיקום הספרות מימין לשמאל‬
‫‪ ‬מספר הספרה הימנית ביותר יהיה ‪0‬‬
‫‪ ‬מספר הספרה השמאלית ביותר במספר בן ‪ n‬ספרות יהיה ‪n-1‬‬
‫‪5 4 3 2 1 0‬‬
‫דוגמא‪101011 :‬‬
‫‪ ‬הספרות במיקום ‪ 0,1,3,5‬הן ‪ 1‬והספרות במיקום ‪ 2,4‬הן ‪0‬‬
‫‪6‬‬
‫‪© Keren Kalif‬‬
‫ייצוג מספרים בבסיס בינארי – חישוב ערך עשרוני‬
‫של מספר בינארי (מבסיס ‪ 2‬ל‪)10 -‬‬
‫‪ ‬ערכו של מספר המיוצג בבסיס עשרוני הוא סכום חזקות של ‪:10‬‬
‫‪102 101 100‬‬
‫‪1 7 3 = 1*102 + 7*101 + 3*100 = 173‬‬
‫‪ ‬הספרה ‪ d‬במיקום ה‪ k-‬מוסיפה לסכום‪( d*10k :‬כלומר אם ערכה של‬
‫ספרה הוא ‪ 0‬היא אינה תורמת לסכום)‬
‫‪ ‬ובדומה‪ ,‬ערכו של מספר המיוצג בבסיס בינארי הינו סכום של חזקות‬
‫של ‪( 2‬הספרה ‪ d‬במיקום ה‪ k-‬מוסיפה לסכום ‪)d*2k‬‬
‫‪ ‬דוגמא‪:‬‬
‫הביט הכי שמאלי נקרא ‪ MSB‬משום שהוא הכי משמעותי לסכום‬
‫‪24 23 22 2 1 20‬‬
‫‪11001 = 1*24 + 1*23 + 0*22 + 0*21 + 1*20 =25‬‬
‫הביט הכי ימני נקרא ‪ LSB‬משום שהוא הכי פחות משמעותי לסכום‬
‫‪7‬‬
‫‪© Keren Kalif‬‬
‫ייצוג מספרים בבסיס בינארי – חישוב ערך בינארי‬
‫של מספר עשרוני (מבסיס ‪ 10‬ל‪)2 -‬‬
‫‪ ‬ראינו כיצד בהינתן מספר בייצוג בינארי ניתן להמירו לייצוגו‬
‫העשרוני‬
‫‪ ‬כעת נראה כיצד בהינתן מספר בייצוג עשרוני ניתן להמירו לייצוגו‬
‫הבינרי (כפי שהמחשב מכיר)‬
‫‪ ‬כל עוד המספר אינו ‪ 0‬נחלקו ב‪ 2 -‬ואת השארית נשרשר לתוצאה‬
‫משמאל‪:‬‬
‫‪ ‬דוגמא עבור ‪:23‬‬
‫‪1 0 1 1 1‬‬
‫בקרה‪:‬‬
‫‪24 23 22 21 20‬‬
‫=‪1 0 1 1 1‬‬
‫‪1*24 + 0*23 + 1*22 + 1*21 + 1*20 =23‬‬
‫‪8‬‬
‫‪© Keren Kalif‬‬
‫)‪23/2 = 11 (1‬‬
‫)‪11/2 = 5 (1‬‬
‫)‪5/2 = 2 (1‬‬
‫)‪2/2 = 1 (0‬‬
‫)‪1/2 = 0 (1‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫ייצוג מספרים בבסיס בינארי – חישוב ערך בינארי‬
‫של מספר עשרוני (‪)2‬‬
‫‪ ‬דוגמא עבור ‪:26‬‬
‫‪1 1 0 1 0‬‬
‫בקרה‪:‬‬
‫‪24 23 22 21 20‬‬
‫=‪1 1 0 1 0‬‬
‫‪1*24 + 1*23 + 0*22 + 1*21 + 0*20 =26‬‬
‫‪9‬‬
‫‪© Keren Kalif‬‬
‫)‪26/2 = 13 (0‬‬
‫)‪13/2 = 6 (1‬‬
‫)‪6/2 = 3 (0‬‬
‫)‪3/2 = 1 (1‬‬
‫)‪1/2 = 0 (1‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫טווח המספרים שניתן לייצג ע"י ספרות בינאריות –‬
‫מספרים חיוביים‬
‫‪ ‬ע"י מספר עשרוני בעל ‪ 3‬ספרות ניתן לייצג ‪ )103=( 1000‬מספרים‬
‫שונים (‪)999...0‬‬
‫‪ ‬ובאופן כללי‪ ,‬מספר עשרוני בעל ‪ k‬ספרות יכול לייצג ‪ 10k‬מספרים‬
‫שונים (‪)10k-1...0‬‬
‫‪ ‬ובדומה‪ ,‬ע"י מספר בינארי בעל ‪ k‬ספרות ניתן לייצג ‪ 2k‬מספרים שונים‬
‫)‪(2k-1…0‬‬
‫למשל עבור ‪:k=3‬‬
‫‪ 000 = 0*22 + 0*21 + 0*20 = 0‬‬
‫‪= 0*22 + 0*21 + 1*20 = 1‬‬
‫‪= 0*22 + 1*21 + 0*20 = 2‬‬
‫‪= 0*22 + 1*21 + 1*20 = 3‬‬
‫‪= 1*22 + 0*21 + 0*20 = 4‬‬
‫‪= 1*22 + 0*21 + 1*20 = 5‬‬
‫‪= 1*22 + 1*21 + 0*20 = 6‬‬
‫‪= 1*22 + 1*21 + 1*20 = 7‬‬
‫‪10‬‬
‫‪© Keren Kalif‬‬
‫‪001‬‬
‫‪010‬‬
‫‪011‬‬
‫‪100‬‬
‫‪101‬‬
‫‪110‬‬
‫‪111‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫‪‬‬
‫טווח המספרים שניתן לייצג ע"י ספרות בינאריות –‬
‫מספרים שליליים‬
‫‪ ‬ניתן לייצג ‪ 2k‬מספרים ע"י ‪ K‬ספרות בינאריות‬
‫‪ ‬בייצוג מספרים שלמים חיוביים ייוצגו המספרים ‪0…2k-1‬‬
‫‪ ‬בייצוג מספרים שלמים חיוביים ושליליים ייוצגו המספרים‬
‫‪-2k-1….2k-1-1‬‬
‫‪ ‬למשל עבור ‪:k=3‬‬
‫סה"כ ‪ (23) 8‬מספרים‬
‫‪11‬‬
‫‪© Keren Kalif‬‬
‫‪-23-1…23-1-1‬‬
‫‪-22…22-1‬‬
‫‪-4…3‬‬
‫טווח המספרים שניתן לייצג ע"י ספרות בינאריות –‬
‫מספרים שליליים‬
‫‪ ‬מאחר והמחשב מכיר רק ‪ 0‬ו‪ ,1-‬ואינו מכיר את הסימן ‪ ,-‬צריך‬
‫אינדיקציה לכך שהמספר שלילי‪ .‬אינדיקציה זו היא שהספרה הכי‬
‫שמאלית תהייה תמיד ‪ ,1‬ואז נותרו לנו ‪ k-1‬ספרות לייצוג המספר‬
‫‪ ‬דוגמא‪ :‬עבור ייצוג מספר עם ‪ 4‬סיביות‪:‬‬
‫‪‬‬
‫‪‬‬
‫‪12‬‬
‫‪© Keren Kalif‬‬
‫‪ 3‬בבינארית זה ‪0011‬‬
‫‪ -3‬בבינארית זה ‪1101‬‬
‫יצוג מספר שלילי בבינארי‬
‫‪ ‬נשתמש בשיטת המשלים ל‪:2-‬‬
‫‪ ‬נמצא את יצוגו הבינארי של המספר החיובי‬
‫‪ ‬נוסיף ‪ 0‬מוביל משמאלו‬
‫‪ ‬נהפוך כל סיבית (‪ 0‬ל‪ ,1 -‬ו‪ 1 -‬ל‪)0 -‬‬
‫‪ ‬נוסיף ‪ 1‬לתוצאה‬
‫‪ ‬לבסוף נוסיף את הסיבית ‪ 1‬משמאל למספר‬
‫‪‬‬
‫דוגמא‪ :‬המספר ‪-7‬‬
‫‪ 7 ‬בבינארי ‪ 0 +‬מוביל ‪:‬‬
‫‪ ‬לאחר הפיכת הסיביות‪:‬‬
‫‪ ‬הוספת ‪ 1‬לתוצאה‪:‬‬
‫‪ ‬הוספת הסיבית ‪ 1‬משמאל למספר‪:‬‬
‫‪13‬‬
‫‪© Keren Kalif‬‬
‫‪0111‬‬
‫‪1000‬‬
‫‪+‬‬
‫‪1‬‬
‫‪11001‬‬
‫סיכום בסיס בינארי‬
http://rlv.zcache.com/binary_joke_stickerr52fa63b95dac463787549589a29f5366_v9waf_8byvr_324.jpg
14
© Keren Kalif
‫ייצוג מספרים בבסיס ‪ - 8‬הגדרות‬
‫‪ ‬בבסיס ‪( 8‬אוקטאלי) משתמשים ב‪ 8 -‬ספרות כדי לספור‪:‬‬
‫הספרות ‪0-7‬‬
‫‪‬‬
‫דוגמאות למספרים בבסיס ‪7502 ,25361 :8‬‬
‫‪ ‬נמספר את מיקום הספרות מימין לשמאל‬
‫‪ ‬מספר הספרה הימנית ביותר יהיה ‪0‬‬
‫‪ ‬מספר הספרה השמאלית ביותר במספר בן ‪ n‬ספרות יהיה‬
‫‪n-1‬‬
‫‪5 4 3 2 1 0‬‬
‫דוגמא‪401621 :‬‬
‫‪15‬‬
‫‪© Keren Kalif‬‬
‫ייצוג מספרים בבסיס ‪ – 8‬חישוב ערך עשרוני של‬
‫מספר אוקטאלי (מ‪ 8 -‬ל‪)10 -‬‬
‫‪ ‬ראינו כי ערכו של מספר המיוצג בבסיס עשרוני הוא סכום חזקות של‬
‫‪10 10 10‬‬
‫‪:10‬‬
‫‪1 7 3 = 1*102 + 7*101 + 3*100 = 173‬‬
‫‪ ‬הספרה ‪ d‬במיקום ה‪ k-‬מוסיפה לסכום‪( d*10k :‬כלומר אם ‪d=0‬‬
‫הספרה לא תורמת לסכום)‬
‫‪ ‬ובדומה‪ ,‬ערכו של מספר המיוצג בבסיס ‪ 8‬הינו סכום של חזקות של ‪8‬‬
‫(הספרה ‪ d‬במיקום ה‪ k-‬מוסיפה לסכום ‪)d*8k‬‬
‫‪8 8 8 8‬‬
‫‪ ‬דוגמא‪:‬‬
‫‪0‬‬
‫‪0‬‬
‫‪1‬‬
‫‪1‬‬
‫‪2‬‬
‫‪2‬‬
‫‪3‬‬
‫‪4 2 5 6 = 4*83 + 2*82 + 5*81 + 6*80 =2222‬‬
‫‪16‬‬
‫‪© Keren Kalif‬‬
‫ייצוג מספרים בבסיס ‪ – 8‬חישוב ערך אוקטאלי של‬
‫מספר עשרוני (מ‪ 10 -‬ל‪)8 -‬‬
‫‪ ‬ראינו כיצד בהינתן מספר בייצוג אוקטאלי ניתן להמירו לייצוגו‬
‫העשרוני‬
‫‪ ‬כעת נראה כיצד בהינתן מספר בייצוג עשרוני ניתן להמירו לייצוגו‬
‫בבסיס האוקטלי‬
‫‪ ‬כל עוד המספר אינו ‪ 0‬נחלקו ב‪ 8 -‬ואת השארית נשרשר לתוצאה‬
‫משמאל‪:‬‬
‫‪ ‬דוגמא עבור ‪:123‬‬
‫‪7 3‬‬
‫‪1‬‬
‫)‪123/8 = 15 (3‬‬
‫)‪ 15/8 = 1 (7‬‬
‫‪‬‬
‫)‪1/8 = 0 (1‬‬
‫‪‬‬
‫בקרה‪:‬‬
‫‪82 81 80‬‬
‫‪1 7 3 = 1*82 + 7*81 + 3*80= 123‬‬
‫‪17‬‬
‫‪© Keren Kalif‬‬
‫ייצוג מספרים בבסיס ‪ - 16‬הגדרות‬
‫‪ ‬בבסיס ‪( 16‬הקסה‪-‬דצימלי) משתמשים ב‪ 16 -‬תווים כדי לספור‪:‬‬
‫הספרות ‪ 0-9‬והאותיות ‪F-A‬‬
‫‪‬‬
‫דוגמאות למספרים בבסיס ‪ABCDEF ,2510DE1 :16‬‬
‫‪ ‬נמספר את מיקום הספרות מימין לשמאל‬
‫‪ ‬מספר הספרה הימנית ביותר יהיה ‪0‬‬
‫‪ ‬מספר הספרה השמאלית ביותר במספר בן ‪ n‬ספרות יהיה‬
‫‪n-1‬‬
‫‪5 4 3 2 1 0‬‬
‫דוגמא‪4F19B1 :‬‬
‫‪18‬‬
‫‪© Keren Kalif‬‬
‫ייצוג מספרים בבסיס ‪ – 16‬חישוב ערך עשרוני של‬
‫מספר הקסה‪-‬דצימאלי (מ‪ 16 -‬ל‪)10 -‬‬
‫‪ ‬ראינו כי‪ ,‬ערכו של מספר המיוצג בבסיס עשרוני הוא סכום חזקות של‬
‫‪10 10 10‬‬
‫‪:10‬‬
‫‪1 7 3 = 1*102 + 7*101 + 3*100 = 173‬‬
‫‪ ‬הספרה ‪ d‬במיקום ה‪ k-‬מוסיפה לסכום‪( d*10k :‬כלומר אם ‪d=0‬‬
‫הספרה לא תורמת לסכום)‬
‫‪ ‬ובדומה‪ ,‬ערכו של מספר המיוצג בבסיס ‪ 16‬הינו סכום של חזקות של‬
‫‪( 16‬הספרה ‪ d‬במיקום ה‪ k-‬מוסיפה לסכום ‪)d*16k‬‬
‫‪16 16 16 16‬‬
‫‪ ‬דוגמא‪:‬‬
‫‪0‬‬
‫‪0‬‬
‫‪1‬‬
‫‪1‬‬
‫‪2‬‬
‫‪2‬‬
‫‪3‬‬
‫‪4 D 5 E = 4*163 + 13*162 + 5*161 + 14*160 =19806‬‬
‫‪19‬‬
‫‪© Keren Kalif‬‬
‫ייצוג מספרים בבסיס ‪ – 16‬חישוב ערך הקסה‪-‬‬
‫דצימאלי של מספר עשרוני (מ‪ 10 -‬ל‪)16 -‬‬
‫‪ ‬ראינו כיצד בהינתן מספר בייצוג הקסה‪-‬דצימאלי ניתן להמירו‬
‫לייצוגו העשרוני‬
‫‪ ‬כעת נראה כיצד בהינתן מספר בייצוג עשרוני ניתן להמירו לייצוגו‬
‫בבסיס הקסה‪-‬דצימאלי‬
‫‪ ‬כל עוד המספר אינו ‪ 0‬נחלקו ב‪ 16 -‬ואת השארית נשרשר‬
‫לתוצאה משמאל‪:‬‬
‫‪ ‬דוגמא עבור ‪:123‬‬
‫‪7 B‬‬
‫)‪123/16 = 7 (11‬‬
‫)‪ 7/16 = 0 (7‬‬
‫‪‬‬
‫בקרה‪:‬‬
‫‪161 160‬‬
‫‪7 B = 7*161 + 11*160 = 123‬‬
‫‪20‬‬
‫‪© Keren Kalif‬‬
7DA = 2010
http://bokov.net/pics/img/programmer_calendar.png
‫לוח שנה של מתכנתים‬
21
© Keren Kalif
‫ובאופן כללי‪ :‬מעבר מבסיס ‪ N‬לבסיס ‪10‬‬
‫‪ ‬מעבר מבסיס ‪( 2‬בינארי) לבסיס ‪( 10‬עשרוני)‪:‬‬
‫‪11012 = 1*23 + 1*22 + 0*21 + 1*20 = 1310‬‬
‫‪ ‬מעבר מבסיס ‪( 8‬אוקטאלי) לבסיס ‪( 10‬עשרוני)‪:‬‬
‫‪2538=2*82 + 5*81 + 3*80 = 17110‬‬
‫‪ ‬מעבר מבסיס ‪( 16‬הקסה‪-‬דצימלי) לבסיס ‪(10‬עשרוני)‪:‬‬
‫‪1FA16 = 1*162 + 15*161 + 10*160 = 50610‬‬
‫‪22‬‬
‫‪© Keren Kalif‬‬
‫ובאופן כללי‪ :‬מעבר מבסיס ‪ 10‬לבסיס‬
‫‪N‬‬
‫יהיה ‪ X‬מספר עשרוני‪.‬‬
‫יהיה ‪ n‬הבסיס אליו רוצים להעביר את ‪.X‬‬
‫‪.1‬‬
‫כל עוד ‪ X‬אינו ‪:0‬‬
‫‪(a‬‬
‫‪23‬‬
‫‪© Keren Kalif‬‬
‫חלק את ‪ X‬ב ‪ n‬ושרשר את השארית משמאל לתוצאה‬
‫המרה מבסיס ‪ 2‬ל‪16 -‬‬
‫‪‬‬
‫‪‬‬
‫כל ‪ 4‬סיביות (מה‪ LSB -‬ל‪ )MSB -‬ייצגו ספרה בבסיס ‪:16‬‬
‫למשל‪ ,‬עבור‪0 1 1 0 1 0 1 1 0 1 0 :‬‬
‫‪A‬‬
‫‪‬‬
‫‪5‬‬
‫‪3‬‬
‫בקרה‪011010110102 = 85810 :‬‬
‫‪35A16 = 85810‬‬
‫המעבר מבסיס ‪ 2‬ל‪ 8 -‬זהה‪ ,‬רק כל ‪ 3‬סיביות ייצגו ספרה‬
‫‪24‬‬
‫‪© Keren Kalif‬‬
‫המרה מבסיס ‪ 16‬ל‪2 -‬‬
‫‪‬‬
‫כל ספרה תיוצג ע"י ‪ 4‬סיביות‪:‬‬
‫‪3‬‬
‫‪5‬‬
‫‪A‬‬
‫למשל‪ ,‬עבור‪:‬‬
‫‪0011 0101 1010‬‬
‫‪‬‬
‫בקרה‪011010110102 = 85810 :‬‬
‫‪‬‬
‫‪35A16 = 85810‬‬
‫המעבר מבסיס ‪ 8‬ל‪ 2 -‬זהה‪ ,‬רק כל ספרה תיוצג ע"י ‪ 3‬סיביות‬
‫‪25‬‬
‫‪© Keren Kalif‬‬
‫השוואה בין ערכים בבסיסים שונים‬
‫‪‬‬
‫‪30E16 = 78210 = 14168 = 11000011102‬‬
‫‪‬‬
‫ניתן לראות שככל שיש יותר ספרות בבסיס‪ ,‬כך צריך פחות‬
‫ספרות על‪-‬מנת לייצג ערך של מספר מסויים‬
‫‪ ‬הסיבה היא כי כל מיקום תורם יותר לסכום‬
‫‪26‬‬
‫‪© Keren Kalif‬‬
‫כתיבת תוכנית ראשונה בשפת ‪JAVA‬‬
‫‪ ‬כל תוכנית ב‪ java -‬תראה כך‪:‬‬
‫‪ Program‬היא מחלקה אשר מכילה‬
‫את פונקציית ה‪ main -‬להרצה‬
‫במקום ‪ 3‬נקודות נשים‬
‫את אוסף הפקודות שנרצה‬
‫שהתוכנית תבצע‬
‫‪ main ‬היא פונקציה המורצת עם הרצת התוכנית‬
‫‪ ‬בכל תוכנית תהייה פונקצית ‪ main‬אחת בדיוק‬
‫‪27‬‬
‫‪© Keren Kalif‬‬
‫הדפסה למסך‬
‫‪ ‬אחת הפקודות שהמחשב מכיר היא הדפסה למסך‬
‫הרצה של התוכנית הזו תדפיס‬
‫למסך את המחרוזת‬
‫!‪Hello World‬‬
‫‪28‬‬
‫‪© Keren Kalif‬‬
‫קבלת קלט מהמשתמש‬
‫‪ ‬היינו רוצים שהתוכנית שלנו תהייה אינטראקטיבית ותדע גם לקלוט‬
‫נתונים מהמשתמש‬
‫‪ ‬לשם כך עלינו ללמוד את הדברים הבאים‪:‬‬
‫‪ ‬כיצד מקבלים מידע מהמשתמש‬
‫‪ ‬היכן מאחסנים מידע זה‬
‫‪ ‬כיצד מדפיסים מידע זה‬
‫‪29‬‬
‫‪© Keren Kalif‬‬
‫קבלת קלט מהמשתמש (‪)2‬‬
‫‪ ‬פקודה נוספת שהמחשב מכיר היא קריאת נתון מהשתמש‬
‫יבוא ספריה המכילה את הטיפוס ‪Scanner‬‬
‫;‪import java.util.Scanner‬‬
‫{ ‪public class Program‬‬
‫{ )‪public static void main(String[] args‬‬
‫;)‪Scanner s = new Scanner(System.in‬‬
‫;)(‪int num = s.nextInt‬‬
‫;)‪System.out.println("Your number is " + num‬‬
‫‪ ‬מה זה ‪?Scanner‬‬
‫‪ ‬אובייקט שתפקידו לקלוט נתונים מהמקלדת‬
‫‪ ‬יש לו פעולה ‪ nextInt‬אשר יודעת לקלוט מספר שלם‬
‫‪ ‬מה זה ‪?num‬‬
‫‪ num ‬הוא השם של המקום שבו נאכסן את הערך המתקבל מהמשתמש‬
‫‪ ‬כדי להקצות עבורנו מקום זה עלינו להגדיר משתנה‬
‫‪ ‬מה זה ‪ ?int‬בקשת הקצאת המקום‪ ,‬נראה פירוט בהמשך‬
‫‪30‬‬
‫‪© Keren Kalif‬‬
‫}‬
‫}‬
‫אחסון ערכים‬
‫‪ ‬כאשר מריצים תוכנית נרצה לשמור ערכים מסוימים כדי שישמשו‬
‫אותנו בפקודות בהמשך‬
‫‪ ‬כאשר התוכנית רצה‪ ,‬היא מקבלת שטח בזיכרון בו היא יכולה לאחסן‬
‫ערכים אלו‪ .‬שטח זה נקרא מחסנית (‪)stack‬‬
‫‪ ‬המחסנית מורכבת מתאים‪ ,‬ולכל תא יש כתובת‬
‫‪ ‬כל תא נקרא ‪( byte‬בייט)‬
‫‪ ‬יש משתנים שערכם מאוחסן בבייט אחד‪ ,‬ויש‬
‫‪1000‬‬
‫משתנים שערכם מאוחסן ביותר (נראה בהמשך)‬
‫‪1001‬‬
‫‪1002‬‬
‫‪1003‬‬
‫‪1004‬‬
‫‪31‬‬
‫‪© Keren Kalif‬‬
‫‪1005‬‬
‫אחסון ערכים (‪)2‬‬
‫‪1000‬‬
‫‪1004‬‬
‫‪1008‬‬
‫‪1012‬‬
‫‪1016‬‬
‫‪1020‬‬
‫‪4‬‬
‫‪int:x‬‬
‫{ )‪public static void main(String[] args‬‬
‫;‪int x‬‬
‫;)‪Scanner s = new Scanner(System.in‬‬
‫;)(‪x = s.nextInt‬‬
‫}‬
‫‪ ‬בתוכנית זו הגדרנו את המשתנה ‪ ,x‬ולכן התוכנית מקצה תא במחסנית‬
‫למשתנה זה‬
‫‪ ‬כאשר המשתמש יקליד מספר‪ ,‬המספר יכנס לתוך התא המוקצה עבור‬
‫‪x‬‬
‫‪32‬‬
‫‪© Keren Kalif‬‬
‫הדפסת ערכו של משתנה‬
public static void main(String[] args) {
Scanner s = new Scanner(System.in);
int x;
int:x
4
1000
1004
1008
System.out.println(“Please enter a number: “);
4 ‫לאחר הקלדת‬
x = s.nextInt();
System.out.println(“The number is ” + x);
}
1012
1016
1020
‫ פקודת ההדפסה מדפיסה את התוכן של התא המוקצה עבור‬
The number is 4 ‫ ולכן יודפס למסך‬x ‫המשתנה‬
‫ כדי שהתוכנית שלנו תהייה ידידותית נציג הודעה מתאימה‬
33
© Keren Kalif
‫ייצוג בינארי‬
‫‪ ‬אבל מחשב מכיר רק את ‪ 0‬ו‪( 1 -‬יש חשמל או אין חשמל)‪ .‬לכן הזיכרון‬
‫לא באמת נראה כך‪..‬‬
‫‪ ‬בכל תא זיכרון יש קומבינציה של ‪ 0‬ו‪ 1-‬המייצגות את הערך הנמצא בתוך‬
‫התא‬
‫‪ ‬כל ‪ byte‬מורכב מ‪ 8-‬יחידות‬
‫בסיסיות הנקראות ‪( bit‬סיבית)‬
‫‪ bit ‬מכיל ‪ 0‬או ‪1‬‬
‫‪ ‬כל ‪ int‬מורכב מ‪'byte 4 -‬ים‬
‫‪1000‬‬
‫‪00000100‬‬
‫‪00000000‬‬
‫‪4‬‬
‫‪00000000‬‬
‫‪00000000‬‬
‫‪1004‬‬
‫‪00011000‬‬
‫‪00000000‬‬
‫‪24‬‬
‫‪00000000‬‬
‫‪00000000‬‬
‫‪1008‬‬
‫‪10101011‬‬
‫‪11111111‬‬
‫‪-85‬‬
‫‪11111111‬‬
‫‪11111111‬‬
‫‪1012‬‬
‫‪34‬‬
‫‪© Keren Kalif‬‬
‫‪int: n1‬‬
‫‪int: n2‬‬
‫‪int : n3‬‬
‫אז כאשר המחשב רואה ‪ 111‬איך הוא יודע אם הכוונה ל‪ 7 -‬או‬
‫ל‪?-8 -‬‬
‫‪ ‬בשפת ‪ JAVA‬טיפוסי המספרים יחזיקו תמיד בסיבית הראשונה‬
‫אינדיקציה האם המספר חיובי או שלילי‪ :‬מספר שלילי יתחיל בסיבית ‪1‬‬
‫ומספר חיובי בסיבית ‪0‬‬
‫‪  ‬טווח המספרים ש‪ int -‬יכול להכיל הוא בין ‪-2-31 - 231-1‬‬
‫‪-2147483648 … 0 … 2147483647‬‬
‫‪ ‬לכן כאשר המחשב רואה ‪( 111‬בהנחה ששאר הסיביות משמאל הן ‪)0‬‬
‫הוא מתייחס למספר כאל ‪.7‬‬
‫‪35‬‬
‫‪© Keren Kalif‬‬
‫תוכנית ב‪ –JAVA -‬סיכום ביניים‬
‫‪ ‬כפי שראינו‪ ,‬קוד ב‪ JAVA -‬הוא קובץ טקסט הכתוב מאוסף מילים‬
‫מסוימות באנגלית‬
‫‪ ‬יש מילים מסוימות שהן פקודות מוכרות למחשב‬
‫‪ ‬המחשב אינו יודע אנגלית‪ ,‬אלא רק מכיר את הספרות ‪ 0‬ו‪( 1-‬בינארית)‬
‫ולכן עלינו לתרגם עבורו את הקוד שלנו ל‪ ,byte code -‬בתהליך‬
‫הנקרא קומפילציה‬
‫‪ ‬תהליך הקומפילציה מייצר קובץ בינארי עם סיומת ‪ class‬שאותו‬
‫המחשב יכול להריץ אם מותקן לו ‪(Java Virtual Machine) JVM‬‬
‫‪36‬‬
‫‪© Keren Kalif‬‬
‫הגדרת קבועים‬
public static
Scanner
double
double
void main(String[] args) {
s = new Scanner(System.in);
price;
totalPrice;
System.out.println("Please enter the product’s price: ");
price = s.nextDouble();
totalPrice = price + (price*0.17);
System.out.println("Total price including “ + 17 +
“% taxes is “ + totalPrice);
}
37
© Keren Kalif
)2( ‫הגדרת קבועים‬
public static
Scanner
double
double
double
void main(String[] args) {
s = new Scanner(System.in);
price;
‫ע"י שימוש במשתנה התוכנית יותר‬
totalPrice;
‫ ברורה מה משמעות המספר גם‬,‫קריאה‬
TAXES = 17;
‫למי שאינו יודע מהו ערכו של המע"מ‬
System.out.println("Please enter the product’s price: ");
price = s.nextDouble();
totalPrice = price + (price*TAXES/100);
System.out.println("Total price including “ + TAXES +
“% taxes is “ + totalPrice);
}
,‫שינוי בערך המע"מ יגרור שינוי במקום אחד בלבד בתוכנית‬
)..‫מה שחוסך עבודה ובעיות בעתיד (אם שכחנו לתקן במקום כלשהו‬
38
© Keren Kalif
‫קבועים‬
‫‪ ‬קבוע הוא משתנה שלא ניתן לשנות את ערכו‪ .‬הערך נכתב‬
‫ע"י המתכנת בשורה בה מוגדר הקבוע‬
‫‪ ‬לא ניתן לשנות את ערכו במהלך ריצת התוכנית‬
‫‪‬‬
‫רק המתכנת יכול לשנות את הערך (שינוי בזמן כתיבת התוכנית)‬
‫ולקמפל מחדש עם הערך החדש‬
‫‪ ‬יתרונות‪:‬‬
‫‪‬‬
‫‪‬‬
‫תוכנית קריאה יותר‬
‫תחזוקה‬
‫‪39‬‬
‫‪© Keren Kalif‬‬
FINAL
‫הגדרת קבועים ע"י‬
public static void main(String[] args) {
Scanner s = new Scanner(System.in);
double price;
‫ניתן להגדיר משתנה כקבוע באמצעות‬
double totalPrice;
‫ וכך לא ניתן‬final ‫המילה השמורה‬
final double TAXES = 17;
‫לשנות את ערכו בהמשך התוכנית‬
System.out.println("Please enter the product’s price: ");
price = s.nextDouble();
totalPrice = price + (price*TAXES/100);
System.out.println("Total price including “ + TAXES +
“% taxes is “ + totalPrice);
TAXES = 16.5;
}
:‫שגיאת קומפילציה‬
The final local variable can not be assigned
40
© Keren Kalif
‫שמות משתנים‬
‫‪ ‬שמות המשתנים יכולים להכיל אותיות גדולות וקטנות‪ ,‬מספרים וקו‬
‫תחתון בלבד‬
‫‪ ‬לא ניתן להתחיל שם משתנה במספר‬
‫‪ ‬יש לתת שמות משמעותיים!!!‬
‫‪ ‬שם משתנה לא יכיל רווחים‬
‫‪ ‬יש הבדל בין אותיות גדולות לקטנות‬
‫‪ ‬אין להשתמש המילים שמורות של השפה‬
‫‪ ‬דוגמאות‪:‬‬
‫;‪int x, _y, _average, avg, x1,x2‬‬
‫!‪int 5, 1x, #x, !!2; // error‬‬
‫‪41‬‬
‫‪© Keren Kalif‬‬
‫‪‬‬
‫‪‬‬
‫טיפוסי משתנים‬
‫‪ ‬בתוכניות הקודמות ראינו כיצד קולטים מהמשתמש מספר שלם‬
‫ומספר עשרוני‬
‫‪ ‬ניתן לקלוט סוגים נוספים של נתונים‪ ,‬למשל תו‪ ,‬מחרוזת או בוליאני‬
‫‪ ‬אבל צריך לידע את המחשב עם איזה סוג של נתונים אנחנו רוצים‬
‫לעבוד‬
‫‪ ‬בתוכנית הגדרנו‪:‬‬
‫{ )‪public static void main(String[] args‬‬
‫;)‪Scanner s = new Scanner(System.in‬‬
‫;‪int x‬‬
‫;)(‪x = s.nextInt‬‬
‫}‬
‫‪ ‬כאשר כתבנו את השורה ;‪ int x‬הגדרנו משתנה שמכיל מספרים‬
‫שלמים‬
‫‪42‬‬
‫‪© Keren Kalif‬‬
‫טיפוסי משתנים בסיסיים ‪DATA TYPES‬‬
‫‪ ‬ישנם סוגים שונים של משתנים הנבדלים ב‪ 2-‬דברים‪:‬‬
‫‪‬‬
‫‪‬‬
‫בתוכן אותו הם יכולים להכיל (שלם‪ ,‬עשרוני‪ ,‬תו‪ ,‬בוליאני)‬
‫במספר ה‪ byte -‬שהמשתנה תופס בזיכרון‪ ,‬ומכאן טווח הערכים‬
‫שמשתנה מהטיפוס יכול להכיל‬
‫‪Range‬‬
‫‪Size‬‬
‫‪Example‬‬
‫‪Definition‬‬
‫‪-27…27-1‬‬
‫‪1 byte‬‬
‫תו (’!’‪)‘a’, ‘A’, ‘6’,‬‬
‫‪char‬‬
‫‪-231…231-1‬‬
‫‪4 bytes‬‬
‫מספר שלם (‪)-3,7,8234‬‬
‫‪int‬‬
‫‪8 bytes‬‬
‫מספר ממשי (‪)5.2 ,-89 ,3.6‬‬
‫‪double‬‬
‫‪1 byte‬‬
‫בוליאני )‪(true / false‬‬
‫‪boolean‬‬
‫)‪(-128..127‬‬
‫‪true / false‬‬
‫‪43‬‬
‫‪© Keren Kalif‬‬
‫טיפוסי נתונים בסיסיים נוספים‬
‫‪Size‬‬
‫‪Example‬‬
‫‪Definition‬‬
‫‪Range‬‬
‫‪4 byte‬‬
‫מספר ממשי (‪)5.2 ,-89 ,3.6‬‬
‫‪float‬‬
‫‪-215…215-1‬‬
‫‪2 bytes‬‬
‫מספר שלם (‪)-3,7,8234‬‬
‫‪short‬‬
‫‪-263…263-1‬‬
‫‪8 bytes‬‬
‫מספר שלם (‪)-3,7,8234‬‬
‫‪long‬‬
‫‪-27…27-1‬‬
‫‪1 byte‬‬
‫מספר שלם (‪)-3,7,82‬‬
‫‪byte‬‬
‫‪ ‬נשתמש בטיפוסים אלו רק כאשר נרצה לחסוך במקום גדול‬
‫‪44‬‬
‫‪© Keren Kalif‬‬
http://www.ynet.co.il/articles/0,7340,L-4599213,00.html :‫לקוח מתוך‬
45
© Keren Kalif
‫הגדרת משתנים בתוכנית‬
byte 4 -‫ מורכב מ‬int
public static void main(String[] args) {
int
n1 = 4;
double n2 = 5.2;
char
ch = ‘f’;
short
n3 = 7, n4 = 77;
int
n6 = -11;
}
byte1 -‫ מורכב מ‬char
4
1000
5.2
1004
char: ch
‘f’
1012
short: n3
7
1013
short: n4
77
1015
int: n6
-11
1017
int: n1
double: n2
?‫למה ההפרש בין הכתובות שונה‬

‫ כי כל סוג משתנה תופס כמות שונה של בתים‬
:‫הגדרת משתנים באופן כללי‬
<type> <var name>[=init value][,<var name2>…];

46
© Keren Kalif
‫אתחול והשמת משתנים‬
‫‪ ‬פעולת השמה היא מתן ערך למשתנה‪:‬‬
‫>‪<variable> = <expression‬‬
‫‪L-Value = R-Value‬‬
‫‪ ‬נקרא גם‪:‬‬
‫‪ ‬ראשית מתבצע חישוב הביטוי שמימין ואז ערכו מושם לתוך המשתנה שמשמאל‬
‫{ )‪public static void main(String[] args‬‬
‫‪int: a‬‬
‫‪17‬‬
‫‪5‬‬
‫??‬
‫‪1000‬‬
‫;‪int a, b, c‬‬
‫‪int: b‬‬
‫??‬
‫‪15 1004‬‬
‫‪17‬‬
‫;‪int d = 9‬‬
‫‪int: c‬‬
‫‪?? 1008‬‬
‫;‪a = 5‬‬
‫‪int: d‬‬
‫‪9‬‬
‫‪1012‬‬
‫; ‪b = a*3‬‬
‫;‪a = b = 17‬‬
‫בשפת ‪ JAVA‬לא ניתן להשתמש במשתנה‬
‫‪a=c‬‬
‫ללא אתחולו‪ ,‬ולכן תתקבל שגיאת קומפילציה‬
‫}‬
‫‪47‬‬
‫‪© Keren Kalif‬‬
‫הדפסת וקליטת משתנים מטיפוסים שונים‬
:‫ עד כה ראינו‬
‫ הגדרת משתנים מטיפוסים שונים‬
double -‫ ו‬int ‫ הדפסה וקליטה של משתנים מטיפוס‬
‫ עבור כל טיפוס יש פקודה שונה לקליטתו‬
Scanner ‫ הוא משתנה מטיפוס‬s ‫ כאשר‬s.nextInt ‫ הפקודה היא‬int ‫ עבור‬
public static void main(String[] args) {
Scanner s = new Scanner(System.in);
int x;
System.out.println(“Please enter a number: “);
x = s.nextInt();
System.out.println(“number is ” + x);
}
48
© Keren Kalif
‫פורמט קליטה והדפסה לטיפוסים השונים‬
Data Type
Format
int
s.nextInt()
short
s.nextShort()
long
s.nextLong()
char
s.next().charAt(0)
float
s.nextFloat()
double
s.nextDouble()
byte
s.nextByte()
boolean
s.nextBoolean()
49
© Keren Kalif
‫הדפסת וקליטת משתנים מטיפוסים שונים‬
‫‪50‬‬
‫‪© Keren Kalif‬‬
‫הדפסת תווים מיוחדים‬
‫ירידת שורה‬
‫‪\n‬‬
‫"‬
‫"\‬
‫‪tab‬‬
‫‪\t‬‬
‫\‬
‫\\‬
‫‪51‬‬
‫‪© Keren Kalif‬‬
‫טבלת ‪ASCII‬‬
‫‪http://www.asciitable.com/‬‬
‫‪ ‬עד כה ראינו ייצוג של מספרים‪ ,‬אבל איך מייצגים אותיות ע"י‬
‫קומבינציה של ‪ 0‬ו‪?1 -‬‬
‫‪ ‬לכל תו יש קוד מספרי הנקרא "קוד ‪"ASCII‬‬
‫‪ ‬ניתן לראות את הקוד של כל תו ב"טבלת ‪:"ASCII‬‬
‫‪52‬‬
‫‪© Keren Kalif‬‬
‫ייצוג תווים‬
‫‪ ‬טבלאת ‪:ASCII‬‬
‫‪American Standard for Code Information Interchange‬‬
‫‪ ‬כאשר מאחסנים את ערכו של משתנה מטיפוס ‪ char‬למעשה שומרים‬
‫את ערך ה‪ ASCII -‬שלו‬
‫‪ ‬מאחר וגודלו של ‪ char‬הוא ‪ ,1byte‬כלומר ‪ ,8bit‬ניתן לאחסן במשתנה‬
‫זה ‪ (28) 256‬ערכים שונים‬
‫‪ ‬בטבלת ה‪ ASCII -‬הבסיסית יש רק ‪ 127‬ערכים‬
‫‪53‬‬
‫‪© Keren Kalif‬‬
‫טבלת ‪ - ASCII‬דגשים‬
‫‪http://www.asciitable.com/‬‬
‫ערכי ה‪ ASCII -‬של‬
‫האותיות הגדולות‬
‫נמצאים ברצף‬
‫ערכי ה‪ ASCII -‬של‬
‫הספרות נמצאים ברצף‪.‬‬
‫שימו לב כי ערכה ה‪-‬‬
‫‪ ASCII‬של ספרה אינו‬
‫זהה לערכה המספרי!‬
‫‪54‬‬
‫‪© Keren Kalif‬‬
‫ערכי ה‪ ASCII -‬של‬
‫האותיות הקטנות‬
‫נמצאים ברצף‬
‫הגדרת משתנים מטיפוס‬
‫‪CHAR‬‬
‫‪ ‬משתנה מטיפוס ‪ char‬נועד כדי לאכסן תו‪ ,‬ולכן ניתן לשים בו תו או‬
‫מספר‬
‫‪ ‬כאשר שמים מספר הכוונה לתו שמספר זה מייצג בטבלת ה‪ASCII -‬‬
‫‪ ‬בדוגמא זו‪ ,‬הערך בשני תאי הזיכרון זהה (משום שערך ה‪ASCII -‬‬
‫של ’‪ ‘a‬הוא ‪)97‬‬
‫‪01100001‬‬
‫‪char: ch1‬‬
‫‪1000‬‬
‫‪01100001‬‬
‫‪1001‬‬
‫‪1002‬‬
‫‪55‬‬
‫‪© Keren Kalif‬‬
‫‪char: ch2‬‬
‫{ )‪static public void main(String[] args‬‬
‫;’‪char ch1 = ‘a‬‬
‫;‪char ch2 = 97‬‬
‫}‬
‫הגדרת משתנים מטיפוס ‪)2( CHAR‬‬
‫‪ ‬ערכו של ‪ ch1‬הוא '‪ - '8‬התו ולא המספר (בגלל שהוא בתוך ' ')‬
‫‪ ‬לכן הערך שנשמר בזכרון הוא ערך ה‪ ASCII -‬של התו '‪)56( '8‬‬
‫‪ ‬לעומתו‪ ,‬ערכו של ‪ ch2‬הוא המספר ‪8‬‬
‫{ )‪public static void main(String[] args‬‬
‫;’‪char ch1 = ‘8‬‬
‫;‪char ch2 = 8‬‬
‫}‬
‫‪01010110‬‬
‫‪char: ch1‬‬
‫‪1000‬‬
‫‪00001000‬‬
‫‪1001‬‬
‫‪1002‬‬
‫‪56‬‬
‫‪© Keren Kalif‬‬
‫‪char: ch2‬‬
‫ וההיפך‬INT -‫ כ‬CHAR ‫הצגת‬
‫ ניתן להדפיסו או כתו או‬,‫ מאחר ותו מיוצג כמספר‬
:‫כמספר‬
public static void main(String[] args) {
char ch = ‘Z’;
int num = 97;
‫ הוראה לקומפיילר‬:‫המרה‬
‫להתייחס לתו כאל מספר‬
System.out.println(“int=“ + (int)ch + “ char=” + ch);
System.out.println(“int=“ + num + “ char=” + (char)num);
}
‫ הוראה לקומפיילר להתייחס למספר כאל תו‬:‫המרה‬
57
© Keren Kalif
‫מעבר תו המייצג ספרה למספר‬
‫‪ ‬בהינתן תו המכיל ספרה‪ ,‬יש למצוא את ערך הספרה‬
‫‪ ‬דוגמא‪ :‬עבור התו ’‪ ,‘8‬שערך האסקיי שלו הוא ‪ ,56‬יש לשמור את הערך ‪ 8‬ב‪-‬‬
‫‪int‬‬
‫‪ ‬כל הספרות נמצאות בטבלת האסקיי ברצף החל ממספר ‪( 48‬ערך‬
‫האסקיי של התו '‪)'0‬‬
‫‪ ‬החסרת הערך ‪ 48‬מתו המכיל ספרה יביא לנו את ערך המספר‬
‫‪58‬‬
‫‪© Keren Kalif‬‬
‫{ )‪public static void main(String[] args‬‬
‫;'‪char ch = '8‬‬
‫;'‪int num = ch - '0‬‬
‫;)‪System.out.println("ch as char: " + ch + ", as int: " + (int)ch‬‬
‫;)‪System.out.println("num is “ + num‬‬
‫}‬
STRING ‫הטיפוס‬
String ‫ ישנו טיפוס נתונים שיכול להכיל בתוכו מחרוזת והוא נקרא‬
‫ מכיל תו אחד בלבד בעוד‬char -‫ הוא ש‬String -‫ ל‬char ‫ ההבדל בין‬
‫שמחרוזת יכולה מספר תווים ללא הגבלה‬
‫) ובהמשך נלמד אילו‬Scanner ‫ הוא אובייקט (למשל כמו‬String 
‫פעולות אובייקט מטיפוס זה יודע לבצע‬
public static void main(String[] args) {
String str = "Hello World!";
System.out.println("The text is: " + str);
Scanner s = new Scanner(System.in);
System.out.print("Enter a num: ");
int num = s.nextInt();
str = "Your number is " + num;
System.out.println(str);
}
59
© Keren Kalif
‫קליטת מחרוזות‬
‫‪ s.next‬קורא מילה עד רווח‬
‫‪60‬‬
‫‪© Keren Kalif‬‬
‫קליטת מחרוזת עם רווחים‬
‫קליטת מחרוזת עד‬
‫אנטר (כולל רווחים)‬
‫‪61‬‬
‫‪© Keren Kalif‬‬
BUFFER
‫קליטת נתונים לתוך‬
public static void main(String[] args) {
Scanner s = new Scanner(System.in);
int n1, n2;
System.out.println("Enter a number --> ");
n1 = s.nextInt();
System.out.println("Enter another number --> ");
n2 = s.nextInt();
System.out.println("n1=“ + n1 + “ n2=“ + n2);
}
.ENTER ‫ניתן להקליד נתונים עד אשר מקלידים‬
.‫ ומחכים לפעולת הקליטה הבאה‬buffer -‫נתונים אלו נמצאים ב‬
.‫ פקודת הקליטה תיקח ממנו נתונים‬buffer -‫כל עוד יש נתונים ב‬
.‫ ריק פקודת הקליטה תמתין לקלט מהמשתמש‬buffer -‫רק כאשר ה‬
62
© Keren Kalif
‫קליטת מחרוזת עם רווחים‬
‫ניתן לראות כי הקומפיילר‬
‫"דילג" על שורה זו‪.‬‬
‫זאת משום שהוא לקח את‬
‫האנטר שהיה ב‪buffer -‬‬
‫מהקליטה הקודמת‪.‬‬
‫‪63‬‬
‫‪© Keren Kalif‬‬
‫הפתרון‬
‫נבצע קליטת שורה "סתם" כדי‬
‫לנקות את האנטר מה‪buffer -‬‬
‫‪64‬‬
‫‪© Keren Kalif‬‬
‫דוגמאת עבודה דרך הקונסול‬
‫כתיבת והרצת תוכניות בקונסול‬
‫‪ ‬סביבת העבודה שלנו מהווה מעטפת ויזואלים לכלים הבאים‪:‬‬
‫‪ ‬עורך‬
‫‪ ‬קומפיילר‬
‫‪ ‬דיבגר‬
‫‪ ‬ניתן לכתוב קובץ ב‪ notepad -‬ולקמפל ולהריץ אותו דרך הקונסול‬
‫‪66‬‬
‫‪© Keren Kalif‬‬
‫קומפילציה דרך הקונסול‬
‫הרצת פקודת הקומפליציה ‪javac‬‬
‫תוצר הקומפילציה‬
‫הרצת התוצר‬
‫‪67‬‬
‫‪© Keren Kalif‬‬
‫פלט התוכנית‬
‫פלט ב‪GUI -‬‬
‫הטקסט‬
‫משמע התיבה תופיע במרכז המסך‬
‫‪68‬‬
‫‪© Keren Kalif‬‬
‫פלט ב‪)2( GUI -‬‬
‫כותרת התיבה‬
‫סוג האייקון‬
‫‪69‬‬
‫‪© Keren Kalif‬‬
GUI -‫קלט מחרוזת ב‬
public static void main(String[] args) {
String name = JOptionPane.showInputDialog("Enter your name:");
JOptionPane.showMessageDialog(null, "Hi " + name + "!");
}
70
© Keren Kalif
GUI -‫ ב‬INT ‫קלט‬
public static void main(String[] args) {
String temp = JOptionPane.showInputDialog("Enter your age:");
-‫המרת נתון מ‬
int -‫ ל‬String
int age = Integer.parseInt(temp);
JOptionPane.showMessageDialog(null, “You are “ + age + “years old");
}
‫ תמיד קולט מחרוזות‬JOptionPane
public static void main(String[] args) {
String temp = JOptionPane.showInputDialog("Enter your height:");
double height = Double.parseDouble(temp);
JOptionPane.showMessageDialog(null, “Your height is“ + height + “m”);
}
71
© Keren Kalif
‫ביחידה זו למדנו‪:‬‬
‫‪ ‬בסיסי מספרים‪:‬‬
‫‪ ‬בינארי (‪ ,)2‬אוקטאלי (‪ ,)8‬הקסה‪-‬דצימאלי (‪)16‬‬
‫‪ ‬הדפסה למסך‬
‫‪ ‬קבלת נתונים מהמשתמש‬
‫‪ ‬קבועים‬
‫‪ ‬מבנה זיכרון התוכנית‬
‫‪ ‬הגדרת משתנים‬
‫‪ ‬טיפוסי משתנים‬
‫‪ ‬השמת ערך למשתנים‬
‫‪ ‬קימפול והרצת תוכניות בקונסול‬
‫‪ ‬הצגת נתונים בחלון‬
‫‪72‬‬
‫‪© Keren Kalif‬‬
‫תרגיל ‪ :1‬קלט מסוגים שונים‬
‫‪ ‬כתוב תוכנית המקבלת מהמשתמש את שנת הלידה שלו‪ ,‬ת‪.‬ז‪ ,.‬גובה‬
‫ותו המייצג האם המשתמש זכר או נקבה (‪)M/F‬‬
‫‪ ‬התוכנית תדפיס את פרטי המשתמש‪ ,‬אך במקום שנת הלידה תדפיס‬
‫את גילו‬
‫‪ ‬יש לראות בדיבגר את ערכי המשתנים‬
‫‪ ‬עדכנו את התוכנית כך שסוג הטיפוס השומר את מין המשתמש יהיה‬
‫בוליאני (במקום תו)‬
‫‪73‬‬
‫‪© Keren Kalif‬‬
‫תרגיל ‪ :2‬עבודה עם תווים שהם ספרות‬
‫‪ ‬כתוב תוכנית הקוראת מהמשתמש ‪ 3‬תווים (מטיפוס ‪ )char‬שהם‬
‫ספרות‬
‫‪ ‬התוכנית תייצר משתנה מטיפוס ‪ int‬שיכיל את הספרות שהתקבלו‬
‫כמספר‬
‫‪ ‬לבסוף התוכנית תדפיס את המספר‬
‫‪ ‬דוגמה‪ :‬אם הוכנסו התווים '‪ '7' '3' '1‬יווצר ויודפס המספר ‪.731‬‬
‫‪74‬‬
‫‪© Keren Kalif‬‬
‫תרגיל ‪ :3‬טבלאת האסקיי‬
‫‪ ‬כתוב תוכנית (קצרצרה!) המדפיסה את מספר האותיות ‪ AB‬באנגלית‬
‫(בהנחה שאינך יודע כמה יש ‪)‬‬
‫‪75‬‬
‫‪© Keren Kalif‬‬
‫תרגיל ‪ :4‬מחיר נסיעה במונית‬
‫‪ ‬מחיר נסיעה במונית משוקלל מהרכיבים הבאים‪:‬‬
‫‪ ‬מחיר התחלתי‪ 10.20 :‬ש"ח‬
‫‪ ‬מחיר עבור כל ק"מ‪ 1.30 :‬ש"ח‬
‫‪ ‬מחיר עבור כל מזוודה‪ 2.00 :‬ש"ח‬
‫‪ ‬יש לבקש מהמשתמש את הנתונים הדרושים ולהציג את הסכום‬
‫לתשלום‬
‫‪76‬‬
‫‪© Keren Kalif‬‬
‫תרגיל ‪ :5‬זמן נסיעה במעלית‬
‫‪ ‬נרצה לחשב את הזמן מהרגע שזימנו את המעלית עד אשר נגיע‬
‫לקומת היעד‬
‫‪ ‬בכל קומה בה המעלית עוצרת היא מתעכבת ‪ 5‬שניות‬
‫‪ ‬זמן הנסיעה בין קומה לקומה הינו ‪ 3‬שניות‬
‫‪ ‬ניתן להניח שהמעלית נוסעת ללא עצירות‪ ,‬פרט לעצירה בקומה ממנה‬
‫נאסף הנוסע‬
‫‪ ‬לצורך הפשטות‪ ,‬ניתן להניח כי קומת המקור נמוכה מקומת היעד‬
‫‪ ‬בפתרון אראה כיצד ניתן לוותר על הנחה זו‬
‫‪77‬‬
‫‪© Keren Kalif‬‬