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

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

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

אובייקט ב-Java

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

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

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

שיטות ב-Java

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

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

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

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

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

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

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

class HelloJava

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

public static void main (String args []) {

הנה תחילתה של השיטה העיקרית. שיטה היא התנהגות, או רצף הפקודות המאפשר לבצע פעולה בתוכנית. למשל להכפיל 2 מספרים או להדפיס מחרוזת. במילים אחרות, שיטה היא פונקציה. בשפות תכנות אחרות, שיטות מכונה לעתים קרובות "פונקציות". שיטות, בדיוק כמו כל הרכיבים של תוכנית Java, ממוקמות בתוך מחלקה. לכל מחלקה יכולה להיות מתודה אחת, רבות או לא. public הוא משנה גישה. ניתן לגשת למשתנה, שיטה או מחלקה המסומנים ב-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) . השיטה הראשית () היא חלק נדרש מכל תוכנית Java;
• שיטה (פרוצדורה, פונקציה) היא רצף של פקודות. שיטות מגדירות את ההתנהגות של על אובייקט;
• סדר השיטות בקובץ התוכנית אינו רלוונטי;
• זכור שהאות הראשונה של שם מחלקה היא באותיות גדולות. אם אתה משתמש במספר מילים, השתמש באותיות גדולות עבור האות הראשונה של כל מילה ("MyFirstJavaClass");
• השמות של כל השיטות בתחביר Java מתחילים באות קטנה. כשמשתמשים במספר מילים, האותיות הבאות מופיעות באותיות רישיות ("ריקון ציבורי myFirstMethodName ()");
• קבצים נשמרים עם שם המחלקה וסיומת .java ("MyFirstJavaClass.java");
• בתחביר Java, ישנם תוחמים "{...}" שמציינים גוש קוד ואזור חדש של קוד;
• כל משפט קוד חייב להסתיים בנקודה-פסיק.

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

• מספרים שלמים: בייט, קצר, int, ארוך
• שברים: צפים וכפולים
• ערכים לוגיים: בוליאני
• ערכים סמליים (לייצוג אותיות וספרות): 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)

Java Enums

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

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

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

דוגמה של Java Enum

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

        Day myDay = DayOfWeek.FRIDAY;
        System.out.println(myDay);	//print a day from the enum
}
}
enum DayOfWeek{

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

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

הכרזה על משתנים ב-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 יש שתי קטגוריות של משנה: גישה ו-No-Access Modifiers.

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

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

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

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

יש 7 כאלה

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

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

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

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

הערות ב-Java

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

//single-line comment
/*here we have a multi-line comment. As you can see it uses slash and asterisks from both sides of it.*/

public class HelloJava {
   /* this program was created to demonstrate comments in Java. This one is a multi-line comment.
   You can use such comments anywhere in your programs*/
   public static void main(String[] args) {
       //here is a single-line comment
       String j = "Java"; //This is my string
       int a = 15; //here I have an integer
       System.out.println("Hello, " + j + " " + a + "!");
       int[] myArray = {1,2,5};
       System.out.println(myArray.length);
   }
}

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

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

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

דוגמאות מילוליות של Java

int i = 100; //100 is an integral  literal
double d = 10.2;//10.2 is a floating point literal
char c = ‘b’; //b is a char literal
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;
   }
}

כאן יש לנו מחלקה עם שיטות עץ לתמרן עם 2 מספרים. אתה יכול לנסות לכתוב את השיטה הרביעית int mul (int a, int b) כדי להכפיל 2 מספרים בתוך תוכנית זו. בואו גם ניצור מחלקה כדי להדגים את עבודת 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 Practical CodeGym . בהצלחה בלימוד הג'אווה שלך!