หนว่ ยที่ 2
พ้ืนฐานภาษาจาวา
ภาษาจาวาสามารถนำมาพฒั นาโปรแกรมไดห้ ลายประเภท และเป็นภาษาท่ไี ม่ยึดติดกบั แพลตฟอร์มใด
ๆ โดยภาษาน้สี นับสนุนการเขียนโปรแกรมเชงิ วัตถไุ ด้เป็นอย่างดี ในการเขยี นโปรแกรมจะต้องสร้างคลาสขึ้นมา
หนึ่งคลาส จากนั้นคอมไพล์โปรแกรมให้เป็นไบต์โค้ด จึงสามารถรันโปรแกรมได้ สำหรับการเขียนโปรแกรม
เบื้องต้น ผู้เขียนโปรแกรมควรรู้จักเมธอด println ที่ใช้สำหรับแสดงข้อความสตริงออกมาทางจอภาพ รู้จัก
คลาส Scanner ทใ่ี ชใ้ นการรับข้อมลู เขา้ ทางแป้นพมิ พ์
2.1 โครงสรา้ งภาษาจาวา
ภาษาจาวามีแนวคิดในการเขียนโปรแกรมเชิงวัตถุ โปรแกรมจะเริ่มขึ้นด้วยการสร้างคลาสข้ึนมาก่อน
จากนั้นจะเขียนคำสั่งต่าง ๆ ลงไป ตัวอย่าง เช่น ถ้าต้องการเขียนโปรแกรมให้แสดงคำว่า Computer
Technology จะต้องเขียนคำสัง่ ต่อไปนี้
System.out.println(“Computer Technology”);
รูปแบบ
Public class Simple{
public static void main(String[] args) {
System.out.println(“Computer Technology”);
}
}
จากรูปแบบเป็นการสรา้ งคลาสชื่อ Simple โดยชื่อคลาสน้ตี อ้ งเป็นชอ่ื เดียวกับโปรแกรม โดยจะบันทึก
เป็นช่อื Simple.java โดยโปรแกรมนจ้ี ะใช้ System.out.println ในการแสดงผลทางหนา้ จอ โดยคำสั่งน้ีจะจบ
ด้วยเครื่องหมายเซมิโคลอน(;) ในการเขียนคำสั่งในภาษาจาวา ตัวอักษรตัวพิมพ์เล็กตัวพิมพ์ใหญ่มีความหมาย
แตกตา่ งกัน โดยโปรแกรมจะขึน้ ตน้ ดว้ ยคำว่า Public ตามดว้ ยคำวา่ Class แล้วตามดว้ ยช่ือคลาส คำว่า Public
น้ีจะตอ้ งเขียนไว้ก่อนหน้า Class เสมอ คลาสทีส่ รา้ งข้นึ จะอยู่ในเคร่ืองหมายปีกกา
public static void main(String[] args)
บรรทัดที่ 2 ของโปรแกรมจะเป็นเมธอด (Method) ของคลาส ใช้คำว่า main เพื่อบอกว่าเป็นเมธอด
หลัก เมธอดนี้จะขึ้นต้นด้วยคำว่า public แล้วตามด้วยคำว่า static เพื่อให้โปรแกรมสามารถเรียกเมธอดนี้
ขึ้นมาทำงานโดยไม่ต้องสรา้ งออบเจ็กขึ้นมา ส่วนคำว่า void เป็นการบอกว่าหลังจากทำเมธอดแล้วจะไม่มีการ
สง่ คา่ กลบั คืน สว่ นอาร์กิวเม้นต์ในวงเลบ็ ท่ตี ามหลังคำว่า main ใชส้ ำหรบั ส่งคา่ ขอ้ มูลเขา้ มาในเมธอด
2.2 เมธอดแสดงผลทางจอภาพ
การแสดงผลออกทางจอภาพมันเปน็ เมธอดแรกทีน่ ักเขียนโปรแกรมจะต้องศึกษา ภาษาจาวาจะใชเ้ มธ
อด print และ println ในการแสดงผลทางจอภาพ โดยเมธอดท้ังสองน้จี ะอยูในออกเจก๊ ชื่อ out ซึ่งออบเจก๊ น้ี
จะถกู เก็บในคลาส System การเรียกใชเ้ มธอดมราบรรจุอยู่ในออบเจก๊ ตา่ ง ๆ จะใชเ้ ครื่องหมาย (.) ในการอา้ ง
ถึง
System.out.print(data); คลาส System มอี อบเจ็กต์ out
System.out.println(data); เป็นสมาชกิ อยู่
System class
out object ออบเจ็กต์ out เป็นสมาชิกของ
คลาส System
เมธอด print และ println
เป็นสมาชกิ ของออบเจ็กต์ out ൜
data เป็นข้อมูลที่ต้องการแสดงผลซึ่งอยู่ในรูปแบบของข้อมูลสตริง การใช้เมธอด print หลังจาก
แสดงผลข้อมูลแล้วจะไม่ขึ้นบรรทัดใหม่ ส่วนเมธอด println จะทำให้โปรแกรมขึ้นบรรทัดใหม่หลังจากพิมพ์
ข้อมูลทแ่ี สดงผลแล้ว
ในการแสดงผลด้วยเมธอด print และ println นั้น สามารถใช้ escape sequence สำหรับควบคุม
การแสดงผล โดยจะเริ่มต้นดว้ ยเครอ่ื งหมาย แบ็กสแลช (\) แลว้ ตามด้วยตัวอักขระควบคุมหนึ่งตวั โดยรหัสต่าง
ๆ ดงั ตารางต่อไปน้ี
ตารางท่ี 2.1 ตารางแสดง escape sequence ในภาษาจาวา
escape sequence ช่ือ ความหมาย
\n Newline ขึ้นบรรทัดใหม่
\t Horizontal tab แทบ็ ในแนวนอน
\b Backspace ถอยหลงั 1 ช่องตวั อกั ษร
\r Return เล่ือนเคอรเ์ ซอร์ไปซา้ ยสดุ
\\ Backslash ตัวอักษร \ (backslash)
\’ Single quote ตัวอักษร ‘ (single quote)
\” Double quote ตวั อักษร “ (double quote)
การแสดงผลดว้ ยเมธอด print และ println นั้น ขอ้ มูลที่แสดงผลจะเปน็ ข้อมูลแบบสตริง และถา้
ต้องการแสดงผลข้อมลู หลายตวั สามารถใชต้ ัวดำเนินการ + ในการเชอ่ื มข้อมลู ได้ เชน่
System.out.println(“This is”+”one string.”);
2.3 ชนิดของขอ้ มูล ตวั แปรและค่าคงที่
ตัวแปรคือชื่อที่กำหนดขึ้นสำหรับเก็บข้อมูล หากระบบต้องการเก็บข้อมูลที่รับเข้าจากอินพุต หรือ
ต้องการเก็บข้อมูลโดยทีค่ ่านั้นสามารถเปลีย่ นแปลงได้ จะต้องจองพื้นที่หน่วยความจำของคอมพิวเตอร์สำหรับ
เก็บข้อมูล โดยตัวแปรจะเป็นตัวแทนตำแหน่งของหน่วยความจำที่จอง เนื่องจากการเก็บข้อมูลแต่ละประเภท
จะใช้เน้ือท่ีหนว่ ยความจำไมเ่ ท่ากนั การกำหนดตัวแปรแต่ละตวั จะต้องกำหนดดว้ ยวา่ จะให้ตัวแปรนน้ั เก็บข้อมูล
ชนดิ ใด ซึง่ รปู แบบการประกาศคา่ ตัวแปรในภาษาจาวาเปน็ ดังน้ี
รปู แบบ
dataType variableName[,variableName];
หรอื
ชนิดขอ้ มูล ตัวแปร;
ถ้าหากมีตัวแปรหลายตวั จะใช้เครอ่ื งหมาย , ค่นั ดงั ตวั อยา่ งการประกาศค่าตัวแปรต่อไปน้ี
int x; //ประกาศตัวแปร x สำหรับเกบ็ เลขจำนวนเตม็
int x,y; //ประกาศตวั แปร x และ y สำหรับเกบ็ เลขจำนวนเตม็
เม่ือประกาศตวั แปรขน้ึ มาแลว้ สามารถใชเ้ ครื่องหมาย = ในการกำหนดค่าได้อีกด้วย โดยมีรูปแบบดงั น้ี
รูปแบบ
ตวั แปร = คา่ ทตี่ ้องการกำหนด;
เชน่ int x;
x = 8;
เช่น int x = 8;
ขอ้ มูลท่ีกำหนดกับชนดิ ของตัวแปรจะต้องเปน็ ข้อมลู ประเภทเดียวกนั ชนิดข้อมลู ในภาษาจาวาแบ่ง
ออกเป็น 2 ประเภทใหญ่ๆ ดังน้ี
1. ขอ้ มูลแบบพนื้ ฐาน (primitive data type)
2. ขอ้ มลู แบบอ้างองิ (reference data type)
ข้อมูลทั้งสองประเภทนจ้ี ะต่างกนั ตรงที่การอ้างถงึ ตำแหน่งหน่วยความจำทีใ่ ช้เก้บข้อมูลจรงิ ตัวอย่าง
ของขอ้ มูลแบบอ้างอิงจะศึกษาตอ่ ในเร่ืองของสตริงหรืออาร์เรย์ สำหรับขอ้ มลู แบบพ้ืนฐานในภาษาจาวายังแบ่ง
ออกได้ 4 กลุ่มดงั น้ี
1. ขอ้ มลู ชนิดตรรกะ (Logical)
2. ข้อมูลชนิดอกั ขระ (Textual)
3. ข้อมูลชนิดจำนวนเต็ม (Integer)
4. ขอ้ มูลชนดิ เลขทศนยิ ม (Floating point)
ขอ้ มลู ชนดิ ตรรกะ (Logical)
ข้อมูลประเทภนี้จะมีค่าแบบ Boolean โดยมีค่าเพียงสองค่าคือ true (จริง) กับ false (เท็จ)
ตัวอยา่ งเชน่
Boolean check = true;
Boolean no_check = false;
เปน็ การประกาศคา่ ตัวแปรชื่อ check ให้เป็นข้อมลู แบบบูลนี และกำหนดให้เป็นจริง
ส่วน no_check ถูกกำหนดให้เป็นตวั แปรแบบบลู นี และกำหนดให้เปน็ เทจ็
ข้อมลู ชนิดอักขระ (Textual)
ตัวอักขระเป็นขอ้ มูลท่มี คี วามยาวไมเ่ กนิ 1 ตวั อกั ษร การเก็บข้อมลู ประเภทนี้จะใชค้ ำว่า char ในภาษา
จาวาการเก็บข้อมูลตัวอักษรลงหน่วยความจำจะใช้รหัสแบบ Unicode ซึ่งเป็นรหัสที่มีขนาด 16 บิต การ
กำหนดข้อมูลที่เป็นตัวอักขระจะต้องเขียนอยู่ในเครื่องหมาย ‘-‘ (single quote) หรือกำหนดเป็นค่ารหัส
Unicode โดยตรงก็ได้ โดยใชส้ ญั ลักษณ์ \u นำหนา้ แลว้ ตามดว้ ยเลขฐานสิบหกของรหสั น้นั ตวั อย่างเช่น
char x,y; //ประกาศตวั แปร x และ y สำหรับเก็บอักขระ
x = ‘A’; //เก็บตวั อกั ขระ A ลงในตวั แปร x
y = ‘\u0041’; //เกบ็ รหัสอกั ขระของตวั A ลงในตัวแปร y
ขอ้ มูลชนิดจำนวนเตม็ (Integer)
ข้อมูลแบบเลขจำนวนเต็มมี 4 ประเภท คือ byte, short, int และ long แต่ละประเภทจะต่างกันท่ี
ขนาดของหน่วยความจำทีใ่ ชเ้ กบ็ ทำให้แตล่ ะประเภทเก็บขอ้ มูลได้ในช่วงทต่ี า่ งกัน อยา่ งเชน่ ตัวแปรแบบ byte
จะใช้เนื้อที่หน่วยความจำ 8 Bit ส่วนตัวแปรแบบ int จะใช้เนื้อที่หน่วยความจำ 32 bit ซึ่งทำให้ตัวแปรแบบ
int เก็บข้อมูลได้ในช่วงที่กว้างกว่า ในการประกาศตัวแปรสำหรับเก็บข้อมูลชนิดเลขจำนวนเต็ม จะต้องเลือก
ชนิดข้อมูลที่เหมาะสมให้กับตัวแปร ถ้าประกาศค่าตัวแปรที่มีขนาดใหญ่เกินไปจะทำให้โปรแกรมใช้พื้นท่ี
หน่วยความจำเกินความจําเป็น สำหรับขนาดของหน่วยความจำและช่วงขอ้ มลู ทเี่ กบ็ ได้ แสดงในตารางท่ี 2.2
ตารางท่ี 2.2 ข้อมลู แบบพืน้ ฐานในภาษาจาวา
ประเภทของข้อมูล ขนาด ช่วงการเก็บขอ้ มลู
boolean 1 บิต เก็บคา่ true หรือ false
char 2 ไบต์ เก็บรหสั อักขระแบบ Unicode
byte 1 ไบต์ -128 ถงึ +127
short 2 ไบต์ -32,768 ถงึ +32,767
int 4 ไบต์ -2,147,483,648 ถึง +2,147,483,647
long 8 ไบต์ -263 ถงึ +263 -1
float 4 ไบต์ +-3.40 x 10-38 ถงึ +-3.40 x 10+38
double 8 ไบต์ +-1.7 x 10-308 ถงึ +-1.7 x 10+308
เมอ่ื ประกาศตัวแปรชนิดเลขจำนวนเต็มแลว้ สามารถกำหนดคา่ ให้ตวั แปรไดเ้ ช่น แต่ถา้ ตวั แปรชนดิ น้ัน
เป็นชนิด long ต้องใช้ตัวอักษร l หรือ L ตามหลัง นอกจากนี้ยังกำหนดเป็นเลขฐานสิบหกได้อีกด้วยโดยใช้
0x (ศูนยเ์ อก็ ) นำหน้าตัวเลขนนั้ ตัวอยา่ งเช่น
int x; //ประกาศตัวแปร x เปน็ ข้อมูลชนิด int
long m; //ประกาศตัวแปร m เปน็ ข้อมูลชนิด long
x = 3; //กำหนดให้ x เก็บข้อมลู ทมี่ ีค่าเป็น 3
m = 32l; //กำหนดค่า 32 ให้กบั m ซึง่ เปน็ ข้อมลู ชนิด long
x = x1FE; //กำหนดค่าเลขฐานสบิ หก 1FE ใหก้ บั ตัวแปร x
ขอ้ มลู ชนดิ เลขทศนิยม (Floating point)
ข้อมูลประเภทนี้ใช้สำหรับเก็บเลขจำนวนจริง (real number) ในภาษาจาวามีอยู่ 2 ชนิดคือ float
และ double โดยข้อมูลแบบ float จะใช้หน่วยความจำในการเก็บ 32 bit ส่วนแบบ double จะใช้
หนว่ ยความจำ 64 bit ในภาษาจาวาเมื่อกำหนดข้อมูลท่เี ป็นเลขทศนิยมจะใหม้ ีข้อมูลเปน็ ชนิด double แต่ถ้า
เขียนข้อมูลทเี่ ปน็ ชนดิ float จะตอ้ งมีตัว f หรือ F ตามหลังด้วย ตวั อย่างเช่น
double m = 3.12; //กำหนดให้ m เกบ็ เลขทศนิยม 3.12
float x = 1.23f; //กำหนดให้ x เกบ็ เลข 1.23 ซึ่งเป็นตัวเลขชนดิ float
การกำหนดชอ่ื และคีย์เวริ ด์
การเขียนโปรแกรมจะต้องมีการกำหนดชื่อให้กับส่วนต่าง ๆ เช่น กำหนดชื่อให้กับตัวแปรของคลาส
ช่อื ของเมธอด หรอื ชอื่ ของค่าคงท่ี การกำหนดชอื่ ต่าง ๆ มีกฎการตั้งช่อื ดงั นี้
1. ต้องข้ึนต้นดว้ ยอักขระ A – Z, a – z, $ (dollar sign) หรอื _ เทา่ นัน้
2. ตวั ต่อมาอาจเป็นตวั เลขหรือตวั อกั ขระตามข้อ 1 ก็ได้
3. ตัวพิมพ์ใหญแ่ ละตัวพิมพเ์ ล็กมีความหมายตา่ งกนั
4. ตอ้ งไมม่ เี วน้ วรรคหระหว่างการตง้ั ช่อื
5. ตอ้ งไมซ่ ้ำกับคียเ์ วริ ์ดทจี่ าวารูจ้ กั
ตารางท่ี 2.3 คีย์เวิรด์ ในภาษาจาวา
Keywords list in Java
abstract continue for new switch
synchronized
assert default goto package this
throw
boolean do if private throws
transient
break double implements protected try
void
byte else import public volatile
while
case enum instanceof return
catch extends int short
char final interface static
class finally long strictfp
const float native super
ตัวอย่างการต้งั ช่ือ
x ถูกต้อง
dayofWeek ถูกต้อง
3dGraph ไมถ่ ูกตอ้ ง เนอื่ งจากขน้ึ ต้นด้วยตวั เลข
data1 ถูกต้อง
week day ไม่ถูกต้อง เนอื่ งจากมีเว้นวรรค
public ไมถ่ ูกตอ้ ง เน่ืองจากซ้ำกบั คีย์เวิร์ด
คา่ คงท่ี
การประกาศค่าคงที่ซึ่งมีค่าคงเดิมตลอดทั้งโปรแกรม จะใช้คำว่า final ไว้หน้าการประกาศชื่อ โดยมี
รปู แบบดงั นี้
รปู แบบ
final datatype CONSTANT_NAME = expression;
ชนิดข้อมลู ชอื่ คา่ คงที่ นิพจน์หรือค่าของข้อมูล
ตวั อย่างเช่น
final int MAX_DATA = 100;
final double Pi = 3.141;
การเขียนคอมเมน้ ในภาษาจาวา
ในการเขยี นโปรแกรมอาจต้องมีข้อความสำหรบั อธบิ ายส่วนต่างๆ ของโปรแกรม โดยข้อความเหล่าน้ีไม่มีผลต่อ
การทำงานของโปรแกรม ใช้อธิบายให้ผู้ที่อ่านโปรแกรมเข้าใจได้ง่ายเท่านั้น ในภาษาจาวามีคอมเม้นอยู่ 3
ประเภทคอื
คอมเม้นต์แบบบรรทัดเดียว เขียนโดยใช้เครื่องหมาย // ซึ่งหมายความว่าข้อความท่ีตามมาจนจบ
บรรทัดเปน็ คำอธบิ าย
คอมเม้นต์แบบหลายบรรทัด ใช้เขียนคำอธิบายตั้งแต่ 1 บรรทัดข้ึนไป โดยเริ่มต้นดว้ ยเคร่ืองหมาย
/* จบดว้ ยเครอื่ งหมาย */
คอมเม้นต์แบบเอกสารประกอบโปรแกรม คำอธิบายแบบนี้จะสร้างเป็นเอกสาร HTML เรียกว่า
documentation comment การเขียนจะเริ่มด้วยเคร่อื ง /** และจบด้วยเครือ่ งหมาย */
2.4 ตัวดำเนินการทางคณติ ศาสตร์
นิพจน์ของภาษาคอมพิวเตอร์จะใช้ตัวดำเนินการเป็นตัวเชื่อมตัวแปร ค่าคงที่ ให้ได้ผลลัพธ์ตามที่
ตอ้ งการ ตวั ดำเนนิ การในภาษาจาวามีอยู่หลายประเภท แต่ในหัวขอ้ นจี้ ะกล่าวถึงตวั ดำเนินการทางคณิตศาสตร์
กอ่ น ซ่งึ ถือว่าเปน็ ตัวดำเนนิ การทม่ี ีการใช้งานมากท่ีสุด ตวั ดำเนนิ การทางคณิตศาสตรใ์ นภาษาจาวา ดงั ตารางที่
2.4
ตารางท่ี 2.4 ตัวดำเนินการทางคณติ ศาสตร์
ตัวดำเนนิ การ ความหมาย ตวั อย่างนพิ จน์
+ บวก a+b
- ลบ a-b
* คณู a*b
/ หาร a/b
% หารเอาเศษจากการหาร a%b
จากตารางที่ 2.4 เป็นตัวดำเนินการที่ใช้ในการคำนวณทางคณิตศาสตร์ทั่วไป ตัวดำเนินการหารแบบ
MOD จะใช้สัญลักษณ์ % ซึ่งจะกระทำกับเลขที่เป็นจำนวนเต็ม ผลลัพธ์ที่ได้จะเป็นเศษของการหาร ส่วนตัว
ดำเนินการ + และ - มากระทำกบั ตวั ถูกดำเนินการตวั เดียวได้ เช่น -5, +4 เรยี กการใชhตวั ดำเนินการแบบนี้ว่า
unary ตัวอย่างนพิ จนท์ ี่ใช้ตัวดำเนินการทางคณติ ศาสตร์
amount = 4+8; //เกบ็ ค่า 12 ลงตัวแปร amount
total = total + tax; //เก็บคา่ total บวกกบั tax ลงในตัวแปร total
sale = price – discount; //เก็บค่า price ลบด้วย discount ลงในตวั แปร sale
markup = 12 * 0.25; //เกบ็ คา่ 3 ลงในตวั แปร markup
points = 100/20; //เกบ็ ค่า 5 ลงในตัวแปร points
leftover = 17 % 3; //เก็บคา่ เศษจากการหารคือ 2 ลงในตวั แปร leftOver
การหารเลขจำนวนเตม็
การเขยี นนพิ จน์หารเลขจำนวนเตม็ ด้วยเลขจำนวนเต็ม ผลลพั ธท์ ี่ไดจ้ ะเปน็ เลขจำนวนเตม็ โดยเศษท่ีได้
จากการหารจะถูกตดั ทง้ิ ไป พิจารณาการเขียนนพิ จนต์ ่อไปน้ี
double parts; //ประกาศตวั แปร parts เกบ็ เลขทศนิยม
parts = 17/3; //เก็บค่า 17 หารดว้ ย 3 ลงในตัวแปร part
System.out.println(parts); //แสดงผลคา่ parts
จากตัวอย่างด้านบน การหารค่า 17 ด้วย 3 จะได้ผลลัพธ์ออกมาเป็น 5 แต่เนื่องจากตัวแปร parts
ถูกประกาศเป็น double จะทำให้โปรแกรมแสดงผล 5.0 ออกมา แต่ถ้าหากประกาศตัวแปร parts เป็น int
parts; จะทำใหแ้ สดงผลลัพธเ์ ปน็ 5 แต่ถ้าหากเขียนการหารดงั ต่อไปน้ี
double parts;
parts = 17/3;
System.out.println(parts);
จะเปน็ การหารเลขทศนิยม 17.0 ด้วยเลขจำนวนเตม็ 3 ผลลัพธ์จะแสดงผลเป็น 5.66666666666667
ลำดบั ของตวั ดำเนินการทางคณติ ศาสตร์
การเขียนนิพจน์ทางคณิตศาสตร์อาจมีการใช้ตัวดำเนินการหลายๆ ตัวประกอบกันอยู่ในนิพจน์ ซึ่ง
ผู้เขียนโปรแกรมจะต้องคำนึงถึงลำดับในการทำงานของตัวดำเนินการด้วย ว่าตัวดำเนินการตัวใดจะทำก่อนตวั
ดำเนนิ การตัวใดจะทำ ตวั อยา่ งเช่น ถา้ หากเขยี นนพิ จน์ดงั ต่อไปนี้
outcome = 12 + 6 / 3;
การเขยี นนิพจนด์ ังกล่าวจะได้คำตอบ 14 เนือ่ งจากเคร่ืองหมาย / มีลำดับการทำงานก่อนเครื่องหมาย
+ ดังนั้น โปรแกรมจะนำ 6 ไปหารได้ 3 ก่อนได้คำตอบเปน็ 2 แล้วจึงนำไปบวกกับ 12 ทำใหไ้ ด้ผลลพั ธ์เป็น 14
ดังตารางที่ 2.5 เปน็ ลำดบั ความสำคัญของตวั ดำเนนิ การทางคณิตศาสตรจ์ ากมากไปหาน้อย ส่วนตวั ดำเนินการ
ท่ีอยลู่ ำดับเดยี วกันจะเรียงความสำคัญจากซา้ ยไปขวา
ตารางท่ี 2.5 ลำดับความสำคัญของตัวดำเนินการทางคณิตศาสตร์
ตวั ดำเนินการ ลำดับความสำคญั
- (unary negation) ความสำคัญสูงสดุ ถา้ มหี ลายตัวในนพิ จน์เดยี วกันจะเรียงจากขวาไปซ้าย
* / % ความสำคญั รองลงมา ถ้ามหี ลายตวั ในนพิ จน์เดยี วกันจะเรยี งจากซา้ ยไปขวา
+ - ความสำคญั ตำ่ สุด ถ้ามีหลายตวั ในนิพจนเ์ ดียวกนั จะเรยี งจากซา้ ยไปขวา
ตวั อย่างการประมวลผลทางคณติ ศาสตร์
5+2*4 ไดค้ ่าเป็น 13
10 / 2 - 3 ได้คา่ เปน็ 0
8 + 12 * 2 - 4 ไดค้ ่าเปน็ 28
สำหรบั นพิ จน์ทีม่ ีการประมวลผลที่ซับซ้อน ผเู้ ขยี นโปรแกรมอ่านทำความเข้าใจการประมวลผลได้ยาก
ดงั นัน้ ควรใช้เคร่อื งหมายวงเลบ็ เพอ่ื เป็นการระบใุ หท้ ำสว่ นใดกอ่ นท่จี ะทำตวั ดำเนนิ การตัวตอ่ ไป ตวั อยา่ งเช่น
10 / ( 5 - 3) ไดค้ ่าเปน็ 5
( 4 + 17) % 2 – 1 ได้คา่ เปน็ 0
(6 - 3) * (2+7)/3 ไดค้ ่าเปน็ 9
ตวั ดำเนนิ การแบบยอ่ (Shortcut Operator)
การเขียนนิพจน์ทางคณิตศาสตรท์ ั่วไป จะนำการกระทำทางดา้ นขวามือมาใส่ให้กับตวั แปรทางซา้ ยมอื
ตวั อยา่ งเชน่ ถ้าหากตอ้ งการเพมิ่ คา่ ตัวแปร x ขน้ึ 1 ค่าสามารถเขียนได้ ดังน้ี
x = x + 1;
หรือถา้ หากตอ้ งการนำตัวแปร x คณู กบั 10 แล้วเก็บในตวั แปร x จะเขยี นไดด้ ังน้ี
x = x * 10;
การเขยี นนิพจน์ใน 2 ตวั อยา่ งทผ่ี า่ นมานี้สามารถเขียนใหมโ่ ดยช้ตัวดำเนินการแบบยอ่ ได้ดังน้ี
x += 1; และ x *= 10;
ตวั ดำเนินการแบบยอ่ นส้ี ามารถเขยี นกบั ตวั แปรได้เชน่ กนั ตวั อยา่ งเชน่
balance = balance + deposit;
เขียนใหม่ไดเ้ ป็น
balance += deposit;
ในภาษาจาวามกี ารใชต้ วั ดำเนินการแบบตอ่ 5 ตัว ดงั ตัวอย่างในตารางที่ 2.6
ตารางท่ี 2.6 ตัวดำเนินการแบบย่อ
ตวั ดำเนนิ การ ตวั อย่าง ความหมาย
+= x += 5; x = x + 5;
x = x – 2;
-= x -= 2; x = x * 10;
x = x / b;
*= x *= 10; x = x % 3;
/= x /= b;
%= x %= 3;
ตัวดำเนินการเพ่มิ ค่าและลดค่า
การเปลี่ยนแปลงค่าของตัวแปรโดยการเพิ่มค่าหรือลดค่าครั้งละ 1 ถูกใช้อย่างมากในการเขียน
โปรแกรมคอมพิวเตอร์ ในภาษาจาวาจึงมีตวั ดำเนินการเพิ่มค่า (Increment operator) โดยใชเ้ ครอ่ื งหมาย ++
และตัวดำเนินการลดค่า (decrement operator) โดยใช้เครื่องหมาย -- ตัวดำเนินการทั้งสองสามารถใชไ้ ด้ทัง้
หนา้ และตัวแปรและหลงั ตวั แปร ตวั อยา่ งเช่น
x++; หลงั ประมวลผลจะไดเ้ ปน็ x = x+1;
++x; หลังประมวลผลจะไดเ้ ป็น x = x+1;
x--; หลังประมวลผลจะไดเ้ ปน็ x = x-1;
--x; หลงั ประมวลผลจะได้เปน็ x = x-1;
การใชต้ วั ดำเนนิ การเพิม่ คา่ และลดคา่ นี้ถา้ เขียนเปน็ นิพจน์ โดยมีการสง่ คา่ ให้กับตวั แปรทางซ้ายมือด้วย
ตำแหน่งของตัวดำเนินการจะมีผลกับการทำงานของโปรแกรม โดยการใส่ตัวดำเนินการด้านหน้าและด้านหลัง
ตวั แปรจะได้ผลลพั ธไ์ ม่เหมอื นกัน ตัวอย่างเชน่
y = ++x;
จะเป็นการเพิ่มค่า x ขึ้น 1 ค่าก่อนแล้วจึงส่งให้ตัวแปร y ผลลัพธ์ท่ีได้จะทำให้ตัวแปร x และ y มีค่า
เทา่ กัน แตห่ ากเขยี นเปน็
y = x++;
จะเป็นการนำค่า x ไปให้กับ y ก่อนแล้วจึงเพิ่มค่า x ผลลัพธ์ที่ได้จะทำให้ตัวแปร x และ y มีค่าไม่
เทา่ กนั
การเปลย่ี นประเภทของขอ้ มูล
ในการเขียนนิพจน์ทางคณิตศาสตร์ หรือการกำหนดค่าให้กับตัวแปร บางครั้งข้อมูลในนิพจน์จะเป็น
ข้อมูลที่ต่างกัน หรือเป็นข้อมูลที่มีขนาดต่างกัน compiler ภาษา Java สามารถแปลงข้อมูลให้มีรูปแบบที่
สอดคลอ้ งกนั ได้ การแปลงประเภทของข้อมลู มอี ยู่ 2 รปู แบบคอื
การแปลงข้อมลู ใหม้ ีขนาดใหญ่ขนึ้ (widening conversion)
การแปลงขอ้ มลู ใหม้ ขี นาดเลก็ ลง (narrowing conversion)
โดยทั่วไปมักจะเป็นการแปลงข้อมูลให้มีขนาดใหญ่ขึ้น อย่างเช่น ถ้าหากมีข้อมูลแบบ byte ซึ่งเป็น
ข้อมูลแบบ 8 บิต ถูกนำไปบวกกับข้อมูลแบบ short ซึ่งเป็นข้อมูลแบบ 16 บิต คอมไพเลอร์จะแปลงข้อมูล
แบบ 8 บิตให้เป็นข้อมูลแบบ 16 บิต โดยการเติมไบต์สูงให้เป็นค่า 0 ทั้งหมดลงไป ซึ่งจะทำให้ผลบวกเป็น
ข้อมูล short แต่ถ้าเป็นการแปลงข้อมูลให้มีขนาดเล็กลงอาจทำให้การประมวลผลข้อมูลเกิดความเสียหายได้
นอกจากนี้ในภาษาจาวาสามารถแปลงข้อมูลแบบจำนวนเต็มให้เป็นข้อมูลแบบเลขทศนิยมได้อีกด้วย
ตวั อยา่ งเช่น
int x; //ประกาศตวั แปร x เปน็ จำนวนเต็มขนาด 4 ไบต์
double y = 2.5; //ประกาศตัวแปร y เปน็ จำนวนเต็มขนาด 4 ไบต์
x = y; //นำค่าตวั แปร y ไปใส่ในตวั แปร x
ถ้าหากเขียนโปรแกรมดังด้านบนนี้ จะเป็นการนำค่า double ที่มีค่าเป็น 2.5 เก็บลงในตัวแปรแบบ
int แมว้ ่าตวั แปรทัง้ สองมีขนาดเท่ากนั แต่ก็ไม่สามารถทำได้ ถา้ หากคอมไพล์แลว้ จะแจ้งข้อผิดพลาดออกมาว่า
“possible loss of precision .”
int x; //ประกาศตัวแปร x เป็นจำนวนเตม็ ขนาด 4 ไบต์
short y = 2; //ประกาศตัวแปร y เกบ็ คา่ 2 ขนาด 2 ไบต์
x = y; //นำคา่ ตัวแปร y ไปใส่ในตัวแปร x
ถ้าหากเขียนส่วนของโปรแกรมดังด้านบน โปรแกรมจะทำงานได้เนื่องจากนำข้อมูลจากตัวแปรที่เล็ก
กวา่ ไปใสต่ ัวแปรท่ใี หญ่กวา่ ตัวอยา่ งเชน่
double x;
int y = 10;
x = y;
System.out.println(x);
เขียนของโปรแกรมดังดา้ นบนจะทำได้ โดยโปรแกรมจะแปลงเลข 10 ไปเก็บเป็นเลขทศนิยม ซึ่งจะให้
เอาพูดออกมาเป็น 10.0
การแปลงขนาดข้อมูลโดยใช้ Cast Operators
ในภาษาจาวาสามารถแปลงประเภทของจากข้อมูลที่มีขนาดใหญ่กว่าให้เป็นข้อมูลที่มีขนาดเล็กลงได้
โดยใช้ Cast Operators เพิ่งจะเขียนประเภทของข้อมูลที่ต้องการแปลงไว้ในเครื่องหมายวงเล็บ แล้วนำไปไว้
ด้านหนา้ ของตัวแปรหรือนพิ จน์ทต่ี ้องการ ตวั อยา่ งเช่น
x = (int)number;
จะส่งกลับข้อมูลที่อยู่ใน number โดยแปลงให้เป็นเลขจำนวนเต็มประเภท int ก่อน แล้วเก็บไว้ในตัว
แปร x โดยทต่ี วั แปร x ต้องประกาศเปน็ int ดว้ ย เชน่
x = (long) 3.7; //ส่งค่าเลข 3 ซง่ึ เปน็ จำนวนเตม็ แบบ long ให้กบั ตัวแปร x
number = (int)72.567 //ส่งค่า 72 ให้กบั ตัวแปร number
value = (float)x; //ทำคา่ x ให้เป็นแบบ float แล้วสง่ ใหต้ ัวแปร value
ตัวอย่าง //ประกาศตัวแปร x และ y เป็นแบบ double
//x มคี ่าเท่ากับ 5.0/4 ซึ่งเท่ากับ 1.25
double x,y //y มีค่าเท่ากับ (double)(1) ซง่ึ เท่ากับ 1.0
x = (double)5/4;
y = (double)(5/4);
ในการเขียนโปรแกรมบางครั้งมีความจำเป็นต้องเปลี่ยนประเภทของข้อมูล พิจารณาตัวอย่างส่วนของ
โปรแกรมตอ่ ไปน้ี
int pies = 10, people = 4;
double piesPerPerson;
piesPerPerson = pies / people;
จากส่วนของโปรแกรมด้านบนการหารเลขจำนวนเต็ม 10 ด้วยค่า 4 ผลลัพธ์ที่ได้จะต้องเป็น 2.5 และ
เก็บในตัวแปร piesPerPerson แต่การหารดังกล่าวในภาษาจาวาจะได้คำตอบเป็น 2.0 เนื่องจากคอมไพเลอร์
จะมองว่าเป็นการหารเลขจำนวนเต็มด้วยเลขจำนวนเต็ม เนื่องจากตัวแปรทั้ง 2 ตัวที่นำมาหารกันเป็นตัวแปร
แบบเลขจำนวนเตม็ ดงั น้ันจะต้องเปล่ยี นใหเ้ ปน็ การหารแบบเลขทศนยิ มหารดว้ ยจำนวนเต็ม ไดด้ งั นี้
int pies = 10, people = 4;
double piesPerPerson;
piesPerPerson = (double)pies / people;
หรอื เขยี นเป็นการหารเลขจำนวนเต็มดว้ ยเลขทศนยิ ม
piesPerPerson = pies/(double)people;
การเขียนนิพจน์ทางคณติ ศาสตร์ในภาษาจาวามีการเปล่ียนแปลงประเภทของข้อมูลดงั นี้
1. ถ้าหากมีตัวถูกดำเนินการตัวหนึ่งเป็นข้อมูลชนิด double ตัวถูกดำเนินการอีกตัวจะเปลี่ยนเป็น
double โดยอัตโนมัติ ส่งผลให้ผลลัพธ์ที่ได้เป็นข้อมูลชนิด double ตัวอย่างเช่น ถ้าตัวแปร a เป็น double
ตวั แปล b เป็น double และ c เปน็ int แลว้ มีการเขียนนพิ จนต์ ่อไปนี้
a = b + c;
จะทำใหต้ ัวแปร c ถูกเปลี่ยนเปน็ double โดยอัตโนมตั ิ
2. มีตัวถูกดำเนินการตัวหน่ึงเปน็ ขอ้ มูลชนดิ float ตัวถูกดำเนินการอีกตัวหนึ่งเป็นขอ้ มูลท่ีเลก็ กว่า จะ
ทำให้ถูกตัวดำเนินการอีกตัวหนึ่งเปลี่ยนเป็น float โดยอัตโนมัติ ตัวอย่างเช่น ถ้าตัวแปร x เป็น short ตัวแปร
y เป็น float แลว้ มีการเขยี นนพิ จน์ต่อไปนี้
z = x * y;
จะทำให้ตัวแปร x ถูกเปลี่ยนเป็น float ผลลัพธ์ที่ได้อาจเป็น float หรือ double ก็ได้ขึ้นกับขนาด
ของข้อมลู
3. ถา้ หากตวั แปรในนิพจน์เป็นเลขจำนวนเต็ม โดยมตี วั ถูกดำเนินการตวั หนึง่ เป็นข้อมูลประเภท long
ตัวถูกดำเนินการอีกตัวหน่ึงจะถูกเปล่ียนเปน็ long โดยอัตโนมัติ ตัวอย่างเช่น ถ้า a เป็น long ตัวแปร b เป็น
short แลว้ มกี ารทำนพิ จน์ดังต่อไปนี้
c = a – b;
ตวั แปร b จะถูกเปลี่ยนเป็น long และผลลัพธ์ท่ไี ดจ้ ากเป็น long
2.5 คลาสสตริง (String Class)
ข้อความสตริงในภาษาจาวาจะต่างจากภาษา pascal หรือภาษาซี โดยภาษาจาวาจะมองเป็นข้อมูล
แบบอ้างองิ การเก็บขอ้ มูลสตริง ลงในตวั แปรจะไมใ่ ชก่ ารเก็บข้อมลู ลงหน่วยความจำจริงๆ แต่จะเป็นการอ้างไป
ที่หน่วยความจำที่เก็บสตริงนัน้ อยู่ การประมวลผลกับสตริงนั้น จาวาจะมองเป็น object ของคลาส String ซ่ึง
สามารถประกาศตัวแปรไดด้ ังนี้
String name; ชอ่ื คลาส ช่อื ตวั แปรออบเจ็กต์ว
คลาสสตริง ชื่อออบเจ็กต์
ถ้าหากเป็นข้อมูลแบบพื้นฐานทั่วไปเช่น ประกาศตัวแปร number เป็นข้อมูลประเภท int แล้วมีการ
เขียนสเตดเม้นตอ่ ไปนี้
number = 25;
จะเป็นการนำคา่ 25 ไปเก็บในหน่วยความจำช่อื number
แต่ถ้าหากเขียนเป็น
String name = “Computer”;
การประกาศออบเจ็กต์ของคลาสสตริงชื่อ name โดย name นี้เก็บคำว่า “Computer” ซึ่งจาวาจะ
มองตัวแปร name นี้อยู่ที่หน่วยความจำตำแหน่งหนึ่ง โดยหน่วยความจำนี้จะชี้ไปยังตำแหน่งหน่วยความจำ
อีกตำแหน่งหนึ่งที่เก็บคำว่า “Computer” ตัวแปร name ที่ประกาศขึ้นนี้เรียกว่าตัวแปรแบบอ้างอิง
(Reference Variable)
ตวั แปร name String object
address “Computer”
ออบเจ็กต์ของสตรงิ นีส้ ามารถนำตัวดำเนินการ + มาเป็นตัวเชื่อมข้อความสตริงส่งข้อความเข้าดว้ ยกนั
ตัวอยา่ งเช่น
String firstName,lastName,fullName; //ประกาศตวั แปรจำนวน 3 ตวั เก็บไว้ในสตรงิ
firstName = “Bill”; //กำหนดค่าเร่มิ ตน้ ให้กับ firstName
lastName = “Smith”; //กำหนดคา่ เริม่ ตน้ ให้กับ lastName
fullName = firstName + “ “ + lastName
สเตดเมนตด์ า้ นบนจะรวมคำวา่ “Bill” กลบั เว้นวรรค “Smith” ทำใหต้ วั แปร fullName ชีไ้ ปยังออบ
เจ็กทีเ่ กบ็ คำว่า “Bil l Smith”
หาตัวดำเนินการ + ไปรวมกับข้อความสตริงกับตัวเลขจะทำให้ได้ข้อมูลทั้งหมดเป็นสตริง ดังตัวอย่าง
ต่อไปนี้
“number” +3 +4; จะไดเ้ ปน็ “number 34”
“number” +(3 + 4); จะได้เปน้ “number 7” เนื่องจากจะรวม 3 กบั 4 แบบตวั เลขกอ่ น
“number” 3 * 4; จะไดเ้ ป็น “number 12”
3 + 4 + “number”; จะไดเ้ ป็น “7 number”
จะเห็นว่าการสร้างตัวแปรเก็บข้อมูลสตริงจะต้องทำโดยการสร้างตัวแปรแบบอ้างอิงขึ้นมา โดยเป็น
ออบเจก็ ตข์ องคลาส String โดยในคลาสนจ้ี ะมเี มธอดตา่ ง ๆ ให้ใช้ได้มากมาย การเรียกใช้เมธอดทำได้โดยเรียก
ตัวแปรอ้างอิงขึ้นมาตามด้วยเครื่องหมายจุด (.) เพื่อระบุว่าจะเรียกใช้เมธอดในคลาสและตามด้วยเมธอดที่
ตอ้ งการเรียกใช้ ซึง่ มรี ูปแบบดังนี้
รปู แบบ
ReferenceVariable . method(arguments…)
อารก์ วิ เม้นของเมธอด (ถา้ มี)
ตัวแปรทอี่ า้ งถึงออบเจ็กต์ เคร่ืองหมายจดุ ช่ือเมธอดท่ีตอ้ งการเรยี กใช้
ในตารางที่ 2.7 เป็นตัวอย่างของเมธอด ที่สามารถให้ออบเจ็กต์ในคลาส String เรียกใช้ได้ สำหรับ
รายละเอียดต่างๆ สามารถศึกษาได้จากคู่มือของ Sun โดยตรง ในการเรียกใช้เมธอดใดนั้น ผู้เขียนโปรแกรม
จะตอ้ งทราบว่าเมธอดนน้ั มกี ารสง่ อาร์กวิ เมนตเ์ ข้าไปหรือไม่ และเมอื่ เรียกใช้แลว้ จะคนื ค่าใดออกมา
ตารางที่ 2.7 ตัวอย่างน้ีเมธอดในคลาส String
Method การทำงาน
charAt(index) อ่านตัวอักขระจากสตริง โดย index คือลำดับที่ต้องการอ่าน ตัวแรกมีลำดับ
เป็น 0
length() หาความยาวสตริง โดยคืนคา่ เป็นเลขจำนวนเตม็
toLowerCase() เปลีย่ นตวั อักขระในสตรงิ ให้เปน็ ตวั พิมพ์เล็ก
toUpperCase() เปลี่ยนตัวอกั ขระในสตรงิ ให้เป็นตวั พิมพใ์ หญ่
ตวั อยา่ ง
char letter; //ประกาศตวั แปร letter เปน็ char
String name = “Herman”; //เรยี กเมธอด charAt() เพ่ืออ่านคา่ ตวั อักขระตวั ท่ี 4
letter = name.charAt(3)
หลังจากทำสเตดเมนต์ดา้ นบนจะทำใหต้ วั แปร latter เกบ็ ตัวอกั ขระ ‘m’
ตัวอยา่ ง
int stringSize; //ประกาศคา่ ตัวแปร stringSize เปน็ เลขจำนวนเตม็
String name = “Herman”; //เรียกเมธอด length() เพ่อื หาความยาวอกั ขระ
stringSize = name.length();
หลงั ทำสเตดเมนตจ์ ะทำใหต้ วั แปร stringSize เกบ็ 6 ซง่ึ คือความยาวของตัวอกั ขระที่ name อา้ งถึง
ตัวอยา่ ง
String bigName = “HERMAN”;
String littleName = bigName.toLowerCase(); //เรียกออบเจก็ ตเ์ ปลยี่ นสตรงิ ให้เป็นตวั เลก็
หลังทำสเตดเมนต์ดา้ นบนจะทำให้ออบเจ็กตท์ ี่อ้างโดย littleName เก็บคำว่า “herman”
ตัวอย่าง
String littlename = “herman”;
String bigName = littleName.toUpperCase(); //เรียกออบเจ็กตเ์ ปลยี่ นสตรงิ ใหเ้ ป็นตวั ใหญ่
หลงั ทำสเตดเมนต์ด้านบนจะทำใหอ้ อบเจ็กตท์ ่อี ้างโดย bigName เก็บคำว่า “Herman”
2.6 เมธอดรับข้อมูลพื้นฐาน
การเขียนโปรแกรมคอมพิวเตอร์แบบพื้นฐานมักจะเริ่มจากการรับข้อมูลฐานคีย์บอร์ดและแสดงผล
ข้อมูลออกทางจอภาพ จากที่ได้ศึกษามาเราได้รู้จักเมธอดในการแสดงผลข้อความออกทางจอภาพมาแล้ว
สำหรับการรับข้อมูลทางคีย์บอร์ดในภาษาจาวานั้นจะต้องสร้างออบเจ็กต์ของคลาส Scanner ขึ้นมา โดยเริ่ม
จากประกาศตัวแปรออบเจ็กต์ก่อน โดยการประกาศตัวแปรออบเจ็กต์จะคล้ายกับการประกาศตัวแปรทั่วไป
ตัวอย่างเช่น
Scanner keyboard;
จะประกาศตัวแปรออบเจ็กต์ชื่อ keyboard ให้อยู่ในคลาส Scanner เพื่อใช้เป็นตัวแปรออบเจ็กต์ใน
การรับข้อมูลทางแป้นพิมพ์ จากนั้นจะต้องสร้างออบเจ็กต์ขึ้นมาโดยใช้คีย์เวิร์ดคำว่า new ซึ่งจะทำให้
คอมพิวเตอรจ์ องหน่วยความจำเพื่อทำให้ตวั แปรออบเจก็ ตน์ นั้ สามารถอ้างถึงได้ ซงึ่ มรี ูปแบบดังนี้
รูปแบบ
ตวั แปรออบเจก็ ต์ = new ช่อื คลาส(อากวิ เมนต์);
ดงั น้ัน ถา้ จะใหต้ ัวแปร keyboard รบั ค่าทางแป้นพิมพ์จะตอ้ งสร้างออบเจก็ ต์ขนึ้ มาโดยให้มีอากิวเมนต์
เป็น System.in ซงึ่ เขยี นดงั นี้
keyboard = new Scanner(System.in);
ในภาษาจาวาจะยอมให้เขยี นท้ัง 2 ขน้ั ตอนนพ้ี ร้อมกันได้ซงึ่ เขยี นไดเ้ ป็น
ประกาศตวั แปรชอ่ื keyboard เปน็ ตัวแปร สรา้ งออบเจก็ ต์ในหนว่ ยความจำ และ
แบบอ้างองิ ของคลาส Scanner อา่ นขอ้ มลู ทางอนพุตจาก System.in
Scanner keyboard = new Scanner(System.in);
ให้ตัวแปร keyboard ชีไ้ ปยงั ออบเจก็ ต์ทส่ี ร้าง
ในคลาส Scanner นั้นมีเมธอดขสึ้นำหรับอ่านข้อมูลประเภทต่างๆ เข้ามาทางแป้นพิมพ์ ซึ่งผู้เขียน
โปรแกรมจะต้องทราบว่าถ้าหากต้องการรับข้อมูลประเภทใด จะต้องใช้เมธอดใดในการรับข้อมูลเข้ามา
ตวั อย่างเช่น ถา้ หากตอ้ งการรบั ขอ้ มลู ประเภทตัวเลขจำนวนเตม็ เข้ามาสามารถทำไดโ้ ดยเขยี นสเตดเมนตด์ งั นี้
int number;
Scanner keyboard = new Scanner(System.in);
System.out.print(“Enter an integer value:”); //แสดงข้อความก่อนรับข้อมูล
number = keyboard.nextInt(); //รบั เลขจำนวนเต็มมาเก็บในตัวแปร number
จากสเตดเมนต์ด้านบนจะเรียกเมธอด nextInt() ซ่ึงเป็นเมธอดของคลาส Scanner สำหรับรับข้อมูลที่
เป็นตัวเลข Integer เข้ามาทางแป้นพิมพ์ สำหรับเมธอดอ่ืนๆ เป็นดังตารางท่ี 2.8 ในการใช้งานจะตอ้ งสร้างตวั
แปรหรอื อ็อบเจกต์เขา้ มารับขอ้ มูลที่เกิดจากการทำงานของเมธอดเหล่านนั้ ด้วย
ตารางที่ 2.8 ตวั อย่างเมธอดในคลาส Scanner
เมธอด การทำงาน
nextByte() รับข้อมลู เลขจำนวนเตม็ ชนิด Byte ทางแปน้ พมิ พ์
nextDouble() รบั ขอ้ มลู เลขทศนิยมชนดิ Double ทางแปน้ พิมพ์
nextFloat() รบั ข้อมลู เลขทศนิยมชนดิ float ทางแป้นพิมพ์
nextInt() รบั ขอ้ มลู จำนวนเตม็ ชนิด Int ทางเปน็ พิมพ์
nextLine() ขอ้ มูลแบบสตริงทางแป้นพิมพ์
nextLong() รบั ขอ้ มูลตวั เลขชนดิ Long ทางแป้นพมิ พ์
nextShort() รบั ข้อมลู ตวั เลขชนิด Short ทางแปน้ พมิ พ์
ตวั อยา่ ง ถา้ หากตอ้ งการรับขอ้ มลู เลขจำนวนเต็ม สามารถเขยี นสว่ นของโปรแกรมไดด้ ังนี้
int number; //ประกาศตวั แปร number สำหรบั เก็บเลขจำนวนเตม็
Scanner keyboard = new Scanner(System.in);
System.out.print(“Enter an integer value:”);
number = keyboard.nextInt(); //เรียกเมธอด nextInt() เพ่ือรับคา่ เลขจำนวนเตม็
ตวั อยา่ ง ถ้าหากต้องการรับขอ้ มูลประเภทสตริงทางแปน้ พิมพ์สามารถเขียนสว่ นของโปรแกรมได้ดังนี้
int name; //ประกาศ name เป็นออบเจ็กตใ์ นคลาส String
Scanner keyboard = new Scanner(System.in);
System.out.print(“Enter your name:”);
number = keyboard.nextInt(); //เรียกเมธอด nextInt() เพ่ือรบั ขอ้ มูลสตริง
การใช้ import
ในภาษาจาวาคลาสต่าง ๆ ที่ผู้เขียนโปรแกรมสามารถเรียกใช้งานได้จะถูกรวมเอาไว้เป็นแพ็กเกจ ซึ่ง
ผู้เขียนโปรแกรมจะต้องทราบว่าคลาสที่ต้องใช้งานนั้นอยู่ในแพคเกจใด โดยจะต้องใช้คำสั่ง Import เพื่อบอก
ให้คอมไพเลอร์รู้ว่าจะนำคลาสนั้นมาจากที่ใด โดยเขียนคำสั่ง Import ไว้ที่ส่วนหัวของโปรแกรม ไว้ที่ส่วนหัว
ของโปรแกรมสำหรับรายละเอียดในเรื่อง import นี้จะได้กล่าวรายละเอียดต่อไปในบทที่จะศึกษาเรื่องคลาส
ตัวอย่างเช่น การใชง้ านคลาส Scanner จะตอ้ งเขียนดังน้ี
import java.util.Scanner;
เปน็ การเรียกใชค้ ลาส Scanner ทีเ่ กบ็ อยู่ใน util น้ีเกบ็ อยู่ในแพ็กเกจหลกั ชื่อ java