ตัวแปร Java และค่าคงที่

เพื่อให้เข้าใจภาษา Java การเข้าใจไวยากรณ์ของภาษาเป็นสิ่งสำคัญมาก โครงสร้างพื้นฐานที่สำคัญประการหนึ่งคือตัวแปร

ตัวแปรใน Java คืออะไร

ตัวแปรใน Javaคือคอนเทนเนอร์ที่สามารถเก็บค่าข้อมูลบางส่วนเพื่อใช้ในโปรแกรมในภายหลัง โดยพื้นฐานแล้ว ตัวแปรคือหน่วยที่เล็กที่สุดของแอปพลิเคชัน Java ซึ่งแบ่งแยกไม่ได้ ตัวแปรใน Java มีสองประเภท: ตัวแปรสำหรับข้อมูลขนาดเล็ก (ตัวแปรพื้นฐาน) และสำหรับตัวแปรที่ซับซ้อนและหนักกว่า (ตัวแปรอ้างอิง) วันนี้เราจะมาดูกรณีแรกเมื่อตัวแปรเก็บค่าข้อมูลไว้ ตัวแปรดังกล่าวเรียกว่าตัวแปรดั้งเดิม

การประกาศตัวแปรในภาษา Java

ลองดูตัวอย่างนี้:

int x = 9;

มาดูสิ่งที่เราเห็นกัน: int- ประเภทของตัวแปรที่อธิบายจำนวนเต็มที่อยู่ในช่วง -2147483648 ถึง 2147483647 x- ชื่อของตัวแปร (เราต้องแยกพวกมันออกจากกันใช่ไหม?) = การมอบหมายเครื่องหมายให้กับตัวแปรบางตัว บางตัว ค่า 9- ค่าทันทีคือ ;จุดสิ้นสุดของคำสั่งนี้ ตอนนี้เรามารวมทุกอย่างเข้าด้วยกัน: เราระบุว่าตัวแปรประเภทintที่มีชื่อมีxค่า 9ตัวอย่างนี้มีรูปแบบย่อ โดยแบบเต็มจะเป็นดังนี้:

int x;
x = 9;

ในบรรทัดแรก เราเห็นการประกาศตัวแปรและกำหนดชื่อให้กับตัวแปร กล่าวคือ ด้วยวิธีนี้ เราจะบอกให้JVMจัดสรรพื้นที่สำหรับตัวแปรint(4 ไบต์) และตั้งชื่อให้กับตัวแปรxนั้น ในวินาทีที่เราให้คุณค่ากับ9มัน ก่อนหน้านี้มีค่าเริ่มต้น0คือ สมควรพูดสักสองสามคำเกี่ยวกับการตั้งชื่อตัวแปร โดยทั่วไปจะเขียนด้วยรูปแบบอูฐล่าง ตัวอย่างเช่น หากเรามีตัวแปรที่อธิบายจำนวนคน (จำนวนคน) ชื่อที่เหมาะสมสำหรับตัวแปรนั้นจะเป็น:

int countOfPeople;

ในชื่อนี้ คำแรกจะขึ้นต้นด้วยอักษรตัวพิมพ์เล็ก (เล็ก) และแต่ละคำที่ตามมาจะขึ้นต้นด้วยอักษรตัวใหญ่ (ตัวพิมพ์ใหญ่) การทำเช่นนี้จะทำให้ชื่อเหล่านี้อ่านง่ายขึ้น เนื่องจากชื่อตัวแปรมักประกอบด้วยคำมากกว่าหนึ่งคำ

นิยามตัวแปรใหม่

กลับไปที่ตัวอย่างการประกาศตัวแปรของเรา:

int x = 9;

หากเราใส่ค่าลงในตัวแปรครั้งหนึ่ง ไม่ได้หมายความว่าระหว่างการทำงานของโปรแกรม ตัวแปรจะxมีค่าเสมอไป 9เราสามารถเขียนมันใหม่ได้:

x = 4;

ทุกอย่างเกือบจะเหมือนกัน แต่เราไม่ได้เพิ่มประเภท ( int) อีกต่อไป เนื่องจากมีการลงทะเบียนเมื่อประกาศตัวแปร (ประกาศการมีอยู่ของมัน) ต่อไป เราจะนำมันกลับมาใช้ใหม่เท่านั้น ตัวอย่างเช่น เราเห็นว่ามันถูกเขียนทับ (เราตั้งค่าตัวแปรของเราเป็นค่าใหม่ โดยเขียนทับค่าเก่า) สมมติว่าเรามีตัวแปรด้วย:

int y = 7;

และตามการตั้งค่า: x = y; ค่าเก่าของตัวแปรxจะถูกลบ เขียนทับด้วยสำเนาของค่าyคือ7- คุณยังสามารถตั้งค่าของตัวแปรอื่นๆ ได้โดยเพิ่มขึ้นตามจำนวนที่เราต้องการ:

x = y + 5;

เนื่องจากตัวแปรของเราyเท่ากับ 7 ผลลัพธ์xจะเท่ากับ 12 สิ่งที่น่าสนใจกว่าคือความสามารถในการดำเนินการเหล่านี้:

x = x + 6;

เราเห็นอะไรที่นี่? ตัวแปรxจะได้รับค่าเท่ากับอดีตที่เพิ่มขึ้น 6 นั่นคือจะเป็น: 12 + 6 = 18 รายการเดียวกันสามารถย่อให้สั้นลงได้โดยละเว้นx:

x =+ 6;

ประเภทของตัวแปร

แอปพลิเคชันใน Java ประกอบด้วยคลาสและอ็อบเจ็กต์ มาดูกันว่าตัวแปร Java คืออะไร:

• ตัวแปรวัตถุ
• ตัวแปรท้องถิ่น
• ตัวแปรคลาส

สำหรับคลาสตัวอย่าง เราจะใช้คลาส dog ด้วยวิธี "bark":

public class Dog {
   public void bark() {
   }
}

ตัวแปรวัตถุ

ตัวแปรจะถูกประกาศในคลาส แต่ไม่ใช่ในเมธอด ตัวสร้าง หรือบล็อก

public class Dog {
public  int value = 9;
   public void bark() {
   }
}

หากต้องการเรียกตัวแปรนี้ เราต้องสร้างวัตถุก่อน:

Dog dog = new Dog();
dog.value;

ตัวแปรจะถูกสร้างขึ้นหลังจากสร้างออบเจ็กต์แล้วเท่านั้น (นั่นคือ หลังจากสร้างออบเจ็กต์โดยใช้new) ในออบเจ็กต์ ตัวแปรภายในจะมองเห็นได้เสมอสำหรับเมธอด ตัวสร้าง หรืออะไรก็ตามที่อยู่ภายในออบเจ็กต์เดียวกันนั้น ตามที่กล่าวไว้ข้างต้น ตัวแปรวัตถุมีค่าเริ่มต้น สำหรับตัวเลข ค่าเริ่มต้นคือ 0 สำหรับตรรกะ (บูลีน) - เท็จ สำหรับการอ้างอิงไปยังวัตถุ - null

ตัวแปรท้องถิ่น

ตัวแปรเหล่านี้ได้รับการประกาศในเมธอด ตัวสร้าง หรือบล็อก

public class Dog {
   public void bark() {
   int value = 9;
   }
}

ตัวแปรท้องถิ่นมีเฉพาะในกลุ่มโค้ดที่เรียกว่าเท่านั้น ซึ่งส่วนท้ายของตัวแปรจะถูกลบออกจากหน่วยความจำ มองเห็นได้เฉพาะภายในเมธอดตัวสร้างหรือบล็อก ที่ประกาศไว้เท่านั้น นั่นคือคุณไม่สามารถใช้ตัวแปรได้ เช่น ในวิธีอื่น ไม่สามารถใช้ตัวดัดแปลงการเข้าถึง สำหรับตัวแปรในเครื่องได้ ประเด็นของพวกเขาคืออะไรหากตัวแปรไม่สามารถมองเห็นได้เกินขอบเขตของวิธีการ? ตัวแปรประเภทนี้ถูกสร้างขึ้นเมื่อมีการเรียกเมธอด (หรือคอนสตรัคเตอร์ หรือบล็อก) และทำลายเมื่อเสร็จสิ้น

ตัวแปรคลาส

ตัวแปรประเภทนี้เรียกอีกอย่างว่าคงที่ มีการประกาศด้วยคำดัดแปลงstaticแต่อยู่นอกขอบเขตของเมธอด ตัวสร้าง หรือบล็อก

public class Dog {
public static  int value = 9;
   public void bark() {
   }
}

เรียกตัวแปรของเรา:

Dog.value

Dogชื่อของคลาสที่แนบตัวแปรอยู่ ที่ไหน ค่าเริ่มต้นจะเหมือนกับตัวแปรออบเจ็กต์ สำหรับตัวเลข ค่าเริ่มต้นคือ 0 สำหรับบูลีนจะเป็นเท็จ สำหรับการอ้างอิงวัตถุ - null มีตัวแปรคงที่หนึ่งตัวแปรเสมอ ไม่ว่าจะสร้างอ็อบเจ็กต์จำนวนเท่าใดจากคลาสก็ตาม เนื่องจากมันถูกแนบกับคลาสเท่านั้น ตัวแปรคลาสจะถูกสร้างขึ้นเมื่อโปรแกรมเริ่มทำงานและจะถูกทำลายเมื่อโปรแกรมดำเนินการเสร็จสิ้น ตัวแปรคงที่ใน Java มักใช้เมื่อมีการประกาศเป็นค่าคงที่ เรามาพูดถึงรายละเอียดเพิ่มเติมกันดีกว่า

ค่าคงที่ใน Java คืออะไร

ค่าคงที่คือค่าคงที่ที่กำหนดซึ่งไม่ควรเปลี่ยนแปลง ค่าคงที่ในการเขียนโปรแกรมคืออะไร? นี่คือค่าคงที่บางส่วนที่ทราบก่อนที่แอปพลิเคชันจะเริ่มทำงาน และจะถูกตั้งค่าในโค้ดหนึ่งครั้ง ใน Java ค่าคงที่เป็นตัวแปรที่แสดงด้วยคำพิเศษ - final:

final int VALUE = 54;

ที่นี่เราได้รับตัวแปรที่ไม่สามารถเปลี่ยนแปลงได้หลังจากตั้งค่าเป็นค่าใดๆ ประเด็นก็คือค่าคงที่นั้นง่ายกว่าตัวแปรมาก สิ่งเหล่านี้ถูกกำหนดไว้อย่างมีเอกลักษณ์เสมอและไม่เคยเปลี่ยนแปลง สูงขึ้นอีกเล็กน้อยเราได้พูดคุยเกี่ยวกับการตั้งชื่อตัวแปร และเราควรให้ความสนใจกับลักษณะเฉพาะของการตั้งชื่อค่าคงที่ ในตัวแปรคงที่ คำทั้งหมดจะเขียนด้วยตัวพิมพ์ใหญ่ คั่นด้วยเครื่องหมายขีดล่าง_ ตัวอย่างเช่น เราต้องการค่าคงที่ที่อธิบายค่าสูงสุดสำหรับบางสิ่ง:

final int MAX_VALUE = 999;

โดยสรุป: มีการจัดเตรียมตัวแปรไว้ให้เราเป็นสถานที่จัดเก็บข้อมูลของเรา (หรือที่อยู่ของตำแหน่ง) ซึ่งช่วยให้เราสามารถควบคุมแอปพลิเคชันได้ ตัวแปรประเภทดั้งเดิมมีรูปแบบข้อมูล ขนาด และช่วงของค่าเฉพาะที่สามารถเก็บไว้ในหน่วยความจำได้ ตัวแปรสามารถแบ่งตามตำแหน่ง: อ็อบเจ็กต์, โลคัล, ตัวแปรคลาส มีตัวแปรประเภทพิเศษ - ค่าคงที่ซึ่งสามารถเป็นตัวแปรร่วมได้ ขอบเขตของพวกเขาคือโปรแกรมทั้งหมด