Introduction to Programming Java Language

i

สารบัญ กอนจะถึง Java 1 intro. to Java (FEU.faa)
บทที่ 1 21
บทท่ี 2 1.1 ทาํ ไมถงึ เลอื ก Java เปนภาษาในการเขยี น code
1.2 กอ นทเ่ี ราจะเขยี นโปรแกรมดว ย Java ตองมีอะไรบา ง 75
บทท่ี 3 1.3 เตรียมความพรอ ม

1.3.1 ติดต้งั JDK
1.3.2 การกําหนด path
1.4 เขียน code แบบ application หรือ applet
1.5 เครอ่ื งมือหรือคาํ ส่งั (SDK tools) ทตี่ องใชในการพฒั นาโปรแกรม
1.6 การสรางโปรแกรม Java ท่ีเปน application
1.6.1 การ compile โปรแกรม HelloWorld
1.6.2 การ execute โปรแกรม HelloWorld
1.6.3 สรุปขัน้ ตอนของการพัฒนาโปรแกรมท่เี ปน application
1.7 การสรางโปรแกรม Java ท่เี ปน applet
1.7.1 สรุปขัน้ ตอนการเขยี นโปรแกรมแบบ applet
1.8 การเขียน Java program ดว ย Crimson Editor
1.9 การใช NetBeans 5.0 สําหรบั การพัฒนาโปรแกรม
1.10 ทีม่ าของ Java โดยสงั เขป

ขอมูล ตวั แปร และ การประมวลผล

2.1 ขอมูล และ ตวั แปร (data and variables)
2.2 ชนดิ ของขอมูล (datatype)

Keyword
Primitive datatype
2.3 ตัวอยางการประกาศตัวแปร
2.3.1 การกําหนดคาใหกับตวั แปร
2.3.2 การกาํ หนดคาใหกบั ตัวแปรภายในโปรแกรม
2.4 การใช final ในการกําหนดคาใหกับตัวแปร
2.5 อายุ และ ขอบเขตการใชงาน (life-time and scope) ของตัวแปร
2.6 การสรางประโยค (statement and expression)
2.7 การประมวลผล
2.7.1 การประมวลผลขอมลู ทเ่ี ปน integer
2.7.2 การประมวลผลดวย integer ขนาดเล็ก
2.7.3 การเปลย่ี นแปลงชนดิ ของขอ มูล (casting)
2.8 การประมวลดว ยตวั แปรท่มี จี ุดทศนยิ ม (Floating-point Calculations)
2.8.1 การใช printf() ในการแสดงผล

2.8.1.1 การใชเ ครอื่ งหมายอืน่ ๆ (flag) ใน printf()
2.8.2 การใช format() แทน printf()
2.8.3 การแสดงผลที่ไมตองใชค าํ วา System นําหนา
2.9 การประมวลผลขอ มูลตางชนดิ กัน (Mixed Type Calculations)
2.9.1 Autoboxing และ Unboxing
2.10 การประมวลผลตัวเลขท่มี ีขนาดใหญ
2.10.1 การใช BigInteger
2.11 การใช Mathematical Functions ตา ง ๆ ที่ Java มใี ห
2.12 การใชข อ มลู ท่ีเปนตัวอักษร (char)
2.13 การใชตัวแปรชนดิ boolean
Logical operator
Relational operator
2.14 การประมวลระดับ bit ดว ยการใช operator shift และ bitwise
2.15 การกําหนดคาใหต วั แปรผา นสื่อการนําเขา ขอ มูลมาตรฐาน
2.15.1 การนําขอ มูลเขา ผา นทาง Scanner
2.15.2 การนาํ ขอมูลเขาและออกผา น Dialog Box
2.16 การใช enum

การตัดสินใจ และการประมวลผลแบบวน

3.1 การตัดสนิ ใจ และ การเปรยี บเทยี บ
3.1.1 การใช if เพอื่ การตัดสนิ ใจ
3.1.2 การใช if ในประโยคทม่ี ีมากกวา หนง่ึ ประโยค (if-block)
3.1.3 การใช enum กับ if-else

3.2 การใช Conditional operator (? :)
3.3 การใชค าํ ส่งั switch
3.4 การทาํ งานแบบวน (Repetition หรือทีเ่ รยี กกันงาย ๆ วา Loop)

3.4.1 การใช for/loop
3.4.1.1 การใช for-in/loop (for/each)

3.4.2 การใช while/loop

ii

บทที่ 4 3.4.3 การใช do-while/loop 117 intro. to Java (FEU.faa)
บทที่ 5 3.5 การใช break และ continue 159
3.6 การใช loop ใน loop
บทที่ 6 3.7 การใช label continue และ label break ใน for/loop 207

Array และ String

4.1 อารเรย (Array)
4.2 การกําหนดคา เบอ้ื งตนใหก ับ Array
4.3 การอางถึง array ดวยการ clone และการ copy array
4.4 การใช array แบบยืดหยุน (Dynamic Array)
4.5 การคนหาขอมลู ใน array (Searching)

4.5.1 การคนหาแบบตามลาํ ดับ (Sequential search)
4.5.2 การคน หาแบบไบนารี (Binary search)
4.6 การจัดเรยี งลาํ ดบั (sort) ขอมลู ใน array
4.7 การสรา ง array ทมี่ ขี อ มลู เปน array (Array of arrays)
4.7.1 การใช array ที่มีจาํ นวนของขอมลู ในแตละแถวไมเ ทากนั
4.8 String
4.8.1 Array of characters
4.8.2 String ใน Java
4.8.3 การเปรียบเทียบ String
4.8.4 การเปรียบเทยี บความไมเทา กันของ String
4.8.5 การเขาหาตวั อกั ษรที่อยูใน String
4.8.6 การใช class StringBuffer ในการสรา ง String
4.8.7 การกาํ หนดใหข อมลู ของ array เปน String (Array of Strings)

Objects และ Classes

5.1 Class และ Object
[Class Modifier]
[Field Modifier]
5.1.1 Object และองคป ระกอบของ object
[สิง่ ท่ตี องคิดเมอื่ ออกแบบ Class (เมอ่ื สราง Object)]
5.1.2 ขอ แตกตา งระหวาง class กบั object

5.2 Method (สงิ่ ที่ object ทาํ ได)
5.2.1 การเขา หาตวั แปร และ method ของ class
5.2.2 การสรา ง method
[Method Modifier]
5.2.3 กระบวนการท่เี กิดขึน้ เมื่อมีการใช parameter list
5.2.4 การสง คาอา งอิง (Passing object's reference)
[การสลับคา ของส่ิงสองสิง่ ]

5.3 การเขา หา field ของ class (attributes หรอื access modifier)
[finalize method]

5.4 Constructor อีกคร้ัง
[initialization blocks]
[static initialization blocks]
[constructor overloading]
5.4.1 การเรยี ก constructor จาก constructor
[this]

5.5 การ overload method
5.5.1 การสง parameter แบบไมจาํ กดั จํานวน (Varargs)

5.6 การสรา ง class ภายใน class (nested class)
5.6.1 ตวั อยา งการสราง class: MyArray

5.7 Generic Class
[การสงคาที่เปน generic ออกจาก generic array]
[การกําหนดขอบเขตของ type variable]

5.8 Package
5.8.1 การสราง package

Classes และการถายทอดคุณสมบัติ

6.1 การสรา ง class ใหมจาก class เดิมและการถา ยทอดคณุ สมบัติ
[Access Modifier: protected]
6.1.1 ลาํ ดับการเรยี ก constructor
6.1.2 การ override method ใน class แมจาก class ลูก

6.2 Polymorphism (ความมรี ปู แบบท่หี ลากหลาย)
6.3 method กับความมรี ปู แบบทห่ี ลากหลาย
6.4 การสรา ง interface

[การใช interface Comparable เพ่ือเปรยี บเทียบ object]

iii

6.4.1 การถา ยทอดคณุ สมบัติจากหลายแหลง (Multiple Inheritance) intro. to Java (FEU.faa)
6.5 การใช interface ActionListener ของ Java

บทท่ี 7 การตรวจสอบและดกั จับ Error (Exceptions) 231
บทที่ 8
บทที่ 9 7.1 การตรวจสอบ error
บทที่ 10
7.2 การสราง exception ขึ้นมาใชเ อง
บทท่ี 11 7.3 การใช Assertions

Streams I/O 245

8.1 Streams

8.2 การเรยี กใช class File
8.3 Input and Output streams (ชองทางขอ มูลเขา /ออก)

8.3.1 Text File (ไฟลทเี่ กบ็ ขอมูลเปน character)
8.3.2 การสราง Sequential Access File (record)

8.3.3 การสรา ง Binary File ในรปู แบบตา ง ๆ
8.4 การทาํ งานกับ Random-access file

8.4.1 การปรบั ปรงุ (Update) ขอมูลในไฟล

Thread 275

9.1 Thread คอื อะไร

9.2 การสรา ง Thread เบอื้ งตน จาก class Thread
9.4 การสราง Thread เบ้ืองตนจาก Interface Runnable

9.5 Priority ของ Thread
9.6 Thread Synchronization (การประสานเวลาการทํางาน)

9.6.1 การใช locks ในการประสานเวลา
9.6.2 การใช synchronized ในการประสานเวลา

9.6.3 Deadlock

Graphics Programming 299

10.1 Simple Window
10.2 การวางตําแหนงของหนา ตา งบนจอ

10.3 การแสดงขอมลู ในหนาตางดวยการวาด
10.3.1 การวาดเสน (Line)

10.3.2 การวาดรูปเหลย่ี ม
10.3.3 การวาดรปู หลายเหลี่ยม (Polygon)

10.3.4 การวาดรูปวงรี (Oval)
10.4 การวาดรูปทรงสองมติ จิ าก Graphics2D

[การกําหนดรปู แบบ (style) ของเสน
10.4.1 การสรา งเสน โคง (Quadratic and Cubic Curves)

10.4.2 การแสดงผลของพืน้ ทที่ ่ีทบั ซอนกัน (Area)
10.4.3 การยายภาพ (Translation)
10.4.4 การหมนุ ภาพ (Rotation)

10.4.5 การปรบั เปลย่ี นขนาด (Scale) และการเปลยี่ นรูป (Shear)
10.4.6 การกําหนดความโปรงแสง (Transparency)

10.5 การใช Font
[การใช class FontMetrics ในการแสดงขอความ]

10.6 การแสดง Image
10.7 การตัดภาพ (Clipping)

10.8 การสรา งภาพเคลอ่ื นไหวอยา งงาย (Simple Animation)
10.8.1 การใช class Timer ควบคมุ การเคลอ่ื นท่ขี องภาพ

10.8.2 การสราง Off-screen Image และการสรา งภาพเคลอ่ื นไหวดวย Thread
10.8.2.1 การเคลื่อนยา ยขอ ความ
10.8.2.2 การเคล่ือนยาย image (Image Animation)
[การใช mouse เคล่อื นยา ยภาพ]

GUI และ Event Handling เบื้องตน 343

11.1 การสราง Swing Application อยางงา ย

[การสรางปุม ดว ย JButton]
[การสราง JLabel]

[การใส Icon ในปุม]
[การดักฟงเหตกุ ารณ (Event Listener)]
[การสนองตอบเหตุการณภายใน method actionPerformed()]

11.2 Layout Manager
แนะนําการจัดวางดวย [Flow layout]

iv

11.2.1 Border layout 403 intro. to Java (FEU.faa)
11.2.2 Grid layout

[การใช JPanel ในการจัดวาง Componenet]
[การกาํ หนดการทาํ งานของปมุ ในเครอ่ื งคดิ เลข]
11.3 JRadioButton และ JComboBox
[การใช BorderFactory]
11.4 JCheckBox, JTextField และ JTextArea
[การแสดงผลลัพธทันทีท่ผี ุใชเลือก check box]
11.5 JSlider และ JSpinner
11.6 JProgressBar และ ProgressMonitor
11.7 JFileChooser, JMenuBar, JMenu และ JMenuItem
[การใช Action ใน menu]
[Pop-up Menu]
[Accelerator ใน menu]
[Toolbar]
11.8 Swing กับ Netbeans 5.0
[การสรา ง GUI ดวย Netbeans]
[Design Area, Palette, Properties Window and Inspector]
[Running โปรแกรมภายนอก IDE]

ตารางตาง ๆ

ตาราง ASCII และ UNICODE (บางสว น)
ตาราง Constant ทใี่ ชบอ ย ๆ ในโปรแกรม
ตาราง ชนดิ ของขอ มลู
ตาราง Escape sequences
ตาราง Format ตาง ๆ สําหรบั ขอ มูลท่ีเปนตัวเลข
ตาราง การใชสัญลักษณแ สดงผลของ printf() และ format()
ตาราง การใช operator && || & และ |
ตาราง การใช operator shift << >> และ >>>

ในบทท่หี น่ึงนเี้ ราจะมาดกู ารตดิ ตง้ั เครอ่ื งมอื ท่ีใช ในการพัฒนาโปรแกรมดวยภาษา Java ตวั อยางการ intro. to Java (FEU.faa)
เขียนโปรแกรมในรูปแบบของ application และ การเขียนโปรแกรมในรปู แบบของ applet

หลังจากจบบทนแ้ี ลว ผอู านจะไดทราบถงึ

o การตดิ ตง้ั เครอ่ื งมือที่ใชในการพฒั นาโปรแกรมในภาษา Java
o ตวั อยางการเขยี นโปรแกรมในรปู แบบของ application
o ตัวอยา งการเขยี นโปรแกรมในรูปแบบของ applet
o ตัวอยางการเขยี น HTML ไฟลทใี่ ชในการ execute applet
o การเขียนโปรแกรม Java ดวย Crimson Editor
o Netbeans กับการเขยี นโปรแกรม
o ประวตั ิครา ว ๆ ของภาษา Java

1.1 ทําไมถึงเลือก Java เปน ภาษาในการเขยี น code

Java เปนภาษาท่นี กั พัฒนาโปรแกรมสามารถทจี่ ะเขียน code เพยี งครงั้ เดยี ว แลวนาํ ไปใชไดกบั
เคร่ือง computer ชนิด (platform) ตาง ๆ ได โดยไมต อ ง compile ใหม เชน ถา เราเขียนโปรแกรม
บนเครื่อง pc เราสามารถทีจ่ ะนําเอา code ท่ีได compile เรยี บรอยแลวไปใช (execute1) ในเครอ่ื ง
อนื่ ๆ ท่ไี มใช pc ได เชน apple, linux, unix, หรือ อน่ื ๆ ทม่ี ี JVM (Java Virtual Machine) อยู

Java เปนภาษาทไ่ี ดถกู พัฒนาขึ้นเพ่ือสนองตอการพฒั นาโปรแกรมในรูปแบบของการเขียนโปรแกรม
ที่เรยี กวา OOP หรือ Object-Oriented Programming ซงึ่ เปนภาษาท่ชี ว ยใหก ารพฒั นาโปรแกรมมี
ความยืดหยุน สงู ผเู ขยี น หรอื ผพู ฒั นาสามารถทจี่ ะสนองตอบความตอ งการของผใู ช (user) ได
มากกวาการพัฒนาในลกั ษณะของการเขยี นโปรแกรมแบบเดิม (procedural language
programming) และท่ีสําคญั อีกอยา งหน่ึงก็คือ Java เปน ภาษาทไ่ี มต อ งเสยี คา ใชจายใด ๆ เลย เรา
สามารถที่จะ download โปรแกรมสําหรบั การพัฒนาไดจากบริษทั Sun Micro System หรือที่อนื่ ๆ
ท่ที าง Sun ไดอ นญุ าตใหมกี าร download ได

1.2 กอนทเี ราจะเขยี นโปรแกรมดว ย Java เราตองมีอะไรบาง

1. เชนเดียวกันกบั การเขียนโปรแกรมในภาษาอ่ืน ๆ เราตอ งมี Text Editor ท่ีใชสรางและเก็บ
source code

2. JDK (Java Development Kit) ซ่ึงมหี ลาย version ลา สดุ ในขณะที่เขยี นตาํ ราเลม น้ี คอื J2SE
5.0 (jdk1_5_0) ซ่งึ download ไดที่ http://java.sun.com/j2se/1.5.0/download.jsp เรา
ตอ งใช JDK ในการ compile โปรแกรมที่เราไดเขียนขึน้

3. Java VM หรือที่เรียกวา Java Virtual Machine ซึง่ เปน ตวั กลางท่ีเปลีย่ น code ทีไ่ ดจากการ
compile เปน code ที่สามารถ execute บนเครื่องตา ง ๆ (code ทเ่ี ครอ่ื งนั้น ๆ รูจกั – machine
code หรอื ที่ชาว Java เรียกวา byte code) โดยปกติ VM จะถูกตดิ ต้งั พรอ มกับ JDK

ถาเรามอี ปุ กรณท ้งั หมดที่ไดกลาวมาแลว ขัน้ ตอนตอไปทเี่ ราตอ งทําเพื่อใหการพฒั นาโปรแกรมของ
เรา เปน ไปไดดวยความเรียบรอ ย (ไมมีอุปสรรคที่คาดไมถ งึ ) เราตอ งเตรยี มความพรอ มของเครื่อง
กอน

1 ในหนังสอื เลม นีก้ ารนาํ เอาโปรแกรมท่ี compile แลว ไปใชเราจะเรียกวาการ execute หรอื run ตามศัพทของภาษาอังกฤษ

เร่มิ ตนการเขียนโปรแกรมดว ย Java intro. to Java (FEU.faa)

1.3 เตรยี มความพรอ ม (สําหรบั pc)
1. ติดตั้ง JDK
2. กาํ หนดท่อี ยขู องไฟลตา ง ๆ (path) ทจ่ี าํ เปนสําหรับการ compile ภายในเครือ่ งเพ่ือใหก าร

compile และ execute โปรแกรมเปน ไปได – ถาเราไมกาํ หนด path เครือ่ งของเราจะไมร ูจัก
คําส่งั ตา ง ๆ ที่ Java ใช
1.3.1 ติดตงั้ JDK
เมื่อ download JDK มาแลว การติดต้ังก็ทําไดงา ย เนอื่ งจาก JDK เปนไฟลทีเ่ ราเรยี กวา self-
extracting file คือ ไฟลท จ่ี ะตดิ ต้ังโดยอัตโนมัตเิ ม่ือเรา execute (doubling click หรอื ดว ยวิธีการ
อื่น ๆ เชน click บน icon ของ file แลวกด enter) สาํ หรับไฟล j2se 5.0 นัน้ มีขนาดประมาณ 44 MB
ซงึ่ เปนไฟลท ่ีใหญพอสมควร และใชเวลานานในการ download (ถา speed ในการ download ไมดี
พอ) ซ่ึงเมอ่ื ขยายออกจะมขี นาดประมาณ 170 MB เพราะฉะน้ันเราตอ งเตรียมเนอื้ ที่ไวใ หเ หมาะสมใน
การตดิ ตั้ง JDK ถาหากวาเน้ือที่ในการจัดเก็บมนี อย เรากค็ วรใช JDK version อน่ื ๆ ท่ีมีขนาดเล็กกวา
หลังจากทีต่ ิดตงั้ J2se เรยี บรอยแลว ผอู านกค็ วรที่จะตดิ ตัง้ Java API (Application Programming
Interface) เพ่ือใหเปนการอา งอิงถงึ การใช class และ methods ตา งๆ ที่ Java มใี หซ ่งึ API นี้
สามารถ download ไดท่ี http://java.sun.com/j2se/1.5.0/download.jsp เมอื่ ไดไ ฟลมาแลว กท็ าํ
การแตกไฟล (upzip) ไวใ นท่ีๆ เขา หาไดง า ย และถาหากผูอา นอยากท่จี ะดูวา code ของ Java
หนา ตาเปนยังไงก็สามารถ unzip source code ทีม่ ากับ J2se ได
หลงั จากที่ไดต ดิ ตง้ั J2se พรอมทัง้ ไฟลอ ่นื ๆ แลวหนาตาของ directory ของ Java ก็จะมี folder
ตางๆ คลา ยๆ กบั ทเี่ ห็นน้ี

bin – ท่ีเกบ็ compiler และเครอื่ งมอื อ่ืน ๆ
demo – เกบ็ ตัวอยา งการใชง าน Java
docs – เก็บรายละเอียด API
include – เกบ็ method พ้นื ฐานตาง ๆ ของ Java
jre – เกบ็ ไฟลตาง ๆ ท่ีเกีย่ วของกับการ run โปรแกรม
lib – เก็บไฟลท ่ีใชในการทํางาน
sample – เกบ็ ตวั อยางโปรแกรม
src – เกบ็ source code ของ Java

ภาพท่ี 1-1 Folder ทอ่ี ยูใต j2sdk1.5.0 หลังจากการติดตั้งไฟลท เี่ กีย่ วของ

1.3.2 การกาํ หนด path
ถา การพฒั นาโปรแกรมเปนการพัฒนาบนเครื่อง Windows 9x การกําหนด path กส็ ามารถทจี่ ะทาํ ได
ดว ยวธิ กี ารตาง ๆ ดังน้ี
1. เปดไฟล autoexec.bat แลว เพ่ิม path ท่ีไดต ิดตั้ง JDK ไว ซงึ่ ถา เราติดตงั้ J2SDK 1.5.0 ไวใ น

drive c การกําหนด path ในไฟล autoexec.bat ก็ทาํ ไดดงั น้ี
ใสคาํ สง่ั set path=c:\j2sdk1.5.0\bin ในบรรทัดใหมถายังไมมีมีคาํ สั่ง set path อยูเลย แตถา
มกี ารใช คาํ สั่ง set path อยแู ลว ก็ใหใ ส ; (semicolon) หลงั ตัวสดุ ทา ยของ path แลวจึงใส
c:\j2sdk1.5.0\bin
2. หรอื เราอาจกาํ หนด path ทุกคร้งั กอ นการเขียนโปรแกรม (ถา เราไมไดก าํ หนดในไฟล
autoexec.bat) โดยไปท่ี Command Prompt (หรอื ท่ีรูจกั กันในคนรนุ เกาวา dos window) และ
set path บน Command Prompt ดงั ท่เี ห็นในภาพ

2

บทที่ 1: กอนจะถงึ Java intro. to Java (FEU.faa)

ภาพที่ 1-2 การกาํ หนด path ของ Java

3. ทาํ การพฒั นาโปรแกรมใน directory ทีม่ ี JDK อยู เชนเปลี่ยน drive ไปท่ี c:\j2sdk1.5.0\bin
แลว เรมิ่ ทํางานใน directory น้ี ไฟลท กุ ตวั ทเ่ี กยี่ วของกับการเขยี นโปรแกรมจะตอ งเก็บไวทีน่ ่ี –
วิธนี ี้ ไมแ นะนาํ เพราะจะทาํ ให directory ของ java เปรอะไปดวยไฟลท่ีเราเขยี นขนึ้ เอง

ถาเราใช Windows XP หรือ Windows 2000 การกาํ หนด path ทําไดด ว ยขน้ั ตอนตอไปน้ี
(Windows XP และ Windows 2000 ใชคาํ ส่ังทีแ่ ตกตา งกันนิดหนอย ตัวอยา งท่ีทําใหดูน้ี เปนการ
กาํ หนด path บนเคร่ืองที่ใช Windows XP)
1. กดปมุ ขวาของ mouse บน icon My Computer (หรือ ไปที่ปุม start ท่ีมุมลา งซายของจอแลว

เลอื ก My Computer) แลว เลอื ก Properties

ภาพที่ 1-3 การเขาหา My computer

2. กดปมุ advanced บน System Properties

ภาพท่ี 1-4 ปุม Advanced

3

เริ่มตนการเขียนโปรแกรมดว ย Java intro. to Java (FEU.faa)

3. กดปมุ Environment Variables

ภาพที่ 1-5 ปมุ Environment Variables

4. ใน System Variables เลอื กขอความท่ขี น้ึ ตนดว ยคาํ วา Path

ภาพที่ 1-6 ท่ีอยูข องตัวแปร Path

5. เมือ่ กดปมุ Edit กจ็ ะไดห นา จอดงั ทเ่ี หน็

ภาพที่ 1-7 การกําหนดคาใหก บั Path

6. เตมิ ; (semicolon) ถายงั ไมม ี แลวจงึ ใส path ท่ไี ดตดิ ต้ัง J2SDK ไว เสร็จแลวกดปุม OK
เพอื่ ใหร ะบบบันทึกการเปลยี่ นแปลงที่ไดทําข้ึน

หลังจากที่ไดกําหนด path ใหกบั เคร่อื งท่ีเราจะใชใ นการเขียนโปรแกรมแลว ขน้ั ตอนตอ ไปก็ข้ึนอยู
กบั ผเู ขียน การพัฒนาโปรแกรมกท็ าํ ไดโดยไมต อ งวุนวายกบั การกําหนด path ตา ง ๆ อกี (ยก
เวน เสียแตวา path ท่ไี ดกาํ หนดข้ึนไมมีอยูจ ริง – เราก็ตอ งกลับไปเริ่มตน ใหม พรอมกบั path ทม่ี อี ยู
จริง)
ท้งั นีท้ ั้งน้ัน ผูพัฒนาโปรแกรมตองเลอื กเองวา วธิ ีไหนเหมาะสมท่ีสุด ถาตองใช Java อยบู อย ๆ และ
สม่าํ เสมอก็ควรทจี่ ะเลอื กกาํ หนด path แบบถาวร เพ่อื จะไดไ มตองเสยี เวลากบั การกาํ หนด path
สิ่งท่ีสาํ คัญอีกสิง่ หนึ่งทีข่ าดไมไดใ นการทดสอบและ execute code ที่เขียนขึน้ ดว ย Java กค็ ือ JRE
หรอื ทีเ่ รยี กวา Java Run-time Environment ถา เรานําเอา code ที่ไดผานการ compile จาก J2SDK
แลว ไป execute บนเครือ่ งทยี่ งั ไมไ ดติดตง้ั JRE ผลลพั ธก ค็ อื execute ไมได แตถ าเคร่ืองนน้ั ไดรบั
การติดตงั้ J2SDK ก็จะไดร ับการติดตัง้ JRE พรอมกนั ไปดวย ดังทีไ่ ดก ลา วไวก อนหนานี้ สาเหตุท่ี
Sun ทาํ แบบนก้ี ็เพราะวา หลาย ๆ คนอาจไมใชผูพัฒนา Java โปรแกรมแตเ ปน ผูใ ชโปรแกรมท่เี ขยี น

4

บทท่ี 1: กอ นจะถงึ Java

ขน้ึ ดว ย Java ก็ได ดังน้ันหากเคร่ืองใด ๆ ตอ งใชโปรแกรมที่เขียนขน้ึ ดวย Java บอย ๆ ก็ตอ ง intro. to Java (FEU.faa)
download JRE มาไวท ่เี ครอื่ งดวย

1.4 เขียน code ทีเ่ ปน application หรือเขยี น code ทเ่ี ปน applet

Applet เปน code ทีเ่ ขยี นขน้ึ มาเพอ่ื ใหส ามารถทจี่ ะ execute ใน web browser ผา นทาง HTML
ไฟล ซง่ึ โดยทวั่ ไปมกั จะมีขนาดเลก็ เพอื่ ใหการ download applet ทาํ ไดรวดเรว็ ยิง่ ข้ึน สว น
application เปนการ execute ไฟลผา นทาง command line ดังน้นั ขนาดจงึ ไมเ ปน อปุ สรรค (เพราะ
ไมตอ งมกี าร download) หนังสอื เลมนจ้ี ะแสดงโปรแกรมตวั อยางดว ยการเขยี น code ในรูปแบบของ
application

1.5 เครอ่ื งมือ หรอื คาํ สั่ง (SDK tools) ท่ตี องใชใ นการพัฒนาโปรแกรม

Java Development Kit ไดถ กู เปล่ียนใหมีชอ่ื เปน J2SDK – Java 2 Software Development Kit
ดังนั้นเราจะใชชอ่ื เครอื่ งมือในการพฒั นาโปรแกรมน้ีสลับกันไปมา แตใหตัง้ สมมตฐิ านวา ทง้ั สอง ตางก็
เปนเครอ่ื งมอื ที่ใชในการพัฒนา Java โปรแกรมเชนเดยี วกัน

javac เปนเครือ่ งมือท่ีใชในการ compile (compiler) ทีท่ ําการเปลี่ยน source code ท่เี รา
เขยี นขึน้ ใหเปน byte code

java เปนเครือ่ งมือท่ีใชในการ execute byte code สาํ หรบั โปรแกรมท่เี ขยี นขน้ึ ในแบบของ
application

javaw เชนเดียวกับ java

appletviewer เปนเคร่อื งมอื ท่ีใชในการ execute โปรแกรมที่เขยี นขน้ึ ในแบบของ applet

ยงั มเี ครอื่ งมอื อีกหลายตัวที่ java มใี ห แตต อนน้เี ราจะใชเฉพาะเครื่องมือท่ีไดกลาวไวแ คส ามตวั น้ี
เทา นนั้

การพัฒนาโปรแกรมท้ังทเ่ี ปน application และ applet น้ันจะมขี ั้นตอนท่แี ตกตางกันพอสมควร ดัง
แสดงใหเ ห็นในภาพท่ี 1-8 และในภาพท่ี 1-9 ในการเขยี น code นน้ั เราจะตองมี editor ที่เปน text
editor กลาวคอื เปน editor ทีไ่ มม กี ารเก็บ format ตาง ๆ ของตวั อกั ษรดงั เชนท่ี Microsoft Word
เก็บ แตจ ะเกบ็ เปนรหัส ASCII ที่ SDK สามารถอา นและ execute ได สมมตวิ าเรามี text editor และ
SDK แลวการพฒั นากเ็ ปน ไปตามขั้นตอนที่แสดงในภาพท้งั สอง

Text Editor Javac Java Class File
First.class
Java Source File
First.java Java

Java Program
Output

ภาพท่ี 1-8 ขน้ั ตอนการพฒั นาโปรแกรมทีเ่ ปน application

5

เรมิ่ ตนการเขยี นโปรแกรมดว ย Java

Text Editor Javac Java Class File intro. to Java (FEU.faa)
Java Source File First.class

First.java appletviewer

HTML file Java Program
First.html Output

ภาพท่ี 1-9 ขั้นตอนการพัฒนาโปรแกรมทเ่ี ปน applet

1.6 การสรางโปรแกรม Java ท่เี ปน application

สมมตวิ าเราเลอื กใช text editor ตัวใดตัวหนงึ่ ทมี่ ีอยมู ากมาย ท้งั ที่ free และทั้งที่ตอ งจายเงนิ ซอ้ื มา
เรากม็ าลองเร่มิ เขียนโปรแกรมตวั แรก กนั เลยดกี วา

เพ่ือใหเ ขาใจไดงา ยถึงขัน้ ตอนและทม่ี าท่ีไปในการเขยี นโปรแกรมดว ยภาษา Java เราจะเขยี น
โปรแกรมทีไ่ มทาํ อะไรมากมายนกั เพยี งแตสง ขอมลู ไปยังหนา จอเม่ือ user เรยี กใช (execute)
โปรแกรมน้ี เราจะตงั้ ช่ือโปรแกรมน้ีวา HelloWorld.java และมีขอมลู ดงั น้ี

1: /**
2: Display a sentence "Hello World" to screen
3: */
4: class HelloWorld {
5: public static void main(String[] args) {
6: System.out.println("Hello World!");
7: }
8: }

ผอู านยงั ไมตองกงั วลกบั ความหมายของศัพทเ ฉพาะ (keyword) ตาง ๆ ของ Java ท่ีเห็นในตอนน้ี
หลงั จากทีเ่ ขยี นโปรแกรมไดส ักพกั หนง่ึ ผอู านก็จะเขา ใจถงึ ความหมายเหลา นด้ี ขี ้นึ แตต อนน้ีตอ ง
เขา ใจวา ไฟลท่เี ราเขียนขน้ึ มีนิยามของ class ที่เราเขยี นข้ึนชื่อ HelloWorld ซงึ่ Java กาํ หนดไวว า
ช่อื ของ class และชือ่ ของไฟลท เี่ กบ็ code ของ class น้จี ะตองเปนชื่อเดยี วกนั

class นี้มี method อยหู นงึ่ ตวั ชือ่ main() เม่อื เรา execute โปรแกรมน้ี JRE จะคนหา method ท่ชี อ่ื
main() เพ่ือทําการประมวลผลชุดคาํ สง่ั ตาง ๆ ท่มี ีอยู ทง้ั นี้ method main() จะตอ งมี keyword ทช่ี ่อื
public, static, และ void อยู รวมไปถงึ parameter ทเ่ี ปน array ทเ่ี กบ็ String ดว ย ถา ผอู า นเคย
เขยี นโปรแกรมดว ย ภาษา C หรือ ภาษา C++ มากอ นก็จะเห็นถึงความคลา ยคลึงกนั ของ method
main() น้ี

ตัวแปรท่มี อี ยใู นวงเลบ็ (Parameter) ของ method main() ท่เี ปน String[] args บง บอกถงึ คา
(command-line argument) ตาง ๆ ที่ผูใชโ ปรแกรมสงผานไปยังตัวโปรแกรมเพื่อเอาไวใชในการ
ทํางานตา ง ๆ ซึ่งอาจมี หรอื ไมมกี ไ็ ด และเราจะยังไมกลา วถึงคาเหลานใี้ นเวลานี้ ในตัว method
main() เองมีประโยคทีข่ ึ้นตน ดวย System.out.println("…") ซ่ึงเปน คาํ สง่ั ทใ่ี ชสงขอความไปยัง
System.out ที่โดยทวั่ ๆ ไปก็คือ console window หรอื ทเี่ รียกกันติดปากวา dos window หรอื dos
prompt ดงั ตัวอยา งที่แสดงใหเ ห็นในภาพที่ 1-10

6

บทท่ี 1: กอ นจะถึง Java

ภาพท่ี 1-10 การ compile และ run โปรแกรม intro. to Java (FEU.faa)

1.6.1 การ compile โปรแกรม HelloWorld

ดังเชน ท่แี สดงใหเหน็ ในภาพท่ี 1-10 การ compile ไฟลท เ่ี ขยี นขึ้นตองใชคําสั่ง javac ตามดว ยชอื่
ไฟล พรอ มกบั นามสกุล ดังน้ี

javac HelloWorld.java

ในการ compile ทุกครัง้ เราจะตองไมล มื ใสน ามสกุลใหก ับไฟลท เี่ ราไดเขยี นขึน้ ไมเ ชน น้ันแลว
compiler จะฟอ ง โดยการสงขอ ความที่บอกถึงขอผดิ พลาดในโปรแกรม (error message) ใหเ รา
เชน ถา เรา compile ไฟล HelloWorld โดยไมใ ส .java เรากจ็ ะได error ดงั น้ี

E:\bc221Book\source>javac HelloWorld

javac: invalid flag: HelloWorld

Usage: javac <options> <source files>

where possible options include:

-g Generate all debugging info

-g:none Generate no debugging info

-g:{lines,vars,source} Generate only some debugging info

…

…

…

(ผูเขียนไดต ดั ขอ ความบางสว นที่ java ฟอ งออก)

1.6.2 การ execute โปรแกรม HelloWorld

สมมติวา เรา compile โปรแกรม HelloWorld โดยไมมี error ใด ๆ เกิดขึน้ การ execute โปรแกรมก็
ทาํ ไดด วยคําสงั่ java ตามดว ยชอ่ื ไฟล ดังนี้

java HelloWorld

และกจ็ ะได output ดังที่เห็นในภาพที่ 1-10

ในการ execute โปรแกรมนัน้ เราจะไมใส .class ตามหลงั ชอ่ื ไฟล (ถงึ แมวา เราตองมีไฟลน ีก้ ต็ าม) ถา
เราใส compilerกจ็ ะฟองดวย error ท่ีบอกวา หาไฟลไ มเ จอ (java.lang.NoClassDefFoundError)
ดังทเ่ี ห็นในภาพท่ี 1-11

ภาพท่ี 1-11 error ทเ่ี กิดข้ึนจากการใส .class ตามหลงั ชอ่ื ไฟลในขณะ run โปรแกรม

7

เร่มิ ตนการเขียนโปรแกรมดวย Java intro. to Java (FEU.faa)

1.6.3 สรุปขน้ั ตอนของการพฒั นาโปรแกรมทีเ่ ปน application

1. compile ดว ยคาํ ส่ัง javac ตามดวยชอื่ ไฟล พรอ มกบั นามสกุล

2. execute ดวยคาํ ส่ัง java ตามดวยชอื่ ไฟลโดยไมมีนามสกลุ ใด ๆ ตอทาย

การเขยี นโปรแกรมทีด่ ีนั้น ผูเขียนควรใสค าํ อธบิ าย (comment) ถึงการทํางานของโปรแกรมทเี่ ขยี น
ขนึ้ เพือ่ ใหผ ูทน่ี าํ โปรแกรมไปใช หรือผูอา นคนอนื่ เขา ใจถึงวธิ ีการใชท ่ีถกู ตอง ในการเขียน
comment ดวยภาษา Java น้ัน มกี ารทําไดสองวธิ ี คือ

1. การใช //
2. การใช /* … */

การใชใ นแบบที่หนง่ึ น้ัน เปน การใส comment ไดไ มเกิน 1 บรรทดั สว นการใชในแบบที่สอง ผูใช
สามารถทจ่ี ะใส comment ไดม ากกวา หนึ่งบรรทัด แต comment ตองอยภู ายในเครื่องหมาย /* …
*/ เทา นั้น ดังตัวอยางจากการนําโปรแกรม HelloWorld มาเขยี นใหมด วย comment

1: /**
2: Display a sentence "Hello World" to screen
3: */
4: class HelloWorld {
5: //Java launcher will call this method to
6: //display string "Hello World!"
7: public static void main(String[] args) {
8: System.out.println("Hello World!");
9: }
10: }

1.7 การสรางโปรแกรม Java ท่เี ปน applet

ในการเขยี นโปรแกรมที่เปน Java applet นนั้ เราจะตอ งมีไฟลอ ยอู ยางนอย 2 ไฟล ซงึ่ หนงึ่ ในน้นั คือ
Java source file และอีกไฟลหนึ่งคอื HTML file เราลองมาเขียน applet เลก็ ๆ ที่สง ขอ ความไปยงั
web browser เหมือนกบั ท่เี ราเขยี น application กอนหนานี้

1: /**
2: My first Java applet
3: */
4:
5: import javax.swing.JApplet;
6: import java.awt.Graphics;
7:
8: public class HelloWorldApplet extends JApplet {
9: public void paint(Graphics g) {
10: g.drawString("Hello World! สวสั ดคี รบั โลกเกา ๆ ใบนี"้ , 25, 25);
11: }
12: }

เน่อื งจากวา เราตอ งการ applet สําหรับการสงขอความไปยงั web browser ดังนัน้ เราจึงตองดงึ เอา
เครื่องมือทีช่ วยใหเ ราสามารถแสดงขอ ความทวี่ า ดวยการใชก ารถา ยทอดคุณสมบตั ิ (inheritance) ที่
Java มีใหด ว ยการเพิ่มคําวา extends Applet ทางดา นหลงั ของ class HelloWorldApplet เราจะยัง
ไมพดู ถึงรายละเอียดเกี่ยวกับการถายทอดคณุ สมบัติของ Java ตอนนี้ อีกส่ิงหนง่ึ ทีข่ าดไมไดใ นการ
เขียน applet ของเราตอนน้กี ็คอื method paint() ซึ่งเปน method ทที่ าํ การวาดขอความลงบน
applet ดว ยการเรียกใช method drawstring() จาก class Graphics ในตาํ แหนงท่ีกาํ หนดไว จาก
คาํ ส่งั น้ี

g.drawString("Hello World! สวัสดีครบั โลกเกา ๆ ใบน"ี้ , 25, 25);

เม่ือ compile โปรแกรม HelloWorldApplet ดวยคาํ สั่ง javac แลวเราก็สามารถท่ีจะ execute applet
ไดด วยการเรยี ก HTML ไฟลท ่เี ขยี นขึน้ ดังนี้

<html>
<applet code="HelloWorldApplet.class" width="300" height="80"></applet>
</html>

8

บทที่ 1: กอ นจะถึง Java intro. to Java (FEU.faa)

ดวยการใช applet tag ใน HTML ไฟลพ รอ มกบั การใสช ่อื ของ Java ไฟลท ่ี compile แลว ในสว นของ
field ท่ชี ื่อ code และกาํ หนดขนาดความกวา งของ applet ใน field ที่ช่อื width และความยาว (สูง)
ใน field ทช่ี ือ่ height
การ execute ไฟล HelloWorldApplet.html กส็ ามารถทาํ ไดด ว ยการใชค ําสง่ั appletviewer ตาม
ดว ยช่อื ไฟล เราก็จะได output ดงั นี้

ภาพท่ี 1-12 Applet แสดงคา Hello World

1.7.1 สรุปขั้นตอนการเขยี นโปรแกรมแบบ applet
1. สรา ง Java source file ดว ยการ extends Applet
2. สรา ง HTML file ที่มี applet tag และขอมลู ท่สี าํ คัญในการแสดง applet คอื (1) class file ของ

Java โปรแกรม (2) ขนาดของ applet – width และ height
เราคงจะทิง้ เร่ืองการเขียน applet ไวเ พยี งแคน ี้ แตจะไปศึกษาถงึ โครงสรางตา ง ๆ ของภาษา Java
ขั้นตอนการออกแบบ และการเรียกใช class รวมไปถึงเทคนิคและวิธีการใช method ตาง ๆ ที่ Java
มใี หใ นรูปแบบของการสราง application เทาน้นั
1.8 การสราง Java program ดวย Crimson Editor
ตัวอยา งของโปรแกรม HelloWorld.java ทเ่ี ราไดเขียนขน้ึ กอ นหนานใ้ี ชภาษาอังกฤษท้ังหมดในการ
เขยี น ผลลพั ธทีไ่ ดจ ากการ run โปรแกรมก็เปนภาษาอังกฤษ ผานทาง Dos Window ถา เราตอ งการ
ที่จะเขยี นโปรแกรมเพือ่ ใหแสดงผลลัพธ หรือ ขอความทเี่ ปน ภาษาไทยนัน้ จะตองใช Operating
System ทีร่ องรับการปอ นและสง ขอ มลู ที่เปน ภาษาไทย เชน Windows ตาง ๆ ทส่ี รา งข้ึนมาเพ่อื คน
ไทยโดยเฉพาะ ซึง่ จะสังเกตไดจากคําวา Thai Edition หรือ คําวา ไทย ตอ ทา ย แตกม็ ี OS หลาย ๆ
ตวั ท่ียอมใหม กี ารปอนและสงขอมลู ท่เี ปนภาษาไทยผานทางชอ งทางอนื่ ๆ ท่ีไมใ ช Dos Window ใน
การฝกฝนการเขยี นโปรแกรม Java ใหม ๆ น้ันเราจําเปนทจี่ ะตองมีชองทางในการแสดงผลทสี่ ามารถ
ใชไ ดท ง้ั ภาษาไทย และภาษาอังกฤษ ดังนั้นเพอ่ื ใหการปอนและสง ขอมลู ใชไดท ้ังภาษาไทยและ
ภาษาอังกฤษ เราจะเลอื กใช Text Editor ทร่ี องรับภาษาไทย เชน Crimson
กอนอน่ื เราตองหา Crimson มาติดตัง้ ในเคร่อื งทเี่ ราใชในการสรางโปรแกรมดวยภาษา Java เสียกอน
ซงึ่ สามารถท่จี ะไป download มาไดจาก http://www.crimsoneditor.com/ โปรแกรมตวั นี้เปน
freeware เม่อื ติดตง้ั เรยี บรอยแลวก็ใหเขาไปใน menu ท่ชี ่อื วา Tools

9

เรมิ่ ตนการเขยี นโปรแกรมดว ย Java intro. to Java (FEU.faa)

ภาพท่ี 1-13 การกําหนดคา Preferences

เลอื ก Preferences ก็จะไดห นาตางที่เห็นนี้

ภาพท่ี 1-14 หนาตางการกาํ หนด font

click ท่ี Fonts และเลือก font ใหกับ Screen fonts ซ่ึงเปนหนา ตา งสาํ หรบั การ edit ผอู า นควรเลอื ก
font ทร่ี องรับภาษาไทย เชน Tahoma หรอื font ตระกูลอื่นๆ ทม่ี ีคาํ วา UPC ตามหลงั เสรจ็ แลวให
ทําแบบเดยี วกบั Printer fonts และ Miscellaneous (เราจะแสดงใหด ูเฉพาะการกําหนด font ใหกับ
หนาตางแสดงผล)
ในการกาํ หนด font ของหนาตางแสดงผล ผอู า นจะตองกดปุม สองครง้ั ใน Output Window เพือ่
เปลี่ยนคาตา งๆ ท่ตี องการ

10

บทที่ 1: กอนจะถงึ Java intro. to Java (FEU.faa)
ภาพที่ 1-15 หนา ตา งแสดงผล

หลงั จากกดปุมสองครงั้ ก็จะไดหนาตางของการกําหนด font ใหก ับหนาตางแสดงผล ดงั ทแ่ี สดงใน
ภาพท่ี 1-16 ซ่งึ ผูอานสามารถท่จี ะกําหนดตางๆ ไดเอง

ภาพท่ี 1-16 การกําหนด font และคาตางๆ

หลังจากท่กี าํ หนดคาใหกับหนา ตางทกุ ตัวเรียบรอยแลว เราก็ตองมากาํ หนดให Crimson รูจกั กับการ
compile และ execute โปรแกรมในภาษา Java ดวยการเลอื ก Conf. User Tools ในสวนของ
Preference ซึ่งจะไดห นา ตางดงั ทเี่ ห็นในภาพท่ี 1-17

11

เร่มิ ตนการเขียนโปรแกรมดว ย Java

ภาพท่ี 1-17 หนาตางการกาํ หนดคาของ User Tools intro. to Java (FEU.faa)

เร่ิมตน ดวยชอ งแรกสดุ ใน User Tools ท่เี ขียนวา Empty ใสขอ มลู ดงั ตัวอยา งท่ีเห็นในภาพที่ 1-18

ภาพที่ 1-18 การกําหนดคาใหกบั การ compile

รายละเอยี ดขอมูลทีใ่ สดังทเ่ี ห็นในภาพท่ี 1-18

Menu Text: Compile Java Source File ผูอานจะใสอะไรก็ไดท ่สี ือ่ ความหมาย
Command: ท่ีทผ่ี อู า นได install Java ไว เชน c:\j2sdk1.5.0\bin\javac.exe
ซ่ึงอาจคน หาดว ยการ browse ผา นทางปมุ ที่มีให
Argument: $(FileName) เปน ไฟลทม่ี นี ามสกลุ เลอื กจาก drop-down list
Initial directory: $(FileDir) เลือกจาก drop-down list
Hot key: กดปมุ Ctrl แลว ตามดว ยปุมฟง คชน่ั ท่ีตอ งการใชเ ชน F5

พรอ มกบั ใสเ คร่ืองหมาย 9 ในชอ ง Capture output และ Save before execute

หลงั จากนนั้ ก็ทาํ การกําหนดคําส่งั ใหกับการ run โปรแกรมดังตัวอยางทแี่ สดงในภาพท่ี 1 – 19 โดย
เปล่ียนขอ มูลในชองของ Argument ใหเ ปน $(FileTitle) เพราะJava ตอ งการเพยี งแคช่ือไฟลทไี่ มม ี
นามสกลุ ในการ run

12

บทที่ 1: กอนจะถงึ Java intro. to Java (FEU.faa)

ภาพที่ 1-19 การกําหนดคา ใหกบั การ run โปรแกรม

เมื่อทาํ ทุกอยางเรยี บรอยแลว ใหกดปมุ OK เพ่ือทาํ การบันทึกคาํ สั่งท่ีเราสรางขน้ึ ให Crimson รจู ัก
และเม่ือได compile และ run ผลลพั ธท ่ีเราไดคือ

ภาพที่ 1-20 ผลของการ run โปรแกรม HelloWorld.java

13

เร่มิ ตนการเขียนโปรแกรมดว ย Java intro. to Java (FEU.faa)

ถา เราตองการท่จี ะ run โปรแกรม HelloWorldApplet ทเี่ ราไดเขียนขน้ึ และแสดงผลลพั ธของการ
run ผานทาง Crimson เราตอ งทําการกําหนดคําส่งั อกี ตวั หนงึ่ ขึน้ มา เพ่อื ใหสามารถทจี่ ะ run Applet
ได และโดยเฉพาะอยางย่งิ การสง ขอความทเ่ี ปน ภาษาไทยไปยงั applet
ขัน้ ตอนและวิธกี ารกค็ ลายๆ การกาํ หนดในสวนอ่นื กอนหนา นี้ เพียงแตวา เราตอ งกําหนด option ของ
การแสดงผลใหใช HTML encoding ท่ีสามารถแสดงผลเปนภาษาไทย ซ่งึ ทําไดง า ยๆ ดังภาพท่ี
แสดงนี้

ภาพท่ี 1-22 การกําหนด option ใหก ับคําส่ัง appletviewer

ภาพที่ 1-23 แสดงผลลัพธข องการใชคําส่งั ที่เราไดกําหนดไวหลังจากท่ีเรากด ctrl + F7 ซึ่งเปน ภาพ
เดยี วกันกับภาพ 1-12

ภาพท่ี 1-23 ผลลัพธจากการ run HelloWorldApplet.html

Crimson ยังมี features ตา งๆ อกี มากมายที่เราสามารถที่จะ set ไวช ว ยในการทํางานของเราไดท้ังน้ี
ผูอานสามารถทีจ่ ะหาขอ มูลเพ่มิ เติมไดจาก help file ของตัว Crimson เอง
สิ่งท่เี ราตองการบอยมากกค็ ือการใสขอ มลู เขาสโู ปรแกรมผา นทาง keyboard ซึ่งอาจเปน ขอมลู
ทดสอบ หรอื เปนขอ มูลที่ตองการใชจรงิ ในโปรแกรม แตเ ราไมสามารถทาํ ได (งา ย ๆ) ดว ย Crimson
ดังน้นั เราจงึ จาํ เปนตองใชเครอื่ งมอื ตวั อน่ื ในการนาํ ขอมูลเขา เชน command window หรือ การใช
IDE ตวั อื่น ๆ ท่ีมอี ยู เชน netbeans
1.9 การใช NetBeans สาํ หรับการพัฒนาโปรแกรม
ปจ จุบันผใู ชส ามารถทีจ่ ะเลอื ก download Java 1.5 ทมี่ ี NetBeans IDE รวมอยดู ว ยจาก Sun
โดยตรง NetBeans เปนโปรแกรมท่ีดมี ากตวั หนึ่งสาํ หรบั การพัฒนาโปรแกรมทตี่ อ งการใช GUI
(Graphical User Interface) ทง้ั โปรแกรมที่ run บน web และบนเครอ่ื งโดยตรง

14

บทที่ 1: กอ นจะถึง Java intro. to Java (FEU.faa)

ภาพที่ 1.28 โปรแกรม NetBeans

อกี ทีห่ นึง่ ท่ผี อู า นสามารถ download NetBeans ไดก ็คอื http://www.netbeans.org/ เราจะแสดง
วิธีการสรา งโปรแกรมอยางงา ย ๆ ดวย Netbeans ใหด ู

ภาพท่ี 1.29 New Java Application Project Dialogbox

หลงั จากท่ีเปด Netbeans พรอมกับเลือก General และ Java Application เราก็จะไดห นา ตา งดงั ที่
เหน็ ในภาพ 1.29 และเม่ือกดปุม Next เราก็จะได

15

เริม่ ตนการเขียนโปรแกรมดวย Java intro. to Java (FEU.faa)

ภาพที่ 1.30 การต้ังชื่อ project และตําแหนงทเ่ี กบ็ project

และเมือ่ เรากดปุม Finish เราก็จะไดห นาตางสาํ หรบั เขียน code ดังท่แี สดงในภาพ 1.31 น้ี

ภาพท่ี 1.31 แสดง project windows ตาง ๆ ท่ถี ูกกําหนดจาก Netbeans

หลังจากทีใ่ ส code เสรจ็ เราก็ compile project ดวยการกด Build Æ Build Main Project และเม่อื
compile เสร็จโดยไมม ี error เราก็ execute project ดว ยการกด Run Æ Run Main Project เราก็
จะเหน็ ผลลัพธท่แี สดงใน output window ดานลา ง

16

บทที่ 1: กอนจะถงึ Java intro. to Java (FEU.faa)

ในการสรา ง applet น้ันเราตอ งเลอื ก Java Library Class ภายใต Java Application ซ่ึงเมือ่ เลือกแลว
เราก็จะไดหนา ตา งดงั นี้

ภาพที่ 1.32 หนา ตาง HelloWorldApplet ภายใต New Java Library Class

หลงั จากที่กดปมุ Next เราก็จะไดหนา ตางท่ีมี Project อยเู ราก็กดปมุ ขวาบน HelloWorldApplet (เรา
เรยี กสวนตา ง ๆ เหลานี้วา node) เลอื ก New File/Folder เรากจ็ ะไดห นาตา งใหม ซงึ่ เราตองเลอื ก
Java Classes ภายใต Categories และเลอื ก Applet ภายใต File Types หลังจากนัน้ กก็ ดปุม Next
เราก็จะไดหนาตางใหมดงั นี้

ภาพที่ 1.33 หนา ตางของ New Applet

17

เรม่ิ ตนการเขยี นโปรแกรมดว ย Java intro. to Java (FEU.faa)

เราจะใหชอ่ื Class Name วา HelloWorldApplet พรอมกบั กําหนดให Package เปน
org.neramit.hello ซ่ึงผอู านสามารถกําหนดใหเ ปนอะไรก็ไดตามทชี่ อบ และเมอ่ื กด Finish เราก็จะ
ไดห นา ตางสําหรับเขยี น code ใหก ับ applet ของเรา และเพื่อใหงายขึน้ เรานาํ เอา code ทเ่ี ห็นนี้ใส
เขาสู method init() ทม่ี อี ยู

public void init() {
String greeting = "Hello from Netbeans!";
setLayout(new BorderLayout());
JLabel label = new JLabel(greeting, SwingConstants.CENTER);
add(label, BorderLayout.CENTER);
JPanel panel= new JPanel();
JButton source = new JButton("neramit");
source.addActionListener(listenToURL("http://sci.fareastern.ac.th/faa"));
panel.add(source);
add(panel, BorderLayout.SOUTH);

}
private ActionListener listenToURL(final String url) {

return new ActionListener() {
public void actionPerformed(ActionEvent e) {
try {
getAppletContext().showDocument(new URL(url));
}
catch(MalformedURLException ex) {
ex.printStackTrace();
}
}

};
}

หลงั จากน้ันกก็ ดปมุ ขวาบน HelloWorldApplet ใน Project window เลอื ก Build Project และเม่อื
เลือก Files tab เราก็จะเหน็

ภาพที่ 1.34 ไฟลท ่ีถูกสรางข้นึ จาก Netbeans โดยอัตโนมัติ

เราเรียกใช applet viewer เพือ่ ดูผลลพั ธไดดว ยการกดปุมขวาบน HelloWorldApplet.java ใน
Project window เลือก Run File

18

บทท่ี 1: กอนจะถึง Java intro. to Java (FEU.faa)

ภาพท่ี 1.35 ผลลัพธจากการ run ไฟล HelloWorldApplet.java

อีกทางหนงึ่ ทเี่ ราเรยี กดู applet ของเราไดก ค็ ือ ผา นทาง web browser ซ่งึ เราสามารถทําผา นทาง
Netbeans ไดด วยการกดปมุ ขวาบน HelloWorldApplet.html ท่ีอยูใน Files tab แลวเลอื ก view เรา
กจ็ ะเห็น applet ใน browser ดังนี้

ภาพท่ี 1.36 applet ท่ีเปดใน browser

19

เร่ิมตน การเขยี นโปรแกรมดว ย Java intro. to Java (FEU.faa)

และถาผอู านกดปมุ neramit web browser ก็จะไป load web site ของผเู ขยี นมาแสดง เราจะ
กลบั มาดถู งึ การใช Netbeans ในบทที่ 11 เรื่องของการสรา ง GUI สําหรับ application ตา ง ๆ
1.10 ที่มาของภาษา Java โดยสงั เขป
Java เปน ภาษาท่ีเกดิ ข้ึนจากการพัฒนาของบรษิ ัท Sun Microsystems โดยมีทม่ี าจากภาษาที่ช่อื วา
Oak ซึง่ เปน ภาษาทใี่ ชภายใน Sun เอง เขียนขึ้นโดย Patrick Naughton และ James Gosling (มี
การตงั้ สมมตุ ฐิ านวาโปรแกรมตวั น้ไี ดช่ือวา Oak ก็เพราะวา James Gosling มองเหน็ ตน Oak นอก
หนา ตา งทที่ ํางานทกุ วัน) หนาทีเ่ บื้องตน ท่ี Oak ตองทาํ ก็คอื เปนภาษาทีเ่ ล็ก มีความสามารถในเร่ือง
ของชุดคําสง่ั สงู ใชหนว ยความจาํ นอย ไมยึดติดกบั ระบบคําส่งั ของ CPU ในรูปแบบ (platform) ตางๆ
เพราะจะตอ งนําไปใชก บั อุปกรณอ ิเล็กทรอนิกส เชน ตูสบั เปล่ยี นชอ ง ของ cable TV แตห ลังจากท่ี
Sun ไดพ ฒั นา Oak และใชม าอกี ระยะหนง่ึ Sun ก็ไดนาํ เอา Oak ออกมาสูสายตาชาวบา นทัว่ ไป แต
เนอ่ื งจากวา ช่ือของ Oak ไดม ีผใู ชอ ยูกอนแลว Sun จงึ ตอ งหาชอ่ื ใหมใหกบั ภาษาน้ี ซงึ่ ในตอนแรก็
ไดทดลองหลายชอื่ เชน Silk, Ruby และ WRL (Web Runner Language) แตช อื่ เหลา น้กี ไ็ มไดถ ูก
เลอื ก ในท่ีสุด Java กก็ ลายเปนชอ่ื ของภาษานี้ (ท้งั ๆ ทไ่ี มมีอะไรเกีย่ วของกับ กาแฟ จากชวา หรอื
อะไรทีเ่ กี่ยวขอ งกบั เกาะชวาเลย)
Java ไดอ อกสูสายตาของชาวโลกจริงเม่ือตน ป ค.ศ. 1996 โดยทาง Sun ไดเ พ่ิมความสามารถใหก ับ
Java คอื สามารถที่จะ execute code ทีอ่ ยูภายใน web page ได ทําให java ไดร ับความนยิ มในหมู
นกั พัฒนาโปรแกรมมาก แต Java รุนแรกๆ ก็ยงั มีขีดความสามารถท่ีจํากัด ยงั ไมส ามารถทาํ อะไรได
มากมายนัก จนกระทั่งปลายป ค.ศ. 1998 ทาง Sun ก็ไดเ ปด ตัว Java 1.2 ซงึ่ เปนรุนท่ีทาง Sun
ภมู ิใจมากทีส่ ดุ มีการปรับแตง อยางมากมาย เพมิ่ ขดี ความสามารถใหกบั Java เพ่ือใหส มกับคําทที่ าง
Sun ไดสญั ญาไวกบั ชาวโลกวา Java เปน ภาษาท่ีเขียนขนึ้ มาครั้งเดยี ว แลว เอาไป run ทไี่ หนกไ็ ด
(Write Once, Run Anywhere)
ทาง Sun ไดเ ปลีย่ นใหมให Java เปน Java 2 Standard Edition Software Development Kit
Version 1.2 หลังจากนัน้ ไมนาน Sun กอ็ อกรนุ อ่ืนอีก 2 รุนมาสสู ายตาชาวโลก คอื รนุ Micro Edition
สําหรับการทาํ งานบนเครือ่ งมอื สอ่ื สาร เชน โทรศัพทเคลื่อนท่ี และรุน Enterprise edition ซงึ่ เปนรนุ
ที่ออกมาสาํ หรับการทาํ งานบนเซริ ฟ เวอร
Java มอี ยมู ากมายหลาย version แต version ลาสุดของ Java ขณะที่เขียนตําราเลมน้ี คือ
J2SDK1.5.0 ผูอ านสามารถตดิ ตาม version ใหม ๆ และ download ไดท ่ี web site ของ Sun ที่ได
ใหไวกอนหนานี้
ในบททีส่ องเราจะมาทําความรูจกั กบั ขอ กําหนด ตาง ๆ ของ โปรแกรม ขอ มูล (data) ตวั แปร
(variable) และ การประมวลผล (calculation – evaluation)

20

ในบทท่สี องนี้เราจะมาทําความเขาใจในเรอื่ งของชนดิ ขอมูลท่ี Java มีไวในการรองรับการเขียน intro. to Java (FEU.faa)
โปรแกรม ทัง้ ขอมูลทเี่ ปน ตวั เลข และขอ มูลทีเ่ ปนตัวอกั ษร เราจะทดลองเขียนโปรแกรมดวยขอ มูล
ชนิดตาง ๆ นี้

หลังจากจบบทเรยี นนแ้ี ลว ผูอ า นจะไดท ราบถงึ

o วิธีการประกาศตวั แปร (variable declaration) ทมี่ ชี นิดเปน integer และ floating-point
o วธิ ีการประกาศตวั แปรท่ีมีชนิดเปน character และ boolean
o วิธีการกาํ หนด (assignment) คา ใหกบั ตวั แปรตาง ๆ
o การสรางประโยค (statement หรือ expression)
o การประมวลผล (calculation และ evaluation) ที่เกย่ี วกับตวั แปรชนิดตา ง ๆ
o การเปลย่ี นแปลง (casting) ชนิดของขอมลู
o การแสดงผลดว ยการใช printf() และ format()
o การใชฟ ง คช่นั ทางคณติ ศาสตร (Mathematical Functions) ที่ Java มีให

กอนทีเ่ ราจะพดู ถึงขอมลู และการประมวลผลขอ มูล เราควรกลับไปดถู ึงโครงสรา งทจี่ าํ เปน ตอ งมใี นการ
เขียนโปรแกรมดว ย Java

public class ClassName {
public static void main(String[] args) {
program statements
}

}

Java โปรแกรมทกุ ตัว (ทีไ่ มใช applet) ตองมี method ท่ีชื่อ main() ทม่ี รี ปู แบบดังท่เี ห็นดา นบนน้ี
ClassName จะเปน ท้ังช่ือของ class และชอ่ื ของไฟลทเี่ ก็บโปรแกรมน้ี สวน program statements
จะเปน ชุดคําสัง่ ทอ่ี ยูในโปรแกรม

2.1 ขอ มลู และ ตัวแปร (data and variable)

โดยทั่วไปถา เราตอ งการคํานวณหาคา ทางคณิตศาสตร เชน 354 + 45 * 12 เรามักจะใชเครือ่ งคิด
เลข หรือไมก็ใชวธิ คี ดิ ในกระดาษ ซึ่งวิธคี ดิ แบบท่สี องนีเ้ ราใชกระดาษเปน ตวั กลางในการหาคาน้ัน ๆ
กลา วคือ เราใชกระดาษเปนที่เก็บตัวเลขท่ีตอ งการหาคา รวมไปถงึ ผลลัพธของการหาคานัน้ ๆ ดวย
เชน เดียวกบั การเขยี นโปรแกรมทางคอมพวิ เตอร คา ตาง ๆ เหลา นจ้ี าํ เปน จะตองมีทเี่ ก็บ และท่ีเกบ็
ขอ มูลเหลา นต้ี อ งเปน ท่เี กบ็ ท่ีสามารถรองรับการประมวลผล หรอื การคาํ นวณไดอยางพอเพยี ง

ดงั นัน้ ในการเขียนโปรแกรม เราจงึ ตองใชต วั แปรเปนที่เก็บขอมูลตาง ๆ ทเ่ี ราจะตอ งใชในการ
ประมวลผล ตัวแปรทว่ี า น้ีเปนสัญลกั ษณแ ทนหนว ยความจาํ (memory) ท่ีอยใู นเครื่อง และ compiler
จะเปน ผูก าํ หนดวา อยูท ่ใี ด มขี นาดเทา ใด (address เรม่ิ ตน และ offset) ท่ีเกบ็ ขอ มลู นี้จะเก็บขอมูล
ไดเพยี งชนดิ ท่ีเราไดกําหนดไว เพียงชนิดเดยี วเทานั้น ขอมูลถกู แบง ออกตามชนดิ ของขอ มูล หลกั ๆ
คือ ขอมลู ท่เี ปนตัวเลข และ ขอ มลู ทีไ่ มใชตัวเลข แตจะแบง ยอย ๆ ลงไปอกี เชน ถาเรากําหนดใหตัว
แปรตวั ใดตัวหนง่ึ เก็บขอ มลู ชนดิ ทเี่ ปน ตัวเลขในแบบของ integer (จํานวนเต็ม เชน 2, 45, 90 เปน
ตน) เราก็ไมสามารถที่จะนําเอาขอมลู ท่ีเปน ตวั เลขในรูปแบบอื่น เชน double หรือ float (เลขทม่ี ีจุด
ทศนยิ ม เชน 2.35, 3.00 เปนตน) มาเกบ็ ไวในตัวแปรนีไ้ ด เนื่องจากวาขอ มูลทีต่ ัวแปรเก็บไดนน้ั มี
ขนาดตายตัว ตามการออกแบบของภาษา ดังนน้ั การนาํ เอาขอมลู ชนดิ อืน่ มาใสไวในตวั แปรนจี้ ะถูก
ตรวจสอบโดย compiler และ compiler จะฟองไปยังผเู ขียนโปรแกรมทันที

เริม่ ตนการเขียนโปรแกรมดวย Java

การประกาศตวั แปรน้ัน ผูเขยี นโปรแกรมจะใชสญั ลักษณใด ๆ ก็ไดท่ี Java ยอมใหใ ช ซ่ึงตองอยใู น intro. to Java (FEU.faa)
กฎเกณฑ ตอ ไปน้ี

1. ตอ งขึ้นตนดว ยตวั อักษร (letter) หรอื เครอ่ื งหมาย _ (underscore) หรอื เครือ่ งหมาย $ (dollar
sign)

2. เครอ่ื งหมายอนื่ ๆ ท่ตี ามมาเปนไดท้งั ตัวอักษร ตัวเลข และ สญั ลกั ษณอ ื่น ๆ ทีไ่ มไ ดถ กู ใชโดย
Java (เชน operator ตาง ๆ ที่ Java ใชด ังตัวอยา งของการ + (บวก) – (ลบ) * (คูณ) / (หาร)
เปนตน )

ตวั อยางของตวั แปรที่ถูกตอ ง

taxRate
pricePerUnit
_timeInSecond
$systemClock
unit897

เน่ืองจากวา Java ไดออกแบบใหผใู ชสามารถท่จี ะกาํ หนดตวั แปรใหเ ปน Unicode1 เพือ่ เปด โอกาสให
การออกแบบตวั แปรเปน ไปไดใ นภาษานัน้ ๆ ของ ผเู ขยี นโปรแกรม เราจงึ สามารถท่จี ะใชต ัวแปรทเ่ี ปน
ภาษาไทยได สง่ิ ทเี่ ราตองคํานงึ ถงึ กค็ ือ text editor ทเ่ี ราใชในการเขยี น code ตองยอมใหเราใช
ภาษาไทยดว ย ในบทน้แี ละบทอ่นื ๆ ของตํารานจ้ี ะใชต ัวแปรทีเ่ ปน ภาษาองั กฤษเทา น้ัน เพอ่ื ใหงาย
ตอ การเขียน และการทําความเขา ใจในเน้ือหาไดรวดเรว็ ขน้ึ

โดยทวั่ ไปเราจะเรียกตัวแปรทไี่ ดก าํ หนดใหเ กบ็ ขอมูลชนดิ ใด ชนิดหน่งึ วา variable หรอื identifier
และ identifier ท่ีวาน้ี มคี วามยาวเทาไรกไ็ ด (จํานวนของตวั อักษร) แตก็ตองอยูภายใตขอ กําหนดที่
ไดก ลาวมาแลว พรอ มกนั นี้ ตัวแปรท่สี รา งข้นึ จะตองไมใชคาํ เฉพาะ (keyword หรอื reserved word)
ท่ี Java ไดส รางขึ้นไวใชงาน ดังท่ีแสดงในตาราง 2.1

ตารางที่ 2.1 keyword

abstract const finally interface return throws
float long short transient
assert continue for native static try
goto new strictfp void
boolean default if null super volatile
implements package switch while
break do import private synchronized
instanceof protected this
byte double int public throw

case else

catch enum

char extends

class final

2.2 ชนิดของขอมูล (Data Type)

ในการประกาศตวั แปรทุกคร้ังเราจะตองบอกชนดิ ของขอมลู ใหก บั ตัวแปรนนั้ ดวย ซง่ึ การประกาศตวั
แปรน้นั ตองเร่ิมตน ดว ย ชนดิ ของขอ มลู (datatype) และตามดว ย ชือ่ ของตัวแปร (identifier หรอื
variable) ตามรูปแบบทีก่ าํ หนดดังน้ี

datatype identifier

โดยท่ี datatype คอื ชนิดของขอ มลู ที่ ตัวแปรสามารถเก็บได และในภาษา Java datatype เปนไดท ้งั
ขอ มูลท่เี รยี กวา ขอ มลู พนื้ ฐาน (primitive datatype) และขอมลู ทีเ่ ปนขอมลู อางอิง (reference
type) ซง่ึ เราจะไดมาดูกนั เมอ่ื เราพดู ถึงเรอ่ื งของ class และ object

Java กาํ หนดใหมี primitive datatype จาํ นวนทงั้ สน้ิ 8 ชนิดซง่ึ สามารถแบง ออกเปนกลุมได 4 กลมุ
ดงั นี้ (ดตู ารางท่ี 2.2)

1 มีความจุ 2 byte เพ่อื รองรบั ภาษาท่ีใชกันในประเทศตา ง ๆ (เดมิ ใช ASCII ซึ่งมีความจเุ พียง 1 byte)

22

บทท่ี 2: ขอ มูล ตัวแปร และการประมวลผล

1. ตรรกะ (Logical) – boolean intro. to Java (FEU.faa)
2. ตัวอกั ษร (Textual) – char
3. เลขจํานวนเต็ม (Integral) – byte, short, int, และ long
4. เลขทีม่ ีจุดทศนยิ ม (Floating point) – double และ float

ตาราง 2.2 ขอมลู พนื้ ฐาน (primitive datatype)

datatype คาํ อธบิ าย ขนาด (bit)
มีคา เปน true หรอื false
boolean คา ทางตรรกะ 8
16
byte ตวั เลขท่ไี มม จี ุดทศนิยม 32
64
short ตวั เลขท่ไี มมีจุดทศนยิ ม 32
64
int ตัวเลขที่ไมมจี ดุ ทศนิยม 16

long ตัวเลขทไี่ มม จี ดุ ทศนยิ ม

float ตัวเลขท่ีมีจุดทศนยิ ม

double ตัวเลขท่มี ีจุดทศนยิ ม

char ตวั อกั ษร

ขนาดของ datatype จะเปน ตวั กําหนดคา ทีเ่ ราสามารถเกบ็ ไดในตวั แปรที่ไดป ระกาศในโปรแกรม ยิง่
จาํ นวนของ bit มากเทา ไรเรากส็ ามารถเกบ็ คาสงู ๆ ได ตารางที่ 2.3 แสดงคา ตา ง ๆ ทสี่ ามารถเกบ็ ได
ใน datatype ชนดิ ตา ง ๆ

ตาราง 2.3 คาท่เี กบ็ ไดใน primitive datatype ตาง ๆ

datatype คา ตํา่ สดุ คาสงู สดุ

byte -128 (-27) 127 (27 - 1)
-32768 (-215) 32767 (215 - 1)
short 2147483647 (231 - 1)
9223372036854775807 (263 - 1)
int -2147483648 (-231)
3.4 x 1038
long -9223372036854775808 (-263) 1.7 x 10308

float -3.4 x 1038

double -1.7 x 10308

2.3 ตวั อยางการประกาศตวั แปร

int numberOfBikes;
float taxRate;
double interests, PI;
boolean yesOrNo;
char response;

โดยทวั่ ไปนักพฒั นาโปรแกรมมักจะใช ตวั อกั ษรตวั เล็กเปนตวั เริม่ ตนของตวั แปร และจะเปลีย่ นเปน
อกั ษรตัวใหญเม่อื คาํ น้ัน ๆ สน้ิ สุดลง เชน การประกาศตวั แปรทเี่ หน็ ดา นบนนี้ อกี วธิ หี นึง่ ทหี่ ลาย ๆ คน
ชอบใช คือการใชเ ครือ่ งหมาย _ (underscore) เปน ตัวแบง คํา เชน

int number_of_bikes;
float tax_rate;
double cum_gpa;
boolean yes_or_no;

ท้ังน้แี ละทั้งนน้ั การประกาศตัวแปรทัง้ สองวิธีทําใหก ารอานตัวแปรทําไดง ายขึน้ แตสิง่ สาํ คญั ทเ่ี รา
จาํ เปนจะตองคํานงึ ถึงในการประกาศตัวแปรกค็ ือ การเลือกใชค าํ ที่ส่อื ถงึ ความหมายของขอ มูลทตี่ วั
แปรนน้ั ๆ รองรับ หรือ เก็บอยู เชน ถา เราตอ งการเก็บขอมูลทเี่ ปน เกรดที่เปนตวั อักษร เราก็ควรใช ตวั
แปรท่ีสือ่ ถงึ เกรดท่เี ปน ตัวอักษร เชน คําวา letterGrade และถาเราตองการเก็บเกรดทีเ่ ปนคาเฉลีย่ เรา
กค็ วรใช ตวั แปร เชน gpa หรือ cumulativeGPA เปน ตน

2.3.1 การกาํ หนดคา ใหกบั ตวั แปร (Assignment)

หลงั จากท่ีเราไดประกาศตัวแปรสาํ หรับการใชงานแลว เราจะตองกําหนดใหต ัวแปรท่เี ราสรางขึ้นมคี า
เบื้องตนสําหรับการใชง านนน้ั ๆ ไมเชนนั้นแลว Java จะฟองถึงความผดิ พลาดที่เกดิ ข้ึน ดังเชนทเ่ี กดิ
ข้ึนกับโปรแกรมตัวอยา งนี้

23

เริ่มตน การเขียนโปรแกรมดวย Java

1: class TestDefault { intro. to Java (FEU.faa)
2: public static void main(String[] args) {
3: byte bt;
4: short st;
5: int in;
6: long ln;
7: float ft;
8: double db;
9: char ch;
10: boolean bo;
11:
12: System.out.println(ch);
13: System.out.println(bt);
14: System.out.println(st);
15: System.out.println(in);
16: System.out.println(ln);
17: System.out.println(ft);
18: System.out.println(db);
19: System.out.println(bo);
20: }
21: }

หลงั จากทเี่ รา compile โปรแกรม error ท่ีเราไดค ือ

TestDefault.java:12: variable ch might not have been initialized
System.out.println(ch);
^

TestDefault.java:13: variable bt might not have been initialized
System.out.println(bt);
^

TestDefault.java:14: variable st might not have been initialized
System.out.println(st);
^

TestDefault.java:15: variable in might not have been initialized
System.out.println(in);
^

TestDefault.java:16: variable ln might not have been initialized
System.out.println(ln);
^

TestDefault.java:17: variable ft might not have been initialized
System.out.println(ft);
^

TestDefault.java:18: variable db might not have been initialized
System.out.println(db);
^

TestDefault.java:19: variable bo might not have been initialized
System.out.println(bo);
^

8 errors

ผอู านจะเหน็ วา Java ไมย อมใหเราใชตัวแปรเหลานถ้ี า ไมมกี ารกาํ หนดคากอ น ดังนั้นเราจึงจาํ เปนที่
จะตอ งกาํ หนดคาเบอ้ื งตนของตวั แปรกอนการใชทุกคร้งั 2

การกาํ หนดคา ใหก ับตวั แปรนน้ั ทาํ ไดดวยการใชเครือ่ งหมาย = (เรียกกันวา assignment operator)
ซ่ึงมคี วามหมายวา "ใหนําคา ทางขวามือ (rvalue) ของเคร่ืองหมาย = ไปเกบ็ ไวใ นตัวแปรท่อี ยู
ทางดา นซา ยมอื (lvalue) ของเครอื่ งหมาย =" rvalue สามารถเปน ไดทง้ั คา คงที่ ตวั แปร หรือ

2 Java เรียกตวั แปรที่มีการประกาศใชภายใน method (เชน method main() ทีเ่ ห็น) วา local variable ซ่ึงเปน การ
ประกาศใชท่ีตอ งการกาํ หนดคาเบอ้ื งตนกอ น แตม ตี ัวแปรอกี แบบหนง่ึ ที่ Java เรยี กวา member variable หรอื reference

variable (เชน variable ทอ่ี ยูใน class) ทไี่ มจาํ เปนตองมีการกาํ หนดคา ผา นเรา แต Java จะกําหนดคา เบอื้ งตนใหกับตวั แปร
เหลานัน้ เอง ซ่งึ มคี าตา ง ๆ ดงั น้ี

ชนิดของตัวแปร คาเบ้ืองตน จาก Java
boolean false
char '0'
byte, short, int, long 0
double, float 0.0

24

บทท่ี 2: ขอ มูล ตัวแปร และการประมวลผล intro. to Java (FEU.faa)

ประโยคใด ๆ ท่ีสามารถหาคา ได สวน lvalue เปน ไดเ ฉพาะตัวแปรเทานนั้ เพราะจะตอ งเปนทีท่ ีเ่ กบ็
ขอ มูลได (physical memory) เชน

numberOfBikes = 2;
area = PI * r * r;
taxReturned = calculateTaxReturned(income);

แตไ มใ ชแบบนี้

2 = numberOfBikes;
PI * r * r = area;
calculateTaxReturned(income) = taxReturned;

ในการกาํ หนดคา ใหกบั ตัวแปรนน้ั ถา เรามองในมุมมองของทม่ี าของคาท่ีนาํ มาใสใ หกับตัวแปร เราก็
สามารถทจี่ ะแบงการกาํ หนดคา ไดเปน สองแบบ คอื (1) การกําหนดคา ใหก ับตัวแปรภายในตวั
โปรแกรม และ (2) การกาํ หนดคาใหก ับตวั แปรผานทางส่อื การนําเขา ขอ มลู มาตรฐาน (standard I/O
channel) เราจะมาทําความเขาใจการกําหนดคาในแบบทหี่ นง่ึ กนั กอ น เพราะเปน การกาํ หนดคา ที่งา ย
ท่สี ุด

2.3.2 การกาํ หนดคาใหก บั ตัวแปรภายในโปรแกรม

ดงั ที่ไดกลาวมาแลว วาการกําหนดคา ใหก บั ตวั แปรนน้ั สําคัญมาก เพราะโดยทวั่ ไปตวั แปรจะไมมคี าใด
ๆ เลยหลังจากการประกาศ ภาษาในการเขยี นโปรแกรมหลาย ๆ ภาษาบงั คบั ใหผเู ขียนโปรแกรม
กาํ หนดคา เบอ้ื งตน กอ นที่จะใชตัวแปรนัน้ ๆ ซงึ่ ก็เปนสิ่งทด่ี ี เพราะจะทําใหก ารเขียนโปรแกรมเปนไป
ไดง าย และสะดวกตอ การตรวจสอบหากมขี อผิดพลาดเกิดขน้ึ โปรแกรมตัวอยา งท่ีเห็นนีแ้ สดงถงึ
วิธีการประกาศตัวแปรพรอ มกับการกําหนดคา เบ้ืองตนใหกบั ตัวแปรเหลาน้ัน

1: /**
2: Demonstrates variables declaration and initialization
3: */
4:
5: class Variables {
6: public static void main(String[] args) {
7: boolean booleanVar = true;
8: byte byteVar = 0;
9: byte maxByte = Byte.MAX_VALUE;
10: byte minByte = Byte.MIN_VALUE;
11: short shortVar = 0;
12: short maxShort = Short.MAX_VALUE;
13: short minShort = Short.MIN_VALUE;
14: int intVar = 0;
15: int maxInt = Integer.MAX_VALUE;
16: int minInt = Integer.MIN_VALUE;
17: long longVar = 0L;
18: long maxLong = Long.MAX_VALUE;
19: long minLong = Long.MIN_VALUE;
20: float floatVar = 0.0F;
21: float maxFloat = Float.MAX_VALUE;
22: float minFloat = Float.MIN_VALUE;
23: double doubleVar = 0.0D;
24: double maxDouble = Double.MAX_VALUE;
25: double minDouble = Double.MIN_VALUE;
26: char charVar = 'A';
27:
28: System.out.println("boolean variable: " + booleanVar);
29: System.out.println("byte variable: " + byteVar);
30: System.out.println("short variable: " + shortVar);
31: System.out.println("int variable: " + intVar);
32: System.out.println("long variable: " + longVar);
33: System.out.println("float variable: " + floatVar);
34: System.out.println("double variable: " + doubleVar);
35: System.out.println("char variable: " + charVar);
36:
37: System.out.println("Max byte: " + maxByte);
38: System.out.println("Min byte: " + minByte);
39: System.out.println("Max short: " + maxShort);
40: System.out.println("Min short: " + minShort);
41: System.out.println("Max int: " + maxInt);

25

เรมิ่ ตน การเขียนโปรแกรมดว ย Java intro. to Java (FEU.faa)

42: System.out.println("Min int: " + minInt);
43: System.out.println("Max long: " + maxLong);
44: System.out.println("Min long: " + minLong);
45: System.out.println("Max float: " + maxFloat);
46: System.out.println("Min float: " + minFloat);
47: System.out.println("Max double: " + maxDouble);
48: System.out.println("Min double: " + minDouble);
49: }
50: }

เรากําหนดคาที่เปน ศูนยใ หก ับตวั แปรทุกตวั ยกเวน ตัวแปรท่เี ปน boolean ซงึ่ เรากําหนดคา ใหเปน
true และตัวแปรที่เปน char ที่เรากาํ หนดคาใหเ ปนตวั อกั ษร A สว นตวั แปรทข่ี ึ้นตนดว ย max หรอื
min เราจะกาํ หนดคาใหเปน คาสูงสดุ และคาตา่ํ สดุ ท่ี Java มีให เราบอกให Java รูวาคาทกี่ ําหนด
ใหก บั ตวั แปรตา ง ๆ มีชนิดเปนอะไรไดดวยการใสต วั อักษรท่ีบงบอกชนดิ นั้น ๆ ของตวั แปร เชน 0L
0.0F และ 0.0D ซึ่งหมายถงึ คาของศูนยท ี่เปน long คาของศนู ยท ีเ่ ปน float และ คา ของศูนยท ่เี ปน
double ตามลําดับ ทั้งนี้เพอ่ื บอกให Java รวู าเราตองการใชคาที่เกบ็ ชนิดน้ัน ๆ จรงิ ซ่ึงเราจําเปนท่ี
จะตอ งทําเพยี งคา ของตัวแปรทเ่ี ปน float และ double เทา นนั้ เพราะวาตวั แปรท่มี ีชนิดเปน float ถา
มีการกําหนดคา Java จะเหมาเอาวา เปน double เราจงึ ตอ งกาํ หนดคาตามชนิดของตัวแปรจรงิ ๆ ท่ี
เราตอ งการ สว นตวั แปรอน่ื ๆ เรากาํ หนดใหมคี า เปน คาสูงสดุ และคาต่ําสุดที่ Java ยอมใหเปนได

ผลลพั ธของโปรแกรม Variables.java

boolean variable: true
byte variable: 0
short variable: 0
int variable: 0
long variable: 0
float variable: 0.0
double variable: 0.0
char variable: A
Max byte: 127
Min byte: -128
Max short: 32767
Min short: -32768
Max int: 2147483647
Min int: -2147483648
Max long: 9223372036854775807
Min long: -9223372036854775808
Max float: 3.4028235E38
Min float: 1.4E-45
Max double: 1.7976931348623157E308
Min double: 4.9E-324

เรามาดขู ้ันตอนที่ Java เกบ็ ขอมูลในตัวแปรกนั ดีกวา (หากจะบอกวาภาษาอน่ื ๆ ก็เกบ็ แบบนกี้ ค็ งจะ
ไมผิดนกั ) เราจะใชต วั แปรจากโปรแกรมตวั อยา งขา งบน จากประโยคของการประกาศและกําหนดคา

long longVar = 0L;

ประโยคท่เี ห็นดานบนน้ีสามารถทจ่ี ะเขยี นไดอ ีกแบบหนึง่ คือ

long longVar;
longVar = 0L;

ประโยค long longVar; นน้ั เปน การประกาศตวั แปรชื่อ longVar ทมี่ ีชนดิ เปน long สวนประโยค
longVar = 0L; นัน้ เปน การกําหนดคา 0 ใหกับตัวแปร longVar (ภาพที่ 2-1 แสดงถงึ ขนั้ ตอนในการ
สรางตัวแปรและการกําหนดคาใหกบั ตวั แปรของ Java) การประกาศพรอมกับกําหนดคา ใหกบั ตัวแปร
ในประโยคเดยี วกัน ชว ยใหก ารเขยี น code เมอ่ื มองดแู ลว สวยและกะทดั รดั ข้นึ ทงั้ นี้กค็ งจะขึน้ อยูก ับ
ตวั ผูอานเองวามคี วามคิดเหน็ อยา งไร สําหรับตวั ผเู ขียนเองคิดวาถาเปนการประกาศท่ีมีตัวแปรไมกี่ตวั
ในบรรทดั นั้นก็คงมองดแู ลว สวยดี แตถา มีมากเกนิ ไปกค็ งจะไมเขา ทาเทาไรนัก ตัวอยา งเชน

double price = 0.0D, tax = 0.7D, returned = 0.0D, interests = 0.0D, principal =
10000.0D;

โปรแกรมเมอรควรจะแยกการประกาศทเ่ี ห็นดา นบนนี้ใหอยคู นละบรรทัดเพ่อื ใหงา ยตอ การอา น และ
เปล่ียนแปลง หากมกี ารเปล่ยี นแปลงเกิดข้นึ ในโปรแกรม

26

บทท่ี 2: ขอมลู ตวั แปร และการประมวลผล

long longVar; longVar = 0L; intro. to Java (FEU.faa)

??? 0

ประกาศตัวแปรชนิด long ชอ่ื วา หลังจากกําหนดคา 0 ใหกับ
longVar ซงึ่ Java จะจอง longVar แลว หนวยความจํา ณ
หนวยความจําใหแตไ มมคี า ใด ๆ ตาํ แหนงนัน้ กจ็ ะมีคา ตามที่
ณ หนวยความจํานั้น กาํ หนดให คอื 0

ภาพท่ี 2-1 การกาํ หนดคา ใหกับตวั แปร

ในการกาํ หนดคา ใหกับตัวแปรน้นั เราไมจาํ เปนทจ่ี ะตองกําหนดคา ของตวั แปรตา ง ๆ ใหเปนศนู ย เรา
สามารถที่จะกาํ หนดคา อะไร ก็ไดใหก ับตวั แปรเหลาน้ี ทง้ั นีข้ ้ึนอยกู บั การใชง านของตวั แปรน้ัน ๆ
หลาย ๆ คร้งั ที่เราตองตดั สนิ ใจวา ควรจะใชต วั แปรชนิดใดดี ในกรณที ขี่ อ มลู เปนชนิดท่อี ยูในหมวด
เดียวกนั เชน ขอมลู เปน เลขท่ีไมมจี ุดทศนยิ ม หรอื ขอ มลู เปนเลขที่มีจดุ ทศนิยม ซง่ึ ถา เหตกุ ารณ
เหลา น้ีเกิดขน้ึ เราก็จาํ เปนทจ่ี ะตอ งคิดถงึ คา ความเปนไปไดของขอ มูลวาต่ําสดุ และสงู สุดควรเปน
เทาใด (range) เชน ถาเราตอ งการใชต ัวแปรรองรบั ขอมลู ทเ่ี ปนเลขท่ไี มม ีจุดทศนยิ มทมี่ ขี นาดไมเ กนิ
127 เรากค็ วรท่ีจะประกาศตัวแปรดว ยการใช byte แทนการใช int เปนตน

เราสามารถทจ่ี ะประกาศตัวแปรพรอมกบั การกําหนดคา ใหกับตวั แปร หลาย ๆ ตวั ในหนึ่งประโยค เชน

int length = 2, height = 8, width = 4;
double angles = 30.5, distance = 24.50;

การประกาศตวั แปรในรปู แบบนตี้ อ งใชเครือ่ งหมาย , (comma) เปนตวั แบง ตวั แปรออกจากกัน และตวั
แปรเหลานั้นจะมีชนิดเปนชนดิ เดียวกนั ตลอด เราไมสามารถประกาศตัวแปรตางชนดิ กนั ไดดวยวิธีการ
ประกาศแบบนี้ เชน

int cats = 90, float tax = 0.50; // ERROR – mixed-type

การประกาศตวั แปรไมจาํ เปน ตอ งกําหนดคา ใหท นั ที แตส ามารถที่จะกําหนดไดภ ายหลัง เชน

double radius;
radius = 2.54;

ลองมาดกู ารประกาศและกาํ หนดคาในรูปแบบอกี รูปแบบหนึ่ง

int one = 1, two = 2, three = one + two;

Java ยอมใหมีการประกาศและกาํ หนดคาแบบน้ีได เนือ่ งจากวา ตวั แปร one และ two มกี าร
กําหนดคา เรยี บรอยแลว ดังนน้ั การประกาศและกาํ หนดคาใหก บั ตวั แปร three จึงทําไดโดยไมมี
ปญหาใด ๆ จาก compiler เลย ประโยค three = one + two; เปนประโยคทมี่ กี ารประมวลผลของ
one + two กอนแลวจึงนาํ คา ท่ีไดมาเก็บไวท ต่ี ัวแปร three เราจะพดู ถึง ประโยค และ การ
ประมวลผลทีเ่ กิดข้นึ ในประโยคในโอกาสตอไป

2.4 การใช final ในการกาํ หนดคา ใหกบั ตัวแปร

หลาย ๆ ครัง้ ทีเ่ ราตองการใชคา บางคาตลอดอายกุ ารทํางานของโปรแกรม เชน คา ของ PI หรอื
คาคงทีท่ ่จี ะไมมีการเปลีย่ นแปลงใด ๆ ในขณะใชงานในโปรแกรม Java มคี าํ สัง่ ที่ user ไมสามารถที่
นํามาใชใ นการประกาศตัวแปรได (reserved word) แตเ อาไวใ ชในงานนี้โดยเฉพาะ คอื คําวา final

27

เริ่มตนการเขยี นโปรแกรมดวย Java intro. to Java (FEU.faa)

ถาเราขนึ้ ตนการประกาศตัวแปรดว ยคาํ วา final ตัวแปรนนั้ ๆ จะไมสามารถมีคา อน่ื ๆ ไดอกี ไมวาจะ
เปน การเปลย่ี นคาภายในโปรแกรม หรือ การเปลี่ยนแปลงทีเ่ กดิ จากการใสขอมลู ใหมผานทาง
keyboard ดังโปรแกรมตวั อยางท่แี สดงใหเ หน็ นี้

1: /**
2: Demonstrates the use of final keyword
3: */
4:
5: class Final {
6: public static void main(String[] args) {
7: final double PI = 3.14;
8: int radius = 2;
9:
10: System.out.println("The value of PI is " + Math.PI);
11:
12: double area = radius * radius * Math.PI;
13: System.out.println("Area of a circle is " + area);
14: }
15: }

หลังจากท่ี compile และ run โปรแกรม ผลลัพธทไี่ ดคือ

The value of PI is 3.14
Area of a circle is 12.56

ถา เราเปลีย่ นแปลงโปรแกรม Final.java ดว ยการกาํ หนดคา ใหกับตวั แปร PI ใหม ดงั ทเี่ ห็นใน
โปรแกรม FinalWithError.java น้ี compiler จะฟองดว ยขอมลู ดังท่ีเห็น

1: /**
2: Changing the value of final keyword
3: */
4:
5: class FinalWithError {
6: public static void main(String[] args) {
7: final double PI = 3.14;
8: int radius = 2;
9:
10: double area = radius * radius * PI;
11: System.out.println("Area of a circle is " + area);
12:
13: PI = 3.142;
14: area = radius * radius * PI;
15: System.out.println("Area of a circle is " + area);
16: }
17: }

ผลของการ compile

FinalWithError.java:13: cannot assign a value to final variable PI
PI = 3.142;
^

1 error

ขออธิบายถึงขอ ความ error ที่ Java ฟอ งสกั นดิ หนอย ถาผูอ า นสังเกต error ทเ่ี กิดข้ึนจะเหน็ เลข 13
ถดั จากชือ่ ของโปรแกรมทไ่ี ดรับการ compile ซงึ่ บงบอกถงึ เลขทบ่ี รรทดั ท่ี error นเี้ กิดข้ึน รวมไปถึง
ตําแหนงที่ error เกดิ ขึน้ ซง่ึ เปน ตวั ชวยใหเ รากลบั เขาไปแกไขโปรแกรมของเราไดง ายย่งิ ขนึ้ (ไมต อ ง
เสียเวลาคน หาบรรทดั ท่ีเกดิ error)

การใช final ทําใหโปรแกรมมีความแมนยําและม่นั คงมากยงิ่ ขนึ้ ความพยายามทจี่ ะเปลยี่ นคาเหลาน้ีก็
ไมสามารถทาํ ได ทําใหก ารออกแบบและพัฒนาโปรแกรมเปนไปไดดวยดี ลดขอ ผดิ พลาดทีอ่ าจ
เกิดข้นึ จากตวั โปรแกรมเมอรเ อง

ในบางครงั้ การประกาศตวั แปรตอ งการใชค าท่ีสูงมาก ๆ หรือ คา ทเ่ี ล็กมาก ๆ เชน ระยะทางจากโลก
ไปยงั ดวงอาทติ ย ซ่ึงมคี า โดยประมาณเทากับ 149, 600,000 กโิ ลเมตร (1.496 x 108) หรอื การ
กาํ หนดคา ของมวลของอเิ ลคตรอน (electron mass) ซง่ึ มีคา เล็กมาก ขนาดของมวลโดยประมาณมี

28

บทท่ี 2: ขอ มลู ตวั แปร และการประมวลผล

คา เทากับ 0.0000000000000000000000000009 กรมั (9.0 x 10-28) เรากส็ ามารถทาํ ไดด ว ยการ intro. to Java (FEU.faa)
ใชการประกาศในรปู แบบของการกําหนดคา ทางวทิ ยาศาสตร (scientific notation) เชน

final double sunDistance = 1.496E8; // 1.496 x 108
final float electronMass = 9.0E-28F; // 9.0 x 10-28

การประกาศและกําหนดคาในรูปแบบนท้ี าํ ใหการมองเห็น และ การเขยี นหรือการอานทาํ ไดงา ยยิ่งขนึ้
ลองนกึ ถงึ การทเ่ี ราตองเขยี นประโยคในการกําหนดคา ใหกับ มวลของอิเลคตรอน ทไี่ ดก ลา วถึง
ขา งตนซ่งึ มศี นู ยถงึ 27 ตวั วา นา รําคาญขนาดไหน (โปรแกรมเมอรสว นใหญร ูเรือ่ งน้ดี )ี ยิ่งถาเราเขียน
code เยอะ ๆ การกาํ หนดคา ใหก บั ตวั แปรเหลา น้ดี ว ยการเขยี นที่สนั้ ทีส่ ดุ ยอมเปน การดเี สมอ (เขียน
โปรแกรมไดไวข้นึ ?)

2.5 อายุ และ ขอบเขตการใชง าน (life-time and scope) ของตัวแปร

หลังจากที่มกี ารประกาศใชตวั แปรใด ๆ ในโปรแกรม ตวั แปรเหลา นจ้ี ะมขี อบเขต หรืออายุการใชงาน
ตามลักษณะการประกาศตวั แปรของผูเขียนโปรแกรมเอง โดยทั่วไปตวั แปรจะมอี ายุการใชง านตาม
เน้ือท่ี (block) ทต่ี วั แปรเหลานน้ั ปรากฏอยู ซงึ่ จะอยูในเครื่องหมาย {} เชนโปรแกรมตัวอยางตอไปน้ี

1: /**

2: Showing scope of variables
3: */

4:
5: class Scope {
6: public static void main(String[] args) {

7: int x = 5, y = 8;

8:
9: System.out.print("Value of x is ");

10: System.out.println(" Value of y is " + y);
11: //create scope for x and w

12: {
13: int x = 45;
14: int w = 89;

15: System.out.println("Value of w in brackets is " + x);
16: System.out.println("Value of y in brackets is " + y);
17: }

18: //error w is out of scope

19: System.out.println("Value of w is " + w);
20: }

21: }

เปนทีแ่ นน อนอยูแลววา โปรแกรม Scope.java จะ compile ไมผ าน เนอ่ื งจากเหตผุ ลสองอยา งดังที่
compiler ฟอง คอื (1) ตัวแปร int x ไดม กี ารประกาศใน main() แลว และ (2) ตัวแปร int w ไมไ ด
อยูใน scope ของมนั เอง ซงึ่ ในที่นคี้ อื block ทม่ี ีการประการ int x และ int w

Scope.java:13: x is already defined in main(java.lang.String[])

int x = 45;

^
Scope.java:19: cannot find symbol
symbol : variable w

location: class Scope
System.out.println("Value of w is " + w);
^

2 errors

ในภาษาอนื่ เชน C++ การประกาศตัวแปรใน block ใหมด ว ยตัวแปรทมี่ ีช่ือซา้ํ กนั สามารถทําไดโ ดย
ไมมเี ง่อื นไขใด ๆ (ดังทเ่ี หน็ ในโปรแกรม Scope.java) แตต วั Java เองไมยอมใหม กี ารประกาศตวั
แปรซํา้ ถงึ แมว าจะอยูใน block ใหมทซ่ี อนกันอยูก็ตาม ยกเวน ในกรณีทเ่ี ราสราง block ใหมท ีไ่ มซอน
กัน ดังทีเ่ ห็นน้ี

{
int w = 3;

}

{
int w = 5;

}

29

เรม่ิ ตนการเขียนโปรแกรมดว ย Java intro. to Java (FEU.faa)

ลองมาดโู ปรแกรม Scope2.java

1: /**
2: Showing scope of variables
3: */
4:
5: class Scope2 {
6: static int x = 8, y;
7: public static void main(String[] args) {
8: {
9: int x;
10: x = 5;
11: y = x;
12: System.out.println("Value of y is " + y);
13: }
14: y = x;
15: System.out.println("Value of y is " + y);
16: }
17: }

โปรแกรม Scope2.java หลังจากท่ี compile ผานแลว จะไดผ ลลพั ธด งั น้ี

Value of y is 5
Value of y is 8

จะเหน็ วา compiler ยอมใหผานท้งั นเี้ พราะตวั แปร x ใน block ดา นในมกี ารประกาศและกําหนดคา
อยา งสมบรูณ และ ตัวแปร x ใน scope ดานนอกมีการกาํ หนดใหเปน static ซึง่ เปนตัวแปรที่ Java
เรยี กวา class variable ดังนนั้ ตวั แปรท้ังสองจึงไมใชต วั แปรเดยี วกัน เพราะฉะนนั้ การกําหนดคา ใหกบั
ตวั แปร y ใน block ดา นในจะไดค า ของตวั แปร x ท่อี ยดู า นใน และการกาํ หนดคาใหกับ y อีกครง้ั ดา น
นอกจึงไดค าของ class variable ท่ชี ่ือวา x

เรามาลองดโู ปรแกรมตวั อยางอีกโปรแกรมหน่งึ

1: /**
2: Showing scope of variables
3: */
4:
5: class Scope2v1 {
6: static int x = 8, y;
7: public static void main(String[] args) {
8: {
9: x = 5;
10: y = x;
11: System.out.println("Value of y is " + y);
12: }
13: y = x;
14: System.out.println("Value of y is " + y);
15: }
16: }

โปรแกรม Scope2v1.java แสดงการใชต วั แปร x ตัวเดยี วทไี่ ดป ระกาศกอ น method main() ซ่ึงมคี า
เปน 8 ดังนน้ั การเปลี่ยนคา ของ x ใน block ดา นในทาํ ใหค า ของตัวแปร x เปนคาลาสดุ คอื 5 ผลลัพธ
ของการ run โปรแกรมนีจ้ ึงไดอ ยา งท่ีคาดหวงั ไว คือ

Value of y is 5
Value of y is 5

ลองมาดูอีกตวั อยางหนึ่ง

1: /**
2: Showing scope of variables
3: */
4:
5: class Scope3 {
6: static int x = 20;
7: public static void main(String[] args) {
8: System.out.println("x = " + x);

30

บทที่ 2: ขอ มูล ตวั แปร และการประมวลผล intro. to Java (FEU.faa)

9: int x = (x = 12) + 8;
10: System.out.println("Value of local x is " + x);
11: }
12: }

ในโปรแกรม Scope3.java นเี้ ราประกาศตวั แปรสองตวั ที่มชี ื่อเหมอื นกันคือ x โดยที่ตวั หนงึ่ มี scope
อยใู น class Scope3 และอกี ตัวหนึ่งมี scope อยูใ น method main() และเมือ่ compile ผา นแลว
ผลลัพธท ีไ่ ด คอื

x = 20
Value of local x is 20

ในบรรทดั ท่ี 8 การแสดงผลท่เี กดิ ขึ้นเปน การแสดงผลของตัวแปร x ทีอ่ ยูภายนอก main() สวนการ
แสดงผลในบรรทัดที่ 10 เปนการแสดงผลของตัวแปร x ทเี่ ราไดป ระกาศใชภายใน main() ซึ่งเปนคน
ละตัวกนั เหมอื นท่ีไดก ลาวไวแลว

1: /**
2: Showing scope of variables
3: */
4:
5: class Scope4 {
6: public static void main(String[] args) {
7: int x = (x = 12) + 8;
8: System.out.println("Value of local x is " + x);
9: }
10: }

โปรแกรม Scope4.java เปน โปรแกรมเดยี วกนั กบั โปรแกรม Scope3.java เพยี งแตเ ราลบการประกาศ
ตวั แปรทอี่ ยดู านนอกออก และเมือ่ compile และ run ผลลัพธท่ไี ดก ็คอื ผลลพั ธเดิมที่ไดจ าก
โปรแกรม Scope3.java

ลองมาดอู ีกตวั อยา งหนง่ึ

1: /**
2: Showing scope of variables
3: */
4:
5: class Scope6 {
6: public static void main(String[] args) {
7: int x = 12, y = x + 8;
8: System.out.println("Value of local y is " + y);
9: }
10: }

ซงึ่ ไดผลลัพธห ลงั จากการ compile และ run ดงั นี้

Value of local y is 20

การประกาศและกําหนดคา แบบน้ีสามารถทําไดเ พราะ x ไดร ับการกําหนดคากอนที่จะถกู นาํ มาใชใน
การประกาศและกาํ หนดคา ใหก บั ตัวแปร y

การประกาศและกาํ หนดคา ใหก ับตวั แปรใด ๆ นนั้ จะตองคาํ นงึ ถึงการใช และขอบเขตของการใชเสมอ
ท้ังนใ้ี นการกาํ หนดคา ใด ๆ ใหก บั ตัวแปรน้ันสิ่งท่นี าํ มากําหนดคา นัน้ ในตวั ของมันเองจะตองมีคาอยู
แลว หรอื สามารถทจ่ี ะทาํ การประมวลคาไดก อ นท่จี ะนาํ มาใชในการกําหนดคา ใหก ับตัวแปรอ่นื ดงั เชน
ตัวอยา งทเี่ หน็ กอนหนา นี้

2.6 การสรางประโยค (statement and expression)

ในภาษา Java ประโยค (statement) จะตอ งจบดวยเครือ่ งหมาย ; (semicolon) เสมอดังตวั อยา งท่ี
แสดงใหเห็นน้ี

int priceOfBook = 125;
float taxReturn;

31

เร่ิมตนการเขยี นโปรแกรมดวย Java intro. to Java (FEU.faa)

เราไมจ ําเปนจะตองเขยี นประโยคใหจ บภายในบรรทดั เดยี ว แตท ่สี ําคญั ตอ งมีเครื่องหมาย ; ปด ทา ย
เสมอ เชน

int
priceOfBook
=
125
;

Java จะมองหาเครือ่ งหมาย ; เสมอโดยไมแ ยแสวาประโยคนั้น ๆ จะกนิ เนอื้ ทก่ี ี่บรรทัด แตท ี่สาํ คัญก็
คอื การเขียนท่ีทําใหอ านไดง า ย ยอมจะทาํ ใหทง้ั เรา และผูอ่ืนสามารถทจี่ ะดู code ไดรวดเร็วยงิ่ ข้นึ ถา
ไมเชื่อลองดู code จากโปรแกรมน้ดี ูสิ

/* Scope2v1.java - Showing scope of variables* @author faa xumsai*/class
Scope2v1{static int x = 8, y;public static void main(String[] args) { {int x;x =
5;y = x;System.out.println("Value of y is " + y);}y = x; System.out.println("Value
of y is " + y);}}

การเขยี น code ใหม ีรปู แบบทเี่ หมาะสม อานไดง าย จะทําใหการพัฒนาโปรแกรมเปนไปไดด ว ยความ
รวดเรว็ และเปนท่ียอมรับตามระบบสากล รูปแบบที่เหมาะสมนนั้ คือมกี ารยอ หนา (indentation)
เพื่อใหก ารอา นทําไดงา ย และมองดูแลวสวยงาม ดังโปรแกรมตวั อยา งหลาย ๆ ตวั ทแ่ี สดงใหเ ห็นกอ น
หนา นี้

Expression หมายถงึ ประโยคในภาษา Java ที่ไดร ับการยอมรบั วา อยูในรูปแบบที่ไดกําหนดไว เชน
ประโยคในเรือ่ งของการกําหนดคา ใหก บั ตวั แปร ประโยคท่ีตองมกี ารประมวลผลในรปู แบบตา ง ๆ เชน
การประมวลผลทางดานคณิตศาสตร (mathematical evaluation) การประมวลผลทางดานตรรกะ
(relational evaluation) เปนตน

การประมวลผลทางดา นคณิตศาสตรน้ัน มี operator ที่ใชอ ยูดงั น้ี คือ + (บวก), – (ลบ), * (คณู ), /
(หาร) และ % (การหาเศษทเี่ หลือจากการหารตัวเลขสองตวั ) โปรแกรมตวั อยางตอไปน้ีแสดงถงึ การ
ประมวลผลของขอมูลดวย operator ชนดิ ตา ง ๆ ทไี่ ดกลาวถงึ

1: /**
2: Shows mathematical operators
3: */
4:
5: class OperatorsOnInt {
6: public static void main(String[] args) {
7: int i, j, k;
8:
9: //generate random number between 1 and 10
10: j = 1 + (int)(Math.random() * 10);
11: k = 1 + (int)(Math.random() * 10);
12: System.out.println("j = " + j + " and k = " + k);
13:
14: //evaluate and display results of math operators
15: i = j + k; System.out.println("j + k = " + i);
16: i = j - k; System.out.println("j - k = " + i);
17: i = j * k; System.out.println("j * k = " + i);
18: i = j / k; System.out.println("j / k = " + i);
19: i = j % k; System.out.println("j % k = " + i);
20: }
21: }

เนือ่ งจากวาเราตองการทจี่ ะแสดงถึงการสรา งประโยคและการประมวลผลดว ยคาทม่ี าจาก ขางใน
โปรแกรมเอง และเราไดใ ชเ คร่ืองมือในการสรางคาเหลา นใี้ หเ ราแบบอตั โนมตั ิ ซึ่งเครื่องมอื ท่ีวานก้ี ็คือ
method random() ท่ีมาจาก class Math (มอี ยใู น Java แลว ) method random() จะสรางคา
ระหวา ง 0 – 0.9+ พูดงา ย ๆ ก็คอื คา ตํา่ สุดคือ 0 และคาสงู สุดคอื คา ที่ใกล 1 แตไมเทา กบั 1 (คา n
ใด ๆ ทีอ่ ยใู นเงื่อนไขน้ี Æ 0.0 <= n < 1.0) เมอื่ ไดค านีแ้ ลว เราคณู คานด้ี วย 10 แลวบวก 1 เราก็จะ
ไดค าระหวาง 1 – 10 หลงั จากนัน้ เราก็คํานวณหาคา i ดว ยการใช operator ตาง ๆ พรอ มทั้งแสดง
คา ทหี่ าไดไปยงั หนา จอ และเมอื่ run โปรแกรมผลลพั ธท่ไี ดค อื

j = 5 and k = 2
j+k=7

32

บทที่ 2: ขอ มูล ตัวแปร และการประมวลผล intro. to Java (FEU.faa)

j-k=3
j * k = 10
j/k=2
j%k=1

และเนอื่ งจากวาเราใช method random() เปนตัวหาคา ดงั นนั้ การ run ในแตละครัง้ กจ็ ะไดผ ลลพั ธท ่ี
อาจซ้าํ กนั หรือแตกตา งกนั

Operator ตวั อนื่ ๆ ก็เหมือนกับการคํานวณ ทางดานคณิตศาสตรทีเ่ ราคุน เคยโดยทวั่ ไป ยกเวน %
ซง่ึ เปนการหาเศษจากการหารตวั เลขที่เปน integral และ floating point ประโยคจากโปรแกรมทว่ี า

i = j % k;

จะนาํ เอาคาของตวั แปร k คือ 2 ไปหารคาของตัวแปร j ซึ่งมคี า เปน 5 แลวเก็บเศษทไี่ ดจากการหาร
ไว (ซึง่ ก็คือ 1) เม่ือไดแ ลวก็นําคาน้ีไปเกบ็ ไวใ นตวั แปร i ตอ ไป

โปรแกรมตัวอยางตอไปน้แี สดงถึงการกาํ หนดคาดวยขอมลู ชนดิ int และ double

1: /**
2: Shows mathematical operators
3: */
4: import java.util.Random;
5:
6: class Operators {
7: public static void main(String[] args) {
8: //do the ints
9: int i, j, k;
10:
11: //generate random number between 1 and 10
12: Random rand = new Random();
13: j = 1 + rand.nextInt(10);
14: k = 1 + rand.nextInt(10);
15: System.out.println("j = " + j + " and k = " + k);
16:
17: //evaluate and display results of math operators
18: i = j + k; System.out.println("j + k = " + i);
19: i = j - k; System.out.println("j - k = " + i);
20: i = j * k; System.out.println("j * k = " + i);
21: i = j / k; System.out.println("j / k = " + i);
22: i = j % k; System.out.println("j % k = " + i);
23:
24: //do the doubles
25: double v1, v2, v3;
26: //generate random double between 1.0 and 10.0
27: v1 = 1.0 + rand.nextDouble() * 9;
28: v2 = 1.0 + rand.nextDouble() * 9;
29: System.out.println("v1 = " + v1 + " v2 = " + v2);
30: v3 = v1 + v2; System.out.println("v1 + v2 = " + v3);
31: v3 = v1 - v2; System.out.println("v1 - v2 = " + v3);
32: v3 = v1 * v2; System.out.println("v1 * v2 = " + v3);
33: v3 = v1 / v2; System.out.println("v1 / v2 = " + v3);
34: }
35: }

ผลลัพธท ไ่ี ดคอื

j = 7 and k = 6
j + k = 13
j-k=1
j * k = 42
j/k=1
j%k=1
v1 = 3.5279786640632915 v2 = 9.035898448743211
v1 + v2 = 12.563877112806502
v1 - v2 = -5.5079197846799195
v1 * v2 = 31.878456937808643
v1 / v2 = 0.39044027376757345

33

เรมิ่ ตนการเขียนโปรแกรมดว ย Java

โปรแกรม Operators.java แสดงตวั อยางของการกาํ หนดคา และ การคาํ นวณดว ย operator อยา ง intro. to Java (FEU.faa)
งาย ๆ ทางดา นคณิตศาสตร โดยเริ่มตน ดว ยการกําหนดคา ใหกับตัวแปร i และ j ดว ยการสรา งคาแบบ
สุม (random) จาก method nextInt(max value) ซง่ึ method นี้จะกําหนดคาทอี่ ยรู ะหวาง 0 ถงึ
คา ที่กาํ หนดใน max value แตไ มร วมตัว max value ดว ยซง่ึ ถา เราตอ งการท่ีจะสรา งคา ที่อยูระหวาง
1 ถึง 10 เรากต็ อ งบวก 1 เขากับคาที่เกดิ จากการเรียกใช method นีด้ ว ย ดงั ทีไ่ ดก าํ หนดไวใน
โปรแกรม

เราสามารถทจ่ี ะเขียนประโยคท่มี ีการประมวลผลในรูปของประโยคทมี่ หี ลายตัวแปรในประโยคเดยี วกนั
ได ดงั ตวั อยา งน้ี

1: /**
2: Shows mathematical operators

3: */

4:
5: class Operators1 {

6: public static void main(String[] args) {

7: int a, b, c, d, e;
8:
9: b = 1 + (int)(Math.random() * 10);
10: c = 1 + (int)(Math.random() * 10);

11: d = 1 + (int)(Math.random() * 10);
12: e = 1 + (int)(Math.random() * 10);
13:

14: System.out.print("b = " + b + " c = " + c);

15: System.out.println(" d = " + d + " e = " + e);
16: a = b + c - d;

17: System.out.println("Value of a is " + a);

18: a = b * c - d;
19: System.out.println("Value of a is " + a);
20: a = b / c * d;

21: System.out.println("Value of a is " + a);
22: }

23: }

ผลลพั ธท่ไี ดจ ากการ run คือ

b=8c=2d=6e=5
Value of a is 4
Value of a is 10

Value of a is 24

2.7 การประมวลผล

เม่ือมีตวั แปรหลายตวั ในการประมวลผลของประโยค ลําดบั ขัน้ (precedence) ของการประมวลผลมี
ความสําคญั ทันที ท้ังนกี้ เ็ นือ่ งมาจากรปู แบบของการประมวลผลตามช้ันของ operator ตา ง ๆ มีลําดบั
การประมวลผลท่ีไมเ ทา กนั (กอ น หรือ หลงั ) ซึง่ เปนไปตามลาํ ดับขัน้ ของการประมวลผลตามกฎของ
การประมวลผลทางดานคณิตศาสตร ดังตารางที่ 2.4

ตาราง 2.4 Operator Precedence การประมวลผล
Operator ตามกลุม
ซายไปขวา
(), [], ., postfix ++, postfix -- ขวาไปซา ย
unary +, unary –, prefix ++, prefix -- ซา ยไปขวา
(datatype), new ซา ยไปขวา
*, /, %
ซายไปขวา
+, - ซายไปขวา
<<, >>, >>> ซา ยไปขวา
<, <=, >, >=, instanceof ซา ยไปขวา
==, !=
ซายไปขวา
& ซายไปขวา
^ ซา ยไปขวา
| ซายไปขวา
&&

34

บทท่ี 2: ขอมลู ตัวแปร และการประมวลผล

|| ซายไปขวา intro. to Java (FEU.faa)
?: ซายไปขวา
=, +=, -=, *=, /=, %=, <<=, >>=, >>>=, &=, |=, ^= ขวาไปซาย

2.7.1 การประมวลผลขอมลู ทเ่ี ปน integer

การประมวลผลขอ มลู ท่ีเปน integer ทง้ั หมดไมม ีความสลับซับซอ นอะไรเลย เปน การประมวลผล
เหมือนกบั ทเ่ี ราเคยเรยี นมา ในวิชาคณิตศาสตรซงึ่ ลําดับข้ันของการประมวลผลก็ข้ึนอยกู บั ชนิดของ
operator ทีใ่ ชในการประมวลผลนน้ั ๆ เชน การคูณและการหาร ทํากอน การบวกและการลบ
statement

50 * 2 – 45 / 5

จะไดผลลพั ธค อื 91 ซงึ่ ไดม าจากการนําเอา 2 ไปคณู 50 กอนหลังจากน้ันกเ็ อา 5 ไปหาร 45 เม่ือได
แลว ก็นําเอาผลลพั ธท่ไี ดไปลบออกจากผลลพั ธข องการคูณ 50 กับ 2 ซง่ึ มีคาเทา กับ 100 – 9

แตถ า เราตองการท่จี ะใหการประมวลผลอยูในรูปแบบอ่ืน ท่เี ราตอ งการเราก็ใชว งเลบ็ เปนตัวกาํ หนด
เชน ถาเราตอ งการที่จะใหก ารลบเกิดกอน ในประโยคท่เี ห็นกอนหนาน้ีเรากเ็ ขียนใหมเ ปน

50 * (2 – 45) / 5

ซึ่งมคี า เทาเทยี มกบั ประโยค

50 * -43 / 5

และมีคาเทากบั -430

เน่อื งจากวา การประมวลผลขอ มูลทเี่ ปน integer โดยเฉพาะการหารนนั้ เราจะไมม ีเศษเหลือใหท าํ การ
หารตอไปเหมือนที่เราเคยหารกันมา เชน ถาเราเอา 4 ไปหาร 9 เรากจ็ ะได 2.25 แตถ า เปนการหาร
ดว ย integer ใน Java แลวผลลัพธที่เราไดจากการหารนจ้ี ะเปน 2 เทา น้ัน เราจะไมไดเศษ เราจะได
แตสวน ลองดตู ัวอยางตอไปนี้

5/2=2
125 / 4 = 31
3/9=0
15 / 15 = 1

แตเราก็หาเศษไดดวยการใช operator % ดงั ท่ีไดแสดงในโปรแกรมตวั อยางกอนหนาน้ี หรอื ดงั
ตัวอยางการหาเศษตอ ไปนี้

5%2=1
125 % 4 = 1
3%9=3
15 % 15 = 0

โดยท่วั ไปเทา ทพี่ บเห็นและประสพมา ผูอานทีใ่ หมตอ การเขียนโปรแกรม มกั จะสบั สนในเรื่องของการ
หาเศษ หรอื การหาสวนของขอมูลท่ีเปน integer อยา งไรก็ตามเรอื่ งเหลานม้ี ักจะหายไปถา ไดท ดลอง
ทําอยางสมํ่าเสมอ สาํ หรับ Java น้ันการหาเศษสามารถท่ีจะทาํ ไดกับขอ มลู ที่เปน double หรือ float
ดวย แตใ นท่นี จ้ี ะทิ้งไวใหผ ูอา นไดท ดลองทําการตรวจสอบดเู อง (เนอื่ งจากวาผูเขียนเองยังมองไม
เห็นประโยชนข องการหาเศษจากขอมูลทเี่ ปน double หรอื float เลย)

ในการเขียนโปรแกรมนนั้ เราเก็บขอมูลไวใ นตวั แปร ดงั นั้นการประมวลผลก็ตอ งทาํ กับตวั แปรเหลาน้นั
เชน เราสามารถทีจ่ ะคาํ นวณหาคาของภาษมี ลู คา เพมิ่ (vat) จากตวั แปร price และ rate ถา ตวั แปร
ทั้งสองไดร ับการกําหนดคาเรยี บรอยแลว เชน

double price = 120.0, rate = 7.5;

35

เรม่ิ ตนการเขียนโปรแกรมดวย Java intro. to Java (FEU.faa)

double vat = price * rate;

ลองมาดูโปรแกรมตัวอยางการประมวลผลดว ยขอ มลู ทเ่ี ปน integer

1: /**
2: Integer calculation
3: */
4:
5: class IntegerCal {
6: public static void main(String[] args) {
7: //declares and initialize three variables
8: int studentNumber = 40;
9: int teacherNumber = 30;
10: int totalNumber = 0;
11:
12: totalNumber = studentNumber + teacherNumber;
13:
14: //display result
15: System.out.print(studentNumber + " students + " + teacherNumber);
16: System.out.println(" teachers = " + totalNumber + " people");
17:
18: System.out.println("30 + 45 = " + 30 + 45);
19: }
20: }

โปรแกรม Integer.java เปนการแสดงถึงการคํานวณหาคาของผลรวมของจํานวนนักศกึ ษา
(studentNumber)และครู (teacherNumber) จากประโยค

totalNumber = studentNumber + teacherNumber;

ซ่ึงขน้ั ตอนของการประมวลผล อาจพดู ไดค ราว ๆ คอื Java นาํ เอาคาท่ีเกบ็ ไวในตัวแปร
studentNumber และคาท่เี กบ็ ไวในตัวแปร teacherNumber มารวมกนั และนาํ เอาผลลัพธท ีไ่ ดไป
เกบ็ ไวในตัวแปร totalNumber ผา นทางเครื่องหมาย = (assignment operator) ลองดภู าพที่ 2-2

teacherNumber
studentNumber

40 + 30

totalNumber 70

ภาพที่ 2-2 การบวก integer สองตัว

ในการแสดงผลลัพธท ไ่ี ดจากการประมวลผลไปยังหนาจอนนั้ เราสงผานทาง System.out.print()
และ System.out.println() ประโยค

System.out.print(studentNumber + " students + " + teacherNumber);

จะใหผ ลลัพธค ือ คา ทเี่ ก็บไวในตวั แปร studentNumber ตามดวย string ทม่ี คี า เปน "student +"
ตามดวยคา ทเี่ กบ็ ไวใ นตัวแปร teacherNumber ในบรรทดั เดียวกัน หลงั จากน้ันประโยค

System.out.println(" teachers = " + totalNumber + " people");

36

บทท่ี 2: ขอ มลู ตัวแปร และการประมวลผล intro. to Java (FEU.faa)

ก็จะใหผ ลลัพธ คอื string ที่มคี าเปน " teachers = " ตามดว ยคา ทเี่ ก็บไวใ นตัวแปร totalNumber
ตามดว ย string ท่มี คี าเปน " people" ซึ่งเม่อื รวมแลว ทั้งหมดก็จะไดผ ลลัพธท ีแ่ สดงไปยงั หนาจอ
ดงั นี้ (หลังจากแสดงผลลพั ธ cursor จะไปอยใู นบรรทัดใหม)

40 students + 30 teachers = 70 people

คําวา "ตามดว ย" จากคําอธิบายดา นบนน้เี กดิ จากการประมวลผลของ Java กับเคร่อื งหมาย + ในการ
ใชป ระโยคของการแสดงผล (System.out) ขอ มลู ใด ๆ ที่อยูใ นเคร่ืองหมาย " " จะถูกสง ไปยัง
หนา จอ แตถาเปนตวั แปรหรือประโยคที่ตองมกี ารประมวลผลอีก Java จะทําการประมวลผลกอ น
เพ่ือใหไ ดค า สดุ ทายที่สามารถจะสงออกไปหนาจอได เชน

System.out.println("30 + 45 = " + (30 + 45));

ส่ิงทถ่ี ูกสง ออกไปกอนคอื "30 + 45 = " ตามดว ยคา ของการประมวลผลของประโยค (30 + 45) ซง่ึ
กค็ อื 75 ดงั นั้นผลลัพธท ่สี งไปยงั หนาจอคือ

30 + 45 = 75
วงเลบ็ ในประโยคของการบวก 30 กบั 45 ก็มีสวนสาํ คัญเพราะถา ไมมี Java กจ็ ะแสดงผลเปน

30 + 45 = 3045
การใสว งเล็บเปนการบอก Java ใหท าํ การคาํ นวณหาคาของประโยคนั้น ๆ ทัง้ นีเ้ ฉพาะในประโยคท่ใี ช
System.out เทานนั้ สวนการประมวลผลทอ่ี ่ืน ๆ ก็ทําตามเดมิ เหตุทีเ่ ปน เชน นก้ี เ็ พราะวา System.out
จะนําคา นั้น ๆ ทเี่ ปนอยไู ปแสดงถา ไมมีการคาํ นวณใด ๆ
สมมติวาเราตอ งทาํ การบวกคา ใดคาหนง่ึ ใหกบั ตวั แปร เราก็สามารถทจ่ี ะสรางประโยคไดเหมือนกบั ท่ี
เราเคยทาํ มากอนหนานี้ เชน total = total + value;
ถาเราลองเขียนภาพแทนประโยคดงั กลา ว เรากอ็ าจเขียนไดดังน้ี

value
total

total + value

ภาพที่ 2-3 การเพิ่มคาใหกับตัวแปรตัวเดิม

ประโยคทีเ่ หน็ ดา นบนนสี้ ามารถทจี่ ะเขียนอีกแบบได ดงั นคี้ อื

total += value;

เราใชเคร่อื งหมาย += ในการสรา งประโยคของเรา แตไดผลลพั ธเ ชน เดยี วกันกบั ประโยคกอ นหนานี้
และลดเวลาในการเขียนลง (ถึงแมวา จะไมมากก็ตาม) เชนเดียวกับการประมวลผลดว ย operator ตัว
อ่ืน ๆ เราก็สามารถจะใชว ธิ ีเดยี วกนั น้ีได ดงั ทไ่ี ดส รปุ ไวใ น ตาราง 2.5

37

เรม่ิ ตน การเขียนโปรแกรมดว ย Java

ตาราง 2.5 การใช operator ตา ง ๆ รวมกับการกําหนดคา intro. to Java (FEU.faa)

ประโยคตัวอยาง ประโยคทไ่ี ดผ ลลพั ธเ หมอื นกนั

sum = sum + count; sum += count;

sum = sum - count; sum -= count;

sum = sum * count; sum *= count;

sum = sum / count; sum /= count;

sum = sum % count; sum %= count;

การกาํ หนดคาแบบนไ้ี มจ ําเปนที่จะตองทํากับตัวแปรเทา น้ัน เราสามารถที่จะทํากบั คาคงทีอ่ ่ืน ๆ ได
เชน

total += 4;
sum += 1;

ยังมี operator ทเ่ี ราสามารถใชไดโ ดยไมต องเสยี เวลาในการเขียนมากมายนกั เชน การเพ่ิม หรือ ลด
ทีละหนงึ่ คา ดังประโยคตัวอยาง

count = count + 1;
value -= 1;

ทั้งสองประโยคทเี่ ห็นดา นบนทาํ การเพ่มิ คาและลดคา ทีละหน่งึ คา ตามลําดบั เราสามารถท่ีจะเขยี น
ใหมดว ยการใช operator ++ และ operator -- ไดดังนี้ คอื

count++;
value--;

จะเห็นวา ถาเราตองการเพม่ิ คา เพยี งแคห น่ึงคา เราก็ใชเครือ่ งหมาย ++ ตามหลงั ตัวแปรนน้ั
เชนเดยี วกนั ถา เราตองการลดคา ลงหน่ึงคา เราก็ใชเครอ่ื งหมาย –- ตามหลังตัวแปรนน้ั เราเรียกการ
เขยี นแบบน้ีวา การเขียนแบบ postfix (postfix notation) ซึง่ เปน การใช operator ตามหลงั ตวั แปร
และ Java ยอมใหม ีการเพิม่ หรือลดคา ไดเ พยี งแคหนงึ่ คาเทานัน้ ถา เราตอ งการเพิ่มหรอื ลดคามากกวา
หนง่ึ คา เราตองใชวิธีสองวิธีทไี่ ดแ สดงการใชก อนหนานี้ เชน ถา ตอ งการเพมิ่ ทีละสอง เราก็เขียนเปน

total += 2;

และถา เราตอ งการลดทีละสาม เรากเ็ ขยี นเปน

total -= 3;

Java ยงั มี Operator อีกตัวหนงึ่ ที่เราสามารถเลอื กใช ในการประมวลผลถา เราคํานงึ ถงึ ขน้ั ตอนของ
การประมวลผล วา ควรจะทําอะไรกอ น อะไรหลงั ดงั ประโยคตวั อยา งตอ ไปน้ี

int count = 8, value = 5;
count = count + value++;

ถา มองดเู ผนิ ๆ เราก็อาจบอกวาประโยคนเี้ ปน การบวกคา ของตวั แปร value เขากบั ตวั แปร count
พรอมกับการเพิ่มคาใหก บั ตัวแปร value อกี หนึ่งคา แตเรารูหรอื ไมว า อะไรไดร บั การประมวลผลกอน
count + value กอน หรอื value++ กอ น และผลลัพธท ไี่ ดจ ากการบวกคืออะไร

จากประโยคดา นบน Java จะนําเอาคาของ value มาบวกเขากับคาของ count กอน หลังจากนน้ั จงึ
เพ่ิมคา ใหกบั ตัวแปร value อีหนึง่ คา ดงั นัน้ ถา เรา execute ประโยค count = count + value++ เรา
กจ็ ะไดผ ลลพั ธเปน 13 และคาของ value หลงั จากการบวกจะเปน 6 แตถา เราเปลี่ยนประโยคใหเ ปน
ดงั นี้

count = count + ++value;

เราจะไดผลลพั ธจากการบวกเปน 14 (ทาํ ไม)

38

บทที่ 2: ขอมลู ตัวแปร และการประมวลผล intro. to Java (FEU.faa)

เน่อื งจากวาเราใชเคร่อื งหมาย ++ นาํ หนาตัวแปร ดงั น้ัน Java จึงทําการเพ่ิมคาใหก ับตัวแปร value
กอน หลังจากนั้นจงึ นาํ คา ทีไ่ ดน ี้ไปบวกเขา กับคา ของตัวแปร count ผลลพั ธท่ีไดจงึ เปน 14 ดังทีเ่ ห็น
เราเรียกการเขียนแบบน้วี าการเขยี นแบบ prefix (prefix notation)
ขน้ึ อยกู ับตาํ แหนง ที่ใช prefix หรอื postfix ในประโยค บางครัง้ การประมวลผลจาก Java อาจได
ผลลพั ธท ่เี หมือนกนั เราจะกลับมาพูดถงึ กรณดี ังกลา วในเร่ืองของการทาํ งานแบบวน หรอื loop
(repetition)
ลองมาดตู วั อยา งการใช prefix และ postfix กันอกี สกั หนอย

int count = 10, value = 5;
count--;
value++;
value = ++count + ++value;

ถาเรา execute ประโยค value = ++count + --value; เราก็จะไดผ ลลัพธ คือ value มีคาเปน 17
เพราะกอนหนาน้ัน count มคี า เปน 9 และ value มคี าเปน 6 (จาก count—และ value++) แตไ ดรบั
การเพ่มิ ใหอ กี หนง่ึ คากอ นการบวกในประโยคสุดทาย
ถาหากวาเราตอ งการให code ทเ่ี ขียนนัน้ อานไดงายขน้ึ เราก็อาจใชว งเล็บเปนตวั ชว ยกไ็ ด เชน

value = (++count) + (++value);

หรืออาจเขยี นใหด ูแลว เวียนหวั แบบน้ี

value = (count += 1) + (value += 1);

หรือแบบน้ี

value = (count = count + 1) + (value = value + 1);

สว นประโยคตอ ไปนีจ้ ะใหผ ลลัพธต างจากตัวอยา งดานบน (ทาํ ไม?)

value = (count++) + (value++);

ถาเราลองวเิ คราะหป ระโยคดานบนนี้ ดวยคาของ count = 10 และคา ของ value = 5 และตาม
ขอ กาํ หนดการใชงานของ postfix ++ เราก็ตองสรปุ วา Java จะนาํ เอาคา ของ count ซ่งึ มคี า เทากบั
10 บวกเขากับคาของ value ซึง่ มีคา เทา กับ 5 เมอ่ื ไดแลว กน็ ําผลลพั ธท ีไ่ ดไปเกบ็ ไวในตัวแปร value
ดังนัน้ value จึงมคี า เทา กับ 15 หลงั จากนัน้ กจ็ ะเพ่มิ คา ใหก บั count และ value อีกหน่ึงคา ซงึ่ ทําให
count มคี าเทากับ 11 และ value มคี าเทา กบั 16
แตเม่อื ทดลอง run ดูแลวผลลพั ธทไ่ี ดกลับเปน value = 15 และ count = 11 ทาํ ไม? เพือ่ ใหเ กดิ
ความกระจางเราก็ทดลองเขยี นประโยคตรวจสอบใหม คอื

value = 5;
value = value++;

และเมอ่ื run ดูเราก็ไดผลลพั ธเปน value = 5 ทําใหเราคอนขางจะมัน่ ใจวา Java ไมยอมให postfix
operator ++ เพิ่มคา ใหก ับตัวแปรเดิมทไี่ ดร บั การกาํ หนดคา ในประโยคเดียวกนั แตเ พอ่ื ใหแ นใจขน้ึ
อีกเราก็ทดลอง run ดว ยประโยค

int sum = value++;

เราไดผลลัพธเ ปน sum มคี า เทากับ 5 และ value มคี า เทา กับ 6 ดังน้ันเราจึงมัน่ ใจวา postfix
operator ++ ไมย อมใหมกี ารเพมิ่ คาใหกับตวั แปรตวั เดียวกันกบั ที่ใชในการกําหนดคาในประโยค
เดยี วกนั (ดังทีไ่ ดก ลาวไว แตถ า เราตองการท่จี ะเพิ่มคาใหกบั ตวั แปรเดิมจรงิ ๆ เราก็ทําไดด ว ยการ
เปล่ียนประโยคใหเ ปน value = value + 1 แทน)
การเขียนโปรแกรมทดี่ ีนั้นไมควรเขียนใหอา นยาก เชน ตัวอยา งของการใช ++ ที่ไดก ลา วถึงกอนหนา
นี้ ถา การเขยี นนัน้ ไดผ ลลัพธดงั ทีเ่ ราตอ งการ ถงึ แมวาจะเขยี นดวยประโยคหลาย ๆ ประโยค กย็ งั

39

เรมิ่ ตนการเขยี นโปรแกรมดว ย Java intro. to Java (FEU.faa)

ดกี วา ที่เขียนดว ยจาํ นวนประโยคท่สี นั้ แตอ านไดย ากกวา ตัวอยา งตอไปน้เี ปน การใช operator ++
และ operator – ในรปู แบบตาง ๆ

1: /**
2: Shows increment operators
3: */
4: class Increments {
5: public static void main(String[] args) {
6: int value = 25, number = 25;
7:
8: System.out.println("value is " + value);
9: System.out.println("number is " + number);
10: --value;
11: number++;
12: System.out.println("value is " + value);
13: System.out.println("number is " + number);
14: value = value + --number;
15: System.out.println("value is " + value);
16: System.out.println("number is " + number);
17: number = number - value++;
18: System.out.println("value is " + value);
19: System.out.println("number is " + number);
20: number--;
21: value++;
22: System.out.println("value is " + value);
23: System.out.println("number is " + number);
24: value = --value;
25: number = number++;
26: System.out.println("value is " + value);
27: System.out.println("number is " + number);
28: }
29: }

ผลลัพธท ไี่ ดจ ากการ run

value is 25
number is 25
value is 24
number is 26
value is 49
number is 25
value is 50
number is -24
value is 51
number is -25
value is 50
number is -25

ผูอ า นควรทดสอบการใช operator increment ทงั้ สอง (++ และ --) ในประโยคสมมตติ า ง ๆ เพ่อื ให
เกิดความเขา ใจในการใช operator ทงั้ สองไดด ยี ่งิ ขน้ึ ผูอา นควรพงึ ระลกึ วาขอ แตกตางระหวา ง
operator ทงั้ สองนัน้ จะเกดิ ข้ึนเมื่อไปปรากฏอยใู น expression เชนทเี่ ราไดแสดงใหดจู ากตวั อยาง
หลาย ๆ ตวั อยา งกอ นหนา น้ี

แตผ ูเ ขยี นไมข อแนะนาํ ใหใช operator ทง้ั สองเพราะจะทําใหเกิดความลาํ บากในการทจี่ ะเขาใจ
โดยเฉพาะผูอ่นื ที่นาํ เอา code ของเราไปใชห รอื นําไปปรบั ปรุง อยา งไรก็ตาม การใชท ี่เหมาะสมก็
ยงั คงมีอยูไ ด

2.7.2 การประมวลผลดว ย integer ขนาดเลก็ (short และ byte)

ในการประมวลผลดวยขอ มูลทเี่ ปน byte หรือ short นน้ั Java จะทาํ การประมวลผลเชน เดียวกันกบั
การประมวลผลดว ยขอมลู ท่ีเปน int และผลลัพธข องการประมวลผลขอมลู ที่เปน short หรอื byte นั้น
จะถูกเก็บอยูในรูปแบบของขอ มูลท่เี ปน int ดงั ตวั อยา งตอ ไปน้ี (ByteShort.java)

1: /**
2: Shows byte and short integer calculation
3: */
4: class ByteShort {

40

บทที่ 2: ขอมูล ตวั แปร และการประมวลผล

5: public static void main(String[] args) { intro. to Java (FEU.faa)
short numScooters = 10;
6: short numChoppers = 5;
7: short total = 0;

8: total = numScooters + numChoppers;
9:
10: System.out.println("Number of scooters is " + numScooters);
System.out.println("Number of choppers is " + numChoppers);
11: System.out.println("Total number of bikes is " + total);
12: }
13:

14:
15:

16: }

เม่อื ได compile แลว Java จะฟอ งวามี error เกดิ ขึ้น

ByteShort.java:10: possible loss of precision
found : int
required: short

total = numScooters + numChoppers;
^

1 error

เนือ่ งจากวา ผลลัพธของการบวกจะตอ งเก็บเปน integer ท่ีมีขนาดเทากับ 64 bit แตต วั แปร total
สามารถเกบ็ ขอ มลู ไดส งู สุดเทากบั 16 bit ดังน้นั compiler จึงฟองทันที วิธกี ารแกไขกอ็ าจจะตอ ง
เปล่ียนตวั แปรทงั้ สามใหเปน int หรือไมก ็ใชวิธีการเปลย่ี นชนดิ ของขอ มลู ที่เรียกวา casting

2.7.3 การเปลี่ยนแปลงชนดิ ของขอ มูล (casting)

ในการเปล่ียนชนิดขอ มลู น้นั เราจําเปนที่จะตอ งคํานึงถงึ การจัดเกบ็ ขอ มลู วาเราจะตองใชข อ มูลชนดิ
ไหนในการจัดเก็บ การประกาศตัวแปรกต็ องทําดว ยความระมดั ระวงั เนอ่ื งจากวา การ cast นน้ั ถา เรา
cast ขอมูลท่ีมขี นาดใหญไ ปสูขอ มูลท่ีมีขนาดเล็ก เราจะสญู เสียคาความเปนจรงิ ของขอ มลู นน้ั เรามา
ทําการแกไ ขโปรแกรม ByteShort.java เพ่อื ให Java ยอมใหก าร compile เปนไปอยางถูกตอง

วธิ ีการกไ็ มยากเพยี งแตเ ปลีย่ นประโยค total = numScooters + numChoppers; ใหเ ปน

total = (short)(numScooters + numChoppers);

เทา นี้ Java ก็ยอมใหเรา compile และเม่ือเราทดลอง run ดูก็ไดผ ลลัพธดงั ท่คี าดไว คือ

Number of scooters is 10
Number of choppers is 5

Total number of bikes is 15

ทีน้เี ราลองมาดกู นั วา ถาเราเปลยี่ นคา ของ numScooters ใหเ ปน 32767 ดงั ท่เี หน็ ดา นลา ง ผลลพั ธท ่ี
ไดในการ compile และ run โปรแกรมของเราจะเปน อยา งไร

short numScooters = 32767; //คาสงู สดุ ทีเ่ ปน ไปได
short numChoppers = 5;

ผลลัพธท ี่ได คอื

Number of scooters is 32767
Number of choppers is 5
Total number of bikes is -32764

จะเหน็ วาคาของ total เปน -32764 ซง่ึ เปนคาท่ีไมถกู ตอง ซึง่ ถาบวกกนั แลวคาทไ่ี ดต อ งเปน 32772
ทาํ ไม?

เน่อื งจากวาตวั แปรทั้งสามตวั มชี นดิ เปน short และสามารถเก็บขอมูลไดส งู สดุ เพยี งแค 32767 ดังนน้ั
การนาํ เอาผลรวมทมี่ ีคา เกนิ กวาคาสงู สุดท่เี ปนไปไดม าเกบ็ ไวใ นตัวแปร total จงึ ไมสามารถทําไดแ ต
Java กจ็ ะนาํ เอาคา อ่ืนทีไ่ ดจ ากการประมวลผล (ทถี่ ูกตองตามหลักการแตมีคาความคลาดเคล่ือนของ
การประมวลผล – จํานวน bit ทใี่ ชในการคาํ นวณหายไปครง่ึ หน่งึ จาก 64 bit เหลือเพียง 32 bit) มา
ใสไ วให ผูเ ขยี นโปรแกรมจะตองทําความเขา ใจเกยี่ วกับชนิดของขอ งมูล และการประมวลผลตามชนดิ

41

เร่ิมตนการเขียนโปรแกรมดวย Java intro. to Java (FEU.faa)

น้ัน ๆ ของขอ มูล ถา หากวาหลกี เล่ยี งได ผูเขียนโปรแกรมก็ควรหลีกเล่ยี งการใช cast นอกเสียจากวา
จําเปนตองใชจ รงิ ๆ เทา นน้ั

เรามาดกู าร cast อน่ื ๆ จากโปรแกรม Casting.java

1: /**
2: Changing type of data
3: */
4:
5: class Casting {
6: public static void main(String[] args) {
7: byte byteVar = 127;
8: short shortVar = 32767;
9: long longVar = 100000;
10: int intVar = 300000;
11:
12: System.out.println("byteVar is " + byteVar);
13: System.out.println("shortVar is " + shortVar);
14: System.out.println("longVar is " + longVar);
15: System.out.println("intVar is " + intVar);
16:
17: byteVar = (byte)shortVar;
18: shortVar = (short)longVar;
19: longVar = (int)intVar * (int)longVar;
20: intVar = (short)intVar * (short)intVar;
21:
22: System.out.println("byteVar is " + byteVar);
23: System.out.println("shortVar is " + shortVar);
24: System.out.println("longVar is " + longVar);
25: System.out.println("intVar is " + intVar);
26: }
27: }

ผลลพั ธท ่ีไดจ ากการ run คือ

byteVar is 127
shortVar is 32767
longVar is 100000
intVar is 300000

byteVar is -1
shortVar is -31072
longVar is -64771072
intVar is 766182400

ในการประมวลผลดวยการใชขอมูลท่ีมชี นิดเปน long นั้น (บังคบั ใหเปน long ดวยการใส L ดานหลงั
คา ทก่ี ําหนดใหก บั ตวั แปรนั้น ๆ) ขอ มูลชนิดอ่ืนจะถูกเปล่ยี นใหเปน long กอ นการประมวลผล เชน

long value = 125;
long price = 200L;
int total = 0;

total = value * price;

กอนการประมวลผลคาของตวั แปร value จะถูกเปล่ียนใหเปน long แลว จงึ นาํ มาคณู กับตัวแปร price
เพราะฉะน้นั ในการประมวลผลขอ มูลทเ่ี ปน integer นนั้ ขอควรคาํ นึงถึงกค็ ือ

o การประมวลผลกับตัวแปรท่ปี ระกาศเปน long ทมี่ กี ารกาํ หนดคาดวยตัว L จะเปนการ
ประมวลผลดว ยการใชจาํ นวน bit เทา กับ 64 bit

o การประมวลผลกับตัวแปรทีป่ ระกาศเปน int จะเปนการประมวลผลดว ยการใชจ ํานวน bit
เทา กบั 32 bit

ปญหาของการประมวลผลดวยขอ มูลทีม่ ีชนดิ เปน integer

o ถาเราหารตัวแปรที่มีชนดิ เปน int ดว ย 0 เราไมส ามารถหาคาํ ตอบได เพราะฉะนน้ั Java จะ
ทาํ การฟอ งดว ย error แตเ ราก็สามารถทจี่ ะตรวจสอบและแกไขไดด วยการใช exception

42

บทท่ี 2: ขอมูล ตวั แปร และการประมวลผล intro. to Java (FEU.faa)

ซึ่งเปนวิธดี ักจับ error ที่ Java เอ้ืออาํ นวยใหผเู ขียนโปรแกรมไดทําการเอง เราจะพูดถึง
exception ในโอกาสตอ ไป
o การประมวลผลดวยคาที่เกนิ ขดี จํากดั ของตัวแปรจะทาํ ใหไ ดผลลัพธท คี่ ลาดเคลอื่ น
o การประมวลผลดว ย % ทีม่ ีคาของ 0 อยทู างขวากท็ าํ ใหเกิด error เหมอื นกบั การหารดว ย 0

2.8 การประมวลผลดวยตัวแปรที่มีจุดทศนิยม (Floating Point Calculations)

การประมวลผลของขอ มูลทเี่ ปนเลขทศนยิ มนั้นก็คลายกันกบั การประมวลผลดว ยขอมูลทีเ่ ปน integer
การใช operator ตาง ๆ กเ็ หมอื นกนั คือ + - * / ลองมาดตู วั อยา งกัน

1: /**
2: Calculating with floating-point numbers
3: */
4: class FloatingPoint {
5: public static void main(String[] args) {
6: double weeklyPay = 1075 * 5;//1075 per day
7: double extras = 1580;
8: final double TAX_RATE = 8.5;//tax rate in percent
9:
10: //calculate tax and income
11: double tax = (weeklyPay + extras) * TAX_RATE / 100;
12: double totalIncome = (weeklyPay + extras) - tax;
13:
14: System.out.println("Tax = " + tax);
15: System.out.println("Total income = " + totalIncome);
16: }
17: }

โปรแกรม FloatingPoint.java เปน การคาํ นวณหาภาษี และรายไดตอหน่ึงอาทติ ย โดยเราสมมติให
รายไดตอ วันเทากับ 1075 บาท และรายไดพ เิ ศษเทา กบั 1580 บาท อดั ตราภาษเี ทา กับ 8.5% เมอื่
เรา execute โปรแกรมเราก็จะไดผ ลลัพธด งั นี้

Tax = 591.175
Total income = 6363.825

ในการคาํ นวณหาภาษีนั้นเราจาํ เปน ทจ่ี ะตองใชว งเลบ็ ในประโยค

double tax = (weeklyPay + extras) * TAX_RATE / 100;

เนอื่ งจากวาเราตองการใหก ารบวกทํากอนการคณู และการหาร ถา ไมเชนน้ันแลวเราจะไมไดคา รายได
โดยรวมทเี่ ปน จรงิ ถา เราสังเกตใหด ีผลลพั ธท ไี่ ดจะมีเลขหลงั จดุ ทศนยิ มอยูสามตัว เราทําใหเปน สอง
ตัวดังทีใ่ ชก ันอยทู ่ัวไปไดม ยั้ ? คําตอบกค็ ือ ได ดว ยการเพมิ่ code เขา ไปในโปรแกรมดงั น้ี

1: /**
2: Calculating floating-point with formatted output
3: */
4:
5: import java.text.*; //for NumberFormat
6:
7: class FloatingPoint2 {
8: public static void main(String[] args) {
9: double weeklyPay = 1075 * 5;//1075 per day
10: double extras = 1580;
11: final double TAX_RATE = 8.5;//tax rate in percent
12:
13: //set format output
14: NumberFormat form = NumberFormat.getNumberInstance();
15: form.setMaximumFractionDigits(2);
16:
17: //calculate tax and income
18: double tax = (weeklyPay + extras) * TAX_RATE / 100;
19: double totalIncome = (weeklyPay + extras) - tax;
20:
21: System.out.println("Tax = " + form.format(tax));
22: System.out.println("Total income = " +

form.format(totalIncome));
23: }

43

เริม่ ตนการเขียนโปรแกรมดวย Java intro. to Java (FEU.faa)

24: }

เราเพิ่มประโยค

NumberFormat form = NumberFormat.getNumberInstance();
form.setMaximumFractionDigits(2);

และเปล่ียนการแสดงผลลัพธดว ยการใช form.format(tax) และ form.format(totalIncome)
เพ่อื ใหผลลพั ธที่ออกมาเปน

Tax = 591.18
Total income = 6,363.82

จะเห็นวา 591.175 จะถกู ปด ใหเ ปน 591.18 และ 6363.825 ถูกปดใหเปน 6363.82 โดยทีค่ าของ
totalIncome มี , (comma) เปนตัวบอกถึงจาํ นวนของหลกั รอยดว ย

ในการใช method ทัง้ getNumbereInstance() และ setMaximumFractionDigits() น้ันเราจาํ เปน
ท่จี ะตอง import class NumberFormat เขา สโู ปรแกรมของเรา ถาไมแ ลว เราจะไมสามารถใช
method เหลานี้ได

ยงั มี method อ่ืนใน class DecimalFormat ท่เี ราสามารถเรียกใชในการ format ผลลัพธที่เปน จุด
ทศนิยมได เชนถาเราไมต อ งการ , (comma) เปน ตวั แบงหลกั เราจะทําอยา งไร? ลองดตู วั อยางน้ีดู
(FloatingPoint3.java)

1: /**
2: Calculating floating-point with formatted output
3: */
4:
5: import java.text.*; //for DecimalFormat
6:
7: class FloatingPoint3 {
8: public static void main(String[] args) {
9: double weeklyPay = 1075 * 5;//1075 per day
10: double extras = 1580;
11: final double TAX_RATE = 8.5;//tax rate in percent
12:
13: //set format output
14: DecimalFormat form = new DecimalFormat("#.00");
15:
16: //calculate tax and income
17: double tax = (weeklyPay + extras) * TAX_RATE / 100;
18: double totalIncome = (weeklyPay + extras) - tax;
19:
20: System.out.println("Tax = " + form.format(tax));
21: System.out.println("Total income = " + form.format(totalIncome));
22: }
23: }

ผลลพั ธท ่ไี ดค อื

Tax = 591.18
Total income = 6363.82

เราเพยี งแตเรียกใช class DecimalFormat แทน NumberFormat และเปลีย่ นการกาํ หนด format
ใหเปน

DecimalFormat form = new DecimalFormat("#.00);

เราก็จะไดผ ลลพั ธท่ีมเี ลขหลงั จุดทศนยิ มอยูสองตวั และไมม ี , (comma) เปน ตัวแบงหลกั ยังมีวธิ กี าร
กาํ หนดรูปแบบของการแสดงผลลพั ธอีกหลายแบบ หนง่ึ ในน้นั มีมากับ Java 1.5 น่นั กค็ ือการใช
printf() เปนตวั แสดงผล

44

บทที่ 2: ขอมูล ตัวแปร และการประมวลผล intro. to Java (FEU.faa)

2.8.1 การใช printf() ในการแสดงผล

ใน Java 1.5 เราสามารถเรียกใช printf() เพอ่ื แสดงผลใหเ ราตามโครงสรางท่ีเราตอ งการไดอยา ง
งาย ๆ ดงั โปรแกรมตัวอยา งน้ี

1: /**
2: Using printf() for formatted output
3: */
4:
5: class UsingPrintf {
6: public static void main(String[] args) {
7: double weeklyPay = 1075 * 5;//1075 per day
8: double extras = 1580;
9: final double TAX_RATE = 8.5;//tax rate in percent
10: String total = "Total income = ";
11:
12: //calculate tax and income
13: double tax = (weeklyPay + extras) * TAX_RATE / 100;
14: double totalIncome = (weeklyPay + extras) - tax;
15:
16: System.out.printf("Tax = %.2f%n", tax);
17: System.out.printf("%s %.2f", total, totalIncome);
18: }
19: }

การแสดงผลของการประมวลในบรรทดั ท่ี 16 จากโปรแกรมตัวอยา งนี้ ใช printf() แสดงผลลัพธโ ดย
กําหนดใหก ารแสดงผลเปนเลขท่มี ีจดุ ทศนยิ มสองจดุ ดว ยการใชสญั ลกั ษณ '%.2f' ซึง่ ตวั กําหนดใหม ี
ทศนิยมสองตําแหนงคอื ตวั เลขท่ีอยูหลงั จุด ตามดวยตวั อักษร 'f' สว นตวั %n หมายถงึ การเล่ือน
บรรทดั ผอู า นจะสังเกตวา เราจะตองกาํ หนดรูปแบบท่ตี องการภายในเครือ่ งหมาย " " สวนตวั แปรที่
เกบ็ คา ของขอมลู ท่ตี องการแสดงผลนน้ั จะอยภู ายนอกและตองตามหลงั เคร่ืองหมาย ',' เสมอ

ในบรรทัดที่ 17 เราแสดงผลขอ มลู สองตวั ตัวแรกมชี นดิ เปน String สว นตวั ท่สี องเปน เลขทมี่ ีจุด
ทศนยิ มเหมอื นกับที่แสดงในบรรทดั ที่ 16 ผอู านจะตองใช %s ในการแสดงผลขอ มลู ทีเ่ ปน String
และถา มกี ารแสดงผลขอ มลู มากกวา หน่งึ ตัวเราก็ใชเ ครื่องหมาย ',' เปน ตวั แบงเสมอ และจํานวนของ
สญั ลกั ษณแสดงผลภายในเครอ่ื งหมาย " " ตองมีจาํ นวนเทากับตวั แปรที่อยภู ายนอก

2.8.1.1 การใชเ คร่ืองหมายอื่น ๆ (flag) ใน printf()

โปรแกรมตัวอยา งตอไปนแ้ี สดงถึงการควบคุมหนา ตาของสิ่งท่เี ราตอ งการสงไปยงั ชองทางออก (เชน
หนา จอ เปน ตน ) ซึง่ มีเครอ่ื งหมายทนี่ าสนใจดงั น้ี

1. เครื่องหมายลบ (-)
2. เครื่องหมายบวก (+)
3. ศนู ย (0)
4. เครอ่ื งหมาย comma (,)
5. เครอื่ งหมายวงเลบ็ เปด ( สําหรับการแทนคา ท่ีเปน ลบ

1: /**
2: Using flags in printf()
3: */
4:
5: class FlagInPrintf {
6: public static void main(String[] args) {
7:
8: System.out.println("column:\t01234567890123456789");
9: System.out.printf("\t%+d %d %n", 1234, 1234);
10: System.out.printf("\t%-10.2f%n", 1234.567);
11: System.out.printf("\t%+09d%n", 493);
12: System.out.printf("\t%09d%n", 493);
13: System.out.printf("\t%,d%n", 123456);
14: System.out.printf("\t%,.2f%n", 1234.567);
15: System.out.printf("\t%(d%n", -1234);
16: System.out.printf("\t%(.1e%n", -493.0);
17: }
18: }

45

เรมิ่ ตนการเขียนโปรแกรมดวย Java

ผลลพั ธท่เี ราไดค อื intro. to Java (FEU.faa)

column: 01234567890123456789
+1234 1234

1234.57
+00000493

000000493
123,456
1,234.57

(1234)

(4.9e+02)

ผอู า นควรศึกษาถึงผลลพั ธที่ไดจ ากโปรแกรมตวั อยางนเ้ี พือ่ ใหเ กิดความเขา ใจใหม ากยิ่งข้ึน (column
ทีอ่ ยูด านบนของผลลพั ธมไี วเ พือ่ เปนการอางองิ ถึงตาํ แหนง ที่ผลลัพธควรจะเปนเม่ือมกี ารเรียกใช flag
ตาง ๆ)

2.8.2 การใช format() แทน printf()

เราสามารถท่จี ะใช format() แทนการแสดงผลดว ย printf() โดยไมตอ งมกี ารเปล่ยี นแปลง code
ของเราแตอ ยา งใด เชน ถา เราเปล่ียนชดุ คาํ สัง่ ในบรรทดั ท่ี 16 และ 17 ของโปรแกรม UsingPrintf ให
เปน

System.out.format("Tax = %.2f%n", tax);
System.out.format("%s %.2f", total, totalIncome);

ผลลพั ธของการประมวลผลทเ่ี ราไดก เ็ หมือนกนั คอื

Tax = 591.18
Total income = 6363.83

ผูอานกเ็ ลือกใชตามแตท ี่ตนเองชอบกแ็ ลว กัน ยังมีสญั ลกั ษณอ ีกหลายตัวทีเ่ ราสามารถเรียกใชไ ด ซึ่ง
เราไดนาํ มาแสดงไวในตารางที่ 2.6 น้ี

ตาราง 2.6 การใชสญั ลกั ษณแ สดงผล

สญั ลักษณแสดงผล ความหมาย

%% แสดง % ใน String

%a, %A แสดงคา เลขทมี่ จี ุดทศนิยม

%b, %B แสดงคา ทีเ่ ปน จรงิ หรือเท็จ

%c, %C แสดงคา ของตวั อักษรหนึ่งตัว

%d แสดงคาของตวั เลขที่ไมมจี ุดทศนิยม

%e, %E แสดงคาเลขทมี่ จี ุดทศนิยมในรูปแบบของ exponential notation

%f แสดงคาเลขทมี่ จี ุดทศนยิ ม

%g, %G แสดงคาเลขทมี่ จี ุดทศนยิ มสงู สดุ หกตาํ แหนง

%h, %H แสดงคาเลขในฐานสิบหก (hash code)

%n เลอ่ื นบรรทดั ใหมหนึง่ บรรทัด

%o แสดงคา เลขในฐานแปด

%s, %S แสดงคาของ String

%t, %T แสดงคา ของเวลา

%x, %X แสดงคา ตัวเลขในฐานสิบหก

2.8.3 การแสดงผลท่ไี มตอ งใชค ําวา System นาํ หนา

หลาย ๆ คร้ังทีเ่ ราตอ งการแสดงผลลพั ธไ ปยงั หนา จอ แตก็ตอ งมาเสียเวลาในการพิมพค าํ วา System
กอ นหนาคําวา out.println() หรอื out.printf() ดงั ทเ่ี ราไดเ หน็ จากตวั อยา งตางๆ ท่ผี านมา ใน Java
1.5 เราสามารถทจ่ี ะลดการเขียนลงดวยการใชก าร import ท่ีเรียกวา static import แทนการ import
ท่เี ราไดเ คยทาํ มา ดูโปรแกรมตวั อยางตอ ไปนี้

1: /**
2: Display output without 'System'

46