ตัวแปร 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: ดั้งเดิมและไม่ดั้งเดิม

ชนิดข้อมูลของตัวแปรในภาษาจาวาแบ่งออกเป็นสองกลุ่มคือ

• ชนิดข้อมูลดั้งเดิมประกอบด้วยbyte , short , int , long , float , double , booleanและchar
• ชนิดข้อมูลที่ไม่ใช่ แบบพื้นฐาน เช่นสตริงอาร์เรย์และคลาส

นี่คือตัวอย่างการทำงานกับตัวแปร:

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ที่ ผู้ใช้สร้างขึ้น มันถูกสร้างขึ้นเพียงเพื่อแสดงให้เห็นถึงการทำงานกับตัวแปรที่ไม่ใช่แบบดั้งเดิม พวกเขาเป็นส่วนใหญ่ใน Java เนื่องจากเกือบทุกอย่างในภาษาการเขียนโปรแกรมนี้เป็นวัตถุ เพื่อความเข้าใจนี่คือรหัสของ ชั้น เรียนนักเรียน :

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 ของเรา