Java : ตัวแปร (Variable)

     ข้อมูลคือค่าต่างๆที่เราใช้ในโปรแกรม เช่น ตัวเลข ตัวอักษร ข้อความ จากตัวอย่างด้านล่าง ข้อมูลคือ ตัวเลข 10 0.126 และ ข้อความ Hello World



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

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

     นอกจากการกำหนดข้อมูลให้กับตัวแปรตรงๆแล้ว เรายังสามารถกำหนดเป็นนิพจน์ (expression) ซึ่งผลลัพธ์ที่ได้จากนิพจน์ก็คือข้อมูลที่จะถูกเก็บในตัวแปร ตามรูปแบบ  ชนิดของข้อมูล ชื่อตัวแปร = นิพจน์;

     ตัวแปรสามารถถูกเรียกได้หลายชื่อ ในกรณีที่เป็นตัวแปรของคลาสหมายถึงตัวแปรที่อยู่ในบล๊อกของคลาสแต่ไม่อยู่ในบล๊อกของเมธอดเราจะเรียกว่า

ฟิลด์ ในกรณีที่เป็นตัวแปรเพื่อรับข้อมูลในประโยคคำสั่งประกาศเมธอดเราจะเรียกว่าพารามิเตอร์ ส่วนในกรณีอื่นๆเราจะเรียกว่าตัวแปร    

     การตั้งชื่อให้กับตัวแปรให้ขึ้นต้นด้วยตัวอักษรเล็กส่วนคำที่เหลือให้ขึ้นต้นด้วยตัวอักษรใหญ่ ห้ามใช้ขีดล่าง ( _ ) และควรสื่อความหมายถึงข้อมูลที่ตัวแปรชี้ไปหา 

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

ขอบเขตการใช้งานของตัวแปร

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

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

     จากตัวอย่างด้านบนลำดับการทำงานโปรแกรมจะเริ่มจากทำงานแต่ละประโยคคำสั่งในเมธอด main เรียงลำดับลงมาจนถึงบรรทัด changFirstValue(); ซึ่งเป็นการเรียกใช้งานเมธอด changeFirstValue ลำดับการทำงานของโปรแกรมจะเปลี่ยนไปทำงานในเมธอดดังกล่าว และเมื่อเสร็จสิ้นการทำงานในเมธอดแล้วจึงจะกลับมาทำงานในประโยคคำสั่งที่เหลือในเมธอด main ต่อไป

     อีกหนึ่งตัวอย่างสำหรับขอบเขตของตัวแปร ตามตัวอย่างด้านล่างตัวแปร secondValue เป็นตัวแปรที่ถูกประกาศในบล็อก if ซึ่งจะถูกลบออกไปจากหน่วยความจำหลังจากที่การดำเนินการในบล็อกจบลง สังเกตุได้จากเมื่อเราอ้างถึงตัวแปร secondValue นอกบล็อก if แล้วจะพบข้อความแสดงข้อผิดพลาดว่าไม่รู้จักตัวแปรนี้

ตัวแปรแบบ Static

     ตัวแปรหรือฟิลด์แบบ static คือฟิลด์ที่กำกับด้วยคีย์เวิร์ด static ในขั้นตอนการประกาศฟิลด์ในคลาส ตัวอย่างเช่น  static int number;  ฟิลด์ที่กำกับด้วยคีย์เวิร์ด static จะเป็นฟิลด์ในระดับคลาสที่ทุกอินแสตนซ์ที่ถูกสร้างมาจากคลาสเดียวกันจะใช้ร่วมกัน ต่างกับฟิลด์ที่ไม่ได้กำกับด้วยคีย์เวิร์ด static จะเป็นฟิลด์ในระดับอินแสตนซ์ซึ่งเป็นของใครของมันไม่เกี่ยวกัน ดังนั้นการเปลี่ยนค่าในฟิลด์ที่กำกับด้วยคีย์เวิร์ด static จะมีผลกระทบกับทุกอินแสตนซ์ที่ถูกสร้างขึ้นมาจากคลาสเดียวกัน 

     ตัวอย่างเช่น เราสร้างคลาสของตัวละครในเกมส์เป็นทหาร แล้วเราต้องการแสดงให้ผู้เล่นทราบว่าได้สร้างทหารขึ้นมาจำนวนเท่าไรแล้ว เราสามารถกำหนดฟิลด์ที่ใช้นับจำนวนเป็น static และกำหนดให้บวกเพิ่มทุกครั้งในขั้นตอนการสร้างออบเจกต์ ตัวอย่างเช่น

     จากตัวอย่างด้านบนเราสร้างคลาส Soldier ขึ้นมาและกำหนดฟิลด์ทั้งที่เป็นแบบธรรมดาและแบบ static จากนั้นเราสั่งให้เพิ่มค่าของตัวแปรในขั้นตอนการสร้างออบเจกต์ และพิมพ์ค่าของฟิลด์ออกมา จะเห็นว่าเมื่อเราสร้างออบเจกต์ในคลาส Main ค่าของฟิลด์ numberOfGun จะเป็นของใครของมันคือ 1 แต่ค่าของฟิลด์ countSoldier จะเพิ่มไปตามจำนวนออบเจกต์ที่สร้างขึ้นมาเนื่องจากเป็นตัวแปรแบบ static ซึ่งทุกออบเจกต์ใช้ร่วมกัน

     และถ้าเราลองเรียกเมธอดของแต่บะอินแสตนซ์โดยการพิมพ์ชื่อตัวแปรตามด้วยเครื่องหมาย .  ซึ่ง IntelliJ IDEA จะแสดงเมธอดและฟิลด์ที่เรียกใช้งานได้ของแต่ละอินแสตนซ์มาให้ จะเห็นว่าไม่มีฟิลด์ countSoldier เพราะว่าไม่ใช่ฟิลด์เฉพาะของแต่ละอินแสตนซ์

ตัวแปรแบบ Final

     ตัวแปรหรือฟิลด์แบบ final คือฟิลด์ที่กำกับด้วยคีย์เวิร์ด final ในขั้นตอนการประกาศฟิลด์ในคลาส ตัวอย่างเช่น  final int number;  ฟิลด์ที่กำกับด้วยคีย์เวิร์ด final จะสามารถถูกกำหนดค่าได้เพียงครั้งเดียว และจะต้องถูกกำหนดค่าในขั้นตอนการสร้างออบเจกต์ เราจึงจะระบุการกำหนดค่าไว้ในเมธอดคอนสตรัคเตอร์ (เมธอดคอนสตรัคเตอร์ เป็นเมธอดพิเศษที่ใช้ในการสร้างออบเจต์ของคลาสซึ่งจะได้เรียนรู้ในบทต่อๆไป)

     เราใช้ประโยชน์จากฟิลด์ที่กำกับด้วยคีย์เวิร์ด final ในการกำหนดค่าที่ไม่สามารถเปลี่ยนแปลงได้และต้องการให้มีค่าที่แตกต่างกันไปสำหรับแต่ละออบเจกต์ เช่น การกำหนดกุญแจ (key) ในการพิสูจน์ตัวตนของผู้ใช้งานซึ่งต้องไม่เหมือนกันสำหรับผู้ใช้งานแต่ละคนและต้องไม่สามารถแก้ไขหรือเปลี่ยนแปลงได้

    จากตัวอย่างด้านล่างเราประกาศฟิลด์ที่กำกับด้วยคีย์เวิร์ด final ขึ้นมา แต่ทดลองกำหนดค่าด้วยเมธอดอื่นที่ไม่ใช่เมธอดคอนสตรัคชั่น จะพบว่าโปแกรม  IntelliJ IDEA จะแจ้งข้อผิดพลาดว่ายังไม่ได้กำหนดค่าให้กับฟิลด์ที่กำกับด้วยคีย์เวิร์ด final และในบรรทัดล่างจะแสดงข้อผิดพลาดว่า ไม่สามารถกำหนดค่าให้กับฟิลด์ที่กำกับด้วยคีย์เวิร์ด final

     แต่ถ้าเรากำหนดค่าให้กับฟิลด์ที่กำกับด้วยคีย์เวิร์ด final ในเมธอดคอนสตรัคชั่น ข้อผิดพลาดจะหายไป

     และถ้าทดลองเปลี่ยนค่าให้กับฟิลด์ที่กำกับด้วยคีย์เวิร์ด final จะพบว่าไม่สามารถทำได้

ตัวแปรแบบ Constant

          ตัวแปรหรือฟิลด์แบบคอนแสตนท์ (constant) คือฟิลด์ที่กำกับด้วยคีย์เวิร์ด static และ final และต้องมีการกำหนดค่าให้กับฟิลด์ในขั้นตอนการประกาศฟิลด์ในคลาส ตัวอย่างเช่น  

static final String ERROR_MESSAGE_1 = “Invalid Name”;   

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

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

     จากตัวอย่างด้านล่างเป็นการกำหนดข้อความแสดงข้อผิดพลาด ซึ่งแทนที่เราจะพิมพ์ข้อความตรงๆในโปรแกรมซึ่งอาจจะพิมพ์ผิดได้เพราะต้องพิมพ์ในหลายๆที่ และหากต้องการแก้ไขข้อความก็ต้องตามไปแก้ไขหลายที่ การใช้ตัวแปรแบบคอนแสตนท์จึงเหมาะสมกว่า

 static final String ERROR_MESSAGE_1 = “Invalid Name”;

     จากตัวอย่างด้านล่างเราประกาศฟิลด์แบบคอนแสตนท์แต่ไม่กำหนดค่าซึ่ง IntelliJ IDEA จะแสดงข้อผิดพลาด ซึ่งฟิลด์แบบคอนแสตนท์จะต้องถูกกำหนดค่าไปพร้อมกับการประกาศฟิลด์