תחביר Java: מבוא קצר לשפת התכנות

מהו תחביר ג'אווה?

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

אובייקטים ב-Java

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

שיעור בג'אווה

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

שיטות ב-Java

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

משתני מופע ב-Java

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

תוכנית פשוטה ב-Java: שלום, Java!

להלן התוכנית הפשוטה ביותר ב-Java:

class HelloJava {
   public static void main(String[] args) {
       System.out.println("Hello, Java!");
   }
}

תוכנית זו מציגה את המחרוזת "Hello, Java!" בקונסולה. אני ממליץ לך להתקין JDK ו-IntelliJ IDEA ולנסות לכתוב את הקוד מהדוגמה הזו. או בפעם הראשונה, פשוט מצא IDE מקוון כדי לעשות זאת. כעת ננתח את התוכנית הזו שורה אחר שורה, אך נשמיט כמה פרטים שאינם נחוצים למתחילים.

class HelloJava

כל תוכנית ג'אווה היא מחלקה, או לעתים קרובות יותר קבוצה של מחלקות. שורת הכיתה HelloJava פירושה שאנו יוצרים מחלקה חדשה בשם HelloJava . כפי שנאמר לעיל, מחלקה היא סוג של תבנית או שרטוט; היא מתארת ​​את ההתנהגות והמצבים של אובייקטים של המחלקה. זה עשוי להיות קשה למתכנתים חדשים, אבל אל דאגה: את המושג הזה תלמדו קצת מאוחר יותר. לעת עתה, שיעור HelloJava הוא רק ההתחלה של התוכנית שלך. אולי שמתם לב לסד המתולתל { באותה שורה ולאורך כל הטקסט. זוג סוגרים מסולסלים {} מציינים בלוק, קבוצה של הצהרות הניתנות לתכנות שמתייחסות אליהן כיחידה אחת. כאשר { פירושו תחילת הבלוק, ו- } סופו. בלוקים יכולים להיות מקוננים זה בתוך זה, או שהם יכולים להיות עוקבים. ישנם שני בלוקים מקוננים בתוכנית לעיל. החיצוני מכיל את גוף מחלקת Hello . הבלוק הפנימי מכיל את הגוף של השיטה main() .

public static void main (String args []) {

הנה תחילתה של השיטה העיקרית . שיטה היא התנהגות או רצף של פקודות המאפשרים לבצע פעולה בתוכנית. לדוגמה, הכפל שני מספרים או הדפס מחרוזת. במילים אחרות, שיטה היא פונקציה. בשפות תכנות אחרות, שיטות נקראות לעתים קרובות "פונקציות". שיטות, כמו כל הרכיבים של תוכנית Java, ממוקמות בתוך מחלקה. לכל מחלקה יכולה להיות מתודה אחת, מספר מתודה, או ללא מתודה כלל. ציבורי - משנה גישה. ניתן לגשת למשתנה, שיטה או מחלקה המסומנים ב- Public Modifier מכל מקום בתוכנית. בג'אווה יש ארבעה מהם: ציבורי, פרטי, מוגן וברירת מחדל - כברירת מחדל (ריק). נדבר עליהם קצת מאוחר יותר. מלכתחילה, עדיף לפרסם את כל השיטות שלך. void הוא סוג ההחזרה של השיטה. בטל פירושו שהוא לא מחזיר שום ערך. main מייצג את נקודת ההתחלה של התוכנית. זה שמה של השיטה. String[] args הוא הטיעון העיקרי של השיטה. לעת עתה, מספיק לדעת שכמעט לכל תוכנת Java יש שיטה ראשית : היא מריץ את התוכנה ומוכרזת כ- public static void main(String[] args) . שיטות סטטיות (סטטיות) מיועדות לעבוד עם מחלקה. שיטות המשתמשות במילת המפתח הסטטית בהצהרה שלהן יכולות לפעול ישירות רק על משתנים מקומיים וסטטיים.

System.out.println("Hello, Java!");

רשמית, שורה זו מבצעת את שיטת println של אובייקט ה-out . אובייקט ה-out מוצהר במחלקה OutputStream ומאוחל סטטית במחלקה System . עם זאת, זה עשוי להיראות קצת קשה למתחילים. אם אתה רק לומד, מספיק לדעת שהשורה הזו מדפיסה את המילים "שלום, ג'אווה!" בקונסולה. אז אם תפעיל את התוכנית בסביבת הפיתוח שלך (IDE), תקבל פלט כך:

כללי תחביר בסיסיים של Java

ישנם מספר כללי תחביר בסיסיים שיש לפעול לפיהם בעת תכנות ב-Java:

• שם הקובץ חייב להתאים לשם המחלקה;
• לרוב, כל מחלקה נמצאת בקובץ נפרד עם סיומת .java . קבצי כיתה מקובצים בדרך כלל לתיקיות. תיקיות אלו נקראות חבילות;
• התווים הם רגישים לאותיות גדולות. מחרוזת אינה שווה למיתר ;
• תחילת עיבוד תוכנית Java מתחילה תמיד בשיטה הראשית: public static void main (String [] args) . השיטה main() היא חלק נדרש מכל תוכנית Java;
• שיטה (פרוצדורה, פונקציה) היא רצף של פקודות. שיטות מגדירות התנהגות על אובייקט;
• סדר השיטות בקובץ התוכנית אינו משנה;
• זכור שהאות הראשונה של שם הכיתה חייבת להיות באותיות גדולות. אם אתה משתמש במספר מילים, השתמש באות רישיות באות הראשונה של כל מילה (לדוגמה, "MyFirstJavaClass");
• כל שמות השיטה בתחביר Java מתחילים באות קטנה. בעת שימוש במספר מילים, האותיות הבאות מופיעות באותיות גדולות ( public void myFirstMethodName () );
• קבצים נשמרים עם שם המחלקה וסיומת .java ( MyFirstJavaClass.java );
• לתחביר Java יש מפרידים {...} שמציינים גוש קוד ואזור חדש של קוד;
כל משפט קוד חייב להסתיים בנקודה-פסיק.

משתני Java וסוגי נתונים

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

• מספרים שלמים: byte , short , int , long
• מספרים שברים : צפים וכפולים
• ערכים בוליאניים: בוליאניים
• ערכי תווים (לייצג אותיות ומספרים): char

דוגמה למשתנים ב-Java:

int s;
s = 5;
char myChar = ‘a’;

בקוד זה, יצרנו משתנה שלם s (מיכל ריק) ולאחר מכן הכנסנו לתוכו את הערך 5. אותו סיפור עם המשתנה myChar . יצרנו אותו עם סוג הנתונים char והגדרנו אותו בתור האות a . במקרה זה, יצרנו משתנה והקצינו לו ערך בו-זמנית. תחביר Java מאפשר לך לעשות זאת בדרך זו. סוגי הפניות הם כמה אובייקטים המכילים הפניות לערכים או לאובייקטים אחרים. הם עשויים להכיל גם הפניה ל-null. Null הוא ערך מיוחד שפירושו שאין ערך. סוגי הפניות כוללים מחרוזת , מערכים וכל מחלקה שתרצה. אם יש לך מחלקה לכינור ( כינור ), תוכל ליצור משתנה עבור אותה מחלקה. דוגמה למשתני סוג התייחסות ב-Java:

String s = “my words”;
Violin myViolin;

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

int i = 25;
String s = “Hello, Java!”;

מערכים ב-Java

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

int[] myArray = {1,7,5};

כאן יש לנו מערך המכיל שלושה מספרים שלמים (1,7 ו-5).

Enums ב-Java (Java Enums)

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

enum DayOfWeek {
     MONDAY,
     TUESDAY,
     WEDNESDAY,
     THURSDAY,
     FRIDAY,
     SATURDAY,
     SUNDAY
}

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

דוגמה לספירה ב-Java (Java Enum)

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

        Day myDay = DayOfWeek.FRIDAY;
        System.out.println(myDay);	//напечатать день из enum
}
}
enum DayOfWeek{

    MONDAY,
    TUESDAY,
    WEDNESDAY,
    THURSDAY,
    FRIDAY,
    SATURDAY,
    SUNDAY
}

אם תפעיל את התוכנית, הקונסולה תציג FRIDAY. אתה יכול לשים את הקוד למחלקות Enum ו- MyNum בקובץ אחד, אבל עדיף ליצור שני קבצים נפרדים: אחד למחלקה MyNum ואחד לרשימת ימי השבוע (Day). IntelliJ IDEA מאפשר לך לבחור מנה בעת יצירתו.

הכרזה על משתנים ב-Java

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

int i;
boolean boo;

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

דוגמה להצהרת משתנה

String str;
int i = 5;
Str = “here is my string”;

אם אתה מכריז על משתנה ללא אתחול, הוא עדיין יקבל ערך ברירת מחדל כלשהו. עבור int ערך זה הוא 0, עבור String או כל סוג התייחסות אחר זהו המזהה המיוחד null .

מזהים ב-Java

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

Class Violin {
int age;
String masterName;
}

כינור - מזהה כיתה. age ו- masterName הם מזהים משתנים. הנה כמה כללי מזהה של Java:

• כל המזהים מתחילים באות לטינית (A עד Z או a עד z), סמל מטבע ($) או קו תחתון (_);
• לאחר התו הראשון, המזהים יכולים לכלול כל שילוב של תווים;
• מילת מפתח Java לא יכולה להיות מזהה (תלמד על מילות מפתח מעט מאוחר יותר);
• מזהים הם תלויי רישיות.

דוגמאות למזהים

מזהים חוקיים: java, $mySalary, _something מזהים לא חוקיים: 1stPart, -one

משנה ב-Java

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

דוגמאות לשינויי גישה

ישנם ארבעה מגדי גישה ב-Java:

• ציבורי _ אלמנט פתוח. ניתן לגשת אליו מתוך הכיתה, מחוץ לכיתה, בתוך החבילה ומחוצה לה;
• ניתן לגשת לרכיב עם שינוי ברירת המחדל - ברירת מחדל (ריק) - רק בתוך החבילה;
• מתקן מוגן - ניתן לגשת בתוך החבילה ומחוצה לה דרך כיתת ילדים;
• private - האלמנט נגיש רק בתוך המחלקה שהוא מצהיר.

דוגמאות למתאמים אחרים

ישנם שבעה מתקנים אחרים (עבור מחלקות, שדות, שיטות, ממשקים וכן הלאה):

• סטָטִי
• סופי
• תַקצִיר
• מסונכרן
• חולף
• נָדִיף
• יָלִיד

מילות מפתח של Java

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

• abstract : מילת מפתח להכרזה על מחלקה מופשטת;
• boolean : מילת המפתח הבוליאנית ב-Java נחוצה כדי להכריז על משתנה מסוג בוליאני. משתנים כאלה יכולים להיות רק נכונים או שקריים;
• break : מילת המפתח break ב-Java משמשת לשבירת לולאה או הצהרת switch ;
• byte : מילת המפתח בייט ב-Java נחוצה כדי להכריז על משתנה של מספר שלם של בית אחד;
• מקרה : משמש עם הצהרות switch לסימון בלוקים של טקסט;
• catch : משמש לתפיסת חריגים לאחר חסימת ניסיון ;
• char : מילת המפתח char ב-Java משמשת למשתנה תו. יכול להכיל תווי Unicode 16 סיביות לא חתומים;
• class : מילת המפתח המחלקה ב-Java נחוצה כדי להכריז על מחלקה;
• להמשיך : מילת מפתח Java להמשך לולאה;
• default : מילת המפתח המוגדרת כברירת מחדל ב-Java משמשת לציון גוש קוד ברירת מחדל בהצהרת switch ;
• do : בשימוש במבנה לולאת עשה תוך כדי ;
• double : מילת המפתח הכפולה ב-Java נחוצה כדי להכריז על משתנה מספרי. יכול להכיל מספרי נקודה צפה של 8 בתים;
• else : ניתן להשתמש בהצהרות else-if מותנות;
• enum : משמש להגדרת קבוצה קבועה של קבועים;
• extends : מילת המפתח extends ב-Java משמשת לציון שמחלקה מרחיבה מחלקה אחרת (היא כיתת ילד של מחלקה אחרת);
• final : מילת מפתח כדי לציין שהמשתנה הוא קבוע;
• לבסוף : מסמן גוש קוד שיבוצע בין אם החריג יטופל או לא;
• float : משתנה המכיל מספר נקודה צפה של 4 בתים;
• for : מילת מפתח להפעלת לולאת for . הוא משמש לביצוע שוב ושוב קבוצה של הוראות כל עוד מתקיימים תנאים מסוימים;
• if : מילת מפתח לבדיקת התנאי. זה מבצע את החסימה אם התנאי נכון;
• מיישם : מילת מפתח ליישום הממשק;
• import : מילת המפתח ייבוא ​​ב-Java משמשת לייבוא ​​חבילה, מחלקה או ממשק;
• instanceof : בודק אם אובייקט הוא מופע של מחלקה או ממשק מסוים;
• int : משתנה שיכול להחזיק מספר שלם בסימן של 4 בתים;
• interface : מילת המפתח של ממשק ב-Java משמשת להכרזה על ממשק;
• long : משתנה שיכול להחזיק מספר שלם בסימן 8 בתים;
• native : מציין שהשיטה מיושמת בקוד מקורי באמצעות JNI (Java Native Interface);
• new : מילת המפתח החדשה משמשת ב-Java ליצירת אובייקטים חדשים;
• package : מכריז על חבילת Java (תיקיה) עבור קבצי מחלקות Java;
• private : משנה הגישה מציין שהמתודה או המשתנה יכולים להיראות רק על ידי המחלקה שבה הוא מוצהר;
• protected : משנה גישה המציין שניתן לגשת למתודה או למשתנה בתוך החבילה ומחוצה לה דרך כיתת ילד;
• public : משנה הגישה מציין שהאלמנט נגיש בכל מקום;
• return : מחזירה את התוצאה של ביצוע השיטה;
• קצר : משתנה שיכול להחזיק מספר שלם בסימן של 2 בתים;
• static : מציין שהמשתנה או המתודה הם מחלקה ולא אובייקט או מתודה;
• strictfp : מגביל חישובי נקודה צפה;
• super : מתייחס לאובייקט של מחלקת האב;
• switch : בוחר גוש קוד (או כמה מהם) לביצוע;
• מסונכרן : סוג אחר של משנה. זה מציין שניתן לגשת למתודה רק על ידי שרשור אחד בכל פעם;
• זה : מתייחס לאובייקט הנוכחי בשיטה או בנאי;
• throw : משמש לזרוק חריג במפורש;
• זורק : מכריז על חריג;
• לא ניתן לבצע קטע נתונים חולף בסידרה;
• try : מריץ גוש קוד שנבדק עבור חריגים;
• void : מציין שהשיטה לא מחזירה ערך;
• volatile : מציין שניתן לשנות את המשתנה באופן אסינכרוני;
• while : מתחיל לולאת while . חוזר על חלק מהתוכנית מספר פעמים כאשר התנאי מתקיים.

הערות ב-Java

Java תומכת בהערות בשורות בודדות ובריבוי שורות. כל התווים זמינים בתוך כל הערה ומהדר Java מתעלם מהם. מפתחים משתמשים בהם כדי להסביר קוד או לזכור משהו. דוגמאות להערות:

//однострочный комментарий
/*а вот многострочный комментарий. Как видите, в нем используются слеши и звездочки в начале и в конце.*/

public class HelloJava {
   /* эта программа создана для демонстрации комментариев в Java. Это многострочный комментарий.
   Вы можете использовать такие комментарии в любом месте вашей программы*/
   public static void main(String[] args) {
       //а вот однострочный комментарий
       String j = "Java"; //Это моя строка
       int a = 15; //Здесь у меня целое число
       System.out.println("Hello, " + j + " " + a + "!");
       int[] myArray = {1,2,5};
       System.out.println(myArray.length);
   }
}

מילוליות בג'אווה

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

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

דוגמאות של מילים ב-Java

int i = 100; //100 – целочисленный литерал
double d = 10.2;//10.2 – литерал с плавающей точкой
char c = ‘b’; //b – символьный литерал
String myString = “Hello!”;
boolean bool = true;

שימו לב: ריק הוא גם מילולי.

אופרטורים בסיסיים ב-Java

ישנם סוגים שונים של אופרטורים: אריתמטי:

• + (הוספת מספרים ושרשור מחרוזת)
• - (מינוס או חיסור)
• * (כפל)
• / (חלוקה)
• % (מודלוס או שארית)

השוואות:

• < (פחות מ)
• <= (פחות או שווה ל)
• > (יותר מ)
• >= (גדול או שווה ל)
• == (שווה)
• != (לא שווה)

מגניב מוח:

• && (ו)
• || (אוֹ)
• ! (לֹא)
• ^ (XOR)

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

public class NumbersOperations {
   int a;
   int b;
   public static int add(int a,int b){
       return a+b;
   }
   public static int sub (int a, int b){
       return a-b;
   }
   public static double div (double a, int b){
       return a/b;
   }
}

כאן יש לנו מחלקה עם שיטות עץ לעבודה עם שני מספרים. אתה יכול לנסות לכתוב שיטה רביעית int mul(int a, int b) כדי להכפיל שני מספרים בתוכנית זו. בואו גם ניצור מחלקה כדי להדגים כיצד NumberOprations עובד :

public class NumberOperationsDemo {
   public static void main(String[] args) {
       int c = NumbersOperations.add(4,5);
       System.out.println(c);
       double d = NumbersOperations.div(1,2);
       System.out.println(d);
   }
}

אם תפעיל את NumberOperationsDemo תקבל פלט כך:

תוצאות

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