ในบทความนี้ เราจะอธิบายให้ผู้เรียน 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 ในโปรแกรมนี้ เราพิมพ์บรรทัดออกมา และถ้าคุณเรียกใช้ คุณจะเห็นผลลัพธ์ต่อไปนี้:
เริ่มต้น init5
ชนิดข้อมูลของตัวแปรใน 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 เราได้แสดงไว้ดังนี้:- ตัวแปรท้องถิ่น
- ตัวแปรอินสแตนซ์
- ตัวแปรคงที่
ตัวแปรท้องถิ่น
ตัวแปรที่ประกาศภายในเนื้อความของเมธอดเรียกว่าตัวแปรโลคัล นอกจากนี้ ตัวแปรโลคัลจะถูกประกาศภายในคอนสตรัคเตอร์และบล็อค คุณสามารถใช้ตัวแปรโลคัลได้เฉพาะภายในเมธอด ตัวสร้าง หรือบล็อกที่สร้างขึ้นเท่านั้น และเมธอดอื่นๆ ในคลาสจะไม่รู้ด้วยซ้ำว่ามีตัวแปรอยู่ ดังนั้นตัวแปรโลคัลจะถูกสร้างขึ้นเมื่อเมธอด ตัวสร้าง หรือบล็อกถูกป้อน และตัวแปรจะถูกทำลายเมื่อเมธอด ตัวสร้าง หรือบล็อกไม่ทำงาน ไม่สามารถกำหนดตัวแปรโลคัลด้วยคีย์เวิร์ดสแตติก ยิ่งกว่านั้น: คุณไม่สามารถใช้ตัวแก้ไขการเข้าถึงสำหรับตัวแปรในเครื่องได้ นี่คือตัวอย่าง:
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);
}
}
หากเราพยายามเรียกใช้โปรแกรม มันจะส่งข้อผิดพลาด:
ข้อผิดพลาด:(10, 50) java: ตัวแปร myBool อาจไม่ได้เริ่มต้น
ตัวแปรอินสแตนซ์
ตัวแปรที่ประกาศภายในคลาสแต่อยู่นอกเนื้อความของเมธอด ตัวสร้าง หรือบล็อกใดๆ จะเรียกว่าตัวแปรอินสแตนซ์ ตัวแปรอินสแตนซ์ถูกสร้างขึ้นเมื่อวัตถุถูกสร้างขึ้นโดยใช้คีย์เวิร์ดใหม่ จะถูกทำลายเมื่อวัตถุถูกทำลาย ไม่สามารถประกาศเป็นแบบคงที่ได้ แต่คุณสามารถใช้ตัวแก้ไขการเข้าถึงสำหรับตัวแปรอินสแตนซ์ได้ ตัวแปรอินสแตนซ์สามารถมองเห็นได้สำหรับเมธอด ตัวสร้าง และบล็อกทั้งหมดในคลาส โดยปกติแล้ว ตัวแปรอินสแตนซ์จะเป็นแบบส่วนตัว แต่คุณสามารถเปลี่ยนการมองเห็นสำหรับคลาสย่อยได้ ตัวแปรอินสแตนซ์ซึ่งตรงข้ามกับตัวแปรโลคัลมีค่าเริ่มต้น สำหรับประเภทดั้งเดิมของตัวเลขทั้งหมด ค่าเริ่มต้นคือ 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 ของเรา
GO TO FULL VERSION