משתני Java

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

מהו משתנה Java

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

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

כיצד להצהיר על משתנים

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

int myInt;
String s;
Object variableName;

כאן int , String ו- Object הם סוג הנתונים ו- myInt , s , variableName הם שמות משתנים. יש לבחור את סוג הנתונים בהתאם לצרכי התוכנית, ועדיף לבחור שם כדי שיהיה ברור במה מדובר. כמובן, למתחילים זה לא כל כך קפדני, אבל בפרויקטים גדולים, שמות משתנים כמו 's' יכולים לפגוע בקריאות הקוד. אז עדיף להתרגל לתת שמות למשתנים באופן שיבהיר למה הם מיועדים כבר מההתחלה. בגדר ההגיון, כמובן.

כיצד לאתחל משתנים

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

public class VariableTest {
    public static void main(String[] args) {
        int myInt = 5;
        String s;
        s = "init";
        System.out.println(s);
        s = s+5;
        System.out.println(s);
    }
}

כאן הכרזנו ואתחול את המשתנה myInt בשורה אחת, מיד הקצאנו לו זיכרון (32 סיביות לכל מספר int), נתנו לו שם, ואז שמנו את הערך 5 בזיכרון שהוקצה. ואז הכרזנו שאנחנו מקצים שטח זיכרון למחרוזת s , וכבר פקודה נפרדת הכניסה לתוכה את הערך "init". לאחר מכן, הדפסנו את המחרוזת ושינינו את הערך של המשתנה s . בתוכנית זו הדפסנו את השורות, ואם תפעיל אותה, תראה את התוצאה הבאה:

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

סוגי נתונים של משתנים ב-Java מחולקים לשתי קבוצות:

• סוגי נתונים פרימיטיביים כוללים בתים , קצר , int , ארוך , צף , כפול , בוליאני ו- char
• סוגי נתונים לא פרימיטיביים כגון String , Arrays ו- Classes

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

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

       int myInt = - 5;               // integer (whole number)
       float myFloat = 2.718281828459045f;    // Floating point number
       char myLetter = 'a';         // character
       boolean myBool = true;       // boolean
       String myText = "Hero";     // String
       System.out.println(myInt + " " +
               myFloat +" " + myLetter + " " +  myBool + " " + myText);
       Student myStudent = new Student("Walker","Johnny", "Kyle", null);

   }
}

int , char , boolean ו- float הם פרימיטיביים. מחרוזת אינה פרימיטיבית. מה לגבי משתנה myStudent ? זהו אובייקט של הכיתה Student שנוצרה על ידי המשתמש . הוא נוצר פשוט כדי להמחיש את העבודה עם משתנים לא פרימיטיביים. הם הרוב בג'אווה, מכיוון שכמעט כל דבר בשפת התכנות הזו הוא אובייקט. להבנה, הנה הקוד של כיתת הסטודנטים :

import java.util.Date;

public class Student {
   String surname;
   String name;
   String secondName;
   Long birthday; // Long instead of long is used by Gson/Jackson json parsers and various orm databases

   public Student(String surname, String name, String secondName, Date birthday ){
       this.surname = surname;
       this.name = name;
       this.secondName = secondName;
       this.birthday = birthday == null ? 0 : birthday.getTime();
   }

   @Override
   public int hashCode(){
       //TODO: check for nulls
       //return surname.hashCode() ^ name.hashCode() ^ secondName.hashCode() ^ (birthday.hashCode());
       return (surname + name + secondName + birthday).hashCode();
   }
   @Override
   public boolean equals(Object other_) {
       Student other = (Student)other_;
       return (surname == null || surname.equals(other.surname) )
               && (name == null || name.equals(other.name))
               && (secondName == null || secondName.equals(other.secondName))
               && (birthday == null || birthday.equals(other.birthday));
   }
}

סוגי משתנים ב-Java: מקומי, מופע וסטטי

ישנם שלושה סוגים שונים של משתנים ב-Java, רשמנו אותם כדלקמן:

1. משתנים מקומיים
2. משתני מופע
3. משתנים סטטיים

משתנים מקומיים

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

public class VariableTest {
   public static void main(String[] args) {
       System.out.println(myMethod("C plus "));
   }
           private static String myMethod(String myString) {
       String myOtherString = "plus";
       return myString + myOtherString;
   }
}

כאן myOtherString הוא משתנה מקומי. אתה לא יכול להשתמש בו מהשיטה האחרת, אלא myMethod . למשתנים מקומיים לא יכולים להיות ערכי ברירת מחדל. אם לפחות משתנה מקומי אחד לא מאותחל בתוכנית, התוכנית לא תעבוד כראוי. בואו נעשה שינוי קטן באחת הדוגמאות הקודמות ו"נשכח" לאתחל את המשתנה myBool :

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

       int myInt = - 5;               // integer (whole number)
       float myFloat = 2.718281828459045f;    // Floating point
       char myLetter = 'a';         // character
       boolean myBool;       // boolean
       String myText = "Hero";     // String
       System.out.println(myInt + " " +
               myFloat +" " + myLetter + " " +  myBool + " " + myText);
       Student myStudent = new Student("Walker","Johnny", "Kyle", null);

   }
}

אם ננסה להפעיל את התוכנית, היא תגרום לשגיאה:

משתני מופע

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

//instance variable example
public class Employee {

   // here we have a public instance variable. It is visible for this class and child classes
   public String name;

   //this instance variable is private so it’s visible for the Employee class only. You can use setters and getters to get it
   private double salary;

   public Employee (String empName) {
       name = empName;
   }

   public String getName() {
       return name;
   }

   public void setName(String name) {
       this.name = name;
   }

   public double getSalary() {
       return salary;
   }

   public void setSalary(double employeeSalary) {
       salary = employeeSalary;
   }

   public static void main(String args[]) {
       Employee employee = new Employee("Johnny");
       employee.setSalary(1500);
       System.out.println("name = " + employee.getName());
       System.out.println("salary = " + employee.getSalary());
   }
}

משתנים סטטיים

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

public class Box
{
   public void add(int data)
   {
       Storage.sum = Storage.sum + data;
       Storage.count++;
   }

   public void remove(int data)
   {
       Storage.sum = Storage.sum - data;
       Storage.count--;
   }
}

public class Storage
{
   public static int count = 0;
   public static int sum = 0;
}

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