מדריך | Java למתחילים

[אליר325000]

האמת שכבר יש פה מדריכים נהדרים בעניין ג׳אווה אבל אני אנסה לכתוב מדריך קצת שונה בדרך שלי בשביל אנשים שבאמת אין להם מושג בקוד, אז יאללה;

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

Spoiler

1. משתנה: לרוב פעולה שמשתנה בהתאם לתוכנה. יש שני סוגי משתנים עיקריים המשתנה הפרימיטיבי ואובייקט.

2. קלט: כינוי למה שג׳אווה מקבלת מהמשתמש

3. פלט: כינוי למה שג׳אווה פולטת (או "מדפיסה") למשתמש

4. תנאי: מכיל את if שזה שאלת התנאי, [כמו אם] ואז תוצאה לפעולה = [כמו אז]
   לעיתים מכיל גם else למקרה שהתנאי לא עבד [כמו "אם לא"]

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

6. פעולה (או שיטה): שם כולל למכלול פקודות, יש פעולות ראשיות, שהם הפעולה הראשונה בכניסה לדף, ויש פעולות "נסתרות" שמכילות מכלול פעולות, שניתנים לשליפה ע"י הזכרת הפעולה]

סקירה קצרה;

האמת שJava איננה שפה מבוקשת כמו בעבר, משתי סיבות עיקריות;

1. ישנם שפות רבות וקלות יותר, כדוגמת Js (שהשם לא יבלבל אין קשר לג׳אווה) ו python.
2. אפילו באנדרואיד - מקדש הג׳אווה עד לא מזמן - כבר יש את קוטלין, שפה קצרה וקלה בהרבה.

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

ג׳אווה עובדת בשלושה שלבים מהקוד ועד לשפת המכונה;

1. קוד המתכנת (Java)
2. שפת הביניים לאחר ההידור (bytecode) שרצה בסביבה עצמאית (Java virtual machine או בקיצור jvm)
3. שפת המכונה (אסמבלר או אסמבלי) המוכרים לנו מאפליקציות האנדרואיד כ Smali

אם נתמצת את זה נבין מדוע במ. הפעלה שאינם נושאים איתם את סביבת העבודה של ג׳אווה כדוגמת ווינדוס 8 ומעלה אז נצטרך להתקין את סביבת העבודה (jvm) כדי שיהיה לנו מהדר (משלב הקוד לשפת המכונה) שיריץ פקודות ג׳אווה למכונה (ווינדוס)

אנדרואיד לעומת זאת כבר משתמשים ב jvm עצמאי ולכן הקוד יעבוד עליהן ישר.

ידיעה מעניינת: בתכנות דפים ואתרי אינטרנט באמצעות ג׳אווה, יש להשתמש בכלים הממירים את הפונקציונליות של ג׳אווה ל html כמו jsp, משום שדפדפנים רגילים אינם יכולים לקרוא או להריץ קוד ג'אווה ישירות, קוד ג'אווה הוא שפת תכנות שרצה על מכונה וירטואלית של ג'אווה (JVM) בצד השרת, כדי לאפשר לדפדפנים "רגילים" להריץ ג'אווה, היה צורך לשלב מכונה וירטואלית של ג'אווה בתוך הדפדפן עצמו.

בעבר, זה אכן היה נעשה בעזרת טכנולוגיה שנקראת Java Applets שאיפשרה לדפדפנים עם JVM משולבת להריץ קוד ג'אווה מהדף.

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

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

התקנת ג׳אווה וקומפיילר

jdk
אז אם אנחנו משתמשי ווינדוס (מסתמא) נצטרך כאמור להתקין קודם כל ג׳אווה, העסק פשוט למדי:

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

כעת נצטרך להגדיר את הנתיב למחשב,
נכנס ללוח הבקרה > מערכת ואבטחה > מערכת > הגדרות מערכת מתקדמות > משתני סביבה

נכנס ל path (נתיב),

נחפש בתיקיית הווינדוס איפה ג׳אווה מותקנת, אנו אמורים למצוא שם נתיב ל jdk ושם נמצא bin נעתיק את הנתיב (לדוגמא אצלי זה ב c:porgram Files/Java/jdk/bin )

נדביק אותו בנתיב חדש ב path של משתני הסביבה.

וזוהי סביבת הרצה.

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

(טיפ קטן: למשתמשי IOS יש אפליקציה מעולה לקומפוליזיצייה Java compiler)

משתנים

נפתח את הקומפילייר שלנו, לרוב הקוד הראשוני שלנו צריך להראות כך; אם לא ננקה אותו עד שיראה כזה

public class Main {
public static void main(String[] args)

}

בואו נתרגם מלמעלה , רק כדי להבין קצת מה אנו רואים

בהמשך בפרק על שיטות אנחנו נסביר יותר:

Class = כיתה או מחלקה, בג׳אווה אנחנו מסדרים פעולות במחלקות (לדוגמא תנאי משתנה ופעולה)
Public = מגדיר מי יוכל לגשת למחלקה, public בשונה מ private היא הרשאה פתוחה לשאר המחלקות.
Main = שם המחלקה, זה יכול להשתנות לפי מה שבא לכם לקרוא לשם המחלקה.
static void = אנו מגדירים שהמשתנה או הפונקציה תהיה תלויה במחלקה שלנו ולא באובייקט כזה או אחר.
string args = זה נותן את היכולת להפנות את המחרוזות לארגמנטים עצמאיים. לא נדבר על זה עכשיו יותר מידי (בין היתר כי זה בינתיים לא רלוונטי ודי חובה אם נרצה לתת קלט לתוכנה)

כעת ניגש למשתנים:
משתנה הוא בעצם כשמו, עצם שאינו קבוע, ומשתנה לפי פעילויות,

ישנם שני סוגי ״קטגוריות״ של משתנים:

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

בואו נסדר את כל המשתנים הפרמיטיביים;

1. int מספר עגול עם טווח קטן, כמו 1078
2. char משתנה (להבדיל מסטרינג) של אותיות, כמו a.
3. String מחרוזת. עורכי ה APk מכירים, זה משפט שלם שיכול להכיל מילים ורווחים, כמו ״hello world!”.
4. float מספרים שאינם שלמים, כמו 1.98
5. long כמו int ו float, אך מסוגל להכיל 10 ספרות לפני הנקודה העשרונית.
6. double - דומה ל float עם טווח מספרים ענק.
7. byte כמו int רק עם טווח זעיר. טוב לזכרון קטן.
8. short התאום של byte
9. boolean משתנה שמציג שני ערכים בלבד, אמת או שקר, שיוצגו בדר״כ כ true או false.

אז יאללה, בואו ננסה לכתוב קוד שיכיל משתנה; ונתפוס לשום דוגמא פעולה של חיבור (נשתמש פה בפלט למרות שזה הנושא הבא אבל רק לשם הדגמה)

Public class public class Main {

public static void main(String[] args) {
int number1 = 5, number2 = 1, sum;
sum = number1 + number2;
System.out.println(sum); 

        }

    } 

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

לכן אכתוב -
int אנחנו מבקשים מJava להשתמש במשתנה פרימטבי, של מספר שלם.

עכשיו אנחנו מספרים לה באילו מספרים נשתמש,

הראשון הוא נאמבר 1 שאני רוצה שהערך שלו יהיה נניח 5 לכן נכתוב אותו ככה:
number 1 = 5
השני הוא נאמבר 2 שאני רוצה שיהיה שווה 1 ולכן נכתוב אותו ככה:
number 2 = 1

לאחר מכן אסביר לג׳אווה שאני מעוניין בסכום (=sum) של שני המספרים לכן אכתוב לאחר מכן (sum)

אבל, ג׳אווה אינה יודעת מה זה sum אז אני אסביר לה בפקודה הבאה; sum = number 1 + number 2

לבסוף אבקש פלט של הסכום (נדבר על פלט בהמשך הרבה, רק לדוג׳) של התוצאה בפקודה של System.out.println(sum)

אני מדגיש כאן בסוף כל פקודה בג׳אווה צריך לשים כזה ; ובאמצע פקודה להבדיל צריך פסיק, תבדקו טוב היכן השתמשתי בהם!

אם נריץ את הקוד הנ״ל , נקבל 6, למה? כי ביקשנו מג׳אווה, לחבר שני משתנים ולפלוט לנו את סכום החיבור!

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

אם כן עליי להוסיף סכום נוסף, למשתנים שהגדרתי ולהגדיר שהסכום יהיה חיסור משתנה במשתנה,

לשם דוגמא אני אקרא לסכום השני sum2

אם כן זה יצטרך להראות כך

public class Main {
public static void main(String[] args) {
int number1 = 5, number2 = 1, sum, sum2;

sum = number1 + number2;
sum2 = number1 - number2;
System.out.println(sum); 
 System.out.println(sum2); 
 
        }

    } 

והפלט יהיה:

6
4

ה 6 מייצג את ה sum הראשון שהגדרנו כחיבור, וה 4 מיצג את sum 2 שהוא חיסור.

המדריך בעריכה ויתעדכן מעת לעת בעז״ה

[אליר325000]

קלט ופלט

אז דיברנו בחלק א קצת על פלט, ופקודת הפלט שהצגנו הייתה

system.out.println

למעשה הוספתי את ln לפקודת הפלט הבסיסית, בעוד שפקודת הפלט הבסיסית היא;

system.out.print

מה ההבדל בין שינהם? ובכן ה ln מייצג מעבר שורה בין פלט לפלט; אם לדוגמא יש לי שני פלטים אחד של hallo והשני של world:

אז בפקודה בתוספת ln אקבל;

Hello
World

וללא תוספת זו אקבל;

Helloworld.

עכשיו נדבר על קלט;

ישנה מחלקה מאד מוכרת בג׳אווה לצורך קבלת מידע מהמשתמש (או במונח המכובד ״קלט״); והיא נקראת Scanner

למחלקה זו יש את היכולת לקבל נתון כלשהוא מהשתמש ולפי״ז לקבוע ערך מסויים;

בשלב הראשון עלינו להביא לידיעת ג׳אווה שאנחנו הולכים להשתמש בקלט וזה על ידי פעולת import (המייבאת פקודות ממחלקות אחרות. נדבר בהמשך).

בשלב השני אנחנו ממקמים את הקלט במקום הפעולה.

בואו ניקח דוגמה מהקוד הבא;

import java.util.Scanner;

public class Main {
  
 public static void main(String[] args){
 
       Scanner in  = new Scanner(System.in);
 
       int number1, number2, sum;
       System.out.println("Enter the number");
       number1 = in.nextInt();
       System.out.println("Enter the secind number");
       number2 = in.nextInt()
       in.Close();
       sum = number1 + number2;

       System.out.println sum;
   
 
   }

}

בואו נפרק מה יש לנו כאן:

1. תחילה אנחנו מספרים לג׳אווה שאנחנו הולכים להשתמש בקלט על ידי פקודת ההפנייה:
   import java.util.Scanner;

2. את הפעולה המדוייקת עצמו של הקלט שנלקחת ממחלקת ה scanner

Scanner in = new Scanner(System.in);

2. את המשתנה int שיכיל את המספר שהמשתמש יקיש

3. פלט של סטרינג שמבקש מהמשתמש שיקיש מספר
   System.out.println("Enter the number");

4. קלט שיקלוט מה המשתמש יבחר ויגדיר כנאמבר 1, שימו לב לתחביר;
   number1 = in.nextInt();
   אמרנו לג׳אווה, שמספר 1 יהיה מה שהקלט יקלוט.

5. פלט של סטרינג שמבקש מהמשתמש שיקיש מספר נוסף
   System.out.println("Enter the second number");

6. קלט נוסף שיקלוט מה המשתמש בוחר ויגדיר כנאמבר 2,
   number2 = in.nextInt();

7. חשוב! סגירת הפלט והקלט, כאילו אנחנו אומרים לג׳אווה שיותר לא נשתמש בקליטת מספרים:
   in.Close();

8. הגדרת ה sum כפעולת חיבור

9. פלט אחרון של תוצאה סופית.

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

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

וזה אמור להראות כך;

System.out.println(״המספר הוא״) + sum;

בואו נפרק;

1. פעולת הפלט תפלוט ראשונה סטרינג,
   סטרינג כותבים בסוגריים עגולות וגרשיים;
   (״ככה״)

2. יחד עם תוצאת ה sum.

טיפ לאלופים אתם לא ממש מוכרחים לחבר את הsum בשורה נפרדת, ואז לבקש להדפיס אותו, אתם יכולים לעשות את פעולות החיבור ממש בתוך הפרינט, לדוגמא ככה;

System.out.println(number1 + number2);

[אליר325000]

פעולות חשבוניות נוספות

בשני החלקים הקודמים של המדריך הזכרנו 2 פעולות חשבוניות.

חיבור;

number1 + number2

וחיסור

number1 - number2

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

כפל

מסומן בכוכבית *

number1 * number2

חילוק

מסומן ב back slash [להבדיל מסלאש - \ רגיל]

number1 / number2

שארית החלוקה
מסתמנת באחוז

number1 % number2

מה זה שארית החלוקה?

לשם דוגמא

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

1. אני אתן לג׳אווה את המספר [או שהקלט יתן...]

2. אצווה על ג'אווה לבדוק לי כמה תוצאת שארית רחוקה משתיים,

כעת ג'אווה תבדוק את המרחק בין 2 לשארית,

אם אין מרחק מספרי, כי המספר לא השאיר שארית, אז ג'אווה תגיד שהמרחק הוא 0 ואני יבין שהוא זוגי, כי הוא התחלק לחלוטין בשתיים,

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

בואו נתפוס דוגמא

אני אקח את המספר 7

ג'אווה תחלק בשתיים ותקבל 3

ג'אווה תבדוק אם התוצאה מתחלקת בשתיים

ותודיע לי שחסר לי 1 כדי להשלים את המספר לכך שהוא יתחלק בשתיים [4]

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

אם נתמצת את משמעות שארית החלוקה במשפט,
מטרתה של שארית החולקה היא סה"כ לבדוק לי כמה רחוק מספר מסויים [נניח 7] ליהות מספר שמתחלק במספר שהנחתי אותו [נניח 2, והתוצאה תהיה 1, כי הוא רחוק ב1 כדי להתחלק ב 2].

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

שיעורי בית :

כתבו קוד, שכאשר מזינים לו את מספר הימים בעומר, לדוגמא 12 הוא יגיד כמה שבועות שלמים יש במספר,

למתקדמים תוסיפו שיכיל גם את שארית הימים,

אני אתן לכם בקצרה מה תצטרכו בשביל זה:

1. משתנה int
   2.קלט
2. תרגיל מתמטי של אחוז החלוקה
3. פלט
4. למתקדמים: משתנה double

[אליר325000]

תנאי

אחד הדברים הכי חשובים בתוכנה היא תנאי, ואם אני לא טועה בכל השפות המבוססת c תנאי מוגדר ב;

If

כאשר ארצה פעולה שהתנאי לא יתבצע הוא יסומן כך;

else

רגע לפני הדוגמא

אני אסדר לכם פה כמה סוגי בדיקות;

הכלה

=

זה שווה במובן של תוצאה, כאילו אני אומר למישהו ״פעולתך שווה מדלייה״ ולא במובן של ערך מספרי שיוויוני.

1. בדיקת שיוויון

==

פשוטו כמשמעו, שווה

2. גדול מ:

<

דהיינו אנחנו בודקים אם התוצאה גדולה מהמספר המוגדר

3. קטן מ:

>

דהיינו אנחנו בודקים אם התוצאה קטנה מהמספר המוגדר

4. גדול או שווה ל:

>=

דהיינו אנחנו בודקים אם התוצאה גדולה או שווה למספר המוגדר

קטן או שווה ל:

<=

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

ועכשיו נסביר יותר;
תנאי בעצם מבקש מג׳אווה לבדוק משהו, לדוגמא, אם x שווה y אז כך, ואם לא אז כך,
אני אביא לשם דוגמא תנאי שמכיל את מה שלמדנו, שבודק אם המספר של הקלט הוא המספק שג׳אווה מכירה, ונפרק אותו;

import java.util.Scanner;

public class Main {
  
 public static void main(String[] args){
 
       Scanner in  = new Scanner(System.in);
 
 
       int number;
       System.out.println("1 + 1");
       number = in.nextInt();
       
       if(number == 2){
       
                System.out.println("good!");
                
                }else{
                
                System.out.println("no!");
                
                }
       
        In.close();
 
   }

}

בואו נפרק:

1. הכנסנו משתנה, בשביל שיכיל מספר, scanner שיקלוט מספר משתמש, ופלט שיבקש מהמשתמש לענות על התרגיל ״1 + 1״ ויקבל קלט של תוצאה,
2. if(number == 2){
   מה עשינו כאן?
   אמרנו לג׳אווה if (אם) המספר של המשתנה (שמוגדר לפי מה שנקלט) שווה אחד, אזי התוצאה הישירה תהיה פלט של "Good!" כי זה אומר שהוא צדק
3. else

פעולת ה else היא פעולה במקרה שהתנאי לא יתבצע', ולכן אם המשתמש יקיש 2 לדוג', שזה לא שווה ערך למספר המוגדר [1] אזי התוצאה הישירה תהיה פלט של "no!"

חשוב ביותר למי שלא שם לב, בתחילת תנאי יש סוגריים מסולסלות [לבד מהסוגריים המסולסלות של כל הדף] שמתחילים { לפני התנאי [if] ונגמרים אחריו } לפני ה
else

גם לפני ה else יש סוגריים מסולסלות שנפתחות לפניו ונסגרות אחריו.

בספויילר כתבתי קצת על סוגריים מסולסלות.

Spoiler

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

שיעורי בית:

כתבו קוד, שכאשר מזינים לו מספר הוא בודק אם הוא זוגי או לא,

אני אתן לכם בקצרה מה תצטרכו בשביל זה:

1. משתנה int
2. קלט
3. תרגיל מתמטי של אחוז החלוקה
4. תנאי
5. פלט

[אליר325000]

לולאה (לולאת for)

מה זה לולאה?

לולאה היא פעולה כשמה, פעולה שעובדת בלולאה, ולא עוצרת, אחר משהו אחד.

ניקח לדוגמא מקרה שאני אצטרך בו חישוב של מאה משתנים, האם זה אומר שעליי להקצות 100 משתנים?

(זה המון, ומה יהיה באלף? ובמיליון? ועשרות מיליון?, קחו לדוגמא את עלי אקספרס תארו לכם שכל מוצר הוא משתנה, והכמות שנכנסת היא אינסופית…)

בדיוק בשביל זה יש את הלולאה;

לולאה נועדה לומר לג׳אווה להמשיך את הפעולה עד שלב מסויים.

אנחנו נשתמש בלולאת for

לולאה עובדת בשלושה שלבים;

1. משתנה התחלתי
2. משתנה סופי
3. פעולה שהתוכנית חוזרת ללולאה

הנה דוגמא ללולאה ופעולה;

for (int number=1; number<50; number ++)

System.out.println(“n”);

בואו נפרק;

for = שם הלולאה
int number = 1 = מאיזה משתנה הלולאה מתחילה, במקרה שלנו 1
int number<50 = סוף הלולאה נעצרת כל עוד המספר קטן מ50
number++ = מה יקרה במהלך הלולאה, במקרה שלנו פלוס פלוס, מסמל את ההוספה של המספר פעם אחת בכל לולאה
System.out.println(“n”). = הפעולה עצמה.

[אם שמתם לב, לולאת for היא דווקא במקרה שאני יודע את מספר הלולאות...]

לסיכום הלולאה הנ״ל תדפיס לנו 50 פעם את הסטרינג “n”.

בואו נקח דוגמא ללולאת for עם פעולה טיפה יותר מורכבת,

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

כידוע, [אני מקווה!!!] ממוצע נמדד על ידי חיבור כל הסכומים לסכום אחד, ולחלק במספר הסכומים.

בואו נכתוב את הקוד הבא ונפרק:

import java.util.Scanner;

public class Main {

    public static void main(String[] args){
        Scanner in = new Scanner(System.in);
        int number, sum = 0;
        double avg;

        for(int a = 1 ; a <= 10 ; a++){
            System.out.println("enter is the number ");
            number = in.nextInt();
            System.out.println("Succesfully! " + number);
            sum += number;
        }

        avg = (double)sum / 10;

        System.out.println("your result " + avg);

    }

}

בואו נפרק מה היה לנו כאן:

1. הגדרנו את ספריית הקלט.

2. ביקשנו שני משתנים מסוג int, וקראנו להם בשתי שמות [אגב אתם יכולים לכנות משתנה באיזה שם שבא לכם]:

   1. number: שיכיל את המספר שהמשתמש יזין
   2. sum: שיכיל את סכום הכולל של כל המספרים
      שימו לב: הגדרתי את ה sum לאפס, כי זוהי נקודת ההתחלה.

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

4. כעת ניגשנו ללואת ה for ונתנו לה את השם a וכאמור כתבנו בה שלושה פעולות:

   1. נקודת ההתחלה:a = 1
   2. כמה פעמים נריץ את הלולאה: = a <= 10
   3. מה יקרה במהלך הלולאה: = a ++

5. הגדרנו את הפלט, של בקשת הזנת המספר, קלט למספר, ושוב פלט, שהתקבל הקלט.

6. לאחר הפעולה, ביקשתי מג'אווה sum += number שתחבר את הסכום ל משתנה אחיד, [כך כל כל פעם שהלולאה תרוץ]

[זהו קיצור מפורסם בג'אווה שמבצע הוספה והקצאה בשלב אחד. דהיינו זה מוסיף את הערך בצד החדש בתרגיל, (number במקרה שלנו) לערך בצד הראשוני (sum) ומקצה את התוצאה בחזרה למשתנה בצד הראשוני, וכך ה sum גודל לערך חדש.

7. כעת לולאת ה for תרוץ עשרה פעמים, את כל הפעולה הנמצאת בסוגריים המסולסלות שלה.

8. לאחר כל הפעולה אבקש מג'אווה, avg = (double)sum / 10 דהיינו אני ממיר את הsum שהוא int למשתנה double המכיל גם שברים, ומחלק בעשר, כמספר המספרים.

9. זהו, כעת הגדרתי פלט של התוצאה הסופית.

יפה! אתם יודעים לכתוב לולאה מסוג for!

[אליר325000]

לולאת while

בחלק הקודם דובר על לולאת for, החיסרון בלולאה זו שהיא לולאה המוגדרת כמספר הפעמים המוגדר מראש, ומה יהיה שלא יהיה מוגדר מראש דבר?

אז נשתמש בלולאה הבאה,
הידועה בשמה:

while loop

[מסתמא אתם יודעים מה זה לופ...]

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

אז בלולאת while נצטך לבצע תנאי התחלה, ותנאי עצירה, דהיינו שכל עוד תנאי העצירה לא מתקיים הלולאה תרוץ.

בואו נקח דוגמא לולאת while וננתח,

נשתמש בדוגמא הקודמת [כמו בלולאת for] של ממוצע מספרים, אבל ללא סיום מותנה מראש:

בואו נכתוב את הקוד הבא ונפרק:

import java.util.Scanner;

public class Main {

    public static void main(String[] args){
        Scanner in = new Scanner(System.in);
        int number, sum = 0, numerate = 0;
        double avg;

      System.out.println("Enter the number");
       number = in.nextInt();

      while(number != -1){   
      numerate++;  
      sum+=number;

      System.out.println("Enter the other number");
      number = in.nextInt();

        }
        
        if(numerate != 0){
        avg = (double)sum / numerate;

        System.out.println("your result " + avg);
     
       }

    }

}

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

בואו נפרק את הקוד:

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

2. הפעם השתמשנו בשלושה משתנים מסוג int, ולא בשתיים כמו בלואלת for.

שימו לב:
1) במשתנה אחד בשם number שיכיל את הערך הנכנס בדיוק כמו שעשינו בלואלת for.
2) משתנה נוסף שמוכר לנו מקודם הוא מה שקראנו בשם sum שנועד להכיל את הערך הכולל של סכום המספרים, כמו מקודם, כמובן שאתחלנו אותו לאפס.
3) יצרנו משתנה נוסף, שלא היה בלולאת for בשם numerate שהוא יכיל את כמות המספרים שנקלטו במערכת, דהיינו כל הזנה נוספת של מספר המשתנה יעלה באחד, שימו לב, שגם אותו איתחלנו לאפס.

3. הוספנו כמובן משתנה מסוג double בשביל הממוצע הסופי שיכיל גם שברים.

4. הזנו פלט, שיבקש מהשתמש להזין את המספר הראשון שלו, ולאחריו קלט שיקלוט כמה בחר המשתמש.

5. עכשיו הגענו להגדרת לולאת ה while, תבחנו היטב את מבנה הלולאה,

שלב ראשון - תנאי עצירה:

while(number != -1)

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

שלב שני - פעולה:

numerate++

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

6. פלט נוסף למספרים הבאים, וכמובן קלט.

7. הוספנו תנאי:

if(numerate != 1)

התנאי הזה בעצם אומר שסך המספרים המינמליים לחישוב הממוצע יהיה שונה מאפס. [בעצם אחד ומעלה]

(כפי שמתם לב "שונה מ" מסומן בג'אווה ב סימן קריאה ושווה [=!] .

8. לסיום ביקשנו שג'אווה תחלק את המשתנה של הנקלט [sun] בסך המספרים [numerate], ותפלוט אותו למשתמש.

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

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

בשלוש מילים: יצרנו לולאה מסוג while, תנאי העצירה שלה הוא הזנת המספר - 1, כל עוד לא יזינו סכום זה היא תרוץ.

[אליר325000]

מערכים

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

מערך הוא בעצם כלי שיוצר לי סדרה של משתנים מאותו הסוג [להלן תאים], ואז נוכל לפנות לכל משתנה לפי מספר המשתנה שבו.

בעצם מערך צריך שלושה פרמטרים.

1. המשתנה שיכיל את המערך, מסומן במשתנה שלאחריו סוגריים מרובעים [] סגורים, כדי להכריז על המערך.

2. הגדרת סכום המערך, הוספת מספר תאים [כל מספר הוא תא], נכתב בשם new int[xxx], ובאיקסים נכתוב את כמות התאים הנצרכת לנו.

3. אתחול המערך לרוב [תציצו בספויילר] עליי לאתחל את המערך שיתחיל ממספר מסויים ויסיים במספר סופי, אחרת כל המשתנים יהיו בעלי ערך אחד [אצלינו 0]. כעיקרון אפשר להגדיר כל תא באופן ידני, אך במקרה כזה העבודה תהיה קשה, ולכן מומלץ לעבוד עם לולאות, כפי שנפרט בהמשך.

Spoiler

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

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

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

אז, אתחול המערך עם ערכים אינו חובה, אבל זה יכול להיות נוח אם אתה כבר יודע את הערכים ההתחלתיים שאתה רוצה לאחסן במערך.

בואו נציץ במערך של 100 תאים, מאותחל מ0 ל - 99:

public class Main {

    public static void main(String[] args) {

        int[] number;
        number = new int[100];

        for(int i = 0; i<number.length; i++) {
            number[i] = i;
            }
       } 
    }

בואו נפרק:

1. int[] number = יצרתי משתנה אם סוגריים סגורים להודיע על המערך.

2. number = new int[100] הגדרתי את המערך שיהיה בן מאה תאים.

3. אתחלתי את המערך על ידי לולאת for ושימוש ב length

א. ראשית הגדרתי לולאה מסוג for [אתם אמורים כבר להבין למה].
ב. בלולאה כינתי את הפעולה הראשונה של הגדרת המשתנה באפס. i = 0
ג. לאחר מכן הגדרתי את מספר פועלות הלולאה, שיהיה שווה ערך לקטן מ length שזה בעצם המקום שג'אווה מאכסנת את מספר התאים המוגדרים במערך. i<number.length.

[הסיבה שהגדרתי קטן מ, ולא שווה ל, זה מסיבה פשוטה, שאין לנו מאה תאים, למרות שהגדרנו את המספר מאה, מסיבה פשוטה, שהתא הראשון מתכנס ב 0, כי אין לנו מ 1 ועד מאה, אלא מ 0 ועד מאה.]

ד. השלב האחרון בלולאה הוא ה i++ שבעצם גורם לולאה להוסיף מספר סידורי מ0 ועד מאה [לא כולל] לכל תא במערך. כזכור פלוס פלוס זה הוספת הערך למספר העצמי.

ה. לאחר מכן ניתן "שמות" לכל תא, וזה ע"י השורה number[i]= i; דהיינו שמספר ה i יהיה שווה לשמו של ה i, וממילא לתא במערך.

אם תרצו לראות את הדפסת כל התאים במערך תוסיפו לולאת הדפסה כזו לדוגמא:

    for (int i = 0; i < number.length; i++) {
        System.out.println(number[i]);

[אליר325000]

פעולות (או: שיטות)

שיטה - method או פעולה: היא בעצם השם של מכלול אוסף הפקודות שאנחנו כותבים בכל מחלקה, הרווח העיקרי בלקטלג ולתת לפעולה שם, הוא כך שאם נצטרך להשתמש שוב באוסף הפקודות נוכל להשתמש בהם בקיצור, מה שמאפשר תכנות קל ואינטלגנטי יותר.

הפעולה נכתבת בתבנית כדלהלן:
[צירפתי הסבר תמציתי סביב כל שורה, ומה שלא דיברנו עליו עד עכשיו, ואינו מובן לא נורא, אנחנו נאריך עליו בהמשך אי"ה]

1. ראשית את הפעולה [השם שהשתמשנו עד עתה הוא main].

public class main

2. לאחר מכן את החתימה של הפעולה:

ראשית היא מכילה את תחילת הפעולה:

public

לאחר מכן, מקדם, שמכיל פעולה סטטית או לא:

static

ולאחר מכן, התיאור של מה שמחזירה הפעולה:

void

שם הפעולה

main

ומה הפעולה מקבלת:

(String[] args)

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

וזהו בעצם הקוד הבסיסי שמוכר לנו מכל פתיחת פרוייקט חדש, המכיל פעולה:

public class Main
public static void main(String[] args) {
   
}

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

הנה דוגמא של פעולת אחת שהיא הפעולה הראשית, שמחוץ לה פעולה נוספת שהיא פעולת חיבור, לצורך שימוש מקוצר בפעולה:

import java.util.Scanner;

public class Main {

    public static void main(String[] args) {

        Scanner in =new Scanner(System.in);

        int n1, n2, sum;

        System.out.println("Enter the number 1 ");
        n1 = in.nextInt();
        System.out.println("Enter the number 2 ");
        n2 = in.nextInt();

        sum = SumAll(n1,n2);
        System.out.println(sum);

        in.close();

    }

מכאן והילך זה הפעולה [הכל בדף אחד, הפרדתי כדי שתשימו לב]

    public static int SumAll(int number1, int number2){

        return number1 + number2;
    }
}

בואו נפרק מה היה בקוד שלנו:

1. אנחנו מייבאים את החבילה "java.util.Scanner" שמכילה כלים לקריאה מהקלט.
2. אנחנו מגדירים מחלקה ראשית בשם "Main".
3. מגדירה בתוך המחלקה את השיטה הראשית "main" שהיא נקודת הכניסה לתוכנית.
4. יצרנו את פעולת "Scanner" בשם "in" שתשמש לקריאה מהקלט.
5. אנחנו מגדירים משתנים שלמים בשמות "n1", "n2" ו-"sum".
6. ג'אווה מדפיסה למסך את הודעה "Enter the number 1 ".
7. אנחנו מבקשים מהמשתמש את המספר הראשון וג'אווה שומרת אותו במשתנה "n1".
8. ג'אווה מדפיסה למסך את הודעה "Enter the number 2 ".
9. אנחנו מבקשים מהמשתמש את המספר השני ושומרת אותו במשתנה "n2".
10. ג'אווה מחזירה את השיטה "SumAll" עם הפרמטרים "n1" ו-"n2" ושומרת את הערך המוחזר במשתנה "sum".
11. ג'אווה מדפיסה את הערך של "sum" למסך.
12. סגרנו את הקלט של "Scanner" באמצעות השיטה "close" כדי לחסוך משאבי זכרון.
13. בסיום פעולת main כתבנו את הפעולה של החיבור כיניתי אותה "SumAll", והפעולה כוללת 2 משתנים, לאחר מכן היא מקבלת כל שני מספרים שלמים למשתנים, ובאמצעות return מחזירה את סכומם.

לסיכום: יצרנו פעולה צדדית [קראתי SumAll אתם יכולים לקרוא לכל פעולה, באיזה שם שתרצו] שתכיל 2 משתנים, ותחבר אותם, כך שיש שני משתנים, כמו בדוגמא שלפנינו נוכל לייבא את הפעולה עם 2 המשתנים ונקבל את הערך שלהם.

Spoiler

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

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

הערה חשובה: משתנים שלא נמצאים בתוך פעולות, כמו בדוגמא הנ"ל של n1 ו n2 שנמצאים מחוץ לפעולה, לאחר החיבור עם הפעולה הם לא ישתנו בפעולה הראשית, דהיינו הם ישארו בערך שלהם.

פעולת void

פעולה נוספת אפשר לייצר בג'אווה והיא פעולת void

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

פעולה ה void כך:

public static void print(String s)
System.out.println(s)

כעת כל פעם שאני אביא את הפעולה בשמה בלבד (print) היא תביא את כל הפקודה של system out println.

כהערת אגב יש לציין הכללים הנהוגים לגבי שמות השיטות הוא לתת לשיטות שם שמתאר את תפקידן בקצרה, כדי להקל על הבנת הקוד בעתיד. ב-Java נהוג לתת לשיטות שמות שמתחילים באות קטנה. אם שם השיטה מורכב מכמה מילים, האות הראשונה בכל מילה תהייה גדולה. דוגמה: PrintAll.

באנגלית מכונה צורת כתיבה זו Camel Case (זאת, מפני שהאותיות הגדולות הנמצאות באמצע המילה יוצרות קו מתאר שמזכיר את גבו של הגמל (camel), כאשר האותיות הגדולות הן הדבשות).

מקור לזה בין היתר מצאתי בויקי ספר.

[אליר325000]

מחזוריות ופעולות כפולות

כאשר אנחנו מעוניים לעשות כמה פעולות שונות, אבל שהפעולה שלהם זהה, אנחנו יכולים ליצור כמה מהם, הנה דוגמא:

import java.util.Scanner;

public class Main {

    public static void main(String[] args) {

        Scanner in = new Scanner(System.in);

        int n1, n2, n3, sum;

        System.out.println("Enter the number 1 ");
        n1 = in.nextInt();
        System.out.println("Enter the number 2 ");
        n2 = in.nextInt();
        System.out.println("Enter the number 2 ");
        n3 = in.nextInt();

        sum = SumAll(n1,n2);
        System.out.println(sum);
        
        sum = SumAll(n1,n2,n3);
        System.out.println(sum);
        

        in.close();

    }
    public static int SumAll(int number1, int number2){

        return number1 + number2;
    }
    public static int SumAll(int number1, int number2, int number3){

        return number1 + number2 + number3;
    }
}

אם תשימו לב זה בדיוק כמו הפעולה הקודמת שהבאתי למעלה,

רק שהוספתי עוד פעולת static נוספת:

• גם היא נקראת sumall והפעולה שלה לחבר את הערכים, ההבדל היחיד, שהפעולה הראשונה היתה חיבור של שניים, והיא חיבור של שלושה.

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

[אליר325000]

אפשר להגיב בפרטי. בשמחה.