1. היכרות עם שפת התכנות JAVA
יסודות מדעי המחשב
הרצאה 2
היכרות עם שפת התכנות JAVA
אלמנטים בסיסיים בשפה.

2. תכנון / תכנות תכנות תכנון אפיון ובניית המחלקות כתיבת הקוד
להיזכר בתמונה
בעיה  איש  מחשב
שעור קודם התמקדנו בצד השמאלי
התמקדנו פעם קודמת ב "תכנון"
הפעם נתמקד "בתכנות"

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

4. ואיך המחשב מבצע?
שתי שיטות נפוצות:
קומפילציה (הידור) - תרגום שפה עילית לשפת מכונה (ע"י קומפיילר). הפקודות מתורגמות באופן חד פעמי.
אינטרפטציה (פירוש) - שימוש בתוכנית, שכבר תורגמה לשפת המכונה, היודעת לבצע ישירות את הפקודות שבשפה העילית. הפקודות מתורגמות בזמן הביצוע ויתכן שפקודות מסויימות יתורגמו מספר רב של פעמים.
JAVA מתורגמת תחילה לשפת ביניים שמורצת על ידי אינטרפרטר
שפת הביניים נקראת Java byte-code
מורץ ע"י Java Virtual Machine
ומה זה מעניין אותנו?
בשלב הזה - אפשר להסתפק בהשכלה כללית

5. מאפייני שפה
סינטקס (תחביר)
סמנטיקה – משמעות מילים

6. תוכנית שילדית בג'ווה public class Hello {
public static void main(String[] args)
System.out.println(“Hello World !”); }

7. מתחילים לתכנת הליך פתרון בעייה באמצעות מחשב
קבלת דרישות מהמשתמש (הדרישות צריכות להיות מובנות למשתמש ולבונה התוכנה) מומלץ לשתף את כל הגורמים הנוגעים לתוכנה מהסיבות הבאות:
לשמור על כבודם העצמי של המשתמשים במטרה לא לפתח אצלם אנטיגוניזם לתוכנה.
לקבל מכל המשתמשים את אופן העבודה הרצוי להם וליצור כלי שיענה על כל הדרישות יחד (לא תמיד זה אפשרי)..
הבנת הבעייה.
בניית מבנה הנתונים בהתאם לבעייה יתכן ויש צורך לחזור לסעיף 1.
כתיבת מחלקות לביצוע התהליך. במידת הצורך חלוקת העבודה למספר עובדים שכל אחד יהיה אחראי לכתיבה של מחלקה מסויימת. גם כאן עקב חילוקי דעות ואילוצים יתכן שבו יהיה צורך לחזור לסעיף 1.
איחוד המחלקות וביצוע קומפילציה.
במידה ויש בעיות קומפילציה יש צורך לחזור לסעיף 3 או סעיף 4 תלוי במהות הבעייה.
הרצת התוכנית המוגמרת ובדיקת המערכת.
כאן יתכן הצורך לחזור לסעיף 1 כי יתכן שהמתכנת והמגדיר לא הבינו אחד את השני או המגדיר לא ידע למה מסוגלת המערכת ובשלב זה הוא רואה שניתן לקבל יותר.
סיום. כאן יתכנו מספר אפשרויות:
מסירת העבודה ולאחר זמן מסויים המשתמש נוכח לדעת כי הוא רוצה פונקציונליות נוספת. הרחבות.....(וכאן מגיע הכסף הגדול של חברות התוכנה הגדולות – אין מצב בו לקוח מסויים לא יכנס למצב זה).
מציאת גורם מתאים להטיח עליו את הסיבה העיקרית לכשלון בפרוייקט.

8. מתחילים לתכנת - המשך
כללי: כאשר מתחילים לעבוד בסביבה חדשה ולא מוכרת מומלץ תמיד להפעיל את התוכנית "שלום עולם" שבד"כ מסופקת עם ערכת הפיתוח.
Class – מחלקה בעלת שיטות – יתואר בהמשך
כל תכנית ב JAVA בנויה כך:
Class <name> {
public static void main(String[] args)
System.out.println(“Hello World !”); }
שיטות במחלקה ( { אוסף פקודות })
חייבת להמצא שיטה הנקראת main משם התוכנית מתחילה לרוץ EntryPoint
ישנה התייחסות לאותיות קטנות או גדולות בשפה.

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

10. הגדרות משתנים פרימיטיביים.
הגדרות משתנים פרימיטיביים.
שמות משתנים
מתחילים אך ורק באותיות A..Z או a..z _ וסימן $.
כוללים: A..Z או a..z מספרים קו תחתי
המשתנים Bob ו-bob אינם זהים.
מספרים שלמים
Byte
short
int
long
מספרים עם נקודה צפה
float
double
אחרים
char
boolean
string
מוסכמות לשמות משתנים
אות ראשונה רגילה וכל התחלת אות רישית: דוגמה: numberOfBrats.
שמות של מחלקות תמיד מתחיל באות רישית. דוגמה: BasicIO.

11. בחירת סוגי המשתנים
שימוש בשני מצבים אמת/שקר כן/לא יש לבחור משתנה בוליאני.
כמה ביטים דרושים על מנת לייצג ערך ?
כמה ביטים דרושים על מנת לייצג אחת מבין 4 אפשרויות ?
כמה ביטים דרושים על מנת לייצג אחת מבין 9 אפשרויות ?
מהו גודל המספר שניתן לייצג באמצעות n ביטים? ומה עם שליליים ?
תוים יהיו מיוצגים כמספרים – קיימים מוסכמות שונות לתווים (unicode, ascii)

12. דוגמאות למשתנים משתנה לשמירת מספר הנפשות במשפחה byte NumOfPeoples;
משתנה לשמירת מספר התושבים ביישובי הפרפריה מסביב לבאר שבע
int NomOfToshavim;
משתנה לשמירת מספר התושבים במדינת ישראל
long NumOfHabit;
משתנה לשמירת ערך השכר השנתי המשולם למרצים באב"ג:
float Salary = ;

13. דוגמאות למשתנים
משתנה לשמירת מספר עם דיוק גבוה וטווח גבוה מאוד של ערכים
double HiAccurateNum;
למה לא להשתמש במשתנה מסוג double כאשר רוצים לשמור מספר נפשות בבית ?
אין צורך לשמור למספר נפשות מספר אחרי הנקודה.
שימוש במשתנה כזה גוזל משאבי מחשב כאשר מבצעים עליו פעולות שונות.
מסקנה: מומלץ להשתמש בסוג המשתנה המתאים ביותר.

14. דוגמאות למשתנים משתנה לשמירת תו כל שהוא char anyChar;
משתנה לשמירת שם של סטודנט:
string NameOfStudent;
אם מוספים למשתנה את ההקדמה final מגדירים משתנה שערכו אינו יכול להשתנות במהלך הביצוע של התוכנית.
דוגמה:
final float MaxSalary = 0.45;
final char EscapeChar = ‘F’;
final string USAPresidentName = “Obama”;

15. פקודות קלט פלט פקודות פלט למסך: System.out.println(“A+B=”+(A+B));
מה ההבדל בין השורה הראשונה לשורה השנייה

16. תווים מיוחדים במחרוזות
\n – מעבר לתחילת השורה
\r – מעבר לשורה הבאה
\t – הכנסת טאב
\\ - הדפסת התו \
\” – הדפסת התו "

17. פקודות קלט פלט
פקודות קלט מהמקלדת: מחלקה שנבנתה לצורך הקורס. המחלקה אינה חלק משפת JAVA
int FirstNum;
FirstNum = BasicIO.ReadInteger("give first num\n");
string Name;
Name = BasicIO.ReadString(“Enter first Name\n");
float Weight = BasicIO.ReadDouble("enter weight:");

18. השמות ואופרטורים על משתנים
I = J + 1; I = J = K = 55;
I = I + 1; I += 1; I++; ++I; זהים לחלוטין
I = I – 1; I -= 1; I--; --I; זהים לחלוטין
I = I * 6; I *= 6; זהים לחלוטין
I = I / 6; I /= 6; זהים לחלוטין
I = I % 6; I %= 6; זהים לחלוטין
איך נממש "מתחלק ב"
זיהוי הלולאה
כל עוד "מה" נבצע "מה"
להביע את התנאי

19. הפעלת אופרטורים ישנם אופרטורים ה"פועלים" בצורה שונה על טיפוסים שונים:
double x = 5.0/2.0
X=2.5
int x = 5/2
X=2
double x = 5/2
X=2.0
double x = 5.0/2
int x = (int)5.0/2.0

20. אופרטורים על משתנים
I = J++ + 1; <<<==>>> I = J + 1; J++;
I = ++J + 1; <<<==>>> J++; I = J + 1;
איך נממש "מתחלק ב"
זיהוי הלולאה
כל עוד "מה" נבצע "מה"
להביע את התנאי

21. אופרטורים יחס בין משתנים
משתמשים בהם לקביעת תנאים, מחזירים ערך בולאני
> גדול מ....
>= גדול ושווה ל...
< קטן מ...
<= קטן ושווה ל...
== שווה ל....
!= שונה מ.....
I > J
I >= J
I < J
I <= J
I == J
I != J
איך נממש "מתחלק ב"
זיהוי הלולאה
כל עוד "מה" נבצע "מה"
להביע את התנאי

22. הרחבת אופרטורי יחס בין משתנים
משתמשים בהם לקביעת תנאים מורכבים יותר
&& - and second will be checked only if first is True
|| - or second will be checked only if first is false
! - inverse
& - and (all checked always)
| - or (all checked always)
^ - not equal
איך נממש "מתחלק ב"
זיהוי הלולאה
כל עוד "מה" נבצע "מה"
להביע את התנאי

23. קדימויות סוגריים, ++exp --exp . [] & ++exp –exp +exp –exp ~ ! ^
(cast)expr
* / %
+ -
> >>
> < >= <=
== !=
& ^ |
&& ||
? :
= += -= /= %= ....

24. Casting בד"כ תוצאה של ביטוי מתימתי תהיה בהתאם להרכב המשתנים בביטוי.
אם כל המשתנים שלמים התוצאה תהיה מספר שלם.
אם כל המשתנים שלמים ואחד המשתנים ארוך אזי התוצאה תהיה ארוכה.
אם אחד מהמשתנים ממשי אזי התוצאה ממשית.
אם אחד מהמשתנים הינו ממשי כפול התוצאה ממשית כפולה.

25. Casting אך מה קורה למשתנה שאמור לקבל את התוצאה
אם המשתנה המקבל את התוצאה הינו שלם אזי התוצאות יהיו מספר שלם. באם המשתנה המקבל את התוצאה קטן יותר התוצאה "תתעוות"
אם המשתנה המקבל הינו ממשי אזי התוצאה תהיה ממשית אם אחד מהמשתנים הינו ממשי.
הצגה של 33 הינה שלם ואם רוצים להציג את המספר 33 כמספר ממשי יש צורך להציגו 33.0 או (float)33
אם רוצים לבצע חילוק שלמים אבל רוצים שהתוצאה תהיה מספר ממשי אזי ניתן להשתמש ב-Casting

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

27. משפטי התנייה IF שימוש: הסתעפות של מהלך ביצוע התוכנית If (תנאי) {
…// execute those commands when Condition is true }
else
… //execute those command when Condition is false (Optional)…..
איך נממש "מתחלק ב"
זיהוי הלולאה
כל עוד "מה" נבצע "מה"
להביע את התנאי

28. דוגמה למשפט IF If (m > n) { max = m; } else max = n;
איך נממש "מתחלק ב"
זיהוי הלולאה
כל עוד "מה" נבצע "מה"
להביע את התנאי

29. לולאות – לולאת WHILE -FOR
שימוש: לביצוע מספר פעמים עד לביצוע תנאי לוגי מסויים
for( איתחול משתנים ; תנאי ביצוע; קידום משתנים) { …. }
while(תנאי ביצוע)
…..
לולאת FOR כוללת בתוכה את לולאת WHILE. ניתן "לשכוח" מלולאת WHILE ולהשתמש בלולאת FOR בלבד
איך נממש "מתחלק ב"
זיהוי הלולאה
כל עוד "מה" נבצע "מה"
להביע את התנאי

30. לולאות DO-WHILE do { } while (תנאי ביצוע);
שימוש: לביצוע מספר פעמים עד לביצוע תנאי לוגי מסויים do {
} while (תנאי ביצוע);
ההבדל בין הלולאה הזו ללואות הקודמות הינו בכך שלולאה זו תתבצע לפחות פעם אחת בו בזמן שהלולאות הקודמות לא יתבצעו כלל – מכיוון שבלולאה זו תנאי קיום הלולאה נבדק לאחר סיום ביצוע הראשון של הלולאה.
איך נממש "מתחלק ב"
זיהוי הלולאה
כל עוד "מה" נבצע "מה"
להביע את התנאי

31. פקודות "הפרעה" למהלך תקין של לולאה
מילות מפתח: break, continue
break – ברגע ביצוע הפקודה הלולאה מסתיימת ללא תנאי
Continue – ברגע ביצוע פקודה זו הלולאה הנוכחית מסתיימת וחוזרים לתחילת הלולאה.
מילות מפתח: return
השיטה הנוכחית מסתיימת. במידה והשיטה מחזירה ערך יש להוסיף לפקודה זו את הערך המוחזר.
איך נממש "מתחלק ב"
זיהוי הלולאה
כל עוד "מה" נבצע "מה"
להביע את התנאי

32. דוגמה: שימוש בשלושת הלולאות להדפסת כל המספרים בין 1 ל-200 (כולל)
ניתן לבחור כל כל סוג לולאה לביצוע כל פעולה, החוכמה הינה לבחור את הלולאה האופטימלית לסוג הבעייה הנדרשת לפתרון.
for loop
for (int I = 1; I < 201;i++) {
System.out.println(I); }
While loop
I = 1;
while (I < 201) {
System.out.println(I);
I++; }
Do while loop
I = 1; do {
System.out.println(I);
I++;
} while (I != 201)
איך נממש "מתחלק ב"
זיהוי הלולאה
כל עוד "מה" נבצע "מה"
להביע את התנאי

33. דוגמה: קבלת ערך תקין מהמקלדת
יש צורך להזין מספר מהמקלדת ולא להתקדם הלאה אם המספר שהתקבל אינו בתחום שבין 20 ל-100
במקרה זה הלולאה תתבצע לפחות פעם אחת ותאפשר הזנת הערך. כל עוד הערך לא יוזן בתחום הדרוש, הלולאה תמשיך להתבצע.
Do while loop
int number; do {
number = BasicIO.ReadInteger(“Enter Number [20-100]\n");
} while (number < 20 && number > 100);
איך נממש "מתחלק ב"
זיהוי הלולאה
כל עוד "מה" נבצע "מה"
להביע את התנאי

34. דוגמה: חישוב שורש ריבועי של מספר
final Accuracy = 0.001;
float number; do {
number = BasicIO.ReadDouble(“Enter Number\n");
} while (number >= 0);
Num = number / 2; min = 0; max = number;
while (Math.abs(Num * Num – number) > Accuracy )
if (Num * Num – number > 0)
max = num; }
else
min = num;
Num = (min + max) / 2;
System.out.println(“Root of ”+number+ “ is “ + Num);
איך נממש "מתחלק ב"
זיהוי הלולאה
כל עוד "מה" נבצע "מה"
להביע את התנאי

35. משפט SWITCH
switch (Selector) {
case 1:
case 2:
dosomething12();
break;
case 3:
dosomething3();
default:
dosomethingdefault(); }
במקרים בהם יש צורך להתפצל ליותר משתי נקודות בפיצול ניתן להשתמש בפקודה switch

36. משפטי הסתעפות במקרים בהם יש צורך לשבור לולאות או בתוך משפטי switch
break; case - ליציאה מהלולאה או מ-
Continue – למעבר לתחילת לולאה;
במקרים בהם יש צורך לשבור לולאות או בתוך משפטי switch
חזרה לתחילת הלולאה.

37. קיצורים נוספים if (i > 0) { System.out.println(“Pos”); } else
System.out.println(“Neg”);
הפקודה השקולה:
System.out.println((i > 0) ? “Pos”: “Neg”);

38. מימוש: מאלגוריתם לתכנית אוקלידוס
התחלה
public class Gcd1 {
public static void main(String[] args)
int m, n, r;
m = BasicIO.ReadInteger(“First num: ");
n = BasicIO.ReadInteger(“Second num: ");
r = m % n;
while (r != 0)
m = n;
n = r; }
System.out.println(n);
קלוט m, n
r m % n כן
n פלוט
r = 0 לא
סיום
m n
n r

39. בעיה: מספרים ראשונים קבע האם מספר טבעי (גדול מ-1) הינו ראשוני
אלגוריתם במילים

40. חלק מתוכנית לחישוב מספר ראשוני
int x = BasicIO.ReadInteger("give num\n");
boolean prime = true;
int I = 2;
while (I < x && prime ) {
if ( x % I == 0)
prime = false; }
I = I + 1;
System.out.println(prime);
דיון בתנאי שבלולאה – אפשר ליעל על ידי הוספה של
&prime
נבדוק נכונות
ננסה לשפר:
יעיל יותר: מהיר יותר – פחות פעולות חישוב.
פשוט יותר: לתכנות .

41. מספרים ראשונים תוכנית שונה
int x = BasicIO.ReadInteger("give num\n");
boolean prime = true;
for(int i =2; i < x && prime; i++) {
if ( x % I == 0)
prime = false; }
System.out.println(x+" is prime? "+prime);
דיון בתנאי שבלולאה – אפשר ליעל על ידי הוספה של
&prime
נבדוק נכונות
ננסה לשפר:
יעיל יותר: מהיר יותר – פחות פעולות חישוב.
פשוט יותר: לתכנות .

42. שיפורים יעיל יותר: (צמצום מרחב החיפוש) נבדוק רק עד השורש של המספר.
int x = BasicIO.ReadInteger("give num\n");
boolean prime = true;
for(int i =2; i < (int)Math.sqrt(x); && prime; i++) {
if ( x % I == 0)
prime = false; }
System.out.println(x+" is prime? "+prime);

43. הרחבת הבעיה: הדפס את כל המספרים הראשונים עד n. נגדיר אלגוריתם במילים.
נבדוק נכונות
ננסה לשפר:
יעיל יותר: מהיר יותר – פחות פעולות חישוב.
פשוט יותר: לתכנות .

44. חישוב כל הראשוניים עד n מספיק לבדוק עד השורש מספיק לבדוק ראשוניים!
int n = BasicIO.ReadInteger("give num\n");
int x = 2;
while (x <= n) {
boolean prime;
prime = true
int I = 2;
while (I < (int)Math.sqrt(x) && prime )
if ( x % I == 0)
prime = false; }
i++;
if ( prime )
System.out.println(x);
x++;
output:
enter natural max number: 40
2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37
צמצום מרחב המועמדים (אפשר לוותר על מספרים זוגיים).
צמצום מרחב המועמדים לחלוקה:
מספיק לבדוק עד השורש
מספיק לבדוק ראשוניים!
שמירת רשימת ראשוניים עד עתה!

45. חומר למחשבה
כתבו תוכנית לחישוב צפיפות הראשוניים בין שני מספרים.

46. תרגיל בית מספר 1 יש לכתוב מחשבון לתאריך וזמן:
אפשרות קביעת תאריך וזמן שישמש לביצוע התרגיל.
אפשרות לקבוע פעולה לביצוע (חיבור או חיסור)
אפשרות לקבוע גודל של זמן בימים שעות דקות או שניות
הפלט יהיה הזמן ההתחלתי + (או מינוס) גודל הזמן.
הדפסת כל התאריכים בין תאריך התחלתי ותאריך סופי כולל.
הדפסת טווח התאריכים בין שתי התאריכים.
לדוגמה אם:
זמן התחלתי הינו: 12/10/2008 בשעה 23:45:00
הוזנה פעולת חיבור.
גודל הזמן הינו 17 דקות
הפלט יהיה 13/10/2008 השעה 0:02:00
דוגמה נוספת:
זמן התחלתי 12/12/1989 שעה 01:12:22
פעולת חיסור
זמן לחיסור הינו 24 שניות
הפלט יהיה 12/12/1989 שעה 01:11:58