สารบัญ

บทที่ 1 ความรูเบื้องตนของภาษาจาวา .........................................................................1

1.1 ระบบคอมพิวเตอร ..............................................................................1
1.2 ภาษาคอมพิวเตอร ..............................................................................2
1.3 ตัวแปลภาษา ......................................................................................5
1.4 หลักการของโปรแกรมเชิงออปเจ็ค.......................................................7
1.5 ประวัติภาษาจาวา...............................................................................8
1.6 เทคโนโลยีจาวา ..................................................................................9
1.6.1 Java Virtual Machine.................................................................10
1.6.2 Java Runtime Environment.......................................................12
1.6.3 Java 2 Software Development Kit ............................................13
1.6.4 จุดเดนของภาษาจาวา .................................................................14
1.7 แพลตฟอรมของเทคโนโลยีจาวา........................................................15
1.7.1 Java 2 Platform, Standard Edition............................................17
1.7.2 Java 2 Platform, Enterprise Edition..........................................18
1.7.3 Java 2 Platform, Micro Edition..................................................19
1.8 โปรแกรมภาษาจาวา.........................................................................20
1.8.1 การสรางโปรแกรมจาวาประยุกต..................................................20
1.8.2 การสรางโปรแกรมจาวาแอปเพล็ต ...............................................22
1.9 คูมือ JAVA API ..................................................................................24
สรุปเนื้อหาของบท..........................................................................................27

บทที่ 2 พื้นฐานโปรแกรมภาษาจาวา ...........................................................................29

2.1 ไวยากรณระดับของคํา ......................................................................29
2.1.1 คอมเม็นต ...................................................................................29
2.1.2 Identifier.....................................................................................30
2.1.3 คียเวิรด .......................................................................................32
2.1.4 สัญลักษณแยกคํา ........................................................................33

Java Programming i
 2.1.5 ชองวาง.......................................................................................33
2.1.6 ขอมูลคาคงที่ ...............................................................................34
2.2 ชนิดขอมูลแบบพื้นฐาน .....................................................................34
2.2.1 ชนิดขอมูลตรรกะ.........................................................................35
2.2.2 ชนิดขอมูลตัวอักขระ....................................................................36
2.2.3 ชนิดขอมูลตัวเลขจํานวนเต็ม ........................................................37
2.2.4 ชนิดขอมูลตัวเลขทศนิยม.............................................................38
2.3 ตัวแปรและคาคงที่ ............................................................................39
2.3.1 คําสั่งกําหนดคา ...........................................................................40
2.3.2 คาคงที่ ........................................................................................42
2.3.3 ขอบเขตของตัวแปรและคาคงที่ ....................................................44
2.4 ตัวดําเนินการ....................................................................................47
2.4.1 ตัวดําเนินการทางคณิตศาสตร .....................................................47
2.4.2 ตัวดําเนินการแบบสัมพันธ ...........................................................50
2.4.3 ตัวดําเนินการทางตรรกศาสตร .....................................................52
2.4.4 ตัวดําเนินการแบบบิต ..................................................................54
2.4.5 ลําดับความสําคัญของตัวดําเนินการ.............................................56
2.5 การแปลงชนิดขอมูล..........................................................................57
2.5.1 การแปลงขอมูลในคําสั่งกําหนดคา ...............................................58
2.5.2 Typecasting ...............................................................................60
2.6 ชนิดขอมูลแบบอางอิง .......................................................................61
2.6.1 คลาส String ...........................................................................63
2.6.2 คลาส Math ..............................................................................66
2.7 คําสั่งอินพุตและเอาทพุต ...................................................................67
2.7.1 System.out.println() ...................................................68
2.7.2 การรับขอมูลเขามาทาง Command Line......................................69
สรุปเนื้อหาของบท..........................................................................................70

บทที่ 3 โครงสรางควบคุม .............................................................................................73

3.1 คําสั่งโครงสรางควบคุม .....................................................................73
3.2 โครงสรางแบบเลือกทํา ......................................................................74

ii คณะเทคโนโลยีสารสนเทศ สถาบันเทคโนโลยีพระจอมเกลาเจาคุณทหารลาดกระบัง
 3.2.1 คําสั่ง if.....................................................................................74
3.2.2 คําสั่ง if..else ......................................................................76
3.2.3 คําสั่ง if แบบซอน.....................................................................79
3.2.4 คําสั่ง switch ...........................................................................82
3.3 โครงสรางแบบทําซ้ํา .........................................................................85
3.3.1 คําสั่ง while .............................................................................85
3.3.2 คําสั่ง do..while ....................................................................88
3.3.3 คําสั่ง for ..................................................................................89
3.4 โครงสรางแบบซอน (NESTED STRUCTURE) ........................................92
3.4.1 คําสั่ง break, continue และ label ....................................94
สรุปเนื้อหาของบท..........................................................................................97

บทที่ 4 หลักการเชิงออปเจ็ค........................................................................................99
4.1 องคประกอบของโปรแกรมเชิงออปเจ็ค ..............................................99
4.1.1 ออปเจ็ค ......................................................................................99
4.1.2 คลาส ........................................................................................100
4.1.3 คุณลักษณะ...............................................................................101
4.1.4 เมธอด.......................................................................................103
4.2 การเขียนโปรแกรมเชิงออปเจ็คโดยใชภาษาจาวา.............................104
4.2.1 การประกาศคลาส......................................................................104
4.2.2 การประกาศคุณลักษณะ ............................................................105
4.2.3 การประกาศเมธอด....................................................................105
4.2.4 การประกาศและสรางออปเจ็ค ....................................................107
4.2.5 การเรียกใชสมาชิกของออปเจ็ค .................................................109
4.3 คุณลักษณะเดนของโปรแกรมเชิงออปเจ็ค........................................111
4.3.1 การหอหุม .................................................................................111
4.3.2 การสืบทอด...............................................................................113
4.3.3 การมีไดหลายรูปแบบ................................................................115
4.4 UNIFIED MODELING LANGUAGE ........................................................116
4.4.1 ไดอะแกรมของคลาส .................................................................116
4.4.2 ไดอะแกรมของออปเจ็ค .............................................................117

Java Programming iii

 4.5 ขั้นตอนการพัฒนาโปรแกรม............................................................118
สรุปเนื้อหาของบท........................................................................................120

บทที่ 5 การสรางสวนติดตอกับผูใชแบบกราฟฟก ....................................................123

5.1 JAVA FOUNDATION CLASS................................................................123
5.2 แพคเก็จ AWT ................................................................................125
5.2.1 คลาสและอินเตอรเฟสในแพคเก็จ AWT......................................125
5.3 คลาสประเภท Container ..........................................................126
5.3.1 คลาส Frame ...........................................................................127
5.3.2 คลาส Panel ...........................................................................129
5.3.3 คลาส Dialog .........................................................................130
5.4 การจัดวางผังของสวนประกอบกราฟฟก ..........................................131
5.4.1 BorderLayout ....................................................................132
5.4.2 FlowLayout .........................................................................134
5.4.3 GridLayout .........................................................................136
5.5 สวนประกอบกราฟฟกในแพคเก็จ AWT...........................................138
5.5.1 คลาส Button .......................................................................138
5.5.2 คลาส Checkbox ...................................................................139
5.5.3 คลาส Choice .......................................................................146
5.5.4 คลาส List ............................................................................148
5.5.5 คลาส Label ..........................................................................139
5.5.6 คลาส TextField ................................................................139
5.5.7 คลาส TextArea ...................................................................141
5.6 การสรางเมนู...................................................................................149
5.6.1 การสราง MenuBar ................................................................150
5.6.2 การสราง Menu .......................................................................151
5.6.3 การสราง MenuItem..............................................................153
5.6.4 คลาส CheckboxMenuItem ................................................155
5.6.5 การสรางเมนูยอย ......................................................................157
5.7 คุณลักษณะของคลาส Component ...............................................158
5.8 การสรางโปรแกรม GUI ที่ซับซอน...................................................161

iv คณะเทคโนโลยีสารสนเทศ สถาบันเทคโนโลยีพระจอมเกลาเจาคุณทหารลาดกระบัง
 5.9 การสรางภาพกราฟฟก....................................................................161
5.9.1 การเขียนคลาสเพื่อวาดรูปกราฟฟก ...........................................161
5.10 แพคเก็จ Swing.............................................................................164
5.10.1 คลาส JFrame ...................................................................166
5.10.2 คลาส JComponent..........................................................169
5.10.3 การใชคุณลักษณะเดนอื่นๆ ..................................................169
สรุปเนื้อหาของบท........................................................................................170

บทที่ 6 การเขียนโปรแกรมภาษาจาวาเชิงออปเจ็ค ..................................................173

6.1 เมธอด ............................................................................................173
6.1.1 การเรียกใชเมธอด .....................................................................175
6.1.2 การสงผาน argument................................................................176
6.1.3 การรับคาที่สงกลับมา ................................................................181
6.1.4 modifier ของเมธอด ..................................................................182
6.2 การเขียนโปรแกรมโดยใชหลักการของการหอหุม.............................184
6.2.1 เมธอดแบบ Accessor ...............................................................185
6.2.2 คียเวิรด this ..........................................................................188
6.3 การเขียนโปรแกรมโดยใชหลักการของการสืบทอด ..........................189
6.3.1 การสืบทอดที่ถูกตอง .................................................................193
6.3.2 คียเวิรด protected .............................................................194
6.3.3 คลาสที่ชื่อ Object..................................................................195
6.3.4 คียเวิรด super........................................................................195
6.4 การมีไดหลายรูปแบบ......................................................................196
6.4.1 Dynamic Binding .....................................................................196
6.4.2 การกําหนดเมธอดใหมีวิธีการที่ตางกัน .......................................198
6.4.3 คอลเล็กชั่นแบบ Heterogeneous ..............................................201
6.4.4 การสงผาน argument ไดหลายรูป...........................................202
6.4.5 ตัวดําเนินการ instanceof ...................................................202
6.4.6 การ Casting ออปเจ็ค ...............................................................203
6.5 CONSTRUCTOR................................................................................206
6.5.1 การเขียน Constructor...............................................................206

Java Programming v
 6.5.2 ขั้นตอนการทํางานของคําสั่ง new..............................................207
6.5.3 Constructor แบบ Overloaded..................................................208
6.5.4 เมธอด this() .......................................................................209
6.5.5 เมธอด super().....................................................................210
6.6 เมธอดของคลาสที่ชื่อ Object .......................................................213
6.6.1 เมธอด toString() .............................................................214
6.6.2 เมธอด equals() ..................................................................215
6.7 คลาสประเภท WRAPPER .................................................................216
6.8 คียเวิรดอื่นๆที่สําคัญ .......................................................................217
6.8.1 คุณลักษณะแบบ static ........................................................217
6.8.2 เมธอดแบบ static ................................................................218
6.8.3 Static Initializer ........................................................................219
6.8.4 คียเวิรด final........................................................................220
6.9 คลาสแบบ abstract และอินเตอรเฟส.........................................221
6.9.1 คลาสแบบ abstract .............................................................221
6.9.2 อินเตอรเฟส ..............................................................................223
6.10 คลาสภายใน ...................................................................................225
6.10.1 คลาสภายในที่อยูภายในคลาส..............................................226
6.10.2 คลาสภายในที่อยูภายในเมธอด ............................................227
6.11 แพคเก็จ .........................................................................................228
6.11.1 การประกาศและใชแพคเก็จ .......................................................229
สรุปเนื้อหาของบท........................................................................................230

บทที่ 7 การจัดการกับเหตุการณกราฟฟก.................................................................235
7.1 เหตุการณ .......................................................................................235
7.2 AWTEvent ...................................................................................236
7.2.1 ActionEvent.......................................................................237
7.2.2 WindowEvent.......................................................................238
7.2.3 MouseEvent .........................................................................238
7.2.4 ItemEvent ...........................................................................239
7.2.5 Event อื่นๆ ............................................................................240

vi คณะเทคโนโลยีสารสนเทศ สถาบันเทคโนโลยีพระจอมเกลาเจาคุณทหารลาดกระบัง
 7.3 อินเตอรเฟสประเภท Listener ...................................................240
7.4 การจัดการกับเหตุการณ..................................................................242
7.4.1 การสรางออปเจ็คของคลาสภายนอก ..........................................244
7.4.2 การสรางออปเจ็คของคลาสภายใน .............................................244
7.4.3 การสรางออปเจ็คภายในคลาสเดียวกัน .......................................247
7.4.4 การรับฟงเหตุการณหลายเหตุการณ ..........................................248
7.4.5 คลาสประเภท Event Adapter ...........................................250
7.4.6 การสรางคลาสแบบ anonymous ..............................................251
สรุปเนื้อหาของบท........................................................................................252

บทที่ 8 อะเรยและคอลเล็กชั่น ...................................................................................253

8.1 อะเรย .............................................................................................253
8.2 อะเรยของขอมูลชนิดพื้นฐาน ...........................................................254
8.2.1 การประกาศชื่อตัวแปรอะเรยของขอมูลชนิดพื้นฐาน ...................254
8.2.2 การสรางตัวแปรอะเรยของขอมูลชนิดพื้นฐาน.............................255
8.2.3 การเรียกใชสมาชิกของอะเรย .....................................................257
8.2.4 การกําหนดคาเริ่มตนใหกับสมาชิกของอะเรย .............................258
8.2.5 การใชคําสั่ง for เพื่ออางอิงสมาชิกของอะเรย...........................259
8.2.6 ขอผิดพลาดประเภท ArrayIndexOutOfBoundsException 260
8.3 อะเรยของขอมูลชนิดคลาส ..............................................................261
8.3.1 การเก็บคาของตัวแปรอะเรยของขอมูลชนิดคลาส .......................263
8.4 อะเรยหลายมิติ ...............................................................................264
8.4.1 การเขียนโปรแกรมเพื่อจัดการกับเมตริกซ ..................................265
8.4.2 อะเรยสองมิติที่มีจํานวนคอลัมนตางกัน ......................................270
8.5 เมธอดที่เกี่ยวของกับอะเรย .............................................................271
8.6 คอลเล็กชั่น .....................................................................................274
8.6.1 อินเตอรเฟส Collection ....................................................275
8.6.2 อินเตอรเฟส Set.....................................................................276
8.6.3 อินเตอรเฟส List ..................................................................277
8.6.4 อินเตอรเฟส Map.....................................................................279
8.6.5 อินเตอรเฟส Iterator .........................................................280

Java Programming vii

 8.6.6 คลาส Vector .......................................................................283
สรุปเนื้อหาของบท........................................................................................284

บทที่ 9 การจัดการกับขอผิดพลาด ............................................................................287

9.1 ขอผิดพลาด ....................................................................................287
9.1.1 Exception ...........................................................................288
9.2 คําสั่ง try..catch .....................................................................290
9.2.1 การจัดการกับขอผิดพลาดหลายๆประเภท .................................292
9.2.2 บล็อก finally......................................................................294
9.3 การจัดการกับเมธอดที่สงออปเจ็คประเภท Exception .................295
9.4 การสรางคลาสประเภท Exception ขึ้นใหม .................................298
9.4.1 การเขียนเมธอดเพื่อสงออปเจ็คประเภท Exception ..............299
สรุปเนื้อหาของบท........................................................................................300

บทที่ 10 โปรแกรมจาวาแอปเพล็ต ..............................................................................303

10.1 โปรแกรมจาวาแอปเพล็ต.................................................................303
10.1.1 tag ที่ชื่อ <APPLET>................................................................306
10.1.2 การสงพารามิเตอร ....................................................................307
10.2 คลาส Applet..............................................................................308
10.3 คลาส Graphics ..........................................................................310
10.3.1 เมธอดในการวาดรูปทรงตางๆ ...................................................311
10.3.2 เมธอดที่ใชในการจัดการคุณลักษณะของกราฟฟก ......................313
10.4 คําสั่งดาน MULTIMEDIA ....................................................................316
10.4.1 คลาส Image ...........................................................................317
10.4.2 คลาส AudioClip ................................................................318
10.5 โปรแกรมจาวาแอปเพล็ตที่โตตอบกับผูใช ........................................319
สรุปเนื้อหาของบท........................................................................................321

บทที่ 11 คลาสอินพุตและเอาทพุต ..............................................................................323

11.1 STREAM ..........................................................................................323

viii คณะเทคโนโลยีสารสนเทศ สถาบันเทคโนโลยีพระจอมเกลาเจาคุณทหารลาดกระบัง

 11.1.1 แพคเก็จ java.io .............................................................324
11.1.2 คลาสประเภท Byte Stream ...............................................326
11.1.3 คลาส InputStream .......................................................326
11.1.4 คลาส OutputStream .....................................................328
11.1.5 คลาสประเภท Character Stream.......................................330
11.2 โหนดสําหรับ STREAM .....................................................................331
11.3 คลาสประเภท STREAM ระดับสูง ......................................................333
11.3.1 DataInputStream และ DataOutputStream .............336
11.3.2 InputStreamReader และ OutputStreamWriter....339
11.4 คลาส File ...................................................................................341
11.4.1 คลาส RandomAccessFile ................................................343
11.4.2 ObjectInputStream และ ObjectOutputStream.....344
สรุปเนื้อหาของบท........................................................................................346

บทที่ 12 โปรแกรมแบบเธรด .......................................................................................349

12.1 โปรแกรมแบบมัลติเธรด ..................................................................349
12.2 การสรางคลาสแบบเธรด .................................................................351
12.2.1 การ implements อินเตอรเฟส Runnable ....................352
12.2.2 การ extends คลาสที่ชื่อ Thread ................................354
12.3 วงจรการทํางานของเธรด ................................................................355
12.3.1 เมธอดของคลาส Thread .................................................357
12.4 SYNCHRONIZATION ..........................................................................358
12.4.1 เมธอด wait() และ notify() ......................................362
12.4.2 Deadlock ............................................................................365
สรุปเนื้อหาของบท........................................................................................366

ศัพทานุกรม………………………………………………………..……………………...…..367

ดัชนี………………………………………………………..……………………...…..……….377

บรรณานุกรม…………………………………………………………………………………385

Java Programming ix
x คณะเทคโนโลยีสารสนเทศ สถาบันเทคโนโลยีพระจอมเกลาเจาคุณทหารลาดกระบัง
 บทที่ 1
ความรูเบื้องตนของภาษาจาวา
เนื้อหาในบทนี้เปนการแนะนําภาษาจาวา โดยจะเริ่มจากการแนะนําหลักการของ
ภาษาคอมพิวเตอรโดยทั่วๆไป ประวัติความเปนมาโดยยอของภาษาจาวา ขอแตกตางของ
ภาษาจาวากับภาษาคอมพิวเตอรอื่นๆ หลักการการทํางานของโปรแกรมภาษาจาวา และ
ความหมายของเครื่องจักรสมมุติที่ใชในภาษาจาวา พรอมทั้งแนะนําเทคโนโลยีและแพลตฟอรม
ตางๆของภาษาจาวา แนะนําตัวอยางการเขียนโปรแกรมจาวาประยุกตและโปรแกรมจาวา
แอปเพล็ต และในสวนทายของบทไดมีการแนะนําวิธีการใชคูมอื Java API

1.1 ระบบคอมพิวเตอร
เครื่องคอมพิวเตอรเปนเครื่องอิเล็กทรอนิกส ที่ใชในการคํานวณและจัดการกับระบบ
ขอมูล องคประกอบของระบบคอมพิวเตอรโดยทั่วไปจะเปนดังแสดงในรูปที่ 1.1 ซึ่งจะประกอบ
ไปดวยสวนหลักสามสวนคือ
1. ฮารดแวร (Hardware) คือสวนประกอบที่เปนตัวเครื่องคอมพิวเตอรที่
ประกอบดวยหนวยประมวลผลกลาง (Central Processing Unit หรือ CPU)
อุปกรณสวนอินพุต อุปกรณสวนเอาทพุต หนวยความจํา และอุปกรณเก็บขอมูล
2. ระบบปฏิบัติการ (Operating System) คือระบบซอฟตแวรที่ติดตั้งเพื่อให
โปรแกรมประยุกตตางๆ สามารถติดตอกับฮารดแวรได ระบบปฏิบัติการที่นิยมใช
ในปจจุบันมีอยูหลายระบบ อาทิเชน Windows XP, Linux และ Solaris เปนตน
ทั้งนี้ฮารดแวรชนิดเดียวกันสามารถที่จะมีระบบปฏิบัติการที่แตกตางกันได
3. โปรแกรมประยุกต (Application Program) คือโปรแกรมที่ใชงานทั่วๆไป เชน
โปรแกรม Word Processor, เกมส หรือโปรแกรมเว็บบราวเซอร (Web
Browser) เปนตน โปรแกรมเหลานี้จะถูกพัฒนาโดยใชภาษาคอมพิวเตอรตางๆ
อาทิเชน ภาษาฟอรแทรน (FORTRAN) ภาษาโคบอล (COBOL) ภาษาเบสิก
(BASIC) ภาษา C++ หรือภาษาจาวา เปนตน โปรแกรมประยุกตจะทํางาน
ภายใตระบบปฏิบัติการ ดังนั้นโปรแกรมประยุกตบนระบบปฏิบัติการระบบใด
ระบบหนึ่งจะไมสามารถนําไปใชในระบบปฏิบัติการอื่นได

Java Programming 1
 รูปที่ 1.1 องคประกอบของระบบคอมพิวเตอร

1.2 ภาษาคอมพิวเตอร
ภาษาคอมพิวเตอรคือคําสั่งที่นักพัฒนาโปรแกรม (programmer) พัฒนาขึ้นเพื่อสั่งให
เครื่องคอมพิวเตอรทํางานตามที่ตองการ ภาษาคอมพิวเตอรแบงออกเปนสามประเภทคือ
1. ภาษาเครื่อง (Machine Language) เปนภาษาเดียวที่เครื่องคอมพิวเตอรสามารถ
เขาใจได ภาษาเครื่องจะประกอบไปดวยคําสั่งที่เปนชุดของเลขฐานสองเชน
01010110 ซึ่งจะถูกกําหนดโดยฮารดแวรของเครื่องคอมพิวเตอร ทั้งนี้
ภาษาเครื่องจะขึ้นอยูกับชนิดของหนวยประมวลผลกลางของเครื่องคอมพิวเตอร
แตละเครื่อง โดยปกติแลวนักพัฒนาโปรแกรมไมสามารถที่จะพัฒนาโปรแกรมโดย
เขียนภาษาเครื่องไดโดยตรง ทั้งนี้เนื่องจากเปนภาษาที่ใชเลขฐานสองซึ่งไมใช
ชุดคําสั่งที่มนุษยจะสามารถเขาใจไดโดยงาย ตัวอยางของคําสั่งภาษาเครื่องมีดังนี้
10110011 00011001
01111010 11010001 10010100
10011111 00011001
01011100 11010001 10010000
10111011 11010001 10010110
2. ภาษาแอสเซมบลี (Assembly Language) เปนภาษาคอมพิวเตอรที่แทนชุดคําสั่ง
เลขฐานสองดวยคําสัญลักษณที่เปนภาษาอังกฤษ เชน 10110011 อาจแทนดวย
MOV เปนตน ทําใหนักพัฒนาโปรแกรมเขียนและเขาใจโปรแกรมไดงายขึ้น การ
ทํางานของโปรแกรมภาษาแอสเซมบลี จะตองมีการแปลภาษาแอสเซมบลีใหเปน
ภาษาเครื่องกอนจึงจะทํางานได แมภาษาแอสเซมบลีจะมีชุดคําสั่งที่เปนคํา
ภาษาอังกฤษ แตนักพัฒนาโปรแกรมภาษาแอสเซมบลีจะตองมีความเขาใจ
โครงสรางฮารดแวรของระบบคอมพิวเตอรจึงจะสามารถเขียนโปรแกรมได ดังนั้น

2 คณะเทคโนโลยีสารสนเทศ สถาบันเทคโนโลยีพระจอมเกลาเจาคุณทหารลาดกระบัง
 ทําใหภาษาแอสเซมบลีไมเปนที่นิยมใช ตัวอยางของโปรแกรมภาษาแอสเซมบลีมี
ดังนี้
MOV 0, SUM
MOV NUM, AC
ADD SUM, AC
STO SUM, TOT
3. ภาษาระดับสูง (High-level Language) การพัฒนาโปรแกรมโดยทั่วไปจะใช
โปรแกรมภาษาคอมพิวเตอรระดับสูง ภาษาคอมพิวเตอรระดับสูงจะใชชุดคําสั่งที่
คนทั่วไปเขาใจไดงาย เหมือนการใชคําสั่งในภาษาอังกฤษหรือการเขียนสมการ
คณิตศาสตรทั่วไป นักพัฒนาโปรแกรมไมจาํ เปนตองเขาใจหลักการทํางานของ
ฮารดแวรก็สามารถที่จะพัฒนาโปรแกรมภาษาคอมพิวเตอรระดับสูงได โปรแกรม
ภาษาคอมพิวเตอรระดับสูง จะตองการตัวแปลภาษาที่ทําหนาที่เปลี่ยนชุดคําสั่งให
มาเปนภาษาแอสเซมบลีหรือภาษาเครื่องจึงจะทํางานได เมื่อเทียบกับภาษา
แอสเซมบลีแลวภาษาคอมพิวเตอรระดับสูง จะชวยใหนักพัฒนาโปรแกรมพัฒนา
โปรแกรมไดรวดเร็วกวา แตโปรแกรมที่พัฒนาขึ้นจะทํางานไดชากวา
ในปจจุบันมีโปรแกรมภาษาคอมพิวเตอรระดับสูงอยูหลายรอยภาษา แตที่นิยมใชและ
ไดรับการยอมรับมีเพียงไมกี่ภาษา ภาษาคอมพิวเตอรในยุคแรกที่นิยมใชมหี ลายภาษาอาทิเชน
• ภาษาฟอรแทรน (FORTRAN ยอมาจาก FORmula TRANslator) พัฒนาโดย
บริษัท IBM ระหวางป ค.ศ. 1954 ถึง ค.ศ. 1957 ภาษานี้ใชสําหรับการพัฒนา
โปรแกรมประยุกตดานวิทยาศาสตรและวิศวกรรมศาสตร ที่ตองใชในการคํานวณ
สมการคณิตศาสตรที่ซับซอน ปจจุบันภาษาฟอรแทรนยังเปนที่นิยมใชในการ
พัฒนาโปรแกรมดานวิทยาศาสตรและวิศวกรรมศาสตร
• ภาษาโคบอล (COBOL ยอมาจาก COmmon Business Oriented Language)
พัฒนาขึ้นในป ค.ศ. 1959 เปนภาษาที่พัฒนาขึ้นมาเพื่อใชในการพัฒนาโปรแกรม
ประยุกตดานธุรกิจและการคา ปจจุบันโปรแกรมที่ใชในดานธุรกิจจํานวนมากยัง
เปนโปรแกรมที่พัฒนามาจากภาษาโคบอล
• ภาษาเบสิก (BASIC ยอมาจาก Beginners All-purpose Symbolic Instructional
Code) เปนภาษาที่พัฒนาขึ้นโดยมีจุดประสงคเพื่อใหผูเริ่มตนพัฒนาโปรแกรม
สามารถเรียนรูและเขาใจการพัฒนาโปรแกรมอยางงาย ภาษาเบสิกเปนภาษา
คอมพิวเตอรภาษาแรกที่ใชในเครื่องไมโครคอมพิวเตอร

Java Programming 3
 ภาษาคอมพิวเตอรที่พัฒนาขึ้นในยุคแรก ยังมีขอจํากัดในการที่จะพัฒนาโปรแกรม
ขนาดใหญ ทั้งนี้เนื่องจากภาษาคอมพิวเตอรเหลานั้นขาดโครงสรางที่ดี ทําใหการพัฒนา
โปรแกรมที่มีขนาดใหญและมีความซับซอนเปนไปไดยาก ในชวงตนป ค.ศ. 1970 จึงมีภาษา
คอมพิวเตอรที่เปนภาษาเชิงกระบวนการ (Procedural หรือ Structural Language) เกิดขึ้น
ภาษาคอมพิวเตอรประเภทนี้จะมีความยืดหยุนในการพัฒนาโปรแกรม ทําใหสามารถแกไขและ
บํารุงรักษาไดงาย เนื่องจากโปรแกรมถูกแยกออกเปนสวนๆ ภาษาคอมพิวเตอรที่เปนภาษา
เชิงกระบวนการที่สําคัญคือ
• ภาษาปาสคาล (Pascal) พัฒนาโดย Nicklaus Wirth ในป ค.ศ. 1971 โดยมี
จุดประสงคเพื่อใชในการสอนการเขียนโปรแกรมภาษาเชิงกระบวนการ ใน
มหาวิทยาลัย แตเนื่องจากภาษาปาสคาลไมมีคุณลักษณะที่จะสนับสนุนการ
พัฒนาโปรแกรมดานธุรกิจและอุตสาหกรรมจึงไมไดรับความนิยมมากนัก
• ภาษาซี (C) พัฒนาขึ้นในชวงเดียวกับภาษาปาสคาล โดยนักวิจัยที่หองปฏิบัติการ
AT&T Bell ซึ่งไดนําเอาจุดเดนของภาษา BCPL และภาษา B มาใชและไดเพิ่ม
คุณลักษณะและชนิดขอมูลอื่นเขามาดวย เดิมภาษาซีถือวาเปนภาษาคอมพิวเตอร
ที่สําคัญในการพัฒนาโปรแกรมบนระบบปฏิบัติการยูนิกส (Unix) ซึ่งเปนภาษา
คอมพิวเตอรที่สามารถสรางโปรแกรมประยุกตที่ทํางานไดรวดเร็วมาก เมื่อเทียบ
กับภาษาคอมพิวเตอรอื่นๆ
จุดดอยของการพัฒนาโปรแกรมภาษาเชิงกระบวนการคือ จะมีตนทุนในการพัฒนา
โปรแกรมที่คอนขางสูง เนื่องจากจะตองมีการออกแบบโปรแกรมใหแยกออกเปนสวนๆที่
เรียกวาโมดูล (module) ซึ่งจะตองเปนอิสระจากกัน การออกแบบใหมคี วามเปนอิสระตอกัน
นั้นทําไดยาก ซึ่งหากออกแบบมาไมดีจะทําใหการแกไขและบํารุงรักษาโปรแกรมเปนไปไดยาก
ดังนั้นจึงมีการพัฒนาภาษาคอมพิวเตอรในแบบที่เรียกวา ภาษาเชิงออปเจ็ค (Object Oriented
Programming) ที่พยายามใหการพัฒนาโปรแกรมเปนการเลียนแบบการทํางานของออปเจ็ค
ตางๆในโลก ทั้งนี้เพื่อใหงายตอการพัฒนาโปรแกรมและสามารถนําโปรแกรมกลับมาใชใหม
(reuse) ไดดีกวาภาษาเชิงกระบวนการ ภาษาคอมพิวเตอรที่เปนภาษาเชิงออปเจ็คที่สําคัญคือ
• ภาษา C++ เปนภาษาที่พัฒนามาจากภาษาซีเมื่อตน ค.ศ. 1980 โดยนักวิจัยที่
หองปฏิบัติการ Bell โดยไดเพิ่มหลักการเชิงออปเจ็คขึ้นมาจากภาษาซี ดังนั้น
นักพัฒนาโปรแกรมภาษา C++ สามารถที่จะพัฒนาโปรแกรมทั้งในเชิงออปเจ็ค
และเชิงกระบวนการ (ตามแบบภาษาซี) ได ทําใหปจจุบันภาษา C++ ยังเปนที่
นิยมใชกันอยางแพรหลาย

4 คณะเทคโนโลยีสารสนเทศ สถาบันเทคโนโลยีพระจอมเกลาเจาคุณทหารลาดกระบัง
 • ภาษา Smalltalk เปนภาษาเชิงออปเจ็คที่พัฒนาโดยนักวิจัยที่ Xerox’s Palo Alto
Research Center (PARC) ซึ่งเปนภาษาคอมพิวเตอรที่เปนภาษาเชิงออปเจ็ค
อยางแทจริง แตภาษา Smalltalk ไมไดรับความนิยมในการนําไปใชงานมากนัก
เมื่อเทียบกับภาษา C++ หรือภาษาจาวา
• ภาษาจาวาเปนภาษาคอมพิวเตอรที่พัฒนาโดย นักวิจัยของบริษัทซันไมโครซิส-
เต็มส (SUN Microsystems) โดยเริ่มมีการนํามาเผยแพรเมื่อป ค.ศ. 1995
ปจจุบันเปนภาษาเชิงออปเจ็คที่เปนที่นิยมใชกันมากภาษาหนึ่ง ซึ่งไดรับการ
ยอมรับในการพัฒนาโปรแกรมทางธุรกิจและอุตสาหกรรม และยังเปนที่นิยมใช
เพื่อการศึกษาหลักการการเขียนโปรแกรมคอมพิวเตอรโดยใชภาษาเชิงออปเจ็ค
อีกดวย

1.3 ตัวแปลภาษา
ภาษาคอมพิวเตอรระดับสูงจะตองการตัวแปลภาษา (language translator) เพื่อแปล
โปรแกรมที่เขียนขึ้นหรือที่เรียกวาซอรดโคด (source code) ของภาษาคอมพิวเตอรแตละ
ภาษาใหเปนภาษาแอสเซมบลีหรือภาษาเครื่องที่เครื่องคอมพิวเตอรสามารถเขาใจได ตัวแปล
ภาษาแบงออกเปนสองแบบคือ
1. คอมไพเลอร (Compiler) ตัวแปลภาษาประเภทนี้จะแปลชุดคําสั่งในซอรดโคด
ทั้งหมดใหเปนโปรแกรม executable code ดังแสดงในรูปที่ 1.2 ตัวอยางเชน
แปลซอรดโคดภาษาซีจากโปรแกรม Hello.c ใหเปนโปรแกรม executable
code ที่ชื่อ Hello.exe โดยโปรแกรม executable code ที่ไดจากการ
แปลภาษาคอมพิวเตอรระดับสูงจะสามารถทํางานไดอยางรวดเร็ว ทั้งนี้เนื่องจาก
โคดอยูในรูปของเลขฐาน สองที่สามารถติดตอกับเครื่องคอมพิวเตอรไดโดยตรง
ตัวอยางของภาษา คอมพิวเตอรที่ใชคอมไพเลอรคือ ภาษาซี C++ ฟอรแทรน
และปาสคาล เปนตน
คอมไพเลอรจะสรางโปรแกรม executable code ที่ขึ้นอยูกับแพลตฟอรม
(ฮารดแวรและระบบปฏิบัติการ) ดังนั้นผูใชจะไมสามารถนําโปรแกรม executable
code ที่ไดจากการแปลของคอมไพเลอรบนแพลตฟอรมหนึ่งไปใชบนแพลตฟอรม
อื่นๆได ในกรณีที่นักพัฒนาโปรแกรมตองการนําโปรแกรมที่พัฒนาขึ้นไปใชบน
แพลตฟอรมอื่นๆ นักพัฒนาโปรแกรมจะตองทําการแปลซอรดโคดของโปรแกรม

Java Programming 5
 ใหม โดยจะตองใชคอมไพเลอรที่สรางโปรแกรม executable code สําหรับ
แพลตฟอรมที่ตองการใชงานนั้นๆ

รูปที่ 1.2 ขั้นตอนการทํางานของคอมไพเลอร

2. อินเตอรพรีตเตอร (Interpreter) ตัวแปลภาษาประเภทนี้จะแปลชุดคําสั่งของ

ภาษาคอมพิวเตอรระดับสูงทีละคําสั่งใหเปนโปรแกรม executable code แลวจะ
สั่งใหเครื่องคอมพิวเตอรทํางานทันทีดังแสดงในรูปที่ 1.3 โปรแกรมภาษา
คอมพิวเตอรที่ใชอินเตอรพรีตเตอร จะทํางานไดชากวาโปรแกรมภาษา
คอมพิวเตอรที่ใชคอมไพเลอร แตขอดีของโปรแกรมภาษาคอมพิวเตอรที่ใช
อินเตอรพรีตเตอรคือจะสามารถใชงานขามแพลตฟอรมได ทั้งนี้เนื่องจาก
ขั้นตอนการแปลภาษากระทําอยูในชวงการรันโปรแกรม นอกจากนี้โปรแกรม
อินเตอรพรีตเตอรจะพัฒนาไดงายกวาเนื่องจากมีขนาดเล็ก ตัวอยางของ
ภาษาคอมพิวเตอรที่ใชอินเตอรพรีตเตอรคือ ภาษาเบสิก โปรล็อก (Prolog) และ
Smalltalk เปนตน

6 คณะเทคโนโลยีสารสนเทศ สถาบันเทคโนโลยีพระจอมเกลาเจาคุณทหารลาดกระบัง
 รูปที่ 1.3 ขั้นตอนการทํางานของอินเตอรพรีตเตอร

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

Java Programming 7
 การพัฒนาโปรแกรมเชิงออปเจ็คจะมีแนวคิดในการแกปญหา โดยมองปญหาวา
ประกอบไปดวยออปเจ็คตางๆ ซึ่งแนวคิดนี้จะเขาใกลเคียงกับธรรมชาติของมนุษยมากที่สุด
เนื่องจากมนุษยมองสิ่งตางๆรอบตัวเปนออปเจ็คทั้งที่เปนรูปธรรม (วัตถุ) เชน ปากกา
นักศึกษา หรือใบลงทะเบียน เปนตน และที่เปนนามธรรมเชน คะแนน หรือรายชื่อวิชา เปนตน
การเขียนโปรแกรมเชิงออปเจ็คจะเปนขบวนการการวิเคราะหปญหา โดยการจําลอง
คุณลักษณะและพฤติกรรมของออปเจ็คในระบบจริง ใหอยูในรูปของโปรแกรมคอมพิวเตอร
ตัวอยางเชน การพัฒนาโปรแกรมระบบทะเบียนนักศึกษาอาจแบงโปรแกรมใหประกอบดวย
ออปเจ็คตางๆอาทิเชน นักศึกษา ใบลงทะเบียน และรายวิชา เปนตน ออปเจ็คชนิดนักศึกษา
อาจมีคุณลักษณะตางๆเชน ชื่อ รหัส และเกรดเฉลี่ย เปนตน และอาจมีพฤติกรรมที่นักศึกษา
สามารถกระทําไดเชน ลงทะเบียน และเพิ่มหรือถอนวิชา เปนตน
การพัฒนาโปรแกรมโดยใชภาษาคอมพิวเตอรเชิงออปเจ็ค จะทําใหขบวนการพัฒนา
โปรแกรมทําไดรวดเร็วขึ้นและสามารถปรับปรุงแกไขโปรแกรมไดงาย ซึ่งเหมาะกับการพัฒนา
โปรแกรมขนาดใหญที่จะตองมีการปรับปรุงแกไขโปรแกรมอยูต ลอด นอกจากนี้โปรแกรมเชิง
ออปเจ็คยังมีคุณลักษณะเดนอื่นๆอีกดังนี้
• การหอหุม (Encapsulation) เปนคุณลักษณะที่ทําใหออปเจ็คแตละตัวเปนอิสระ
ตอกัน ซึ่งทําใหสามารถแบงการพัฒนาโปรแกรมออกเปนสวนๆไดงาย
• การสืบทอด (Inheritance) เปนคุณลักษณะที่ทําใหสามารถนําโปรแกรมที่พัฒนา
แลวกลับมาใชใหมไดงายกวาการเขียนโปรแกรมเชิงกระบวนการ
• การมีไดหลายรูปแบบ (Polymorphism) เปนคุณลักษณะที่ทําใหนักพัฒนา
โปรแกรมสามารถเพิ่มเติมสวนตางๆของโปรแกรมไดงาย

1.5 ประวัติภาษาจาวา
ภาษาจาวาเปนภาษาคอมพิวเตอรที่พัฒนาขึ้น โดยทีมวิจัยของบริษัทซันไมโครซิส-
เต็มส ซึ่งเริ่มตนเมื่อป ค.ศ. 1991 โดยทางบริษัทซันไมโครซิสเต็มสไดสนับสนุนใหมีการพัฒนา
โครงการที่ชื่อ Green Project ที่มีจุดมุงหมายที่จะออกแบบภาษาคอมพิวเตอรขนาดเล็กเพื่อใช
กับอุปกรณอิเล็กทรอนิกสตางๆเชน สวิทซบล็อกของเคเบิ้ลทีวี ซึ่งอุปกรณเหลานี้จะมีขอจํากัด
ในดานหนวยความจําและหนวยประมวลผลกลางที่จะมีความแตกตางกัน ดังนั้นภาษา
คอมพิวเตอรที่พัฒนาขึ้นจะตองไมขึ้นอยูกับแพลตฟอรม (Platform Independent) ผลงานของ
ทีมวิจัยนี้ทําใหไดภาษาคอมพิวเตอรใหมที่ชื่อวา “Oak” ซึ่งมีโครงสรางและคําสั่งคลายภาษา
C++ ทั้งนี้เนื่องจากทีมวิจัยของบริษัทซันไมโครซิสเต็มสมีความคุนเคยกับระบบปฏิบัติการ

8 คณะเทคโนโลยีสารสนเทศ สถาบันเทคโนโลยีพระจอมเกลาเจาคุณทหารลาดกระบัง
ยูนิกสซึ่งมักจะใชภาษา C++ ในการพัฒนาโปรแกรม ภาษา “Oak” ตอมาไดเปลี่ยนมาเปนชื่อ
“จาวา” ทั้งนี้เนื่องจากทีมวิจัยไดทราบภายหลังวา ”Oak” เปนชื่อภาษาคอมพิวเตอรที่มีอยูแลว
ภาษาจาวาเปนภาษาคอมพิวเตอรเชิงออปเจ็ค (Object Orianted Programming หรือ
เรียกยอวา OOP) โดยมีจุดเดนตรงที่สามารถทํางานไดกับระบบคอมพิวเตอรหลาย
แพลตฟอรม ทีมวิจัยของโครงการ Green Project ไดสรางเครื่องตนแบบที่เรียกวา ”*7”
ซึ่งเปนรีโมทคอนโทรลเพื่อสาธิตเทคโนโลยีภาษาจาวาที่คนคิดขึ้นมานี้เมื่อป ค.ศ. 1992 โดย
ทางบริษัทซันไมโครซิสเต็มสไดพยายามหาผูซื้อเทคโนโลยีดังกลาว แตก็ไมประสบความสําเร็จ
มากนัก
ในชวงดังกลาว ระบบอินเตอรเน็ตไดเริ่มมีการใชงานอยางแพรหลายมากขึ้น โดย
เฉพาะการใชงานของโปรแกรมเว็บบราวเซอร (Web Browser) เพื่อที่จะเรียกดูเอกสารใน
รูปแบบของไฟล HTML เนื่องจากระบบอินเตอรเน็ตจะประกอบไปดวยเครื่องคอมพิวเตอรที่มี
แพลตฟอรมแตกตางกัน ทางบริษัทซันไมโครซิสเต็มสจึงไดเห็นความจําเปนที่จะตองมีภาษา
คอมพิวเตอรที่สามารถสรางโปรแกรมที่ทํางานบนแพลตฟอรมใดๆก็ได จึงไดนําภาษาจาวามา
พัฒนาอีกครั้งหนึ่ง โดยไดพัฒนาโปรแกรมเว็บบราวเซอรที่ชื่อ Hot Java ที่สามารถรัน
โปรแกรมจาวาแอปเพล็ต (Java Applet) ไดเพื่อพิสูจนการทํางานของเทคโนโลยีจาวา (proof
of technology) และไดนําผลงานดังกลาวมาแสดงในงาน Sun World’95 ในเดือนพฤษภาคม
ป ค.ศ. 1995
จากนั้นภาษาจาวาเริ่มเปนที่นิยมแพรหลายขึ้นในชวงปลายป ค.ศ. 1995 เมื่อบริษัท
Netscape ไดพัฒนาโปรแกรมเว็บบราวเซอร Netscape 2.0 และไดรวมเอาการทํางานของ
โปรแกรมจาวาแอปเพล็ต (Java Applet) เขามาเปนคุณลักษณะเดนของโปรแกรม ซึ่งบริษัท
อื่นๆอาทิเชน IBM, Symantec, Inspire หรือ Microsoft ตางก็ประกาศสนับสนุนการใชงานของ
โปรแกรมภาษาจาวาในเวลาตอมา ในชวงเดียวกันทางบริษัทซันไมโครซิสเต็มสไดนําชุดพัฒนา
โปรแกรมภาษาจาวาเวอรชั่นแรก (Java Development Kit 1.0 หรือที่เรียกยอวา JDK 1.0)
ออกมาแจกจาย ตอมาในป ค.ศ. 1998 ทางบริษัทซันไมโครซิสเต็มสไดเผยแพรโปรแกรม
ภาษาจาวา JDK 1.2 (แตตอมาไดเปลี่ยนชื่อเปน Java 2) ซึ่งเปนเทคโนโลยีที่สมบูรณแบบกวา
ภาษาจาวาเวอรชั่นกอนหนานี้ และเปนเทคโนโลยีที่สามารถทํางานไดกับทุกแพลตฟอรมอยาง
แทจริง

1.6 เทคโนโลยีจาวา
เทคโนโลยีจาวาประกอบไปดวยองคประกอบหลักๆสามสวนดังแสดงในรูปที่ 1.4 คือ

Java Programming 9
 1. Java Virtual Machine (JVM) เปนเทคโนโลยีจาวาที่ทําหนาที่เปนอินเตอรพรีต
เตอร ที่จะแปลโปรแกรมจาวาไบทโคด (Java Bytecode) ใหเปนภาษาที่เครื่อง
เขาใจได
2. Java Runtime Environment (JRE) เปนเทคโนโลยีจาวาที่ใชในการรันโปรแกรม
ภาษาจาวาอาทิเชน โปรแกรมจาวาประยุกต (Java Application) และโปรแกรม
จาวาแอปเพล็ต (Java Applet) JRE จะประกอบดวย JVM และ Java
Application Programming Interface (Java API) ที่จะรวบรวมคลาสและ
อินเตอรเฟสตางๆ ที่จําเปนตอการใชงานของโปรแกรมภาษาจาวา
3. Java 2 Software Developer Kit (J2SDK) เปนชุดพัฒนาโปรแกรมภาษาจาวาที่
จะประกอบไปดวย JVM ตัวแปลภาษาจาวา (Java Compiler) เครื่องมือ (tool)
อื่นๆในการพัฒนาโปรแกรม และ API ทั้งหมดในภาษาจาวา ซึ่ง API จะเปน
มาตรฐานคําสั่งตางๆของภาษาจาวา

รูปที่ 1.4 องคประกอบของเทคโนโลยีจาวา

1.6.1 Java Virtual Machine

ภาษาจาวาออกแบบมาเพื่อใหสามารถประมวลผลไดกับทุกแพลตฟอรม โดยไดรวม
หลักการของตัวแปลภาษาทั้งคอมไพเลอรและอินเตอรพรีตเตอรไว โดยคอมไพเลอรของภาษา
จาวาจะทําหนาที่แปลซอรดโคดของโปรแกรม (ชื่อไฟล.java) ใหเปนโปรแกรมไบทโคด (ชื่อ
ไฟล.class) โปรแกรมไบทโคดจะแตกตางจากโปรแกรมภาษาเครื่องที่สามารถประมวลผล
บนระบบปฏิบัติการไดโดยตรง แตโปรแกรมไบทโคดจะประมวลผลไดโดยผานอินเตอรพรีต
เตอร ซึ่งจะแปลโปรแกรมไบทโคดแลวสั่งงานไปยังเครื่องคอมพิวเตอร อินเตอรพรีตเตอรแบบ

10 คณะเทคโนโลยีสารสนเทศ สถาบันเทคโนโลยีพระจอมเกลาเจาคุณทหารลาดกระบัง
นี้มีชื่อเรียกวา JVM (Java Virtual Machine หรือเครื่องจักรสมมุติจาวา) ซึ่งขั้นตอนการ
ทํางานของโปรแกรมภาษาจาวาสามารถแสดงไดดังรูปที่ 1.5
JVM จะทําหนาที่แปลโปรแกรมไบทโคดใหเปนภาษาเครื่องที่ขึ้นอยูกับแพลตฟอรม
โปรแกรมไบทโคดที่ประมวลผลโดยใช JVM จะทํางานไดเร็วกวาโปรแกรมภาษาคอมพิวเตอร
อื่นๆที่ใชอินเตอรพรีตเตอรปกติในการประมวลผล ทั้งนี้เนื่องจาก JVM จะมีชดุ คําสั่งที่ใกลเคียง
กับชุดคําสั่งภาษาเครื่องของหนวยประมวลผลกลางที่ใชงาน ดังนั้น JVM จึงสามารถแปล
คําสั่งของโปรแกรมไบทโคดไปเปนคําสั่งภาษาเครื่องของหนวยประมวลผลกลางที่ใชงานไดงาย
กวา นอกจากนี้โปรแกรมไบทโคดจะไมขึ้นอยูกับแพลตฟอรม ดังนั้นเราสามารถที่จะนํา
โปรแกรมไบทโคดที่คอมไพลจากระบบปฏิบัติการหนึ่ง มาประมวลผลบนระบบปฏิบัติการอี่นๆ
ได หากระบบปฏิบัติการนั้นมี JVM อยู
JVM เปนเครื่องจักรกลสมมุติที่ทําหนาที่เหมือนกับระบบคอมพิวเตอรจริง โดย
มาตรฐานของ JVM ที่กําหนดโดยบริษัทซันไมโครซิสเต็มสจะมีขอกําหนดตางๆเชนเดียวกับ
องคประกอบของระบบคอมพิวเตอรเชน ชุดคําสั่ง (instruction set) และชุดรีจีสเตอร (register
set) เปนตน และยังมีขอกําหนดอื่นๆเชน เนื้อที่ของหนวยความจํา (memory area) สแต็ก
(stack), heap, garbage collection และรูปแบบของคลาสไฟล (class file format) เปนตน
ทั้งนี้ขอกําหนดของ JVM เปนมาตรฐานที่เปดเผย ทําใหบริษัทตางๆ สามารถที่จะพัฒนา JVM
ขึ้นมาเองได โดยไมจํากัดอยูเพียง JVM ของบริษัทซันไมโครซิสเต็มสเทานั้น

รูปที่ 1.5 ขั้นตอนการทํางานของโปรแกรมภาษาจาวา

Java Programming 11
 JVM ที่พัฒนามาใชในปจจุบันสวนใหญจะเปนซอฟตแวร แตก็ไดมีการพัฒนา JVM
ในรูปแบบของฮารดแวรขึ้นมาบางแลวเชน Java Chip ในปจจุบัน JVM มีใชในระบบ
ปฏิบัติการคอมพิวเตอรตางๆ โปรแกรมเว็บบราวเซอร เครื่องใชไฟฟาตางๆ โทรศัพท
เครื่องมือสื่อสารตางๆ และสมารทการด (smart card) จึงทําใหอุปกรณตางๆเหลานี้สามารถ
ประมวลผลโปรแกรมที่พัฒนาโดยใชภาษาจาวาได

1.6.2 Java Runtime Environment

JRE จะรันโปรแกรมไบทโคดที่แปลมาจาก JVM โดยจะมีขั้นตอนการทํางานสาม
ขั้นตอนดังแสดงในรูปที่ 1.6 คือ
1. โหลดโปรแกรมไบทโคด ขั้นตอนนี้จะเปนการโหลดคลาสทุกคลาสที่จําเปนตอ
การรันโปรแกรม โดยใช Class Loader
2. ตรวจสอบโปรแกรมไบทโคด ขั้นตอนนี้เปนการตรวจสอบโดยใช Byte Code
Verifier วาโปรแกรมไบทโคดถูกตองตามขอกําหนดของ JVM หรือไม และ
โปรแกรมจะตองไมมีคําสั่งใดที่สั่งงานแลวจะทําใหเกิดขอผิดพลาดกับระบบ เชน
การแปลงขอมูลที่ผิดพลาด หรือการพยายามบุกรุกเขาสูระบบภายใน
3. รันโปรแกรมไบทโคด ขั้นตอนนี้จะเปนการรันโปรแกรมไบทโคด โดยใช Runtime
Interpreter

รูปที่ 1.6 ขั้นตอนการทํางานของ JRE

12 คณะเทคโนโลยีสารสนเทศ สถาบันเทคโนโลยีพระจอมเกลาเจาคุณทหารลาดกระบัง
1.6.3 Java 2 Software Development Kit
Java 2 SDK คือชุดพัฒนาโปรแกรมภาษาจาวาของบริษัทซันไมโครซิสเต็มส ซึ่งแต
เดิมเรียกวา JDK ทั้งนี้บริษัทซันไมโครซิสเต็มสไดเปลี่ยนชื่อมาเปน Java 2 ตั้งแต JDK
เวอรชั่น 1.2 ชุดโปรแกรม Java 2 SDK ที่ใชในปจจุบันคือเวอรชั่น 5.0 (สามารถ download
ไดที่ http://java.sun.com) จะประกอบไปดวยโปรแกรมตางๆอาทิเชน โปรแกรมคอมไพเลอร
(javac.exe) โปรแกรมอินเตอรพรีตเตอร (java.exe) และโปรแกรมดีบักเกอร เปนตน
แตชุดโปรแกรม Java 2 SDK จะไมใชโปรแกรม IDE (Integrated Development
Environment) ที่สมบูรณ เนื่องจากชุดโปรแกรมนี้จะไมมีโปรแกรมอีดิเตอรสําหรับการเขียน
ซอรดโคด ดังนั้นผูใชจะตองใชโปรแกรมอื่นชวยในการเขียนซอรดโคด
นอกจากนี้โปรแกรมที่อยูใน Java 2 SDK จะเปนโปรแกรมที่ตองเรียกใชงานผานทาง
command line จึงไมสะดวกในการใชงาน แตก็มีขอดีตรงที่ทําใหผูที่เริ่มตนในการพัฒนา
โปรแกรมสามารถเขาใจขั้นตอนตางๆของการพัฒนาโปรแกรมโดยใชภาษาจาวาไดดีขึ้น โดย
ไมมุงเนนการใชเครื่องมือหรือคําสั่งตางๆ ที่มีอยูในชุดพัฒนาโปรแกรมภาษาจาวาโปรแกรม
อื่นๆ
นอกจากชุดพัฒนาโปรแกรม Java 2 SDK แลวในปจจุบันยังมีชุดพัฒนาโปรแกรม
ภาษาจาวาที่เปนโปรแกรมแบบ IDE ทั้งที่เปนฟรีแวร (freeware) หรือโปรแกรมเพื่อการคา
(commercial software) ออกมาหลายโปรแกรมอาทิเชน
• Netbeans ของบริษัท Sun Microsystems (http://www.netbeans.org)
• Eclipse ของบริษัท IBM (http://eclipse.org)
• JBuilder ของบริษัท Borland (http://www.borland.com/jbuilder)
• JDeveloper ของบริษัท Oracle (http://www.oracle.com)
• intelliJ IDEA ของบริษัท JetBrains (http://www.jetbrains.com/idea)
โปรแกรม IDE เหลานี้จะมีเครื่องมือเพื่อชวยในการสรางโปรแกรมภาษาจาวาใน
รูปแบบตางๆไดงายขึ้นอาทิเชน เครื่องมือชวยในการออกแบบโปรแกรมกราฟฟก
สําหรับชุดพัฒนาโปรแกรม Java 2 SDK นั้นจําเปนตองมีโปรแกรมอิดีเตอรเพื่อใชใน
การเขียนซอรดโคดของโปรแกรมภาษาจาวา ซึ่งสามารถที่จะใชโปรแกรม Text Editor ทั่วไป
ไดเชน โปรแกรม Notepad ในระบบปฏิบัติการ Windows แตหากตองการพัฒนาโปรแกรมให
เร็วขึ้น ผูใ ชควรเลือกใชโปรแกรมอิดีเตอรที่ออกแบบมาเพื่อเขียนซอรดโคดของโปรแกรม
ภาษาจาวาโดยเฉพาะ ซึ่งโปรแกรมเหลานี้จะทํางานคลายกับโปรแกรมแบบ IDE โดยผูใช

Java Programming 13
 สามารถเรียกคําสั่งในการคอมไพล หรือการรันโปรแกรมที่พัฒนาขึ้นจากเมนูที่กําหนดไวได
ตัวอยางโปรแกรมอิดีเตอรแบบนี้คือ
• EditPlus ของบริษัท ES-Computing (http://www.editplus.com)
• JCreator ของบริษัท Xinox Software (http://www.jcreator.com)

1.6.4 จุดเดนของภาษาจาวา
บริษัทซันไมโครซิสเต็มสไดระบุถึงจุดเดนของภาษาจาวาไวดังนี้
• ความงาย (simple) ภาษาจาวาเปนภาษาที่งายตอการศึกษาและพัฒนาโปรแกรม
ทั้งนี้เพราะภาษาจาวาพัฒนาโดยตัดขอดอยของภาษา C++ ออกไปอาทิเชน เรื่อง
ของการใช pointer
• ภาษาเชิงออปเจ็ค (object oriented) ภาษาจาวาเปนภาษาคอมพิวเตอรเชิง
ออปเจ็คที่สมบูรณโดยมีคุณลักษณะเดนของโปรแกรมเชิงออปเจ็คคือ การสืบทอด
การหอหุม และการมีไดหลายรูปแบบ
• การกระจาย (distributed) ภาษาจาวามีชุดคําสั่งที่เปนแพคเก็จ (package) ในการ
จัดการกับโปรโตคอล TCP/IP ทําใหสามารถพัฒนาโปรแกรมเชิงออปเจ็คแบบ
กระจาย (distributed object) ผานระบบเครือขายอินเตอรเน็ตไดงาย
• การปองกันการผิดพลาด (robust) ภาษาจาวาเปนภาษาคอมพิวเตอรที่ออกแบบ
มาเพื่อใหโปรแกรมที่พัฒนาขึ้นมีความนาเชื่อถือ โดยมีการตรวจสอบการ
ผิดพลาดที่อาจเกิดขึ้นในขั้นตอนตางๆเชน ขั้นตอนการคอมไพล และการรัน
โปรแกรม เปนตน
• ความปลอดภัย (secure) ภาษาจาวาออกแบบมาเพื่อพัฒนาโปรแกรมบนระบบ
เครือขาย และมีการกระจายการทํางานบนระบบเครือขายอินเตอรเน็ต ดังนั้นจึง
ตองสรางระบบปองกันความปลอดภัยจากไวรัสคอมพิวเตอร และการแกไข
โปรแกรมจากภายนอก
• สถาปตยกรรมกลาง (architecture neutral) โปรแกรมภาษาจาวาจะคอมไพลได
โปรแกรมไบทโคด (byte code) ซึ่งสามารถทํางานบนสถาปตยกรรมคอมพิวเตอร
ที่มีหนวยประมวลผลกลางและระบบปฏิบัติการตางๆได

14 คณะเทคโนโลยีสารสนเทศ สถาบันเทคโนโลยีพระจอมเกลาเจาคุณทหารลาดกระบัง
 • เคลื่อนยายงาย (portable) ขอกําหนดของภาษาจาวาจะไมขึ้นอยูกับระบบ
คอมพิวเตอรใดโดยเฉพาะ ดังนั้นโปรแกรมภาษาจาวาจึงสามารถประมวลผลได
กับระบบคอมพิวเตอรทุกประเภท
• อินเตอรพรีต (interpreted) ภาษาจาวาจะใชอินเตอรพรีตเตอรในการแปล
โปรแกรมไบทโคดใหเปนภาษาเครื่อง ดังนั้นจึงทําใหขบวนการการพัฒนา
โปรแกรมเปนไปไดอยางรวดเร็ว เชนเดียวกับภาษาคอมพิวเตอรอื่นๆที่ใช
อินเตอรพรีตเตอร
• ประสิทธิภาพสูง (high performance) โดยปกติโปรแกรมอินเตอรพรีตเตอรที่ทํา
หนาที่แปลโปรแกรมไบทโคดจะทํางานชา แตเทคโนโลยีจาวาไดพัฒนาใหมีการ
แปลโปรแกรมไบทโคด ในขั้นตอนการรันโปรแกรมใหเปนภาษาเครื่องแบบทันที
ทันใด (Just In Time) ที่ทํางานไดรวดเร็วเทียบเทากับคอมไพเลอร เพื่อได
โปรแกรมจาวาที่มีประสิทธิภาพในการประมวลผลสูง
• มัลติเธรด (multithreaded) ภาษาจาวามีความสามารถที่จะประมวลผลหลายๆงาน
ไดพรอมกัน
• พลวัต (dynamic) ภาษาจาวาออกแบบมาเพื่อที่จะใหปรับเปลี่ยนเพิ่มเติมไลบารี่
(library) ตางๆไดงาย ซึ่งแตกตางจากภาษาซี หรือ C++

1.7 แพลตฟอรมของเทคโนโลยีจาวา
แพลตฟอรม (Platform) คือฮารดแวรและสภาวะแวดลอมทางซอฟตแวร (Software
Environment) ที่โปรแกรมจะใชในการประมวลผลโดยทั่วไป
แพลตฟอรมจะนิยามโดยพิจารณาจากองคประกอบของฮารดแวรและระบบปฏิบัติการ
ที่ใชเชน แพลตฟอรมของระบบปฏิบัติการ Windows XP บนเครื่องไมโครคอมพิวเตอร
Pentium IV แตนิยามของแพลตฟอรมสําหรับเทคโนโลยีจาวาจะแตกตางจากนิยามที่ใชกัน
ทั่วไป ทั้งนี้จะพิจารณาจากองคประกอบของซอฟตแวรเทานั้นดังแสดงในรูปที่ 1.7 ซึ่ง
แพลตฟอรมของเทคโนโลยีจาวาจะประกอบดวย
• Java Virtual Machine (JVM)
• Java Application Programming Interface (Java API)

Java Programming 15
 รูปที่ 1.7 แพลตฟอรมของเทคโนโลยีจาวา

โดยที่ JVM จะเปนสวนฐานของแพลตฟอรมเพื่อใชในการติดตอกับแพลตฟอรมสวน

ที่เปนฮารดแวร สวน Java API เปนชุดแพคเก็จที่รวบรวมคลาสและอินเตอรเฟสตางๆที่เปน
ประโยชนตอการใชงานของโปรแกรมที่พัฒนาโดยภาษาจาวาเชน คลาสที่เกี่ยวของกับการ
ติดตอกับผูใชแบบกราฟฟก (Graphical User Interface) เปนตน
บริษัทซันไมโครซิสเต็มสไดกําหนดแพลตฟอรมของ Java 2 ใหมีสามรูปแบบคือ
1. Java 2 Platform, Standard Edition (J2SE)
2. Java 2 Platform, Enterprise Edition (J2EE)
3. Java 2 Platform, Micro Edition (J2ME)
โดยแตละแพลตฟอรมจะมี JVM และ API ที่แตกตางกัน และมุงเนนที่จะใชในการ
พัฒนาโปรแกรมภาษาจาวา สําหรับระบบคอมพิวเตอรหรืออุปกรณที่แตกตางกัน ดังแสดง
ในรูปที่ 1.8

รูปที่ 1.8 แพลตฟอรมของ Java 2 ในรูปแบบตางๆ

16 คณะเทคโนโลยีสารสนเทศ สถาบันเทคโนโลยีพระจอมเกลาเจาคุณทหารลาดกระบัง
 โปรแกรมจาวาที่ใชบนเครื่องไมโครคอมพิวเตอรโดยทั่วไป จะใชแพลตฟอรมที่เปน
J2SE สวนแพลตฟอรม J2EE มุงเนนการพัฒนาโปรแกรมภาษาจาวาที่ใชงานบนเครื่อง
แมขาย (Server) สําหรับระบบงานในองคกร (Enterprise) และแพลตฟอรม J2ME ใชในการ
พัฒนาโปรแกรมจาวาบนอุปกรณขนาดเล็ก เชน โทรศัพทเคลื่อนที่ หรือ PDA เปนตน

1.7.1 Java 2 Platform, Standard Edition

แพลตฟอรม J2SE เปนแพลตฟอรมจาวาที่ใชในการพัฒนาโปรแกรมภาษาจาวาเพื่อ
ใชงานกับเครื่องคอมพิวเตอรที่เปนเครื่องลูกขาย (client) Virtual Machine ที่กําหนดไวใน
แพลตฟอรมนี้คือ JVM และมี Java API ที่กําหนดไวตางๆอาทิเชน java.lang,
java.util, java.io และ java.net ดังแสดงในรูปที่ 1.9

แพลตฟอรม J2SE ใชในการพัฒนาโปรแกรมจาวาที่ใชในเครื่องคอมพิวเตอรลูกขาย

โดยแบงออกเปน 2 ประเภท คือ
• โปรแกรมจาวาประยุกต (Java Application) คือ โปรแกรมที่ใชงานทั่วไป
• โปรแกรมจาวาแอปเพล็ต (Java Applet) คือโปรแกรมภาษาจาวาที่รันบนเว็บ
บราวเซอร
เวอรชั่นลาสุดของ J2SE คือเวอรชั่น 5.0 ซึ่งผูใชสามารถ download ไดฟรีทาง
เว็บไซตที่ชื่อ java.sun.com

รูปที่ 1.9 Java API ในแพลตฟอรม J2SE

Java Programming 17
 1.7.2 Java 2 Platform, Enterprise Edition
แพลตฟอรมจาวารุนนี้ มีจุดประสงคเพื่อใชพัฒนาโปรแกรมภาษาจาวาสําหรับเครื่อง
แมขาย (Server) โดยมุงเนนการพัฒนาโปรแกรมที่เปน N-tier สําหรับงานในองคกร โดยใช
โปรแกรม Application Server หรือโปรแกรมสําหรับแมขายเว็บ (Web Server) ที่เรียกวา
โปรแกรมจาวาแบบ Servlet โปรแกรม Application Server เปนโปรแกรมที่ชวยในการพัฒนา
โปรแกรมภาษาจาวาที่สามารถเปลี่ยนแปลง แกไข และนํากลับมาใชใหมไดงาย โดยพัฒนา
เปนสวนประกอบออปเจ็ค (object component) ที่เรียกวา Enterprise Java Bean (EJB)
Application Server ที่ใชกับภาษาจาวาในปจจุบันมีทั้งโปรแกรมที่เปน open source อาทิเชน
JBoss หรือ Enhydra และโปรแกรมเพื่อการคา เชน WebLogic หรือ WebSphere
แพลตฟอรม J2EE เวอรชั่น 1.4 ซึ่งประกอบไปดวย API ดังแสดงในรูปที่ 1.10
โดยมีสวนตางๆที่สําคัญดังนี้
• JNDI API
JNDI ยอมาจาก Java Naming and Directory Interface เปน API เพื่อใชใน
การจัดการ directory service เชน LDAP server และระบบไฟล
• JavaMail API
เปน API ที่ใชในการพัฒนาโปรแกรมสําหรับสงขาวสารและอีเมลบนระบบ
อินเตอรเน็ต โดยใชโปรโตคอลตางๆ อาทิเชน SMTP และ POP3
• CORBA API
เปน API เพื่อสนับสนุนการใชงาน JavaIDL และ RMI-IIOP ซึ่งเปน
ซอฟตแวรสําหรับระบบออปเจ็คแบบกระจาย (Object Distributed System) ตาม
มาตรฐาน CORBA
• Java Transaction API
เปน API เพื่อใชในการจัดการ Transaction
• XML API
เปน API ที่สนับสนุนการจัดการขอมูลในรูปแบบของ XML
• JMS API
JMS ยอมาจาก Java Message Service เปน API เพื่อใชในการสงหรือรับ
ขาวสารแบบ asynchronous

18 คณะเทคโนโลยีสารสนเทศ สถาบันเทคโนโลยีพระจอมเกลาเจาคุณทหารลาดกระบัง
 รูปที่ 1.10 Java API ในแพลตฟอรม J2EE

1.7.3 Java 2 Platform, Micro Edition

แพลตฟอรม J2ME เปนแพลตฟอรมจาวาที่ใชในการพัฒนาโปรแกรมภาษาจาวา
เพื่อใชงานกับอุปกรณไฟฟา และเครื่องมือสื่อสารตางๆอาทิเชน โทรศัพทมือถือ หรือ PDA
(Personal Digital Assistant) เปนตน แพลตฟอรม J2ME จะใช Virtual Machine ที่มีขนาด
เล็กกวา JVM ที่ใชในเครื่องคอมพิวเตอรทั่วไป ทั้งนี้เนื่องจากอุปกรณเหลานั้นจะมีหนวย
ความจํานอยกวา และจะมีหนวยประมวลผลกลางที่มีความเร็วชากวา
Java API ที่ใชในแพลตฟอรม J2ME จะแบงออกเปน Configuration และ Profile
ทั้งนี้ขึ้นอยูกับอุปกรณที่จะนําโปรแกรมภาษาจาวาไปใชงานดังแสดงในรูปที่ 1.11 ตัวอยางเชน
โปรแกรมภาษาจาวาบนโทรศัพทมือถือจะตองรันโดยใช KVM และมี Configuration ที่เปน
CLDC รวมกับ Profile ที่เปน MIDP เปนตน

Java Programming 19
 รูปที่ 1.11 Java API ในแพลตฟอรม J2ME

1.8 โปรแกรมภาษาจาวา
โปรแกรมจาวาที่อยูบนแพลตฟอรม J2SE สามารถพัฒนาไดสองรูปแบบคือ
1. โปรแกรมจาวาประยุกต (Java Application) คือโปรแกรมประยุกตใชงานทั่วไป
โดยโปรแกรมแบบนี้จะทํางานภายใตโปรแกรมอินเตอรพรีตเตอรโดยตรง ซึ่ง
โปรแกรมลักษณะนี้เปน stand-alone
2. โปรแกรมจาวาแอปเพล็ต (Java Applet) คือโปรแกรมภาษาจาวาที่จะทํางาน
ภายใตโปรแกรมเว็บบราวเซอรที่มี JVM อยู

1.8.1 การสรางโปรแกรมจาวาประยุกต
การสรางโปรแกรมจาวาประยุกตจะมีขั้นตอนดังแสดงในรูปที่ 1.12 ซึ่งสามารถอธิบาย
พอสังเขปไดดังนี้
1. ขั้นตอนแรกจะเปนการเขียนซอรดโคดโดยใชโปรแกรมอิดีเตอรใดๆ โปรแกรมที่
1.1 เปนตัวอยางโปรแกรมเพื่อพิมพขอความ Hello World ออกทางจอภาพ
โปรแกรมนี้ใชชอื่ คลาสวา HelloWorld ซึ่งผูเขียนโปรแกรมจะตองเขียน

20 คณะเทคโนโลยีสารสนเทศ สถาบันเทคโนโลยีพระจอมเกลาเจาคุณทหารลาดกระบัง
 ซอรดโคดแลวเก็บลงในไฟลที่มีชื่อเดียวกับชื่อคลาส โดยมี extension เปน
.java กลาวคือโปรแกรมนี้จะเก็บไวในชื่อ HelloWorld.java โปรแกรมนี้
จะมี เมธอด main()เปนจุดเริ่มตน
2. ขั้นตอนที่สองจะเปนการคอมไพลโปรแกรม เพื่อแปลโปรแกรมซอรดโคดใหอยูใน
รูปของโปรแกรมไบทโคด ชุดพัฒนาโปรแกรม Java 2 SDK จะมีโปรแกรมชื่อ
javac.exe ที่ทําหนาที่เปนคอมไพลเลอร ซึ่งในตัวอยางนี้สามารถทําการ
คอมไพลโปรแกรมโดยใชคําสั่งตอไปนี้
javac HelloWorld.java
ผลลัพธที่ไดจากการคอมไพลโปรแกรมนี้คือ โปรแกรมไบทโคดที่ชื่อ
HelloWorld.class ในกรณีที่โปรแกรมซอรดโคดมีขอผิดพลาด
คอมไพเลอรจะระบุขอผิดพลาดที่เกิดขึ้น เพื่อใหผูเขียนโปรแกรมทําการแกไข
โปรแกรมซอรดโคดกอนที่จะทําการคอมไพลโปรแกรมใหม
3. ขั้นตอนการประมวลผลหรือรันโปรแกรม เปนการเรียกใชอินเตอรพรีตเตอรเพื่อ
แปลโปรแกรมไบทโคด ชุดพัฒนาโปรแกรม Java 2 SDK จะมีโปรแกรมชื่อ
java.exe ที่ทําหนาที่เปนโปรแกรมอินเตอรพรีตเตอร ซึ่งในตัวอยางนี้จะสามารถ
รันโปรแกรมไบทโคดไดโดยใชคําสั่งตอไปนี้
java HelloWorld
โดยโปรแกรมจะใหผลลัพธดังแสดงในรูปที่ 1.13

โปรแกรมที่ 1.1 เปนโปรแกรมเพื่อพิมพขอความ Hello World

public class HelloWorld {
public static void main(String args[]){
System.out.println("Hello World");
}
}

Java Programming 21
 รูปที่ 1.12 ขั้นตอนการสรางโปรแกรมจาวาประยุกต

รูปที่ 1.13 ขั้นตอนในการคอมไพลและผลลัพธที่ไดจากการรันโปรแกรมที่ 1.1

1.8.2 การสรางโปรแกรมจาวาแอปเพล็ต
การสรางโปรแกรมจาวาแอปเพล็ต จะมีขนั้ ตอนคลายกับการสรางโปรแกรมจาวา
ประยุกต แตโปรแกรมจาวาแอปเพล็ตจะประกอบดวยไฟลที่เขียนขึ้นสองไฟลคือ
• โปรแกรมซอรดโคด (.java)
• โปรแกรมเว็บเพจ (.html)
โปรแกรมที่ 1.2 เปนตัวอยางของโปรแกรมจาวาแอปเพล็ตเพื่อแสดงขอความ Hello
World โปรแกรมนี้จะแตกตางจากโปรแกรมจาวาประยุกตตรงที่ไมมีเมธอด main() และจะ
ไมสามารถทํางานตามลําพังได แตจะตองเรียกใชโดยผานโปรแกรมภาษา HTML ตัวอยางเชน
โปรแกรมที่ 1.3 เปนโปรแกรมภาษา HTML ที่เรียกใชโปรแกรม
HelloWorldApplet.class เพื่อประมวลผลภายใตโปรแกรมเว็บบราวเซอรที่มี JVM
อยู ขั้นตอนการสรางโปรแกรมนี้มีดังนี้

22 คณะเทคโนโลยีสารสนเทศ สถาบันเทคโนโลยีพระจอมเกลาเจาคุณทหารลาดกระบัง
โปรแกรมที่ 1.2 โปรแกรมจาวาแอปเพล็ตเพื่อพิมพขอความ Hello World

import java.awt.*;
import java.applet.*;

public class HelloWorldApplet extends Applet {

public void paint(Graphics g) {
g.drawString("Hello World",20,20);
}
}

โปรแกรมที่ 1.3 โปรแกรมภาษา HTML ที่เรียกใช HelloWorldApplet.class

<HTML>
<HEAD>
<TITLE>HelloWorld Example</TITLE>
</HEAD>
<BODY>
<APPLET CODE=”HelloWorldApplet.class”
WIDTH=”300” HEIGHT=”300”>
</APPLET>
</BODY>
</HTML>

รูปที่ 1.14 ขั้นตอนการสรางโปรแกรมจาวาแอปเพล็ต

Java Programming 23
 1. เขียนโปรแกรมซอรดโคด (HelloWorldApplet.java) และโปรแกรม
เว็บเพจ (HelloWord.html) โดยใชโปรแกรมอิดีเตอรใดๆ
2. คอมไพลโปรแกรม HelloWorldApplet.java โดยใชคอมไพเลอรดังนี้
javac HelloWorldApplet.java
ตัวอยางนี้จะไดโปรแกรมไบทโคดที่ชื่อ HelloWorldApplet.class
3. ใชโปรแกรมเว็บบราวเซอรใดๆเชน Internet Explorer หรือ Netscape เปด
โปรแกรมเว็บเพจที่ชื่อ HelloWorld.html ซึ่งจะเรียกโปรแกรมไบทโคดที่
ชื่อ HelloWorldApplet.class โดยอัตโนมัติและจะมีผลรันดังรูปที่ 1.15

รูปที่ 1.15 ผลลัพธที่ไดจากการรันโปรแกรมที่ 1.3 บนเว็บบราวเซอร

1.9 คูมือ Java API

Java API เปนขอกําหนดที่วาดวยคลาสและอินเตอรเฟสตางๆที่กําหนดไวในแพคเก็จ
มาตราฐานของภาษาจาวา แพคเก็จจะเปนที่รวบรวมคลาสและอินเตอรเฟสตางๆ ที่มีหนาที่การ

24 คณะเทคโนโลยีสารสนเทศ สถาบันเทคโนโลยีพระจอมเกลาเจาคุณทหารลาดกระบัง
ทํางานคลายกันไวในที่เดียวกัน Java API มีแพคเก็จที่สําคัญอยูหลายแพคเก็จอาทิเชน
java.lang, java.util, java.awt และ java.io เปนตน

เนื่องจาก Java API มีแพคเก็จและคลาสตางๆอยูเปนจํานวนมาก จึงเปนเรื่องยากใน

การที่จะจดจําคลาสและเมธอดตางๆ ทั้งหมดที่มีอยู ชุดพัฒนาโปรแกรม Java 2 SDK จะมีไฟล
คูมือ Java API ที่อยูในรูปของไฟล HTML ดังแสดงในรูปที่ 1.16 ซึ่งคูมือ Java API จะ
ประกอบไปดวยเฟรมสามเฟรมคือ สวนที่เปนชื่อแพคเก็จ (มุมบนซาย) สวนที่เปนชื่อคลาส
และอินเตอรเฟสตางๆของแพคเก็จ (มุมลางซาย) และสวนที่เปนรายละเอียดของคลาสหรือ
อินเตอรเฟส (ตรงกลาง) ซึ่งรูปที่ 1.16 แสดงคูมือ Java API ที่ระบุคลาสและอินเตอรเฟสตางๆ
ในแพคเก็จ java.lang และเฟรมหลักตรงกลางแสดงรายละเอียดของคลาส String
คูมือ Java API จะแสดงรายละเอียดตางๆของคลาสหรืออินเตอรเฟสดังนี้
• ลําดับการสืบทอดของคลาส
• คําอธิบายเกี่ยวกับคลาสและจุดประสงคทั่วไป
• รายชื่อคุณลักษณะตางๆ ของคลาส
• รายชื่อเมธอดตางๆ ของคลาส
• รายชื่อ Constructor ตางๆ ของคลาส
• คําอธิบายรายละเอียดของคุณลักษณะแตละตัวของคลาส
• คําอธิบายรายละเอียดของเมธอดแตละตัวของคลาส
• คําอธิบายรายละเอียดของConstructor แตละตัวของคลาส

Java Programming 25
 รูปที่ 1.16 คูมือ Java API

สรุปเนื้อหาของบท
• ระบบคอมพิวเตอรประกอบไปดวยสวนหลักสามสวนคือ ฮารดแวร ระบบปฏิบัติ
การ และโปรแกรมประยุกต
• ภาษาคอมพิวเตอรแบงออกเปนสามประเภทคือ ภาษาเครื่อง ภาษาแอสเซมบลี
และภาษาระดับสูง
• ภาษาระดับสูงแบงออกเปนสองประเภทคือ ภาษาเชิงกระบวนการ และภาษาเชิง
ออปเจ็ค
• ตัวแปลภาษาแบงออกเปนสองแบบคือ คอมไพเลอร และอินเตอรพรีตเตอร

26 คณะเทคโนโลยีสารสนเทศ สถาบันเทคโนโลยีพระจอมเกลาเจาคุณทหารลาดกระบัง
• ภาษาจาวาเปนภาษาเชิงออปเจ็คที่ใชทั้งตัวแปลภาษาแบบคอมไพเลอรและ
อินเตอรพรีตเตอรในการคอมไพลและรันโปรแกรม
• คอมไพเลอรของภาษาจาวาจะทําหนาที่แปลโปรแกรมภาษาจาวาใหเปนโปรแกรม
ไบทโคด และจะใชจาวาอินเตอรพรีตเตอร (JVM) ในการแปลโปรแกรมไบทโคด
ใหเปนภาษาเครื่อง
• โปรแกรมภาษาจาวาสามารถทํางานขามแพลตฟอรมได ถาระบบคอมพิวเตอรนั้น
มี JVM อยู
• แพลตฟอรมของ Java ประกอบไปดวย JVM และ Java API ซึ่ง Java 2 มี
แพลตฟอรม 3 แบบคือ J2SE, J2EE และ J2ME
• ชุดพัฒนาโปรแกรมภาษาจาวา Java 2 SDK ประกอบไปดวยโปรแกรมตางๆที่
สําคัญคือ โปรแกรมคอมไพเลอร (javac.exe) และโปรแกรมอินเตอรพรีตเตอร
(java.exe)
• โปรแกรมจาวาที่อยูบนแพลตฟอรม J2SE สามารถพัฒนาไดสองรูปแบบคือ
โปรแกรมจาวาประยุกตซึ่งจะทํางานภายใต JVM โดยตรง และโปรแกรมจาวา
แอปเพล็ตซึ่งจะทํางานภายใตเว็บบราวเซอรที่มี JVM
• คูมือ Java API จะชวยในการคนหารายละเอียดของแพคเก็จและคลาสตางๆที่มี
อยูในชุดพัฒนาโปรแกรม Java 2 SDK

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

2.1 ไวยากรณระดับของคํา
คําหรือขอความที่สามารถเขียนในโปรแกรมภาษาจาวา จะตองเปนคําหรือขอความใน
รูปแบบใดรูปแบบหนึ่งของประเภทตางๆเหลานี้
• คอมเม็นต (comment)
• identifier
• คียเวิรด (keyword)
• สัญลักษณแยกคํา (separator)
• ชองวาง (whitespace)
• ขอมูลคาคงที่ (literals)

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

Java Programming 29
 ภาษาจาวากําหนดรูปแบบของการเขียนคอมเม็นตไวสามรูปแบบดังนี้
1. คอมเม็นตสําหรับขอความบรรทัดเดียว จะใชเครื่องหมาย // นําหนาขอความที่
ตองการเขียน ซึ่งจะอยูสวนไหนของบรรทัดก็ได
2. คอมเม็นตสําหรับขอความตั้งแตหนึ่งบรรทัดขึ้นไป จะเริ่มตนดวยเครื่องหมาย /*
และสิ้นสุดดวยเครื่องหมาย */
3. คอมเม็นตสําหรับขอความที่ตองการสรางเปนไฟลเอกสาร ที่เปนไฟลประเภท
HTML จะเริ่มตนดวยเครื่องหมาย /** และสิ้นสุดดวยเครื่องหมาย */ คอมเม็นต
รูปแบบนี้สามารถสรางเปนไฟลเอกสารไดโดยใชโปรแกรม javadoc.exe

โปรแกรมที่ 2.1 แสดงการเขียนคอมเม็นตในรูปแบบตางๆ

/* This program is to show

how to write comments */
public class CommentDemo {
// Main method
public static void main(String args[]) {
/** This is a comment for documentation */
System.out.println("Document");
}
}

2.1.2 Identifier
identifier คือชื่อที่ตั้งขึ้นในภาษาจาวา ซึ่งอาจเปนชื่อของคลาส ชื่อของตัวแปร ชื่อของ
เมธอด หรือชื่อของคาคงที่ ซึ่งจะตองเปนไปตามกฎการตั้งชื่อ ดังนี้
• identifier จะตองขึ้นตนดวยอักขระ A-Z, a-z, _ หรือ $ เทานั้น
• identifier ที่ประกอบไปดวยตัวอักขระมากกวาหนึ่งตัว ตัวอักขระหลังจากตัวแรก
นั้นจะตองเปนตัวอักขระขางตน หรือเปนตัวเลข 0 ถึง 9 เทานั้น
• identifier จะตองไมตรงกับคียเวิรด
identifier ในภาษาจาวาจะถือวาตัวอักษรพิมพใหญและตัวอักษรพิมพเล็กตางกัน
(case sensitive) ดังนั้น identifier ที่ชื่อ myVariable จะแตกตางจาก MyVariable
ตัวอยางของ identifier ที่ถูกตอง

30 คณะเทคโนโลยีสารสนเทศ สถาบันเทคโนโลยีพระจอมเกลาเจาคุณทหารลาดกระบัง
 • MyVariable
• _MyVariable
• $x
• This_is_also_a_variable
ตัวอยางของ identifier ที่ไมถูกตอง
• My Variable

• 9pns

• a+c

• Hello’World

• public

หลักการตั้งชือ่ ที่นิยมปฏิบตั ิกันโดยทัว่ ไป

แนวทางปฏิบัติที่ใชในการตั้งชื่อจะมีขอกําหนดดังนี้
• การตั้งชื่อคลาส
– จะขึ้นตนดวยตัวอักษรพิมพใหญแลวตามดวยตัวอักษรพิมพเล็ก หรือตัวเลข
โดยจะใชตัวอักษรพิมพใหญสําหรับอักษรนําของแตละคําที่ตามมาในชื่อ
– ควรเปนคํานาม
– ตัวอยางเชน Sample, HelloWorld, Student หรือ
GraduateStudent เปนตน
• การตั้งชื่อตัวแปร
– จะขึ้นตนดวยตัวอักษรพิมพเล็ก โดยจะใชตัวอักษรพิมพใหญสําหรับ
อักษรนําของแตละคําที่ตามมาในชื่อ
– ควรเปนคํานามหรือเปนชื่อสั้นๆ
– ตัวอยางเชน x, id, name หรือ thesisTitle เปนตน
• การตั้งชื่อเมธอด
– จะใชหลักการเดียวกับการตั้งชื่อตัวแปร แตควรเปนคํากริยา

Java Programming 31
 – ตัวอยางเชน getName, setName หรือ showDetails เปนตน
• การตั้งชื่อคาคงที่
– จะใชตัวอักษรพิมพใหญทั้งหมด และจะแยกคําโดยใชเครื่องหมาย_
(underscore)
– ควรเปนคํานาม
– ตัวอยางเชน MINIMUM, MIN_GPA เปนตน

2.1.3 คียเวิรด
คียเวิรดคือชื่อที่มีความหมายพิเศษในภาษาจาวา คอมไพเลอรของภาษาจาวาจะ
เขาใจความหมายและคําสั่งที่จะตองดําเนินการสําหรับคียเวิรดแตละตัว ภาษาจาวาไดกําหนด
คียเวิรดตางๆ ไวดังแสดงในตารางที่ 2.1

ตารางที่ 2.1 คียเวิรดที่ใชในภาษาจาวา

abstract continue for new switch

assert default goto package synchronied

boolean do if private this

break double implements protected throw

byte else import public throws

case enum instanceof return transient

catch extends int short try

char final interface static void

class finally long strictfp volatile

const float native super while

คียเวิรดเหลานี้ไมสามารถจะนํามาตั้งเปน identifier ได ซึ่งจากคียเวิรดขางตนจะเห็น

วาคียเวิรดทุกตัวจะเปนตัวอักษรพิมพเล็ก และจะมีคียเวิรด goto และ const เปนคียเวิรดที่
ไมไดตรงกับคําสั่งใดในภาษาจาวา สวนคําวา true และ false ไมไดเปนคียเวิรดในภาษา

32 คณะเทคโนโลยีสารสนเทศ สถาบันเทคโนโลยีพระจอมเกลาเจาคุณทหารลาดกระบัง
จาวาแตจะเปนขอมูลคาคงที่ชนิดตรรกะ เชนเดียวกับคําวา null ซึ่งเปนขอมูลคาคงที่ของ
ตัวแปรที่มีชนิดขอมูลแบบอางอิงที่จะกลาวถึงตอไป

2.1.4 สัญลักษณแยกคํา
ภาษาจาวามีสัญลักษณแยกคําตางๆ ที่สามารถนําไปใชเขียนในโปรแกรมไดดังตาราง
ที่ 2.2
ตารางที่ 2.2 หนาที่ของเครื่องหมายตางๆที่ใชในภาษาจาวา

สัญลักษณแยกคํา หนาที่

; เพื่อระบุการสิ้นสุดของคําสั่งตางๆ ภายในภาษาจาวา
สําหรับตอทายเมธอดหรือคําสั่งอื่นๆในภาษาจาวา เชน if,for
()
เปนตน
, สําหรับแยกตัวแปรหรือคําสั่งในภาษาจาวา
เพื่อใชในการระบุคุณลักษณะหรือเมธอดของออปเจ็ค หรือใชใน
.
การระบุแพคเก็จของภาษาจาวา
เพื่อระบุบล็อกคําสั่งของภาษาจาวา คําสั่งตางๆของภาษาจาวา
จะอยูภายในบล็อกอาทิเชน คําสั่งที่อยูภายในคลาส ภายใน
{} เมธอด หรืออยูภายในชุดคําสั่งโครงสรางควบคุมตางๆ เชน
if,while หรือ for เปนตน โดยปกติบล็อกเหลานี้สามารถ
ซอนกันได

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

Java Programming 33
 • แท็ป (กดคีย Tab บนคียบอรด)
• การขึ้นบรรทัดใหม (กดคีย Enter บนคียบอรด)

2.1.6 ขอมูลคาคงที่
ขอมูลคาคงที่คือคําที่ใชแสดงขอมูลที่เปนตัวเลข ตัวอักขระ ขอความ หรือคาทาง
ตรรกะ ซึ่งในภาษาจาวาไดกําหนดขอมูลคาคงที่ไว 5 ประเภทดังนี้
1. ตรรกะ (boolean)
2. ตัวอักขระ (character)
3. ตัวเลขจํานวนเต็ม (integral)
4. ตัวเลขทศนิยม (floating point)
5. ขอความ (string)
ซึ่งรูปแบบของการเขียนขอมูลคาคงที่และประเภทของชนิดขอมูล จะกลาวถึงในหัวขอ
ตอไป

2.2 ชนิดขอมูลแบบพื้นฐาน
ภาษาจาวาเปนภาษาที่ตองระบุชนิดขอมูลอยางชัดเจน (strongly typed language)
กลาวคือขอมูลที่เปนตัวแปรหรือคาคงที่ทุกตัวที่ปรากฏอยูในโปรแกรม จะตองมีการประกาศ
และจะตองระบุชนิดขอมูลดวยเสมอ โดยชนิดขอมูลในภาษาจาวาแบงเปนสองประเภทใหญๆ
คือ
1. ชนิดขอมูลแบบพื้นฐาน (primitive data type)
2. ชนิดขอมูลแบบอางอิง (reference data type)
ชนิดขอมูลแบบพื้นฐานคือชนิดขอมูลที่กําหนดไวในภาษาจาวา ซึ่งภาษาจาวา
กําหนดไว 8 ชนิดคือ boolean, char, byte, short, int, long, float
และ double ดังแสดงในตารางที่ 2.3 ซึ่งทั้ง 8 ชนิดสามารถแบงออกไดเปน 4 ประเภทคือ
1. ชนิดขอมูลตรรกะ (logical) คือชนิด boolean
2. ชนิดขอมูลอักขระ (textual) คือชนิด char
3. ชนิดขอมูลตัวเลขจํานวนเต็ม (integral) คือชนิด byte,short,int และ
long

34 คณะเทคโนโลยีสารสนเทศ สถาบันเทคโนโลยีพระจอมเกลาเจาคุณทหารลาดกระบัง
 4. ชนิดขอมูลตัวเลขทศนิยม (floating point) คือชนิด float และ double

ตารางที่ 2.3 ขนาดและชวงคาของชนิดขอมูลแบบพื้นฐานของภาษาจาวา

ชนิดขอมูล ขนาด (บิต) ชวงคา หมายเหตุ
boolean 1 true หรือ false

char 16 ‘\u0000’ ถึง ‘\uFFFF’ ขอมูลอักขระแบบ Unicode

byte 8 -128 ถึง +127
short 16 -32,768 ถึง +32,767
int 32 -231 ถึง +231-1
long 64 -263 ถึง +263-1
IEEE 754 single precision
float 32 -3.40E+38 ถึง +3.40E+38
floating point.
IEEE 754 double precision
double 64 -1.80E+308 ถึง +1.80E+308
floating point.

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

2.2.1 ชนิดขอมูลตรรกะ
ในภาษาจาวาชนิดขอมูล boolean คือชนิดขอมูลตรรกะ โดยขอมูลชนิดตรรกะเปน
ขอมูลที่ประกอบดวยคาสองคาคือจริงและเท็จ ซึ่งตรงกับ true และ false คาคงที่หรือตัว
แปรที่มีชนิดขอมูลเปน boolean จะมีคาเปนใดคาหนึ่งภายในสองคานี้เทานั้น คําวา true
และ false แมจะไมใชคียเวิรดในภาษาจาวา แตเนื่องจากเปนคําที่สงวนไว (reserved word)
จึงไมอนุญาตใหตั้งชื่อ identifier ตรงกับคําทั้งสอง ภาษาจาวาเปนภาษาที่ตองระบุชนิดขอมูล
อยางชัดเจน ดังนั้นจึงสามารถใชชนิดขอมูล boolean ในกรณีที่ตองการคาขอมูลชนิดตรรกะ

Java Programming 35
 เทานั้นโดยไมอนุญาตใหใชชนิดขอมูลอื่นๆ ซึ่งกรณีนี้จะแตกตางจากภาษาซีหรือ C++ ที่
อนุญาตใหแปลงขอมูลชนิดตัวเลขจํานวนเต็มใหเปนขอมูลคาคงที่ชนิดตรรกะได
ตัวอยางเชน คําสั่ง
boolean flag = true;
เปนการประกาศตัวแปร flag ใหมีชนิดขอมูลเปน boolean โดยกําหนดใหมีคา
เปน true

2.2.2 ชนิดขอมูลตัวอักขระ
ในภาษาจาวาชนิดขอมูล char คือชนิดขอมูลตัวอักขระ โดยขอมูลชนิดตัวอักขระใช
เพื่อแสดงตัวอักขระหนึ่งตัว ซึ่งในภาษาจาวาจะถูกเก็บอยูในรูปของมาตรฐาน Unicode ซึ่งจะมี
ขนาด 16 บิต ขอมูลคาคงที่ซึ่งเปนตัวอักขระแบบ Unicode จะอยูในเครื่องหมาย ‘ ‘ โดยจะ
ขึ้นตนดวยสัญลักษณ \u และตามดวยเลขฐานสิบหก (Hexadecimal number) โดยจะมีคา
ตั้งแต ‘\u0000’ ถึง ‘\uFFFF’ เพื่อเก็บตัวอักขระของภาษาตางๆไดทั้งหมด 65,536 ตัว
ตัวอยางเชน ตัวอักขระแบบ Unicode สําหรับภาษาไทยจะมีคาตั้งแตชวง ‘\u0E00’ ถึง
‘\U0E7F’ เปนตน
ตัวอยางเชน คําสั่ง
char letter = ‘\u0041’;
จะเปนการประกาศตัวแปร letter ใหมีชนิดขอมูลเปน char โดยมีคาเปน
\u0041 ซึ่งมีคา เทากับตัวอักษร A
สําหรับรหัส ASCII ที่ใชในระบบคอมพิวเตอรทั่วไป ตัวอักขระแบบ Unicode จะ
กําหนดคาในชวง ‘\u0000’ ถึง ‘\u00FF’ ใหสอดคลองกับรหัส ASCII 128 ตัวแรก นอกจากนี้
เราสามารถที่จะกําหนดขอมูลคาคงที่ชนิดตัวอักขระโดยกําหนดตัวอักขระภายในเครื่องหมาย
‘ ’ อาทิเชน ‘x’,‘1’ และ ‘$’

ตัวอยางเชน คําสั่ง
char letter = ‘A’;
จะเปนการประกาศตัวแปร letter ใหมชี นิดขอมูลเปน char โดยมีคาเปน
ตัวอักษร A เชนเดียวกับคําสั่งกอนหนานี้
ภาษาจาวาสามารถที่จะเขียนขอมูลคาคงที่ที่เปนอักขระพิเศษตางๆได โดยใช
สัญลักษณ \ นําหนาตัวอักษรภาษาอังกฤษตางๆอาทิเชน ‘\n’ คืออักขระสําหรับการขึ้นบรรทัด
ใหม เปนตน ตัวอักขระพิเศษที่นิยมใชทั่วไปจะเปนไปตามตารางที่ 2.4

36 คณะเทคโนโลยีสารสนเทศ สถาบันเทคโนโลยีพระจอมเกลาเจาคุณทหารลาดกระบัง
 ตารางที่ 2.4 ตัวอักขระพิเศษที่นิยมใชทั่วไป
อักขระ Unicode ความหมาย
‘\b’ ‘\u000B’ Backspace
‘\t’ ‘\u0009’ Tab
‘\n’ ‘\u000A’ New line
‘\r’ ‘\u000D’ Return
‘\\’ ‘\u005C’ Backslash
‘\’’ ‘\u0027’ Single quote
‘\’’’ ‘\u0022’ Double quote

2.2.3 ชนิดขอมูลตัวเลขจํานวนเต็ม
ในภาษาจาวาชนิดขอมูล byte, short, int และ long คือชนิดขอมูลตัวเลข
จํานวนเต็ม โดยขอมูลชนิดนี้คือขอมูลที่เปนจํานวนเต็มใดๆในทางคณิตศาสตร โดยที่แตละ
ชนิดจะมีขนาดในการเก็บขอมูลไมเทากันทําใหมีชวงของขอมูลตางกัน ดังที่กลาวมาแลวใน
ตารางที่ 2.3 ซึ่งโดยทั่วไปภาษาจาวาจะกําหนดใหเลขจํานวนเต็มมีชนิดขอมูลเปน int
การเขียนขอมูลคาคงที่ที่เปนขอมูลชนิดตัวเลขจํานวนเต็มใดๆ จะไมมีการใช
เครื่องหมาย , (comma) เชน 10,000 จะตองเขียนเปน 10000 โดยภาษาจาวาจะสามารถเขียน
คาคงที่ขอมูลไดสามแบบดังนี้
1. เลขฐานสิบคือการเขียนเลขจํานวนเต็มทั่วไป อาทิเชน -121 และ 75362 เปนตน
2. เลขฐานแปดคือการเขียนเลขจํานวนเต็มที่ขึ้นตนดวยเลข 0 แลวตามดวยตัวเลข
ตั้งแต 0 ถึง 7 อาทิเชน 016 (มีคาเทากับ 14 ในเลขฐานสิบ)
3. เลขฐานสิบหกคือการเขียนเลขจํานวนเต็มที่ขึ้นตนดวย 0x หรือ 0X แลวตาม
ดวยตัวเลขตั้งแต 0 ถึง 9 หรือตัวอักษร A ถึง F อาทิเชน 0xA2 (มีคา
เทากับ 162 ในเลขฐานสิบ)
การประกาศตัวแปรใดๆใหมีชนิดขอมูลเปนตัวเลขจํานวนเต็มชนิดใดชนิดหนึ่ง จะมี
ผลใหภาษาจาวากําหนดขนาดของเนื้อที่สําหรับหนวยความจํา และชวงในการเก็บขอมูลให
สอดคลองกับชนิดขอมูลนั้นโดยอัตโนมัติอาทิเชน คําสั่ง
int x = 4;

Java Programming 37
 byte b = 4;
เปนการประกาศตัวแปร x ใหมีชนิดขอมูลเปน int มีขนาดของเนื้อที่ใน
หนวยความจํา 32 บิต และตัวแปร b ใหมีชนิดขอมูลเปน byte มีขนาดของเนื้อที่ใน
หนวยความจํา 8 บิต ถึงแมวาตัวแปรทั้งสองจะเก็บคาเริ่มตนเปน 4 เหมือนกัน แตตัวแปร x
จะสามารถเก็บขอมูลตัวเลขจํานวนเต็มในชวงที่กวางกวา (-231 ถึง 231-1)
ขอมูลคาคงที่ของตัวเลขจํานวนเต็มโดยทั่วไปจะถูกกําหนดใหมีชนิดขอมูลเปน int
แตภาษาจาวาสามารถกําหนดขอมูลคาคงที่ของตัวเลขจํานวนเต็มใหมีชนิดขอมูลเปนlong ได
โดยใสตัวอักษร l หรือ L ตอทาย อาทิเชน
• 2l หมายถึงเลขฐานสิบที่มีคาเทากับ 2 และมีชนิดขอมูลเปน long
• 077L หมายถึงเลขฐานแปดที่มีคาเทากับ 63 และมีชนิดขอมูลเปน long
• 0xBAACL หมายถึงเลขฐานสิบหกที่มีชนิดขอมูลเปน long

2.2.4 ชนิดขอมูลตัวเลขทศนิยม
ขอมูลชนิดตัวเลขทศนิยมคือเลขจํานวนจริง (real number) ซึ่งในระบบคอมพิวเตอร
จะเก็บขอมูลประเภทนี้ โดยแบงจํานวนบิตที่เก็บขอมูลเปนสองสวนคือสวนที่เปนความละเอียด
ของตัวเลข (mantissa) และสวนที่เปนจํานวนเลขยกกําลัง (exponent) โดยสวนที่เปนความ
ละเอียดของตัวเลขจะเก็บคาในชวงตั้งแต -1.0 ถึง 1.0 และสวนที่เปนเลขยกกําลังจะเก็บคาที่
เปนเลขยกกําลังสอง ภาษาจาวาเก็บเลขจํานวนจริงตามมาตรฐาน IEEE 754 ซึ่งจะแบงเลข
จํานวนจริงออกเปน single precision และ double precision โดยที่ตัวเลขแบบ single
precision จะใชเนื้อที่หนวยความจําจํานวน 32 บิต แบงเปนสวนที่เปนความละเอียดของ
ตัวเลขจํานวน 24 บิต และสวนที่เปนจํานวนเลขยกกําลังจํานวน 8 บิต ดังแสดงในรูปที่ 2.1
สวนตัวเลขแบบ double precision จะใชเนื้อที่หนวยความจําจํานวน 64 บิต แบงเปนสวนที่
เปนความละเอียดของตัวเลขจํานวน 53 บิต และสวนที่เปนจํานวนเลขยกกําลังจํานวน 11 บิต

รูปที่ 2.1 จํานวนบิตของ mantissa และ exponent สําหรับตัวเลขแบบ single precision

38 คณะเทคโนโลยีสารสนเทศ สถาบันเทคโนโลยีพระจอมเกลาเจาคุณทหารลาดกระบัง
 ภาษาจาวากําหนดชนิดขอมูลตัวเลขทศนิยมไวสองชนิดคือ float และ double
โดยที่ชนิดขอมูล float จะเก็บขอมูลขนาด 32 บิตตามมาตรฐานแบบ single precision
สวนขอมูลชนิด double จะเก็บขอมูลขนาด 64 บิตตามมาตรฐานแบบ double precision
ภาษาจาวากําหนดขอมูลชนิดตัวเลขทศนิยมใหเปนเลขที่มีเครื่องหมายจุดทศนิยม อาทิเชน
3.14 หรือ 3.0 นอกจากนี้ยังสามารถเขียนอยูในรูปแบบของเลขยกกําลังสิบ (exponential
form) ไดโดยใชตัวอักษร E หรือ e ระบุจํานวนที่เปนเลขยกกําลังสิบอาทิเชน 6.02E23 หรือ
2e-7
ขอมูลคาคงที่ชนิดตัวเลขทศนิยม โดยทั่วไปจะถูกกําหนดใหมีชนิดขอมูลเปน
double แตภาษาจาวาสามารถกําหนดขอมูลคาคงที่ใหมีชนิดขอมูลเปน float ได โดยใส
ตัวอักษร f หรือ F ตอทาย อาทิเชน 2.718F หรือ 3.14f เปนตน
นอกจากนี้ภาษาจาวาจะกําหนดขอมูลคาคงที่ชนิดตัวเลขทศนิยมที่มีอักษร D หรือ d
ตอทายวาเปนขอมูลคาคงที่ที่มีชนิดขอมูลเปน double อาทิเชน 3.14D แตเนื่องจาก
โดยทั่วไปขอมูลคาคงที่ชนิดตัวเลขทศนิยมจะถูกกําหนดใหเปนชนิด double อยูแลว จึงไมมี
ความจําเปนตองใสตัวอักษร D หรือ d ตอทาย
ตัวอยางขอมูลคาคงที่ของตัวเลขทศนิยมที่ถูกตอง
12. 12E2 12.0e2 12.0e2F -3.14F
ตัวอยางขอมูลคาคงที่ของตัวเลขทศนิยมที่ไมถูกตอง
1,234.0 1.2E108F

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

[modifier] dataType variableName[,variableName];

Java Programming 39
 โดยที่
• modifier คือคียเวิรดระบุคุณสมบัติตางๆของตัวแปรเชน access modifier
สวนกรณีที่ไมระบุจะถือวาเปน default
• dataType คือชนิดขอมูล
• variableName คือชื่อของตัวแปรที่เปนไปตามกฎการตั้งชื่อ
ตัวอยางเชน คําสั่ง
int amount;
เปนการประกาศตัวแปร amount ใหมีชนิดขอมูลเปน int
double x;
เปนการประกาศตัวแปร x ใหมีชนิดขอมูลเปน double
นอกจากนี้ภาษาจาวายังอนุญาต ใหสามารถประกาศชื่อตัวแปรที่เปนชนิดขอมูล
เดียวกันไดหลายๆตัวแปร ภายในคําสั่งเดียวกัน ตัวอยางเชน
float price, wholeSalePrice;
เปนคําสั่งประกาศตัวแปร price และ wholeSalePrice ใหมีชนิดขอมูลเปน
float

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

variableName = expression;

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

40 คณะเทคโนโลยีสารสนเทศ สถาบันเทคโนโลยีพระจอมเกลาเจาคุณทหารลาดกระบัง
 x = 1;
radius = 3.14;
c = ‘a’;
y = x+4*3;
คําสั่งกําหนดคาจะสั่งงานใหเครื่องคอมพิวเตอรทํางานสองขั้นตอนคือ คํานวณหา
ผลลัพธของนิพจน แลวเก็บผลลัพธที่ไดไวในตัวแปรอาทิเชน คําสั่ง
amount = 121+14;
จะมีขั้นตอนคือคํานวณหาผลลัพธซึ่งจะไดคาเปน 135 แลวเก็บผลลัพธที่ไดลงในตัว
แปร amount
คําสั่งกําหนดคาจะตองมีชื่อตัวแปรอยูทางดานซายมือ การใชคําสั่งเชน
1 = x;
เปนการใชคําสั่งที่ไมถูกตอง เพราะคาคงที่ใดๆไมสามารถที่จะเก็บผลลัพธที่ไดจาก
นิพจน (คาของ x) ได
นอกจากนี้เราสามารถที่จะนําชื่อตัวแปรที่จะกําหนดคามาประกอบในนิพจนได อาทิ
เชน
x = x+1;
เปนคําสั่งที่ใหนิพจนเพิ่มคาของตัวแปร x ที่มีอยูแลวไปอีก 1 แลวนําผลลัพธที่ไดเก็บ
ไวในตัวแปร x เชนเดิมอาทิเชน ถา x มีคาเปน 5 จะกลายเปน 6
เราสามารถที่จะประกาศและกําหนดคาเริ่มตนของตัวแปร ภายในคําสั่งเดียวกันได
โดยมีรูปแบบคําสั่งดังนี้

[modifier] dataType variableName = expression

[,variableName = expression];

อาทิเชน
int amount = 123;
float price = 12.0f;
double x = 4.0, y = 2.5;

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

ของตัวแปรที่มีชนิดขอมูลตางๆ ซึ่งโปรแกรมนี้จะใหผลลัพธดังแสดงในรูปที่ 2.2

Java Programming 41
 โปรแกรมที่ 2.2 ตัวอยางการใชคําสั่งกําหนดคา

public class VariableAssignDemo {

public static void main(String args[]) {
int x,y;
boolean b1;
float z = 3.414f; /* The program will not be
compiled successfully if
a character f is missing */
double w;
x = 5;
y = 4;
b1 = (x > y);
w = x * 3.2;
System.out.println("x = " + x + " y = " + y);
System.out.println("b1 = " + b1);
System.out.println("z = " + z + " w = " + w);
}
}

รูปที่ 2.2 ผลลัพธที่ไดจากการรันโปรแกรมที่ 2.2

2.3.2 คาคงที่
การประกาศคาคงที่ในภาษาจาวาทําไดโดยการใสคียเวิรด final หนาคําสั่ง
ประกาศชื่อ โดยมีรูปแบบดังนี้

[modifier] final dataType CONSTANT_NAME = expression;

โดยที่
• modifier คือคียเวิรดระบุคุณสมบัติตางๆของคาคงที่เชน access modifier
• dataType คือชนิดขอมูลของคาคงที่

42 คณะเทคโนโลยีสารสนเทศ สถาบันเทคโนโลยีพระจอมเกลาเจาคุณทหารลาดกระบัง
 • CONSTANT_NAME คือชื่อของคาคงที่ซึ่งโดยทั่วไปนิยมใชตัวอักษรพิมพใหญ
และแยกคําดวยเครื่องหมาย _
• expression คือนิพจนที่ใหผลลัพธเปนชนิดขอมูลที่สอดคลองกับชนิดขอมูล
ของคาคงที่
ตัวอยางเชน คําสั่ง
final int MINIMUM = 4;
final double MIN_GPA = 2.00;
เปนการประกาศคาคงที่ MINIMUM ใหมีชนิดขอมูลเปน int โดยมีคาเปน 4 และ
คาคงที่ MIN_GPA ใหมีชนิดขอมูลเปน double โดยมีคาเปน 2.00
คาคงที่จะกําหนดคาไดเพียงครั้งเดียว โดยจะตองมีการกําหนดคากอนที่จะมีการ
เรียกใชงาน ซึ่งเมื่อกําหนดคาแลวจะไมสามารถเปลี่ยนแปลงคาได
โปรแกรมที่ 2.3 เปนตัวอยางที่แสดงการประกาศคาคงที่และการใชคาคงที่ ซึ่งจะให
ผลลัพธดังแสดงในรูปที่ 2.3

โปรแกรมที่ 2.3 ตัวอยางแสดงการประกาศคาคงที่

public class ConstantDemo {
public static void main(String args[]) {
final int MAXIMUM = 10;
final double MIN_GPA;

System.out.println("Maximum is " + MAXIMUM);

MIN_GPA = 2.00;
System.out.println("Minimum GPA is " + MIN_GPA);
// MIN_GPA = 3.00; //illegal
}
}

รูปที่ 2.3 ผลลัพธที่ไดจากการรันโปรแกรมที่ 2.3

Java Programming 43
 2.3.3 ขอบเขตของตัวแปรและคาคงที่
ตัวแปรและคาคงที่ซึ่งประกาศขึ้นจะสามารถใชงานภายในบล็อกคําสั่ง { } ที่ประกาศ
เทานั้น โดยภาษาจาวาแบงตัวแปรและคาคงที่เปนสองประเภทคือ
1. ตัวแปรหรือคาคงที่ที่เปนคุณลักษณะของออปเจ็คหรือคุณลักษณะของคลาส
2. ตัวแปรหรือคาคงที่ที่อยูในบล็อกของเมธอดที่เรียกวาคาคงที่ภายใน (local
constant) หรือตัวแปรภายใน (local variable)
ตัวแปรหรือคาคงที่ ที่เปนคุณลักษณะของออปเจ็คหรือคุณลักษณะของคลาส คือ
ตัวแปรหรือคงที่ที่ประกาศภายในบล็อกของคลาส ซึ่งอยูนอกเมธอดของคลาส ตัวแปรหรือ
คาคงที่ประเภทนี้จะมีขอบเขตใชงานอยูภายในคลาส โดยที่ทุกๆเมธอดในคลาสสามารถ
เรียกใชได สําหรับตัวแปรประเภทนี้จะถูกกําหนดคาเริ่มตนใหโดยอัตโนมัติดังตารางที่ 2.5

ตารางที่ 2.5 คาเริ่มตนที่ถูกกําหนดใหอัตโนมัติ

ชนิดขอมูล คาเริ่มตน
boolean false
byte 0
short 0
int 0
long 0L
float 0.0f
double 0.0
char ‘\u0000’
คลาส null

สําหรับคาคงที่หรือตัวแปรที่อยูภายในบล็อกของเมธอด จะมีขอบเขตการใชงานอยู
ภายในบล็อกเทานั้น โปรแกรมที่ 2.4 แสดงตัวอยางตัวแปรที่เปนคุณลักษณะของออปเจ็คและ
ตัวแปรที่เปนตัวแปรภายใน โดยโปรแกรมนี้มีตัวแปร i ที่เปนคุณลักษณะของออปเจ็ค สวนตัว
แปร j และ k ในเมธอด method1() เปนตัวแปรภายใน และตัวแปร j ในเมธอด
method2() ก็เปนตัวแปรภายในอีกตัวหนึ่ง เราไมสามารถที่จะเรียกใชตัวแปร k นอกเมธอด
method1()ได นอกจากนี้ตัวแปร j ในเมธอดทั้งสองจะถือวาเปนตัวแปรคนละตัวกัน

44 คณะเทคโนโลยีสารสนเทศ สถาบันเทคโนโลยีพระจอมเกลาเจาคุณทหารลาดกระบัง
โปรแกรมที่ 2.4 ตัวอยางแสดงขอบเขตของตัวแปร
public class VariableScopeDemo {
public int i; // object variable

public void method1() {

int j = 4; // local variable
int k = 2; // another local variable
}

public void method2() {

int j = 0; //local variable
System.out.println(i);
// calling an object variable i

// System.out.println(k); // illegal
}
}

ตัวแปรที่เปนคุณลักษณะของออปเจ็คจะสามารถเก็บ และเปลี่ยนแปลงคาที่เก็บไวใน
หนวยความจําได ตราบใดที่ออปเจ็คยังถูกอางอิงในโปรแกรม ตัวแปรภายในจะเปนตัวแปรที่
กําหนดในบล็อกของเมธอด ซึ่งจะมีขอบเขตการใชงานอยูภายในบล็อกที่กําหนดขึ้นเทานั้น ตัว
แปรประเภทนี้จะถูกสรางขึ้นเมื่อมีการเรียกใชงานเมธอดที่ตัวแปรประกาศอยู และจะถูกลบทิ้ง
เมื่อสิ้นสุดการทํางานของเมธอด ดังนั้นในบางครั้งจะเรียกตัวแปรประเภทนี้วา ตัวแปรชั่วคราว
(temporary variable) ตัวแปรที่ประกาศอยูใน argument ของเมธอด ก็จัดอยูในตัวแปร
ประเภทนี้เชนกัน
โปรแกรมที่ 2.5 แสดงตัวอยางของการประกาศและใชงานตัวแปรภายในและตัวแปร
ของออปเจ็ค คลาส ScopeExample จะมีตัวแปรของออปเจ็ค i ที่ถูกสรางขึ้นเมื่อมีการ
สรางออปเจ็คของคลาสและจะเก็บอยูใน Heap Memory ดังแสดงในรูปที่ 2.4 และเมื่อมีการ
เรียกใชเมธอด method1() และ method2() ตัวแปรภายใน i และ j จะถูกสรางขึ้นและ
ถูกลบทิ้งไปเมื่อออกจากเมธอดดังแสดงในรูปที่ 2.4

Java Programming 45
 โปรแกรมที่ 2.5 ตัวอยางแสดงตัวแปรภายในและตัวแปรของออปเจ็ค
public class ScopeExample {
private int i=1;

public void method1() {

int i=4, j=5;

this.i = i+j;
method2(7);
}
public void method2(int i) {
int j=8;
this.i = i+j;
}
}
-------------------------------------------------------
public class TestScoping {
public static void main(String args[]) {
ScopeExample scope = new ScopeExample();
scope.method1();
}
}

รูปที่ 2.4 การเก็บคาของตัวแปรในหนวยความจํา

46 คณะเทคโนโลยีสารสนเทศ สถาบันเทคโนโลยีพระจอมเกลาเจาคุณทหารลาดกระบัง
 ภาษาจาวากําหนดใหตองมีการกําหนดคาเริ่มตนใหกับตัวแปรที่ประกาศไวกอนที่จะ
สามารถเรียกใชงานได ในกรณีของตัวแปรของออปเจ็คหรือตัวแปรของคลาสภาษาจาวาจะ
กําหนดคาเริ่มตนใหโดยอัตโนมัติดังตารางที่ 2.5 แตในกรณีของตัวแปรภายในจะตองมีคําสั่งใน
การกําหนดคาเริ่มตนเอง มิฉะนั้นจะเกิดขอผิดพลาดในขั้นตอนคอมไพล (Compile Error)
ตัวอยางเชน คําสั่ง
public void demoMethod(){
int x = (int)(Math.random()*10);
int y,z;
if(x > 5){
y = 6;
}
z = x+y;
}
จะทําใหโปรแกรมไมสามารถคอมไพลผานได เนื่องจากคา y มีโอกาสที่จะไมถูก
กําหนดคาเริ่มตนกอนใชงาน

2.4 ตัวดําเนินการ
นิพจนในภาษาจาวาอาจจะประกอบดวยขอมูลคาคงที่ ตัวแปร หรือคาคงที่ตางๆ โดย
จะมีตัวดําเนินการตางๆไวเพื่อคํานวณหาผลลัพธที่เปนชนิดขอมูลตางๆ ตัวดําเนินการในภาษา
จาวาแบงออกเปน 4 ประเภทคือ
1. ตัวดําเนินการทางคณิตศาสตร (Arithmetic Operator)
2. ตัวดําเนินการแบบสัมพันธ (Relational Operator)
3. ตัวดําเนินการทางตรรกศาสตร (Logical Operator)
4. ตัวดําเนินการแบบบิต (Bitwise Operator)
ทั้งนี้ตัวดําเนินการทางคณิตศาสตรและตัวดําเนินการแบบบิต จะใหผลลัพธเปนขอมูล
ชนิดจํานวนเต็มหรือจํานวนทศนิยม สวนตัวดําเนินการแบบสัมพันธและตัวดําเนินการทาง
ตรรกศาสตรจะใหผลลัพธเปนขอมูลชนิดตรรกะ

2.4.1 ตัวดําเนินการทางคณิตศาสตร
ตัวดําเนินการทางคณิตศาสตรสําหรับภาษาจาวาจะประกอบไปดวยเครื่องหมาย +,
-, *, / และ % ดังแสดงในตารางที่ 2.6

Java Programming 47
 ตารางที่ 2.6 ตัวดําเนินการทางคณิตศาสตร
เครื่องหมาย ความหมาย ตัวอยางนิพจน
+ บวก a+b

- ลบ a-b

* คูณ a*b

/ หาร a/b

% เศษจากการหาร a%b

ตัวดําเนินการ / จะใหผลลัพธเปนเลขจํานวนทศนิยม ถาตัวถูกดําเนินการ (operand)

ตัวใดตัวหนึ่งเปนขอมูลชนิดจํานวนทศนิยม สวนกรณีที่ตัวกระทําทั้งสองตัวเปนขอมูลชนิด
จํานวนเต็ม ตัวดําเนินการจะใหผลลัพธเปนคาจํานวนเต็ม กลาวคือ 1/2.0 จะไดผลลัพธเปน 0.5
สวน 1/2 จะไดผลลัพธเปน 0
ตัวดําเนินการ % ใชกับตัวถูกดําเนินการที่เปนตัวเลขจํานวนเต็ม โดยจะใหผลลัพธ
เปนตัวเลขจํานวนเต็มที่เปนเศษของการหาร อาทิเชน 7%3 จะไดผลลัพธเปน 1 ตัวดําเนินการ
สวนใหญจะตองมีตัวถูกดําเนินการสองตัว ยกเวนตัวดําเนินการ + และ - ที่อาจมีตัวถูก
ดําเนินการตัวเดียวไดเชน –3 หรือ +4.0 เปนตน
ตัวอยางตอไปนี้เปนการกําหนดคา โดยมีตัวดําเนินการอยูในนิพจนคําสั่ง
int i = 34+2;
double d1 = 34.0–0.2;
long l = 300*30;
int j = 1/2;
double d2 = 1.0/2.0;
byte b1 = 20%3;

ตัวดําเนินการแบบยอ
ภาษาจาวาไดกําหนดตัวดําเนินการแบบยอ (shortcut operator) เพื่อใชแทนตัว
ดําเนินการทางคณิตศาสตร ที่ตองการเปลี่ยนแปลงคาของตัวแปรทางดานซายของคําสั่ง
กําหนดคา อาทิเชน คําสั่ง x = x+1; ซึ่งเปนคําสั่งที่ตองการเพิ่มคาของ x ขึ้นอีก 1
สามารถเขียนใหมโดยใชตัวดําเนินการแบบยอไดดังนี้

48 คณะเทคโนโลยีสารสนเทศ สถาบันเทคโนโลยีพระจอมเกลาเจาคุณทหารลาดกระบัง
 x += 1;
ขอดีของการเขียนคําสั่งโดยใชตัวดําเนินการแบบยอคือจะชวย ทําใหโปรแกรมทํางาน
ไดเร็วขึ้น ภาษาจาวามีตัวดําเนินการแบบยอ 5 ตัว คือ +=, -=, *=, /= และ %= ดังแสดง
ในตารางที่ 2.7
ตารางที่ 2.7 ตัวดําเนินการแบบยอ
เครื่องหมาย ตัวอยาง ความหมาย
+= x += 3; x = x + 3;

-= x -= 3; x = x – 3;

*= x *= 3; x = x * 3;

/= x /= 3; x = x / 2;

%= x %= 3; x = x % 3;

ตัวดําเนินการเพิ่มคาและลดคา
ภาษาจาวายังมีตัวดําเนินการแบบยออีกสองตัวคือตัวดําเนินการเพิ่มคา (increment
operator) ที่ใชเครื่องหมาย ++ และตัวดําเนินการลดคา (decrement operator) ที่ใช
เครื่องหมาย -- ตัวดําเนินการทั้งสองตัวใชในการเพิ่มคาทีละ 1 หรือลดคาทีละ 1
ตัวดําเนินการทั้งสองสามารถใสไวขางหนาหรือขางหลังตัวแปรก็ได ตัวอยางเชน
x++ คือ x = x+1

++x คือ x = x+1

x-- คือ x = x-1

--x คือ x = x-1

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

Java Programming 49
 โปรแกรมที่ 2.6 แสดงตัวอยางของการใชตัวดําเนินการเพิ่มคา โดยการเปรียบเทียบ
ผลลัพธที่ไดจากการวางตําแหนงของเครื่องหมาย ++ ไวดานหนาและดานหลังตัวแปร ซึ่ง
ผลลัพธที่ไดจะเปนดังแสดงในรูปที่ 2.5

โปรแกรมที่ 2.6 ตัวอยางการใชตัวดําเนินการเพิ่มคา

public class IncrementDemo {
public static void main(String args[]) {
int x;
int y;
x = 5;
y = x++;
System.out.println("x = "+x+" y = "+y);
y = ++x;
System.out.println("x = "+x+" y = "+y);
}
}

รูปที่ 2.5 ผลลัพธที่ไดจากการรันโปรแกรมที่ 2.6

2.4.2 ตัวดําเนินการแบบสัมพันธ
ตัวดําเนินการแบบสัมพันธใชในการเปรียบเทียบคาของขอมูลชนิดใดๆสองคา โดยจะ
ใหผลลัพธของการเปรียบเทียบเปนขอมูลคาคงที่ชนิดตรรกะ ภาษาจาวากําหนดตัวดําเนินการ
แบบสัมพันธไว 6 ตัว คือ <, <=, >, >=, == และ != ดังแสดงในตารางที่ 2.8

50 คณะเทคโนโลยีสารสนเทศ สถาบันเทคโนโลยีพระจอมเกลาเจาคุณทหารลาดกระบัง
 ตารางที่ 2.8 แสดงตัวดําเนินการแบบสัมพันธ
เครื่องหมาย ความหมาย ตัวอยาง ผลลัพธ
< นอยกวา 3<4 true

<= นอยกวาหรือเทากับ 3<=4 true

> มากกวา 3>4 false

>= มากกวาหรือเทากับ 3>=4 false

== เทากับ 3==4 false

!= ไมเทากับ 3!=4 true

ชนิดขอมูลที่จะนํามาเปรียบเทียบจะตองเปนชนิดขอมูลที่สอดคลองกันอาทิเชน การ
เปรียบเทียบตัวเลขกับตัวเลข ตัวอักขระกับตัวอักขระ หรือออปเจ็คกับออปเจ็ค เปนตน
ตัวอยางเชน
‘x’ > ‘y’
342 <= 431.50
“Test” == “\test”
ตัวถูกดําเนินการที่จะนําเปรียบเทียบอาจเปนตัวแปรหรือนิพจนก็ได แตจะตองมีชนิด
ขอมูลที่สอดคลองกันดวย ตัวอยางเชนถานิพจนเปน
x < 4.23
ตัวแปร x จะตองเปนตัวแปรชนิดตัวเลขทศนิยมหรือจํานวนเต็ม
โปรแกรมที่ 2.7 แสดงตัวอยางของการใชตัวดําเนินการแบบสัมพันธเพื่อเปรียบเทียบ
ตัวแปร x และ y ที่มีชนิดขอมูลเปน int และเก็บผลลัพธลงในตัวแปร b1 ที่มีชนิดขอมูลเปน
boolean ซึ่งโปรแกรมนี้จะใหผลลัพธดังแสดงในรูปที่ 2.6

Java Programming 51
 โปรแกรมที่ 2.7 การใชตัวดําเนินการแบบสัมพันธ
public class BooleanDemo {
public static void main(String args[]) {
int x = 5;
int y = 4;
boolean b1;
b1 = (x != y);
System.out.println("x not equal y is " + b1);
System.out.println("y less than 0 is " + (y < 0));
}
}

รูปที่ 2.6 ผลลัพธที่ไดจากการรันโปรแกรมที่ 2.7

2.4.3 ตัวดําเนินการทางตรรกศาสตร
ตัวดําเนินการทางตรรกศาสตร จะใชกับตัวถูกดําเนินการที่เปนนิพจนตรรกศาสตร
หรือชนิดขอมูล boolean ตัวดําเนินการประเภทนี้จะใหผลลัพธเปนขอมูลคาคงที่ชนิดตรรกะ
โดยภาษาจาวากําหนดตัวดําเนินการทางตรรกศาสตรไว 6 ตัวดังแสดงในตารางที่ 2.9
ตัวดําเนินการทุกตัวจะตองมีตัวถูกดําเนินการสองตัว ยกเวนตัวดําเนินการที่เปนตัว
ดําเนินการที่ใชในการกลับคา ซึ่งตองการตัวถูกดําเนินการเพียงหนึ่งตัว ตารางที่ 2.10 ถึง
ตารางที่ 2.13 แสดงผลลัพธที่เปนขอมูลคาคงที่ชนิดตรรกะซึ่งไดจากการดําเนินการที่เปนการ
กลับคา, AND, OR และ Exclusive-OR คาทางตรรกะ
ตัวอยางของนิพจนที่ใชตัวดําเนินการทางตรรกศาสตรมีดังนี้
(7>6) & (2<1) จะไดผลลัพธมีคาเปน false
(7>6) | (2<1) จะไดผลลัพธมีคาเปน true
!(7>6) จะไดผลลัพธมีคาเปน false

52 คณะเทคโนโลยีสารสนเทศ สถาบันเทคโนโลยีพระจอมเกลาเจาคุณทหารลาดกระบัง
 ตารางที่ 2.9 ตัวดําเนินการทางตรรกศาสตร
เครื่องหมาย ความหมาย
! กลับคาทางตรรกะ
&& หรือ & AND คาทางตรรกะ
ll หรือ l OR คาทางตรรกะ
^ Exclusive-OR คาทางตรรกะ

ตารางที่ 2.10 ผลลัพธของการกลับคาทางตรรกะ

op !op
true false
false true

ตารางที่ 2.11 ผลลัพธของการ AND คาทางตรรกะ

op1 op2 op1 & op2
true true true
true false false
false true false
false false false

ตารางที่ 2.12 ผลลัพธของการ OR คาทางตรรกะ

op1 op2 op1 l op2
true true true
true false true
false true true
false false false

Java Programming 53
 ตารางที่ 2.13 ผลลัพธของการ Exclusive-OR คาทางตรรกะ
op1 op2 op1 ^ op2
true true false
true false true
false true true
false false false

ตัวดําเนินการที่มีเครื่องหมาย && และ ll เรียกวา ตัวดําเนินการทางตรรกศาสตร

แบบ short circuit โดยที่ && เปนการ AND คาทางตรรกะ ซึ่งจะแตกตางจาก & ตรงที่ &&
จะหยุดการเปรียบเทียบถานิพจนตัวแรกเปนเท็จ เชนเดียวกับ ll ที่เปนการ OR คาทางตรรกะ
ซึ่งจะแตกตางจาก l ตรงที่ ll จะหยุดการเปรียบเทียบถานิพจนตัวแรกเปนจริง ตัวอยางเชน
int x = 10;
if ( (x > 0) || (x++ < -5) ) {
System.out.println(x);
}
ผลลัพธของ x จะมีคาเปน 10 เนื่องจาก || จะไมเรียกคําสั่งในนิพจนที่สอง
แตคําสั่ง
int x = 10;
if ( (x > 0) | (x++ < -5) ) {
System.out.println(x);
}
ผลลัพธของ x จะมีคาเปน 11

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

54 คณะเทคโนโลยีสารสนเทศ สถาบันเทคโนโลยีพระจอมเกลาเจาคุณทหารลาดกระบัง
 ตารางที่ 2.14 ตัวดําเนินการเพื่อจัดการกับขอมูลเชิงบิต
เครื่องหมาย ความหมาย
~ Complement
& AND
l OR
^ XOR

ตารางที่ 2.15 ตัวดําเนินการเพื่อเลื่อนบิต

เครื่องหมาย ความหมาย
>> signed right shift
>>> unsigned right shift
<< left shift

เครื่องหมาย ~, &, l และ ^ ใชในการจัดการขอมูลเชิงบิต เชน 4 ^ 3 คือ 0100 ที่ทํา

การ XOR กับ 0011 จะมีคาเปน 0111 สวนเครื่องหมาย >>, >>> และ << เปนตัว
ดําเนินการเพื่อเลื่อนบิต โดยจะใชกับชนิดขอมูลจํานวนเต็มที่เปน int หรือ long โดยตัว
ถูกดําเนินการที่เปนจํานวนบิตที่จะเลื่อนไปจะเปนเศษของการหารดวย 32 และ 64 สําหรับ
ชนิดขอมูล int และ long ตามลําดับ ดังนั้นคําสั่ง
int x = 8;
System.out.println (x >> 32);
หมายถึงการเลื่อนบิตของตัวแปร x ไป 0 บิต ไมใช 32 บิต
เครื่องหมาย >> เปนการเลื่อนบิตโดยพิจารณาจากเครื่องหมาย ซึ่งถาบิตทางซาย
เปนคา 1 ก็จะใสคา 1 แทน แตถาเปนคา 0 ก็จะใสคา 0 แทน สวนเครื่องหมาย >>> และ
<< จะเปนการเลื่อนบิตโดยไมพิจารณาเครื่องหมาย กลาวคือจะใสคา 0 เสมอ การเลื่อนบิตไป
ทางขวา (>>) คือการหารของจํานวนเต็มดวยคา 2 ยกกําลังจํานวนบิตที่จะเลื่อน สวนการ
เลื่อนบิตไปทางซาย (<<) จะเปนการคูณเลขจํานวนเต็มดวยคา 2 ยกกําลังจํานวนบิตที่จะเลื่อน
ตัวอยางเชน

Java Programming 55
 128 >> 1 คือ 128/21 = 64
-128 >> 4 คือ -128/24 = -8
128 << 2 คือ 128 * 22 = 512

2.4.5 ลําดับความสําคัญของตัวดําเนินการ
กรณีที่นิพจนใดๆมีตัวดําเนินการมากกวาหนึ่งตัว ภาษาจาวาจะจัดลําดับความสําคัญ
ของตัวดําเนินการเพื่อคํานวณหาผลลัพธตามลําดับความสําคัญของตัวดําเนินการ โดยมีลําดับ
ความสําคัญดังแสดงในตารางที่ 2.16

ตารางที่ 2.16 ลําดับความสําคัญของตัวดําเนินการ

ลําดับที่ เรียงจาก ตัวดําเนินการ
1 ขวาไปซาย (R to L) ++, --, +, -, ~, ! (data type)
2 ซายไปขวา (L to R) *, /, %
3 ซายไปขวา (L to R) +, -
4 ซายไปขวา (L to R) <<, >>, >>>
5 ซายไปขวา (L to R) <, >, <=, >=, instanceof
6 ซายไปขวา (L to R) ==, !=
7 ซายไปขวา (L to R) &
8 ซายไปขวา (L to R) ^
9 ซายไปขวา (L to R) |
10 ซายไปขวา (L to R) &&
11 ซายไปขวา (L to R) ||
12 ขวาไปซาย (R to L) ?:
=, +=, -=, *=, /=, %=, <<=,
13 ขวาไปซาย (R to L)
>>=, >>>=, &=, ^=, |=

56 คณะเทคโนโลยีสารสนเทศ สถาบันเทคโนโลยีพระจอมเกลาเจาคุณทหารลาดกระบัง
 ตัวอยางเชน คําสั่ง
x = 2+3*4-(7+2);
จะคํานวณหาผลลัพธตามลําดับดังนี้
1. คํานวณหาผลลัพธคา 7+2 ทําใหได
x = 2+3*4-9
2. คํานวณหาผลลัพธคา 3*4 ทําใหได
x = 2+12-9
3. คํานวณหาผลลัพธคา 2+12 ทําใหได
x = 14-9
4. คํานวณหาผลลัพธคา 14-5 ทําใหได
x = 5

2.5 การแปลงชนิดขอมูล
นิพจนทางคณิตศาสตรในภาษาจาวาอาจมีตัวถูกดําเนินการทางคณิตศาสตร ที่มีชนิด
ขอมูลเปนประเภทตางๆ ภาษาจาวาไดกําหนดใหผลลัพธของนิพจนเปนดังนี้
• ในกรณีที่ตัวถูกดําเนินการทั้งสองตัวมีชนิดขอมูลเปน double เหมือนกัน จะทํา
ใหไดผลลัพธที่มีชนิดขอมูลเปน double
• ในกรณีที่ตัวถูกดําเนินการทั้งสองตัวมีชนิดขอมูลเปน float เหมือนกัน จะทําให
ไดผลลัพธที่มีชนิดขอมูลเปน float
• ในกรณีที่ตัวถูกดําเนินการทั้งสองมีชนิดขอมูลที่ตางกัน ภาษาจาวาจะมีหลักการ
แปลงชนิดขอมูล (type conversion) ดังนี้
– ถาตัวถูกดําเนินการตัวหนึ่งมีชนิดขอมูลเปน double ตัวถูกดําเนินการอีก
ตัวหนึ่งจะถูกแปลงใหมีชนิดขอมูลเปน double โดยอัตโนมัติ
– ถาตัวถูกดําเนินการทั้งสองไมไดมีชนิดขอมูลเปน double แตมีตัวถูก
ดําเนินการตัวหนึ่งที่มีชนิดขอมูลเปน float ตัวถูกดําเนินการอีกตัวหนึ่ง
จะถูกแปลงใหมีชนิดขอมูลเปน float โดยอัตโนมัติ
– ถาตัวถูกดําเนินการทั้งสองไมไดมีชนิดขอมูลเปน double หรือ float
แตมีตัวถูกดําเนินการตัวหนึ่งที่มีชนิดขอมูลเปน long ตัวถูกดําเนินการอีก
ตัวหนึ่งจะถูกแปลงใหมีชนิดขอมูลเปน long โดยอัตโนมัติ
– กรณีอื่นๆ ตัวถูกดําเนินการทั้งสองจะแปลงใหมีชนิดขอมูลเปน int

Java Programming 57
 จากหลักการขางตนจะเห็นไดวาผลลัพธที่ไดจากการคํานวณนิพจนคณิตศาสตร จะมี
ชนิดขอมูลเปน int เปนอยางนอย ดังนั้นคําสั่งตอไปนี้
byte b1, b2, b3;
b1 = 2;
b2 = 4;
b3 = b1+b2; // illegal
จึงเปนคําสั่งที่ไมถูกตอง เนื่องจาก b1+b2 จะใหคาผลลัพธที่มีชนิดขอมูลเปน int
ซึ่งไมสามารถกําหนดคาใหกับตัวแปรที่มีชนิดขอมูลเปน byte ได

2.5.1 การแปลงขอมูลในคําสั่งกําหนดคา
ภาษาจาวากําหนดใหคําสั่งกําหนดคาจะตองมีชนิดขอมูลของตัวแปรทางดานซายและ
ชนิดขอมูลของนิพจนทางดานขวาสอดคลองกัน อาทิเชน
int i = 4;
double x = 3.0;
ในกรณีที่ตัวแปรและนิพจนมีชนิดขอมูลที่แตกตางกัน คอมไพเลอรของภาษาจาวาจะ
ทําการแปลงชนิดขอมูลทั้งสองชนิดใหสอดคลองกัน โดยการแปลงชนิดขอมูลมีสองรูปแบบคือ
1. การแปลงขอมูลที่กวางขึ้น (widening conversion) คือการแปลงจากชนิดขอมูลที่
มีขนาดเล็กกวาไปเปนชนิดขอมูลที่มีขนาดใหญกวา
2. การแปลงขอมูลที่แคบลง (narrowing conversion) คือการแปลงจากชนิดขอมูลที่
มีขนาดใหญกวาไปเปนชนิดขอมูลที่มีขนาดเล็กลง ซึ่งอาจมีผลใหเสียความ
ละเอียดของขอมูลบางสวนไป
ภาษาจาวากําหนดขนาดของชนิดขอมูลตางๆที่สามารถแปลงขอมูลใหกวางขึ้นได ดัง
แสดงในรูปที่ 2.7 ซึ่งมีหลักการดังนี้
• ชนิดขอมูลตัวเลขจํานวนเต็มสามารถแปลงใหเปนชนิดขอมูลตัวเลขทศนิยมได
• ชนิดขอมูล float สามารถแปลงใหเปนชนิดขอมูล double ได
• ชนิดขอมูลตัวเลขจํานวนเต็มมีขนาดเรียงกันจากนอยไปมากดังนี้
byte → short → int → long
• ชนิดขอมูล char สามารถแปลงใหเปนชนิดขอมูล int ได
• ชนิดขอมูล boolean จะไมมคี วามสัมพันธกับชนิดขอมูลแบบพื้นฐานอื่นๆ

58 คณะเทคโนโลยีสารสนเทศ สถาบันเทคโนโลยีพระจอมเกลาเจาคุณทหารลาดกระบัง
 รูปที่ 2.7 การแปลงชนิดขอมูล

ในคําสั่งกําหนดคา ถาผลลัพธของนิพจนเปนชนิดขอมูลที่มีขนาดเล็กกวาชนิดขอมูล
ของตัวแปร ภาษาจาวาจะทําการแปลงขอมูลใหเปนชนิดขอมูลของตัวแปรดังกลาวโดย
อัตโนมัติอาทิเชน คําสั่ง
int i = 4;
long l = i;
นิพจน i จะถูกปรับชนิดขอมูลจาก int ใหเปน long โดยอัตโนมัติ
หรือคําสั่ง
double x = 3;
นิพจนที่มีคาเปน 3 จะถูกปรับชนิดขอมูลจาก int ใหเปน double โดยอัตโนมัติ
ในกรณีที่คําสั่งกําหนดคามีชนิดขอมูลของตัวแปรที่มีขนาดเล็กกวา ชนิดขอมูลของ
นิพจน ภาษาจาวาจะไมสามารถแปลงชนิดขอมูลของนิพจนใหเปนขนาดที่เล็กลงเทากับชนิด
ขอมูลของตัวแปรโดยอัตโนมัติ แตคอมไพเลอรจะแจงขอผิดพลาดในขั้นตอนการคอมไพล
(compile error) ตัวอยางเชน คําสั่ง
int amount = 123L;
หรือ float f = 4.0;
จะไมสามารถคอมไพลผานได เนื่องจากชนิดขอมูลของนิพจนมีขนาดใหญกวาชนิด
ขอมูลของตัวแปร
โปรแกรมที่ 2.8 แสดงตัวอยางของขอผิดพลาดในการแปลงชนิดขอมูล ซึ่งจะทําให
โปรแกรมนี้ไมสามารถคอมไพลผานได

Java Programming 59
 โปรแกรมที่ 2.8 โปรแกรมที่มขี อผิดพลาดในการแปลงชนิดขอมูล

public class PromotionDemo {

public static void main(String args[]) {
int i;
long l;
float fl = 4.2f;
i = 4;
l = i;
fl = i;
double x = fl;
fl = 4.2; //illegal
}
}

2.5.2 Typecasting
ภาษาจาวาจะสามารถทําการแปลงชนิดขอมูล ใหเปนชนิดขอมูลที่มีขนาดเล็กลงได
โดยใชวิธีการที่เรียกวา typecasting ซึ่งมีรูปแบบดังนี้

(targetType) expression
โดยที่
• targetType คือชนิดขอมูลที่ตองการ
การใช typecasting จะชวยทําใหโปรแกรมที่มีคําสั่งซึ่งจําเปนตองแปลงชนิดขอมูล
ใหมีขนาดเล็กลงสามารถคอมไพลผานได แตจะทําใหขอมูลบางสวนสูญหายไปในบางกรณี
ตัวอยางเชน คําสั่ง
int amount = (int)3.0;
จะทําการแปลงนิพจน 3.0 ที่มีชนิดขอมูลเปน double ใหเปน 3 ที่มีชนิดขอมูลเปน
int
หรือตัวอยางคําสั่ง
int x;
double y = 1.25;
x = (int)y;

60 คณะเทคโนโลยีสารสนเทศ สถาบันเทคโนโลยีพระจอมเกลาเจาคุณทหารลาดกระบัง
 จะทําการแปลงนิพจน y ที่มีคา 1.25 ใหมีชนิดขอมูลเปน int ที่มีคา 1 แตจะทําให
ตัวเลขที่เปนสวนทศนิยมหายไป
โปรแกรมที่ 2.9 แสดงตัวอยางการใช typecasting ในการแปลงชนิดขอมูล โดยนิพจน
b1+b2 จะใหผลลัพธที่มีชนิดขอมูลเปน int จึงตองแปลงชนิดขอมูลใหเปน byte เพื่อที่จะ
สามารถกําหนดคาใหกับตัวแปร b3 ซึ่งมีชนิดขอมูลเปน byte ได เชนเดียวกันกับคา 3.2 ซึ่ง
มีชนิดขอมูลเปน double จะถูกแปลงชนิดขอมูลใหเปน float

โปรแกรมที่ 2.9 การใช typecasting ในการแปลงชนิดขอมูล

public class TypecastingDemo {

public static void main(String args[]) {
byte b1 = 4;
byte b2 = 3;
byte b3;
b3 = (byte) (b1 + b2);
float f1;
f1 = (float) 3.2;
}
}

2.6 ชนิดขอมูลแบบอางอิง
ตัวแปรหรือคาคงที่ที่ประกาศเปนชนิดขอมูลอื่นๆ ซึ่งไมใชชนิดขอมูลแบบพื้นฐาน จะ
เปนชนิดขอมูลแบบอางอิงซึ่งก็คือออปเจ็คในภาษาจาวา โดยแบงออกเปนสองแบบคือ
1. ชนิดขอมูลที่เปนคลาส
2. ชนิดขอมูลที่เปนอะเรย
ตัวอยางของชนิดขอมูลที่เปนคลาสคือ ชนิดขอมูล String โดย String ไมใช
ชนิดขอมูลแบบพื้นฐาน แตเปนคลาสที่นิยามไวใน Java API อาทิเชน คําสั่ง
String id;
เปนคําสั่งประกาศตัวแปร id ใหเปนออปเจ็คของคลาส String สําหรับตัวอยาง
ของชนิดขอมูลที่เปนอะเรยจะถูกกลาวถึงในบทที่ 8

Java Programming 61
 ชนิดขอมูลแบบอางอิงจะมีวิธีการเก็บขอมูลในหนวยความจําที่แตกตางจาก การเก็บ
ขอมูลของชนิดขอมูลแบบพื้นฐาน ทั้งนี้ขอมูลที่เก็บในหนวยความจําของชนิดขอมูลแบบอางอิง
จะเปนตําแหนงอางอิงที่เก็บขอมูลในหนวยความจํา แตในกรณีของชนิดขอมูลแบบพื้นฐาน
ขอมูลที่เก็บในหนวยความจําจะเปนคาของขอมูลจริงๆ อาทิเชน คําสั่ง
int x = 7;
String s = new String(“Thana”);
เปนการประกาศตัวแปรที่มีชนิดขอมูลแบบพื้นฐาน int ที่ชื่อ x และใหเก็บคาเปน 7
และเปนการประกาศตัวแปรชนิดขอมูลแบบอางอิง (ซึ่งก็คือออปเจ็ค) s ของคลาส String
และใหเก็บคาเปนขอความวา Thana ซึ่งตัวแปรทั้งสองตัวอาจจะมีการเก็บขอมูลใน
หนวยความจําดังแสดงในรูปที่ 2.8 ซึ่งคาที่เก็บในตัวแปร x จะเปนคาขอมูลที่เปนคา 7 สวนคา
ของตัวแปร s จะเปนตําแหนงอางอิงในหนวยความจําที่ใชเก็บขอความวา Thana

รูปที่ 2.8 ตัวอยางของการเก็บขอมูลในหนวยความจํา

การประกาศตัวแปร (หรือออปเจ็ค) ของชนิดขอมูลแบบอางอิงจะเปนเพียงการ

ประกาศชื่อตัวแปร (หรือออปเจ็ค) แตจะไมมกี ารจองเนื้อที่ในหนวยความจําเพื่อเก็บขอมูล ใน
กรณีที่ตัวแปรดังกลาวเปนคุณลักษณะของออปเจ็ค หรือคุณลักษณะของคลาส ภาษาจาวาจะ
กําหนดตําแหนงอางอิงเริ่มตนใหมีคาเปน null โดยอัตโนมัติ ซึ่งเนื้อที่ในหนวยความจําเพื่อ
เก็บขอมูลตางๆ ของตัวแปรชนิดขอมูลแบบอางอิงจะถูกสรางขึ้น เมื่อมีการเรียกใชคําสั่ง new
อาทิเชน คําสั่ง
Date d;
เปนคําสั่งในการประกาศตัวแปร (หรือออปเจ็ค) d ใหเปนคลาสชนิด Date ที่กําหนด
ไวใน Java API และจะไดคาในหนวยความจําดังแสดงในรูปที่ 2.9 (ก)
และคําสั่ง
d = new Date(16, 8, 2002);

62 คณะเทคโนโลยีสารสนเทศ สถาบันเทคโนโลยีพระจอมเกลาเจาคุณทหารลาดกระบัง
 จะเปนคําสั่งในการจองเนื้อที่ในหนวยความจําเพื่อเก็บคุณลักษณะของออปเจ็คที่ชื่อ d
ที่มีอยู 3 ตัว คือ day, month และ year ซึ่งมีชนิดขอมูลเปน int ดังแสดงในรูปที่ 2.9 (ข)

(ก)

(ข)
รูปที่ 2.9 ตัวอยางของการเก็บขอมูลในหนวยความจํา

2.6.1 คลาส String

String เปนคลาสที่กําหนดไวใน Java API ตัวแปรที่มีชนิดขอมูลเปน String
ก็คือออปเจ็คชนิดหนึ่ง ซึ่ง String มีขอแตกตางจากออปเจ็คทั่วๆไปดังนี้
• String เปนออปเจ็คที่มีคาคงที่ขอมูลซึ่งก็คือขอความใดๆ ที่อยูภายใน
เครื่องหมาย double quote (“ ”) ตัวอยางเชน
“This is a java course”
• String เปนออปเจ็คที่สามารถถูกสรางขึ้นและกําหนดคาไดโดยไมจําเปนตอง
ใชคําสั่ง new ตัวอยางเชน เราสามารถใชคําสั่ง
String s = “Thana”;

Java Programming 63
 โดยไมจําเปนที่จะตองใชคําสั่ง
String s = new String(“Thana”);
ในกรณีที่ไมใชคําสั่ง new ภาษาจาวาจะกําหนดตําแหนงอางอิงในหนวยความจํา
ของขอความที่ระบุในเครื่อง (“ ”) โดยพิจารณาจาก String Pool วามีขอความ
เดิมอยูหรือไม หากมีก็จะใชตําแหนงอางอิงที่ซ้ํากัน แตถายังไมมีก็จะสราง
ขอความขึ้นมาใหมและกําหนดตําแหนงอางอิงของขอความนั้น สวนกรณีที่ใช
คําสั่ง new ภาษาจาวาจะสรางขอความใหมและจองเนื้อที่ในหนวยความจําเสมอ
โปรแกรมที่ 2.10 แสดงตัวอยางการสรางและกําหนดคา ออปเจ็คชนิด String
ทั้งในกรณีที่ใชและไมใชคําสั่ง new ออปเจ็ค s1 และ s2 จะมีขอมูลใน
หนวยความจําเปนตําแหนงอางอิงที่เดียวกัน สวน s3 จะมีขอมูลในหนวยความจํา
เปนตําแหนงอางอิงที่ตางกันเนื่องจากมีการสรางขอความขึ้นมาใหมดังแสดงในรูป
ที่ 2.10

โปรแกรมที่ 2.10 เปนของประกาศและสรางออปเจ็คชนิด String

public class StringDemo {
public static void main(String args[]) {
String s1 = "Thana";
String s2 = "Thana";
String s3 = new String("Thana");
}
}

รูปที่ 2.10 ตัวอยางการเก็บขอมูลชนิด String ในหนวยความจํา

64 คณะเทคโนโลยีสารสนเทศ สถาบันเทคโนโลยีพระจอมเกลาเจาคุณทหารลาดกระบัง
• String เปนออปเจ็คที่เปลี่ยนคาไมได (immutable object) การกําหนดคา
ใหกับออปเจ็คชนิด String ใหม เปนการเปลี่ยนตําแหนงอางอิงใน
หนวยความจําของออปเจ็คดังกลาว แตจะไมไดมีการเปลี่ยนคาภายในตําแหนง
อางอิงเดิม ตัวอยางเชน คําสั่ง
String s1;
s1 = “Thanachart”;
s1 = “Somchai”;
จะมีผลทําใหตําแหนงอางอิงในหนวยความจําของออปเจ็ค s1 เปลี่ยนไป ดังแสดง
ในรูปที่ 2.11 ซึง่ เปนตัวอยางของการเปลี่ยนตําแหนงอางอิงในการเก็บขอมูลชนิด
String ในหนวยความจํา

รูปที่ 2.11 ตัวอยางการเปลี่ยนตําแหนงอางอิงในการเก็บขอมูล

• String เปนออปเจ็คที่มีตัวดําเนินการที่ใชในการเชื่อมขอความสองขอความ
เขาดวยกัน โดยใชเครื่องหมาย + อาทิเชน
String s1 = “Hello”+“ World”;
ตัวดําเนินการในการเชื่อมขอความสามารถใชเชื่อมขอมูลชนิด String กับตัว
ถูกดําเนินการที่เปนชนิดขอมูลอื่นๆที่ไมใชชนิด String ได ซึ่งภาษาจาวาจะ
แปลงชนิดขอมูลดังกลาวใหเปนชนิด String โดยอัตโนมัติอาทิเชน คําสั่ง
String s1 = “This”;
String s2 = s1+ “ is a test ”;
String s3 = s1+4;
จะทําใหไดขอความของตัวแปร s2 เปน “This is a test” และ s3
เปน “This4”

Java Programming 65
 ตัวดําเนินการเพื่อเชื่อมขอความจะมีตัวดําเนินการแบบยอที่ใชเครื่องหมาย +=
เพื่อเชื่อมขอความ แลวกําหนดคาในออปเจ็คของคลาส String โดยใชชอื่ เดิม
อาทิเชน คําสั่ง
String s1 = “This”;
s1 += “ is a test”;
เปนคําสั่งเชื่อมขอความของออปเจ็ค s1 เดิมกับขอความที่วา “ is a test”
แลวเก็บลงในออปเจ็ค s1 เชนเดิม โดยทําให s1 มีขอความเปน “This is
a test”

2.6.2 คลาส Math

Java API ไดกําหนดใหมีคลาส Math ที่อยูในแพคเก็จ java.lang ซึ่งจะมี
เมธอดตางๆในการจัดการกับฟงกชันหรือคําสั่งทางคณิตศาสตรตางๆ คลาส Math เปนคลาส
แบบ final และเมธอดทุกเมธอดจะเปนเมธอดของคลาส (มีคียเวิรด static อยู
ซึ่งจะกลาวถึงในบทที่ 6) การเรียกใชเมธอดเหลานี้ทําไดโดยไมจําเปนตองสรางออปเจ็ค แต
สามารถเรียกผานชื่อคลาสไดโดยตรงอาทิเชน Math.exp(4.0); เปนการคํานวณหาคา
exponential ของ 4.0
คลาส Math ไดประกาศคาคงที่สองตัวดังนี้
− final static double E = 2.7182818284590452354;
− final static double PI = 3.14158265358979323846;

ซึ่งการเรียกใช Math.E จะมีคาเปน 2.718281828… และ Math.PI จะมีคาเปน

3.141582653…
เมธอดอื่นๆในคลาส Math ที่สําคัญมีดังนี้
− static int abs(int x);
− static long abs(long x);
− static float abs(float x);
− static double abs(double x);
− static double acos(double x);
− static double asin(double x);
− static double atan(double x);
− static double atan2(double x, double y);
− static double ceil(double x);
− static double cos(double x);

66 คณะเทคโนโลยีสารสนเทศ สถาบันเทคโนโลยีพระจอมเกลาเจาคุณทหารลาดกระบัง
 − static double exp(double x);
− static double floor(double x);
− static double log(double x);
− static int max(int x, int y);
− static long max(long x, long y);
− static float max(float x, float y);
− static double max(double x, double y);
− static int min(int x, int y);
− static long min(long x, long y);
− static float min(float x, float y);
− static double min(double x, double y);
− static double pow(double x, double y);
− static double random();
− static double rint(double x);
− static int round(float x);
− static long round(double x);
− static double sin(double x);
− static double sqrt(double x);
− static double tan(double x);

2.7 คําสั่งอินพุตและเอาทพุต
โปรแกรมคอมพิวเตอรโดยทั่วไป จะตองมีการอานขอมูลเขาเพื่อใชในการประมวลผล
และจะมีการนําผลลัพธที่ไดจากการประมวลผลออกมาแสดง ขบวนการในการอานขอมูลเขา
และแสดงผลลัพธเรียกวา อินพุต/เอาทพุต (input/output) ภาษาจาวามีวิธีการหลายวิธีการใน
การจัดการกับอินพุต/เอาทพุต และมีคลาสหลายคลาสที่เกี่ยวของกับขบวนการอินพุต/เอาทพุต
แตวิธีการงายๆวิธีการหนึ่งคือการใชอินพุตมาตรฐาน (standard input) และการใชเอาทพุต
มาตราฐาน (standard output) ภาษาจาวามีออปเจ็คที่เปนอินพุต/เอาทพุตมาตรฐานสาม
ออปเจ็คคือ System.in, System.out และ System.err
• ออปเจ็ค System.in เปนออปเจ็คที่มีเมธอดสําหรับการอานขอมูลทางอุปกรณ
อินพุตมาตรฐาน ซึ่งโดยทั่วไปก็คือคียบอรด
• ออปเจ็ค System.out เปนออปเจ็คที่มีเมธอดสําหรับการแสดงขอมูลออกทาง
อุปกรณเอาทพุตมาตรฐานซึ่งโดยทั่วไปคือจอภาพ

Java Programming 67
 • ออปเจ็ค System.err เปนออปเจ็คที่มีเมธอดสําหรับการแสดงขอผิดพลาด
(error) ออกทางอุปกรณที่ใชในการแสดงขอผิดพลาด ซึ่งโดยทั่วไปจะกําหนดเปน
จอภาพ

2.7.1 System.out.println()
ออปเจ็ค System.out หมายถึงออปเจ็คที่ชื่อ out ซึ่งเปนคุณลักษณะของคลาส
System ออปเจ็คที่ชื่อ out เปนออปเจ็คของคลาส PrintStream ที่มีเมธอดที่เกี่ยวของ
กับการแสดงผลอยูหลายเมธอด แตเมธอดที่นิยมใชทั่วไปคือ
print(String s)
และ println(String s)
ซึ่งเมธอดทั้งสองใชในการแสดงผลขอมูลที่มี argument เปนชนิดขอมูล String
เมธอด println() จะมีผลใหโปรแกรมขึ้นบรรทัดใหมหลังจากพิมพขอมูลที่ตองการแสดง
เมธอด print() และ println() สามารถรับ argument ที่เปนชนิดขอมูลอื่น ซึ่ง
โปรแกรมจะแปลงเปนชนิดขอมูล String ใหโดยอัตโนมัติตัวอยางเชน คําสั่ง
int x = 3;
System.out.println(x);
เปนชุดคําสั่งในการพิมพคาของตัวแปร x ที่มีชนิดขอมูลเปน int ออกทางจอภาพ
โดยโปรแกรมจะแปลงชนิดขอมูล int ใหเปน String แลวจึงพิมพขอความออกมา
โปรแกรมที่ 2.11 แสดงตัวอยางของการใชคําสั่ง System.out.print() และ
System.out.println() เพื่อแสดงขอมูลชนิดตางๆ ออกทางจอภาพดังแสดงในรูปที่
2.12

โปรแกรมที่ 2.11 การใชคําสั่งเพื่อพิมพขอความตางๆออกทางจอภาพ

public class PrintDemo {
public static void main(String args[]) {
int x = 3, y = 4, z = 5;
System.out.print("x = "+x);
System.out.println(" y = "+y);
System.out.println("z = "+z);
}
}

68 คณะเทคโนโลยีสารสนเทศ สถาบันเทคโนโลยีพระจอมเกลาเจาคุณทหารลาดกระบัง
 รูปที่ 2.12 ผลลัพธที่ไดจากการรันโปรแกรมที่ 2.11

2.7.2 การรับขอมูลเขามาทาง Command Line

เมธอด main() ที่เปนตําแหนงเริ่มตนการทํางานของโปรแกรมจาวาประยุกต จะมี
argument เปน String args[] ซึ่งหมายถึงตัวแปรอะเรย (จะกลาวถึงในบทที่ 8) args
ที่มีชนิดขอมูลเปน String ซึ่งสามารถรับ argument ที่สงผานมาจาก command line ได
โดยมีตัวอยางของการทํางานดังรูปที่ 2.13 ซึ่งเปนการกําหนดให args[0]มีคาเปน Tommy
และตัวแปร args[1] มีคาเปน boy โปรแกรมที่ 2.12 เปนตัวอยางการปอนอินพุตทาง
command line แลวแสดงผลออกทางจอภาพ

โปรแกรมที่ 2.12 โปรแกรมแสดงการปอนอินพุตทาง command line

public class Sample {
public static void main(String args[]) {
System.out.println("My name is "+ args[0] +
" and I am a " + args[1]);
}
}

รูปที่ 2.13 ผลลัพธที่ไดจากการรันโปรแกรมที่ 2.12

Java Programming 69
 สรุปเนื้อหาของบท
• คอมเม็นต คือขอความที่แทรกอยูภายในโปรแกรม ซึ่งคอมไพเลอรจะไมแปล
ขอความนี้ใหเปนสวนหนึ่งของโปรแกรม
• identifier คือชื่อที่ตั้งขึ้นในภาษาจาวา ซึ่งอาจเปนชื่อของคลาส ชื่อของตัวแปร ชื่อ
ของเมธอด หรือชื่อของคาคงที่ ซึ่งจะตองเปนไปตามกฎการตั้งชื่อ
• การตั้งชื่อในภาษาจาวา
– สําหรับคลาส นิยมขึ้นตนดวยตัวอักษรพิมพใหญ
– สําหรับเมธอดและตัวแปร นิยมขึ้นตนดวยตัวอักษรพิมพเล็ก
– ถาชื่อที่ตั้งขึ้นมีมากกวา 1 คํา นิยมขึ้นตนคําใหมดวยตัวอักษรพิมพใหญ
– ตองไมตรงกับคียเวิรด
• คียเวิรด คือชื่อที่มีความหมายพิเศษในภาษาจาวา คอมไพเลอรของภาษาจาวาจะ
เขาใจความหมายและคําสั่งที่จะตองดําเนินการสําหรับคียเวิรดแตละตัว
• ขอมูลคาคงที่ คือคําที่ใชแสดงขอมูลที่เปนตัวเลข ตัวอักขระ ขอความ หรือคาทาง
ตรรกะ
• ชนิดขอมูลในภาษาจาวาแบงเปนสองประเภท คือชนิดขอมูลแบบพื้นฐาน และ
ชนิดขอมูลแบบอางอิง
• ชนิดขอมูลแบบพื้นฐานที่ใชในภาษาจาวามีทั้งหมด 8 ชนิดคือ char, byte,
short, int, long, float, double และ boolean

• ขอมูลที่เก็บอยูในโปรแกรมแบงเปนสองประเภท คือตัวแปรและคาคงที่ ซึ่งตัวแปร

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

70 คณะเทคโนโลยีสารสนเทศ สถาบันเทคโนโลยีพระจอมเกลาเจาคุณทหารลาดกระบัง
• ตัวดําเนินการที่ใชในภาษาจาวามีทั้งหมด 4 แบบคือ
– ตัวดําเนินการทางคณิตศาสตร : +, -, *, /, %, +=, -=, *=, /=, %=, ++และ --
– ตัวดําเนินการทางตรรกศาสตร : !, &&, &, || และ |
– ตัวดําเนินการแบบสัมพันธ : <, <=, >, >=, == และ !=
– ตัวดําเนินการแบบบิต : ~, &, |, ^, >>, >>>, <<
• กรณีที่นิพจนใดๆมีตัวดําเนินการมากกวาหนึ่งตัว ภาษาจาวาจะจัดลําดับ
ความสําคัญของตัวดําเนินการ เพื่อคํานวณหาผลลัพธตามลําดับความสําคัญของ
ตัวดําเนินการ
• ความแตกตางระหวางการแปลงขอมูลชนิดอัตโนมัติและ Typecasting
– การแปลงขอมูลโดยอัตโนมัติคือ การที่ชนิดขอมูลที่มีขนาดเล็กกวาถูกแปลง
ใหเปนชนิดขอมูลที่มีขนาดใหญกวาโดยอัตโนมัติ
– Typecasting คือการที่จะตองระบุชนิดขอมูลที่มีขนาดเล็กกวาใหกับนิพจนที่
มีชนิดขอมูลขนาดใหญกวา
• ชนิดขอมูลแบบอางอิงซึ่งก็คือออปเจ็คในภาษาจาวา โดยแบงออกเปนสองแบบคือ
ชนิดขอมูลที่เปนคลาส และชนิดขอมูลที่เปนอะเรย
• ขอมูลที่เก็บในหนวยความจําของชนิดขอมูลแบบอางอิง จะเปนตําแหนงอางอิงที่
เก็บขอมูลในหนวยความจํา แตในกรณีของชนิดขอมูลแบบพื้นฐาน ขอมูลที่เก็บใน
หนวยความจําจะเปนคาของขอมูลจริงๆ
• String เปนชนิดขอมูลแบบคลาส ไมใชชนิดขอมูลแบบพื้นฐาน
• คลาส Math จะมีเมธอดตางๆ ในการจัดการกับฟงกชั่นหรือคําสั่งทาง
คณิตศาสตรตางๆ
• คําสั่งที่ใชในการแสดงผลลัพธของขอมูลในภาษาจาวาคือคําสั่ง
System.out.println()

Java Programming 71
72 คณะเทคโนโลยีสารสนเทศ สถาบันเทคโนโลยีพระจอมเกลาเจาคุณทหารลาดกระบัง
 บทที่ 3
โครงสรางควบคุม
เนื้อหาในบทนี้เปนการแนะนําคําสั่งที่เกี่ยวของกับโครงสรางควบคุมในภาษาจาวา ซึ่ง
เปนการควบคุมลําดับการทํางานของคําสั่งตางๆในโปรแกรมภาษาจาวา โดยจะกลาวถึงคําสั่ง
โครงสรางควบคุมสองประเภทคือ คําสั่งโครงสรางแบบเลือกทําซึ่งไดแกคําสั่ง if,if..else
และ switch และคําสั่งโครงสรางแบบทําซ้ําซึ่งไดแกคําสั่ง while,do..while และ
for และในตอนทายของบทนี้จะกลาวถึงคําสั่งโครงสรางควบคุมแบบซอน

3.1 คําสั่งโครงสรางควบคุม
คําสั่งโครงสรางควบคุม (control structure) เปนคําสั่งที่ใชในการกําหนดลําดับการ
ทํางานของคําสั่งตางๆ ภาษาจาวามีโครงสรางควบคุมสามรูปแบบคือ
1. โครงสรางแบบตามลําดับ (sequential structure)
2. โครงสรางแบบเลือกทํา (selection structure)
3. โครงสรางแบบทําซ้ํา (repetition structure)
โดยทั่วไปคําสั่งในภาษาจาวาจะมีโครงสรางควบคุมแบบตามลําดับ โดยจะทํางาน
ตามลําดับของคําสั่งที่มีอยูในโปรแกรม ซึ่งจะเริ่มทํางานจากเมธอด main()โดยจะทํางานจาก
คําสั่งแรกของเมธอด main() และทํางานเรียงตามลําดับคําสั่งตอไปเรื่อยๆ กรณีที่มีการ
เรียกใชเมธอดของออปเจ็ค โปรแกรมจะเขาไปทําคําสั่งภายในเมธอดนั้น และเมื่อสิ้นสุดคําสั่ง
สุดทายของเมธอดก็จะกลับมาทําคําสั่งที่เรียกใชเมธอด ดังแสดงในรูปที่ 3.1

Java Programming 73
 public class Sample {
public static void main(String args[]) {
Student s = new Student();
String name;
name = s.getName();
System.out.println(name);
}
} public class Student {
String name;
public String getName();
return name;
}
}

รูปที่ 3.1 ขั้นตอนการทํางานตามลําดับของคําสั่งที่มีอยูในโปรแกรม

3.2 โครงสรางแบบเลือกทํา
โครงสรางแบบเลือกทํา เปนการใหเลือกทําชุดคําสั่งในกรณีที่นิพจนตรรกศาสตรมีคา
เปนจริงตามเงื่อนไข ซึ่งชุดคําสั่งโครงสรางแบบเลือกทําจะประกอบไปดวยคําสั่งดังตอไปนี้
• คําสั่ง if

• คําสั่ง if..else

• คําสั่ง if แบบซอน (nested if)

• คําสั่ง switch

3.2.1 คําสั่ง if
คําสั่ง if จะมีรูปแบบดังนี้

if (logical expression) {
statements
}

โดยที่
• logical expression คือนิพจนตรรกศาสตรที่ใหผลลัพธเปนขอมูลคาคงที่
ชนิด boolean

74 คณะเทคโนโลยีสารสนเทศ สถาบันเทคโนโลยีพระจอมเกลาเจาคุณทหารลาดกระบัง
 • statements คือชุดคําสั่งใดๆ
ชุดคําสั่งที่อยูในบล็อก { } จะทํางานในกรณีที่นิพจนตรรกศาสตรใหคาเปนจริง ซึ่ง
คําสั่ง if สามารถแสดงลําดับการทํางานเปนโฟวชารต (flowchart) ไดดังแสดงในรูปที่ 3.2

จริง เท็จ
ทําชุดคําสั่ง นิพจนตรรกศาสตร ไมมีการทําคําสั่งใด
ถานิพจนตรรกศาสตร ถานิพจนตรรกศาสตร
เปนจริง เปนเท็จ
ชุดคําสั่ง

รูปที่ 3.2 โฟวชารตของคําสั่ง if

ตัวอยางของการใชคําสั่ง if มีดังนี้
if(radius >= 0) {
area = radius*radius*Math.PI;
System.out.println(area);
}
จากตัวอยางนี้ชุดคําสั่งที่อยูในบล็อก (คําสั่งกําหนดคาตัวแปร area และคําสั่ง
แสดงผล) จะทํางานในกรณีที่นิพจน radius >=0 เปนจริง กลาวคือตัวแปร radius มี
คามากกวาหรือเทากับ 0
กรณีที่ชุดคําสั่งในบล็อก { } มีเพียงคําสั่งเดียวเราสามารถที่จะตัดเครื่องหมาย { }
ออกไปไดอาทิเชน คําสั่ง
if((x > 0) && (x < 10)) {
System.out.println(x);
}
สามารถเขียนใหมไดเปน
if((x > 0) && (x < 10))
System.out.println(x);

Java Programming 75
 แตอยางไรก็ตามการเขียนโปรแกรมที่ดีควรใชบล็อก { } เพื่อใหเกิดความเขาใจงาย
และงายตอการเพิ่มคําสั่ง (กลาวคือถามีมากกวาหนึ่งคําสั่งตองใชบล็อก { } เสมอ)

โปรแกรมที่ 3.1 ตัวอยางการใชคําสั่ง if

public class SampleIf {
public static void main(String args[]) {
int score = Integer.parseInt(args[0]);
if (score >= 50) {
System.out.println("You pass");
}
}
}

โปรแกรมที่ 3.1 เปนตัวอยางของโปรแกรมที่ใชคําสั่ง if โดยโปรแกรมจะรับตัวเลข

เขามาทาง command line ซึ่งจะเปนขอมูลชนิด String ที่จะเก็บอยูในตัวแปร args[0]
แลวจึงสงคาเปน argument ของเมธอด Integer.parseInt() เพื่อทําการแปลงชนิด
ขอมูล String ใหเปนชนิดขอมูล int แลวกําหนดไวในตัวแปร score ซึ่งคําสั่ง if จะ
ตรวจสอบวาถาตัวแปร score มีคามากกวาหรือเทากับ 50 จะพิมพขอความ You pass
ออกมา ตัวอยางของผลลัพธที่ไดจากการรันโปรแกรมที่ 4.1 แสดงดังรูปที่ 3.3

รูปที่ 3.3 ผลลัพธที่ไดจากการรันโปรแกรมที่ 3.1

3.2.2 คําสั่ง if..else

คําสั่ง if จะไมมีการทําคําสั่งใดถานิพจนตรรกศาสตรมีคาเปนเท็จ ดังนั้นถาตองการ
ทําคําสั่งบางคําสั่งเมื่อนิพจนตรรกศาสตรมีคาเปนเท็จ จะตองใชคําสั่ง if..else แทน ซึ่งมี
รูปแบบของคําสั่งดังนี้

76 คณะเทคโนโลยีสารสนเทศ สถาบันเทคโนโลยีพระจอมเกลาเจาคุณทหารลาดกระบัง
 if (logical expression) {
true statements
} else {
false statements
}

โดยที่
• true statements คือชุดคําสั่งสําหรับคาจริง
• false statements คือชุดคําสั่งสําหรับคาเท็จ
โดยมีโฟวชารตของการทํางานของคําสั่งนี้ดังแสดงในรูปที่ 3.4

จริง นิพจนตรรกศาสตร
เท็จ
ทําชุดคําสั่ง ทําชุดคําสั่ง
สําหรับคาจริง สําหรับคาเท็จ
ถานิพจนตรรกศาสตร ถานิพจนตรรกศาสตร
เปนจริง เปนเท็จ
ชุดคําสั่งสําหรับคาจริง ชุดคําสั่งสําหรับคาเท็จ

รูปที่ 3.4 โฟวชารตของคําสั่ง if..else

ตัวอยางของการใชคําสั่ง if..else มีดังนี้

if (radius >= 0) {
area = radius*radius*Math.PI;
System.out.println(area);
} else {
System.out.println(“Negative radius”);
}

Java Programming 77
 จากตัวอยางนี้ถาตัวแปร radius มีคามากกวาหรือเทากับ 0 (นิพจนมีคาเปนจริง)
โปรแกรมจะทําการคํานวณคา กําหนดคาและพิมพคาของตัวแปร area ออกมา แตถาตัวแปร
radius มีคานอยกวา 0 (นิพจนเปนเท็จ) โปรแกรมจะแสดงขอความ Negative radius
ออกมาแทน

โปรแกรมที่ 3.2 ตัวอยางการใชคําสั่ง if..else

public class SampleIfElse {
public static void main(String args[]) {
int score = Integer.parseInt(args[0]);
if (score >= 50) {
System.out.println("You pass");
} else {
System.out.println("You fail");
}
}
}

โปรแกรมที่ 3.2 เปนตัวอยางของการใชคําสั่ง if..else โดยโปรแกรมจะพิมพ

ขอความ You pass ถาคาของตัวแปร score ที่รับเขามาทาง command line มีคา
มากกวาหรือเทากับ 50 และจะพิมพขอความ You fail ถาคาของ score มีคานอยกวา
50 โดยมีตัวอยางของผลลัพธดังแสดงในรูปที่ 3.5

รูปที่ 3.5 ผลลัพธที่ไดจากการรันโปรแกรมที่ 3.2

78 คณะเทคโนโลยีสารสนเทศ สถาบันเทคโนโลยีพระจอมเกลาเจาคุณทหารลาดกระบัง
3.2.3 คําสั่ง if แบบซอน
คําสั่ง if หรือ if..else สามารถที่จะซอนอยูขางในคําสั่ง if หรือ if..else
อื่นไดอาทิเชน โฟวชารตที่แสดงในรูปที่ 3.6 ซึ่งมีขั้นตอนการทํางานคือ โปรแกรมจะทํา
ชุดคําสั่งที่ 3 ถานิพจนตรรกศาสตรที่ 1 เปนเท็จ แตถาเปนจริงจะตรวจสอบผลลัพธของนิพจน
ตรรกศาสตรที่ 2 ซึ่งถามีคาเปนจริง จะทําชุดคําสั่งที่ 1 แตถามีคาเปนเท็จจะทําชุดคําสั่งที่ 2

จริง นิพจน เท็จ

ตรรกศาสตรที่ 1

จริง นิพจน เท็จ ชุดคําสั่งที่ 3

ตรรกศาสตรที่ 2

ชุดคําสั่งที่ 1 ชุดคําสั่งที่ 2

รูปที่ 3.6 โฟวชารตของคําสั่ง if แบบซอน

จากโฟวชารตในรูปที่ 3.6 สามารถที่จะเขียนเปนคําสั่ง if แบบซอนไดดังนี้

if (logical expression 1) {
if (logical expression 2) {
statements 1
} else {
statements 2
}
} else {
statements 3
}

Java Programming 79
 ตัวอยางเชน
if(radius >= 0) {
area = radius*radius*Math.PI;
if(area >= 500.0) {
System.out.println(“Big Circle”);
} else {
System.out.println(“Small Circle”);
}
} else {
System.out.println(“Negative radius”);
}

จริง นิพจน เท็จ

ตรรกศาสตรที่ 1

ชุดคําสั่งที่ 1
จริง นิพจน เท็จ
ตรรกศาสตรที่ 2

ชุดคําสั่งที่ 2 ชุดคําสั่งที่ 3

รูปที่ 3.7 โฟวชารตของคําสั่ง if แบบซอน

โครงสรางเลือกทําแบบซอนยังมีกรณีที่เปนดังโฟวชารตในรูปที่ 3.7 ซึ่งจะมีขั้นตอน

การทํางานคือ โปรแกรมจะทําชุดคําสั่งที่ 1 ถานิพจนตรรกศาสตรที่ 1 เปนจริง แตถาเปนเท็จ
จะตรวจสอบผลลัพธของนิพจนตรรกศาสตรที่ 2 ซึ่งถามีคาเปนจริง จะทําชุดคําสั่งที่ 2 แตถามี
คาเปนเท็จจะทําชุดคําสั่งที่ 3 ซึ่งจะมีรูปแบบของคําสั่งดังนี้

if (logical expression 1) {
statements 1
} else {

80 คณะเทคโนโลยีสารสนเทศ สถาบันเทคโนโลยีพระจอมเกลาเจาคุณทหารลาดกระบัง
 if (logical expression 2) {
statements 2
} else {
statements 3
}
}

ในกรณีนี้สามารถที่เขียนคําสั่ง if แบบซอนไดใหม ในรูปของ if..else

if..else โดยมีรูปแบบของคําสั่งดังนี้

if (logical expression 1) {
statements 1
} else if (logical expression 2) {
statements 2
} else {
statements 3
}

ตัวอยางของการใชคําสั่ง if..else if..else มีดังนี้

if(score >= 80) {
System.out.println(‘A’);
} else if(score >= 70) {
System.out.println(‘B’);
} else if(score >= 60) {
System.out.println(‘C’);
} else if(score >= 50) {
System.out.println(‘D’);
} else {
System.out.println(‘F’);
}
ตัวอยางนี้จะพิมพตัวอักษร A ถาตัวแปร score มีคามากกวาหรือเทากับ 80 พิมพ
ตัวอักษร B ถาตัวแปร score มีคาตั้งแต 70 จนถึง 79 พิมพตัวอักษร C ถาตัวแปร
score มีคาตั้งแต 60 จนถึง 69 พิมพตัวอักษร D ถาตัวแปร score มีคาตั้งแต 50 จนถึง
59 และพิมพตัวอักษร F ถาตัวแปร score มีคาต่ํากวา 50

Java Programming 81
 โปรแกรมที่ 3.3 การใชคําสั่ง if..else if..else

public class SampleIfElseIf {

public static void main(String args[]) {
int x = Integer.parseInt(args[0]);
if (x == 1) {
System.out.println("Value is one");
} else if (x == 2) {
System.out.println("Value is two");
} else {
System.out.println("Other than 1 or 2");
}
}
}

โปรแกรมที่ 3.3 แสดงตัวอยางการใชคําสั่ง if..else if..else โปรแกรมนี้จะ

อานคาที่ปอนเขามาทาง command line โดยโปรแกรมจะพิมพขอความวา “Value is
one” ถาคาที่ปอนเขามาเปน 1 พิมพขอความวา “Value is two” ถาคาที่ปอนเขามา
เปน 2 และพิมพขอความวา “Other than 1 or 2” ถาคาที่ปอนเขามาเปนคาอื่นๆ

3.2.4 คําสั่ง switch

คําสั่ง switch เปนคําสั่งโครงสรางแบบเลือกทํา โดยมีรูปแบบดังนี้

switch (expression) {
case value 1 : statements 1
break;
case value 2 : statements 2
break;
: :
case value N : statements N
break;
default : statements N+1
break;
}

82 คณะเทคโนโลยีสารสนเทศ สถาบันเทคโนโลยีพระจอมเกลาเจาคุณทหารลาดกระบัง
 โดยที่
• expression คือนิพจนที่ตองมีชนิดขอมูลเปน char, byte, short หรือ
int เทานั้น
• value 1 .. value N คือขอมูลคาคงที่ซึ่งมีชนิดขอมูลที่สอดคลองกับชนิด
ขอมูลของ expression
คําสั่ง switch จะตรวจสอบคาของนิพจนที่อาจเปนชนิดขอมูล char, byte,
short หรือ int กรณีที่คาของนิพจนมีคาตรงกับคาที่ 1 โปรแกรมจะทําชุดคําสั่งที่ 1 ถามี
คาตรงกับคาที่ 2 ก็จะทําชุดคําสั่งที่ 2 ถามีคาตรงกับคาที่ N ก็จะทําชุดคําสั่งที่ N สวนกรณีที่มี
คาไมตรงกับคาใดๆเลยในคําสั่ง case ก็จะทําชุดคําสั่งใน default คือชุดคําสั่งที่ N+1 ซึ่งแสดง
ขั้นตอนการทํางานไดดังโฟวชารตในรูปที่ 3.8

นิพจน
จริง
= คาที่ 1 ชุดคําสั่งที่ 1

= คาที่ 2
จริง ชุดคําสั่งที่ 2

: :
จริง ชุดคําสั่งที่ N
= คาที่ N

= คา default จริง ชุดคําสั่งที่ N+1

รูปที่ 3.8 โฟวชารตของคําสั่ง switch

ตัวอยางของการใชคําสั่ง switch มีดังนี้

switch (x) {
case 1 : System.out.println(“One”);
break;

Java Programming 83
 case 2 : System.out.println(“Two”);
break;
case 3 : System.out.println(“Three”);
break;
default : System.out.println(“Other”);
}

ตัวอยางนี้จะพิมพขอความตามคาของ x ตั้งแต 1 ถึง 3 และจะพิมพขอความวา

other ถาคาของ x เปนคาอื่นๆ

คําสั่ง switch มีขอกําหนดตางๆดังนี้

• นิพจนตองมีชนิดขอมูลเปน char,byte,short หรือ int เทานั้น
• ชนิดขอมูลของนิพจนและคาที่ 1 ถึง N ตองเปนชนิดขอมูลเดียวกัน
• คําสั่ง break จะหยุดการทํางานภายในบล็อก { } ถาไมมีคําสั่ง break
โปรแกรมจะทําคําสั่งถัดไป ตัวอยางเชน
switch (x) {
case 1 : System.out.println(“One”);
case 2 : System.out.println(“Two”);
break;
default : System.out.println(“Other”);
}
จะพิมพขอความ One ตามดวย Two ในกรณีที่ x มีคาเปน 1
• เงื่อนไข default จะมีหรือไมมีก็ได

โปรแกรมที่ 3.4 แสดงตัวอยางของการใชคําสั่ง switch ซึ่งจะไดผลลัพธเปน

ขอความวา Value is one ถาตัวเลขที่ปอนเขามามีคาเปน 1 เปนขอความวา Value
is two ถาตัวเลขที่ปอนเขามามีคาเปน 2 และเปนขอความวา Other than 1 or 2
ถาตัวเลขที่ปอนเขามามีคาอื่นๆ

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

public class SampleSwitch {

public static void main(String args[]) {
int x = Integer.parseInt(args[0]);
switch(x) {
case 1:System.out.println("Value is one");
break;
case 2:System.out.println("Value is two");
break;
default:System.out.println("Other than 1 or 2");
}
}
}

3.3 โครงสรางแบบทําซ้ํา
โครงสรางแบบทําซ้ํา เปนคําสั่งที่ใชในการสั่งใหชุดคําสั่งใดๆทําซ้ําหลายครั้งตาม
เงื่อนไขที่ระบุ ซึ่งชุดคําสั่งโครงสรางแบบทําซ้ําประกอบดวยคําสั่ง
• คําสั่ง while

• คําสั่ง do..while

• คําสั่ง for

3.3.1 คําสั่ง while

คําสั่ง while จะมีรูปแบบดังนี้

initial statements
while (logical expression) {
statements
update statements
}

Java Programming 85
 โดยที่
• initial statements คือคําสั่งที่ใชในการกําหนดคาเริ่มตน
• logical expression คือนิพจนตรรกศาสตร
• update statements คือคําสั่งที่ใชในการเปลี่ยนแปลงคา

คําสั่ง while จะทําชุดคําสั่งและคําสั่งเปลี่ยนแปลงคาที่อยูในบล็อก { } ตราบใดที่

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

คําสั่งกําหนดคาเริ่มตน

นิพจน เท็จ
ทําชุดคําสั่งซ้ํา ตรรกศาสตร
ถานิพจนตรรกศาสตร จริง
ยังเปนจริง ชุดคําสั่ง

คําสั่งเปลี่ยนแปลงคา

รูปที่ 3.9 โฟวชารตของคําสั่ง while

ตัวอยางของการใชคําสั่ง while เพื่อพิมพขอความวา Hello World สิบครั้ง มีดังนี้

int count = 1;
while(count <= 10) {
System.out.println(“Hello World”);
count++;

86 คณะเทคโนโลยีสารสนเทศ สถาบันเทคโนโลยีพระจอมเกลาเจาคุณทหารลาดกระบัง
 }
ตัวอยางนี้มีคําสั่ง int count = 1; เปนคําสั่งกําหนดคาเริ่มตน โดยมีนิพจน
ตรรกศาสตรคือ count <= 10 ซึ่งโปรแกรมจะทําคําสั่งในบล็อก { } ตราบเทาที่นิพจน
ตรรกศาสตรมีคาเปนจริง (กลาวคือคาของตัวแปร count นอยกวาหรือเทากับ 10) สวน
คําสั่ง count++; เปนคําสั่งเปลี่ยนแปลงคาของตัวแปร count โดยจะเพิ่มคาทีละหนึ่งใน
แตละรอบจนกระทั่งมีคาเปน 11 ซึ่งจะมีผลทําใหนิพจน count <= 10 มีคาเปนเท็จ หาก
ไมมีคําสั่ง count++; ในบล็อก { } จะทําใหคา count มีคาเปน 1 ตลอด และจะทําใหนิพจน
count <= 10 มีคาเปนจริงเสมอ ซึ่งก็จะทําใหโปรแกรมพิมพขอความ Hello World โดยไม
มีที่สิ้นสุด

โปรแกรมที่ 3.5 ตัวอยางการใชคําสั่ง while

public class SampleWhile {
public static void main(String args[]) {
int i = 1;
while(i <= 10) {
System.out.print(i+" ");
i++;
}
}
}

โปรแกรมที่ 3.5 แสดงตัวอยางการใชคําสั่ง while เพื่อพิมพคาตัวเลข 1 ถึง 10

ซึ่งผลลัพธของโปรแกรมเปนดังแสดงในรูปที่ 3.10

รูปที่ 3.10 ผลลัพธที่ไดจากการรันโปรแกรมที่ 3.5

Java Programming 87
 3.3.2 คําสั่ง do..while
คําสั่ง do..while เปนคําสั่งที่เปนโครงสรางแบบทําซ้ําที่มีการทํางานคลายกับ
คําสั่ง while โดยมีรูปแบบคําสั่งดังนี้

initial statements
do {
statements
update statements
} while(logical expression);

โดยมีโฟวชารตของการทํางานของคําสั่งนี้ดังแสดงในรูปที่ 3.11 ขอแตกตางของคําสั่ง

while กับคําสั่ง do..while คือคําสั่ง do..while จะทําคําสั่งในบล็อก { } อยางนอย
หนึ่งครั้งแลวจึงทําการตรวจสอบเงื่อนไขในนิพจนตรรกศาสตร ขณะที่คําสั่ง while จะทําการ
ตรวจสอบเงื่อนไขในนิพจนตรรกศาสตรกอนซึ่งหากมีคาเปนจริงถึงจะทําคําสั่งในบล็อก { }

มีการทําชุดคําสั่ง
อยางนอยหนึ่งครั้ง

ทําชุดคําสั่งซ้ํา ชุดคําสั่ง

ถานิพจนตรรกศาสตร
คําสั่งเปลี่ยนแปลงคา
ยังเปนจริง

จริง
นิพจนตรรกศาสตร

เท็จ

รูปที่ 3.11 โฟวชารตของคําสั่ง do..while

ตัวอยางของการใชคําสั่ง do..while เพื่อพิมพขอความวา Hello World สิบครั้งมี

ดังนี้
int count = 1;

88 คณะเทคโนโลยีสารสนเทศ สถาบันเทคโนโลยีพระจอมเกลาเจาคุณทหารลาดกระบัง
 do {
System.out.println(“Hello World”);
count++;
} while(count <= 10);

โปรแกรมที่ 3.6 ตัวอยางการใชคําสั่ง do..while

public class SampleDoWhile {
public static void main(String args[]) {
int i = 1;
do {
System.out.print(i+" ");
i++;
} while (i <= 10);
}
}

โปรแกรมที่ 3.6 แสดงตัวอยางการใชคําสั่ง do..while เพื่อพิมพคาตัวเลข 1 ถึง

10 ซึ่งจะไดผลลัพธเชนเดียวกับโปรแกรมที่ 3.5

3.3.3 คําสั่ง for

คําสั่ง for เปนคําสั่งที่เปนโครงสรางแบบทําซ้ํา ที่มีรูปแบบของคําสั่งดังนี้

for(initial statements; expression; update statements) {

statements
}

โดยมีโฟวชารตของการทํางานของคําสั่งนี้ดังแสดงในรูปที่ 3.12 คําสั่ง for จะใชใน

กรณีที่ทราบจํานวนครั้งในการทําซ้ําที่แนนอน สวนคําสั่ง while หรือ do..while นิยมใช
ในกรณีที่ไมทราบจํานวนครั้งในการทําซ้ําลวงหนา

Java Programming 89
 คําสั่งกําหนดคา

นิพจน เท็จ
ทําชุดคําสั่งซ้ํา ตรรกศาสตร
ถานิพจนตรรกศาสตร จริง
ยังเปนจริง ชุดคําสั่ง

คําสั่งเปลี่ยนแปลงคา

รูปที่ 3.12 โฟวชารตของคําสั่ง for

ตัวอยางเชนคําสั่งพิมพขอความ Hello World สิบครั้ง ควรใชคําสั่ง for มากกวาใช

คําสั่ง while หรือ do..while โดยสามารถเขียนคําสั่งไดดังนี้
for(int count = 1; count <= 10; count++) {
System.out.println(“Hello World”);
}
ในกรณีนี้จะเห็นไดวาชุดคําสั่งที่ใชคําสั่ง for จะมีรูปแบบที่กระชับกวาเมื่อเทียบกับ
กรณีของคําสั่ง while หรือ do..while
คําสั่งกําหนดคาเริ่มตนหรือคําสั่งเปลี่ยนแปลงคาที่อยูในคําสั่ง for สามารถที่จะมี
มากกวาอยางละหนึ่งคําสั่ง โดยจะใชเครื่องหมาย , ในการแยกคําสั่ง อาทิเชน
for(int i = 0, j = 0; i < 4; i++, j += 2) {
System.out.println(i + “ ” + j);
}
เปนคําสั่งที่จะพิมพคาของตัวแปร i และ j ที่กําหนดขึ้นภายในคําสั่ง for 4 ครั้ง
โดยตัวแปร i จะเพิ่มคาขึ้นทีละหนึ่ง และตัวแปร j จะเพิ่มคาขึ้นทีละสอง

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

public class SampleFor {

public static void main(String args[]) {
for (int i=1; i<=10; i++) {
System.out.print(i+" ");
}
}
}

โปรแกรมที่ 3.7 แสดงตัวอยางการใชคําสั่ง for เพื่อพิมพตัวเลข 1 ถึง 10 ซึ่งจะได

ผลลัพธเชนเดียวกับโปรแกรมที่ 3.5
ตัวแปรที่ประกาศในคําสั่งกําหนดคาของคําสั่ง for จะมีขอบเขตการใชงานไดเฉพาะ
ภายในบล็อก { } ของคําสั่ง for เทานั้น การใชงานตัวแปรนอกบล็อก { } จะเกิด compile
error ดังแสดงในตัวอยางของโปรแกรมที่ 3.8

โปรแกรมที่ 3.8 ขอบเขตการใชงานของตัวแปร

public class VariableScope {
public static void main(String args[]) {
for (int i=1; i<10; i++) {
System.out.print(i+" ");
}
System.out.println("i = "+i); //illegal
}
}

เราไมสามารถใชคําสั่ง for ในกรณีที่ไมทราบจํานวนครั้งในการทําซ้ําที่แนนอน

ตัวอยางเชน โปรแกรมที่ 3.9 เปนการสุมตัวเลขสองตัวที่มีคาระหวาง 1 ถึง 10 โดยใหทําการ
สุมตัวเลขทั้งสองจนกวาผลการสุมของเลขทั้งสองมีคาเทากัน เมธอด Math.random() เปน
เมธอดที่ใชในการสุมเลขจํานวนทศนิยมระหวาง 0 ถึง 1 และคําสั่ง
i = (int)(Math.random()*10) + 1;

Java Programming 91
 เปนคําสั่งที่ใชในการสุมตัวเลขระหวาง 1 ถึง 10 แลวกําหนดคาใหกับตัวแปร i
โปรแกรมนี้สามารถเขียนใหมโดยใชคําสั่ง while ได แตไมสามารถที่จะเขียนโดยใชคําสั่ง
for เนื่องจากไมทราบจํานวนครั้งที่ตองการสุมตัวเลขที่แนนอนได

โปรแกรมที่ 3.9 การสุมตัวเลขสองตัวที่มีคาระหวาง 1 ถึง 10

public class ShowNotFor {

public static void main(String args[]) {
int i,j;
do {
i = (int)(Math.random()*10)+1;
j = (int)(Math.random()*10)+1;
} while (i != j);
}
}

3.4 โครงสรางแบบซอน (Nested Structure)

คําสั่งโครงสรางควบคุมสามารถเขียนซอนกันไดอาทิเชน ใชคําสั่ง if แบบซอน
คําสั่ง for แบบซอน โครงสรางแบบซอนสามารถที่จะมีคําสั่งโครงสรางควบคุมที่อยูภายใน
และภายนอกแตกตางกันได อาทิเชน คําสั่ง
for(int i = 1; i <= 40; i++) {
if ((i%5) == 0) {
System.out.println(i);
}
}
เปนคําสั่ง if ที่อยูภายในคําสั่ง for เพื่อที่จะพิมพตัวเลขระหวาง 1 ถึง 40 ที่หาร
5 ลงตัวออกมา
ภาษาจาวาอนุญาตใหเขียนคําสั่งโครงสรางควบคุมซอนกันหลายๆชั้นได คําสั่ง
โครงสรางแบบซอนที่ใชกันทั่วไปแบบหนึ่งคือคําสั่ง for แบบซอน ตัวอยางเชน คําสั่ง
for(int i = 1; i <= 3; i++) {
for(int j = 1; j <= 4; j++) {
System.out.println(“i =”+i+“ j =” +j);
}
}

92 คณะเทคโนโลยีสารสนเทศ สถาบันเทคโนโลยีพระจอมเกลาเจาคุณทหารลาดกระบัง
 มีคําสั่ง for ที่อยูภายนอกที่จะทําซ้ําสามครั้ง โดยกําหนดใหตัวแปร i มีคา
เริ่มตนเปน 1 และเพิ่มทีละหนึ่ง สวนคําสั่ง for ที่อยูภายในจะทําซ้ําสี่ครั้ง ในแตละรอบของ
คําสั่ง for ภายนอก โดยกําหนดใหตัวแปร j มีคาเริ่มตนเปน 1 และเพิ่มคาทีละหนึ่ง
ดังนั้นคําสั่งแสดงผล (System.out.println()) จะทําซ้ําทั้งหมด 12 ครัง้
โปรแกรมที่ 3.10 เปนตัวอยางการใชคําสั่ง for แบบซอน โดยคําสั่ง for ที่อยู
ภายในจะพิมพเครื่องหมาย ‘*’ เทากับจํานวนคอลัมน (5 ครั้ง) และคําสั่ง for ที่อยู
ภายนอกจะทําคําสั่ง for ที่อยูภายในซ้ําเทากับจํานวนแถว (3 ครั้ง) โปรแกรมจะไดผลลัพธดัง
รูปที่ 3.13

โปรแกรมที่ 3.10 ตัวอยางการใชคําสั่ง for แบบซอน

public class NestedFor {
public static void main(String args[]) {
for (int i=1; i<=3; i++) {
for (int j=1; j<=5; j++) {
System.out.print('*');
}
System.out.println();
}
}
}

รูปที่ 3.13 ผลลัพธที่ไดจากการรันโปรแกรมที่ 3.10

โปรแกรมที่ 3.11 แสดงตัวอยางโปรแกรมที่มีคําสั่งโปรแกรมแบบซอนหลายๆ

รูปแบบอยูภายใน โปรแกรมนี้จะสุมเลขจํานวนเต็มมาสองคา แลวจะพิมพตัวเลขเฉพาะ (prime
number) ที่อยูระหวางเลขทั้งสองนั้นออกมา ซึ่งรูปที่ 3.14 แสดงตัวอยางผลลัพธที่ไดจากการ
รันโปรแกรมที่ 3.11

Java Programming 93
 โปรแกรมที่ 3.11 ตัวอยางการใชคําสั่งโครงสรางแบบซอนหลายรูป

public class SampleNested {

public static void main(String args[]) {
int n1 = (int) (Math.random()*10)+2;
int n2 = (int) (Math.random()*50);
boolean flag = false;
int j = 0;
System.out.println("The prime number between "+
n1+" to "+n2+" are ");
for (int i=n1; i<=n2; i++) {
flag = false;
j = 2;
do {
if ((i % j++) == 0)
flag = true;
} while ((j < i) & (flag==false));
if (flag==false)
System.out.print(i+" ");
}
}
}

รูปที่ 3.14 ตัวอยางผลลัพธที่ไดจากการรันโปรแกรมที่ 3.11

3.4.1 คําสั่ง break, continue และ label

คําสั่ง break และ continue เปนคําสั่งที่ใชในโครงสรางแบบทําซ้ํา เพื่อที่จะ
ควบคุมการทํางานของคําสั่งในบล็อก { } โดยคําสั่ง break จะทําใหหยุดสิ้นสุดการทํางานของ
โครงสรางแบบทําซ้ํา สวนคําสั่ง continue จะขามการทํางานคําสั่งที่เหลือภายในบล็อก { }
โดยไปเริ่มการทําซ้ําในรอบตอไปใหม

94 คณะเทคโนโลยีสารสนเทศ สถาบันเทคโนโลยีพระจอมเกลาเจาคุณทหารลาดกระบัง
 ตัวอยางเชน คําสั่ง
for(int i = 1; i <= 5; i++) {
if (i == 3)
break;
System.out.println(i);
}
จะพิมพคา i ตั้งแต 1 ถึง 2 ออกมา แลวจะหยุดการทํางานของคําสั่ง แตถาเปลี่ยน
จากคําสั่ง break ไปเปนคําสัง่ continue ดังนี้
for(int i = 1; i <= 5; i++) {
if (i == 3)
continue;
System.out.println(i);
}
โปรแกรมจะพิมพคา i ตั้งแต 1 ถึง 5 โดยขามคาที่ 3 ทั้งนี้เนื่องจากเจอคําสั่ง
continue
ในกรณีของคําสั่งโครงสรางควบคุมแบบซอน ถาคําสั่ง break หรือ continue
ปรากฏอยูในคําสั่งโครงสรางแบบทําซ้ําที่อยูขางใน คําสั่งโครงสรางแบบทําซ้ําที่อยูขางนอกจะ
ยังทําซ้ําตอ โปรแกรมที่ 3.12 แสดงตัวอยางของการใชคําสั่งโครงสรางควบคุมแบบซอนที่มี
คําสั่ง break อยูในคําสั่งโครงสรางแบบทําซ้ําที่อยูขางใน โปรแกรมนี้จะรันคําสั่ง break
เมื่อ j มีคาเปน 3 โดยคําสั่งในคําสั่ง for ภายในจะหยุดทํางาน แตคําสั่ง for ภายนอก
จะยังทํางานตอ โดยจะไดผลลัพธดังแสดงในรูปที่ 3.15

โปรแกรมที่ 3.12 ตัวอยางการใชคําสั่ง break

public class SampleBreak1 {
public static void main(String args[]) {
int i, j, product;
for (i=1; i<=3; i++) {
for (j=1; j<=3; j++) {
product = i*j;
if (j==3) break;
System.out.println(i+" * "+j+" = "+product);
}
}
}
}

Java Programming 95
 รูปที่ 3.15 ผลลัพธที่ไดจากการรันโปรแกรมที่ 3.12

ในกรณีที่ตองการจะหยุดการทํางานของคําสั่งโครงสรางควบคุมที่อยูภายนอก เราจะ
ตองกําหนด label ขึ้นมาเติม ดังตัวอยางในโปรแกรมที่ 3.13 ซึ่งกําหนด label ที่ชื่อ outer
และมีคําสั่ง break outer; เพื่อที่จะทําใหโปรแกรมหยุดการทํางานของคําสั่ง for
ภายนอก โดยจะไดผลลัพธดังแสดงในรูปที่ 3.16

โปรแกรมที่ 3.13 ตัวอยางการใชคําสั่ง break และ label

public class SampleBreak2 {
public static void main(String args[]) {
int i, j, product;
outer: for (i=1; i<=3; i++) {
for (j=1; j<=3; j++) {
product = i*j;
if (j==3) break outer;
System.out.println(i+" * "+j+" = "+product);
}
}
System.out.println("Outside nested loops.");
}
}

รูปที่ 3.16 ผลลัพธที่ไดจากการรันโปรแกรมที่ 3.13

96 คณะเทคโนโลยีสารสนเทศ สถาบันเทคโนโลยีพระจอมเกลาเจาคุณทหารลาดกระบัง
สรุปเนื้อหาของบท
• คําสั่งโครงสรางควบคุม เปนคําสั่งที่ใชในการกําหนดลําดับการทํางานของคําสั่ง
ตางๆ โดยมีสามรูปแบบคือ โครงสรางแบบตามลําดับ โครงสรางแบบเลือกทํา
และ โครงสรางแบบทําซ้ํา
• คําสั่งที่เปนคําสั่งของโครงสรางแบบเลือกทําคือ คําสั่ง if, if..else หรือ
switch
• คําสั่ง if..else แตกตางจากคําสั่ง if ตรงที่ คําสั่ง if..else จะมีการทํา
คําสั่งสําหรับคาเท็จถานิพจนตรรกศาสตรเปนเท็จ สวนคําสั่ง if จะไมมีการทํา
คําสั่งใดถานิพจนตรรกศาสตรเปนเท็จ
• คําสั่ง หรือ
if if..else สามารถที่จะซอนอยูขางในคําสั่ง if หรือ
if..else อื่นได

• คําสั่ง switch จะมีลักษณะโครงสรางการทํางานคลายคลึงกับคําสั่ง

if..else if..else .. แตชนิดขอมูลของตัวแปรที่จะนํามาใชกับคําสั่ง
switch จะตองเปนชนิด char, byte, short หรือ int เทานั้น

• คําสั่งที่เปนคําสั่งของโครงสรางแบบทําซ้ําคือ คําสั่ง while, do..while

หรือ for
• คําสั่ง while แตกตางจากคําสั่ง do..while ตรงที่ คําสั่ง while จะไมมกี าร
ทําชุดคําสั่งเลยถานิพจนตรรกศาสตรเปนเท็จ สวนคําสั่ง do..while จะมีการ
ทําชุดคําสั่งหนึ่งครั้งถานิพจนตรรกศาสตรเปนเท็จ
• คําสั่ง for มีลักษณะการทํางานที่เหมือนกับคําสั่ง while แตจะมีการรวมคําสั่ง
กําหนดคาเริ่มตน นิพจนตรรกศาสตรและคําสั่งเปลี่ยนแปลงคาไวหลังคําสั่ง for
• คําสั่ง for จะใชในกรณีที่ทราบจํานวนครั้งในการทําซ้ําที่แนนอน สวนคําสั่ง
while หรือ do..while นิยมใชในกรณีที่ไมทราบจํานวนครั้งในการทําซ้ํา
ลวงหนา
• คําสั่งโครงสรางทั้งหมดที่กลาวมาแลวขางตน สามารถนํามาใชรวมกันเปน
ลักษณะแบบซอนได เชน คําสั่ง switch อยูภายในคําสั่ง while หรือคําสั่ง
for อยูภายในคําสั่ง for ซึ่งเรียกโครงสรางในลักษณะนี้วา โครงสรางแบบซอน

Java Programming 97
 • คําสั่ง จะทําใหหยุดสิ้นสุดการทํางานของโครงสรางแบบทําซ้ํา สวนคําสั่ง
break
continue จะขามการทํางานคําสั่งที่เหลือภายในบล็อก { } โดยไปเริ่มการทําซ้ํา
ในรอบตอไปใหม

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

4.1 องคประกอบของโปรแกรมเชิงออปเจ็ค
ภาษาจาวาเปนภาษาคอมพิวเตอร ที่ใชหลักการการพัฒนาโปรแกรมเชิงออปเจ็คที่
เรียกยอวาเปนภาษาคอมพิวเตอรแบบ OOP การพัฒนาโปรแกรมเชิงออปเจ็คจะเปน
ขบวนการการวิเคราะหปญหาโดยการจําลองปญหาวาประกอบไปดวยออปเจ็คใดบาง แลวจึง
เขียนใหอยูในรูปแบบของโปรแกรมคอมพิวเตอร โปรแกรมเชิงออปเจ็คจะมีคํานิยามที่สําคัญ
สองคําคือ ออปเจ็ค (object) และคลาส (class)

4.1.1 ออปเจ็ค
ออปเจ็คคือสิ่งตางๆที่มีอยูในชีวิตประจําวันแบงไดเปนสองประเภทคือ
1. สิ่งที่เปนรูปธรรม (tangible) คือสิ่งที่เปนวัตถุและจับตองไดอาทิเชน นักศึกษา ใบ
ลงทะเบียน ปากกา และรถ เปนตน
2. สิ่งที่เปนนามธรรม (intangible) คือสิ่งที่ไมสามารถจับตองไดอาทิเชน คะแนน
รายชื่อวิชา บัญชีเงินฝาก และตารางเที่ยวบิน เปนตน
ออปเจ็คตางๆจะประกอบไปดวยคุณลักษณะ (attribute) และพฤติกรรม
(behavior)คุณลักษณะก็คือขอมูลของออปเจ็ค สวนพฤติกรรมหรือเรียกวาเมธอด (method) คือ
สิ่งที่ ออปเจ็คสามารถกระทําได ซึ่งในโปรแกรมเชิงออปเจ็คก็คือคําสั่งในการทํางาน
โปรแกรมเชิงออปเจ็คจะประก อบดวยออปเจ็คตางๆหลายออปเจ็ค ซึ่งแตละออปเจ็คจะ

Java Programming 99
 มีคุณลักษณะตางๆที่เปนขอมูลของออปเจ็ค และโปรแกรมสามารถจัดการกับขอมูลเหลานี้ได
โดยการเรียกใชเมธอดตางๆ
ตัวอยางของออปเจ็ค
• นักศึกษา อาจจะประกอบไปดวยคุณลักษณะเชน รหัส ชื่อ และเกรดเฉลี่ย
และอาจจะมีเมธอดเชน ลงทะเบียน สอบ และเดิน
• รถยนต อาจจะประกอบไปดวยคุณลักษณะเชน ยี่หอ รุน และสี
และอาจจะมีเมธอดเชน เคลื่อนที่ หยุดและเลี้ยว
• สุนัข อาจจะประกอบไปดวยคุณลักษณะเชน ชื่อ พันธุ และสี
และอาจจะมีเมธอดเชน เหา คลาน และกระดิกหาง
ตัวอยางของโปรแกรมเชิงออปเจ็คอาจยกตัวอยางของโปรแกรมระบบจัดการบัญชีเงิน
ฝากของธนาคาร ซึ่งอาจประกอบไปดวยออปเจ็คตางๆอาทิเชน บัญชี (Account) ลูกคา
(Customer) เครื่องเอทีเอ็ม (ATM) และรายการ (Transaction) ออปเจ็คชนิดบัญชีอาจจะมี
ขอมูลภายในตางๆอาทิเชน เลขที่บัญชี ชื่อเจาของบัญชี วันที่เปดบัญชี และยอดเงินคงเหลือ
เปนตน ออปเจ็คชนิดบัญชีอาจจะมีเมธอดตางๆอาทิเชน ฝาก ถอน และการโอนเงิน เปนตน

4.1.2 คลาส
โดยทั่วไปโปรแกรมเชิงออปเจ็คแตละโปรแกรมจะประกอบไปดวยออปเจ็ค ที่เปนชนิด
เดียวกันหลายๆออปเจ็คแตอาจมีขอมูลหรือคุณลักษณะที่ตางกันอาทิเชน โปรแกรมระบบ
จัดการบัญชีเงินฝากของธนาคารอาจมีออปเจ็คชนิดบัญชีหลายๆออปเจ็ค โดยที่แตละ
ออปเจ็คอาจจะมีขอมูลที่เปนเลขที่บัญชีหรือชื่อเจาของบัญชีที่ตางกัน โปรแกรมเชิงออปเจ็คจะ
มีคําสั่งในการสรางออปเจ็คโดยสรางมาจากคลาสซึ่งเปนตัวกําหนดนิยามของออปเจ็ควาจะตอง
ประกอบดวยคุณลักษณะและเมธอดใดบาง
คลาสเปรียบเสมือนพิมพเขียวของออปเจ็ค ออปเจ็คที่ถูกสรางมาจากคลาสบางครั้งจะ
เรียกวาเปน instance ของคลาส ซึ่งออปเจ็คใดๆจะตองเปน instance ของคลาสใดคลาสหนึ่ง
การเขียนโปรแกรมเชิงออปเจ็ค ตองมีการกําหนดนิยามของคลาสกอนที่จะสามารถสราง
ออปเจ็ค (หรือ instance) ของคลาสได ซึ่งคลาสหนึ่งคลาสสามารถที่จะสรางออปเจ็คไดหลาย
ออปเจ็ค รูปที่ 4.1 แสดงตัวอยางของคลาส Student ซึ่งสรางออปเจ็คขึ้นมาสามออปเจ็คที่
ชื่อ s1, s2 และ s3 เปนตน

100 คณะเทคโนโลยีสารสนเทศ สถาบันเทคโนโลยีพระจอมเกลาเจาคุณทหารลาดกระบัง

 รูปที่ 4.1 ตัวอยางของออปเจ็คและคลาส

4.1.3 คุณลักษณะ
คุณลักษณะของออปเจ็คคือขอมูลที่เก็บอยูในออปเจ็ค ซึ่งจะแบงออกเปนสองประเภท
คือตัวแปร (variable) และคาคงที่ (constant) โดยที่คุณลักษณะที่เปนตัวแปรจะสามารถเปลี่ยน
คาได สวนคุณลักษณะที่เปนคาคงที่จะไมสามารถเปลี่ยนคาได รูปที่ 4.2 แสดงตัวอยางของ
ออปเจ็ค s1,s2 และ s3 ที่เปนออปเจ็คของคลาส Student ซึ่งมีคุณลักษณะของออปเจ็คที่
เปนรหัส ชื่อ และคะแนนเฉลี่ยสะสมที่ตางกัน โดยกําหนดในคาของตัวแปร id, name และ
gpa ตามลําดับ

รูปที่ 4.2 ตัวอยางคุณลักษณะของออปเจ็ค

Java Programming 101

 โปรแกรมเชิงออปเจ็คไดกําหนดนิยามคุณลักษณะอีกประเภทหนึ่ง ที่เรียกวา
คุณลักษณะของคลาส (class data value) ซึ่งจะเปนคุณลักษณะที่ทุกออปเจ็คใชรวมกัน อาทิ
เชน คลาส Student อาจกําหนดใหมีคุณลักษณะของคลาสที่เปนคาคงที่ที่ชื่อ MIN_GPA
เพื่อเก็บคาคะแนนเฉลี่ยสะสมขั้นต่ําของนักศึกษาทุกคน ทั้งนี้นักศึกษาทุกคนจะตองมีคา
คะแนนเฉลี่ยสะสมสูงกวาคะแนนเฉลี่ยสะสมขั้นต่ํา การเก็บคุณลักษณะที่เหมือนกันเชนนี้ถา
กําหนดใหเปนคุณลักษณะของออปเจ็คจะทําใหสิ้นเปลืองเนื้อที่ในหนวยความจํา ดังแสดงให
เห็นในรูปที่ 4.3 (ก) แตถากําหนดใหเปนคุณลักษณะของคลาสจะทําใหสามารถประหยัดพื้นที่
ในหนวยความจําไดดังแสดงใหเห็นในรูปที่ 4.3 (ข)

(ก) คุณลักษณะของออปเจ็ค

102 คณะเทคโนโลยีสารสนเทศ สถาบันเทคโนโลยีพระจอมเกลาเจาคุณทหารลาดกระบัง

 (ข) คุณลักษณะของคลาส
รูปที่ 4.3 คุณลักษณะ MIN_GPA ซึ่งเปนคุณลักษณะของออปเจ็คและคลาส

4.1.4 เมธอด
เมธอดเปนวิธีการหรือการกระทําที่นิยามอยูในคลาสหรือออปเจ็คเพื่อใชในการจัดการ
กับคุณลักษณะของออปเจ็คหรือคุณลักษณะของคลาสอาทิเชน ออปเจ็คชนิดบัญชีเงินฝากอาจ
มีคุณลักษณะ balance เพื่อเก็บยอดเงินคงเหลือที่อยูในบัญชี และอาจมีเมธอด
deposit()เพื่อเปนวิธีการในการฝากเงินใหกับออปเจ็ค ในเมธอดจะมีคําสั่งเพื่อจัดการกับ
วิธีการฝากเงินและจะทําการปรับเปลี่ยนคาของคุณลักษณะ balance เราสามารถ
เปรียบเทียบเมธอดไดกับฟงกชัน Procedure หรือ Subroutine ของโปรแกรมเชิงกระบวนการ
การเขียนโปรแกรมเชิงออปเจ็คจะกําหนดใหออปเจ็คตางๆสื่อสารกัน โดยการผาน
ขาวสาร (message) ระหวางออปเจ็คที่เปนผูสง (Sender) กับออปเจ็คที่เปนผูรับ (Receiver)
โดยการเรียกใชเมธอดอาทิเชน รูปที่ 4.4 แสดงตัวอยางของการสงขาวสารจากออปเจ็ค objA
ที่เปนผูสง เพื่อเรียกการทํางานของเมธอด method4() ของออปเจ็ค objB ที่เปนผูรับ การ
สงขาวสารระหวางกันอาจมีการสงขอมูลจาก objA ผานไปยัง objB โดยผานทาง argument

Java Programming 103

 ของเมธอด (ตัวอยางเชน คา 1 และ 2 ในรูปที่ 4.4) และผูรับก็อาจสงคากลับ (return value)
มายังผูสง

รูปที่ 4.4 ตัวอยางของการสงขาวสารระหวางออปเจ็ค

4.2 การเขียนโปรแกรมเชิงออปเจ็คโดยใชภาษาจาวา
4.2.1 การประกาศคลาส
โปรแกรมภาษาจาวาแตละโปรแกรมจะประกอบไปดวย คลาสอยางนอยหนึ่งคลาส
โดยมีรูปแบบการประกาศดังนี้

[modifier] class ClassName {

[class member]
}

โดยที่
• modifier คือคียเวิรด (keyword) ของภาษาจาวาที่ใชเปน access modifier
เชน public หรืออธิบายคุณสมบัติอื่นๆของคลาส เชน abstract และ
final ซึ่งเปนเงื่อนไขเพิ่มเติม (option)

• class คือคียเ วิรดของภาษาจาวาเพื่อระบุวาเปนการประกาศคลาส

• ClassName คือชื่อของคลาสที่เปนชื่อ identifier ใดๆที่สอดคลองกับกฎการตั้ง
ชื่อ

104 คณะเทคโนโลยีสารสนเทศ สถาบันเทคโนโลยีพระจอมเกลาเจาคุณทหารลาดกระบัง

 • class member คือเมธอดหรือคุณลักษณะของคลาส
ตัวอยางการประกาศคลาส Student สามารถทําไดดังนี้
public class Student {
}

4.2.2 การประกาศคุณลักษณะ
คุณลักษณะของออปเจ็คคือตัวแปรหรือคาคงที่ซึ่งประกาศภายในออปเจ็ค โดยมี
รูปแบบการประกาศดังนี้

[modifier] dataType attributeName;

โดยที่
• modifier คือคียเวิรดของภาษาจาวาที่อธิบายคุณสมบัติตางๆของตัวแปรหรือ
คาคงที่อาทิเชน public, private, static, final และ
transient เปนตน

• dataType คือชนิดขอมูลซึ่งอาจเปนชนิดขอมูลแบบพื้นฐานหรือชนิดขอมูลแบบ
อางอิงทีจะกลาวถึงในบทตอไป
• attributeName คือชื่อของคุณลักษณะที่เปนชื่อ identifier ใดๆซึ่งสอดคลอง
กับกฎการตั้งชื่อ
ตัวอยางการประกาศคุณลักษณะ id, name และ gpa ซึ่งมีชนิดขอมูลเปน
String และ double ในคลาส Student สามารถทําไดดังนี้
public class Student {
public String id;
public String name;
public double gpa;
}

4.2.3 การประกาศเมธอด
ภาษาจาวากําหนดรูปแบบของการประกาศเมธอดที่อยูในคลาสไวดังนี้

Java Programming 105

 [modifier] return_type methodName([arguments]) {
[method_body]
}

โดยที่
• modifier คือคียเวิรดของภาษาจาวาที่เปน access modifier เชน public
หรือ private หรืออธิบายคุณสมบัติอื่นๆของเมธอดเชน abstract หรือ
static เปนตน

• return_type คือชนิดขอมูลของคาที่สงกลับหลังจากเสร็จสิ้นการทํางานของ
คําสั่งในเมธอดนี้ โดยชนิดขอมูลของคาที่สงกลับอาจเปนชนิดขอมูลแบบพื้นฐาน
หรือชนิดขอมูลแบบอางอิง ในกรณีที่ไมมีการสงคาใดๆกลับจะตองระบุชนิดขอมูล
เปน void
• methodName คือชื่อของเมธอดที่เปนชื่อ identifier ใดๆซึ่งสอดคลองกับกฎการ
ตั้งชื่อ
• arguments คือตัวแปรที่ใชในการรับขอมูลที่ออปเจ็คสงมาให โดยอาจมี
มากกวาหนึ่งตัวแปร หรือไมมีเลยก็ไดขึ้นอยูกับการกําหนดเมธอด
• method_body คือคําสั่งตางๆของภาษาจาวาที่อยูในเมธอด
โปรแกรมที่ 4.1 แสดงตัวอยางโปรแกรมภาษาจาวาที่ประกาศคลาส Student โดยมี
คุณลักษณะคือ id, name, gpa และ MIN_GPA และมีเมธอดคือ setID(),
setName(), setGPA() และ showDetails()

106 คณะเทคโนโลยีสารสนเทศ สถาบันเทคโนโลยีพระจอมเกลาเจาคุณทหารลาดกระบัง

โปรแกรมที่ 4.1 คลาส Student
public class Student {
public String id;
public String name;
public double gpa;
public static final double MIN_GPA = 2.00;

public void setID(String ID) {

id = ID;
}
public void setName(String n) {
name = n;
}
public void setGPA(double GPA) {
gpa = GPA;
}
public void showDetails() {
System.out.println("ID: "+id);
System.out.println("Name: "+name);
System.out.println("GPA: "+gpa);
}
}

เมธอด main()
โปรแกรมภาษาจาวาที่เปนโปรแกรมจาวาประยุกต (Java Application) จะเริ่มตนการ
ทํางานในคลาสที่มีเมธอด main() โดยมีรูปแบบของเมธอดดังนี้

public static void main (String args[]) {

[method_body]
}

4.2.4 การประกาศและสรางออปเจ็ค
ออปเจ็คทุกออปเจ็คในโปรแกรมภาษาจาวาจะตองมีคําสั่งประกาศเพื่อระบุวาออปเจ็ค
นั้นเปนออปเจ็คของคลาสใด โดยมีรูปแบบดังนี้

[modifier] ClassName objectName;

โดยที่

Java Programming 107

 • modifier คือคียเวิรดที่อธิบายคุณสมบัติตางๆของออปเจ็ค
• ClassName คือชื่อของคลาส
• objectName คือชื่อของออปเจ็คที่เปนชื่อ identifier ใดๆซึ่งสอดคลองกับกฏ
การตั้งชื่อ
ตัวอยางเชน คําสั่ง
Student s1;
เปนคําสั่งประกาศออปเจ็ค s1 ใหเปนออปเจ็คของคลาส Student ทั้งนี้คลาสที่ระบุ
ในคําสั่งประกาศออปเจ็คจะตองเปนคลาสที่มีการนิยามไวแลว กลาวคือจะตองมีคลาส
Student ที่นิยามไวแลว

คําสั่งในการประกาศออปเจ็คไมไดเปนคําสั่งที่ใชในการสรางออปเจ็ค คําสั่งที่ใชในการ
สรางออปเจ็คจะมีรูปแบบดังนี้

objectName = new ClassName([arguments]);

โดยที่
• objectName คือชื่อของออปเจ็ค
• new คือคียเวิรดของภาษาจาวาเพื่อใชในการสรางออปเจ็ค
• ClassName คือชื่อของคลาส
• arguments คือคาที่ตองการสงผานในการเรียกเมธอดในการสรางออปเจ็คซึ่ง
อาจมีหรือไมมีกไ็ ด
การสรางออปเจ็คโดยเรียกใชคําสั่ง new นี้จะเปนการเรียกใชเมธอดในการสราง
ออปเจ็คที่เรียกวา constructor ของคลาสนั้นๆ ซึ่งจะมีการอธิบายการทํางานของ constructor
ในบทที่ 5
ตัวอยางคําสั่งในการสรางออปเจ็ค s1 ทําไดดังนี้
s1 = new Student();
นอกจากนี้คําสั่งในการประกาศและสรางออปเจ็คสามารถที่จะรวมเปนคําสั่งเดียวกัน
ไดโดยมีรูปแบบคําสั่งดังนี้

[modifier] ClassName objectName =

new className([arguments]);

108 คณะเทคโนโลยีสารสนเทศ สถาบันเทคโนโลยีพระจอมเกลาเจาคุณทหารลาดกระบัง

 อาทิเชน
Student s1 = new Student();

4.2.5 การเรียกใชสมาชิกของออปเจ็ค
สมาชิกของออปเจ็คประกอบดวยคุณลักษณะและเมธอด การเรียกใชสมาชิกของ
ออปเจ็คทําไดโดยการใชเครื่องหมายจุด (.) กลาวคือคุณลักษณะของออปเจ็คสามารถเรียกใช
โดยมีรูปแบบดังนี้

objectName.attributeName;

โดยที่
• objectName คือชื่อของออปเจ็คที่สรางขึ้น
• attributeName คือชื่อของคุณลักษณะของออปเจ็คนั้น
นอกจากนี้เราสามารถที่จะสงขาวสารไปยังออปเจ็คภายหลังจากที่มีการสรางออปเจ็ค
ขึ้นมาไดโดยการเรียกใชเมธอดของออปเจ็คนั้น รูปแบบคําสั่งในการเรียกใชเมธอดมีดังนี้

objectName.methodName([arguments]);

โดยที่
• objectName คือชื่อของออปเจ็คที่สรางขึ้น
• methodName คือชื่อของเมธอดของออปเจ็คนั้น
• arguments คือคาที่ตองการสงผานไปใหกับเมธอดของออปเจ็คนั้น โดยที่
จะตองมีชนิดขอมูลและจํานวน argument ใหสอดคลองกับที่ประกาศในเมธอด
ของออปเจ็คนั้น
ตัวอยางเชน คําสั่ง
s1.setName(“Thana”);
เปนการเรียกใชเมธอด setName() ของออปเจ็ค s1 ซึ่งเปนออปเจ็คของคลาส
Student โดยจะสงผาน argument ชนิด String ที่มีคาเปนขอความ Thana ใหกับ
เมธอดดังกลาว โปรแกรมที่ 4.2 แสดงตัวอยางโปรแกรมของคลาส Sample ที่มีเมธอด
main()อยู โดยโปรแกรมนี้จะสรางออปเจ็คของคลาส Student ขึ้นมาสามออปเจ็คคือ
ออปเจ็ค s1, s2 และ s3 จากนั้นจะทําการเรียกเมธอด setName() เพื่อกําหนดคาให

Java Programming 109

 กําหนดคาใหกับคุณลักษณะ name ของออปเจ็คแตละตัว ซึ่งผลลัพธของโปรแกรมนี้จะได
ออปเจ็คดังแสดงในรูปที่ 4.5

โปรแกรมที่ 4.2 คลาส Sample

public class Sample {
public static void main(String args[]) {
Student s1 = new Student();
Student s2 = new Student();
Student s3 = new Student();
s1.setID("1234");
s1.setName("Thana");
s1.setGPA(3.25);
s2.setID("1122");
s2.setName("Somchai");
s2.setGPA(2.90);
s3.setID("2211");
s3.setName("Somsri");
s3.setGPA(3.00);
}
}

รูปที่ 4.5 ผลลัพธของโปรแกรมที่ 4.2

110 คณะเทคโนโลยีสารสนเทศ สถาบันเทคโนโลยีพระจอมเกลาเจาคุณทหารลาดกระบัง

4.3 คุณลักษณะเดนของโปรแกรมเชิงออปเจ็ค
โปรแกรมเชิงออปเจ็ค จะมีคุณลักษณะเดนอยูสามประการคือ การหอหุม
(Encapsulation) การสืบทอด (Inheritance) และการมีไดหลายรูปแบบ (Polymorphism)

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

รูปที่ 4.6 หลักการของการหอหุม

ออปเจ็คแตละออปเจ็คจะประกอบไปดวยสวนที่เปน interface และสวนที่เปน
implementation สวนที่เปน interface คือสวนของออปเจ็คที่อนุญาตใหออปเจ็คอื่นสามารถ
เรียกใชงานได ซึ่งในภาษาจาวาก็คือคุณลักษณะหรือเมธอดที่ถูกประกาศใหมี access modifier
เปน public สําหรับสวนที่เปน implementation คือสวนของออปเจ็คที่ไมสามารถเขาถึงได
จากภายนอก ออปเจ็คอื่นๆจะไมสามารถเห็นสวนที่เปน implementation ของออปเจ็คได ใน
ภาษาจาวาก็คือคุณลักษณะหรือเมธอดที่ถูกประกาศใหมี access modifier เปน private
การเขียนโปรแกรมเชิงออปเจ็คโดยใชหลักการของการหอหุม สามารถทําไดโดย
กําหนดใหคุณลักษณะของออปเจ็คมี access modifier เปน private และกําหนดใหเมธอดที่
สามารถเรียกจากออปเจ็คภายนอกไดมี access modifier เปน public ดังแสดงในตัวอยาง
โปรแกรมที่ 4.3

Java Programming 111

 โปรแกรมที่ 4.3 การใชหลักการของการหอหุม
public class Student {
private String id;
private String name;
private double gpa;
private static final double MIN_GPA = 2.00;

public void setID(String ID) {

id = ID;
}
public void setName(String n) {
name = n;
}
public void setGPA(double GPA) {
gpa = GPA;
}
public void showDetails() {
System.out.println("ID: "+id);
System.out.println("Name: "+name);
System.out.println("GPA: "+gpa);
}
}

ขอดีของการหอหุมคือ
• การซอนเรนขอมูล (Information Hiding) ทําใหออปเจ็คสามารถติดตอกับออปเจ็ค
ภายนอกผานเมธอดที่เปนสวนของ interface เทานั้น ซึ่งถามีการเปลี่ยนแปลง
คุณลักษณะหรือเมธอดที่อยูภายในออปเจ็ค ก็จะไมมผี ลกระทบใดๆตอออปเจ็ค
ภายนอกที่เรียกใช
• ความเปนโมดูล (Modularity) การพัฒนาโปรแกรมเชิงออปเจ็คจะสามารถ
กําหนดใหออปเจ็คแตละออปเจ็คมีความเปนอิสระตอกัน ถามีการเปลี่ยนแปลง
เกิดขึ้นภายในออปเจ็คหนึ่งก็จะไมมีผลกระทบตอออปเจ็คอื่น
เครื่องโทรศัพทเปนตัวอยางหนึ่ง ของการแสดงคุณลักษณะเดนดานการหอหุมของ
ออปเจ็ค สวนที่เปน interface ก็คือปุมของโทรศัพทที่ผูใชสามารถติดตอกับเครื่องได สําหรับ
ระบบอิเล็กทรอนิกสที่อยูในเครื่องโทรศัพทคือสวนที่เปน implementation ซึ่งผูใชไมสามารถ
มองเห็นและไมจําเปนตองเขาใจการทํางานของระบบดังกลาว และหากระบบอิเล็กทรอนิกส
ภายในเปลี่ยนแปลงไป ผูใชยงั สามารถที่จะติดตอกับเครื่องไดโดยใชปุมที่เปนสวน interface
เชนเดิม

112 คณะเทคโนโลยีสารสนเทศ สถาบันเทคโนโลยีพระจอมเกลาเจาคุณทหารลาดกระบัง

4.3.2 การสืบทอด
คุณลักษณะเดนประการหนึ่งของการโปรแกรมเชิงออปเจ็คคือ ความสามารถที่จะ
นําเอาโปรแกรมที่ออกแบบไวแลวมาใชใหมได ซึ่งสําหรับโปรแกรมเชิงกระบวนการจะทําได
โดยการกําหนดคําสั่งที่ตองใชบอยไวในโปรแกรมยอย (ฟงกชั่น หรือ Procedure) ซึ่งจะมีความ
ซับซอนในการออกแบบเพื่อใหไดโปรแกรมยอยที่เหมาะสม ทําใหการนําโปรแกรมมาใชใหม
ของโปรแกรมเชิงกระบวนการคอนขางจะเปนไปไดยากกวา และเมื่อโปรแกรมมีความซับซอน
ขึ้น การนําโปรแกรมมาใชใหมก็เปนไปไดยากขึ้น เนื่องจากเราไมสามารถออกแบบโปรแกรม
ครอบคลุมปญหาทั้งหมดไวลวงหนาได
วิธีการนําโปรแกรมมาใชใหมของโปรแกรมเชิงออปเจ็ค จะใชหลักการของการสืบทอด
ซึ่งเปนการนิยามคลาสใหมจากรูปแบบของคลาสที่มีอยูแลว โดยคลาสใหมจะนําคุณลักษณะ
และเมธอดของคลาสเดิมมาใชได โดยทั่วไปคลาสตางๆที่มีอยูจะมีโครงสรางที่มีความสัมพันธ
กันตามลําดับชั้น เราสามารถที่จะออกแบบโปรแกรมเชิงออปเจ็คเพื่อสรางคลาสที่เปนคลาส
แบบทั่วไป (generalized class) ซึ่งจะมีคุณลักษณะและเมธอดเพื่อใหคลาสอื่นๆที่เปนคลาส
เฉพาะ (specific class) สืบทอดได คลาสที่เปนคลาสแบบทั่วไปจะเรียกวาเปน superclass
หรือ parent class สวนคลาสที่เปนคลาสเฉพาะที่สืบทอดมาจะเรียกวาเปน subclass หรือ
child class
รูปที่ 4.7 แสดงตัวอยางของคลาสที่ใชหลักการของการสืบทอด ตัวอยางนี้จะมีคลาส
Student เปนคลาสแบบทั่วไป และมีคลาส GradStudent, PartTimeStudent
และ FullTimeStudent สืบทอดมาจากคลาส Student และคลาส PhDStudent จะ
สืบทอดมาจากคลาส GradStudent อีกชั้นหนึ่ง การสืบทอดจะมีผลใหคุณลักษณะและ
เมธอดของ Superclass สืบทอดไปยัง Subclass ตัวอยางเชน ถาคลาส Student ในรูปที่
4.7 มีคุณลักษณะ id, name, gpa และ MIN_GPA และมีเมธอด setID(),
setName(), setGPA() และ showDetails() คลาส GradStudent,
PartTimeStudent และ FullTimeStudent ก็จะสืบทอดคุณลักษณะและเมธอด
เหลานั้นมาดวย นอกจากนี้คลาส PhDStudent ที่สืบทอดมาจากคลาส GradStudent ก็
จะไดรับคุณลักษณะและเมธอดที่สืบทอดมาจากคลาส Student ที่เปน superclass ของคลาส
GradStudent ดวย

Java Programming 113

 รูปที่ 4.7 ตัวอยางของคลาสที่ใชหลักการของการสืบทอด

ขอดีของการสืบทอดคือ ความสามารถในการที่จะนําโปรแกรมเดิมมาพัฒนาเพิ่มเติม
ใหมไดงายขึ้น และยังชวยทําใหโปรแกรมแตละโปรแกรมมีขนาดเล็ก ซึ่งทําใหงายตอการเขาใจ
และการปรับปรุงแกไขโปรแกรมทําไดงายขึ้น โดยในภาษาจาวาจะใชคียเวิรด extends เพื่อ
ระบุการสืบทอด โปรแกรมที่ 4.4 แสดงตัวอยางของคลาสที่ใชหลักการในการสืบทอดตาม
ไดอะแกรมของคลาสในรูปที่ 4.7

โปรแกรมที่ 4.4 ตัวอยางการใชหลักการในการสืบทอด

public class PartTimeStudent extends Student { }

public class FullTimeStudent extends Student { }

public class GradStudent extends Student {

private String thesisTitle;
private String supervisor;
public void setThesisTitle(String t) {
thesisTitle = t;
}
public void setSupervisor(String s) {
supervisor = s;
}
}

public class PhDStudent extends GradStudent {

public boolean passQualify;
public boolean isPassQualify() {
return passQualify;
}
}

114 คณะเทคโนโลยีสารสนเทศ สถาบันเทคโนโลยีพระจอมเกลาเจาคุณทหารลาดกระบัง

4.3.3 การมีไดหลายรูปแบบ
หลักการของการมีไดหลายรูปแบบคือ คุณสมบัติของโปรแกรมเชิงออปเจ็คที่สามารถ
ตอบสนองตอขาวสาร (เมธอด) เดียวกันดวยวิธีการที่ตางกัน และสามารถกําหนดออปเจ็คได
หลายรูปแบบ หลักการของการมีไดหลายรูปแบบเปนหลักการที่สืบเนื่องมาจากหลักการของ
การสืบทอด ตัวอยางเชน รูปที่ 4.8 มีคลาส Ball ซึ่งเปน superclass ของคลาส
SoccerBall และ TennisBall

รูปที่ 4.8 ตัวอยางของคลาส Ball

คลาส Ball อาจมีเมธอด throwBall() เพื่อกําหนดพฤติกรรมการโยนลูกบอล

ซึ่ง subclass ที่ชื่อ SoccerBall และ TennisBall อาจกําหนดวิธีการการโยนลูกบอลแต
ละชนิดที่ตางกันกลาวคือเขียนคําสั่งในเมธอด throwBall() ที่สืบทอดมาดวยชุดคําสั่งที่
ตางกันดังแสดงในโปรแกรมที่ 4.5 หลักการของการมีไดหลายรูปแบบยังรวมไปถึงความ
สามารถที่จะอางอิงออปเจ็คที่สืบทอดมาไดหลายรูปแบบ ตัวอยางเชนคลาส SoccerBall ที่
สืบทอดมาจากคลาส Ball สามารถที่จะอางอิงออปเจ็คของคลาส SoccerBall ไดทั้งใน
รูปแบบของ SoccerBall หรือ Ball ได ตัวอยางเชนคําสั่ง
SoccerBall b2 = new SoccerBall();
Ball b3 = new SoccerBall();
ซึ่งขอดีของการใชหลักการของการมีไดหลายรูปแบบคือ ทําใหโปรแกรมสามารถ
ปรับเปลี่ยนหรือเพิ่มเติมไดงายขึ้น

Java Programming 115

 โปรแกรมที่ 4.5 ตัวอยางการใชหลักการของการมีไดหลายรูปแบบ

public class Ball {

public void throwBall() { }
}
public class SoccerBall extends Ball {
public void throwBall() {
System.out.println(“Throwing soccerball”);
}
}
public class TennisBall extends Ball {
public void throwBall() {
System.out.println(“Throwing tennisball”);
}
}
public class TestBall {
public static void main(String args[]) {
Ball b1 = new Ball();
SoccerBall b2 = new SoccerBall();
Ball b3 = new SoccerBall();
}
}

4.4 Unified Modeling Language

Unified Modeling Language (UML) เปนภาษาที่ใชรูปกราฟฟกเพื่อจําลองระบบ
ซอฟตแวร UML ถูกพัฒนาขึ้นเพื่อจําลองโปรแกรมเชิงออปเจ็คในตนทศวรรษที่ 1990 ซึ่งใน
ปจจุบัน UML ไดกลายเปนมาตรฐานที่ใชในการจําลองระบบซอฟตแวรตามขอกําหนดของ
OMG (Object Management Group) หนังสือเลมนี้จะใชสัญลักษณของ UML ในการจําลอง
ระบบโปรแกรมตางๆ แตเนื่องจาก UML เปนภาษาที่มีขอกําหนดตางๆมาก ดังนั้นเนื้อหาใน
บทนี้จะกลาวถึงเฉพาะสวนตางๆที่จําเปนตอความเขาใจที่จะใชในหนังสือเลมนี้เทานั้น

4.4.1 ไดอะแกรมของคลาส
ไดอะแกรมของคลาส (Class Diagram) เปนสัญลักษณที่ใชแสดงคลาสใน UML โดย
ไดอะแกรมของคลาสจะประกอบดวยสวนตางๆสามสวนคือ ชื่อของคลาส คุณลักษณะภายใน
คลาส และเมธอดภายในคลาส ดังแสดงในรูปที่ 4.9 ไดอะแกรมของคลาสจะระบุขอมูลตางๆ
สําหรับคุณลักษณะภายในคลาสคือ ชื่อของคุณลักษณะ ชนิดขอมูล สถานะการเขาถึง
(access modes) และคาเริ่มตน สวนเมธอดภายในคลาสจะระบุถึงสถานะการเขาถึง ชื่อของ

116 คณะเทคโนโลยีสารสนเทศ สถาบันเทคโนโลยีพระจอมเกลาเจาคุณทหารลาดกระบัง

เมธอด ชนิดขอมูลของ argument และชนิดขอมูลของคาที่สงกลับ สําหรับสถานะการเขาถึง
UML ไดกําหนดสัญลักษณตางๆไวดังนี้
+ สําหรับ public
- สําหรับ private

รูปที่ 4.9 ตัวอยาง UML ของคลาส Student

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

4.4.2 ไดอะแกรมของออปเจ็ค
UML สามารถที่จะแสดงใหเห็นไดวาออปเจ็คที่สรางขึ้นมาเปนออปเจ็คของคลาสใด
และมีคาของคุณลักษณะตางๆอยางไร โดยใชไดอะแกรมของออปเจ็ค (Object Diagram) ที่
ประกอบไปดวยสวนตางๆสองสวนคือ สวนที่ระบุชื่อของออปเจ็ค และสวนที่ระบุคาของ
คุณลักษณะภายในออปเจ็ค ดังตัวอยางในรูปที่ 4.10 ซึ่งเปนการแสดงออปเจ็ค s1 และ s2
ของคลาส Student จากรูปจะเห็นไดวาสัญลักษณลูกศรที่เปนเสนปะจะเปนการระบุวา
ออปเจ็ค s1 เปนออปเจ็คของคลาส Student

Java Programming 117

 รูปที่ 4.10 ไดอะแกรมของออปเจ็ค s1 และ s2 ของคลาส Student

4.5 ขั้นตอนการพัฒนาโปรแกรม
การพัฒนาโปรแกรมคอมพิวเตอร ไมไดหมายถึงเพียงแคการเขียนโปรแกรมคําสั่ง
ภาษาคอมพิวเตอรภาษาใดภาษาหนึ่ง แตจะรวมถึงขั้นตอนทั้งหมดในการพัฒนาโปรแกรม ซึ่ง
ขั้นตอนการพัฒนาโปรแกรมนี้เรียกวา วัฎจักรการพัฒนาโปรแกรม (Software Development
Life Cycle เรียกยอวา SDLC) ซึ่งจะประกอบไปดวยขั้นตอนตางๆ 5 ขั้นตอนคือ
1. ขั้นตอนการวิเคราะห (Analysis)
2. ขั้นตอนการออกแบบ (Design)
3. ขั้นตอนการเขียนโปรแกรม (Programming)
4. ขั้นตอนการทดสอบ (Testing)
5. ขั้นตอนการทํางาน (Operation)
ซึ่งแตละขั้นตอนมักไมไดผลลัพธที่สมบูรณที่จะสามารถทําขั้นตอนตอไปได โดยไม
ตองกลับมาทําขั้นตอนเดิมอีก แตระหวางทํางานในแตละขั้นตอนอาจตองยอนกลับไปทํางานใน
ขั้นตอนอื่นๆกอนหนานั้นดังแสดงรูปที่ 4.11

118 คณะเทคโนโลยีสารสนเทศ สถาบันเทคโนโลยีพระจอมเกลาเจาคุณทหารลาดกระบัง

 รูปที่ 4.11 ขั้นตอนการพัฒนาโปรแกรม

ขั้นตอนการวิเคราะห เปนการศึกษาความเปนไปได (feasibility study) ของปญหาที่

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

Java Programming 119

 ขั้นตอนการทดสอบ จะเปนขั้นตอนที่จะทดสอบโปรแกรมที่ไดพัฒนาขึ้น โดยอาจเปน
การทดสอบการทํางานของโปรแกรมจากขอมูลที่นํามาทดสอบตางๆ และตรวจสอบดูวา
โปรแกรมสามารถทํางานไดถูกตองตามขอกําหนดตามความตองการหรือไม การทดสอบ
โปรแกรมเชิงออปเจ็คอาจเปนการทดสอบทีละยูนิต (unit testing) หรือการทดสอบโดยรวม
(integration testing) การทดสอบทีละยูนิตเปนการทดสอบการทํางานของแตละคลาส สวนการ
ทดสอบโดยรวมเปนการทดสอบการทํางานเมื่อรวมคลาสตางๆเขาดวยกัน
ขั้นตอนการทํางาน เปนขั้นตอนสุดทายที่ไดสงมอบโปรแกรมใหกับผูใชงานแลว ซึ่ง
โปรแกรมที่สงมอบก็เปรียบเสมือนสินคาอื่นๆเชน บานหรือรถยนต ที่อาจมีขอบกพรองที่ตอง
แกไขและตองมีการบํารุงรักษา ผูใชโปรแกรมอาจพบขอผิดพลาดของโปรแกรมในระหวางการ
ใชงาน ซึ่งขอผิดพลาดเหลานี้อาจเกิดขึ้นจากขั้นตอนการออกแบบ ขั้นตอนการเขียนโปรแกรม
หรือแมกระทั่งเกิดขึ้นในขั้นตอนการวิเคราะหโปรแกรม ที่อาจวิเคราะหความตองการผิดพลาด
ซึ่งจากขอผิดพลาดเหลานี้ทําใหนักพัฒนาโปรแกรมอาจจะตองนําโปรแกรมมาแกไข ขั้นตอนนี้
เปรียบเสมือนขั้นตอนการบํารุงรักษาโปรแกรม (software maintenance) ซึ่งจะมีระยะเวลา
ยาวนานตามระยะเวลาการใชงานของโปรแกรม ซึ่งมักจะพบวาขั้นตอนนี้จะมีคาใชจายในการ
พัฒนาโปรแกรมมากที่สุดเมื่อเทียบกับขั้นตอนอื่นๆ
จากที่กลาวมาขางตนแลววา วัฎจักรของการพัฒนาโปรแกรมไมสามารถที่จะทําแตละ
ขั้นตอนใหสมบูรณ 100% ได แตจะตองมีการยอนกลับมาทําขั้นตอนอื่นๆเสมอ โดยทั่วไป
นักพัฒนาโปรแกรมที่ดีจะตองใหความสําคัญกับขั้นตอนการวิเคราะห และขั้นตอนการออกแบบ
ใหมากที่สุด เพราะโปรแกรมที่มีการออกแบบที่ดีจะชวยลดความยุงยากในขั้นตอนการทํางาน
(บํารุงรักษา) ซึ่งจะมีผลทําใหตนทุนในการพัฒนาโปรแกรมถูกลง

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

120 คณะเทคโนโลยีสารสนเทศ สถาบันเทคโนโลยีพระจอมเกลาเจาคุณทหารลาดกระบัง

• คุณลักษณะของคลาสเปนคุณลักษณะที่ใชรวมกันของทุกออปเจ็ค
• เมธอดคือวิธีการเพื่อใชในการจัดการกับคุณลักษณะของออปเจ็คหรือคุณลักษณะ
ของคลาส
• ภาษาจาวามีนิยามในการเขียนโปรแกรมเชิงออปเจ็คเพื่อประกาศคลาส
คุณลักษณะ เมธอด และออปเจ็ค
• โปรแกรมเชิงออปเจ็คจะมีคุณลักษณะเดนอยูสามประการคือ การหอหุม การสืบ
ทอด และการมีไดหลายรูปแบบ
• การหอหุมคือการที่ใหคุณลักษณะถูกหอหุมอยูภายในเมธอด โดยกําหนดให
คุณลักษณะมี access modifier เปน private และกําหนดใหเมธอดมี access
modifier เปน public
• ขอดีของการหอหุมคือการซอนเรนขอมูลและความเปนโมดูล
• การสืบทอดคือการที่คลาสใหมสามารถนําเอาคุณลักษณะและเมธอดของคลาสที่
ออกแบบไวแลวมาใชได
• การมีไดหลายรูปแบบคือการที่กําหนดใหมีการตอบสนองตอเมธอดเดียวกันดวย
วิธีการที่ตางกัน และสามารถกําหนดออปเจ็คไดหลายรูปแบบ
• Unified Modeling Language (UML) เปนภาษาที่ใชรูปกราฟฟกเพื่อจําลองระบบ
ซอฟตแวร ในที่นี้ไดแนะนําสัญลักษณของ UML ที่สําคัญสองอยางคือ ไดอะแกรม
ของคลาสและไดอะแกรมของออปเจ็ค
• วัฎจักรการพัฒนาโปรแกรมจะประกอบไปดวยขั้นตอนตางๆ 5 ขั้นตอนคือ
ขั้นตอนการวิเคราะห ขั้นตอนการออกแบบ ขั้นตอนการเขียนโปรแกรม ขั้นตอน
การทดสอบ และขั้นตอนการบํารุงรักษาโปรแกรม

Java Programming 121

122 คณะเทคโนโลยีสารสนเทศ สถาบันเทคโนโลยีพระจอมเกลาเจาคุณทหารลาดกระบัง
 บทที่ 5
การสรางสวนติดตอกับผูใชแบบกราฟฟก
เนื้อหาในบทนี้เปนการแนะนําการเขียนโปรแกรมจาวาประยุกตที่มีสวนติดตอกับผูใช
แบบกราฟฟก โดยจะเปนการแนะนําคลาสและอินเตอรเฟสที่สําคัญในแพคเก็จ java.awt
อธิบายคลาสประเภท Container และคลาสที่เปนสวนประกอบกราฟฟกอื่นๆ แนะนําการ
จัดวางสวนประกอบกราฟฟกโดยใชออปเจ็คประเภท LayoutManager อธิบายการสราง
เมนูโดยใชคลาสในแพคเก็จ java.awt และในตอนทายของบทเปนการแนะนําแพคเก็จ
javax.swing และคลาสตางๆที่มีอยูในแพคเก็จ

5.1 Java Foundation Class

เนื้อหาที่ผานมาเนนการพัฒนาโปรแกรมที่มีสวนติดตอกับผูใชแบบขอความ (text-
mode) แตระบบปฏิบัติการสวนใหญจะมีสวนติดตอกับผูใชเปนแบบกราฟฟก (Graphical User
Interface เรียกยอวา GUI) ทั้งนี้เนื่องจากใชงานงายกวา ดังนั้นการพัฒนาโปรแกรมในปจจุบัน
ควรที่จะมีสวนติดตอกับผูใชเปนแบบกราฟฟก ซึ่งโปรแกรมลักษณะนี้เรียกวาโปรแกรม GUI
การพัฒนาโปรแกรม GUI ผูพัฒนาโปรแกรมตองมีความเขาใจชุดคําสั่งและองค
ประกอบทางดานกราฟฟกของระบบปฏิบัติการที่ตอ งการพัฒนา ภาษาคอมพิวเตอร
สวนใหญจะใชชุดคําสั่งเฉพาะในแตละระบบปฏิบัติการ ดังนั้นผูพัฒนาโปรแกรมจะตองเรียนรู
ชุดคําสั่งในแตละระบบปฏิบัติการและโปรแกรม GUI ที่พัฒนาขึ้นมาจะขึน้ อยูกับแพลตฟอรม
(Platform Dependent) แตภาษาจาวาจะสนับสนุนการพัฒนาโปรแกรม GUI ที่สามารถใชงาน
ไดหลายแพลตฟอรม โดยจะใชชุดคําสั่งเดียวกัน อาทิเชน เราสามารถที่จะนําโปรแกรม GUI ที่
พัฒนาบนระบบปฏิบัติการ Solaris มาใชบนระบบปฏิบัติการอื่นๆที่มีสวนติดตอกับผูใชเปน
แบบกราฟฟกได
ชุดคําสั่งของโปรแกรมภาษาจาวาที่ใชในการพัฒนาโปรแกรม GUI จะอยูในชุดของ
แพคเก็จ Java Foundation Classes (JFC) ดังแสดงในรูปที่ 5.1 ซึ่งประกอบดวยแพคเก็จ
ตางๆดังนี้

Java Programming 123

 รูปที่ 5.1 สวนประกอบที่สําคัญของ JFC

• Abstract Window Toolkit (AWT) เปนแพคเก็จที่ใชในการพัฒนาโปรแกรม GUI

ขั้นพื้นฐาน ซึ่งจะใหโปรแกรม GUI ที่เปน look and feel ที่ขึ้นอยูกับแพลตฟอรม
ภาษาจาวาไดกําหนดแพคเก็จ AWT ขึ้นมาตั้งเวอรชั่นแรก (JDK 1.0) โดย
กําหนดไวในแพคเก็จ java.awt
• Swing เปนแพคเก็จที่มีสวนประกอบกราฟฟกที่มีคุณลักษณะและรูปแบบที่ดีกวา
สวนประกอบกราฟฟกของแพคเก็จ AWT ซึ่งจะเหมาะกับการพัฒนาโปรแกรม
GUI ที่นําไปใชงานจริง ภาษาจาวาไดกําหนดแพคเก็จ Swing ขึ้นในจาวาเวอรชั่น
2 (Java 2) โดยกําหนดในแพคเก็จชื่อ javax.swing โดยทั่วไปโปรแกรมที่ใช
ชุดคําสั่งในแพคเก็จ Swing จะทํางานชากวาโปรแกรม GUI ที่ใชแพคเก็จ AWT
แตจะมีรูปแบบที่สวยงามกวา
• Java 2D เปนชุดคําสั่งกราฟฟกที่มีคลาสที่ชวยในการพัฒนาโปรแกรมกราฟฟก
สองมิติและคลาสที่ใชในการจัดการกับรูปภาพ
• Accessibility เปนชุดคําสั่งที่มีคลาสในการพัฒนาโปรแกรมที่มีอินพุตหรือเอาทพุต
ในลักษณะพิเศษ อาทิเชน screen reader, screen magnifier และ audio text
reader
• Drag and Drop เปนชุดคําสั่งของเทคโนโลยีที่ชวยในการแลกเปลี่ยนขอมูล
ระหวางโปรแกรมที่พัฒนาโดยภาษาจาวากับโปรแกรมภาษาอื่นๆ

124 คณะเทคโนโลยีสารสนเทศ สถาบันเทคโนโลยีพระจอมเกลาเจาคุณทหารลาดกระบัง

5.2 แพคเก็จ AWT
แพคเก็จ AWT (Abstract Window Toolkit) ประกอบดวยคลาสตางๆที่เปนประเภท
สวนประกอบกราฟฟก (graphical component) เพื่อนําไปใชในการพัฒนาโปรแกรม GUI
แพคเก็จ AWT จะชวยในการสรางโปรแกรม GUI ประเภท look and feel ที่ขึ้นอยูกับ
แพลตฟอรมที่ใชงาน ภาษาจาวาไดกําหนดแพคเก็จ AWT ขึ้นไวตั้งแตโปรแกรมจาวาเวอรชั่น
แรก (JDK 1.0) โดยอยูในแพคเก็จ java.awt แพคเก็จ AWT จะประกอบไปดวยคลาสและ
อินเตอรเฟสตางๆเพื่อใชในการพัฒนาโปรแกรม GUI โดยคลาสและอินเตอรเฟสตางๆเหลานี้
จะมีความสัมพันธดังแสดงในรูปที่ 5.2

รูปที่ 5.2 คลาสและอินเตอรเฟสตางๆในแพคเก็จ AWT

5.2.1 คลาสและอินเตอรเฟสในแพคเก็จ AWT

คลาสและอินเตอรเฟสตางๆที่สําคัญในแพคเก็จ AWT มีดังนี้
• Component เปนคลาสที่เปน superclass ของคลาสประเภทสวนประกอบ
กราฟฟกทุกคลาสในแพคเก็จ AWT
• Container เปนคลาสที่ใชในการใสสวนประกอบกราฟฟก
• LayoutManager เปนอินเตอรเฟสที่ใชในการจัดตําแหนงและขนาดของ
สวนประกอบกราฟฟก

Java Programming 125

 • Graphics เปนคลาสแบบ abstract ที่ใชในการวาดรูปกราฟฟก อาทิเชน
วาดเสน วาดสี่เหลี่ยม หรือเขียนขอความ เปนตน
• Color เปนคลาสที่ใชในการจัดการสีของสวนประกอบกราฟฟก
• Font เปนคลาสที่ใชในการจัดการฟอนตของสวนประกอบกราฟฟก
• AWTEvent เปนคลาสที่เกี่ยวของกับเหตุการณ (Event) ทางกราฟฟก
การเขียนโปรแกรม GUI นั้นจะเปนการสรางออปเจ็คตางๆที่เปนออปเจ็คของคลาสที่
เปนสวนประกอบกราฟฟก ซึ่งคลาสเหลานี้จะสืบทอดมาจากคลาสที่ชื่อ Component ดัง
แสดงในรูปที่ 5.3 ซึ่งคลาสที่เปน subclass ของคลาส Component จะแบงเปนสองกลุมคือ
1. คลาสที่เปนคลาสประเภท Container เปนคลาสที่ใชในการใสสวนประกอบ
กราฟฟกตางๆ
2. คลาสที่เปนสวนประกอบกราฟฟกอื่นๆ อาทิเชน Button, Choice และ
List เปนตน

รูปที่ 5.3 คลาสตางๆที่สืบทอดมาจากคลาสที่ชื่อ Component

5.3 คลาสประเภท Container

ออปเจ็คของคลาส Container จะใชในการใสออปเจ็คของสวนประกอบกราฟฟก
หลายๆออปเจ็คไวเพื่อแสดงผล โปรแกรม GUI จะตองมีการสรางออปเจ็คของคลาสประเภท

126 คณะเทคโนโลยีสารสนเทศ สถาบันเทคโนโลยีพระจอมเกลาเจาคุณทหารลาดกระบัง

Container อยางนอยหนึ่งออปเจ็คขึ้นมากอน เพื่อใชในการใสออปเจ็คของคลาสที่เปน
สวนประกอบกราฟฟกอื่นๆ คลาสประเภท Container ที่อยูในแพคเก็จ AWT มีดังนี้
• Frame
• Panel
• Dialog
• Applet
โดยจะมีลําดับชั้นของการสืบทอดดังแสดงในรูปที่ 5.3
คลาสประเภท Container เปนคลาสที่สืบทอดมาจากคลาสที่ชื่อ Component
ซึ่งจัดเปนสวนประกอบกราฟฟกชนิดหนึ่ง ดังนั้นเราจึงสามารถที่จะใสออปเจ็คประเภท
Container บางชนิดลงในออปเจ็คของคลาสประเภท Container ตัวอื่นๆไดอาทิเชน ใส
ออปเจ็คของคลาส Panel ลงในออปเจ็คของคลาส Frame
คลาสที่ชื่อ Container เปนคลาสแบบ abstract ซึ่งเราไมสามารถที่จะสราง
ออปเจ็คของคลาสดังกลาวได แตจะตองสรางออปเจ็คของคลาสอื่นๆที่สืบทอดมาจากคลาสที่
ชื่อ Container แทน คลาสที่ชื่อ Container จะมีเมธอด add() ที่ใชในการใส
สวนประกอบกราฟฟกอื่นๆ เมธอดนี้จะมีรูปแบบที่สําคัญดังนี้
• void add (Component c)

• void add (Component c, int position)

โดยที่
• c คือออปเจ็คของสวนประกอบกราฟฟกที่ตองการใส
• position คือตําแหนงที่ตองการวางสวนประกอบกราฟฟก
โดยปกติคลาสประเภท Container จะมีการจัดวางสวนประกอบกราฟฟกโดย
กําหนดตําแหนงและขนาดตามรูปแบบการจัดวางผัง ที่กําหนดโดยออปเจ็คประเภท
LayoutManager โดยอัตโนมัติซึ่งจะกลาวถึงในหัวขอตอไป

5.3.1 คลาส Frame

คลาส Frame เปนคลาสที่สืบทอดมาจากคลาสที่ชื่อ Window ซึ่งจัดวาเปนคลาส
ประเภท Container แบบหนึ่ง โดยออปเจ็คของคลาส Frame จะประกอบดวย title bar,
resizable corner, icon และ menu bar ดังแสดงในรูปที่ 5.4 โปรแกรม GUI สําหรับโปรแกรม

Java Programming 127

 จาวาประยุกตจะเริ่มตนดวยการสรางออปเจ็คของคลาส Frame อยางนอยหนึ่งออปเจ็ค ซึ่ง
คลาส Frame จะมีรูปแบบของ constructor ที่สําคัญดังนี้
• public Frame()
• public Frame(String title)
โดยที่ title คือขอความที่ตองการจะแสดงตรง title bar ของ Frame

รูปที่ 5.4 รูปแบบของ Frame

โดยทั่วไปคลาส Frame จะมีขนาดเริ่มตนเปน (0, 0) ดังนั้นจึงจําเปนจะตองกําหนด

ขนาดของออปเจ็คของ Frame โดยใชเมธอด setSize() นอกจากนี้คลาส Frame จะ
ถูกกําหนดใหไมสามารถมองเห็นไดในตอนเริ่มตน ดังนั้นจึงตองมีการเรียกใชเมธอด show()
หรือ setVisible(true) เพื่อกําหนดใหออปเจ็คของคลาส Frame สามารถมองเห็นได
ออปเจ็คของคลาส Frame สามารถที่จะปรับขนาดไดโดยการลากเมาสปรับขนาด
ของเฟรมซึ่งคลาส Frame จะมีเมธอดที่เกี่ยวของกับการปรับขนาดของเฟรมดังนี้
• boolean isResizable()
เปนเมธอดเพื่อตรวจสอบวาออปเจ็คของคลาส Frame นี้สามารถปรับขนาดได
หรือไม
• void setResizable(boolean canResize)
เปนเมธอดเพื่อกําหนดใหออปเจ็คของคลาส Frame นี้ สามารถปรับขนาดไดหรือไม
โปรแกรมที่ 5.1 แสดงตัวอยางการสรางออปเจ็คของคลาส Frame ที่ชื่อ fr และ
กําหนดให fr มีขนาดเริ่มตนเปน 200x150 พิกเซล โดยกําหนดไวในคําสั่ง

128 คณะเทคโนโลยีสารสนเทศ สถาบันเทคโนโลยีพระจอมเกลาเจาคุณทหารลาดกระบัง

fr.setSize(200,150); สวนคําสั่ง fr.show(); เปนคําสั่งเพื่อที่จะทําใหสามารถ
มองเห็นออปเจ็ค fr ได โปรแกรมนี้จะใหผลลัพธดังแสดงในรูปที่ 5.5

โปรแกรมที่ 5.1 คลาส Frame

import java.awt.*;

public class FrameSample {

private Frame fr;
public void init() {
fr = new Frame("Frame Sample");
fr.setSize(200,150);
fr.show();
}
public static void main(String args[]) {
FrameSample obj = new FrameSample();
obj.init();
}
}

รูปที่ 5.5 ผลลัพธที่ไดจากการรันโปรแกรมที่ 5.1

5.3.2 คลาส Panel

คลาส Panel จะเปนคลาสประเภท Container เชนเดียวกับคลาส Frame แต
Panel จะแตกตางจาก Frame ตรงที่ Panel จะไมมี title bar และไมมี resizable corner

Java Programming 129

 คลาส Panel จะมี subclass ที่ชื่อ Applet เพื่อใชในการเขียนโปรแกรมจาวาแอปเพล็ต ซึ่ง
ทําใหเราสามารถใสสวนประกอบกราฟฟกลงในโปรแกรมจาวาแอปเพล็ตได โปรแกรมจาวา
ประยุกตไมสามารถที่จะสรางโปรแกรม GUI โดยเริ่มตนจากการสรางออปเจ็คของคลาส
Panel ไดโดยตรง ทั้งนี้เนื่องจากโปรแกรม GUI ตองมีการสราง Frame ขึ้นมากอน

คลาส Panel สามารถที่จะใสลงไปใน Frame ไดจึงทําใหเราสามารถที่จะสราง

โปรแกรม GUI ที่มีการวางผังที่ซับซอนขึ้นได โดยการใสออปเจ็คของคลาสที่เปนสวนประกอบ
กราฟฟกตางๆลงในออปเจ็คของคลาส Panel กอน แลวจึงนําออปเจ็คของคลาส Panel ใส
ลงในออปเจ็คของคลาสประเภท Container อีกชั้นหนึ่ง ทั้งนี้เราสามารถที่จะกําหนดให
ออปเจ็คของคลาส Panel แตละตัวมีตัวจัดวางผังที่ตางกันได และเรายังสามารถที่จะใส
ออปเจ็คของคลาส Panel ลงไปในออปเจ็คของคลาส Panel ตัวอื่นอีกทีหนึ่งก็ได

5.3.3 คลาส Dialog

คลาส Dialog เปนคลาสที่สืบทอดมาจากคลาส Window เพื่อใชเปนอินพุตและ
เอาทพุตกับผูใช คลาส Dialog จะทํางานอยูภายใตออปเจ็คของคลาส Frame ทั้งนี้การ
สรางออปเจ็คของคลาส Dialog จะตองระบุออปเจ็คของคลาส Frame ที่คูกันซึ่งเรียกวา
เฟรมแม (parent frame) ออปเจ็คของคลาส Dialog อาจมีโหมดการทํางานแบบ modal ซึ่ง
ผูใชตองปดออปเจ็คของคลาส Dialog กอนจึงจะกลับมาทํางานในเฟรมแมที่คูกันได
คลาส Dialog มีรูปแบบของ constructor ที่สําคัญดังนี้
• public Dialog(Frame parent)

• public Dialog(Frame parent,String title)

• public Dialog(Frame parent, boolean isModal)

• public Dialog(Frame parent, String title, boolean

isModal)

โดยที่
• parent คือออปเจ็คของคลาส Frame ที่เปนเฟรมแม
• title คือขอความที่ตองการจะแสดงตรง title bar ของ Dialog
• isModal คือขอมูลชนิด boolean เพื่อระบุวาออปเจ็คของ Dialog มี
โหมดเปน modal หรือไม

130 คณะเทคโนโลยีสารสนเทศ สถาบันเทคโนโลยีพระจอมเกลาเจาคุณทหารลาดกระบัง

 นอกจากนี้ Java API ไดกําหนดใหมีคลาสที่สืบทอดมาจากคลาส Dialog อื่นๆอีก
อาทิเชน คลาส FileDialog ซึ่งจะใชในการระบุชื่อไฟลที่ตองการใชงานในโปรแกรม

5.4 การจัดวางผังของสวนประกอบกราฟฟก
โปรแกรม GUI ของภาษาจาวาจะจัดวางสวนประกอบกราฟฟกตางๆลงใน
ออปเจ็คของคลาสประเภท Container โดยอัตโนมัติ ทั้งนี้จะกําหนดขนาดและตําแหนงของ
สวนประกอบกราฟฟกไดโดยใชออปเจ็คของคลาสประเภท LayoutManager ซึ่ง
LayoutManager เปนอินเตอรเฟสที่ใชัในการกําหนดวิธีการจัดวางผังสวนประกอบ
กราฟฟก ภาษาจาวาไดกําหนดใหมีคลาสที่ implements อินเตอรเฟสที่ชื่อ
LayoutManager เพื่อใชเปนตัวจัดวางผังของสวนประกอบกราฟฟกทั้งหมดของคลาสคือ

1. BorderLayout
2. FlowLayout
3. GridLayout
4. CardLayout
5. GridBagLayout
การกําหนดวิธีการวางผังของออปเจ็คของคลาสประเภท Container จะทําไดโดย
การสรางออปเจ็คประเภท LayoutManager ของคลาสใดคลาสหนึ่งในหาคลาสขางตน
จากนั้นเราสามารถที่จะกําหนดการวางผังโดยการเรียกใชเมธอด setLayout() ของคลาส
ประเภท Container โดยสงผาน argument ที่เปนออปเจ็คประเภท LayoutManager ที่
สรางขึ้นมา ตัวอยางเชนคําสั่ง
Frame fr = new Frame(“Demo”);
FlowLayout fl = new FlowLayout();
fr.setLayout(fl);
เปนการกําหนดใหออปเจ็คของคลาส Frame ที่ชื่อ fr ซึ่งมีวิธีการจัดวางผังใน
รูปแบบของ FlowLayout
เนื่องจากคําสั่งในตัวอยางขางตนจะไมมีการนําออปเจ็ค fl ซึ่งเปนออปเจ็คของ
คลาส FlowLayout ไปอางอิงในคําสั่งอื่นๆ ดังนั้นเราจึงสามารถที่จะเขียนคําสั่งในการสราง
ออปเจ็คและคําสั่งกําหนดรูปแบบการวางผังภายในคําสั่งเดียวกันไดดังนี้
fr.setLayout(new FlowLayout());
โดยทั่วไปคลาสประเภท Container แตละชนิด จะมีการกําหนดวิธีการวางผังของ
ออปเจ็คของคลาสแตละชนิดไวเริ่มตนอยูแลวดังนี้

Java Programming 131

 • คลาส Window, Frame และ Dialog จะกําหนดใหเปน BorderLayout
• คลาส Panel และ Applet จะกําหนดใหเปน FlowLayout

5.4.1 BorderLayout
BorderLayout เปนการจัดวางผังที่กําหนดใหสามารถวางออปเจ็คของคลาสที่
เปนสวนประกอบกราฟฟกได 5 ออปเจ็คตามตําแหนงทิศตางๆของออปเจ็คประเภท
Container 5 ตําแหนงคือ ทิศเหนือ (NORTH) ทิศใต (SOUTH) ทิศตะวันออก (EAST)
ทิศตะวันตก (WEST) และตรงกลาง (CENTER) ซึ่งออปเจ็คที่เปนสวนประกอบกราฟฟกจะ
ถูกใสในตําแหนงทิศตางๆโดยจะมีการกําหนดขนาดใหโดยอัตโนมัติ
โปรแกรมที่ 5.2 แสดงตัวอยางโปรแกรม GUI ที่ประกอบไปดวยปุม 5 ปุม โดยได
สรางออปเจ็คของคลาส Button ขึ้นมา 5 ออปเจ็คซึ่งมีชื่อเปน bn1 จนถึง bn5 และมี
ขอความบนปุมเปน B1 จนถึง B5 ตามลําดับ จากนั้นไดใสออปเจ็คชนิด Button แตละตัวลง
ไปในออปเจ็คชนิด Frame ที่ชื่อ fr โดยใชเมธอด add() ตามตําแหนงทิศตางๆ โดยที่
ออปเจ็ค bn1 จะอยูทางทิศเหนือ ออปเจ็ค bn2 จะอยูทางทิศใต ออปเจ็ค bn3 จะอยูทางทิศ
ตะวันออก ออปเจ็ค bn4 จะอยูทางทิศตะวันตก และออปเจ็ค bn5 จะอยูตรงกลาง ซึ่ง
โปรแกรมนี้จะใหผลลัพธดังแสดงในรูปที่ 5.6
การใชเมธอด add() ในกรณีที่ออปเจ็คประเภท Container มีการจัดวางผังแบบ
BorderLayout นั้น จะตองมี argument เพื่อระบุตําแหนงทิศที่ตองการวางออปเจ็คที่เปน
สวนประกอบกราฟฟกอาทิเชน คําสั่ง
fr.add(bn1,BorberLayout.NORTH);
เปนคําสั่งที่ใชในการใสออปเจ็ค bn1 ลงในออปเจ็ค fr ในตําแหนงทิศเหนือ
กรณีที่เรียกใชเมธอด add() โดยไมสงผาน argument เพื่อระบุตําแหนงทิศที่
ตองการวางออปเจ็คที่เปนสวนประกอบกราฟฟกนั้น ภาษาจาวาจะถือวาเปนการกําหนดใหใส
สวนประกอบกราฟฟกไวตําแหนงตรงกลางของออปเจ็คของคลาสประเภท Container อาทิ
เชน คําสั่ง
fr.add(bn1);
จะถือวาเปนคําสั่งเชนเดียวกับคําสั่ง
fr.add(bn1,BorderLayout.CENTER);

132 คณะเทคโนโลยีสารสนเทศ สถาบันเทคโนโลยีพระจอมเกลาเจาคุณทหารลาดกระบัง

โปรแกรมที่ 5.2 ตัวอยางการใชตัวจัดวางผังแบบ BorderLayout
import java.awt.*;

public class BorderLayoutSample {

private Frame fr;
private Button bn1, bn2, bn3, bn4, bn5;
public void init() {
fr = new Frame("Button Sample");
bn1 = new Button("B1");
bn2 = new Button("B2");
bn3 = new Button("B3");
bn4 = new Button("B4");
bn5 = new Button("B5");
fr.add(bn1,BorderLayout.NORTH);
fr.add(bn2,BorderLayout.SOUTH);
fr.add(bn3,BorderLayout.EAST);
fr.add(bn4,BorderLayout.WEST);
fr.add(bn5,BorderLayout.CENTER);
fr.setSize(200,150);
fr.show();
}
public static void main(String args[]) {
BorderLayoutSample obj = new BorderLayoutSample();
obj.init();
}
}

รูปที่ 5.6 ผลลัพธที่ไดจากการรันโปรแกรมที่ 5.2

Java Programming 133

 การปรับขนาดของออปเจ็คของคลาสประเภท Container จะมีผลทําใหขนาดของ
ออปเจ็คของสวนประกอบกราฟฟก เปลี่ยนแปลงไปตามขนาดของออปเจ็คของคลาสประเภท
Container ดังนี้

• ออปเจ็คของสวนประกอบกราฟฟกที่อยูตําแหนงทิศเหนือ ใต และตรงกลาง จะ

ปรับขนาดตามขนาดของออปเจ็คของคลาสประเภท Container ตามแนวนอน
ดังแสดงในรูปที่ 5.7 (ก)
• ออปเจ็คของสวนประกอบกราฟฟกที่อยูตําแหนงทิศตะวันออก ตะวันตก และ
ตรงกลางจะปรับขนาดตามขนาดของออปเจ็คของคลาสประเภท Container
ตามแนวตั้ง ดังแสดงในรูปที่ 5.7 (ข)

(ก) แนวนอน (ข) แนวตั้ง

รูปที่ 5.7 ขนาดของออปเจ็คที่ถูกปรับ

5.4.2 FlowLayout
FlowLayout เปนการจัดวางผังสวนประกอบกราฟฟกไวตําแหนงบนสุดของ
ออปเจ็คของคลาสประเภท Container โดยจะเรียงออปเจ็คของคลาสที่เปนสวนประกอบ
กราฟฟกจากซายไปขวา และถาความกวางของออปเจ็คของคลาสประเภท Container ใน
แตละแถวไมพอ ตัวจัดวางผังแบบ FlowLayout จะนําออปเจ็คของคลาสที่เปนสวนประกอบ

134 คณะเทคโนโลยีสารสนเทศ สถาบันเทคโนโลยีพระจอมเกลาเจาคุณทหารลาดกระบัง

ที่เหลือวางในตําแหนงถัดไปดานลาง การจัดวางผังแบบ FlowLayout จะปรับขนาดของ
ออปเจ็คของคลาสที่เปนสวนประกอบกราฟฟกตางๆตามความเหมาะสม ทั้งนี้ขึ้นอยูกับ
ขอกําหนดตางๆอาทิเชน ขนาดของออปเจ็คของคลาส Button จะมีขนาดตามขนาดของ
ขอความบนปุม เปนตน
โปรแกรมที่ 5.3 แสดงตัวอยางโปรแกรม GUI ที่สรางออปเจ็คของคลาส Frame
ขึ้นมา แลวกําหนดใหมีการจัดวางผังแบบ FlowLayout โดยใชคําสั่ง
fr.setLayout(new FlowLayout());
โปรแกรม GUI นี้จะมีออปเจ็คของคลาส Button อยู 3 ออปเจ็ค โดยกําหนดใหมี
ขอความเปน Submit, Cancel และ Exit จากนั้นโปรแกรมไดใสออปเจ็คของคลาส Button
แตละตัวลงในออปเจ็คของคลาส Frame ซึ่งจะไดโปรแกรม GUI ที่มีปุมสามปุมเรียงจากซาย
ไปขวาดังรูปที่ 5.8 (ก) และในกรณีที่ Frame ขนาดแคบลงปุมบางปุมก็จะลงมาอยูในตําแหนง
ถัดไปดังรูปที่ 5.8 (ข)

โปรแกรมที่ 5.3 ตัวอยางการใชตัวจัดวางผังแบบ FlowLayout

import java.awt.*;

public class FlowLayoutSample {

private Frame fr;
private Button bn1, bn2, bn3;
public void init() {
fr = new Frame("Button Sample");
fr.setLayout(new FlowLayout());
bn1 = new Button("Submit");
bn2 = new Button("Cancel");
bn3 = new Button("Exit");
fr.add(bn1);
fr.add(bn2);
fr.add(bn3);
fr.setSize(200,150);
fr.show();
}
public static void main(String args[]) {
FlowLayoutSample obj = new FlowLayoutSample();
obj.init();
}
}

Java Programming 135

 (ก) (ข)
รูปที่ 5.8 ผลลัพธที่ไดจากการรันโปรแกรมที่ 5.3

5.4.3 GridLayout
GridLayout เปนการจัดวางผังที่แบงออปเจ็คของคลาสประเภท Container
เปนชองยอยๆหลายชอง โดยแตละชองยอยจะมีขนาดความกวางและความสูงเทากัน
GridLayout จะอนุญาตใหใสออปเจ็คของคลาสที่เปนสวนประกอบกราฟฟกไดหนึ่งออปเจ็ค
ในแตละชองยอย โดยจะกําหนดใหขนาดของออปเจ็คของคลาสที่เปนสวนประกอบกราฟฟกมี
ขนาดเทากับขนาดของชองยอย การสรางตัวจัดวางผังแบบ GridLayout ทําไดโดยการ
สรางออปเจ็คของคลาส GridLayout ที่มีรูปแบบของ constructor เปนดังนี้
public GridLayout(int row, int col)
โดยที่ row และ col คือจํานวนแถวและคอลัมนที่ตองการแบงออปเจ็คของคลาส
ประเภท Container ใหเปนชองยอย
การใสออปเจ็คของคลาสที่เปนสวนประกอบกราฟฟกลงในชองยอย จะทําไดโดยการ
เรียกใชเมธอด add() เชนเดียวกัน แตในกรณีนี้โปรแกรม GUI จะใสออปเจ็คจากชองยอย
บนสุดเรียงจากซายไปขวา โดยไมสามารถที่จะขามชองยอยใดชองยอยหนึ่งได

136 คณะเทคโนโลยีสารสนเทศ สถาบันเทคโนโลยีพระจอมเกลาเจาคุณทหารลาดกระบัง

โปรแกรมที่ 5.4 ตัวอยางการใชตัวจัดวางผังแบบ GridLayout
import java.awt.*;

public class GridLayoutSample {

private Frame fr;
private Button bn1, bn2, bn3, bn4, bn5;
public void init() {
fr = new Frame("Button Sample");
fr.setLayout(new GridLayout(3,2));
bn1 = new Button("B1");
bn2 = new Button("B2");
bn3 = new Button("B3");
bn4 = new Button("B4");
bn5 = new Button("B5");
fr.add(bn1);
fr.add(bn2);
fr.add(bn3);
fr.add(bn4);
fr.add(bn5);
fr.pack();
fr.setVisible(true);
}
public static void main(String args[]) {
GridLayoutSample obj = new GridLayoutSample();
obj.init();
}
}

รูปที่ 5.9 ผลลัพธที่ไดจากการรันโปรแกรมที่ 5.4

Java Programming 137

 5.5 สวนประกอบกราฟฟกในแพคเก็จ AWT
แพคเก็จ java.awt มีคลาสที่เปนสวนประกอบกราฟฟกที่สําคัญดังนี้
• Button เปนคลาสที่ใชในการสรางออปเจ็คที่เปนปุม
• Label เปนคลาสที่ใชในการสรางออปเจ็คที่มีไวในการแสดงขอความ
• TextField เปนคลาสที่ใชในการสรางออปเจ็คเพื่อใหผูใชปอนขอความได
สูงสุดหนึ่งบรรทัด
• TextArea เปนที่ทําหนาที่คลายกับ TextField แตจะมีหลายบรรทัด
• Checkbox เปนคลาสที่ทําหนาที่คลายกับปุมโดยใชสวิทซ “on-off”
• Choice เปนคลาสที่ผูใชสามารถเลือกรายการจากที่กําหนดมาใหได
• List เปนคลาสที่จะทําหนาที่คลาย Choice แตจะแสดงรายการไดหลายแถว
พรอมๆกัน
• Scollbar เปนคลาสที่ทําหนาที่เปนแถบควบคุมเพื่อใหผูใชสามารถเลื่อนไปยัง
ตําแหนงที่ตองการได
• Canvas เปนคลาสที่เปนพื้นที่วางเปลาเพื่อใชในการวาดรูปกราฟฟกลงไป

5.5.1 คลาส Button

Button เปนคลาสที่ใชในการสรางออปเจ็คที่แสดงเปนปุม โดยจะมีขอความ (label)
ปรากฎอยูบนปุม ผูใชสามารถใชอุปกรณอินพุตเชนเมาสหรือคียบอรดกดเลือกปุมได
Button เปนคลาสที่สืบทอดมาจากคลาส Component เราสามารถที่จะสรางออปเจ็คของ
คลาส Button โดยเรียกใช constructor ของคลาส Button ที่มีรูปแบบดังนี้
• public Button()

• public Button(String label)

โดยที่
• label คือขอความที่จะปรากฏอยูบนปุม

คลาส Button ยังมีเมธอดอื่นๆที่สําคัญในการจัดการกับขอความดังนี้

• public void setLabel(String label)

138 คณะเทคโนโลยีสารสนเทศ สถาบันเทคโนโลยีพระจอมเกลาเจาคุณทหารลาดกระบัง

 เปนเมธอดที่ใชในการกําหนดหรือเปลี่ยนขอความของปุม
• public String getLabel()
เปนเมธอดที่ใชในการเรียกดูขอความของปุม

5.5.2 คลาส Label

Label เปนคลาสที่ใชสรางออปเจ็คที่เปนสวนประกอบกราฟฟกที่ใชในการแสดง
ขอความยาวหนึ่งบรรทัด โดยที่คลาส Label มี constructor ที่สําคัญดังนี้
• public Label(String text)

• public Label(String text, int align)

โดยที่
• text คือขอความที่ตองการแสดง
• align คือการกําหนดการวางแนว(ชิดซาย ขวา หรือตรงกลาง) ของขอความ

คลาส Label มีเมธอดที่สําคัญดังนี้

• public void setText(String text)
• public String getText()
เมธอด setText()เปนเมธอดที่ใชในการกําหนดหรือเปลี่ยนขอความของออปเจ็ค
ชนิด Label สวนเมธอด getText()เปนเมธอดที่จะสงขอความของออปเจ็คชนิด Label
คืนมา

5.5.3 คลาส TextField

TextField คือคลาสที่ใชในการสรางออปเจ็คเพื่อใหผูใชปอนขอความหนึ่งบรรทัด
โดยที่คลาส TextField มี constructor ที่สําคัญดังนี้
• public TextField()

• public TextField(int col)

• public TextField(String text)

• public TextField(String text, int col)

Java Programming 139

 โดยที่
• text คือขอความเริ่มตนที่ตองการแสดง
• col คือจํานวนคอลัมนที่ตองการแสดง

คลาส TextField มีเมธอดที่สําคัญดังนี้

• public int getColumns()

• public String getText()

• public boolean isEditable()

• public void select(int selectionStart,

int selectionEnd)

• public void selectAll()

• public void setEditable(boolean b)
• public void setText(String t)
• public void setColumn(int column)
เมธอด setText() ใชในการกําหนดหรือเปลี่ยนขอความของออปเจ็คชนิด
TextFiled ในกรณีที่เราตองการกําหนดให TextField สามารถอานขอความไดอยาง
เดียว เราสามารถทําไดโดยเรียกใชเมธอด setEditable(boolean b) โดยกําหนดให
argument มีคาเปน false สวนเมธอด select()ใชในการเลือกขอความใน TextField
โปรแกรมที่ 5.5 แสดงตัวอยางการสรางเฟรมที่มีออปเจ็คของคลาส Label และ
TextField แสดงอยู โปแกรมนี้จะกําหนดใหออปเจ็ค fr ของคลาส Frame มีการจัดวาง
ผังแบบ FlowLayout ผลลัพธของโปรแกรมนี้เปนดังแสดงในรูปที่ 5.10

140 คณะเทคโนโลยีสารสนเทศ สถาบันเทคโนโลยีพระจอมเกลาเจาคุณทหารลาดกระบัง

โปรแกรมที่ 5.5 ตัวอยางการสราง Label และ TextField
import java.awt.*;

public class TextFieldDemo {

private Frame fr;
private Label l;
private TextField tf;
public void init() {
fr = new Frame("TextField Demo");
l = new Label("Name: ");
tf = new TextField("Thanisa", 15);
fr.setLayout(new FlowLayout());
fr.add(l);
fr.add(tf);
fr.pack();
fr.show();
}
public static void main(String args[]) {
TextFieldDemo obj = new TextFieldDemo();
obj.init();
}
}

รูปที่ 5.10 ผลลัพธที่ไดจากการรันโปรแกรมที่ 5.5

5.5.4 คลาส TextArea

TextArea เปนคลาสที่ใชในการสรางออปเจ็คที่สามารถปอนและแกไขขอความได
TextArea จะแตกตางจาก TextField ตรงที่จะสามารถกําหนดจํานวนบรรทัดไดหลาย
บรรทัด โดยที่คลาส TextArea มี constructor ที่สําคัญดังนี้
• public TextArea()

Java Programming 141

 • public TextArea(String Text)

• public TextArea(String Text, int row, int col)

• public TextArea(int row, int col)

• public TextArea(String Text, int row, in col, int

scrollbar)

โดยที่
• text คือขอความเริ่มตนที่ตองการแสดง
• row และ col คือจํานวนแถวและคอลัมนของ TextArea
• scrollbar เปนการกําหนดการมี scrollbar ของ TextArea

คลาส TextArea จะมีเมธอดที่สําคัญดังนี้

• public int getColumns()

• public int getRows()

• public String getSelectedText()

• public boolean isEditable()

• public void select(int selectionStart, int

selectionEnd)

• public void selectAll()

• public void setEditable(boolean b)

• public void setText(String t)

• public void setColumns(int column)

• public void setRows(int rows)

ทั้งนี้เมธอดที่สําคัญที่อยูในคลาส TextArea จะคลายกับเมธอดของคลาส

TextArea แตจะเพิ่มเมธอดที่เกี่ยวของกับการจัดการจํานวนแถวขึ้นมา อาทิเชน
setRow() และ getRow()

โปรแกรมที่ 5.6 แสดงตัวอยางการสราง Frame ที่มีออปเจ็คของคลาส TextArea

โดยโปรแกรมนี้จะใหผลลัพธดังแสดงในรูปที่ 5.11

142 คณะเทคโนโลยีสารสนเทศ สถาบันเทคโนโลยีพระจอมเกลาเจาคุณทหารลาดกระบัง

โปรแกรมที่ 5.6 ตัวอยางการสราง TextArea
import java.awt.*;

public class TextAreaDemo {

private Frame fr;
private TextArea ta;
public void init() {
fr = new Frame("TextArea Demo");
ta = new TextArea("Text Area",5,10);
fr.setLayout(new FlowLayout());
fr.add(ta);
fr.setSize(200,150);
fr.setVisible(true);
}
public static void main(String args[]) {
TextAreaDemo obj = new TextAreaDemo();
obj.init();
}
}

รูปที่ 5.11 ผลลัพธที่ไดจากการรันโปรแกรมที่ 5.6

5.5.5 คลาส Checkbox

Checkbox เปนคลาสที่ใชในการสรางออปเจ็คที่ทําหนาที่คลายปุม โดยใหผูใชกด
ชองที่เปนสวิทซเพื่อเลือกหรือไมเลือกรายการ Checkbox จะมีขอความอยูขางๆเพื่ออธิบาย
ความหมายของรายการ Checkbox มี constructor ที่สําคัญดังนี้

Java Programming 143

 • public Checkbox(String label)

• public Checkbox(String label, boolean state)

โดยที่
• state เปนตัวกําหนดสถานะเริ่มตนของ Checkbox กรณีที่ constructor
ไมไดกําหนดสถานะเริ่มตนจะถือวามีคาเปน false (ไมถูกเลือก)

คลาส Checkbox มีเมธอดที่สําคัญดังนี้

• public String getLabel()
• public Object[] getSelectedObjects()
• public boolean getState()
• public void setLabel(String label)
• public void setState(boolean state)
โปรแกรมที่ 5.7 แสดงตัวอยางการใช Checkbox โดยโปรแกรมจะสรางเฟรมที่มี
ออปเจ็คชนิด Checkbox เพื่อใหผูใชเลือกสามออปเจ็คดังแสดงในรูปที่ 5.12

โปรแกรมที่ 5.7 ตัวอยางการสราง Checkbox

import java.awt.*;

public class CheckboxDemo {

public static void main(String args[]) {
Frame fr = new Frame("Checkbox Demo");
Checkbox c1 = new Checkbox("Visual Basic");
Checkbox c2 = new Checkbox("C++",false);
Checkbox c3 = new Checkbox("Java",true);
fr.setLayout(new FlowLayout());
fr.add(c1);
fr.add(c2);
fr.add(c3);
fr.pack();
fr.show();
}
}

144 คณะเทคโนโลยีสารสนเทศ สถาบันเทคโนโลยีพระจอมเกลาเจาคุณทหารลาดกระบัง

 รูปที่ 5.12 ผลลัพธที่ไดจากการรันโปรแกรมที่ 5.7

เราสามารถที่จะสรางสวิทซตัวเลือกที่เปนแบบ Radio Button โดยใช Checkbox ใน

กรณีนี้จะกําหนดใหออปเจ็ค Checkbox หลายตัวอยูในกลุมเดียวกัน โดยอยูในกลุมของ
ออปเจ็คของคลาส CheckboxGroup ซึ่งจะตองใช constructor ตอไปนี้สรางออปเจ็คชนิด
Checkbox

• public Checkbox(String label,boolean state,

CheckboxGroup group)

• public Checkbox(String label, CheckboxGroup

group, boolean state)
คลาส CheckboxGroup ไมใชคลาสที่เปนสวนประกอบกราฟฟก แตจะใชใน
การสรางออปเจ็คเพื่อกําหนดกลุมของ Checkbox โดยมี constructor ดังนี้
• public CheckboxGroup()

โปรแกรมที่ 5.8 แสดงตัวอยางของการสราง Radio Button โดยปรับเปลี่ยน

Checkbox ในโปรแกรมที่ 5.7 ใหอยูในกลุมของออปเจ็คที่ชื่อ cg โปรแกรมนี้จะมีผลลัพธที่
เปนสวนติดตอกับผูใชดังรูปที่ 5.13

Java Programming 145

 โปรแกรมที่ 5.8 ตัวอยางของการสราง Radio Button
import java.awt.*;

public class CheckboxGroupDemo {

public static void main(String args[]) {
Frame fr = new Frame("CheckboxGroup Demo");
CheckboxGroup cg = new CheckboxGroup();
Checkbox c1 = new Checkbox("One", true, cg);
Checkbox c2 = new Checkbox("Two", false, cg);
Checkbox c3 = new Checkbox("Three", cg, true);
fr.setLayout(new GridLayout(3,1));
fr.add(c1);
fr.add(c2);
fr.add(c3);
fr.pack();
fr.show();
}
}

รูปที่ 5.13 ผลลัพธที่ไดจากการรันโปรแกรมที่ 5.8

5.5.6 คลาส Choice

Choice เปนคลาสที่ใชในการสรางออปเจ็คที่เปนรายการใหผูใชสามารถเลือกได
โดย Choice จะแสดงรายการปรากฏใหเห็นเฉพาะรายการที่เลือกเพียงรายการเดียว ปกติ
กอนที่จะมีการเลือกรายการ Choice จะแสดงรายการแรกที่มีอยู และหากมีการคลิกเมาส
ออปเจ็ค Choice จะแสดงรายการทั้งหมดที่มีอยู โดยที่คลาส Choice มี constructor ที่
สําคัญดังนี้
• public Choice()

คลาส Choice มีเมธอดตางๆที่สําคัญดังนี้

• public void add(String item)

146 คณะเทคโนโลยีสารสนเทศ สถาบันเทคโนโลยีพระจอมเกลาเจาคุณทหารลาดกระบัง

 • public void addItem(String item)

• public String getItem(int index)

• public int getItemCount()

• public int getSelectedIndex()

• public String getSelectedItem()

• public void select(int pos)

• public void select(String str)

เราสามารถที่จะใสรายการลงในออปเจ็ค Choice ไดโดยใชเมธอด add(String

item) หรือ addItem(String item) คลาส Choice ยังมีเมธอด select(int
pos) และ select(String item) เพื่อใชในการเลือกใหออปเจ็ค Choice แสดง
รายการที่ตําแหนงหรือขอความที่ตองการใหแสดงได สวนเมธอด getSelectedIndex()
และ getSelectedItem() ใชในการแสดงตําแหนงหรือขอความที่ถูกเลือก
โปรแกรมที่ 5.9 แสดงตัวอยางเฟรมที่มีออปเจ็คชนิด Choice แสดงอยู คําสั่ง
c.addItem() และ c.add() ใชในการใสรายการตางๆลงในออปเจ็ค c สวนคําสั่ง
c.select(“Thailand”) เปนการกําหนดใหออปเจ็ค c เลือกแสดงรายการที่ชื่อ
Thailand โปรแกรมนี้จะใหผลลัพธที่เปนสวนติดตอกับผูใชดังรูปแสดงในรูปที่ 5.14

โปรแกรมที่ 5.9 ตัวอยางการสราง Choice

import java.awt.*;

public class ChoiceDemo {

public static void main(String args[]) {
Frame fr = new Frame("Choice Demo");
Choice c = new Choice();
c.addItem("New Zealand");
c.addItem("Thailand");
c.addItem("USA");
c.add("Japan");
c.select("Thailand");
fr.add(c);
fr.pack();
fr.show();
}
}

Java Programming 147

 รูปที่ 5.14 ผลลัพธที่ไดจากการรันโปรแกรมที่ 5.9

5.5.7 คลาส List

List เปนคลาสที่ใชสรางออปเจ็คที่เปนสวนประกอบกราฟฟกเพื่อใหผูใชสามารถ
เลือกรายการคลายกับ Choice แตจะแตกตางกันตรงที่ List จะแสดงรายการหลาย
รายการตามจํานวนแถวที่ระบุ โดยที่คลาส List มี constructor ที่สําคัญดังนี้
• public List()

• public List(int row)

• public List(int row, boolean multipleMode)

โดยที่
• row คือจํานวนแถวที่ตองการใหออปเจ็คชนิด List แสดงรายการ
• multipleMode เปนการกําหนดใหผูใชสามารถเลือกรายการหลายรายการ
พรอมกันไดหรือไม

คลาส List มีเมธอดที่สําคัญดังนี้

• public void add(String item)
• public void add(String item, int index)
คลาส List จะมีเมธอด add() เพื่อใชในการใสรายการที่ตองการใหเลือกลงใน
ออปเจ็คของคลาส List ดังตัวอยางโปรแกรมที่ 5.10 ซึ่งจะไดผลลัพธดังแสดงอยูในรูปที่ 5.15

148 คณะเทคโนโลยีสารสนเทศ สถาบันเทคโนโลยีพระจอมเกลาเจาคุณทหารลาดกระบัง

โปรแกรมที่ 5.10 ตัวอยางการสราง List
import java.awt.*;

public class ListDemo {

private Frame fr;
private List l;
public void init() {
fr = new Frame("List Demo");
l = new List(3,true);
l.add("One");
l.add("Two");
l.add("Three");
fr.add(l);
fr.pack();
fr.setVisible(true);
}
public static void main(String args[]) {
ListDemo ld = new ListDemo();
ld.init();
}
}

รูปที่ 5.15 ผลลัพธที่ไดจากการรันโปรแกรมที่ 5.10

5.6 การสรางเมนู
โปรแกรมจาวาประยุกตที่มีสวนติดตอกับผูใชเปนแบบกราฟฟก สามารถที่จะมีเมนูให
ผูใชเลือกรายการได เมนูเปนออปเจ็คของคลาสที่สืบทอดมาจากคลาส MenuComponent
โดยมีลําดับชั้นของคลาสตางๆดังแสดงในรูปที่ 5.16 ซึ่งคลาสตางๆที่สําคัญมีดังนี้
• MenuBar เปนคลาสที่ใชในการสรางออปเจ็คที่เก็บกลุมของออปเจ็คของคลาส
Menu ซึ่งจะปรากฏเปนแถบเมนูโดยออปเจ็คของคลาสนี้จะตองมีออปเจ็คของ
คลาส Frame ที่คูกัน

Java Programming 149

 • Menu เปนคลาสที่ใชในการสรางออปเจ็คที่เก็บกลุมของออปเจ็คของคลาส
MenuItem และตัวแยกรายการ (separator)

• MenuItem เปนคลาสที่ใชในการสรางออปเจ็คที่เปนรายการ
• CheckboxMenuItem เปนคลาสที่ใชในการสรางออปเจ็คที่เปนรายการโดย
จะมีเครื่องหมายถูกที่จะแสดงขึ้นเมื่อรายการนี้ถูกเลือก

รูปที่ 5.16 คลาสสําคัญๆที่สืบทอดมาจากคลาส MenuComponent

5.6.1 การสราง MenuBar

คลาส MenuBar เปนคลาสที่สืบทอดมาจากคลาส MenuComponent ซึ่งจะเปน
แถบเมนูที่ปรากฏอยูบน Frame และมี constructor ดังนี้
• public MenuBar()
เราสามารถที่จะใสออปเจ็คชนิด MenuBar ลงในออปเจ็คประเภท Container
ได โดยใชเมธอด setMenuBar()ของคลาส Container
โปรแกรมที่ 5.11 แสดงตัวอยางการสรางออปเจ็คของคลาส MenuBar แลวใส
ออปเจ็คดังกลาวลงในออปเจ็คของคลาส Frame โปรแกรมนี้จะใหผลลัพธดังแสดงในรูปที่
5.17 (ระบบปฏิบัติการบางประเภทอาจจะไมแสดงแถบของเมนูหากไมมีรายการในเมนู)

150 คณะเทคโนโลยีสารสนเทศ สถาบันเทคโนโลยีพระจอมเกลาเจาคุณทหารลาดกระบัง

โปรแกรมที่ 5.11 ตัวอยางการสราง MenuBar
import java.awt.*;

public class MenuBarDemo {

private Frame fr;
private MenuBar mb;
public void init() {
fr = new Frame("MenuBar Demo");
mb = new MenuBar();
fr.setMenuBar(mb);
fr.setSize(200,150);
fr.setVisible(true);
}
public static void main(String args[]) {
MenuBarDemo md = new MenuBarDemo();
md.init();
}
}

รูปที่ 5.17 ผลลัพธที่ไดจากการรันโปรแกรมที่ 5.11

5.6.2 การสราง Menu

Menu เปนคลาสที่ใชในการสรางรายการที่จะแสดงอยูขางในออปเจ็คของคลาส
MenuBar โดยมี constructor ที่สําคัญดังนี้
• public Menu()
• public Menu(String label)
• public Menu(String label, boolean tearOff)
โดยที่
• label คือขอความที่ปรากฏอยูในรายการ

Java Programming 151

 เราจะใชเมธอด add() ในคลาส MenuBar เพื่อที่จะใสออปเจ็คของคลาส Menu
ลงใน MenuBar กรณีที่ออปเจ็คของคลาส Menu เปนรายการที่ชื่อ Help เราจะใชเมธอด
setHelpMenu() เพื่อใสออปเจ็คลงใน MenuBar

โปรแกรมที่ 5.12 แสดงตัวอยางการสรางออปเจ็คของคลาส Menu เพื่อใสลงใน

MenuBar โดยมีชื่อรายการตางๆ โปรแกรมนี้จะใหผลลัพธดังแสดงในรูปที่ 5.18

โปรแกรมที่ 5.12 ตัวอยางการสราง Menu ที่ใสลงในออปเจ็คของคลาส MenuBar

import java.awt.*;

public class MenuDemo {

private Frame fr;
private MenuBar mb;
private Menu m1,m2,m3,m4;
public void init() {
fr = new Frame("Menu Demo");
mb = new MenuBar();
m1 = new Menu("File");
m2 = new Menu("Edit");
m3 = new Menu("View");
m4 = new Menu("Help");
fr.setMenuBar(mb);
mb.add(m1); mb.add(m2); mb.add(m3);
mb.setHelpMenu(m4);
fr.setSize(200,150);
fr.setVisible(true);
}
public static void main(String args[]) {
MenuDemo mm = new MenuDemo();
mm.init();
}
}

รูปที่ 5.18 ผลลัพธที่ไดจากการรันโปรแกรมที่ 5.12

152 คณะเทคโนโลยีสารสนเทศ สถาบันเทคโนโลยีพระจอมเกลาเจาคุณทหารลาดกระบัง

5.6.3 การสราง MenuItem
MenuItem คือคลาสที่ใชในการสรางรายการยอยที่อยูในออปเจ็คชนิด Menu
คลาส MenuItem มี constructor ที่สําคัญดังนี้
• public MenuItem()
• public MenuItem(String label)
• public MenuItem(String label, MenuShortcut s)
เราสามารถที่จะใสออปเจ็คของคลาส MenuItem ลงในออปเจ็คของคลาส Menu
โดยเรียกใชเมธอด add() ในคลาส Menu นอกจากนี้เราสามารถที่จะกําหนด Shortcut ของ
รายการที่อยูในออปเจ็คของคลาส MenuItem ไดโดยการสรางออปเจ็คของคลาส
MenuShortcut ที่มี constructor ดังนี้

• public MenuShortcut(int key)

แลวสงออปเจ็คดังกลาวเปน argument ของ constructor ของ MenuItem จาก
ที่กลาวมาทั้งหมดนี้ เราสามารถที่จะสรุปขั้นตอนการสรางเมนูไดดังนี้
1. สรางออปเจ็คของคลาส MenuBar แลวใสลงในออปเจ็คประเภท
Container
2. สรางออปเจ็คของคลาส Menu หนึ่งออปเจ็คหรือมากกวา แลวใสลงในออปเจ็ค
ของคลาส MenuBar
3. สรางออปเจ็คของคลาส MenuItem หนึ่งออปเจ็คหรือมากกวา แลวใสลงใน
ออปเจ็คของคลาส Menu
โปรแกรมที่ 5.13 แสดงตัวอยางการสราง MenuItem และ Menu ลงใน MenuBar
โดยจะมีผลลัพธดังแสดงในรูปที่ 5.19

Java Programming 153

 โปรแกรมที่ 5.13 ตัวอยางการสราง MenuItem
import java.awt.*;

public class MenuItemDemo {

private Frame fr;
private MenuBar mb;
private Menu m1,m2,m3,m4;
private MenuItem mi1,mi2,mi3,mi4;
private MenuShortcut ms1;
public void init() {
fr = new Frame("MenuItem Demo");
mb = new MenuBar();
m1 = new Menu("File");
m2 = new Menu("Edit");
m3 = new Menu("View");
m4 = new Menu("Help");
fr.setMenuBar(mb);
mb.add(m1);
mb.add(m2);
mb.add(m3);
mb.setHelpMenu(m4);
char key = 'N';
ms1 = new MenuShortcut(key);
mi1 = new MenuItem("New",ms1);
mi2 = new MenuItem("Open");
mi3 = new MenuItem("Save");
mi4 = new MenuItem("Exit");
m1.add(mi1);
m1.add(mi2);
m1.addSeparator();
m1.add(mi3);
m1.addSeparator();
m1.add(mi4);
fr.setSize(200,200);
fr.setVisible(true);
}
public static void main(String args[]) {
MenuItemDemo mid= new MenuItemDemo();
mid.init();
}
}

154 คณะเทคโนโลยีสารสนเทศ สถาบันเทคโนโลยีพระจอมเกลาเจาคุณทหารลาดกระบัง

 รูปที่ 5.19 ผลลัพธที่ไดจากการรันโปรแกรมที่ 5.13

5.6.4 คลาส CheckboxMenuItem

CheckboxMenuItem คือรายการเมนูที่มีเครื่องหมายระบุวารายการนี้ถูกเลือก
คลาส CheckboxMenuItem มี constructor ที่สําคัญดังนี้
• public CheckboxMenuItem()
• public CheckboxMenuItem(String label)
• public CheckboxMenuItem(String label,
boolean state)
โดยที่
• label คือขอความในรายการเมนู
• state คือสถานะในการเลือกโดยทั่วไป จะมีคา เปน false
นอกจากนี้เราสามารถที่จะเปลี่ยนสถานะของออปเจ็คของคลาส
CheckboxMenuItem โดยใชเมธอด setState(boolean b)

โปรแกรมที่ 5.14 แสดงตัวอยางการสรางออปเจ็คของคลาส CheckboxMenuItem

โดยจะมีผลลัพธดังแสดงในรูปที่ 5.20

Java Programming 155

 โปรแกรมที่ 5.14 ตัวอยางการสราง CheckboxMenuItem
import java.awt.*;

public class CheckboxMenuDemo {

private Frame fr;
private MenuBar mb;
private Menu m1,m2,m3;
private MenuItem mi;
private CheckboxMenuItem cbm;
public void init() {
fr = new Frame("CheckboxMenuItem Demo");
mb = new MenuBar();
m1 = new Menu("File");
m2 = new Menu("Edit");
m3 = new Menu("View");
fr.setMenuBar(mb);
mb.add(m1);
mb.add(m2);
mb.add(m3);
mi = new MenuItem("Toolbars");
cbm = new CheckboxMenuItem("Status Bar", true);
m3.add(mi);
m3.add(cbm);
fr.setSize(200,200);
fr.setVisible(true);
}
public static void main(String args[]) {
CheckboxMenuDemo obj= new CheckboxMenuDemo();
obj.init();
}
}

รูปที่ 5.20 ผลลัพธที่ไดจากการรันโปรแกรมที่ 5.14

156 คณะเทคโนโลยีสารสนเทศ สถาบันเทคโนโลยีพระจอมเกลาเจาคุณทหารลาดกระบัง

5.6.5 การสรางเมนูยอย
เมนูสามารถที่จะมีเมนูยอยไดโดยเมนูยอยจะเปนออปเจ็คของคลาส Menu ซึ่ง
ขั้นตอนในการสรางเฟรมที่มีเมนูยอยมีดังนี้
1. สรางออปเจ็คของคลาส MenuBar แลวใสลงไปในออปเจ็คของคลาส Frame
2. สรางออปเจ็คของคลาส Menu แลวใสลงไปในออปเจ็คของคลาส MenuBar
3. สรางออปเจ็คของคลาส Menu สําหรับเมนูยอยแลวใสลงไปในออปเจ็คของ
คลาส Menu ที่เปนเมนูหลัก
4. สรางออปเจ็คของคลาส MeunItem แลวใสลงไปในออปเจ็คของคลาส Menu
ที่เปนเมนูยอย
โปรแกรมที่ 5.15 แสดงตัวอยางการสราง Frame ที่มีเมนูยอยโดยโปรแกรมนี้จะให
ผลลัพธดังแสดงในรูปที่ 5.21

โปรแกรมที่ 5.15 ตัวอยางการสราง Frame ที่มีเมนูยอย

import java.awt.*;

public class SubMenuDemo {

private Frame fr;
private MenuBar mb;
private Menu m1,m2,m3, ms1;
private MenuItem mi2,mi3,mi4, msi1, msi2;

public void init() {

fr = new Frame("SubMenuItem Demo");
mb = new MenuBar();
m1 = new Menu("File");
m2 = new Menu("Edit");
m3 = new Menu("View");
fr.setMenuBar(mb);
mb.add(m1);
mb.add(m2);
mb.add(m3);
ms1 = new Menu("New");
mi2 = new MenuItem("Open");
mi3 = new MenuItem("Save");
mi4 = new MenuItem("Exit");
m1.add(ms1);
m1.add(mi2);
m1.addSeparator();
m1.add(mi3);

Java Programming 157

 m1.addSeparator();
m1.add(mi4);
msi1 = new MenuItem("Window");
msi2 = new MenuItem("Message");
ms1.add(msi1);
ms1.addSeparator();
ms1.add(msi2);
fr.setSize(200,200);
fr.setVisible(true);
}
public static void main(String args[]) {
SubMenuDemo obj= new SubMenuDemo();
obj.init();
}
}

รูปที่ 5.21 ผลลัพธที่ไดจากการรันโปรแกรมที่ 5.15

5.7 คุณลักษณะของคลาส Component

สวนประกอบกราฟฟกตางๆจะมีคุณลักษณะอื่นอาทิเชน รูปแบบของฟอนต สีของพื้น
หลังหรือสีของพื้นหนา (Foreground) เราสามารถที่จะกําหนดคุณลักษณะของสวนประกอบ
กราฟฟกได โดยปกติสวนประกอบกราฟฟกจะใชคุณลักษณะแบบเดียวกับออปเจ็คประเภท
Container ที่บรรจุอยูเวนแตจะมีการกําหนดคุณลักษณะเฉพาะของสวนประกอบกราฟฟก
นั้นๆ

158 คณะเทคโนโลยีสารสนเทศ สถาบันเทคโนโลยีพระจอมเกลาเจาคุณทหารลาดกระบัง

 เมธอดที่ใชในการกําหนดคุณลักษณะของสวนประกอบกราฟฟก จะอยูในคลาส
Component โดยมีเมธอดที่สําคัญคือ

• setFont(Font f)
• setForeground(Color c)
• setBackground(Color c)
เมธอด setFont() ใชในการกําหนดรูปแบบของฟอนต สวนเมธอด
setForeground() และ setBackground() ใชในการกําหนดสีพื้นหนาและพื้นหลัง
ตามลําดับ
คลาส Font เปนคลาสที่ใชในการสรางออปเจ็คเพื่อกําหนดรูปแบบของฟอนต โดยมี
constructor ดังนี้
• public Font(String name, int style, int size)

โดยที่
• name คือชื่อของฟอนต
• style เปนรูปแบบของฟอนต ซึ่งคลาส Font ไดกําหนดคาคงที่ไวคือ
Font.PLAIN, Font.BOLD และ Font.ITALIC

• size คือขนาดของฟอนต
ตัวอยางของการสรางออปเจ็คของคลาส Font มีดังนี้
• Font fn1 = new Font(“AngsanaUPC”,Font.PLAIN,16);

• Font fn2 = new Font(“Time Romans”, Font.BOLD

+Font.ITALIC,14);
คลาส Color เปนคลาสที่ใชในการสรางออปเจ็คสําหรับกําหนดรูปแบบของสี โดยมี
constructor ดังนี้
public Color(int r, int g, int b)
โดยที่
• r, g, b คือคาความเขมของแสงสีแดง เขียวและน้ําเงิน ตามลําดับ
คลาส Color มีคุณลักษณะที่กําหนดสีที่ใชทั่วไปไวแลวหลายๆสีอาทิเชน
yellow = new Color(255,255,0);
black = new Color(0,0,0);

Java Programming 159

 โปรแกรมที่ 5.16 แสดงตัวอยางการกําหนดคุณลักษณะของออปเจ็คของคลาส
Frame และคลาส Button ใหมีสีและฟอนตตางๆ โดยจะไดผลลัพธดังแสดงในรูปที่ 5.22

โปรแกรมที่ 5.16 ตัวอยางการกําหนดคุณลักษณะ

import java.awt.*;

public class AttributeDemo {

private Frame fr;
private Button bn1,bn2,bn3;

public void init() {

fr = new Frame("ShowAttribute");
bn1 = new Button("OK");
bn2 = new Button("Cancel");
bn3 = new Button("Help");
fr.setLayout(new FlowLayout());
fr.add(bn1);
fr.add(bn2);
fr.add(bn3);
fr.setFont(new Font("TimesRoman",Font.BOLD,16));
fr.setForeground(Color.blue);
fr.setBackground(Color.green);
bn2.setForeground(Color.red);
fr.setSize(200,150);
fr.show();
}
public static void main(String args[]) {
AttributeDemo ad = new AttributeDemo();
ad.init();
}
}

รูปที่ 5.22 ผลลัพธที่ไดจากการรันโปรแกรมที่ 5.16

160 คณะเทคโนโลยีสารสนเทศ สถาบันเทคโนโลยีพระจอมเกลาเจาคุณทหารลาดกระบัง

5.8 การสรางภาพกราฟฟก
แพคเก็จ AWT มีคลาสที่เปนสวนประกอบกราฟฟกที่ชื่อ Canvas ซึ่งเปนเนื้อที่วาง
เปลาที่สามารถใชในการวาดรูปกราฟฟกหรือเขียนขอความใดๆได คลาสนี้จะมีเมธอด
paint() ซึ่งจะถูกเรียกใชงานเมื่อออปเจ็คของคลาสปรากฏใหเห็น หรือเมื่อออปเจ็คของ
คลาสมีการปรับเปลี่ยนขนาดหรือตําแหนง ซึ่งจะมีผลใหคําสั่งตางๆในเมธอดที่ paint() ถูก
เรียกใชงาน โดยทั่วไปคําสั่งที่อยูในเมธอด paint() จะเปนคําสั่งที่เกี่ยวของกับการวาดรูป
กราฟฟกตางๆ โดยเมธอด paint()มีรูปแบบดังนี้
public void paint(Graphics g) {
[statements]
}
โดยที่
• g คือออปเจ็คของคลาส Graphics ที่สามารถใชในการวาดรูปกราฟฟกตางๆ
• statements คือคําสั่งในการวาดรูปกราฟฟกตางๆ

5.8.1 การเขียนคลาสเพื่อวาดรูปกราฟฟก
การสรางภาพกราฟฟกในภาษาจาวา จะทําไดโดยการสรางคลาสที่เปนสวนกราฟฟก
ซึ่งสืบทอดมาจากคลาส Canvas แลว override เมธอด paint() โดยเขียนคําสั่งในการวาด
รูปกราฟฟกตางๆในเมธอด ตัวอยางเชน โปรแกรมที่ 5.17 แสดงตัวอยางของคลาส
MyCanvas ซึ่งจะลากเสนตรงจากพิกัด (coordinate) (10,10) ไปยังพิกัด (100,100)

โปรแกรมที่ 5.17 คลาส MyCanvas

import java.awt.*;

public class MyCanvas extends Canvas {

public void paint(Graphics g) {
g.drawLine(10,10,100,100);
}
}

คลาส MyCanvas เปนคลาสที่เปนสวนประกอบกราฟฟกคลาสหนึ่งเทานั้น การจะ

แสดงภาพกราฟฟกของคลาสนี้จะทําไดโดยการเขียนโปรแกรม GUI ที่มีการสรางออปเจ็คของ
คลาส Frame ที่เปน Container จากนั้นสรางออปเจ็คของคลาส MyCanvas แลวจึงใสลง
ในออปเจ็คของคลาส Frame ดังตัวอยางโปรแกรมที่ 5.18 ซึง่ จะไดผลลัพธเปนดังแสดงในรูป
ที่ 5.23

Java Programming 161

 โปรแกรมที่ 5.18 ตัวอยางการใชคลาส MyCanvas
import java.awt.*;

public class GUIDemo {

public static void main(String args[]) {
Frame fr = new Frame("Draw line");
MyCanvas mc = new MyCanvas();
fr.add(mc);
fr.setSize(150,150);
fr.setVisible(true);
}
}

รูปที่ 5.23 ผลลัพธที่ไดจากการรันโปรแกรมที่ 5.18

5.9 การสรางโปรแกรม GUI ที่ซับซอน

โดยทั่วไปโปรแกรม GUI จะมีการวางผังสวนประกอบกราฟฟกที่ซับซอนกวาการใช
ตัวจัดวางผังที่กลาวมาขางตน (BorderLayout, FlowLayout และ GridLayout)
วิธีการที่จะสรางโปรแกรม GUI ที่ซับซอนขึ้นสามารถทําไดโดยการสรางออปเจ็คของคลาสของ
คลาส Panel มาชวยในการจัดผัง
เราสามารถที่จะใสออปเจ็คของคลาส Panel ลงใน Container ตัวอื่น โดยเรา
สามารถที่จะสงสวนประกอบกราฟฟกลงใน Panel อีกทีหนึ่ง ทั้งนี้เราสามารถที่จะกําหนดให
Panel แตละตัวที่ซอนกันอยูมีตัวจัดวางผังที่ตางกัน

โปรแกรมที่ 5.19 แสดงตัวอยางของโปรแกรม GUI ที่มีออปเจ็คของคลาส Panel ที่

ชื่อ p1 ที่ใสอยูในออปเจ็คของคลาส Frame และมีออปเจ็คของคลาส Panel ที่ชื่อ p2 ใสอยู
ในออปเจ็ค p1 อีกตอหนึ่ง โดยออปเจ็ค p1 จะมีตัวจัดวางผังเปนแบบ BorderLayout และ

162 คณะเทคโนโลยีสารสนเทศ สถาบันเทคโนโลยีพระจอมเกลาเจาคุณทหารลาดกระบัง

ออปเจ็ค p2 จะมีตัวจัดวางผังเปนแบบ GridLayout โปรแกรมนี้จะใหผลลัพธดังแสดงในรูป
ที่ 5.24

โปรแกรมที่ 5.19 ตัวอยางการสรางโปรแกรม GUI ที่ซับซอน

import java.awt.*;

public class StickyPad {

private Frame fr;
private Panel p1, p2;
private TextArea ta1, ta2;
private Button bn1, bn2, bn3;
public void init() {
fr = new Frame("Sticky Pad");
p1 = new Panel();
p2 = new Panel();
bn1 = new Button("Submit");
bn2 = new Button("Leave");
bn3 = new Button("Return");
ta1 = new TextArea(4,40);
ta2 = new TextArea(4,40);
ta1.setBackground(Color.pink);
ta1.setFont(new Font("Dialog",Font.PLAIN,20));
ta2.setBackground(Color.lightGray);
ta2.setFont(new Font("Dialog",Font.PLAIN,20));
p1.setLayout(new GridLayout(2,1));
p1.add(ta1);
p1.add(ta2);
p2.setLayout(new FlowLayout());
p2.add(bn1);
p2.add(bn2);
p2.add(bn3);
fr.add(p1);
fr.add(p2,BorderLayout.SOUTH);
fr.setSize(400,300);
fr.show();
}
public static void main(String args[]) {
StickyPad obj = new StickyPad();
obj.init();
}
}

Java Programming 163

 รูปที่ 5.24 ผลลัพธที่ไดจากการรันโปรแกรมที่ 5.19

5.10 แพคเก็จ Swing

Swing เปนแพคเก็จสําหรับพัฒนาโปรแกรม GUI ซึ่งมีสวนประกอบกราฟฟกที่มาก
ชนิดกวาที่มีอยูในแพคเก็จ AWT นอกจากนี้สวนประกอบกราฟฟกของแพคเก็จ Swing จะมี
ลักษณะที่ดีกวาสวนประกอบกราฟฟกของแพคเก็จ AWT สวนประกอบกราฟฟกของแพคเก็จ
Swing สามารถกําหนดรูปแบบของ look and feel ที่ทําใหไดโปรแกรม GUI ที่มีรูปแบบของ
กราฟฟกเหมือนกันในทุกแพลตฟอรม ซึ่งจะแตกตางกับแพคเก็จ AWT ที่จะมีรูปแบบของ
กราฟฟกซึ่งขึ้นอยูกับ look and feel ของแตละแพลตฟอรม ซึ่งการกําหนด look and feel ได
เองนี้ทําใหโปรแกรม GUI ที่ใชออปเจ็คของแพคเก็จ Swing แสดงผลไดชากวาโปรแกรม GUI
ที่ใชออปเจ็คของแพคเก็จ AWT
แพคเก็จของ Swing อยูในแพคเก็จ javax.swing ซึ่งคลาสที่เปนสวนประกอบ
กราฟฟกของแพคเก็จ Swing ทุกคลาสจะสืบทอดมาจากคลาส JComponent ดังแสดงใน
รูปที่ 5.25 โดยคลาส JComponent จะสืบทอดมาจากคลาส Container ในแพคเก็จ
AWT อีกตอหนึ่ง

164 คณะเทคโนโลยีสารสนเทศ สถาบันเทคโนโลยีพระจอมเกลาเจาคุณทหารลาดกระบัง

 รูปที่ 5.25 คลาสตางๆที่สืบทอดมาจากคลาส JComponent

แพคเก็จ Swing จะมีคลาสที่เปนสวนประกอบกราฟฟกที่สอดคลองกับคลาสใน

แพคเก็จ AWT โดยคลาสเหลานี้จะมีชื่อขึ้นตนดวยตัวอักษร ‘J’ โดยมีคลาสที่สําคัญดังนี้
• JFrame เปนคลาสที่เปนเฟรมในแพคเก็จ Swing
• JPanel เปนคลาสที่เปน Panel ในแพคเก็จ Swing
• JButton เปนคลาสที่ทําหนาที่เปนปุมในแพคเก็จ Swing
• JLabel เปนคลาสที่ใชในการสรางออปเจ็คที่ไวในการแสดงขอความใน
แพคเก็จ Swing
• JTextField เปนคลาสที่ใชในการปอนขอความหนึ่งบรรทัดในแพคเก็จ
Swing
• JTextArea เปนคลาสที่ใชในการปอนขอความหลายบรรทัดในแพคเก็จ
Swing
• JScrollBar เปนคลาสที่ทําหนาที่เปนแถบควบคุมเพื่อใหผูใชเลื่อนไปยัง
ตําแหนงที่ตองการไดในแพคเก็จ Swing
• JCheckBox เปนคลาสที่ทําหนาที่คลายปุมในแพคเก็จ Swing
• JChoice เปนคลาสที่ผูใชสามารถเลือกรายการไดในแพคเก็จ Swing

Java Programming 165

 5.10.1 คลาส JFrame
แพคเก็จ Swing มีคลาสประเภท Container ที่แตกตางจากคลาสประเภท
Container ของแพคเก็จ AWT คือ JFrame, JDialog, JPanel และ JApplet
โดยทั่วไปโปรแกรม GUI ที่เปนโปรแกรมจาวาประยุกตจะใช Container ที่เปนออปเจ็ค
ของคลาส JFrame
คลาส JFrame จะสืบทอดมาจากคลาส Frame โดยมี constructor ที่สําคัญดังนี้
• public JFrame()
• public JFrame(String title)
ออปเจ็คของคลาส Jframe จะแตกตางกับ Frame ตรงที่จะมีหนาตาง (Pane) อยู
4 หนาตางดังแสดงในรูปที่ 5.26 คือ
• root pane
• layer pane
• glass pane
• content pane

รูปที่ 5.26 หนาตางที่อยูในคลาส Jframe

เราไมสามารถที่จะใสสวนประกอบกราฟฟกลงใน JFrame ไดโดยตรง แตจะตองใส

ลงในหนาตางที่เปน content pane แทน ทั้งนี้หนาตางดังกลาวเปนออปเจ็คของคลาสประเภท
Container แบบหนึ่ง เราสามารถที่จะเรียกออปเจ็คของคลาสประเภท Container

166 คณะเทคโนโลยีสารสนเทศ สถาบันเทคโนโลยีพระจอมเกลาเจาคุณทหารลาดกระบัง

ดังกลาวมาไดโดยใชเมธอดที่ชื่อ getContentPane() และสามารถที่จะใสสวนประกอบ
กราฟฟกลงในออปเจ็คดังกลาวไดโดยใชเมธอด add() ดังตัวอยางเชน
Container content = fr.getContentPane();
content.setLayout(new BorderLayout());
content.add(bn1,BorderLayout.SOUTH);
โปรแกรมที่ 5.20 แสดงตัวอยางการใชคลาสตางๆในแพคเก็จ Swing เพื่อสราง
โปรแกรม GUI ซึ่งใหผลลัพธดังแสดงในรูปที่ 5.27

โปรแกรมที่ 5.20 ตัวอยางการสรางโปรแกรม GUI โดยใชคลาสในแพคเก็จ Swing

import java.awt.*;
import javax.swing.*;

public class StickyPadSwing {

private JFrame fr;
private JPanel p1, p2;
private JTextArea ta1, ta2;
private JButton bn1, bn2, bn3;
public void init() {
fr = new JFrame("Sticky Pad");
p1 = new JPanel();
p2 = new JPanel();
bn1 = new JButton("Submit");
bn2 = new JButton("Leave");
bn3 = new JButton("Return");
ta1 = new JTextArea(4,40);
ta2 = new JTextArea(4,40);
ta1.setBackground(Color.pink);
ta1.setFont(new Font("Dialog",Font.PLAIN,20));
ta2.setBackground(Color.lightGray);
ta2.setFont(new Font("Dialog",Font.PLAIN,20));
p1.setLayout(new GridLayout(2,1));
p1.add(ta1);
p1.add(ta2);
p2.setLayout(new FlowLayout());
p2.add(bn1);
p2.add(bn2);
p2.add(bn3);
Container c = fr.getContentPane();
c.add(p1);
c.add(p2,BorderLayout.SOUTH);
fr.setSize(400,300);
fr.show();
}

Java Programming 167

 public static void main(String args[]) {
StickyPadSwing obj = new StickyPadSwing();
obj.init();
}
}

รูปที่ 5.27 ผลลัพธที่ไดจากการรันโปรแกรมที่ 5.20

นอกจากนี้เราสามารถที่จะกําหนด content pane ของออปเจ็คชนิด JFrame ได

โดยเรียกใชเมธอด setContentPane() โปรแกรมที่ 5.21 แสดงตัวอยางการสราง
ออปเจ็คชนิด JPanel ขึ้นมาแลวนําสวนประกอบกราฟฟกใสลงในออปเจ็ค p1 จากนั้น
กําหนดให p1 เปน content pane ของออปเจ็ค fr ชนิด JFrame โดยใชเมธอด
setContentPane()

168 คณะเทคโนโลยีสารสนเทศ สถาบันเทคโนโลยีพระจอมเกลาเจาคุณทหารลาดกระบัง

โปรแกรมที่ 5.21 ตัวอยางการสราง Jframe โดยใชเมธอด setContentPane()

import javax.swing.*;
import java.awt.*;

public class SwingDemo {

public static void main(String args[]) {

JFrame fr = new JFrame("SwingDemo");
JPanel p1 = new JPanel();
JButton bn1 = new JButton("New");
p1.add(bn1);
fr.setContentPane(p1);
fr.pack();
fr.show();
}
}

5.10.2 คลาส JComponent

คลาส JComponent มีเมธอดที่เพิ่มลักษณะตางๆใหกับออปเจ็คที่เปนสวนประกอบ
กราฟฟก อาทิเชน
• setBorder(Border bd) เปนเมธอดสําหรับกําหนดขอบใหกับ
สวนประกอบกราฟฟก
• setToolTipText(Swing text) เปนเมธอดสําหรับกําหนดขอความที่จะ
แสดงเปน tooltip ใหกับสวนประกอบกราฟฟก

5.10.3 การใชคุณลักษณะเดนอื่นๆ
แพคเก็จ Swing ยังมีเมธอดอื่นๆที่ใชในการกําหนดรูปลักษณและคุณลักษณะเดนของ
ออปเจ็คที่เปนสวนประกอบกราฟฟกตางๆเพิ่มเติมอาทิเชน
• void setMnemonic(char c) หรือ
• void setMnemonic(int i)
เปนเมธอดในการกําหนดคียที่เปน shortcut ใหกับออปเจ็คของคลาส JButton
• void setIcon(Icon c)

Java Programming 169

 เปนเมธอดในการใสไอคอน (icon) ลงในออปเจ็คของสวนประกอบกราฟฟกตางๆ
เชน ปุม
นอกจากนี้แพคเก็จ Swing จะอนุญาตใหผูใชสามารถกําหนด look and feel ของ
โปรแกรม GUI บนแพลตฟอรมตางๆเองได โดยมีคลาสที่ชื่อ LookAndFeel ที่ใชในการ
กําหนดรูปแบบตางๆของสวนประกอบกราฟฟกเชน ฟอนต ขนาด สี การจัดการกับ
เหตุการณ (Event) เปนตน โดยทั่วไปโปรแกรม GUI ที่ใชแพคเก็จ Swing จะสรางออปเจ็คของ
คลาส UIManager ขึ้นมาตอนรันโปรแกรม เพื่อตรวจสอบรูปแบบ look and feel ของ
โปรแกรม GUI และเราสามารถที่จะกําหนดรูปแบบ look and feel ใหมได โดยใชเมธอด
UIManager.setLookAndFeel(LoodAndFeel l)

สรุปเนื้อหาของบท
• คลาสที่อยูในแพคเก็จ java.awt สามารถนํามาใชสรางโปรแกรม GUI แบบ Look
and Feel ตามแพลตฟอรมที่ใชงานได โดยมีคลาส Component เปน superclass
ของทุกคลาสที่เปนคลาสประเภท Container และคลาสประเภทสวนประกอบกราฟฟก
• คลาสประเภท Container ที่สําคัญคือคลาส Frame และ Panel
• คลาสประเภทสวนประกอบกราฟฟกที่สําคัญคือ Button, Label, TextField,
TextArea, Checkbox, Choice และ List

• รูปแบบการจัดวางผังสวนประกอบกราฟฟกในตัวใสสวนประกอบกราฟฟกมีทั้งหมด 5
รูปแบบคือ BorderLayout, FlowLayout, GridLayout, CardLayout
และ GridBagLayout
• การจัดวางผังของสวนประกอบกราฟฟกแบบ BorderLayout จะเปนการวางตาม
ทิศตางๆได 5 ทิศ สวน FlowLayout จะวางไวในตําแหนงบนสุดโดยเรียงจากซาย
ไปขวา สําหรับ GridLayout จะวางเรียงจากซายไปขวา และบนลงลางในชองยอย
ที่มีขนาดเทากัน ตามจํานวนแถวและคอลัมนที่ไดระบุไว
• Label จะแสดงขอความ ซึ่งผูใชไมสามารถปอนขอความได แตสําหรับ
TextField ผูใชสามารถปอนขอความไดยาวหนึ่งบรรทัด สวน TextArea ผูใช
สามารถปอนขอความไดหลายบรรทัด

170 คณะเทคโนโลยีสารสนเทศ สถาบันเทคโนโลยีพระจอมเกลาเจาคุณทหารลาดกระบัง

• Checkbox จะเปนชองใหผูใชเลือกหรือไมเลือกโดยสามารถเลือกไดหลายชองพรอม
กัน ซึ่งจะแตกตางจาก CheckboxGroup ที่จะสามารถเลือกไดเพียงชองเดียว
เทานั้น
• Choice จะแสดงรายการที่ถูกเลือกเพียงรายการเดียว โดยจะแสดงหลายรายการ
เมื่อผูใชคลิกเมาสเทานั้น ซึ่งจะแตกตางจาก List ที่จะสามารถแสดงไดหลาย
รายการพรอมกัน
• คลาสที่จะนํามาใชในการแสดงแถบเมนูและเมนูยอยคือ MenuBar, Menu และ
MenuItem
• คลาส Font และ Color จะถูกนํามาใชในกรณีที่ตองการระบุคุณลักษณะ ฟอนต
และสีของตัวใสสวนประกอบกราฟฟกและสวนประกอบกราฟฟก
• การสรางภาพกราฟฟกในภาษาจาวาจะทําไดโดยการสรางคลาสที่เปนสวนกราฟฟก
ซึ่งสืบทอดมาจากคลาส Canvas แลว override เมธอด paint()
• คลาส Graphics จะมีเมธอดในการวาดรูปทรงกราฟฟกตางๆหลายเมธอด
• คลาสในแพคเก็จ javax.swing จะถูกนํามาใชในการสราง GUI คลายกับ
java.awt แตจะไมเปนแบบ Look and Feel คือจะมีลักษณะของ GUI ที่เหมือนกัน
ในทุกแพลตฟอรม โดยไมขึ้นอยูกับแพลตฟอรมที่นําไปใชงาน

Java Programming 171

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

6.1 เมธอด
เมธอดเปนสมาชิกของคลาสเพื่อระบุ วิธีการหรือพฤติกรรม ที่ออปเจ็คของคลาส
สามารถกระทําได เมธอดทําหนาที่ในการสงขาวสารระหวางออปเจ็ค ซึ่งเปรียบเทียบไดกับการ
ใช function หรือ procedure ที่อยูในโปรแกรมเชิงกระบวนการ ตัวอยางโปรแกรมในบทที่
ผานมาจะเขียนทุกคําสั่งอยูภายในเมธอด main() การเขียนโปรแกรมเชิงออปเจ็คที่ดีจะตอง
มีการกําหนดเมธอดตางๆใหกับคลาส และมีการสรางออปเจ็คของคลาส แลวจึงจะเรียกใช
เมธอดที่สรางขึ้นตัวอยางเชน โปรแกรมที่ 6.1 เปนโปรแกรมที่มีการเขียนคําสั่งทั้งหมดอยูใน
เมธอด main() โปรแกรมนี้ไมไดใชหลักการเชิงออปเจ็คและไมเหมาะที่จะนําไปใชในทาง
ปฏิบัติเมื่อโปรแกรมมีขนาดใหญขึ้น
เราสามารถเขียนโปรแกรมที่ 6.1 ใหมโดยใชหลักการเชิงออปเจ็คดังโปรแกรมที่ 6.2
โดยกําหนดใหมีคลาสสองคลาส คลาสแรกชื่อ NumericalClass จะมีเมธอด
calculate() ซึ่งจะมีคําสั่งตางๆที่อยูในบล็อกของเมธอด main() ของโปรแกรมที่ 6.1
สวนอีกคลาสชื่อ MyMain เปนคลาสที่กําหนดเพื่อเปนจุดเริ่มตนของโปรแกรม โดยมี เมธอด
main() อยูในคลาส ซึ่งเมธอด main()จะสรางออปเจ็คของคลาส NumericalClass
และมีคําสั่งเรียกใชเมธอด calculate() ในขณะเดียวกันเราก็สามารถที่จะเขียนโปรแกรม
โดยใชหลักการเชิงออปเจ็คโดยกําหนดเมธอด main() ใหอยูภายในคลาสเดียวกันกับคลาสที่
ตองการสรางออปเจ็คได โดยจะมีรูปแบบดังโปรแกรมที่ 6.3

Java Programming 173

 โปรแกรมที่ 6.1 การเขียนคําสั่งทั้งหมดในเมธอด main()
public class AllInMain {
public static void main(String args[]) {
double score = Math.random()*100;
if (score >= 80) {
System.out.println("Grade is A");
} else if (score >= 70) {
System.out.println("Grade is B");
} else if (score >= 60){
System.out.println("Grade is C");
} else if (score >= 50){
System.out.println("Grade is D");
} else {
System.out.println("Grade is F");
}
}
}

โปรแกรมที่ 6.2 การเขียนโปรแกรมโดยใชหลักการเชิงออปเจ็ค

public class NumericalClass {

public void calculate() {
double score = Math.random()*100;
if (score >= 80) {
System.out.println("Grade is A");
} else if (score >= 70) {
System.out.println("Grade is B");
} else if (score >= 60){
System.out.println("Grade is C");
} else if (score >= 50){
System.out.println("Grade is D");
} else {
System.out.println("Grade is F");
}
}
}
--------------------------------------------------------------------------------------------------------------------------------------------------------
public class MyMain {
public static void main(String args[]) {
NumericalClass obj = new NumericalClass();
obj.calculate();
}
}

174 คณะเทคโนโลยีสารสนเทศ สถาบันเทคโนโลยีพระจอมเกลาเจาคุณทหารลาดกระบัง

โปรแกรมที่ 6.3 การเขียนโปรแกรมโดยใหทุกเมธอดอยูภายในคลาสเดียวกัน

public class NumericalClassV1 {

public void calculate() {
double score = Math.random()*100;
if (score >= 80) {
System.out.println("Grade is A");
} else if (score >= 70) {
System.out.println("Grade is B");
} else if (score >= 60){
System.out.println("Grade is C");
} else if (score >= 50){
System.out.println("Grade is D");
} else {
System.out.println("Grade is F");
}
}
public static void main(String args[]) {
NumericalClassV1 obj = new NumericalClassV1();
obj.calculate();
}
}

การเขียนโปรแกรมตามตัวอยางของโปรแกรมที่ 6.2 หรือ โปรแกรมที่ 6.3 เปนการ

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

6.1.1 การเรียกใชเมธอด
เมธอดที่กําหนดขึ้นในคลาสใดๆสามารถเรียกใชงานไดสองรูปแบบคือ
1. การเรียกใชงานจากคลาสที่ตางกัน
2. การเรียกใชงานภายในคลาสเดียวกัน
การเรียกใชเมธอดจากคลาสที่ตางกัน จะตองมีการสรางออปเจ็คของคลาสที่มีเมธอด
ที่จะถูกเรียกใชงานกอน จึงจะสามารถเรียกใชเมธอดได ดังตัวอยางในโปรแกรมที่ 6.2 คลาส
MyMain จะตองสรางออปเจ็คของคลาส NumericalClass กอน จึงจะเรียกใชงานเมธอด
calculate() ได โดยใชคําสั่ง
NumericalClass obj = new NemericalClass();

Java Programming 175

 obj.calculate();
ทั้งนี้เมธอดที่จะถูกเรียกใชงานจากคลาสที่ตางกัน จะตองไมมี modifier เปน
private
การเรียกใชเมธอดภายในคลาสเดียวกันสามารถทําไดโดยไมจําเปนตองสรางออปเจ็ค
ของคลาสขึ้นมากอน และสามารถเรียกเมธอดไดทุกเมธอด ยกเวนเมธอดที่มี modifier เปน
static จะไมสามารถเรียกใชเมธอดที่ไมมี modifier เปน static (เรียกวา เมธอดแบบ
non-static) ได ซึ่งจะกลาวถึงภายหลัง
โปรแกรมที่ 6.4 แสดงตัวอยางการเรียกใชเมธอดภายในคลาสเดียวกัน โปรแกรมนี้
กําหนดเมธอดในคลาส NumericalClass ขึ้นมาใหมที่ชื่อ callMethod() แลวเรียกใช
เมธอด calculate() ภายในเมธอดที่กําหนดขึ้นใหม

โปรแกรมที่ 6.4 การเรียกใชเมธอดภายในคลาสเดียวกัน

public class NumericalClassV2 {
public void calculate() {
double score = Math.random()*100;
if (score >= 80) {
System.out.println("Grade is A");
} else if (score >= 70) {
System.out.println("Grade is B");
} else if (score >= 60){
System.out.println("Grade is C");
} else if (score >= 50){
System.out.println("Grade is D");
} else {
System.out.println("Grade is F");
}
}
public void callMethod() {
calculate();
}
}

6.1.2 การสงผาน argument

เมธอดที่กําหนดขึ้นในคลาสอาจมี argument ที่รับคาเพื่อนําไปใชในเมธอดอาทิเชน
เมธอด setGPA() ในคลาส Student ของโปรแกรมที่ 6.5 จะมี argument สําหรับรับคา

176 คณะเทคโนโลยีสารสนเทศ สถาบันเทคโนโลยีพระจอมเกลาเจาคุณทหารลาดกระบัง

ขอมูลที่มีชนิดขอมูลเปน double ในกรณีนี้การเรียกใชเมธอดจะตองสง argument ที่มีชนิด
ขอมูลที่สอดคลองกันไปพรอมกัน ดังนั้นการเรียกใชเมธอด setGPA() จะตองสง argument
ที่มีชนิดขอมูลเปน double ไปพรอมกับชื่อเมธอด ดังแสดงในคลาส MyMain2 ในโปรแกรม
ที่ 6.5 (คําสั่ง s1.setGPA(3.0);)

โปรแกรมที่ 6.5 ตัวอยางการสงผาน argument

public class Student {

String id;
String name;
double gpa;
public void setGPA(double GPA) {
gpa = GPA;
}
public double getGPA() {
return gpa;
}
}
-------------------------------------------------------
public class MyMain2 {
public static void main(String args[]) {
Student s1 = new Student();
s1.setGPA(3.0);
}
}

argument ของเมธอดจะมีชนิดขอมูลเปนสองแบบตามชนิดขอมูลของตัวแปรดังนี้
1. argument ที่มีชนิดขอมูลแบบพื้นฐาน
2. argument ที่มีชนิดขอมูลแบบอางอิง
ในกรณีของ argument ที่มีชนิดขอมูลแบบพื้นฐาน เราสามารถที่จะสงคาคงที่ขอมูล
ตัวแปร หรือนิพจนใหกับ argument ไดอาทิเชน การเรียกใชเมธอด setGPA() นั้น
argument ที่จะสงผานอาจมีรูปแบบเปน
• คาคงที่ขอมูล เชน
s1.setGPA(3.0);

Java Programming 177

 • ตัวแปร เชน
double x = 3.0;
s1.setGPA(x);
• นิพจน เชน
s1.setGPA(3.0+0.05);
สวนกรณี argument ที่มีชนิดขอมูลแบบอางอิง เราจะตองสงออปเจ็คที่มีชนิดขอมูลที่
สอดคลองไปเทานั้น ยกเวนกรณีที่ argument นั้นมีชนิดขอมูลเปน String ซึ่งในกรณีนี้จะ
สามารถสงขอมูลคาคงที่ได โปรแกรมที่ 6.6 เปนตัวอยางของคลาส StudentV1 ที่มี
คุณลักษณะ dob ซึ่งมีชนิดขอมูลเปนคลาส Date ที่กําหนดไวใน Java API เพื่อเก็บวัน
เดือน ปเกิดของออปเจ็คชนิด StudentV1 คลาส StudentV1 มีเมธอด setDOB()เพื่อ
ใชในการกําหนดคาใหกับคุณลักษณะ dob

โปรแกรมที่ 6.6 ตัวอยางการสงผาน argument ที่เปนออปเจ็ค

import java.util.*;

public class StudentV1 {

String id;
String name;
Date dob;
public void setDOB(Date d) {
dob = d;
}
public Date getDOB() {
return dob;
}
}

โปรแกรมที่ 6.7 แสดงการเรียกใชเมธอดดังกลาวโดยตองสงผานออปเจ็คของคลาส

Date ใหกับเมธอด ดังนี้
Date d1 = new Date(16, 12, 1980);
s1.setDOB(d1);

สําหรับกรณีของโปรแกรมที่ 6.7 เนื่องจากออปเจ็ค d1 ที่สรางขึ้นมา จะไมมีการ

อางอิงภายในโปรแกรมนี้อีก ดังนั้นเราสามารถที่จะสรางออปเจ็คและสงผานไปยัง argument
ในคําสั่งเดียวกันไดดังนี้
s1.setDOB(new Date (16, 12, 1980));

178 คณะเทคโนโลยีสารสนเทศ สถาบันเทคโนโลยีพระจอมเกลาเจาคุณทหารลาดกระบัง

โปรแกรมที่ 6.7 ตัวอยางการเรียกใชเมธอดที่มี argument เปนออปเจ็ค

import java.util.*;

public class TestStudentV1 {

public static void main(String args[]) {
StudentV1 s1 = new StudentV1();
Date d1 = new Date(16,12,1980);
s1.setDOB(d1);
}
}

ชนิดขอมูลของ argument ที่จะสงผานไปยังเมธอดไมจําเปนที่จะตองเปนชนิดขอมูล

เดียวกัน แตตองเปนชนิดขอมูลที่สามารถแปลงขอมูลใหกวางขึ้นไดโดยอัตโนมัติอาทิเชน เรา
สามารถที่จะสง argument ที่มีชนิดขอมูลเปน int ใหกบั เมธอด setGPA() ที่ตองการ
argument ที่มีชนิดขอมูลเปน double ไดดังนี้ s1.setGPA(3);
เมธอดใดๆอาจมี argument สําหรับรับคามากกวาหนึ่งตัว แตการเรียกใชเมธอด
เหลานี้จะตองสง argument ที่มีชนิดขอมูลที่สอดคลองกันและมีจํานวนเทากัน โปรแกรมที่ 6.8
แสดงตัวอยางของคลาส NumericalSample ซึ่งมีเมธอด calMax() ที่รับ argument
สองตัวที่มีชนิดขอมูลเปน int และ double ตามลําดับ การเรียกใชเมธอดนี้จะตองสงผาน
argument จํานวนสองตัวอาทิเชน คําสั่ง obj.calMax(3,4.0); ในเมธอด main()
นอกจากนี้เรายังจะสามารถเรียกใชเมธอด calMax() ในรูปแบบอื่นไดโดยสง argument ที่มี
ชนิดขอมูลที่สอดคลองกันอาทิเชน
obj.calMax(3,4);
obj.calMax(3,4L);
แตเราไมสามารถที่จะเรียกใชเมธอดโดยมีจํานวน argument ไมเทากับที่กําหนด หรือ
มีชนิดขอมูลที่ไมสอดคลองกันอาทิเชน คําสั่ง
obj.calMax(3);
obj.calMax(4.0);
obj.calMax(3L,4.0);
obj.calMax(3.0,4);
obj.calMax(3,4.0,5);
จะเปนคําสั่งในการเรียกใชเมธอดที่ผิด

Java Programming 179

 โปรแกรมที่ 6.8 ตัวอยางการสงผาน argument จํานวนสองตัว

public class NumericalSample {

public void calMax(int i, double d) {
if (i > d) {
System.out.println("Max = "+i);
} else {
System.out.println("Max = "+d);
}
}
public static void main(String args[]) {
NumericalSample obj = new NumericalSample();
obj.calMax(3,4.0);
}
}

ในกรณีที่ argument มีชนิดขอมูลเปนแบบพื้นฐาน และมีการสง argument โดยใช

ตัวแปรใหกับเมธอดที่ถูกเรียกใชงาน โปรแกรมภาษาจาวาจะถือวาเปนการสงคาไปใหเทานั้น
หากมีการเปลี่ยนแปลงคาของ argument ภายในเมธอดที่ถูกเรียกใชงาน จะไมมผี ลทําใหคา
ของ argument ที่สงไปเปลี่ยนคาไปดวย โปรแกรมที่ 6.9 แสดงตัวอยางการเรียกใชเมธอด
method1()ในคลาส ArgumentPassing ซึ่งรับ argument ที่เปนตัวแปร x เขามา ซึ่ง
เมื่อ x ในเมธอดเปลี่ยนคาเปน 3 จะไมมผี ลทําใหคาของ x ในเมธอด main() เปลี่ยนไป
ดวย จึงไดผลลัพธออกมาเปน 4 เชนเดิม อนึ่งตัวแปร x ที่อยูในเมธอด main() และเมธอด
method1()เปนตัวแปรคนละตัวกัน และมีตําแหนงอางอิงสําหรับเก็บขอมูลในหนวยความจํา
ที่ตางกัน เพียงแตมีชื่อเดียวกันเทานั้น
สวนกรณีที่ argument มีชนิดขอมูลเปนแบบอางอิงจะเปนการสงตําแหนงอางอิงของ
ออปเจ็คไปใหกบั เมธอดที่ถูกเรียกใชงาน ดังนั้นการเปลี่ยนแปลงคาของคุณลักษณะของ
ออปเจ็คจะมีผลทําใหคาของคุณลักษณะของออปเจ็คที่สงไปเปลี่ยนไปดวย ตัวอยางเชน
ในโปรแกรมที่ 6.9 การเรียกใชเมธอด method2()โดยการสงผานตัวแปรที่เปนออปเจ็คของ
คลาส Date ไป แลวเปลี่ยนคาของคุณลักษณะวัน เดือน และปของออปเจ็คในเมธอด
method2()จะมีผลทําใหคาของคุณลักษณะวัน เดือน และปของออปเจ็ค d1 ในเมธอด
main()เปลี่ยนไปดวย

180 คณะเทคโนโลยีสารสนเทศ สถาบันเทคโนโลยีพระจอมเกลาเจาคุณทหารลาดกระบัง

โปรแกรมที่ 6.9 ตัวอยางการเปลี่ยนแปลงคาของ argument
import java.util.*;

public class ArgumentPassing {

public void method1(int x) {
x = 3;
}
public void method2(Date d) {
d.setDate(1);
d.setMonth(1);
d.setYear(2002);
}
public int method3() {
return 0;
}
public static void main(String args[]) {
int x = 4;
ArgumentPassing obj = new ArgumentPassing();
Date d1 = new Date(16,12,1980);
obj.method1(x);
System.out.println("x = "+x);
obj.method2(d1);
System.out.println("Date = "+d1);
obj.method3();
}
}

6.1.3 การรับคาที่สงกลับมา
เมธอดใดๆของคลาสสามารถที่จะมีคาที่สงกลับมาได ทั้งนี้การประกาศเมธอดจะตอง
ระบุชนิดขอมูลของคาที่จะสงกลับใน return_type ซึ่งชนิดขอมูลของคาที่จะสงกลับอาจเปน
ชนิดขอมูลแบบพื้นฐาน หรือเปนชนิดขอมูลแบบอางอิง ในกรณีที่เมธอดไมมีขอมูลจะสงกลับมา
จะตองระบุให return_type เปน void อาทิเชน เมธอด setGPA() ในคลาส student
ของโปรแกรมที่ 6.5 นอกจากนี้เมธอดที่มีคาที่จะสงกลับมาจะตองมีคําสั่ง return ซึ่งจะระบุ
คาที่สงกลับโดยมีรูปแบบดังนี้

return value;

โดยที่ value ขึ้นอยูกับชนิดขอมูลที่จะสงกลับ ถาเปนชนิดขอมูลแบบพื้นฐานอาจ

เปนคาคงที่ขอมูล ตัวแปร หรือนิพจนก็ได แตถาเปนชนิดขอมูลแบบอางอิงตองเปนออปเจ็ค

Java Programming 181

 เทานั้น ยกเวนชนิดขอมูล String ที่อาจเปนขอมูลคาคงที่ได
คําสั่ง return จะมีผลใหโปรแกรมสิ้นสุดการทํางานในบล็อกของเมธอดนั้นแลว
กลับไปยังคําสั่งเดิมที่เรียกใชเมธอดนั้น
โดยทั่วไปการเรียกใชเมธอดที่มีการสงคากลับมานั้น จะตองเรียกใชเมธอดนั้นใน
นิพจนอาทิเชน การเรียกใชเมธอด getGPA() ของคลาส Student ในโปรแกรมที่ 6.5 อาจ
ทําไดดังนี้
double d = s1.getGPA();
หรือ System.out.println("GPA: "+ s1.getGPA());
ทั้งสองคําสั่งเปนการเรียกใชเมธอดในนิพจน แตคําสั่งแรกจะเก็บคาที่สงกลับใน
ตัวแปรที่ d สวนคําสั่งที่สองจะไมเก็บคาที่สงกลับแตจะพิมพคาออกมา
นอกจากนี้เราสามารถที่เรียกใชเมธอดที่มีการสงคากลับมา โดยไมอยูในรูปของนิพจน
ไดอาทิเชน เมธอด method3() ในโปรแกรมที่ 6.9 จะสงคาที่มีชนิดขอมูลเปน int กลับมา
แตเนื่องจากไมตองการใชคาดังกลาว จึงสามารถใชคําสั่ง obj.method3(); ไดโดยไมตอง
ใชคําสั่งกําหนดคา

6.1.4 modifier ของเมธอด

เมธอดของคลาสจะมี modifier ที่ประกาศไวหนา return_type ของเมธอดดังที่ระบุ
ไวในหัวขอที่ 4.2.3 ซึ่ง modifier ของเมธอดแบงออกเปน
• access modifier เพื่อระบุถึงระดับการเขาถึง
• static เพื่อระบุวาเปนเมธอดแบบ static
• abstract เพื่อระบุวาเมธอดยังไมสมบูรณ
• synchronized เพื่อระบุวาเมธอดจะมีการล็อกออปเจ็ค ซึ่งใชในกรณีของ
โปรแกรมที่เปนแบบเธรด (thread)
• final เพื่อระบุวาเมธอดนี้ไมสามารถ override ได

access modifier
modifier ประเภทนี้ใชเพื่อระบุระดับการเขาถึง โดยมีคียเวิรดตางๆดังนี้
• public

• protected

182 คณะเทคโนโลยีสารสนเทศ สถาบันเทคโนโลยีพระจอมเกลาเจาคุณทหารลาดกระบัง

 • private
• default (ไมระบุคียเวิรดใดๆ)
เมธอดหรือคุณลักษณะที่มี modifier เปนแบบ public จะทําใหเมธอดหรือ
คุณลักษณะนั้นสามารถที่จะถูกเรียกใชจากเมธอดของคลาสอื่นได สวนเมธอดหรือคุณลักษณะ
ที่มี modifier เปนแบบ private จะถูกปองกันไมใหเมธอดจากคลาสอื่นเรียกใชได โดยจะ
สามารถถูกเรียกใชไดจากเมธอดภายในคลาสเดียวกันเทานั้น โปรแกรมที่ 6.10 แสดงตัวอยาง
การประกาศเมธอดและคุณลักษณะที่มี modifier เปนแบบ public และ private ตัวอยาง
นี้แสดงใหเห็นวาเมธอดและคุณลักษณะที่มี modifier เปนแบบ private ไมสามารถที่จะให
คลาสอื่นเรียกใชงานได กรณีที่เมธอดหรือคุณลักษณะไมระบุคียเวิรดใดๆสําหรับ access
modifier ภาษาจาวาจะถือวาเปน default ซึ่งจะทําใหเมธอดหรือคุณลักษณะนั้นสามารถที่จะ
ถูกเรียกใชจากเมธอดของคลาสอื่นที่อยูในแพคเก็จเดียวกันได สําหรับความหมายของ
modifier ที่เปนแบบ protected จะกลาวถึงตอไป

โปรแกรมที่ 6.10 ตัวอยางการประกาศเมธอดและคุณลักษณะ

public class PrivateStudent {
private String id;
private String name;
private double gpa;
public void setDetails(String ID,String n,double GPA) {
id = ID;
name = n;
gpa = GPA;
}
public void showDetails() {
System.out.println("ID: "+id);
System.out.println("Name: "+name);
System.out.println("GPA: "+gpa);
}
}
----------------------------------------------------------
public class TestPrivateStudent {
public static void main(String args[]) {
PrivateStudent ps = new PrivateStudent();
/* ps.id = "12345"; illegal
ps.name = "Thana"; illegal
ps.gpa = 3.25; illegal */
ps.setDetails("12345","Thana",3.25);
ps.showDetails();
}
}

Java Programming 183

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

โปรแกรมที่ 6.11 ตัวอยางคลาสที่ไมไดใชหลักการของการหอหุม

public class Student {
String ID;
String name;
public double gpa;
}
--------------------------------------------------------------------------------------------------------------------------------------------------------
public class NoEncapDemo {
public static void main(String args[]) {
Student s1 = new Student();
double temp = Double.parseDouble(args[0]);
if ((temp<0) || (temp>4.00)) {
System.out.println("Incorrect Format!");
} else {
s1.gpa = temp;
System.out.println("GPA: "+s1.gpa);
}
}
}

รูปที่ 6.1 ตัวอยางผลลัพธที่ไดจากการรันโปรแกรมที่ 6.11

184 คณะเทคโนโลยีสารสนเทศ สถาบันเทคโนโลยีพระจอมเกลาเจาคุณทหารลาดกระบัง

 โปรแกรมที่ 6.11 แสดงตัวอยางคลาสที่ไมไดใชหลักการของการหอหุม โดยการ
กําหนดใหคุณลักษณะ gpa ซึ่งมี modifier เปน public ทําใหออปเจ็คอื่นๆสามารถเรียกใช
gpa ไดโดยตรง คลาส NoEncapDemo ไดสรางออปเจ็คของคลาส Student ที่ชื่อวา s1
และไดกําหนดใหผูใชสามารถปอนคา gpa ผานเขามาทาง command line ซึ่งผูใชอาจปอนคา
gpa ที่ไมถูกตองเชน เปนคาตัวเลขจํานวนลบ หรือมีคามากกวา 4.00 ดังนั้นจึงจะตองมีการ
ตรวจสอบคาที่ปอนเขามากอนที่จะมีการกําหนดคาใหกับคุณลักษณะ gpa ทุกครั้งโดยใชคําสั่ง
if..else การเขียนโปรแกรมแบบนี้ทําใหโปรแกรมซับซอนขึ้นและยากตอการแกไข ซึ่ง
ตัวอยางของผลลัพธที่ไดจากการรันโปรแกรมที่ 6.11 เปนดังรูปที่ 6.1
โปรแกรมที่ 6.12 ไดเปลี่ยนคุณลักษณะของ gpa ใหมี modifier เปน private
และกําหนดเมธอดใหมที่ชื่อ setGPA() ที่มี modifier เปน public เพื่อใหออปเจ็คอื่นๆที่
ตองการกําหนดคา gpa เรียกใชได ซึ่งการเขียนโปรแกรมแบบนี้เปนการใชหลักการของการ
หอหุม ดังนั้นการกําหนดคาใหกับคุณลักษณะ gpa ของออปเจ็ค s1 ในคลาส EncapDemo
จะทําไดโดยการเรียกใชเมธอด setGPA() เทานั้น ซึ่งในเมธอดดังกลาวจะมีการตรวจสอบคา
ของ gpa อยูภายใน ทําใหการเขียนโปรแกรมทําไดงายขึ้นเพราะไมจําเปนตองตรวจสอบคา
ทุกครั้ง และงายตอการแกไขโปรแกรมในกรณีที่ขอกําหนดของคุณลักษณะ gpa เปลี่ยนแปลง
ไป เนื่องจากเปนคําสั่งเฉพาะในเมธอดเทานั้น

6.2.1 เมธอดแบบ Accessor

การเขาถึงคุณลักษณะของออปเจ็คที่มี modifier เปน private นั้นจะตองใชเมธอด
แบบ accessor ในการกําหนดคาของคุณลักษณะ หรือดึงคาของคุณลักษณะออกมาใชงาน
เมธอดแบบ accessor แบงออกไดเปนสองประเภทคือ
1. เมธอดแบบ setter จะใชในการกําหนดคาของคุณลักษณะ ซึ่งเมธอดแบบนี้จะไมมี
การสงคากลับ ดังนั้นจึงระบุชนิดขอมูลของคาที่ตองการสงกลับเปน void
โดยทั่วไปชื่อของเมธอดแบบนี้จะขึ้นตนดวยคําวา set แลวตามดวยชื่อของ
คุณลักษณะ ซึ่งมีรูปแบบดังนี้

public void setAttributeName(dataType arg) {

attributeName = arg;
}

โดยที่
• dataType คือชนิดขอมูลของคุณลักษณะที่ตองการกําหนดคา

Java Programming 185

 • arg คือตัวแปรที่จะรับคาของคุณลักษณะที่ตองการกําหนด
• attributeName คือชื่อของคุณลักษณะ
ตัวอยางเชนคลาส Student มีเมธอด setGPA() เพื่อกําหนดคาของ
คุณลักษณะ gpa ซึ่งมีคําสั่งดังนี้
public void setGPA(double GPA) {
gpa = GPA;
}

โปรแกรมที่ 6.12 ตัวอยางคลาสทีใชหลักการของการหอหุม

public class Student {
String ID;
String name;
private double gpa;
public void setGPA(double GPA) {
if ((GPA<0) || (GPA>4.00)) {
System.out.println("Incorrect Format!");
} else {
gpa = GPA;
}
}
public double getGPA() {
return gpa;
}
}
--------------------------------------------------------------------------------------------------------------------------------------------------------
public class EncapDemo {
public static void main(String args[]) {
Student s1 = new Student();
double temp = Double.parseDouble(args[0]);
s1.setGPA(temp);
System.out.println("GPA: "+s1.getGPA());
}
}

เมธอดแบบ getter จะใชในการเรียกคาของคุณลักษณะ ซึ่งเมธอดแบบนี้จะมีการสง

คากลับ ดังนั้นจึงตองระบุชนิดขอมูลของคาที่สงกลับมาดวยเสมอ โดยทั่วไปชื่อ
ของเมธอดแบบนี้จะขึ้นตนดวยคําวา get แลวตามดวยชื่อของคุณลักษณะ ซึ่งมี
รูปแบบดังนี้

186 คณะเทคโนโลยีสารสนเทศ สถาบันเทคโนโลยีพระจอมเกลาเจาคุณทหารลาดกระบัง

 public dataType getAttributeName() {
return attributeName;
}

ตัวอยางเชน คลาส Student มีเมธอด getGPA() เพื่อเรียกคา ของ gpa ที่มี

คําสั่งดังนี้
public double getGPA() {
return gpa;
}
ชื่อของเมธอดแบบ getter สําหรับคุณลักษณะที่มีชนิดขอมูลเปน boolean
โดยทั่วไปจะกําหนดใหขึ้นตนดวยคําวา is แทนที่จะเปนคําวา get อาทิเชน
เมธอด isGraduate() เปนเมธอดเพื่อเรียกคาของคุณลักษณะ graduate
ของคลาส Student ที่มีชนิดขอมูลเปน boolean

โปรแกรมที่ 6.13 ตัวอยางคลาสทีใชหลักการของการหอหุม

public class EncapStudent {
private String id;
private String name;
private double gpa;
public void setID(String ID) {
id = ID;
}
public void setName(String n) {
name = n;
}
public void setGPA(double GPA) {
if ((GPA<0) || (GPA>4.00)) {
System.out.println("Incorrect Format!");
} else {
gpa = GPA;
}
}
public String getID() {
return id;
}
public String getName() {
return name;
}
public double getGPA() {
return gpa;
}
}

Java Programming 187

 โปรแกรมที่ 6.13 แสดงตัวอยางของโปรแกรมภาษาจาวาที่ใชหลักการของการหอหุม
โดยกําหนดใหคุณลักษณะตางๆของออปเจ็คมี modifier เปนแบบ private และกําหนดใหมี
เมธอดแบบ accessor ทั้งที่เปนแบบ setter และ getter เพื่อทําใหสามารถเขาถึงคุณลักษณะ
แตละตัวได
คุณลักษณะของออปเจ็คบางกรณีอาจไมสามารถกําหนดเมธอดแบบ setter ได ทั้งนี้
เนื่องจากอาจไมตองการใหมีการกําหนดคาไดโดยตรง โปรแกรมที่ 6.14 แสดงตัวอยางคลาส
Account ซึ่งมีคุณลักษณะ balance เพื่อเก็บยอดเงินคงเหลือในบัญชี โปรแกรมนี้ได
กําหนดใหมีเมธอดแบบ getter ที่ชื่อ getBalance() เพื่อเรียกดูยอดเงินในบัญชี แตไมมี
เมธอดแบบ setter เพื่อกําหนดคา balance ทั้งนี้เนื่องจากคุณลักษณะ balance จะ
เปลี่ยนคาไปเมื่อมีการเรียกใชเมธอด deposit() และ withdraw() ที่ใชในการฝากและ
ถอนเงินตามลําดับ

โปรแกรมที่ 6.14 ตัวอยางคลาสทีใชหลักการของการหอหุม

public class Account {
private double balance;
public double getBalance() {
return balance;
}
public void deposit(double amount) {
balance += amount;
}
public void withdraw(double amount) {
balance -= amount;
}
}

6.2.2 คียเวิรด this

คียเวิรด this หมายถึงออปเจ็คของตัวเอง เราสามารถที่จะเรียกใชเมธอดหรือ
คุณลักษณะภายในคลาสไดโดยใชคียเวิรด this ซึ่งมีรูปแบบดังนี้

this.methodName();
this.attirbuteName;

โดยทั่วไปเราจะไมใชคียเวิรด this ในคําสั่ง ยกเวนในกรณีที่จําเปน

188 คณะเทคโนโลยีสารสนเทศ สถาบันเทคโนโลยีพระจอมเกลาเจาคุณทหารลาดกระบัง

 ตัวอยางโปรแกรมที่ 6.15 เปนการเรียกใชคุณลักษณะของออปเจ็ตโดยใชคียเวิรด
this กรณีนี้ถาไมระบุวา this.id, this.name และ this.gpa คอมไพเลอรจะ
เขาใจวาหมายถึงตัวแปรที่เปน argument ของเมธอด ไมใชตัวแปรที่เปนคุณลักษณะของ
ออปเจ็ค
โปรแกรมที่ 6.15 ตัวอยางแสดงการใชคียเวิรด this

public class ThisStudent {

private String id;
private String name;
private double gpa;
public void setDetails(String id,String name,
double gpa) {
this.id = id;
this.name = name;
this.gpa = gpa;
}
public void showDetails() {
System.out.println("ID: "+id);
System.out.println("Name: "+name);
System.out.println("GPA: "+gpa);
}
}

6.3 การเขียนโปรแกรมโดยใชหลักการของการสืบทอด
ขอดีของการสืบทอดคือ การนําคลาสที่มีอยูแลวมาใชใหมโดยการเพิ่มเติมคุณลักษณะ
หรือเมธอดในคลาสใหม เพื่อใหเขาใจหลักการของการสืบทอดใหพิจารณาตัวอยางของคลาส
Student ทีก ่ ําหนดไวในโปรแกรมที่ 6.16 ซึ่งถาหากจําเปนที่จะตองพัฒนาคลาสขึ้นใหมที่
ชื่อ GradStudent เพื่อใชในการสรางออปเจ็คที่เปนนักศึกษาระดับบัณฑิตศึกษานั้น เรา
สามารถที่จะเลือกวิธีการไดสองแบบคือ
1. สรางคลาสขึ้นมาใหมโดยไมอางอิงกับคลาสเดิมที่ชื่อ Student ดังโปรแกรมที่
6.17
2. สรางคลาสที่สืบทอดมาจากคลาสเดิมที่ชื่อ Student ดังโปรแกรมที่ 6.18
การสรางคลาสขึ้นใหมตามโปรแกรมที่ 6.17 นั้นจะเห็นไดวามีความซ้ําซอนในการ
กําหนดคุณลักษณะและเมธอดของคลาส นอกจากนี้ยังจะทําใหเกิดความยุงยากในการแกไข

Java Programming 189

 โปรแกรมอีกดวยอาทิเชน หากตองมีการเพิ่มคุณลักษณะ address จะทําใหตองแกไข
โปรแกรมของทั้งสองคลาส

โปรแกรมที่ 6.16 ตัวอยางคลาสทีชื่อ Student

public class Student {
private String id;
private String name;
private double gpa;
public void setID(String ID) {
id = ID;
}
public void setName(String n) {
name = n;
}
public void setGPA(double GPA) {
gpa = GPA;
}
public void showDetails() {
System.out.println(“ID: “+id);
System.out.println(“Name: “+name);
System.out.println(“GPA: “+gpa);
}
}

ภาษาจาวาไดกําหนดคียเวิรดที่ชื่อ extends เพื่อระบุการสืบทอดของคลาส โดยมี

รูปแบบดังนี้

public class SubClass extends SuperClass {

...
}

โดยที่ SuperClass คือชื่อของคลาสที่ตองการจะใหมีการสืบทอดคุณลักษณะและ

เมธอดตางๆไปยัง SubClass
โปรแกรมที่ 6.17 สามารถที่จะเขียนไดใหมโดยใชหลักการของการสืบทอดดังแสดงใน
โปรแกรมที่ 6.18 ซึ่งจะเห็นไดวากรณีนี้จะลดความซ้ําซอนของคุณลักษณะและเมธอด และจะ
ทําใหการปรับปรุงและแกไขโปรแกรมเปนไปไดงายยิ่งขึ้น ไดอะแกรมคลาสของคลาสทั้งสอง
สามารถแสดงดังรูปที่ 6.2 คลาส GradStudent จะสืบทอดคุณลักษณะและเมธอดของคลาส

190 คณะเทคโนโลยีสารสนเทศ สถาบันเทคโนโลยีพระจอมเกลาเจาคุณทหารลาดกระบัง

Student มา ดังนั้นออปเจ็คของคลาส GradStudent จะมีคุณลักษณะที่เปน id, name
และ gpa เชนเดียวกับออปเจ็คของคลาส Student

โปรแกรมที่ 6.17 ตัวอยางคลาสทีชื่อ GradStudent ที่ไมไดใชหลักการของการสืบทอด

public class GradStudent {
private String id;
private String name;
private double gpa;
private String thesisTitle;
private String supervisor;
public void setID(String ID) {
id = ID;
}
public void setName(String n) {
name = n;
}
public void setGPA(double GPA) {
gpa = GPA;
}
public void setThesisTitle(String t) {
thesisTitle = t;
}
public void setSupervisor(String s) {
supervisor = s;
}
public void showThesis() {
System.out.println("ThesisTitle: "+thesisTitle);
System.out.println("Supervisor: "+supervisor);
}
}

Java Programming 191

 โปรแกรมที่ 6.18 ตัวอยางคลาสทีชื่อ GradStudent ที่ใชหลักการของการสืบทอด
public class GradStudent extends Student {
private String thesisTitle;
private String supervisor;
public void setThesisTitle(String t) {
thesisTitle = t;
}
public void setSupervisor(String s) {
supervisor = s;
}
public void showThesis() {
System.out.println("ThesisTitle: "+thesisTitle);
System.out.println("Supervisor: "+supervisor);
}
}

รูปที่ 6.2 การใชหลักการของการสืบทอด

192 คณะเทคโนโลยีสารสนเทศ สถาบันเทคโนโลยีพระจอมเกลาเจาคุณทหารลาดกระบัง

6.3.1 การสืบทอดที่ถูกตอง
เราสามารถที่จะกําหนดใหคลาสใดๆสืบทอดคลาสอื่นได แตการออกแบบโปรแกรม
เชิงออปเจ็คที่ดีนั้น ควรจะใหคลาสที่จะสืบทอดกันนั้นมีความสัมพันธที่ถูกตองกันดวย
ตัวอยางเชน หากกําหนดใหคลาส Shirt และ Skirt มีคุณลักษณะของคลาสดังนี้
public class Shirt {
char size;
float price;
}
public class Skirt {
char size;
float price;
boolean long;
}
นักพัฒนาโปรแกรมอาจเห็นวาคลาสทั้งสองมีคุณลักษณะที่ซ้ําซอนกันหลายชื่อ จึง
อาจตัดสินใจกําหนดใหคลาส Skirt สืบทอดมาจากคลาส Shirt โดยมีโปรแกรมดังนี้
public class Shirt {
char size;
float price;
}
public class Skirt extends Shirt {
boolean long;
}
แตในความเปนจริงแลว Shirt และ Skirt จะไมมีความสัมพันธในลักษณะการ
สืบทอดโดยตรง เราสามารถที่จะทดสอบความสัมพันธของการสืบทอด โดยใชคําวา “เปน” (is
a) ได คลาสที่จะสืบทอดกันจะตองสามารถบรรยายดวยวลีที่วา subclass เปน superclass
(A subclass is a superclass) แตคําวากระโปรงเปนเสื้อ (A skirt is a shirt) เปนวลีที่ไม
ถูกตองจึงทําใหคลาสทั้งสองไมควรจะสืบทอดกันได อยางไรก็ตามเราสามารถที่จะเขียน
โปรแกรมของคลาสทั้งสองไดใหมดังนี้
public class Clothing {
char size;
float price;
}
public class Shirt extends Clothing {
}
public class Skirt extends Clothing {
boolean long;

Java Programming 193

 }
ทั้งนี้เนื่องจากทั้งเสื้อ (shirt) และกระโปรง (skirt) ตางก็เปนเสื้อผา (clothing)

6.3.2 คียเวิรด protected

ถึงแมวาคลาสที่เปน subclass จะสืบทอดคุณลักษณะและเมธอดของคลาสที่เปน
superclass มา แตคลาสที่เปน subclass จะไมสามารถที่จะเรียกใชคุณลักษณะหรือเมธอด
ของ superclass ที่มี modifier เปนแบบ private ได ภาษาจาวากําหนดใหมี access
modifier ที่ชื่อ protected ซึ่งจะทําใหคลาสที่เปน subclass สามารถที่จะเรียกใชเมธอด
หรือคุณลักษณะของ superclass ได modifier แบบ protected จะแตกตางจาก modifier
แบบ default ในกรณีที่ superclass และ subclass อยูตางแพคเก็จกัน ทั้งนี้กรณีของ default
จะไมสามารถเรียกใชคุณลักษณะหรือเมธอดของคลาสที่อยูตางแพคเก็จกันได แตถามี
modifier เปนแบบ protected จะสามารถเรียกใชไดในกรณีที่คลาสทั้งสองสืบทอดกัน
ตารางที่ 6.1 แสดงการเปรียบเทียบการกําหนด modifier แบบตางๆ เพื่อเรียกใชคุณลักษณะ
หรือเมธอด และ โปรแกรมที่ 6.19 เปนโปรแกรมที่แสดงตัวอยางการใชคียเวิรด protected

ตารางที่ 6.1 ระดับการเขาถึงคุณลักษณะหรือเมธอดของ modifier แบบตางๆ

คลาสที่อยูใน
คลาสที่เปน
Modifier คลาสเดียวกัน แพคเก็จ คลาสใดๆ
subclass
เดียวกัน
public √ √ √ √

protected √ √ √

default √ √

Private √

194 คณะเทคโนโลยีสารสนเทศ สถาบันเทคโนโลยีพระจอมเกลาเจาคุณทหารลาดกระบัง

โปรแกรมที่ 6.19 ตัวอยางการใชคียเวิรด protected
public class Student {
protected String id;
protected String name;
protected double gpa;
public void setDetails (String ID,String n,double GPA) {
id = ID;
name = n;
gpa = GPA;
}
public void showDetails() {
System.out.println("ID: "+id);
System.out.println("Name: "+name);
System.out.println("GPA: "+gpa);
}
}

6.3.3 คลาสที่ชื่อ Object

คลาสทุกคลาสในภาษาจาวาถาไมไดสืบทอดจากคลาสใดเลย จะถือวาคลาสนั้นสืบ
ทอดจากคลาสที่ชื่อ Object อาทิเชน คลาส Student จะสืบทอดมาจากคลาสที่ชื่อ
Object และคําสั่งประกาศคลาสจะถือเสมือนวามีรูปแบบดังนี้
public class Student extends Object {
...
}
คลาสที่ชื่อ Object จะมีเมธอดที่สําคัญคือ
• public String toString() และ
• public boolean equals(Object o)
เพื่อใชในการแปลงออปเจ็คของคลาสใหเปนออปเจ็คชนิด String และใชในการ
เปรียบเทียบออปเจ็คของคลาสนั้นกับออปเจ็คอื่นๆ

6.3.4 คียเวิรด super

super เปนคียเวิรดที่ใชในการอางอิงถึง superclass เพื่อที่จะเรียกใชเมธอดหรือ
constructor ของ superclass โดยมีรูปแบบคําสั่งดังนี้

super.methodName([arguments])

Java Programming 195

 ตัวอยางเชนคลาส GradStudent อาจกําหนดใหมีเมธอดที่ชื่อ
showDetails() โดยมีคําสั่งที่เรียกใชเมธอด showDetails() ของคลาส Student
ดังแสดงในโปรแกรมที่ 6.20

โปรแกรมที่ 6.20 ตัวอยางการใชคียเวิรด super

public class Student {
private String id;
private String name;
private double gpa;
public void showDetails() {
System.out.println("ID: "+id);
System.out.println("Name: "+name);
System.out.println("GPA: "+gpa);
}
}
--------------------------------------------------------------------------------------------------------------------------------------------------------------------
public class GradStudent extends Student {
private String thesisTitle;
private String supervisor;
public void showDetails() {
super.showDetails();
System.out.println("Thesis Title: "+ thesisTitle);
System.out.println("Supervisor: "+supervisor);
}
}

6.4 การมีไดหลายรูปแบบ
การมีไดหลายรูปแบบหมายถึงคุณสมบัติของออปเจ็คของคลาสที่ตางกัน ที่สามารถจะ
กําหนดคาไดหลายรูปแบบ หรือการตอบสนองตอเมธอดเดียวกันดวยวิธีการที่ตางกันได
หลักการของการมีไดหลายรูปแบบเปนหลักการที่สืบเนื่องมาจากหลักการของการสืบทอด

6.4.1 Dynamic Binding

Dynamic Binding เปนหลักการของการกําหนดออปเจ็คของคลาสที่มีการสืบทอดกัน
ไดหลายรูปแบบ ภาษาจาวากําหนดใหออปเจ็คของคลาสใดๆสามารถสรางมาจากคลาสนั้นหรือ
คลาสอื่นๆที่เปน subclass ได กลาวคือถาประกาศคลาส SubClass ซึ่งสืบทอดมาจาก

196 คณะเทคโนโลยีสารสนเทศ สถาบันเทคโนโลยีพระจอมเกลาเจาคุณทหารลาดกระบัง

คลาส SuperClass แลว และมีคําสั่งประกาศออปเจ็ค obj ใหเปนออปเจ็คของคลาส
SuperClass โดยใชคําสั่ง
SuperClass obj;
เราสามารถใชหลักการของการมีไดหลายรูปแบบในการสรางออปเจ็ค obj ได หลาย
รูปแบบดังนี้
obj = new SuperClass();
หรือ obj = new SubClass();
ในกรณีของตัวอยางของคลาส Student ที่มี subclass เปนคลาส GradStudent
โดยที่คลาส GradStudent มี subclass อีกคลาสหนึ่งที่ชื่อ PhDStudent นั้น เรา
สามารถที่จะกําหนดออปเจ็คของคลาสเหลานี้ไดหลายรูปแบบ ดังแสดงความสัมพันธในรูปที่
6.3 กลาวคือ เราสามารถที่ประกาศออปเจ็คของคลาส Student แลวสรางออปเจ็คไดหลาย
รูปแบบดังนี้
Student s1 = new Student();
หรือ Student s1 = new GradStudent();
หรือ Student s1 = new PhDStudent();
เชนเดียวกับกรณีของออปเจ็คของคลาส GradStudent สามารถที่จะสราง
ออปเจ็คไดหลายรูปแบบดังนี้
GradStudent s2 = new GradStudent();
GradStudent s2 = new PhDStudent();
แตในทางกลับกันเราจะไมสามารถกําหนดออปเจ็คของ subclass แลวสรางออปเจ็ค
ของ superclass ได กลาวคือ คําสั่ง
GradStudent s3 = new Student();
จะเปนคําสั่งที่ไมถูกตอง

รูปที่ 6.3 ออปเจ็คของคลาสที่มีไดหลายรูปแบบ

Java Programming 197

 6.4.2 การกําหนดเมธอดใหมีวิธีการที่ตางกัน
หลักการของการมีไดหลายรูปแบบยังรวมไปถึงการที่เมธอดชื่อเดียวกันแตมีวิธีการ
(คําสั่ง) ที่ตางกัน ซึ่งสามารถกําหนดเมธอดไดสองรูปแบบคือ
1. เมธอดแบบ overloaded
2. เมธอดแบบ overridden

เมธอดแบบ Overloaded
ภาษาจาวาอนุญาตใหคลาสใดๆ มีเมธอดที่ชื่อเดียวกันมากกวาหนึ่งเมธอดได แต
เมธอดเหลานั้นจะตองมีจํานวนหรือชนิดขอมูลของ argument ที่ตางกัน โปรแกรมที่ 6.21 เปน
ตัวอยางของการเขียนเมธอดแบบ overloaded โดยเมธอด setDetails() จะมีสองเมธอด
เมธอดแรกจะรับ argument ที่มีสองตัว และเมธอดที่สองจะรับ argument ที่มีสามตัว ซึ่ง
คอมไพเลอรจะพิจารณาวาโปรแกรมเรียกใชเมธอดใดโดยดูจากจํานวนและชนิดของ argument
ทั้งนี้เมธอดแบบ overloaded อาจมีคาที่สงกลับมาเปนชนิดเดียวกันหรือตางกันก็ได

โปรแกรมที่ 6.21 ตัวอยางของเมธอดแบบ overloaded

public class StudentV2 {
private String id;
private String name;
private double gpa;
public void setDetails(String ID,String n) {
id = ID;
name = n;
}
public void setDetails(String ID,String n,double GPA) {
id = ID;
name = n;
gpa = GPA;
}
}

ตัวอยางตอไปนี้เปนการเขียนเมธอดแบบ overloaded ที่ถูกตอง

public void setDetails(String ID,String n) {
}
public void setDetails(String ID,double GPA) {
}
public double setDetails(double GPA,String ID){

198 คณะเทคโนโลยีสารสนเทศ สถาบันเทคโนโลยีพระจอมเกลาเจาคุณทหารลาดกระบัง

 }
ตัวอยางตอไปนี้เปนการเขียนเมธอดแบบ overloaded ที่ไมถูกตอง
public void setDetails(String ID,double GPA) {
}
public void setDetails(String n,double GPA) {
}
กรณีตัวอยางที่ไมถูกตองนี้ถึงแมวาจะมีชื่อของ argument ที่ตางกันก็ตามแต
เนื่องจากเมธอดทั้งสองมีจํานวนและชนิดขอมูลของ argument ที่เหมือนกัน ดังนั้นเมื่อ
คอมไพเลอรเจอคําสั่งเรียกใชเมธอด setDetails() แลวสง argument ที่มีชนิดขอมูลเปน
String และ double มา คอมไพเลอรจะไมสามารถแยกไดวาจะเรียกใชเมธอดใด ดังนั้นถา
ชุดคําสั่งในตัวอยางนี้อยูในโปรแกรมใดจะทําใหโปรแกรมนั้นไมสามารถคอมไพลผานได

เมธอดแบบ Overridden
การกําหนดเมธอดแบบ overridden เปนหลักการที่สืบเนื่องมาจากหลักการของการ
สืบทอด โดยคลาสที่เปน subclass สามารถที่จะเขียนเมธอดของ superclass ขึ้นใหมได
วิธีการนี้เรียกวา เมธอดใน subclass เปนเมธอดแบบ overridden การเขียนเมธอดแบบ
overridden มีขอกําหนดดังนี้
• จํานวนและชนิดขอมูลของ argument จะตองเหมือนเดิม
• ชนิดขอมูลของคาที่สงกลับจะตองเหมือนเดิม
• access modifier จะตองไมมีระดับต่ํากวาเดิมอาทิเชน ถาเมธอดเดิมเปน
public จะไมสามารถเปลี่ยนเปน private ได

โปรแกรมที่ 6.22 แสดงตัวอยางการกําหนดเมธอดแบบ overridden ที่ชื่อ

showDetails() โดยการเขียนเมธอด showDetails() ของคลาส Student ขึ้น
ใหม

Java Programming 199

 โปรแกรมที่ 6.22 เมธอดแบบ overridden ที่ชื่อ showDetails()
public class Student {
protected String id;
protected String name;
protected double gpa;

public void showDetails() {

System.out.println("ID: "+id);
System.out.println("Name: "+name);
System.out.println("GPA: "+gpa);
}
}
----------------------------------------------------------
public class GradStudent extends Student {
private String thesisTitle;
private String supervisor;

public void showDetails() {

System.out.println("ID: "+id);
System.out.println("Name: "+name);
System.out.println("GPA: "+gpa);
System.out.println("ThesisTitle: "+thesisTitle);
System.out.println("Supervisor: "+supervisor);
}
}

Virtual Method Invocation

การกําหนดออปเจ็คตามหลักการของ Dynamic Binding ทําใหโปรแกรมภาษา
จาวาพิจารณาเรียกใชเมธอดจากชนิดของออปเจ็คที่สรางขึ้น ตัวอยางเชน คําสั่ง
Student s1 = new GradStudent();
s1.showDetails();
เปนคําสั่งที่เรียกใชเมธอด showDetails() ของคลาส GradStudent ไมใช
เมธอดของคลาส Student ทั้งนี้เนื่องจากออปเจ็ค s1 เปนออปเจ็คของคลาส
GradStudent แตคอมไพเลอรของภาษาจาวาจะไมอนุญาตใหเรียกใชเมธอดใดๆก็ตามที่
ไมมีการประกาศอยูในเมธอดของ superclass ที่กําหนดไว กลาวคือคําสั่ง
Student s1 = new GradStudent();
s1.getSupervisor();

200 คณะเทคโนโลยีสารสนเทศ สถาบันเทคโนโลยีพระจอมเกลาเจาคุณทหารลาดกระบัง

 เปนคําสั่งที่ไมถูกตองและจะไมสามารถคอมไพลผานได เนื่องจากคอมไพเลอรจะไม
รูจักเมธอด getSupervisor() ที่อยูในคลาส Student ถึงแมวาออปเจ็ค s1
จะเปนออปเจ็คของคลาส GradStudent ที่มีเมธอดดังกลาวอยูก็ตาม

6.4.3 คอลเล็กชั่นแบบ Heterogeneous

คอลเล็กชั่นแบบ Heterogeneous คือการเก็บขอมูลที่มีชนิดขอมูลตางกันในกลุม
เดียวกัน ซึ่งจะแตกตางจากคอลเล็กชั่นแบบ Homogeneous ซึ่งเปนการเก็บขอมูลชนิด
เดียวกันในตัวแปรชื่อเดียวกันอาทิเชน การเก็บขอมูลในอะเรยของชนิดขอมูลแบบพื้นฐานเชน
int x[] = new int[4];
จะไดตัวแปร x เปนการเก็บขอมูลแบบ Homogeneous คลาสประเภท
คอลเล็กชั่นที่กําหนดใน Collection API (ซึ่งจะกลาวถึงตอไปในบทที่ 8) จัดเปนคอลเล็กชั่น
แบบ Heterogeneous ทั้งนี้เนื่องจากเราสามารถที่จะเก็บออปเจ็คของคลาสใดๆในคอลเล็กชั่น
ได ตามหลักการของการมีไดหลายรูปแบบ เนื่องจากคลาสประเภทคอลเล็กชั่นดังกลาวจะใชใน
การเก็บออปเจ็คของคลาส Object ซึ่งคลาสดังกลาวจะเปนคลาสที่เปนคลาสราก (root
class) ของทุกๆ คลาสที่จะตองสืบทอดกันมา
เราสามารถจะกําหนดอะเรยของขอมูลชนิดคลาส ใหสามารถเก็บขอมูลแบบ
Heterogeneous ได โดยการสรางสมาชิกของอะเรยแตละตัวจากออปเจ็คของคลาสที่เปน
subclass ของคลาสที่กําหนด เชนคําสั่ง
Student s[] = new Student[5];
เปนการกําหนดใหตัวแปรอะเรย s เปนอะเรยของขอมูลชนิด Student ซึ่งสามารถ
ที่จะใชหลักการของการมีไดหลายรูปแบบ ในการกําหนดสมาชิกของอะเรยแตละตัวใหเปน
ออปเจ็คของคลาสตางๆ ที่สืบทอดมาจากคลาส Student ไดเชน
s[0] = new Student();
s[1] = new GradStudent();
s[2] = new PhDStudent();
s[3] = new FullTimeStudent();
s[4] = new PartTimeStudent();

Java Programming 201

 6.4.4 การสงผาน argument ไดหลายรูป
ในกรณีที่เมธอดมี argument เปนขอมูลชนิดคลาส เราสามารถที่จะใชหลักการของ
การมีไดหลายรูปแบบในการสง argument ที่เปนออปเจ็คใหกบั เมธอดดังกลาวได กลาวคือเรา
สามารถที่จะสงออปเจ็คของคลาสที่เปน subclass ของคลาสนั้นแทนได ตัวอยางเชน คําสั่ง
Student s1 = new Student();
Student s2 = new GradStudent();
และเมธอด
public void printInfo(Student s) {
...
}
เปนเมธอดที่มี argument เปนขอมูลชนิดคลาส Student เราสามารถที่จะเรียกใช
เมธอดนี้โดยการสงออปเจ็คที่สืบทอดมาจากคลาส Student ได อาทิเชน
printInfo(s1)
printInfo(s2)
หรือ printInfo(new FullTimeStudent())

6.4.5 ตัวดําเนินการ instanceof

คียเวิรด instanceof เปนตัวดําเนินการที่ใชกับออปเจ็คและคลาส เพื่อตรวจสอบ
วาออปเจ็คใดๆเปนออปเจ็คของคลาสที่ระบุหรือไม คียเวิรด instanceof จะใหผลลัพธเปน
ชนิดขอมูลแบบ boolean ซึ่งถาไดผลลัพธเปน true จะหมายถึงวาออปเจ็คดังกลาวเปน
ออปเจ็คของคลาสที่ระบุหรือเปนออปเจ็คของคลาสที่เปน superclass ของคลาสนั้น
ตัวอยางเชน
GradStudent s1 = new GradStudent();
เปนคําสั่งในการประกาศและสรางออปเจ็ค s1 ของคลาส GradStudent ดังนั้น
นิพจน
(s1 instanceof GradStudent)
จะใหผลลัพธเปน true เชนเดียวกับนิพจน
(s1 instanceof Student)
หรือ (s1 instanceof Object)
ที่จะใหผลลัพธเปน true ทั้งนี้เนื่องจากคลาส GradStudent สืบทอดมาจาก
คลาส Student และคลาส Student ก็สืบทอดมาจากคลาสที่ชื่อ Object อีกตอหนึ่ง

202 คณะเทคโนโลยีสารสนเทศ สถาบันเทคโนโลยีพระจอมเกลาเจาคุณทหารลาดกระบัง

 สวนนิพจน
(s1 instanceof String)
จะใหผลลัพธเปน false ทั้งนี้เนื่องจากออปเจ็คของคลาส GradStudent จะ
ไมใชออปเจ็คของคลาสที่สืบทอดมาจากคลาส String
นอกจากนี้ คียเวิรด instanceof จะใหผลลัพธเปน false ในกรณีที่จะตรวจสอบ
วาออปเจ็คดังกลาวเปนออปเจ็คของคลาสที่เปน subclass หรือไม ตัวอยางเชนคําสั่ง
Student s1 = new Student();
จะไดนิพจน
(s1 instanceof GradStudent)
ที่ใหผลลัพธเปน false
คียเวิรด instanceof สามารถใชในการตรวจสอบวา argument ที่รับขอมูลมาใน
เมธอดเปนออปเจ็คของคลาสใด ตัวอยางเชน คําสั่งตอไปนี้เปนการใชคียเวิรด instanceof
เพื่อตรวจสอบวา argument ของออปเจ็ค s วาเปนออปเจ็คของคลาสใด
public void printInfo(Student s) {
if (s instanceof PhDStudent) {
System.out.println("PhD Student");
} else if (s instanceof GradStudent) {
System.out.println("Graduate Student");
} else if (s instanceof FullTimeStudent) {
System.out.println("Full-Time Student");
} else if (s instanceof PartTimeStudent) {
System.out.println("Part-Time Student");
} else if (s instanceof Student) {
System.out.println("Student");
}
}

6.4.6 การ Casting ออปเจ็ค

หลักการของการมีไดหลายรูปแบบ ทําใหเราสามารถจะกําหนดออปเจ็คของคลาสที่
เปน subclass ใหกับตัวแปรที่กําหนดเปนคลาสที่เปน superclass ได ตัวอยางเชน
GradStudent s1 = new GradStudent();
Student s2 = s1;
แตในทางกลับกันตัวแปรที่กําหนดเปนคลาสที่เปน subclass จะไมสามารถกําหนดคา
ใหเปนออปเจ็คของคลาสที่เปน superclass ได ตัวอยางเชน

Java Programming 203

 Student s1 = new GradStudent();
GradStudent s2 = s1;
จะเปนคําสั่งที่ไมถูกตอง และโปรแกรมนี้จะไมสามารถคอมไพลผานได การกําหนดคา
ในลักษณะนี้จะตองทําการ casting ออปเจ็คเพื่อระบุชนิดของออปเจ็ค โดยมีรูปแบบดังนี้

(ClassName) objectName

โดยที่
• ClassName คือชนิดของคลาสที่ตองการระบุ
• objectName คือชื่อของตัวแปรของออปเจ็ค
ตัวอยางที่ผานมาสามารถเขียนใหมไดเปน
Student s1 = new GradStudent();
GradStudent s2 = (GradStudent) s1;
จึงจะทําใหโปรแกรมสามารถคอมไพลผานได เชนเดียวกับคําสั่งในหัวขอ 6.4.2 ที่เปน
ตัวอยางของการเรียกใชเมธอด ก็จะสามารถเขียนใหมไดเปน
Student s1 = new GradStudent();
((GradStudent) s1).getSupervisor();
จึงจะทําใหโปรแกรมสามารถคอมไพลผานได จากตัวอยางขางตนออปเจ็ค s1 จะถูก
กําหนดใหเปนคลาสชนิด GradStudent ที่มีเมธอด getSupervisor()
ภาษาจาวาจะตรวจสอบชนิดของออปเจ็คในชวงของการรันโปรแกรม ดังนั้นถึงแมวา
โปรแกรมจะคอมไพลผานได แตถาเกิดตรวจสอบพบวาออปเจ็คที่ทําการ casting ไมใช
ออปเจ็คของคลาสนั้นหรือออปเจ็คของ subclass โปรแกรมจะไมสามารถรันผานได
ตัวอยางเชน0
Student s1 = new Student();
GradStudent s2 = (GradStudent) s1;
จะเปนคําสั่งที่ทําใหเกิดขอผิดพลาดในชวงของการรันโปรแกรม เนื่องจากตัวแปร s1
ถูกกําหนดคาใหเปนออปเจ็คของ superclass ซึ่งไมสามารถทําได เชนเดียวกับการเรียกใช
เมธอดของออปเจ็คที่ทําการ casting ภาษาจาวาจะตรวจสอบชนิดของออปเจ็คในชวงของการ
รันโปรแกรม วาออปเจ็คดังกลาวเปนออปเจ็คของคลาสใด และคลาสนั้นมีเมธอดที่เรียกใช
หรือไม หากไมพบก็จะเกิดขอผิดพลาดในชวงของการรันโปรแกรม ตัวอยางเชน
Student s1 = new Student();
((GradStudent) s1).getSupervisor();

204 คณะเทคโนโลยีสารสนเทศ สถาบันเทคโนโลยีพระจอมเกลาเจาคุณทหารลาดกระบัง

 จะเปนคําสั่งที่สามารถคอมไพลผานได แตจะเกิดขอผิดพลาดในชวงของการรัน
โปรแกรม เนื่องจากจาวาอินเตอรพรีตเตอรจะพบวา s1 เปนออปเจ็คของคลาส Student ซึ่ง
ไมมีเมธอด getSupervisor() โปรแกรมที่ 6.23 แสดงตัวอยางการเรียกใชออปเจ็คใน
รูปแบบตางๆ ที่อาจเกิดขอผิดพลาดในชวงของการรันโปรแกรมหรือในชวงของการคอมไพล
โปรแกรม

โปรแกรมที่ 6.23 ตัวอยางการเรียกใชออปเจ็คในรูปแบบตางๆ ที่อาจเกิดขอผิดพลาด

public class Student {
protected String id;
protected String name;
protected double gpa;
public String getID() {
return id;
}
public String getName() {
return name;
}
public double getGPA() {
return gpa;
}
}

public class GradStudent extends Student {

private String thesisTitle;
private String supervisor;
public String getThesisTitle() {
return thesisTitle;
}
public String getSupervisor() {
return supervisor;
}
}
public class TestCallingMethods {

public static void main(String args[]) {

Student s1 = new GradStudent();
s1.getSupervisor();
// compile error

Student s2 = new Student();

((GradStudent) s2).getSupervisor();
// runtime error
}
}

Java Programming 205

 6.5 Constructor
constructor เปนเมธอดที่มีชื่อเดียวกับชื่อคลาสซึ่งจะถูกเรียกใชงานเมื่อมีการสราง
ออปเจ็คโดยใชคําสั่ง new โดย constructor มีรูปแบบดังนี้

[modifier] ClassName([arguments]) {
[statements]
}

constructor เปนเมธอดที่ไมมีคาที่จะสงกลับแตไมตองระบุคียเวิรด void ซึ่ง

แตกตางกับเมธอดทั่วๆไป modifier ของ constructor จะเปน access modifier ซึ่งโดยทั่วไป
จะเปน public กรณีที่ constructor มี access modifier เปน private จะทําใหไมสามารถ
สรางออปเจ็คของคลาสนั้นจากคลาสอื่นได
โดยทั่วไปคลาสทุกคลาสจะมี constructor แบบ default แมจะไมมีการเขียนคําสั่ง
constructor ในโปรแกรม โดย constructor แบบ default จะมีรูปแบบดังนี้

public ClassName() {
}

constructor แบบ default จะเปน constructor ที่ไมมีคําสั่งใดๆอยูภายใน

คอมไพเลอรของภาษาจาวาจะใส constructor แบบ default ใหกับโปรแกรมโดยอัตโนมัติ อาทิ
เชน คลาส Student ในโปรแกรมที่ 6.16 จะมี constructor แบบ default ที่คอมไพเลอรใส
ใหกับโปรแกรม ดังนี้
public class Student {
...
public Student() {
}
...
}

6.5.1 การเขียน Constructor

เราสามารถที่จะเขียน constructor ในคลาสใดๆขึ้นมาก็ไดอาทิเชน คลาส Student
อาจกําหนดใหมี constructor เปน
public class Student {
private String id;

206 คณะเทคโนโลยีสารสนเทศ สถาบันเทคโนโลยีพระจอมเกลาเจาคุณทหารลาดกระบัง

 private String name;
private double gpa;
public Student(String ID,String n,double GPA) {
id = ID;
name = n;
gpa = GPA;
}
...
}
การกําหนด constructor ขึ้นมาใหมนั้นจะทําให constructor แบบ default หายไป
ดังนั้นการสรางออปเจ็คของคลาสที่มี constructor ใหมนี้จะตองใชคําสั่ง new ที่สงผานจํานวน
และชนิดขอมูลของ argument ที่สอดคลองกับที่กําหนดไวใน constructor ตัวใหม จากตัวอยาง
ขางตน การสรางออปเจ็คของคลาส Student อาจจะใชคําสั่ง
Student s1 = new Student(“1122”,“Thana”,3.00);
แตจะไมสามารถใชคําสั่ง
Student s1 = new Student();
ไดอีก เนื่องจาก constructor แบบ default ของคลาส Student ไมมีแลว

6.5.2 ขั้นตอนการทํางานของคําสั่ง new

คําสั่ง new ที่ใชในการสรางออปเจ็คของคลาสจะมีลําดับขั้นตอนการทํางานดังนี้
1. กําหนดเนื้อที่ในหนวยความจําใหกับออปเจ็ค
2. กําหนดคาเริ่มตนใหกับคุณลักษณะของออปเจ็ค
3. กําหนดคาของคุณลักษณะของออปเจ็คตามคําสั่งกําหนดคาที่ประกาศไว
4. เรียกใช constructor
ตัวอยางเชน ถาคลาส MyDate มีโปรแกรมดังนี้
public class MyDate {
private int day = 1;
private int month = 1;
private int year = 2000;
public MyDate(int d,int m,int y) {
day = d;
month = m;
year = y;
}
}

Java Programming 207

 คําสั่ง
MyDate d1 = new MyDate(16,8,1972);
จะมีขั้นตอนในการทํางานดังรูปที่ 6.4 โดยขัน้ ตอนที่หนึ่งจะเปนการกําหนดเนื้อที่ใน
หนวยความจํา (รูปที่ 6.4(ก)) ขั้นตอนที่สองเปนการกําหนดคาเริ่มตนโดยคุณลักษณะของ
ออปเจ็คจะมีคา default เปน 0 (รูปที่ 6.4(ข)) ขั้นตอนที่สามเปนการกําหนดคาของคุณลักษณะ
ตามคําสั่งที่กําหนดคาไวเริ่มตน โดยที่คุณลักษณะ day จะมีคาเปน 1 คุณลักษณะ month
จะมีคาเปน 1 และคุณลักษณะ year จะมีคาเปน 2000 (รูปที่ 6.4(ค)) และขั้นตอนสุดทายจะ
เปนการเรียกใช constructor ทําใหคาของคุณลักษณะเปนไปตามที่กําหนดในคําสั่งของ
constructor (รูปที่ 6.4(ง))

(ก) ขั้นตอนที่หนึ่ง (ข) ขั้นตอนที่สอง

ค) ขั้นตอนที่สาม (ง) ขั้นตอนที่สี่

รูปที่ 6.4 ขั้นตอนการทํางานของคําสั่ง new

6.5.3 Constructor แบบ Overloaded

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

208 คณะเทคโนโลยีสารสนเทศ สถาบันเทคโนโลยีพระจอมเกลาเจาคุณทหารลาดกระบัง

การสราง constructor แบบ overloaded คือทําใหเราสามารถที่จะสรางออปเจ็คเริ่มตนไดหลาย
รูปแบบ
โปรแกรมที่ 6.24 แสดงตัวอยางของคลาส Student ที่มี constructor แบบ
overloaded ซึ่งคําสั่งการสรางออปเจ็ค
Student s1 = new Student(“1234”,“Somchai”,3.75);
จะมีผลทําใหคอมไพเลอรเรียก constructor ของคลาส Student ชุดที่สองซึ่งมี
argument สามตัว

โปรแกรมที่ 6.24 ตัวอยางการเขียน constructor แบบ overloaded

public class Student {
private String id;
private String name;
private double gpa;
public Student(String ID,String n) {
id = ID;
name = n;
}
public Student(String ID,String n,double GPA) {
id = ID;
name = n;
gpa = GPA;
}
}

6.5.4 เมธอด this()

เมธอดที่ชื่อ this() เปนการเรียกใช constructor ของคลาสตัวเอง โดยจะตองเปน
คําสั่งแรกสุดที่อยูใน constructor แบบ overloaded ตัวอยางเชน โปรแกรมที่ 6.24 สามารถ
เขียน constructor ของคลาส Student ชุดที่สองใหมไดโดยใชเมธอดที่ชื่อ this() ดัง
แสดงในโปรแกรมที่ 6.25

Java Programming 209

 โปรแกรมที่ 6.25 ตัวอยางการใชเมธอดที่ชื่อ this()
public class Student {
private String id;
private String name;
private double gpa;
public Student(String ID,String n) {
id = ID;
name = n;
}
public Student(String ID,String n,double GPA) {
this(ID,n);
gpa = GPA;
}
}

6.5.5 เมธอด super()

โดยทั่วไปเมธอดและคุณลักษณะของ superclass จะสืบทอดมายัง subclass แตจะมี
ขอยกเวนสําหรับ constructor ซึ่งจะไมสืบทอดมายัง subclass กลาวคือ ถา superclass มี
constructor รูปแบบใด จะไมไดทําให subclass มี constructor รูปแบบนั้นดวย ตัวอยางเชน
public class Parent {
...
}
public class Child extends Parent {
public Child (String s) {
...
}
}
ในกรณีนี้คลาส Parent มี constructor แบบ default สวนคลาส Child ที่สืบ
ทอดมาจากคลาส Parent มี constructor ที่มี argument เปน String เพียงรูปแบบเดียว
เนื่องจาก constructor แบบ default จะไมไดสืบทอดมายังคลาส Child ดังนั้นการสราง
ออปเจ็คโดยใช constructor แบบ default อาทิเชน
Child c1 = new Child();

210 คณะเทคโนโลยีสารสนเทศ สถาบันเทคโนโลยีพระจอมเกลาเจาคุณทหารลาดกระบัง

 จึงเปนคําสั่งที่ไมถูกตอง เนื่องจาก constructor แบบ default ของคลาส Child ได
ถูกแทนที่ดวย constructor แบบใหมไปแลว
เราสามารถที่จะเรียกใช constructor ของ superclass ไดโดยใชเมธอดที่ชื่อ
super() โดยสงผาน argument ที่สอดคลองกัน ทั้งนี้เมธอด super() จะตองเปนคําสั่ง
แรกของ constructor เชนเดียวกับเมธอดที่ชื่อ this() โดยทั่วไปการทํางานของ
constructor ของคลาสใดๆจะมีผลทําใหมีการเรียกใช constructor ของ superclass นั้น ซึ่งถา
ไมมีคําสั่ง super() อยูในคําสั่งแรกของ constructor ของคลาสนั้น ภาษาจาวาจะเรียกใช
constructor แบบ default ของ superclass นั้นโดยอัตโนมัติ
ในกรณีที่ superclass ไมมี constructor แบบ default และไมมคี ําสั่ง super() อยู
ใน constructor ของ subclass จะทําใหโปรแกรมไมสามารถคอมไพลผานไดดังตัวอยางใน
โปรแกรมที่ 6.26 ซึ่งในกรณีนี้จะตองใชคําสั่ง super() ใน constructor ของคลาส
GradStudentV1 เพื่อที่จะทําใหโปรแกรมสามารถคอมไพลผานได โดยจะตองกําหนด
contructor ของคลาส GradStudentV1 ใหมดังนี้
public GradStudentV1(String n){
super(n);
}

โปรแกรมที่ 6.26 ตัวอยางการเรียกใช constructor ของ superclass

public class StudentV1 {
protected String name;
public StudentV1(String n) {
name = n;
}
}
public class GradStudentV1 extends StudentV1 {
public GradStudentV1(String n) {
name = n; /* compile error
should be super(n) */
}
}

ขั้นตอนการทํางานของ Constructor
ออปเจ็คของคลาสใดๆจะถูกสรางขึ้นเมื่อมีการเรียกใชคําสั่ง new ตามขั้นตอนการ
ทํางานที่ไดกลาวผานมาแลว โดยขั้นตอนสุดทายเปนการเรียกใช constructor ซึ่งจะมีขั้นตอน
การทํางานที่ตองพิจารณาเพิ่มเติมดังนี้

Java Programming 211

 1. ถามีคําสั่ง this() ใน constructor ก็จะเรียกใช constructor แบบ overloaded
ที่สอดคลองกับคําสั่ง this() แลวขามไปขัน้ ตอนที่ 4
2. เรียกใช constructor ของ superclass ถาไมมีคําสั่ง super() จะเรียกใช
constructor แบบ default ยกเวนคลาสที่ชื่อ Object จะไมมีการเรียกใช
constructor ของ superclass เนื่องจากคลาสที่ชื่อ Object จะไมมี
superclass
3. เรียกใชคําสั่งกําหนดคาเริ่มตนของคุณลักษณะของออปเจ็ค
4. เรียกใชคําสั่งภายใน constructor ของคลาสที่ใชนั้น
โปรแกรมที่ 6.27 แสดงตัวอยางคลาสที่มี constructor ในรูปแบบตางๆ กรณีที่มีการ
สรางออปเจ็คของคลาส GradStudent โดยใชคําสั่ง
GradStudent s1 = new GradStudent();
จะมีผลทําให constructor ของคลาส GradStudent ทํางานดังนี้
1. เรียกใช constructor ของคลาส GradStudent ที่มีรูปแบบคําสั่งเปน
GradStudent()
2. เรียกใชคําสั่ง this(“ ”)
2.1 เรียกใช constructor ของคลาส GradStudent ที่มีรูปแบบเปน
GradStudent(String n) โดยที่จะสงขอความ “ ” ใหกับ
argument ที่ชื่อ n
2.2 เนื่องจากไมมีคาํ สั่ง this() จึงขามขั้นตอนนี้ไป
2.3 เรียกใช constructor ของคลาส Student จากคําสั่ง super(n)
2.3.1 เรียกใช constructor ของคลาส Student ที่มีรูปแบบคําสั่งเปน
Student(String n)
2.3.2 เนื่องจากไมมีคาํ สั่ง this() จึงขามขั้นตอนนี้ไป
2.3.3 เรียกใช constructor ของคลาสที่ชื่อ Object ที่เปน constructor
แบบ default
2.3.3.1 เรียกใช constructor แบบ default ของคลาสที่ชื่อ Object
2.3.3.2 เนื่องจากไมมีคําสั่ง this() จึงขามขั้นตอนนี้ไป
2.3.3.3 เนื่องจากคลาสที่ชื่อ Objectไมมี superclass จึงขาม
ขั้นตอนของการเรียก constructor ของ superclass

212 คณะเทคโนโลยีสารสนเทศ สถาบันเทคโนโลยีพระจอมเกลาเจาคุณทหารลาดกระบัง

 2.3.3.4 ไมมีคําสั่งกําหนดคาเริ่มตนของคุณลักษณะของคลาสที่ชื่อ
Object
2.3.3.5 ไมมีคําสั่งภายใน constructor ของคลาสที่ชื่อ Object
2.3.4 เรียกใชคําสั่งกําหนดคาเริ่มตนของคุณลักษณะของออปเจ็คในคลาส
Student
2.3.5 เรียกใชคําสั่ง name = n ใน constructor ของคลาส Student
2.4 เรียกใชคําสั่งกําหนดคาเริ่มตนของคุณลักษณะของออปเจ็คในคลาส
GradStudent
2.5 ไมมีคาํ สั่งอื่นๆ ภายใน constructor ของคลาส GradStudent

โปรแกรมที่ 6.27 ตัวอยางคลาสที่มี constructor ในรูปแบบตางๆ

public class Student {
protected String name;
public Student(String n) {
name = n;
}
}
--------------------------------------------------------------------------------------------------------------------------------------------------------
public class GradStudent extends Student {
public GradStudent(String n) {
super(n);
}
public GradStudent() {
this(" ");
}
}

6.6 เมธอดของคลาสที่ชื่อ Object

คลาสที่ชื่อ Object จะเปนคลาสที่ทุกๆคลาสจะสืบทอดมา คลาสที่ชื่อ Object มี
เมธอดที่สําคัญหลายเมธอด อาทิเชน toString()และ equals() ในการที่จะสามารถใช
งานเมธอดเหลานี้ไดจะตองมีการเขียนคําสั่งเพื่อกําหนดใหเปนเมธอดแบบ overridden ใน
คลาสที่ตองการ

Java Programming 213

 6.6.1 เมธอด toString()
เมธอด toString() เปนเมธอดที่ใชในการแปลงคาของออปเจ็คใหเปนขอมูล
ชนิด String คลาสที่อยูใน Java API เชนคลาส Date ไดกําหนดคําสั่งสําหรับเมธอด
toString() ไวแลว ดังนั้นการเรียกใชเมธอด System.out.println() โดยที่
argument เปนออปเจ็คของคลาส Date จะทําใหมีการเรียกใชเมธอด toString() ของ
คลาส Date โดยอัตโนมัติ ตัวอยางเชนคําสั่ง
Date d = new Date();
System.out.println(d);
จะไดผลลัพธเปนขอความที่ระบุวันเดือนปของออปเจ็ค d
โปรแกรมที่ 6.28 แสดงตัวอยางของคลาส Student ที่มีเมธอดแบบ overridden ที่
ชื่อ toString() เพื่อกําหนดขอความที่สงกลับมาเมื่อมีการเรียกใชเมธอดดังกลาว คําสั่ง
System.out.println(s1) จะเรียกใชเมธอด toString() เพื่อสงขอความที่เปน
คุณลักษณะ name กลับมาแลวแสดงผลลัพธออกทางจอภาพดังแสดงในรูปที่ 6.5

โปรแกรมที่ 6.28 ตัวอยางของคลาสที่มีเมธอดแบบ overridden ที่ชื่อ toString()

public class Student {
private String name;
public Student(String n) {
name = n;
}
public String toString() {
return name;
}
}
-------------------------------------------------------
public class TestToString {
public static void main(String args[]) {
Student s1 = new Student("Thana");
System.out.println(s1);
}
}

รูปที่ 6.5 ผลลัพธที่ไดจากการรันโปรแกรมที่ 6.28

214 คณะเทคโนโลยีสารสนเทศ สถาบันเทคโนโลยีพระจอมเกลาเจาคุณทหารลาดกระบัง

6.6.2 เมธอด equals()
เมธอด equals()เปนเมธอดในคลาสที่ชื่อ Object เพื่อเปรียบเทียบวาออปเจ็คนี้
มีคาเทากับออปเจ็คของที่สงผานมาทาง argument หรือไม คลาสที่จะสามารถเรียกใชเมธอดนี้
ไดจะตองกําหนดเมธอดแบบ overridden สําหรับเมธอดนี้อยูในคลาสนั้นดวย โปรแกรมที่ 6.29
แสดงตัวอยางของคลาส Student ที่มีเมธอดแบบ overridden ที่ชื่อ equals() เพื่อ
กําหนดวิธีการเปรียบเทียบออปเจ็ค โดยเมธอดนี้จะใหคาเปน true ถาออปเจ็คที่สงผานมา
ทาง argument มีคาของคุณลักษณะ name เทากับคาของคุณลักษณะ name ของออปเจ็คนี้
โปรแกรมนี้จะใหผลลัพธดังแสดงในรูปที่ 6.6

โปรแกรมที่ 6.29 ตัวอยางของคลาสที่มีเมธอดแบบ overridden ที่ชื่อ equals()

public class Student {
private String name;
public Student(String n) {
name = n;
}
public boolean equals(Object obj) {
if (obj.equals(name)) {
return true;
} else {
return false;
}
}
}
-------------------------------------------------------
public class TestEquals {
public static void main(String args[]) {
Student s1 = new Student("Thana");
Student s2 = new Student("Thana");
System.out.println(s1.equals(s2));
}
}

รูปที่ 6.6 ผลลัพธที่ไดจากการรันโปรแกรมที่ 6.29

Java Programming 215

 6.7 คลาสประเภท Wrapper
คลาสประเภท Wrapper เปนคลาสที่ใชในการสรางออปเจ็คที่มีคุณลักษณะสอดคลอง
กับชนิดขอมูลแบบพื้นฐานทั้งแปดชนิด โดยภาษาจาวาไดกําหนดคลาสที่อยูในแพคเก็จ
java.lang ที่เปนคลาสประเภท Wrapper ไวแปดคลาส ดังแสดงในตารางที่ 6.2 คลาส
ประเภท Wrapper จะชวยในการสรางออปเจ็คที่เก็บชนิดขอมูลแบบพื้นฐานไวในคอลเล็กชั่น
แบบ Heterogeneous
โปรแกรมที่ 6.30 แสดงตัวอยางการใชคลาสประเภท Wrapper ซึ่งในตัวอยางนี้ได
สรางออปเจ็คของคลาสประเภท Wrapper เพื่อเก็บชนิดขอมูลแบบพื้นฐานสามคา คือ true,
‘A’ และ 1.234 และไดพิมพคาของออปเจ็คทั้งสามออกมา โดยจะไดผลลัพธดังแสดงในรูปที่
6.7

ตารางที่ 6.2 คลาสประเภท Wrapper

ชนิดขอมูล ชื่อคลาส
boolean Boolean
byte Byte
short Short
int Integer
long Long
float Float
double Double
char Character

216 คณะเทคโนโลยีสารสนเทศ สถาบันเทคโนโลยีพระจอมเกลาเจาคุณทหารลาดกระบัง

โปรแกรมที่ 6.30 ตัวอยางการใชคลาสประเภท Wrapper

public class ShowWrapper {

public static void main(String args[]) {
Boolean b = new Boolean(true);
Character c = new Character('A');
Double d = new Double(1.234);
System.out.println(b);
System.out.println(c);
System.out.println(d);
}
}

รูปที่ 6.7 ผลลัพธที่ไดจากการรันโปรแกรมที่ 6.30

6.8 คียเวิรดอื่นๆที่สําคัญ
ภาษาจาวาไดกําหนดคียเวิรดที่เกี่ยวของกับคลาส เมธอดและคุณลักษณะที่สําคัญไว
สองตัวคือ static และ final คียเวิรด static เปนคียเวิรดเพื่อระบุวาตัวแปรหรือ
คาคงที่ใดเปนคุณลักษณะของคลาสหรือเมธอดใดเปนเมธอดของคลาส สวนคียเวิรด final
จะใชในคลาส และเมธอดเพื่อกําหนดไมใหมกี ารสืบทอด หรือใชในคุณลักษณะเพื่อกําหนดให
เปนคาคงที่

6.8.1 คุณลักษณะแบบ static

คุณลักษณะของคลาสจะเปนคุณลักษณะที่ใชรวมกันในทุกออปเจ็ค และสามารถ
เรียกใชงานไดโดยไมจําเปนตองสรางออปเจ็คของคลาสขึ้นมากอน ตัวแปรหรือคาคงที่ที่เปน
คุณลักษณะของคลาสคือตัวแปรหรือคาคงที่ซึ่งมี modifier เปน static คุณลักษณะของ
คลาสนี้จะเปนตัวแปรหรือคาคงที่ซึ่งใชรวมกันในทุกออปเจ็ค โดยจะแตกตางจากตัวแปรหรือ

Java Programming 217

 คาคงที่ที่เปนคุณลักษณะของออปเจ็คซึ่งอาจมีคาแตกตางกันไดในแตละออปเจ็ค โปรแกรมที่
6.31 แสดงตัวอยางการใชคียเวิรด static เพื่อประกาศตัวแปรที่เปนคุณลักษณะของคลาส
ในกรณีนี้ตัวแปร counter จะมีอยูเพียงตัวเดียวและทุกออปเจ็คใชตัวแปรนี้รวมกัน ดังนั้นจึง
สามารถที่จะเรียกใชไดโดยระบุชื่อคลาส (Student.counter) โปรแกรมนี้จะใหผลลัพธที่
มีคาเทากันดังแสดงในรูปที่ 6.8

โปรแกรมที่ 6.31 ตัวอยางการใชคียเวิรด static

public class Student {
static int counter;
public Student() {
counter++;
}
}
-------------------------------------------------------
public class TestStatic {
public static void main(String args[]) {
Student s1 = new Student();
Student s2 = new Student();
System.out.println(Student.counter);
System.out.println(s1.counter);
System.out.println(s2.counter);
}
}

รูปที่ 6.8 ผลลัพธที่ไดจากการรันโปรแกรมที่ 6.31

6.8.2 เมธอดแบบ static

เมธอดแบบ static คือเมธอดที่มี modifier เปน static โดยทั่วไปเราจะ
ประกาศเมธอดใดๆใหเปนเมธอดแบบ static ในกรณีท่เี มธอดนั้นเปนเมธอดที่ใชงานทั่วไป

218 คณะเทคโนโลยีสารสนเทศ สถาบันเทคโนโลยีพระจอมเกลาเจาคุณทหารลาดกระบัง

(Utility Method) เราสามารถที่จะเรียกใชเมธอดแบบ static ไดโดยเรียกผานชื่อคลาส
เชนเดียวกับคุณลักษณะของคลาส ซึ่งมีรูปแบบการใชงานดังนี้

ClassName.methodName()

โดยที่
• className คือชื่อของคลาส
• methodName คือชื่อของเมธอดแบบ static
ตัวอยางของเมธอดแบบ static คือเมธอดทุกเมธอดในคลาส Math ที่อยูใน
Java API ทั้งนี้เนื่องจากเมธอดเหลานี้จัดวาเปนเมธอดสําหรับใชงานทั่วไปจึงกําหนดใหเปน
เมธอดแบบ static ทําใหเราสามารถที่จะเรียกใชเมธอดเหลานี้ไดโดยใชชื่อคลาส เชนคําสั่ง
Math.sqrt(4);
เปนคําสั่งคํานวณหาคารากที่สองของ 4 เปนตน
เมธอดที่ชื่อ main()เปนอีกตัวอยางหนึ่งของเมธอดแบบ static ทั้งนี้เนื่องจาก
ภาษาจาวาไมตองการให JVM ตองสรางออปเจ็คของคลาสที่มีเมธอด main() ขึ้นมากอน
เพื่อรันเมธอด main() จึงไดกําหนดให main() เปนเมธอดแบบ static
ภาษาจาวาไดกําหนดเงื่อนไขของเมธอดแบบ static ที่สําคัญไวดังนี้
• เมธอดแบบ static จะไมสามารถเรียกคุณลักษณะหรือเมธอดที่ไมไดเปน
แบบ static (non-static) ได
• เมธอดแบบ static จะไมสามารถมีเมธอดแบบ overridden ได

6.8.3 Static Initializer

Static Initializer คือบล็อกในคลาสใดๆที่อยูนอกเมธอด และมีคียเวิรด static
เพื่อนิยามใหเปนบล็อกแบบ static โดยมีรูปแบบดังนี้
static {
...
}

โปรแกรมภาษาจาวาจะรันคําสั่งที่อยูในบล็อกแบบ static เพียงครั้งเดียวเมื่อ JVM

โหลดคลาสที่มีบล็อกดังกลาวขึ้นมา Static Initializer จะใชในการดีบัก (debug) โปรแกรมหรือ
ใชในกรณีที่ตองการสรางออปเจ็คของคลาสขึ้นโดยอัตโนมัติ เราสามารถที่จะกําหนดบล็อกแบบ

Java Programming 219

 static ไดมากกวาหนึ่งบล็อกในคลาสแตละคลาส โดยการทํางานของโปรแกรมจะเรียกคําสั่ง
ในบล็อกแบบ static จากบนลงลาง โปรแกรมที่ 6.32 แสดงตัวอยางของคลาสที่มี Static
Initializer ซึ่งโปรแกรมนี้จะใหผลลัพธดังแสดงในรูปที่ 6.9

โปรแกรมที่ 6.32 ตัวอยางของคลาสที่มี Static Initializer

public class TestStaticBlock {
static int x=5;
static {
x += 1;
}
public static void main(String args[]) {
System.out.println("x = "+x);
}
static {
x /= 2;
}
}

รูปที่ 6.9 ผลลัพธที่ไดจากการรันโปรแกรมที่ 6.32

6.8.4 คียเวิรด final

คียเวิรด final สามารถที่จะใชเปน modifier สําหรับคลาส ตัวแปร และเมธอด
โดยที่
• คลาสที่มี modifier เปน final จะเปนคลาสที่ไมสามารถใหคลาสอื่นสืบทอดได
ตัวอยางเชน คลาส String ที่กําหนดใน Java API เปนคลาสแบบ final ซึ่งมี
รูปแบบคําสั่งประกาศคลาสดังนี้
public final class String {
...
}
ดังนั้นเราจึงไมสามารถที่จะกําหนดใหคลาสใดๆสืบทอดคลาส String ได

220 คณะเทคโนโลยีสารสนเทศ สถาบันเทคโนโลยีพระจอมเกลาเจาคุณทหารลาดกระบัง

 • เมธอดที่มี modifier เปน final คือเมธอดที่จะไมสามารถมีเมธอดแบบ
overridden ได ตัวอยางเชนถาคลาส Student กําหนดใหเมธอด
showDetails() มี modifier เปน final ดังนี้
public class Student{
...
public final void showDetails(){
...
}
}
ดังนั้นถาคลาส GradStudent สืบทอดมาจากคลาส Student จะไมสามารถมี
เมธอดแบบ overridden ที่ชื่อ showDetails() ได
• ตัวแปรที่มี modifier เปน final คือคาคงที่ คาคงที่จะสามารถกําหนดคาไดเพียง
ครั้งเดียว โดยจะตองมีการกําหนดคากอนที่จะมีการเรียกใชงาน ซึ่งเมื่อกําหนดคา
แลวจะไมสามารถเปลี่ยนแปลงคาได ถาคาคงที่นั้นเปนคุณลักษณะของออปเจ็ค เรา
จะตองกําหนดคาในคําสั่งประกาศตัวแปร หรือใชคําสั่งกําหนดคาภายใน constructor
ของคลาส แตถาเปนคาคงที่ซึ่งอยูภายในเมธอด เราจะตองกําหนดคาในคําสั่ง
ประกาศตัวแปร หรือใชคาํ สั่งกําหนดคาภายในเมธอดกอนที่จะมีการเรียกใชงาน
คาคงที่นั้น

6.9 คลาสแบบ abstract และอินเตอรเฟส

ภาษาจาวากําหนดใหเราสามารถที่จะนิยามเมธอดตางๆภายในคลาส ขึ้นมากอนได
โดยยังไมตองกําหนดบล็อกคําสั่งตางๆภายในเมธอดเหลานั้น แตจะใหมีการกําหนดบล็อก
คําสั่งภายในคลาสอื่นๆที่จะสืบทอด วิธีการนี้จะชวยทําใหเราสามารถจะกําหนดเมธอดที่ไม
สามารถนิยามคําสั่งไวลวงหนาได โดยภาษาจาวาไดกําหนดคลาสลักษณะนี้ไวสองแบบคือ
คลาสแบบ abstract และอินเตอรเฟส

6.9.1 คลาสแบบ abstract

คลาสที่มี modifier เปน abstract จะหมายความวาคลาสนั้นยังเปนคลาสที่ไม
สมบูรณ โดยมีเมธอดแบบ abstract ซึ่งเปนเมธอดที่ยังไมสมบูรณอยางนอยหนึ่งเมธอดอยู
ในคลาส เมธอดแบบ abstract จะมีรูปแบบการประกาศดังนี้

[modifier] abstract return_type methodName([arguments]);

Java Programming 221

 ทั้งนี้เมธอดแบบ abstract เปนเมธอดที่ยังไมสมบูรณ เนื่องจากไมมีบล็อกคําสั่ง
({ }) อยูภายในเมธอด
โปรแกรมที่ 6.33 แสดงตัวอยางของคลาส Student ที่เปนคลาสแบบ abstract
คลาสนี้จะมีเมธอด showDetails() ซึ่งเปนเมธอดแบบ abstract อยูภายในคลาส

โปรแกรมที่ 6.33 ตัวอยางคลาสแบบ abstract

public abstract class Student {
protected String id;
protected String name;
protected double gpa;
public void setID(String ID) {
id = ID;
}
public void setName(String n) {
name = n;
}
public void setGPA(double GPA) {
gpa = GPA;
}
public abstract void showDetails();
}

คลาสแบบ abstract กําหนดขึ้นมาเพื่อใหคลาสอื่นสืบทอด โดยคลาสที่มาสืบทอด

จะตองกําหนดบล็อกคําสั่งในเมธอดที่ยังไมสมบูรณ ทั้งนี้เราจะไมสามารถจะสรางออปเจ็คของ
คลาสแบบ abstract ได โปรแกรมที่ 6.34 แสดงตัวอยางของคลาส FullTimeStudent
ที่สืบทอดมาจากคลาส Student คลาสนี้จะตองมีการกําหนดบล็อกคําสั่งในเมธอด
showDetails() เพื่อทําใหเปนเมธอดที่สมบูรณ ซึ่งจะทําใหคลาส FullTimeStudent
เปนคลาสที่สามารถใชในการสรางออปเจ็คได อนึ่งถึงแมวาเราจะไมสามารถสรางออปเจ็คของ
คลาส Student ไดแตเราสามารถประกาศออปเจ็คของคลาส Student และสรางออปเจ็ค
ของคลาส FullTimeStudent ไดตามหลักการของการมีไดหลายรูปแบบดังนี้
Student s1 = new FullTimeStudent();

222 คณะเทคโนโลยีสารสนเทศ สถาบันเทคโนโลยีพระจอมเกลาเจาคุณทหารลาดกระบัง

โปรแกรมที่ 6.34 ตัวอยางคลาสที่สืบทอดมาจากคลาสแบบ abstract
public class FullTimeStudent extends Student {
private int credit;
private final int MAX_YEAR = 4;
public FullTimeStudent(int c) {
credit = c;
}
public void showDetails() {
System.out.println("ID: "+id);
System.out.println("Name: "+name);
System.out.println("GPA: "+gpa);
System.out.println("Credit: "+credit);
}
}

6.9.2 อินเตอรเฟส
อินเตอรเฟส (interface) มีลักษณะคลายกับคลาสแบบ abstract แตจะ
ประกอบดวยเมธอดที่ยังไมสมบูรณเทานั้น โดยมีรูปแบบดังนี้

[modifier] interface InterfaceName {

[methods();]
}

โดยที่
• InterfaceName คือชื่อของอินเตอรเฟส
• methods() เปนเมธอดที่ยังไมสมบูรณ เชนเดียวกับเมธอดแบบ abstract
แตไมตองใชคียเวิรด abstract
โปรแกรมที่ 6.35 แสดงตัวอยางของอินเตอรเฟส Student อินเตอรเฟสนี้จะมี
เมธอด 4 เมธอดที่ยังไมมีบล็อกคําสั่งคือเมธอด setID(), setName(), setGPA()
และ showDetails()

Java Programming 223

 โปรแกรมที่ 6.35 ตัวอยางอินเตอรเฟส
public interface Student {
public void setID(String ID);
public void setName(String n);
public void setGPA(double GPA);
public void showDetails();
}

อินเตอรเฟสกําหนดขึ้นมาเพื่อใหคลาสอื่นนําไปใชงานโดยใชคียเวิรด implements
โดยมีรูปแบบดังนี้

[modifier] class ClassName implements InterfaceName {

[methods();]
}

โปรแกรมที่ 6.36 ไดแสดงตัวอยางของคลาส PartTimeStudent ที่

implements อินเตอรเฟส Student คลาสที่ implements อินเตอรเฟสจะตองเขียน
บล็อกคําสั่งในเมธอดทุกเมธอดที่กําหนดไวในอินเตอรเฟส เพื่อทําใหเมธอดเหลานี้สมบูรณ
และสามารถสรางออปเจ็คของคลาสนั้นได
อินเตอรเฟสจะเหมือนกับคลาสแบบ abstract ตรงที่เราจะไมสามารถสราง
ออปเจ็คของอินเตอรเฟสได ประโยชนของอินเตอรเฟสก็คือการกําหนดรูปแบบของเมธอด
ตางๆที่คลาสอื่นๆจะตอง implements ไวลวงหนา ซึ่งสามารถอาศัยหลักการของการมีได
หลายรูปแบบมาเรียกใชเมธอดเหลานั้นไดจากคลาสที่ implements อินเตอรเฟส อาทิเชน
คําสั่ง
Student s1 = new PartTimeStudent(6);
s1.setID(“1111”);
s1.setName(“Thana”);
s1.setGPA(3.00);
s1.showDetails();
อินเตอรเฟสยังชวยในการสืบทอดแบบหลายคลาสได (Multiple Inheritance)
เนื่องจากภาษาจาวากําหนดใหคลาสใดๆสามารถสืบทอดคลาสอื่นไดเพียงคลาสเดียวเทานั้น
แตจะสามารถ implements อินเตอรเฟสไดหลายอินเตอรเฟส อาทิเชน
public class MyApplet extends Applet implements
MouseListener,ActionListener {

224 คณะเทคโนโลยีสารสนเทศ สถาบันเทคโนโลยีพระจอมเกลาเจาคุณทหารลาดกระบัง

 ...
}
เปนโปรแกรมจาวาแอปเพล็ตที่สืบทอดมาจากคลาส Applet แตขณะเดียวกันเปน
คลาสที่ implements อินเตอรเฟส MouseListener และ ActionListener เปนตน

โปรแกรมที่ 6.36 ตัวอยางคลาสที่ implements อินเตอรเฟส

public class PartTimeStudent implements Student {
private String id;
private String name;
private double gpa;
private int credit;
private final int MAX_YEAR = 8;
public PartTimeStudent(int c) {
credit = c;
}
public void setID(String ID) {
id = ID;
}
public void setName(String n) {
name = n;
}
public void setGPA(double GPA) {
gpa = GPA;
}
public void showDetails() {
System.out.println(“ID: “+id);
System.out.println(“Name: “+name);
System.out.println(“GPA: “+gpa);
System.out.println(“Credit: “+credit);
}
}

6.10 คลาสภายใน
คลาสภายใน (Inner class) คือคลาสที่ประกาศอยูภายในคลาสอื่นๆ ซึ่งบางครั้ง
เรียกวาคลาสแบบซอน (nested class) คลาสภายในอนุญาตใหประกาศคุณลักษณะหรือ
เมธอดภายในคลาสอื่นได คลาสภายในมีประโยชนในกรณีที่ตองการจะจัดกลุมของคลาสที่ตอง

Java Programming 225

 ทํางานรวมกัน โดยตองการควบคุมไมใหมกี ารเขาถึงโดยตรงจากคลาสอื่นๆ และตองการ
เรียกใชคุณลักษณะหรือเมธอดของคลาสที่อยูภายนอกไดโดยตรง
ภาษาจาวาแบงคลาสภายในออกเปนสองแบบคือ
1. คลาสภายในที่อยูภายในคลาสโดยตรง
2. คลาสภายในที่อยูภายในเมธอด

6.10.1 คลาสภายในที่อยูภายในคลาส
กรณีนี้เปนการประกาศคลาสภายในคลาสอื่นที่เรียกวา คลาสภายนอก (Outer class)
โปรแกรมที่ 6.37 เปนตัวอยางของการประกาศคลาสภายในที่ชื่อ Inner ซึ่งถูกประกาศอยู
ภายในคลาสที่ชื่อ Outer คลาสภายในจะแตกตางกับคลาสทั่วๆไปตรงที่เราสามารถที่จะ
ประกาศใหคลาสภายในมี access modifier เปน public, private, default หรือ
protected ก็ได ขณะที่คลาสทั่วๆไปจะกําหนดใหเปนไดเฉพาะ public หรือ default
เทานั้น นอกจากนี้การสรางออปเจ็คของคลาสภายในยังมีขอแตกตางดังนี้
1. การสรางออปเจ็คของคลาสภายในนอกคลาสภายนอก จะตองทําการสราง
ออปเจ็คของคลาสภายนอกกอน แลวจึงสรางออปเจ็คของคลาสภายในได
ตัวอยางเชนคําสั่ง
Outer.Inner in2 = new Outer().new Inner();
ในโปรแกรมที่ 6.37 เปนตัวอยางการสรางออปเจ็คของคลาสภายในที่ชื่อ in2
(กรณีนี้จะไมสามารถสรางออปเจ็คของคลาสภายในได ถาคลาสภายในมี
modifier เปน private)
2. การสรางออปเจ็คภายในเมธอดที่อยูในคลาสภายนอกสามารถทําไดโดยตรง เชน
เดียวกับการสรางออปเจ็คทั่วๆไป ตัวอยางเชนถาเมธอด methodX() เปน
เมธอดในคลาสภายนอก และตองการจะสรางออปเจ็คของคลาสภายใน เรา
สามารถทําไดดังนี้
public void methodX() {
...
Inner in1 = new Inner();
}
คลาสที่อยูภายในสามารถที่จะเรียกใชคุณลักษณะ และเมธอดของคลาสภายนอกได
โปรแกรมที่ 6.37 แสดงตัวอยางของการเรียกใชและประกาศตัวแปรของคลาสภายในและ
ภายนอก ตัวอยางนี้จะมีตัวแปรชื่อเดียวกันซึ่งมีขอบเขตที่ตางกัน

226 คณะเทคโนโลยีสารสนเทศ สถาบันเทคโนโลยีพระจอมเกลาเจาคุณทหารลาดกระบัง

โปรแกรมที่ 6.37 ตัวอยางแสดงคลาสภายในที่อยูภายในคลาส
public class Outer {
public void method1() {
Inner in1 = new Inner();
in1.method2();
}
public class Inner {
public void method2() {
System.out.println("Inner Demo");
}
}
}
-------------------------------------------------------
public class InnerDemo {
public static void main(String args[]) {
Outer.Inner in2 = new Outer().new Inner();
in2.method2();
}
}

6.10.2 คลาสภายในที่อยูภายในเมธอด
กรณีนี้เปนการประกาศคลาสภายในที่อยูภายในเมธอดของคลาสภายนอกดังตัวอยาง
ที่แสดงในโปรแกรมที่ 6.38 คลาสภายในประเภทนี้จะมี access modifier เปน default เราจะไม
สามารถที่จะสรางออปเจ็คของคลาสภายในประเภทนี้นอกเมธอดที่ประกาศคลาสได และจะ
สามารถเรียกใชตัวแปรภายในของเมธอดไดในกรณีที่ตัวแปรนั้นประกาศเปน final เทานั้น
สวนตัวแปรที่เปนคุณลักษณะของคลาสหรือคุณลักษณะของออปเจ็ค สามารถที่จะเรียกใชได
เชนเดียวกับคลาสภายในที่อยูภายในคลาส
คลาสภายในทั้งสองประเภทยังมีคุณสมบัติอื่นๆที่สําคัญดังนี้
• คลาสภายในอาจเปนคลาสแบบ abstract หรืออินเตอรเฟสได
• คลาสภายในที่อยูภายในคลาสภายนอกโดยตรง ถามี modifier เปน static จะ
กลายเปนคลาสปกติ และสามารถสรางออปเจ็คโดยการเรียกชื่อของคลาส
ภายนอกไดดังนี้
Outer.Inner in3 = Outer.new Inner();
• คลาสภายในไมสามารถที่ประกาศใหมีคุณลักษณะหรือเมธอดเปนแบบ static
ไดเวนแตคลาสภายในจะเปนคลาสแบบ static

Java Programming 227

 • คลาสภายในสามารถที่จะใชตัวแปรที่เปนคุณลักษณะของคลาสหรือคุณลักษณะ
ของออปเจ็คของคลาสภายนอกได

โปรแกรมที่ 6.38 คลาสภายในที่อยูภายในเมธอด

public class MOuter {

private int a = 1;
public void method(final int b) {
final int c = 2;
int d = 3;
class Inner {
private void iMethod() {
System.out.println("a = "+a);
System.out.println("b = "+b);
System.out.println("c = "+c);
System.out.println("d = "+d); //illegal
}
}
}
}

6.11 แพคเก็จ
แพคเก็จจะเปนที่รวบรวมคลาสและอินเตอรเฟสตางๆที่มีหนาที่การทํางานคลายกันไว
ในที่เดียวกัน โดยทั่วไปโปรแกรมภาษาจาวาจะประกอบไปดวยคลาสหลายคลาสที่ประกาศอยู
ในโปรแกรมไฟลตางๆ ไฟลโปรแกรมภาษาจาวาแตละไฟลอาจมีคลาสที่ประกาศไวหลายคลาส
ได แตจะมีคลาสที่มี access modifier เปน public ไดเพียงคลาสเดียว ซึ่งวิธีการปฏิบัติที่
นิยมใชคือการกําหนดใหในแตละโปรแกรมไฟลมีคลาสเพียงคลาสเดียว โดยมีชื่อไฟลเปนชื่อ
เดียวกับชื่อคลาส
การจัดระบบไฟลและคลาสจึงจําเปนอยางยิ่งสําหรับการพัฒนาโปรแกรมขนาดใหญ
เราสามารถที่จะแบงโปรแกรมใหเปนแพคเก็จตางๆ โดยจัดกลุมของคลาสที่ทํางานคลายกันไว
ในแพคเก็จเดียวกัน แพคเก็จแตละแพคเก็จจะใชในการเก็บคลาสหรือแพคเก็จยอยได
ซึ่งโปรแกรมจาวาจะสรางไดเร็กทอรี่ (Directory) ที่มีชื่อเดียวกับแพคเก็จ ในการเก็บคลาสหรือ
แพคเก็จยอยเหลานั้น รูปที่ 6.10 แสดงตัวอยางโครงสรางไดเร็กทอรี่ของโปรแกรมที่มีคลาส
และแพคเก็จหลายๆตัว โปรแกรมจะอยูในแพคเก็จ faculty ซึ่งจะประกอบดวย

228 คณะเทคโนโลยีสารสนเทศ สถาบันเทคโนโลยีพระจอมเกลาเจาคุณทหารลาดกระบัง

แพคเก็จยอย 3 แพคเก็จคือ domain, GUI และ reports โดยโปรแกรม
Student.class, Teacher.class และ Subject.class จะอยูในแพคเก็จยอย
domain สวนโปรแกรม Report.class จะอยูในแพคเก็จยอย reports

รูปที่ 6.10 ตัวอยางแพคเก็จ

6.11.1 การประกาศและใชแพคเก็จ
โครงสรางโปรแกรมไฟลของภาษาจาวาจะประกอบดวยคําสั่งดังนี้

[<package_declaration>]
[<import_declaration>]
[<class_declaration>]

โดยที่
• package_declaration เปนการระบุวาโปรแกรมไฟลอยูในแพคเก็จใด
• import_declaration เปนคําสั่งในการเรียกใชแพคเก็จอื่นๆ
• class_declaration เปนคําสั่งในการประกาศคลาส

Java Programming 229

 คําสั่งในการระบุแพคเก็จจะมีรูปแบบดังนี้

package <package_name>[<sub_package_name>]

ตัวอยางเชน
package faculty.domain;
หรือ package faculty;

โปรแกรมไฟลหนึ่งไฟลจะมีคําสั่ง package ไดเพียงคําสั่งเดียว โดยจะตองเปน

คําสั่งแรกของโปรแกรม ในกรณีที่ไมมีคําสั่ง package โปรแกรมไฟลนั้นจะถูกกําหนดไวใน
แพคเก็จ default
การเรียกใชแพคเก็จอื่น ๆ จะทําไดโดยการใชคําสั่ง import ซึ่งมีรูปแบบของคําสั่ง
ดังนี้

import <package_name>[.<sub_package_name>].<Class_name>
หรือ
import <package_name>[.<sub_package_name>].*;

ตัวอยางเชน
import faculty.reports.Report;
หรือ import java.awt.*;

คําสั่ง import จะตองกําหนดไวกอนคําสั่งการประกาศคลาส ซึ่งโปรแกรมไฟล

ภาษาจาวาแตละโปรแกรมสามารถมีคําสั่ง import ไดหลายคําสั่ง

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

230 คณะเทคโนโลยีสารสนเทศ สถาบันเทคโนโลยีพระจอมเกลาเจาคุณทหารลาดกระบัง

• เมธอดใดๆของคลาสสามารถที่จะมีคาที่สงกลับมาได ทั้งนี้การประกาศเมธอด
จะตองระบุชนิดขอมูลของคาที่จะสงกลับ
• เมธอดสามารถแบงเปนเมธอดของออปเจ็ค (หรือเรียกวาเมธอดแบบ non-static)
และเมธอดของคลาส (หรือเรียกวาเมธอดแบบ static)
• เมธอดของคลาสใดที่มี modifier เปนแบบ static จะทําใหสามารถถูกเรียกใช
งาน โดยใชชื่อของคลาสนั้นไดเลย
• เมธอดแบบ overloaded คือ มีเมธอดที่มีชื่อเดียวกันแตจะมีจํานวนหรือชนิดขอมูล
ของ argument ที่ตางกัน
• โดยทั่วไป คุณลักษณะของคลาสจะมี modifier เปนแบบ private ทั้งนี้เพื่อ
ปองกันการเขาถึงจากคลาสอื่น
• โดยทั่วไป เมธอดของคลาสจะมี modifier เปนแบบ public ทั้งนี้เพื่อใหเมธอด
จากคลาสอื่นเรียกใชได
• ชื่อของเมธอดที่เกี่ยวของกับคุณลักษณะของคลาส นิยมใช setXXX สําหรับ
เมธอดที่มีไวเพื่อกําหนดคาใหกับคุณลักษณะ XXX และใช getXXX สําหรับ
เมธอดที่จะสงคากลับเปนคุณลักษณะ XXX
• การสืบทอดหมายถึง การที่คลาสที่เปน subclass สืบทอดคุณลักษณะและเมธอด
มาจากคลาสที่เปน superclass ซึ่งภาษาจาวาจะใชคียเวิรด extends
• คียเวิรด protected จะทําใหคลาสที่เปน subclass สามารถที่จะอางอิงถึง
คุณลักษณะหรือเมธอดของ superclass ได
• คลาสทุกคลาสในภาษาจาวาถาไมไดสืบทอดจากคลาสใดเลย จะถือวาคลาสนั้น
สืบทอดจากคลาสที่ชื่อ Object
• super เปนคียเวิรดที่ใชในการอางอิงถึง superclass เพื่อที่จะเรียกใชเมธอดหรือ
constructor ของ superclass
• การมีไดหลายรูปแบบหมายถึง
− การที่เราสามารถที่จะสรางหรืออางถึงออปเจ็คของคลาสที่สืบทอดกันได
หลายรูปแบบ
− การที่เราสามารถที่จะอางถึงเมธอดชื่อเดียวกันไดหลายรูปแบบ

Java Programming 231

 • เมธอดแบบ overloaded หมายถึงเมธอดที่มีชื่อเดียวกันมากกวาหนึ่งเมธอด โดย
มีจํานวนหรือชนิดของ argument ที่แตกตางกัน
• เมธอดแบบ overridden หมายถึงการที่ subclass สรางเมธอดที่มีอยูแลวใน
superclass ขึ้นใหม โดยใชชอื่ argument และชนิดขอมูลของคาที่สงกลับของ
เมธอดเหมือนเดิม
• คอลเล็กชั่นแบบ Heterogeneous คือการเก็บขอมูลที่มีชนิดขอมูลตางกันในกลุม
เดียวกัน
• คียเวิรด instanceof เปนตัวดําเนินการที่ใชกับออปเจ็คและคลาส เพื่อ
ตรวจสอบวาออปเจ็คใดๆเปนออปเจ็คของคลาสที่ระบุหรือไม
• การ casting ออปเจ็ค ทําใหเราสามารถจะกําหนดออปเจ็คของคลาสที่เปน
superclass ใหกับตัวแปรที่กําหนดเปนคลาสที่เปน subclass ได
• Constructor หมายถึง เมธอดที่มีชื่อเดียวกันกับชื่อคลาส แตจะไมมีการสงคากลับ
และจะไมมีการใสคียเวิรด void โดยคลาสทุกคลาสจะมี constructor แบบ
default มาใหอยูแลว แตเราสามารถที่จะกําหนด constructor ขึ้นใหมเองได
• Constructor แบบ overloaded หมายถึง constructor ที่มีจํานวนหรือชนิดของ
argument ที่แตกตางกัน
• เมธอดที่ชื่อ this() เปนการเรียกใช constructor ของคลาสตัวเอง โดยจะตอง
เปนคําสั่งแรกสุดที่อยูใน constructor แบบ overloaded
• Constructor แบบ default ของคลาสที่เปน superclass จะถูกเรียกใชโดย
อัตโนมัติทุกครั้งที่มีการสรางออปเจ็คของคลาสที่เปน subclass แตเราสามารถ
เปลี่ยนใหไปเรียกใช constructor ตัวอื่นของ superclass แทนไดโดยใชเมธอด
super()
• คลาสที่ชื่อ Object มีเมธอดที่สําคัญอยูสองเมธอดคือเมธอด toString()
และเมธอด equals()
• เมธอด toString() ใชในการแปลงคาของออปเจ็คใหเปนขอมูลชนิด
String สวนเมธอด equals() ใชในการเปรียบเทียบคาของออปเจ็ค
• คลาสประเภท Wrapper จะชวยในการสรางออปเจ็คที่เก็บชนิดขอมูลแบบพื้นฐาน
ไวในคอลเล็กชั่นแบบ Heterogeneous

232 คณะเทคโนโลยีสารสนเทศ สถาบันเทคโนโลยีพระจอมเกลาเจาคุณทหารลาดกระบัง

• โดยปกติเราจะประกาศเมธอดใดๆใหเปนเมธอดแบบ static ในกรณีที่เมธอด
นั้นเปนเมธอดที่ใชงานทั่วไป และเมธอดแบบ static สามารถถูกเรียกใชจาก
ชื่อของคลาสไดโดยไมจําเปนตองสรางออปเจ็ค
• คลาสที่มี modifier เปน final จะทําใหคลาสอื่นไมสามารถสืบทอดคลาสนี้ได
และเมธอดที่มี modifier เปน final คือเมธอดที่จะไมสามารถมีเมธอดแบบ
overridden ได สวนตัวแปรที่มี modifier เปน final คือคาคงที่ ซึ่งจะทําให
สามารถกําหนดคาไดเพียงครั้งเดียวเทานั้น
• คลาสที่มี modifier เปน abstract หมายความวาคลาสนั้นยังเปนคลาสที่ไม
สมบูรณ โดยมีเมธอดแบบ abstract ซึ่งเปนเมธอดที่ยังไมสมบูรณอยางนอย
หนึ่งเมธอดอยูในคลาส
• อินเตอรเฟสมีลักษณะคลายกับคลาสแบบ abstract แตจะประกอบดวยเมธอด
ที่ยังไมสมบูรณเทานั้น
• เราไมสามารถสรางออปเจ็คจากคลาสชนิด abstract และอินเตอรเฟสได
• คลาสภายในหมายถึงคลาสที่อยูภายในคลาส หรือคลาสที่อยูภายในเมธอด
• คําสั่ง package เปนการระบุวาคลาสอยูในแพคเก็จใด
• คําสั่ง import เปนการเรียกใชคลาสในแพคเก็จตางๆ

Java Programming 233

234 คณะเทคโนโลยีสารสนเทศ สถาบันเทคโนโลยีพระจอมเกลาเจาคุณทหารลาดกระบัง
 บทที่ 7
การจัดการกับเหตุการณกราฟฟก
เนื้อหาในบทนี้เปนการแนะนําวิธีการเขียนโปรแกรม เพื่อจัดการกับเหตุการณ
กราฟฟกในโปรแกรม GUI โดยจะเริ่มตนจากการแนะนํานิยามความหมายของเหตุการณ
แนะนําคลาสประเภท Event ที่เกี่ยวของกับเหตุการณกราฟฟกตางๆ แนะนําอินเตอรเฟส
ประเภท Listener ที่ใชในการรับฟงเหตุการณ อธิบายวิธีการจัดการกับเหตุการณ
กราฟฟกหลายๆเหตุการณ และตอนทายของบทเปนการแนะนําคลาสประเภท Event Adapter

7.1 เหตุการณ
เหตุการณ (Event) เปนสถานการณที่เกิดขึ้นในขณะรันโปรแกรม อาทิเชน การใช
อินพุต (เมาสหรือคียบอรด) ติดตอกับโปรแกรม GUI การเกิดเหตุการณในโปรแกรมภาษา
จาวาจะเปนการสรางออปเจ็คของคลาสประเภท Event ชนิดตางๆขึ้นมาตามประเภทของ
เหตุการณ อาทิเชน
- เมื่อเลื่อนเมาสในเฟรมจะเกิดออปเจ็คของคลาส MouseEvent ขึ้นมา
- เมื่อปดเฟรมจะเกิดออปเจ็คของคลาส WindowEvent ขึ้นมา
- เมื่อกดปุมที่อยูในเฟรมจะเกิดออปเจ็คของคลาส ActionEvent ขึ้นมา
- เมื่อพิมพขอความใน TextField จะเกิดออปเจ็คของคลาส KeyEvent
ขึ้นมา
คลาสประเภท Event จะสืบทอดมาจากคลาส ObjectEvent สวนคลาสประเภท
Event สําหรับเหตุการณทางกราฟฟกจะสืบทอดมาจากคลาส AWTEvent ที่
สืบทอดมาจากคลาส ObjectEvent อีกตอหนึ่ง ซึ่งคลาสประเภท Event สําหรับ
เหตุการณทางกราฟฟกทั้งหมดจะอยูในแพคเก็จ java.awt.event โดยสามารถแสดง
ลําดับชั้นของการสืบทอดไดดังแสดงในรูปที่ 7.1

Java Programming 235

 รูปที่ 7.1 ลําดับชั้นการสืบทอดของคลาสประเภท Event

โดยทั่วไปองคประกอบของเหตุการณจะมีสามสวนดังแสดงในรูปที่ 7.2 คือ

1. Event คือออปเจ็คประเภท Event ตามชนิดของเหตุการณที่เกิดขึ้นเชน
ออปเจ็คของคลาส WindowEvent
2. Event Source คือออปเจ็คที่ทําใหเกิดเหตุการณเชน ออปเจ็คของคลาส Frame
ที่เปนสวนที่ทําใหเกิดเหตุการณการปดเฟรม
3. Event Handler คือออปเจ็คที่จะทําหนาที่จัดการกับเหตุการณที่เกิดขึ้น โดยมี
เมธอดที่จะรับออปเจ็คประเภท Event ที่เกิดขึ้นและมีคําสั่งในการจัดการกับ
เหตุการณเพื่อโตตอบกับผูใช

รูปที่ 7.2 องคประกอบของเหตุการณ

7.2 AWTEvent
คลาส AWTEvent เปน superclass ของคลาสประเภท Event สําหรับเหตุการณ
ทางดานกราฟฟกซึ่งจะมีอยูทั้งหมด 11 คลาสคือ ActionEvent,
AdjustmentEvent, ComponentEvent, ItemEvent, TextEvent,
FocusEvent, WindowEvent, InputEvent, ContainerEvent,
KeyEvent และ MouseEvent ดังแสดงในรูปที่ 7.1 เนื้อหาในบทนี้จะกลาวถึงเมธอดของ
คลาสประเภท AWTEvent ที่สําคัญเทานั้น ซึ่งคลาส AWTEvent และคลาส
ObjectEvent มีเมธอดที่สําคัญดังนี้

236 คณะเทคโนโลยีสารสนเทศ สถาบันเทคโนโลยีพระจอมเกลาเจาคุณทหารลาดกระบัง

 • Object getSource()
เปนเมธอดในคลาส ObjectEvent เพื่อเรียกดูออปเจ็คประเภท Event
Source
• int geID()
เปนเมธอดในคลาส AWTEvent ที่สงคาจํานวนเต็มเพื่อระบุชนิดของเหตุการณ
เมธอดนี้มีประโยชนสําหรับเหตุการณของคลาส MouseEvent ซึ่งมีเหตุการณ
ไดหลายชนิด โดยมีคาจํานวนเต็มระบุชนิดของเหตุการณ อาทิเชน
MOUSE_CLICKED หรือ MOUSE_DRAGGED เปนตน

7.2.1 ActionEvent
ออปเจ็คของคลาส ActionEvent จะถูกสรางขึ้นในกรณีที่มีเหตุการณเกิดขึ้นใน
โปรแกรม GUI ดังนี้
• เมื่อมีการคลิกเมาสบนปุม (ออปเจ็คของคลาส Button)
• เมื่อมีการปอนคีย Enter ใน TextField
• เมื่อมีการเลือกรายการในเมนูของ MenuItem
• เมื่อมีการกดดับเบิ้ลคลิก (double click) ใน List
คลาส ActionEvent มีเมธอดที่เกี่ยวของดังนี้
• String getActionCommand()
เปนเมธอดที่จะสงชื่อคําสั่งที่เกิดขึ้นจาก ActionEvent ทั้งนี้คําสั่งของ
ActionEvent จะกําหนดขึน ้ โดยออปเจ็คของ Event Source ในกรณีที่เปน
ออปเจ็คของคลาส Button หรือ MenuItem ก็จะคือขอความ (label) ที่
ปรากฏบนปุมหรือเมนู นอกจากนี้เราสามารถที่จะกําหนดชื่อคําสั่งของออปเจ็ค
ของคลาส Button หรือ MenuItem ใหแตกตางจากขอความที่ปรากฏไดโดย
ใชเมธอด setActionCommand()
• int getModifiers()
เปนเมธอดที่จะสงสถานะของคีย Modifier (คีย Alt, Ctrl, Meta และ Shift) ที่เกิด
จากออปเจ็คของคลาส ActionEvent เมธอดนี้จะสงชนิดขอมูลแบบ int ที่มี
คาคงที่คืนมาคือ ALT_MASK, CTRL_MASK, META_MASK และ
SHIFT_MASK

Java Programming 237

 7.2.2 WindowEvent
ออปเจ็คของคลาส WindowEvent จะถูกสรางขึ้นในกรณีที่มีเหตุการณเกิดขึ้นเปน
ออปเจ็คของคลาสประเภท Window โดยมีเหตุการณที่เกิดขึ้นไดดังนี้
• opened เปนเหตุการณที่เกิดขึ้นเมื่อมีการเปด Window
• closed เปนเหตุการณที่เกิดขึ้นเมื่อมีการปด Window
• closing เปนเหตุการณที่เกิดขึ้นขณะกําลังปด Window
• iconified เปนเหตุการณเมื่อออปเจ็คของคลาส Window อยูในรูปของไอคอน
• deiconified เปนเหตุการณเมื่อออปเจ็คของคลาส Window ไมไดอยูในรูปของ
ไอคอน
• activated เปนเหตุการณที่เกิดขึ้นเมื่อ Window กําลังทํางานอยู
• deactivated เปนเหตุการณที่เกิดขึ้นเมื่อ Window ไมไดทํางานอยู
คลาส WindowEvent มีเมธอดที่สําคัญคือ
• Object getWindow()
เปนเมธอดที่สงออปเจ็คของคลาสประเภท Window ที่เปน Event Source คืน
มา

7.2.3 MouseEvent
ออปเจ็คของคลาส MouseEvent จะถูกสรางขึ้นในกรณีที่มีการใชงานเมาสเพื่อ
ติดตอกับผูใชโดยมีเหตุการณที่เกิดขึ้นไดดังนี้
• dragged เปนเหตุการณที่เกิดขึ้นเมื่อมีการเลื่อนเมาสแลวกดปุมของเมาสพรอม
กัน
• moved เปนเหตุการณที่เกิดขึ้นเมื่อมีการเลื่อนเมาส
• clicked เปนเหตุการณที่เกิดขึ้นเมื่อมีการคลิกเมาส
• entered เปนเหตุการณที่เกิดขึ้นเมื่อมีการเลื่อนเมาสเขาไปในขอบเขตของ
ออปเจ็คของคลาสที่เปนสวนประกอบกราฟฟกใดๆ
• exited เปนเหตุการณที่เกิดขึ้นเมื่อตําแหนงของเมาสอยูนอกขอบเขตของ
ออปเจ็คของคลาสที่เปนสวนประกอบกราฟฟกใดๆ
• pressed เปนเหตุการณที่เกิดขึ้นเมื่อมีการกดปุมบนเมาส

238 คณะเทคโนโลยีสารสนเทศ สถาบันเทคโนโลยีพระจอมเกลาเจาคุณทหารลาดกระบัง

 • released เปนเหตุการณที่เกิดขึ้นเมื่อมีการปลอยปุมที่กดบนเมาส
คลาส MouseEvent มีเมธอดที่สําคัญคือ
• int getX()
เปนเมธอดที่จะสงตําแหนงพิกัดของเมาสบนแกน x ที่มีชนิดขอมูลเปน int คืน
มา
• int getY()
เปนเมธอดที่จะสงตําแหนงพิกัดของเมาสบนแกน y ที่มีชนิดขอมูลเปน int คืน
มา
• Point getPoint()
เปนเมธอดที่จะสงตําแหนงพิกัด (x,y) ของเมาสคืนมา โดยมีชนิดขอมูลเปน
ออปเจ็คของคลาส Point
• int getClickCount()
เปนเมธอดที่จะสงจํานวนครั้งของการคลิกเมาสคืนมา

7.2.4 ItemEvent
ออปเจ็คของคลาส ItemEvent จะถูกสรางขึ้นในกรณีที่มีเหตุการณเกิดขึ้นใน
โปรแกรม GUI ดังนี้
• เมื่อมีการเลือกหรือยกเลิกรายการใน List หรือ Checkbox
• เมื่อมีการคลิกเมาสในรายการใน Choice
คลาส ItemEvent มีเมธอดที่สําคัญดังนี้
• ItemSelectable getItemSelectable()
เปนเมธอดที่จะสงออปเจ็คของคลาสประเภท ItemSelectable ที่เปน
Event Source คืนมา
• Object getItem()
เปนเมธอดที่จะสงออปเจ็คของรายการที่ถูกเลือกคืนมา
• int getStateChange()
เปนเมธอดที่จะสงคาคงที่ชนิด int ที่มีคาเปน SELECTED หรือ
DESELECTED เพื่อระบุสถานการณเลือกของรายการคืนมา

Java Programming 239

 7.2.5 Event อื่นๆ
แพคเก็จ java.awt.eventยังมีคลาสที่เปนเหตุการณทางดานกราฟฟกอื่นๆดังนี้
• KeyEvent เปนคลาสที่มีการสรางออปเจ็คเมื่อมีเหตุการณการกดคียบอรด
• FocusEvent เปนคลาสที่มีการสรางออปเจ็คเมื่อผูใชเลื่อนอุปกรณอินพุตมาชี้
ยังออปเจ็คของสวนประกอบกราฟฟกใดๆ
• ComponentEvent เปนคลาสที่มีการสรางออปเจ็คเมื่อมีเหตุการณซึ่ง
ออปเจ็คของสวนประกอบกราฟฟกมีการเปลี่ยนแปลงเชน เคลื่อนที่หรือปรับ
ขนาด
• ContainerEvent เปนคลาสที่มีการสรางออปเจ็คเมื่อมีเหตุการณในการใส
หรือยกเลิกออปเจ็คของสวนประกอบกราฟฟก ลงในออปเจ็คของคลาสประเภท
Container
• AdjustmentEvent เปนคลาสที่มีการสรางออปเจ็คเมื่อมีเหตุการณในการ
ปรับตําแหนงชี้ของออปเจ็คของคลาส ScrollBar หรือ ScrollPane
• TextEvent เปนคลาสที่มีการสรางออปเจ็คเมื่อมีเหตุการณในการ
เปลี่ยนแปลงขอความในออปเจ็คของคลาส TextArea

7.3 อินเตอรเฟสประเภท Listener

ภาษาจาวาจะจัดการกับเหตุการณ โดยการสรางออปเจ็คที่สามารถรับฟงเหตุการณ
จากคลาสที่ implements อินเตอรเฟสประเภท Listener ที่สอดคลองกันซึ่งออปเจ็คนี้จะ
ทําหนาที่เปน Event Handler อาทิเชน ออปเจ็คที่จะจัดการกับเหตุการณประเภท
ActionEvent จะตอง implements อินเตอรเฟส ActionListener โดยตองเขียน
บล็อกคําสั่งในเมธอด actionPerformed() อินเตอรเฟสประเภท Listener
มีทั้งหมด 11 ชนิด ซึ่งสอดคลองกับคลาสประเภท Event ดังนี้
• ActionListener เปนอินเตอรเฟสสําหรับออปเจ็คของคลาส
ActionEvent
• AdjustmentListener เปนอินเตอรเฟสสําหรับออปเจ็คของคลาส
AdjustmentEvent
• ComponentListener เปนอินเตอรเฟสสําหรับออปเจ็คของคลาส
ComponentEvent

240 คณะเทคโนโลยีสารสนเทศ สถาบันเทคโนโลยีพระจอมเกลาเจาคุณทหารลาดกระบัง

 • ContainerListener เปนอินเตอรเฟสสําหรับออปเจ็คของคลาส
ContainerEvent
• FocusListener เปนอินเตอรเฟสสําหรับออปเจ็คของคลาส
FocusEvent
• ItemListener เปนอินเตอรเฟสสําหรับออปเจ็คของคลาส ItemEvent

• KeyListener เปนอินเตอรเฟสสําหรับออปเจ็คของคลาส KeyEvent

• MouseListener เปนอินเตอรเฟสสําหรับออปเจ็คของคลาส
MouseEvent
• MouseMotionListener เปนอินเตอรเฟสสําหรับออปเจ็คของคลาส
MouseEvent
• TextListener เปนอินเตอรเฟสสําหรับออปเจ็คของคลาส TextEvent

• WindowListener เปนอินเตอรเฟสสําหรับออปเจ็คของคลาส
WindowEvent

ออปเจ็คใดๆที่ตองการจัดการกับเหตุการณจะตองลงทะเบียน (register) รับฟง

เหตุการณนั้นดวยโดยตองใชเมธอดที่สอดคลองกันดังแสดงในตารางที่ 7.1 สวนอินเตอรเฟส
ประเภท Listener แตละชนิดจะมีเมธอดที่ตองเขียนบล็อกคําสั่งตางๆดังแสดงในตารางที่
7.2
ตารางที่ 7.1 เมธอดที่ใชรับฟงเหตุการณ
อินเตอรเฟส เมธอดที่ใชรับฟงเหตุการณ
ActionListener addActionListener()
ItemListener addItemListener()
KeyListener addKeyListener()
MouseListener addMouseListener()
MouseMotionListener addMouseMotionListener()
TextListener addTextListener()
FocusListener addFocusListener()
AdjustmentListener addAdjustmentListener()
ComponentListener addComponentListener()
ContainerListener addContainerListener()
WindowListener addWindowListener()

Java Programming 241

 ตารางที่ 7.2 เมธอดที่ตอง implements สําหรับอินเตอรเฟสประเภท Event
อินเตอรเฟส เมธอดที่ตอง implements
ActionListener actionPerformed(ActionEvent)
ItemListener itemStateChanged(ItemEvent)
mouseDragged(MouseEvent)
MouseMotionListener
mouseMoved(MouseEvent)
mouseClicked(MouseEvent)
mouseEntered(MouseEvent)
MouseListener mouseExited(MouseEvent)
mousePressed(MouseEvent)
mouseReleased(MouseEvent)
keyPressed(KeyEvent)
KeyListener keyReleased(KeyEvent)
keyTyped(KeyEvent)
focusGained(FocusEvent)
FocusListener
focusLost(FocusEvent)
adjustmentValueChanged
AdjustmentListener
(AdjustmentEvent)
componentMoved(ComponentEvent)
componentHidden(ComponentEvent)
ComponentListener
componentResized(ComponentEvent)
componentShown(ComponentEvent)
windowOpened(WindowEvent)
windowClosed(WindowEvent)
windowClosing(WindowEvent)
WindowListener windowIconified(WindowEvent)
windowDeiconified(WindowEvent)
windowActivated(WindowEvent)
windowDeactivated(WindowEvent)
componentAdded(ContainerEvent)
ContainerListener
componentRemoved(ContainerEvent)
TextListener textValueChanged(TextEvent)

7.4 การจัดการกับเหตุการณ
ภาษาจาวาจะมีวิธีการจัดการกับเหตุการณที่เรียกวา Delegation Model โดยจะมี
หลักการดังนี้

242 คณะเทคโนโลยีสารสนเทศ สถาบันเทคโนโลยีพระจอมเกลาเจาคุณทหารลาดกระบัง

 • ออปเจ็คของสวนประกอบกราฟฟกใดๆสามารถเปนออปเจ็คประเภท Event
Source ได อาทิเชน ออปเจ็คของคลาส Button สามารถเปน Event Source
ของ ActionEvent ได
• คลาสใดๆสามารถรับฟงเหตุการณใดๆก็ได ถาคลาสนั้น implements
อินเตอรเฟสประเภท Listener ที่สอดคลองกันอาทิเชน คลาสที่ตองการรับ
ฟงเหตุการณ ActionEvent จะตอง implements อินเตอรเฟสที่ชื่อ
ActionListener
• ออปเจ็คประเภท Event ที่เกิดจาก Event Source จะถูกสงไปยังออปเจ็คของ
คลาสที่สามารถรับฟงเหตุการณประเภทนั้น
จากหลักการขางตน โปรแกรมภาษาจาวาจะมีวิธีการเขียนคําสั่งเพื่อจัดการกับ
เหตุการณตางๆดังนี้
Event Source ใดตองการที่จะจัดการกับเหตุการณใดตองลงทะเบียนเพื่อรับฟง
เหตุการณโดยมีรูปแบบดังนี้
eventSource.addXxxListener(listener)
โดยที่
• eventSource เปนชื่อของออปเจ็คที่เปน Event Source
• addXxxListener เปนเมธอดที่ใชในการลงทะเบียนรับฟงเหตุการณโดย
จะตองเลือกใชเมธอดที่สอดคลองกันในการรับฟงเหตุการณแตละชนิด ดังแสดง
ในตารางที่ 7.2 เชน ใชเมธอด addActionListener() เพื่อรับฟง
ActionEvent
• listener เปนออปเจ็คของคลาส Xxxlistener ซึ่งสามารถรับฟง
เหตุการณที่ตองการจัดการได และทําหนาที่เปน Event Handler
• XxxListener เปนคลาสที่ implements อินเตอรเฟสประเภท
Listener ที่สอดคลองกัน

การเขียนโปรแกรมเพื่อจัดการกับเหตุการณสามารถที่เขียนคลาสที่เปน Event
Handler ไดหลายรูปแบบดังนี้
• กําหนดคลาสภายนอกคลาสที่ใชในการจัดการเหตุการณ
• กําหนดคลาสที่เปนคลาสภายในอยูในคลาสที่ใชในการจัดการเหตุการณ

Java Programming 243

 • กําหนดใหคลาสที่ใชในการจัดการเหตุการณ implements อินเตอรเฟส
ประเภท Listener ที่สอดคลองกัน และสรางออปเจ็คของคลาสดังกลาว
ภายในคลาสเอง
• กําหนดคลาสภายในเมธอด (คลาสประเภท anonymous)

7.4.1 การสรางออปเจ็คของคลาสภายนอก
โปรแกรมที่ 7.1 แสดงตัวอยางการจัดการกับเหตุการณที่เกิดจากการกดปุม โดย
กําหนดคลาส ActionHandler ใหเปนคลาสประเภท Event Handler ซึ่งคลาสนี้จะอยู
ภายนอกคลาส EventDemo1 ซึ่งเปนคลาสที่ใชในการจัดการกับเหตุการณการกดปุม คลาส
EventDemo1 จะมีออปเจ็คของคลาส Button ที่ชื่อ bn1 ออปเจ็ค bn1 ไดลงทะเบียน
รับฟงเหตุการณ ActionEvent โดยใชคําสั่ง
bn1.addActionListener(new ActionHandler())
โดยที่คําสั่ง new เปนการสรางออปเจ็คของคลาส
ActionHandler()
ActionHandler ที่จะทําหนาที่เปน Event Handler ดังนั้นคลาส ActionHandler
จะตอง implements อินเตอรเฟส ActionListener โดยมีเมธอดเดียวที่จะตองเขียน
บล็อกคําสั่งคือ
public void actionPerformed(ActionEvent ev)
ซึ่งผลลัพธที่ไดจากการรันโปรแกรมที่ 7.1 จะไดดังแสดงในรูปที่ 7.3

7.4.2 การสรางออปเจ็คของคลาสภายใน
โปรแกรมที่ 7.2 แสดงตัวอยางการจัดการกับเหตุการณที่เกิดขึ้นจากการเลื่อนเมาส
โดยกําหนดคลาสประเภท Event Handler ใหอยูภายในคลาสที่ตองการจัดการกับเหตุการณ
จากตัวอยางนี้คลาส MouseHandler ซึ่งเปนคลาสที่จะรับฟงเหตุการณชนิด
MouseMotionListener โดยเปนคลาสภายในที่อยูในคลาส EventDemo2 ที่มี
ออปเจ็คของคลาส Frame ที่ชื่อ fr ซึ่งการลงทะเบียนรับฟงเหตุการณ MouseEvent
โดยใชคําสั่ง
fr.addMouseMotionListener(new MouseHandler())
โดยที่คําสั่ง new MouseHandler() เปนการสรางออปเจ็คของคลาส
MouseHandler ที่จะทําหนาที่เปน Event Handler โปรแกรมนี้จะไดผลลัพธดังแสดงในรูป
ที่ 7.4

244 คณะเทคโนโลยีสารสนเทศ สถาบันเทคโนโลยีพระจอมเกลาเจาคุณทหารลาดกระบัง

โปรแกรมที่ 7.1 การจัดการกับเหตุการณที่เกิดจากการกดปุม
import java.awt.*;
import java.awt.event.*;

public class EventDemo1 {

public static void main(String args[]) {
Frame fr = new Frame("Event Demo");
Button bn1 = new Button("Exit");
fr.setLayout(new FlowLayout());
bn1.addActionListener(new ActionHandler());
fr.add(bn1);
fr.setSize(200,200);
fr.setVisible(true);
}
}
-------------------------------------------------------
public class ActionHandler implements ActionListener {
public void actionPerformed(ActionEvent ev) {
System.exit(0);
}
}

รูปที่ 7.3 ผลลัพธที่ไดจากการรันโปรแกรมที่ 7.1

Java Programming 245

 โปรแกรมที่ 7.2 การจัดการกับเหตุการณที่เกิดขึ้นจากการเลื่อนเมาส

import java.awt.*;
import java.awt.event.*;

public class EventDemo2 {

private Frame fr;
private TextField tf;
public EventDemo2() {
fr = new Frame("Event Demo");
tf = new TextField(15);
fr.setLayout(new FlowLayout());
fr.add(tf);
fr.setFont(new Font("TimesRoman",Font.BOLD,16));
fr.addMouseMotionListener(new MouseHandler());
fr.setSize(200,200);
fr.setVisible(true);
}
public class MouseHandler implements MouseMotionListener {
public void mouseDragged(MouseEvent ev) {
tf.setText("X="+ev.getX()+" Y="+ev.getY());
}
public void mouseMoved(MouseEvent ev) { }
}
public static void main(String args[]) {
EventDemo2 obj = new EventDemo2();
}
}

รูปที่ 7.4 ผลลัพธที่ไดจากการรันโปรแกรมที่ 7.2

246 คณะเทคโนโลยีสารสนเทศ สถาบันเทคโนโลยีพระจอมเกลาเจาคุณทหารลาดกระบัง

7.4.3 การสรางออปเจ็คภายในคลาสเดียวกัน
เราสามารถที่จะกําหนดใหคลาสที่ตองการจะจัดการกับเหตุการณ เปนคลาสประเภท
Event Handler ไดเอง โดยการกําหนดใหคลาสนั้น implements อินเตอรเฟสประเภท
Listener ที่สอดคลองกัน โปรแกรมที่ 7.3 แสดงตัวอยางของคลาส EventDemo3 ซึ่งจะ
มีออปเจ็คของคลาส Frame ที่ชื่อ fr ซึ่งจะรับฟงเหตุการณประเภท WindowEvent
คลาสนี้จะเปนคลาสประเภท Event Handler ดวย โดยการ implements อินเตอรเฟส
WindowListener โปรแกรมนี้ไดสรางออปเจ็คของคลาส EventDemo ขึ้นมา และใช
คําสั่ง
fr.addWindowListener(this)
เพื่อลงทะเบียนรับฟงเหตุการณและใหออปเจ็คของคลาสนี้ (this) ซึ่งเปนออปเจ็ค
ประเภท Event Handler ในการจัดการกับเหตุการณ โปรแกรมนี้จะทําใหสามารถปดเฟรมได
โดยการคลิกเมาสที่เครื่องหมายกากบาทตรง title bar ทั้งนี้เนื่องจากคลาส EventDemo3
มีคําสั่งในเมธอด windowClosing() เพื่อออกจากโปรแกรม (คําสั่ง
System.exit(0)) โปรแกรมนี้จะไดผลลัพธดังแสดงในรูปที่ 7.5

โปรแกรมที่ 7.3 คลาสที่มีการรับฟงเหตุการณประเภท WindowEvent

import java.awt.*;
import java.awt.event.*;

public class EventDemo3 implements WindowListener{

public static void main(String args[]) {
EventDemo3 obj = new EventDemo3();
obj.init();
}
public void init() {
Frame fr = new Frame("Event Demo");
fr.addWindowListener(this);
fr.setSize(200,200);
fr.setVisible(true);
}
public void windowClosing(WindowEvent ev) {
System.exit(0);
}
public void windowOpened(WindowEvent ev) {}
public void windowClosed(WindowEvent ev) {}
public void windowIconified(WindowEvent ev) {}
public void windowDeiconified(WindowEvent ev) {}
public void windowActivated(WindowEvent ev) {}
public void windowDeactivated(WindowEvent ev) {}
}

Java Programming 247

 รูปที่ 7.5 ผลลัพธที่ไดจากการรันโปรแกรมที่ 7.3

7.4.4 การรับฟงเหตุการณหลายเหตุการณ
ภาษาจาวาอนุญาตใหออปเจ็คของคลาสที่เปนสวนกราฟฟกแตละออปเจ็ค สามารถที่
จะรับฟงเหตุการณหลายประเภทไดพรอมกันอาทิเชน ถาออปเจ็ค fr เปนออปเจ็คของ
Frame เราสามารถที่จะลงทะเบียนรับฟงเหตุการณไดดังนี้
fr.addMouseMotionListener(this);
fr.addWindowListener(this);
ซึ่งเปนการกําหนดใหออปเจ็ค fr รับฟงเหตุการณที่เกิดจากการเลื่อนเมาสและ
เหตุการณที่เกี่ยวของกับเฟรมพรอมกัน
คลาสใดๆสามารถที่จะ implements อินเตอรเฟสประเภท Listener ไดหลาย
ชนิดเชน
public class EventDemo4 implements
MouseMotionListener, WindowListener {
...
}
เปนการกําหนดคลาส EventDemo4 ใหเปนคลาสประเภท Event Handler ที่
implement อินเตอรเฟส MouseMotionListener และ WindowListener
ภายในคลาสเดียวกัน
นอกจากนี้คลาสประเภท Event Handler ใดๆสามารถที่ใชในการสรางออปเจ็คแลว
จัดการกับออปเจ็คที่เปน Event Source ไดหลายออปเจ็ค ทั้งนี้ argument ที่เปนออปเจ็คของ
คลาสประเภท Event จะมีเมธอดที่ใชในการระบุออปเจ็คของ Event Source ไดอาทิเชน
(เมธอด getSource())

248 คณะเทคโนโลยีสารสนเทศ สถาบันเทคโนโลยีพระจอมเกลาเจาคุณทหารลาดกระบัง

 โปรแกรมที่ 7.4 แสดงตัวอยางของคลาส EventDemo4 ซึ่งมีออปเจ็ค fr ที่
ลงทะเบียนรับฟงเหตุการณสองชนิด และคลาสนี้ implements อินเตอรเฟสทั้งสองชนิดที่
สอดคลองกัน โปรแกรมนี้จะใหผลลัพธดังรูปที่ 7.6

โปรแกรมที่ 7.4 คลาสที่ลงทะเบียนรับฟงเหตุการณสองชนิด

import java.awt.*;
import java.awt.event.*;

public class EventDemo4 implements MouseMotionListener,

WindowListener {
private Frame fr;
private TextField tf;
public EventDemo4() {
fr = new Frame("Event Demo");
tf = new TextField(15);
fr.setLayout(new FlowLayout());
fr.add(tf);
fr.setFont(new Font("TimesRoman",Font.BOLD,16));
fr.addMouseMotionListener(this);
fr.addWindowListener(this);
fr.setSize(200,200);
fr.setVisible(true);
}
public static void main(String args[]) {
EventDemo4 obj = new EventDemo4();
}
public void mouseDragged(MouseEvent ev) {
tf.setText("X="+ev.getX()+" Y="+ev.getY());
}
public void mouseMoved(MouseEvent ev) { }
public void windowClosing(WindowEvent ev) {
System.exit(0);
}
public void windowOpened(WindowEvent ev) { }
public void windowClosed(WindowEvent ev) { }
public void windowIconified(WindowEvent ev) { }
public void windowDeiconified(WindowEvent ev) { }
public void windowActivated(WindowEvent ev) { }
public void windowDeactivated(WindowEvent ev) { }
}

Java Programming 249

 รูปที่ 7.6 ผลลัพธที่ไดจากการรันโปรแกรมที่ 7.4

7.4.5 คลาสประเภท Event Adapter

คลาสประเภท Event Adapter คือคลาสที่ได implements อินเตอรเฟสประเภท
Listener ไวแลว โดยไดกําหนดเมธอดตางๆของอินเตอรเฟสที่ตองเขียนบล็อกคําสั่งไวแลว
แตจะเปนบล็อกคําสั่งที่ไมมีคําสั่งใดๆอยูภายในบล็อก คลาสประเภท Event Adapter จะชวย
ทําใหเขียนโปรแกรมที่เปนคลาสประเภท Event Handler ไดงายขึ้นโดยลดจํานวนเมธอดที่
จะตองเขียนบล็อกคําสั่ง การเขียนคลาสประเภท Event Handler นี้จะตองสืบทอดมาจาก
คลาสประเภท Event Adapter สําหรับการรับฟงเหตุการณที่สอดคลองกันและจะกําหนด
เมธอดแบบ overridden เฉพาะเมธอดที่ตองการจัดการกับเหตุการณ คลาสประเภท Event
Adapter จะมีอยู 7 คลาสดังนี้
• MouseAdapter คือคลาสที่ implements อินเตอรเฟสที่ชื่อ
MouseListener
• MouseMotionAdapter คือคลาสที่ implements อินเตอรเฟสที่ชื่อ
MouseMotionListener
• ComponentAdapter คือคลาสที่ implements อินเตอรเฟสที่ชื่อ
ComponentListener
• ContainerAdapter คือคลาสที่ implements อินเตอรเฟสที่ชื่อ
ContainerListener
• KeyAdapter คือคลาสที่ implements อินเตอรเฟสที่ชื่อ
KeyListener
• WindowAdapter คือคลาสที่ implements อินเตอรเฟสที่ชื่อ
WindowListener

250 คณะเทคโนโลยีสารสนเทศ สถาบันเทคโนโลยีพระจอมเกลาเจาคุณทหารลาดกระบัง

 • FocusAdapter คือคลาสที่ implements อินเตอรเฟสที่ชื่อ
FocusListener
โปรแกรมที่ 7.5 แสดงตัวอยางของการกําหนดคลาสประเภท Event Adapter ที่สืบ
ทอดมาจากคลาส WindowAdapter โปรแกรมนี้จะทําใหสามารถปดเฟรม ซึ่งผลลัพธที่ได
จะเปนเชนเดียวกับผลลัพธที่ไดจากการรันโปรแกรมที่ 7.3 ดังแสดงในรูปที่ 7.5

โปรแกรมที่ 7.5 คลาสประเภทที่สืบทอดมาจากคลาส WindowAdapter

import java.awt.*;
import java.awt.event.*;

public class EventDemo5 {

public static void main(String args[]) {
Frame fr = new Frame("Event Demo");
fr.addWindowListener(new WindowHandler());
fr.setSize(200,200);
fr.setVisible(true);
}
}
public class WindowHandler extends WindowAdapter {
public void windowClosing(WindowEvent ev) {
System.exit(0);
}
}

7.4.6 การสรางคลาสแบบ anonymous

เราสามารถสรางคลาสประเภท Event Handler ภายในเมธอดที่ใชในการลงทะเบียน
รับฟงเหตุการณ (เมธอดประเภท addXXxListener()) คลาสประเภทนี้เรียกวาคลาส
แบบ anonymous ซึ่งมักจะใชคูกับคลาสประเภท Event Adapter โดยนิยมใชกับการปดเฟรม
อาทิเชน คําสั่ง
fr.addWindowListener(new WindowAdapter() {
public void windowClosing(WindowEvent ev) {
System.exit(0);
}
});
เปนการสรางคลาสแบบ anonymous ภายในเมธอด addWindowListener()
เพื่อปดเฟรมของออปเจ็ค fr โปรแกรมที่ 7.6 แสดงตัวอยางของคลาสในรูปแบบนี้ ซึ่งผลลัพธ
ที่ไดจะเปนเชนเดียวกับผลลัพธที่ไดจากการรันโปรแกรมที่ 7.3 ดังแสดงในรูปที่ 7.5

Java Programming 251

 โปรแกรมที่ 7.6 คลาสแบบ anonymous
import java.awt.*;
import java.awt.event.*;

public class EventDemo6 {

public static void main(String args[]) {
Frame fr = new Frame("Event Demo");
fr.addWindowListener(new WindowAdapter() {
public void windowClosing(WindowEvent ev) {
System.exit(0);
}
});
fr.setSize(200,200);
fr.setVisible(true);
}
}

สรุปเนื้อหาของบท
• ออปเจ็คของคลาสประเภท Event ในแพจเก็จ java.awt.event จะถูกสรางขึ้น
เมื่อมีเหตุการณเกิดขึ้นกับออปเจ็คของสวนประกอบกราฟฟก เชน ActionEvent
เกิดขึ้นเมื่อมีการกด Button หรือ WindowEvent เกิดขึ้นเมื่อมีการปด Frame
• การจะจัดการกับ Event ประเภทใดนั้น โดยทั่วไปจะตองสรางออปเจ็คของคลาสที่
implements อินเตอรเฟสที่สอดคลองกันกับ Event นั้นดวย เชนถาตองการ
จัดการกับ WindowEvent จะตองสรางออปเจ็คของคลาสที่ implements
อินเตอรเฟส WindowListener โดยการสรางออปเจ็คอาจสรางจากคลาสใหม
คลาสภายใน คลาสเดียวกัน หรือคลาสประเภท anonymous ซึ่งคลาสประเภทนี้จะถูก
เรียกวาคลาสประเภท Event Handler
• คลาสใดๆสามารถ implements อินเตอรเฟสไดหลายตัว ทําใหสามารถที่จะขึ้น
ทะเบียนรับฟงเหตุการณไดหลายเหตุการณ
• คลาสประเภท Event Adapter คือคลาสที่ implements อินเตอรเฟสประเภท
Listener ไวแลว โดยไดกําหนดเมธอดตางๆของอินเตอรเฟสที่ตองเขียนบล็อกคําสั่ง
ไวแลว แตจะเปนบล็อกคําสั่งที่ไมมีคําสั่งใดๆอยูภายในบล็อก

252 คณะเทคโนโลยีสารสนเทศ สถาบันเทคโนโลยีพระจอมเกลาเจาคุณทหารลาดกระบัง

 บทที่ 8
อะเรยและคอลเล็กชั่น
เนื้อหาในบทนี้เปนการแนะนําการใชอะเรยของขอมูลชนิดพื้นฐาน และชนิดคลาส
อธิบายการประกาศและสรางอะเรยหลายมิติ แนะนําเมธอดที่เกี่ยวของกับอะเรย อธิบาย
ความหมายของคอลเล็กชั่น แนะนําอินเตอรเฟสและคลาสตางๆที่อยูใน Collection API และ
การนําไปใชงาน

8.1 อะเรย
อะเรยในภาษาจาวา คือตัวแปรที่เปนชนิดขอมูลแบบอางอิงที่สามารถใชเก็บขอมูล
ชนิดเดียวกันไดหลายคา ตัวแปรอะเรยจะเปนตัวแปรที่มีชื่อเดียวกันแตจะมีจํานวนสมาชิกได
หลายตัว โดยตําแหนงในหนวยความจําที่เก็บขอมูลเหลานี้จะอยูติดกัน ตัวอยางเชน หาก
ตองการกําหนดตัวแปรใหมีชนิดขอมูลเปน int เพื่อเก็บขอมูลได 5 คาโดยตั้งชื่อตัวแปรเปน
x1, x2, x3, x4 และ x5 ดังนี้
int x1, x2, x3, x4, x5;
ตัวแปรดังกลาวจะถือวาเปนตัวแปรคนละตัวกัน โดยมีชื่อตางกันและไมมีความ
สัมพันธซึ่งกันและกัน แตหากประกาศใหตัวแปร x เปนตัวแปรอะเรยที่มีจํานวนสมาชิก 5 ตัว
โดยใชคําสั่งดังนี้
int []x = new int[5];
จะทําใหตัวแปรอะเรย x เปนตัวแปรที่มีชนิดขอมูลเปน int ซึ่งมีสมาชิก 5 ตัว โดยมี
หมายเลขสมาชิกตั้งแต 0 ถึง 4 และเปนชนิดขอมูลแบบอางอิง กลาวคือคาของ x จะเก็บ
ตําแหนงของหนวยความจําเพื่ออางอิงถึงตําแหนงที่เก็บขอมูลสมาชิกของอะเรยแตละตัว ดัง
แสดงในรูปที่ 8.1

รูปที่ 8.1 การเก็บตําแหนงอางอิงของตัวแปรอะเรย

Java Programming 253

 ภาษาจาวาแบงตัวแปรอะเรยเปนสองประเภทคือ
1. อะเรยของขอมูลชนิดพื้นฐาน
2. อะเรยของขอมูลชนิดคลาส
อะเรยของขอมูลชนิดพื้นฐาน คืออะเรยที่สามารถใชเก็บขอมูลที่มีชนิดขอมูลแบบ
พื้นฐานชนิดใดชนิดหนึ่งไดหลายคาเชน อะเรยของขอมูลชนิด int หรืออะเรยของขอมูลชนิด
boolean เปนตน

อะเรยของขอมูลชนิดคลาส คืออะเรยที่สามารถใชเก็บขอมูลที่เปนออปเจ็คของคลาส
ใดๆไดหลายออปเจ็คเชน อะเรยของขอมูลชนิด String เปนตน

8.2 อะเรยของขอมูลชนิดพื้นฐาน
ภาษาจาวาสามารถที่จะสรางอะเรย เพื่อใชเก็บขอมูลที่มีชนิดขอมูลแบบพื้นฐานได
การสรางตัวแปรอะเรย จะมีขั้นตอนเชนเดียวกับการสรางตัวแปรที่เปนชนิดขอมูลแบบอางอิง
ทั่วไปสองขั้นตอนคือ
1. ขั้นตอนแรกเปนการประกาศชื่อตัวแปร ขั้นตอนนี้จะเปนการจองเนื้อที่ในหนวย
ความจําเพื่อเก็บคาของตําแหนงอางอิงที่เก็บขอมูลสมาชิกในหนวยความจํา แต
ขั้นตอนนี้จะยังไมมีการจองเนื้อที่ในหนวยความจํา เพื่อใชเก็บคาขอมูลสมาชิก
ของอะเรยแตละตัว ดังนั้นคาของตัวแปรในขั้นตอนนี้จะเปน null
2. ขั้นตอนที่สองเปนการสรางตัวแปร เพื่อบอกจํานวนสมาชิกของอะเรย และจองเนื้อ
ที่ในหนวยความจําสําหรับเก็บคาขอมูลสมาชิกของอะเรยแตละตัว โดยใชคําสั่ง
new เชนเดียวกับการสรางออปเจ็คของคลาส ขั้นตอนนี้จะทําใหคาของตัว
แปรเปลี่ยนไปเปนคาของตําแหนงอางอิงที่เก็บขอมูลสมาชิกของอะเรย

8.2.1 การประกาศชื่อตัวแปรอะเรยของขอมูลชนิดพื้นฐาน
การประกาศชื่อของตัวแปรอะเรยจะมีรูปแบบคลายกับการประกาศชื่อตัวแปรของชนิด
ขอมูลแบบพื้นฐาน แตการประกาศตัวแปรอะเรยจะตองมีเครื่องหมาย [] อยูดานหนาหรือ
ดานหลังชื่อตัวแปรดังนี้

[modifier] dataType []variableName;

หรือ [modifier] dataType variableName[];

254 คณะเทคโนโลยีสารสนเทศ สถาบันเทคโนโลยีพระจอมเกลาเจาคุณทหารลาดกระบัง

 ตัวอยางเชน คําสั่ง
int x[];
private char []ch;
public double y[];
ตางก็เปนการประกาศใหตัวแปร x, ch และ y เปนตัวแปรอะเรย โดยมีชนิดขอมูล
เปน int,char และ double ตามลําดับ
การประกาศชื่อตัวแปรยังเปนการจองเนื้อที่ในหนวยความจํา เพื่อเก็บคาของตําแหนง
อางอิงที่เก็บขอมูลสมาชิกในหนวยความจํา ซึ่งในขั้นตอนนี้จะเก็บคาเปน null ไวกอน
เนื่องจากยังไมมีการจองเนื้อที่ในหนวยความจําเพื่อเก็บขอมูลสมาชิกของอะเรย
ภาษาจาวาแตกตางจากภาษาซีตรงที่อนุญาตใหใชเครื่องหมาย [] อยูดานหนาชื่อ
ตัวแปรอะเรยที่ตองการประกาศได สวนขอแตกตางของการใชเครื่องหมาย [] ดานหนาและ
ดานหลังจะเกิดขึ้นในกรณีที่ตองการประกาศตัวแปรหลายๆตัว ตัวอยางเชน คําสั่ง
int []x,y;
จะเปนการประกาศใหตัวแปร x และ y เปนตัวแปรอะเรยชนิดขอมูล int ทั้งคูแต
คําสั่ง
int x[],y;
จะเปนการประกาศใหตัวแปร x เปนตัวแปรอะเรยที่มีชนิดขอมูลเปน int สวนตัว
แปร y เปนตัวแปรปกติที่ไมใชตัวแปรอะเรยโดยมีชนิดขอมูลเปน int

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

variableName = new dataType[size];

โดยที่ size คือจํานวนสมาชิกของอะเรยที่ตองการ

คําสั่งนี้เปนการระบุจํานวนสมาชิกของตัวแปรอะเรยและเปนการจองเนื้อที่ในหนวย
ความจําสําหรับสมาชิกของอะเรยแตละตัว นอกจากนี้ยังจะทําใหคาในหนวยความจําที่เก็บ
ตําแหนงอางอิงของตัวแปรนั้นเปลี่ยนคาจาก null ไปเปนตําแหนงที่เก็บขอมูลดังแสดงในรูป
ที่ 8.2 ตัวอยางเชน คําสั่ง
x = new int[5];

Java Programming 255

 ch = new char[4];
y = new double[6];
เปนคําสั่งสรางตัวแปรอะเรย x, ch และ y ใหมีชนิดขอมูลเปน int, char และ
double และมีจํานวนสมาชิกของอะเรยเทากับ 5, 4 และ 6 ตามลําดับ

รูปที่ 8.2 การเก็บตําแหนงอางอิงของตัวแปรอะเรย

ในการสรางตัวแปรอะเรย dataType ที่อยูในคําสั่ง new จะตองเปนชนิดขอมูลชนิด

เดียวกันกับชนิดขอมูลของตัวแปรอะเรย ดังนั้นคําสั่ง
int []x;
x = new double[4];
จึงเปนคําสั่งในการสรางตัวแปรอะเรยที่ไมถูกตอง เนื่องจากตัวแปรอะเรย x ถูก
ประกาศใหมีชนิดขอมูลเปน int แตคําสั่ง new เปนการมาสรางอะเรยของขอมูลชนิด
double
เราสามารถที่จะรวมคําสั่งประกาศชื่อตัวแปรและคําสั่งการสรางตัวแปรอะเรย ไวใน
คําสั่งเดียวกันได โดยมีรูปแบบคําสั่งดังนี้

dataType []variableName = new dataType[size];

หรือ dataType variableName[] = new dataType[size];

256 คณะเทคโนโลยีสารสนเทศ สถาบันเทคโนโลยีพระจอมเกลาเจาคุณทหารลาดกระบัง

 ตัวอยางเชน
int []x = new int[5];

8.2.3 การเรียกใชสมาชิกของอะเรย
ตัวแปรอะเรยที่สรางขึ้นจะมีสมาชิกที่มีหมายเลขตั้งแต 0 จนถึง size-1 การอางอิงถึง
สมาชิกของอะเรยแตละตัวจะมีรูปแบบดังนี้

variableName[index]

โดยที่ index คือตัวเลขระบุหมายเลขที่ของสมาชิกของอะเรย ซึ่งจะมีคาไดตั้งแตคา

0 จนถึง size-1
ตัวอยางเชน
x[3]
หมายถึงขอมูลของสมาชิกหมายเลขที่ 3 ของตัวแปรอะเรย x
ตัวแปรอะเรยที่เปนชนิดขอมูลแบบพื้นฐาน จะแตกตางจากตัวแปรปกติที่เปนชนิด
ขอมูลแบบพื้นฐาน โดยตัวแปรอะเรยจะกําหนดคาเริ่มตนใหกับสมาชิกทุกตัวเสมอ ซึ่งมีคา
เริ่มตนเชนเดียวกับตัวแปรที่เปนคุณลักษณะของออปเจ็ค (ตารางที่ 2.5) ขณะที่ตัวแปรปกติจะ
ถูกกําหนดคาเริ่มตนเฉพาะตัวแปรที่เปนคุณลักษณะของออปเจ็ค หรือคุณลักษณะของคลาส
เทานั้น
เราสามารถที่จะเปลี่ยนแปลงคาของสมาชิกของอะเรยได โดยการใชคําสั่งกําหนดคา
โดยตองอางอิงถึงหมายเลขสมาชิกของอะเรย ตัวอยางเชน
x[0] = 4;
x[2] = 5;
เปนการกําหนดคาใหกับสมาชิกหมายเลขที่ 0 และ 2 ของตัวแปรอะเรย x ใหมคี าเปน
4 และ 5 ตามลําดับ
การอางอิงถึงชื่อตัวแปร x โดยไมระบุหมายเลขสมาชิกจะเปนการเรียกดูคาตําแหนง
อางอิงของตัวแปรอะเรย โปรแกรมที่ 8.1 แสดงตัวอยางการประกาศและสรางตัวแปรอะเรย
พรอมทั้งกําหนดคาตางๆ โดยผลลัพธที่ไดเปนดังแสดงในรูปที่ 8.3

Java Programming 257

 โปรแกรมที่ 8.1 ตัวอยางการใชอะเรย

public class SimpleArrays {

public static void main(String args[]) {
int []x;
x = new int[4];
x[0] = 0;
x[1] = 2;
x[2] = 4;
x[3] = 6;
System.out.println("x = "+x);
System.out.println("x[0] = "+x[0]);
System.out.println("x[1] = "+x[1]);
System.out.println("x[2] = "+x[2]);
System.out.println("x[3] = "+x[3]);
}
}

รูปที่ 8.3 ผลลัพธที่ไดจากการรันโปรแกรมที่ 8.1

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

dataType []variableName = {value1,value2,..,valueN};

โดยที่ value1,value2,..,valueN เปนคาที่ตองการกําหนดใหกับสมาชิก
ของอะเรยแตละตัว ซึ่งจะตองเปนขอมูลคาคงที่ที่มีชนิดขอมูลที่สอดคลองกับชนิดขอมูลของตัว
แปรอะเรย
ตัวอยางเชน

258 คณะเทคโนโลยีสารสนเทศ สถาบันเทคโนโลยีพระจอมเกลาเจาคุณทหารลาดกระบัง

 int []x = {4,3,5,1,8};
เปนคําสั่งสรางตัวแปรอะเรย x ซึ่งมีจํานวนสมาชิก 5 ตัว โดยที่ x[0],x[1],
x[2],x[3] และ x[4] มีคาเริ่มตนเปน 4, 3, 5, 1 และ 8 ตามลําดับ

การกําหนดคาเริ่มตนของตัวแปรอะเรย ทําไดเฉพาะในคําสั่งประกาศตัวแปรเทานั้น
ทั้งนี้เราไมสามารถที่จะกําหนดคาเริ่มตนภายหลังจากคําสั่งประกาศตัวแปรอะเรยได กลาวคือ
คําสั่ง
int []x;
x[] = {4, 3, 5, 1, 8}; // illegal
เปนคําสั่งที่ไมถูกตอง

8.2.5 การใชคําสั่ง for เพื่ออางอิงสมาชิกของอะเรย

โดยทั่วไปเราจะใชคําสั่ง for ในการอางอิงถึงสมาชิกของอะเรยที่ตองเรียกใชในคําสั่ง
ที่ซ้ํากันอาทิเชน คําสั่ง
int x[] = {4,3,5,1,8};
จะเปนการประกาศและสรางตัวแปรอะเรยที่มีสมาชิกหาตัว หากตองการพิมพคา
ขอมูลสมาชิกของอะเรยแตละตัวโดยใชคําสั่งดังนี้
System.out.println(x[0]);
System.out.println(x[1]);
System.out.println(x[2]);
System.out.println(x[3]);
System.out.println(x[4]);
จะเห็นไดวาเปนการเรียกใชคําสั่งที่ซ้ํากัน ซึ่งเราสามารถจะแทนที่ดวยคําสั่ง for
เพื่อใหโปรแกรมกระชับขึ้นดังนี้
for(int i = 0; i < 5; i++) {
System.out.println(x[i]);
}
ทั้งนี้ภาษาจาวากําหนดใหตัวแปรอะเรยทุกตัวมีคุณลักษณะ length เพื่อระบุ
จํานวนสมาชิกของอะเรยแตละตัว ซึ่งตัวอยางขางตนจะทําให x.length มีคาเปน 5 ดังนั้น
สวนของโปรแกรมขางตนสามารถเขียนใหมไดเปน
for(int i = 0; i < x.length; i++) {
System.out.println(x[i]);
}

Java Programming 259

 โปรแกรมที่ 8.2 แสดงตัวอยางการใชคําสั่ง for กับตัวแปรอะเรยเพื่อกําหนดคาและ
พิมพคาของสมาชิกของอะเรยแตละตัว ซึ่งผลลัพธที่ไดจะเปนเชนเดียวกันกับผลลัพธที่ไดจาก
โปรแกรมที่ 8.1

โปรแกรมที่ 8.2 ตัวอยางการใชคําสั่ง for

public class ForWithArrays {

public static void main(String args[]) {
int []x;
x = new int[4];
for (int i=0; i<x.length; i++) {
x[i] = i*2;
}
System.out.println("x = "+x);
for (int i=0; i<x.length; i++) {
System.out.println("x["+i+"] = "+x[i]);
}
}
}

8.2.6 ขอผิดพลาดประเภท ArrayIndexOutOfBoundsException

การอางอิงถึงหมายเลขสมาชิกของอะเรยที่ไมถูกตอง จะทําใหเกิดขอผิดพลาดในตอน
รันโปรแกรมโดยโปรแกรมจะสงขอผิดพลาด ArrayIndexOutOfBoundsException
ออกมาในขณะรันโปรแกรม
ตัวอยางเชน คําสั่ง
int []x = {4,3,5,1,8};
เปนคําสั่งประกาศและสรางตัวแปรอะเรยที่มีจํานวนสมาชิกตั้งแตหมายเลข 0 ถึง 4
การอางอิงถึงสมาชิกตัวอื่น เชน x[5]จะทําใหเกิดขอผิดพลาดในตอนรันโปรแกรม
โปรแกรมที่ 8.3 แสดงตัวอยางโปรแกรมที่มีการอางอิงสมาชิกของตัวแปรอะเรยที่ไม
ถูกตอง ซึ่งผลลัพธที่ไดเปนดังแสดงในรูปที่ 8.4

260 คณะเทคโนโลยีสารสนเทศ สถาบันเทคโนโลยีพระจอมเกลาเจาคุณทหารลาดกระบัง

โปรแกรมที่ 8.3 ตัวอยางโปรแกรมที่จะสงขอผิดพลาดออกมา
public class IncorrectArrays {
public static void main(String args[]) {
int []x = {4,3,5,1,8};
System.out.println(x[5]);
}
}

รูปที่ 8.4 ผลลัพธที่ไดจากการรันโปรแกรมที่ 8.3

8.3 อะเรยของขอมูลชนิดคลาส
ตัวแปรอะเรยของขอมูลชนิดคลาสคือ ตัวแปรที่ใชเก็บกลุมของขอมูลสมาชิกที่เปน
ออปเจ็คของคลาสใดคลาสหนึ่ง
ขั้นตอนการสรางตัวแปรอะเรยของขอมูลชนิดคลาสจะมีขั้นตอนคลายกับขั้นตอนการ
สรางตัวแปรอะเรยของขอมูลชนิดพื้นฐาน โดยมีขั้นตอนตางๆดังนี้
1. ขั้นตอนแรกเปนการประกาศตัวแปรอะเรยซึ่งจะจองเนื้อที่ในหนวยความจํา เพื่อ
เก็บคาของตําแหนงอางอิงของตําแหนงในหนวยความจําของสมาชิกของอะเรยแต
ละตัว
2. ขั้นตอนที่สองเปนการใชคําสั่ง new เพื่อสรางและจองเนื้อที่ในหนวยความจําเพื่อ
เก็บคาของตําแหนงอางอิงของสมาชิกของอะเรยซึ่งจะชี้ไปยังตําแหนงที่เก็บขอมูล
จริงๆ
3. ขั้นตอนสุดทายเปนการสรางออปเจ็คของคลาสใหกับสมาชิกแตละตัวของอะเรย
โดยใชคําสั่ง new ซึ่งจะเปนการจองเนื้อที่ในหนวยความจําเพื่อเก็บขอมูลจริงๆ
ของออปเจ็ค
ตัวอยางเชน ถาคลาส Student มีนิยามดังนี้
public class Student {

Java Programming 261

 private String name;
public Student() {
name = “NoName”;
}
public Student(String n) {
name = n;
}
public String getName() {
return name;
}
}
เราสามารถที่จะประกาศตัวแปรอะเรย s ใหมีชนิดขอมูลเปนคลาส Student ตาม
ขั้นตอนแรก โดยใชคําสั่งดังนี้
Student []s;
ขั้นตอนที่สองเปนการกําหนดขนาดและสรางตัวแปรอะเรย ซึ่งหากตองการใหมี
จํานวนสมาชิก 3 ตัว จะทําไดโดยใชคําสั่งดังนี้
s = new Student[3];
ขั้นตอนที่สามจะเปนการอางอิงสมาชิกของอะเรยแตละตัว หรือสรางออปเจ็คของ
คลาส Student โดยใชคําสั่ง new เพื่อเปนการเรียกใช constructor เหมือนกับการสรางออป
เจ็คทั่วไปดังนี้
s[0] = new Student(“Thana”);
s[1] = new Student(“Somchai”);
s[2] = new Student(“Somsak”);
อนึ่งเราสามารถที่จะใชคําสั่ง for ในกรณีที่ตองการจะสรางออปเจ็คของสมาชิกแตละ
ตัว โดยเรียกใช constructor แบบ default ไดดังนี้
for(int i=0, i<s.length; i++) {
s[i] = new Student();
}
นอกจากนี้เรายังสามารถที่จะรวมคําสั่งที่ใชในการประกาศ และสรางตัวแปรอะเรยของ
ขอมูลชนิดคลาส และคําสั่งที่ใชในการสรางออปเจ็คใหกับสมาชิกของอะเรยแตละตัว
ดังตัวอยางตอไปนี้
Student []s = {new Student(“Thana”);
new Student(“Somchai”);
new Student(“Somsak”)};

262 คณะเทคโนโลยีสารสนเทศ สถาบันเทคโนโลยีพระจอมเกลาเจาคุณทหารลาดกระบัง

8.3.1 การเก็บคาของตัวแปรอะเรยของขอมูลชนิดคลาส
ตัวแปรของขอมูลชนิดคลาสโดยทั่วไปจะเปนตัวแปรแบบอางอิง อาทิเชน คําสั่ง
Student s1 = new Student(“Somsri”);
จะเปนการสรางตัวแปรแบบอางอิง s1 ซึ่งคาที่ s1 เก็บในหนวยความจําจะเปน
ตําแหนงที่อางอิงไปยังเนื้อที่ในหนวยความจําที่เก็บขอมูลของออปเจ็คของคลาส Student
กรณีของตัวแปรอะเรยของขอมูลชนิดคลาส ขอมูลสมาชิกของอะเรยแตละตัวก็จะเก็บ
ตําแหนงอางอิงไปยังเนื้อที่ในหนวยความจําที่เก็บขอมูลของออปเจ็คของคลาส Student แต
ละออปเจ็ค
รูปที่ 8.5 แสดงตัวอยางการเก็บคาในหนวยความจําของตัวแปร s1 และตัวแปรอะเรย s
ที่สรางขึ้นจากคําสั่งขางตน

รูปที่ 8.5 ตัวอยางการเก็บคาของตัวแปรในหนวยความจํา

โปรแกรมที่ 8.4 แสดงตัวอยางโปรแกรมที่มีการสรางตัวแปรอะเรยชนิดขอมูลคลาส

Student และมีการเรียกใชเมธอด getName() ของออปเจ็คแตละตัว ซึ่งผลลัพธที่ไดเปน
ดังแสดงในรูปที่ 8.6

Java Programming 263

 โปรแกรมที่ 8.4 ตัวอยางอะเรยของขอมูลชนิดคลาส
public class Student {
private String name;
public Student(String n) {
name = n;
}
public String getName() {
return name;
}
}
-------------------------------------------------------
public class TestClassArrays {
public static void main(String args[]) {
Student []s = {new Student(“Thana”),
new Student(“Somchai”),
new Student(“Somsak”)};
for(int i=0; i<s.length; i++) {
System.out.print(s[i].getName()+" ");
}
}
}

รูปที่ 8.6 ผลลัพธที่ไดจากการรันโปรแกรมที่ 8.4

8.4 อะเรยหลายมิติ
ภาษาจาวากําหนดใหมีตัวแปรอะเรยที่เปนหลายมิติอาทิเชน การกําหนดตัวแปรที่มี
ลักษณะเปนเมตริกซ (matrix) หรือตารางจะตองใชตัวแปรอะเรยที่เปนสองมิติ การประกาศ
ตัวแปรอะเรยที่มีขนาดมากกวาหนึ่งมิติทําไดโดยการเพิ่มเครื่องหมาย [ ] ในแตละมิติ ดังนั้น
รูปแบบการประกาศตัวแปรอะเรยสองมิติมีดังนี้

[modifier] dataType [][]variableName;

หรือ [modifier] dataType variableName[][];

264 คณะเทคโนโลยีสารสนเทศ สถาบันเทคโนโลยีพระจอมเกลาเจาคุณทหารลาดกระบัง

 ตัวอยางเชน
int [][]x;
เปนการประกาศตัวแปรอะเรยสองมิติ x ซึ่งมีชนิดขอมูลเปน int
การสรางตัวแปรอะเรยหลายมิติจะตองระบุจํานวนสมาชิกของอะเรยในแตละมิติโดย
ใชคําสั่ง new ดังนั้นรูปแบบการสรางตัวแปรอะเรยสองมิติเปนดังนี้

variableName = new dataType[row][col];

โดยที่
• row คือจํานวนสมาชิกในแตละแถว
• col คือจํานวนสมาชิกในแตละคอลัมน
ตัวอยางเชน
x = new int [3][4];
เปนการสรางตัวแปรอะเรยสองมิติ x ซึ่งมีขนาด 3 แถว 4 คอลัมน
การเรียกใชสมาชิกของอะเรยสองมิติจะตองระบุตําแหนงของแถวและคอลัมน โดยมี
รูปแบบดังนี้

variableName[row_number][col_number]

โดยที่
• row_number คือหมายเลขแถวของสมาชิกของอะเรยสองมิติ
• col_number คือหมายเลขคอลัมนของสมาชิกของอะเรยสองมิติ
ตัวอยางเชน
x[2][3]
หมายถึงสมาชิกของอะเรย x ตําแหนงแถวที่ 2 คอลัมนที่ 3 เปนตน

8.4.1 การเขียนโปรแกรมเพื่อจัดการกับเมตริกซ
โปรแกรมทางดานคณิตศาสตรที่เกี่ยวของกับการจัดการเมตริกซ จะตองใชตัวแปร
อะเรยขนาดสองมิติ โปรแกรมที่ 8.5 เปนตัวอยางแสดงการบวกและคูณเมตริกซสองเมตริกซ

Java Programming 265

 โดยการบวกเมตริกซสองเมตริกซนั้นเมตริกซทั้งสองจะตองมีขนาดเทากัน ผลลัพธที่ไดจะเปน
การรวมสมาชิกแตละตัวของเมตริกซเขาดวยกัน อาทิเชน

⎡a 11 a 12 a 13 a 14 a 15 ⎤ ⎡b 11 b 12 b 13 b 14 b 15 ⎤
⎢ ⎥ ⎢ ⎥
⎢a 21 a 22 a 23 a 24 a 25 ⎥ ⎢b 21 b 22 b 23 b 24 b 25 ⎥
⎢a 31 a 32 a 33 a 34 a 35 ⎥ + ⎢b 31 b 32 b 33 b 34 b 35 ⎥ =
⎢ ⎥ ⎢ ⎥
⎢a 41 a 42 a 43 a 44 a 45 ⎥ ⎢b 41 b 42 b 43 b 44 b 45 ⎥
⎢⎣a 51 a 52 a 53 a 54 a 55 ⎥⎦ ⎢⎣b 51 b 52 b 53 b 54 b 55 ⎥⎦

⎡a 11 + b 11 a 12 + b 12 a 13 + b 13 a 14 + b 14 a 15 + b 15 ⎤
⎢ ⎥
⎢a 21 + b 21 a 22 + b 22 a 23 + b 23 a 24 + b 24 a 25 + b 25 ⎥
⎢a 31 + b 31 a 32 + b 32 a 33 + b 33 a 34 + b 34 a 35 + b 35 ⎥
⎢ ⎥
⎢a 41 + b 41 a 42 + b 42 a 43 + b 43 a 44 + b 44 a 45 + b 45 ⎥
⎢⎣a 51 + b 51 a 52 + b 52 a 53 + b 53 a 54 + b 54 a 55 + b 55 ⎥⎦

สวนการคูณเมตริกซ A กับเมตริกซ B นั้นจํานวนคอลัมนของเมตริกซ A จะตองมี

ขนาดเทากับจํานวนแถวของเมตริกซ B โดยถาเมตริกซ C เปนผลลัพธที่ไดจากการคูณ
เมตริกซดังนี้

⎡c 11 c 12 c 13 c 14 c 15 ⎤
⎢ ⎥
⎢c 21 c 22 c 23 c 24 c 25 ⎥
⎢c 31 c 32 c 33 c 34 c 35 ⎥ =
⎢ ⎥
⎢c 41 c 42 c 43 c 44 c 45 ⎥
⎢⎣c 51 c 52 c 53 c 54 c 55 ⎥⎦

⎡a 11 a 12 a 13 a 14 a 15 ⎤ ⎡b 11 b 12 b 13 b 14 b 15 ⎤
⎢ ⎥ ⎢ ⎥
⎢a 21 a 22 a 23 a 24 a 25 ⎥ ⎢b 21 b 22 b 23 b 24 b 25 ⎥
⎢a 31 a 32 a 33 a 34 a 35 ⎥ x ⎢b 31 b 32 b 33 b 34 b 35 ⎥
⎢ ⎥ ⎢ ⎥
⎢a 41 a 42 a 43 a 44 a 45 ⎥ ⎢b 41 b 42 b 43 b 44 b 45 ⎥
⎢⎣a 51 a 52 a 53 a 54 a 55 ⎥⎦ ⎢⎣b 51 b 52 b 53 b 54 b 55 ⎥⎦

266 คณะเทคโนโลยีสารสนเทศ สถาบันเทคโนโลยีพระจอมเกลาเจาคุณทหารลาดกระบัง

 จะไดสมาชิกของเมตริกซ C แตละตัวมีคาดังนี้
cij = ai1x b1j + ai2x b2j + ai3x b3j + ai4x b4j + ai5x b5j
โปรแกรมที่ 8.5 จะมีคาํ สั่ง int[][]a = new int[5][5]; ที่ใชในการสราง
ตัวแปรอะเรยสองมิติ โดยมีคาของสมาชิกของอะเรยจากการสุมตัวเลขจํานวนระหวาง 0 ถึง 9
จากคําสั่ง
a[i][j] = (int)(Math.random()*10);
โปรแกรมนี้จะใชคําสั่ง for ที่มีโครงสรางแบบซอนอยูหลายที่ ทั้งนี้เพื่อชวยในการ
จัดการประมวลผลขอมูลของสมาชิกตัวแปรอะเรย
คลาส Matrices มีเมธอดดังนี้
• addMatrices(int[][] m1, int[][] m2) ใชเพื่อคํานวณหาผลลัพธ
ที่ไดจากการบวกเมตริกซ โดยรับ argument เขามาเปนตัวแปรอะเรยสองมิติ 2
ตัว
• mulMatrices(int[][] m1, int[][] m2) ใชเพื่อคํานวณหา
ผลลัพธที่ไดจากการคูณเมตริกซ โดยรับ argument เขามาเปนตัวแปรอะเรยสอง
มิติ 2 ตัว
• printMatrix(int[][] m) ใชเพื่อแสดงคาสมาชิกแตละตัวของเมตริกซที่
รับเขามาเปน argument
ตัวอยางผลลัพธที่ไดจากโปรแกรมนี้เปนดังแสดงในรูปที่ 8.7

Java Programming 267

 โปรแกรมที่ 8.5 ตัวอยางการคํานวณเมตริกซ
class Matrices {
int [][]m = new int[5][5];
public int[][] addMatrices(int[][] m1, int[][] m2) {
for (int i=0; i<m1.length; i++) {
for (int j=0; j<m1[i].length; j++) {
m[i][j] = m1[i][j] + m2[i][j];
}
}
return m;
}
public int[][] mulMatrices(int[][] m1, int[][] m2) {
int sum;
for (int i=0; i<m1.length; i++) {
for (int j=0; j<m1[i].length; j++) {
sum = 0;
for (int k = 0;k < m1[i].length; k++) {
sum += m1[i][k] * m2[k][j];
}
m[i][j] = sum;
}
}
return m;
}
public void printMatrix(int[][] m) {
for (int i=0; i<m.length; i++) {
for (int j=0; j<m[i].length; j++) {
System.out.print(m[i][j]+"\t");
}
System.out.println();
}
}
}
public class CalMatrices {
public static void main(String args[]) {
int [][]a = new int[5][5];
int [][]b = new int[5][5];
int [][]c = new int[5][5];
for (int i=0; i<a.length; i++) {
for (int j=0; j<a[i].length; j++) {
a[i][j] = (int) (Math.random()*10);
b[i][j] = (int) (Math.random()*10);
}
}
Matrices mt = new Matrices();
System.out.println("Matrix A:");

268 คณะเทคโนโลยีสารสนเทศ สถาบันเทคโนโลยีพระจอมเกลาเจาคุณทหารลาดกระบัง

 mt.printMatrix(a);
System.out.println("Matrix B:");
mt.printMatrix(b);
c = mt.addMatrices(a,b);
System.out.println("Matrix A+B:");
mt.printMatrix(c);
c = mt.mulMatrices(a,b);
System.out.println("Matrix A*B:");
mt.printMatrix(c);
}
}

รูปที่ 8.7 ตัวอยางผลลัพธที่ไดจากการรันโปรแกรมที่ 8.5

อนึ่งคุณลักษณะ length เมื่อนํามาใชกับตัวแปรอะเรยสองมิติจะใหคาดังนี้

x.length จะไดคาเทากับจํานวนแถวของตัวแปรอะเรย สวน x[i].length จะไดคา
เทากับจํานวนคอลัมนในแถวที่ i ของตัวแปรอะเรย

Java Programming 269

 8.4.2 อะเรยสองมิติที่มีจํานวนคอลัมนตางกัน
ภาษาจาวาอนุญาตใหมีการสรางอะเรยสองมิติที่มีขนาดของคอลัมนในแตละแถวไม
เทากันได โดยจะตองระบุจํานวนแถวโดยใชคําสั่ง new กอน แลวระบุจํานวนคอลัมนในแตละ
แถว ตัวอยางเชนคําสั่ง
int [][]x;
x = new int[3][];
x[0] = new int[4]
x[1] = new int[2];
x[2] = new int[3]
เปนการสรางตัวแปรอะเรย x ซึ่งมีสมาชิกจํานวน 3 แถว โดยที่แถวที่หนึ่งมี 4
คอลัมน แถวที่สองมี 2 คอลัมน และแถวที่สามมี 3 คอลัมน
โปรแกรมที่ 8.6 แสดงการสรางตัวแปรอะเรยสองมิติที่แตละแถวมีจํานวนคอลัมน
ตางกัน โปรแกรมนี้จะไดผลลัพธดังแสดงในรูปที่ 8.8 และรูปที่ 8.9 แสดงขอมูลที่อยูในสมาชิก
แตละตัวของอะเรย

โปรแกรมที่ 8.6 ตัวอยางการสรางอะเรยสองมิติที่แตละแถวมีจํานวนคอลัมนตางกัน

public class TwoDimensionArrays {
public static void main(String args[]) {
int x[][] = new int[3][];
x[0] = new int[4];
x[1] = new int[2];
x[2] = new int[3];
for(int i=0; i<x.length; i++) {
for(int j=0; j<x[i].length; j++) {
x[i][j] = (i+j)*2;
}
}
for(int i=0; i<x.length; i++) {
for(int j=0; j<x[i].length; j++) {
System.out.print(x[i][j]+" ");
}
System.out.println();
}
}
}

270 คณะเทคโนโลยีสารสนเทศ สถาบันเทคโนโลยีพระจอมเกลาเจาคุณทหารลาดกระบัง

 รูปที่ 8.8 ผลลัพธที่ไดจากการรันโปรแกรมที่ 8.6

รูปที่ 8.9 แสดงตัวอยางขอมูลที่อยูในอะเรย ซึ่งเปนผลลัพธที่ไดจากการรันโปรแกรมที่ 8.6

8.5 เมธอดที่เกี่ยวของกับอะเรย
ภาษาจาวามีเมธอดหลายเมธอดที่รับ argument เปนอะเรยของขอมูลชนิดตางๆ
ตัวอยางเชนแพคเก็จ java.lang มีคลาสที่ชื่อ Arrays ซึ่งมีเมธอดที่เกียวของกับอะเรยที่
สําคัญดังนี้
• sort() เปนเมธอดที่ใชในการเรียงคาขอมูลสมาชิกของอะเรยจากนอยไปมาก
• binarySearch() เปนเมธอดที่ใชในการคนหาคาขอมูลที่ตองการจากชุด
ขอมูลทั้งหมดของสมาชิกของอะเรย ซึ่งถูกเรียงจากนอยไปมากหรือมากไปนอย
ไวแลว
• fill() เปนเมธอดที่ใชในการกําหนดคาขอมูลเดียวกันใหกับสมาชิกทั้งหมด
ของอะเรย
เนื่องจากเมธอดทั้งสามเมธอดที่กลาวมาขางตนเปนเมธอดแบบ static ดังนั้นการ
เรียกใชงานเมธอดเหลานี้จึงสามารถเรียกโดยใชชื่อคลาส Arrays ไดเลย ไมจําเปนตองสราง
ออปเจ็คของคลาส Arrays ขึ้นมากอนการเรียกใชงาน
โปรแกรมที่ 8.7 แสดงตัวอยางการเรียกใชเมธอดของคลาส Arrays ที่กลาวไว
ขางตน โปรแกรมนี้เรียกใชเมธอด sort() โดยสง argument ที่เปนตัวแปรอะเรย d ไป

Java Programming 271

 เพื่อเรียงคาขอมูลของสมาชิกของตัวแปรอะเรย d จากนอยไปมาก เมธอด
binarySearch() จะใชในการคนหาสมาชิกของตัวแปรอะเรย d ที่มีคาเทากับ 1.65
สวนเมธอด fill() ใชในการกําหนดคาของสมาชิกของตัวแปรอะเรย d ทุกตัวใหมีคาเปน
1.0 โปรแกรมนี้จะใหผลลัพธดังแสดงในรูปที่ 8.10
ภาษาจาวาไมยอมใหมีการเปลี่ยนแปลงขนาดของอะเรย ดังนั้นการใชคําสั่ง new
เพื่อประกาศขนาดของตัวแปรอะเรยใหม จะทําใหคาของขอมูลเดิมหายไป ตัวอยางเชนคําสั่ง
int []x = {4,7,9};
x = new int[4];
จะเปนคําสั่งในการประกาศตัวแปรอะเรย x และสรางอะเรยพรอมกับกําหนดคา
เริ่มตนใหกับสมาชิกทั้ง 3 ตัวของอะเรย โดยมีคาขอมูลเปน 4, 7 และ 9 ตามลําดับ แตคําสั่ง
ถัดมาจะเปนการสรางอะเรย x ขึ้นมาใหมโดยไมสามารถนําคาของขอมูลเดิมกลับมาได จึงทํา
ใหคาขอมูลสมาชิกของอะเรยทั้ง 4 ตัวมีคาเทากับ 0 ทั้งหมด

โปรแกรมที่ 8.7 ตัวอยางการเรียกใชเมธอดของคลาส Arrays

import java.util.Arrays;

public class MethodsArrays {

public static void main(String args[]) {
double d[] = {5.3, 3.56, 0.5, 1.65, 7.8};
Arrays.sort(d);
for(int i=0; i<d.length; i++) {
System.out.print(d[i]+" ");
}
System.out.println();
int pos = Arrays.binarySearch(d,1.65);
System.out.println("arrays["+pos+"] = 1.65");
Arrays.fill(d,1.0);
for(int i=0; i<d.length; i++) {
System.out.print(d[i]+" ");
}
System.out.println();
}
}

272 คณะเทคโนโลยีสารสนเทศ สถาบันเทคโนโลยีพระจอมเกลาเจาคุณทหารลาดกระบัง

 รูปที่ 8.10 ผลลัพธที่ไดจากการรันโปรแกรมที่ 8.7

ภาษาจาวามีคําสั่ง System.arraycopy() ใชสําหรับคัดลอกคาขอมูลของ

สมาชิกของอะเรยโดยมีโครงสรางรูปแบบคําสั่งดังนี้
System.arraycopy(Object src,int src_pos,
Object dst,int dst_pos,int length);
โปรแกรมที่ 8.8 แสดงตัวอยางการใชคําสั่ง System.arrayCopy() โดยสง
argument ซึ่งเปนตัวแปรอะเรย scr ซึ่งเปนอะเรยตนแบบ เริ่มจากคาขอมูลของสมาชิก
ลําดับที่ 3 ของอะเรย src ไปยังสมาชิกลําดับที่ 0 ของอะเรย dst โดยใหทําการคัดลอก
ขอมูลทั้งสิ้น 4 คาขอมูล โดยโปรแกรมนี้จะไดผลลัพธดังแสดงในรูปที่ 8.11

โปรแกรมที่ 8.8 ตัวอยางการใชคําสั่ง System.arraycopy();

public class CopyArrays {

public static void main(String args[]) {
String []scr = {"Copy","an","array","from",
" source"," to"," destination."};
String []dst = new String[4];
System.arraycopy(scr,3,dst,0,4);
for(int i=0; i<dst.length; i++) {
System.out.print(dst[i]);
}
System.out.println();
}
}

รูปที่ 8.11 ผลลัพธที่ไดจากการรันโปรแกรมที่ 8.8

Java Programming 273

 8.6 คอลเล็กชั่น
ตัวแปรอะเรยเปนชนิดขอมูลแบบอางอิง ซึ่งเมื่อมีการสรางอะเรยโดยใชคําสั่ง new
แลวจะไมสามารถเปลี่ยนแปลงขนาดของจํานวนสมาชิกที่เก็บในอะเรยได ในกรณีที่ตองการจะ
เก็บกลุมของขอมูลที่สามารถเปลี่ยนแปลงขนาดของจํานวนสมาชิกได ภาษาจาวาจะใชคลาส
ประเภทคอลเล็กชั่น (Collection) ซึ่งเปนคลาสที่ใชในการเก็บกลุมของขอมูลชนิดคลาสที่ชื่อ
Object ซึ่งคลาสทุกๆคลาสในภาษาจาวาจะสืบทอดมาจากคลาสที่ชื่อ Object นี้ ดังนั้น
คลาสประเภทคอลเล็กชั่นสามารถเก็บออปเจ็คของคลาสใดๆในภาษาจาวาไดตามหลักการ
Dynamic Binding ของการมีไดหลายรูปแบบที่จะกลาวถึงในบทที่ 4
คลาสประเภทคอลเล็กชั่นถูกกําหนดไวใน Java API ที่ชื่อ Collection API โดยจะ
ประกอบไปดวยอินเตอรเฟสและคลาสตางๆดังแสดงในรูปที่ 8.12 Collection API ไดกําหนด
อินเตอรเฟสตางๆ ที่มีเงื่อนไขในการใสขอมูลของสมาชิกของคอลเล็กชั่นที่แตกตางกันดังนี้
• Collection เปนอินเตอรเฟสที่กําหนดเมธอดในการจัดการขอมูลของสมาชิก
สําหรับคลาสประเภทคอลเล็กชั่นที่จะตอง implements อินเตอรเฟสนี้
• Set เปนอินเตอรเฟสที่ใช implements คลาสประเภทคอลเล็กชั่นที่มีสมาชิก
ที่มีขอมูลไมซ้ํากัน และไมมีลําดับการใสขอมูล
• List เปนอินเตอรเฟสที่ใช implements คลาสประเภทคอลเล็กชั่นที่มี
สมาชิกซึ่งอาจมีขอมูลซ้ํากันได แตจะมีลําดับของสมาชิกของการใสขอมูล
• Map เปนอินเตอรเฟสที่ใช implements คลาสประเภทคอลเล็กชั่นซึ่งสมาชิก
จะมีองคประกอบสองสวนคือ ขอมูลและคีย (key) ขอมูลของสมาชิกประเภทนี้อาจ
ซ้ํากันได แตคียของสมาชิกแตละตัวจะตองไมซ้ํากัน
คลาสใน Collection API ที่ implements อินเตอรเฟสเหลานี้คือ HashSet,
ArrayList, LinkedList, Vector และ HashMap

274 คณะเทคโนโลยีสารสนเทศ สถาบันเทคโนโลยีพระจอมเกลาเจาคุณทหารลาดกระบัง

 รูปที่ 8.12 อินเตอรเฟสและคลาสตางๆ ใน Collection API

8.6.1 อินเตอรเฟส Collection

Collection เปนชื่ออินเตอรเฟสที่กําหนดไวใน Collection API โดยมีเมธอดที่
สําคัญดังนี้
• boolean add (Object element)
เปนเมธอดที่ใชในการใสสมาชิกลงในคอลเล็กชั่น โดยสมาชิกที่จะใสตองเปน
ออปเจ็คของคลาสใดคลาสหนึ่ง เมธอดนีจ้ ะสงคากลับมาเปนชนิดขอมูลแบบ
boolean โดยจะใหคาเปน true ถาสามารถใสขอมูลได

• boolean remove (Object element)

เปนเมธอดที่ใชในการลบสมาชิกออกจากคอลเล็กชั่น โดยตองสงผาน argument
ที่เปนออปเจ็คที่ตองการลบออก เมธอดนีจ้ ะสงคากลับมาเปนชนิดขอมูลแบบ
boolean โดยจะใหคาเปน true ในกรณีที่ลบขอมูลได

• int size()
เปนเมธอดที่ใชในการหาจํานวนสมาชิกที่มีอยูในคอลเล็กชั่น
• boolean isEmpty()
เปนเมธอดที่ใชในการตรวจวาคอลเล็กชั่นมีสมาชิกอยูหรือไม โดยจะสงคากลับมา
เปน true ถาไมมีสมาชิกอยูในคอลเล็กชั่น
• boolean contains(Object element)

Java Programming 275

 เปนเมธอดที่ใชในการตรวจสอบวา คอลเล็กชั่นมีสมาชิกที่มีคาเปนออปเจ็คของ
argument ที่สงผานมาหรือไม
• Iterator iterator()
เปนเมธอดที่ใชในการแจกแจงขอมูลของสมาชิกในคอลเล็กชั่น

8.6.2 อินเตอรเฟส Set

Set เปนอินเตอรเฟสที่สืบทอดมาจากอินเตอรเฟส Collection โดยมีคลาสที่
สําคัญที่ implements อินเตอรเฟสนี้คือคลาส HashSet คลาส HashSet ใชในการ
สรางออปเจ็คประเภทคอลเล็กชั่นซึ่งจะมีสมาชิกของขอมูลซ้ํากันไมได โปรแกรมที่ 8.9 แสดง
ตัวอยางการใชคลาส HashSet โปรแกรมนี้จะตองมีคําสั่ง import java.util.*;
เพื่อที่จะเรียกใชคลาสตางๆ ที่กําหนดใน Collection API โปรแกรมนี้ไดสรางออปเจ็ค s ซึ่ง
เปนออปเจ็คของคลาส HashSet และเรียกใชเมธอด add() ในการใสขอมูลลงในออปเจ็ค
s โดยปกติแลว argument ของเมธอด add() จะตองเปน ออปเจ็คของคลาสที่ชื่อ Object
แตโปรแกรมนี้จะสง argument ที่เปนออปเจ็คของคลาส String ซึ่งสามารถทําไดเนื่องจาก
คลาส String เปนคลาสที่สืบทอดมาจากคลาสที่ชื่อ Object โปรแกรมนี้ตองการจะแสดง
ใหเห็นวาเราไมสามารถที่จะใสขอมูลที่ซ้ํากัน (ขอความ “Java”) ลงในออปเจ็คชนิด HashSet
ได ซึ่งโปรแกรมนี้จะไดผลลัพธดังแสดงในรูปที่ 8.13

โปรแกรมที่ 8.9 ตัวอยางการใชคลาส HashSet

import java.util.*;
public class SampleSet {
public static void main(String args[]) {
Set s = new HashSet();
s.add("C#");
s.add("Java");
s.add("Pascal");
System.out.println("The size of this set is "+
s.size());
System.out.println("The contents are "+s);
System.out.println("Removing C#");
s.remove("C#");
System.out.println("Now this set contains C#: "+
s.contains("C#"));
s.add("Java");
System.out.println("Now the size is "+s.size());
System.out.println("The contents are "+s);
}
}

276 คณะเทคโนโลยีสารสนเทศ สถาบันเทคโนโลยีพระจอมเกลาเจาคุณทหารลาดกระบัง

 รูปที่ 8.13 ผลลัพธที่ไดจากการรันโปรแกรมที่ 8.9

8.6.3 อินเตอรเฟส List

List เปนอินเตอรเฟสที่สืบทอดมาจากอินเตอรเฟส Collection แตจะ
แตกตางจากอินเตอรเฟส Set ตรงที่จะมีลําดับของสมาชิกอยู (index) และสามารถที่มี
สมาชิกซึ่งมีขอมูลซึ่งซ้ํากัน ซึ่งอินเตอรเฟส List จะเพิ่มเมธอดที่เกี่ยวของกับขอมูลลําดับของ
สมาชิก ดังนี้
• void add(int index,Object element)
เปนเมธอดในการใสสมาชิกลงในคอลเล็กชั่นที่เปนออปเจ็คที่มีคาเปน argument
ที่สงผาน โดยมีลําดับที่เปนเลขจํานวนเต็มใน argument ที่ชื่อ index
• Object remove(int index)
เปนเมธอดในการลบสมาชิกลําดับที่ซึ่งมีเลขจํานวนเต็มใน argument ที่ชื่อ
index ออกจากคอลเล็กชั่น

• Object get(int index)

เมธอดนี้ใชในการเรียกขอมูลของสมาชิกลําดับที่มีเลขจํานวนเต็มใน argument ที่
ชื่อ index
• int indexOf(Object element)
เมธอดนี้ใชในการตรวจสอบวาออปเจ็คที่มีคาใน argument ที่สงผานมาเปน
สมาชิกลําดับที่เทาไรของคอลเล็กชั่น
• ListIterator listIterator()
เมธอดนี้ใชในการแจกแจงขอมูลของสมาชิกในคอลเล็กชั่นแบบ List

Java Programming 277

 คลาสสําคัญที่ implements อินเตอรเฟส List ซึ่งระบุไวใน Collection API คือ
คลาส LinkedList และ ArrayList โปรแกรมที่ 8.10 แสดงตัวอยางการใชคลาส
LinkedList โปรแกรมนี้จะมีคําสั่ง l.get(0) เปนการเรียกขอมูลของสมาชิกลําดับที่ 0
ในออปเจ็ค l ที่เปนออปเจ็คของคลาส LinkedList สวนคําสั่ง l.indexOf(“Java”)
เปนคําสั่งเรียกดูลําดับที่ของสมาชิกในออปเจ็ค l ซึ่งมีขอมูลเปนออปเจ็ค String ที่มี
ขอความใน “Java” โปรแกรมนี้แสดงตัวอยางของขอแตกตางระหวางคลาสประเภท Set
และ List ทั้งนี้จะเห็นไดจากคําสั่ง l.add(“Java”) สามารถที่จะใสขอมูลที่ซ้ํากันไดโดย
โปรแกรมจะไดผลลัพธดังแสดงในรูปที่ 8.14

โปรแกรมที่ 8.10 ตัวอยางการใชคลาส LinkedList

import java.util.*;

public class SampleList {

public static void main(String args[]) {
List l = new LinkedList();
l.add("C#");
l.add("Java");
l.add("Pascal");
System.out.println("The size is "+l.size());
System.out.println("The contents are "+l);
System.out.println("The first one is "+l.get(0));
l.add("Java");
System.out.println("The contents are "+l);
System.out.println("The index of Java is "+
l.indexOf("Java"));
}
}

รูปที่ 8.14 ผลลัพธที่ไดจากการรันโปรแกรมที่ 8.10

278 คณะเทคโนโลยีสารสนเทศ สถาบันเทคโนโลยีพระจอมเกลาเจาคุณทหารลาดกระบัง

8.6.4 อินเตอรเฟส Map
Map เปนอินเตอรเฟสที่สืบทอดมาจากอินเตอรเฟส Collection ซึ่งสมาชิกแตละ
ตัวของคอลเล็กชั่นที่เปน Map จะมีขอมูลอยูสองสวนคือ สวนที่เปนคียและสวนที่เปนขอมูลซึ่ง
เปนออปเจ็คของคลาสใดๆ คียจะทําหนาที่ชวยในการสืบคนสวนที่เปนขอมูลสมาชิกของ Map
โดยจะตองมีคียที่ไมซ้ํากันแตอาจมีสวนที่เปนขอมูลซ้ํากันได อินเตอรเฟส Map จะมีเมธอด
ตางๆ ที่เพิ่มขึ้นมาเพื่อชวยสนับสนุนการทํางานของคียดังนี้
• Object put(Object key, Object value)
เปนเมธอดที่ใชในการใสสมาชิกลงในคอลเล็กชั่น โดยตองใสออปเจ็คทั้งสวนที่เปน
คียและสวนที่เปนขอมูลตาม argument ที่ชื่อ key และ value ตามลําดับ
• Object remove(Object key)
เปนเมธอดที่ใชในการลบสมาชิกออกจากคอลเล็กชั่น โดยสมาชิกที่ถูกลบจะมีคา
ของคียเปนออปเจ็คที่มีคาตาม argument ที่ชื่อ key
• Object get(Object key)
เปนเมธอดที่ใชในการเรียกดูขอมูลของสมาชิกในคอลเล็กชั่นที่มีคาของคียเปนคา
ของออปเจ็คที่ชื่อ key ที่ผานมายัง argument
• Set entrySet()
เปนเมธอดที่ใชเรียกดูขอมูลของสมาชิกทั้งหมดในคอลเล็กชั่น
• Set keySet()
เปนเมธอดที่ใชเรียกดูคียของสมาชิกทั้งหมดในคอลเล็กชั่น
• int size()
เปนเมธอดที่ใชในการหาจํานวนสมาชิกของคอลเล็กชั่น
คลาสที่สําคัญที่ implements อินเตอรเฟส Map คือคลาส HashMap โปรแกรมที่
8.11 แสดงตัวอยางการสรางออปเจ็คของคลาสนี้แลวเรียกใชเมธอด put() ในการใสสมาชิก
ลงในคอลเล็กชั่น ทั้งนี้เมธอดนี้จะตองสงผาน argument สองตัว ในที่นี้ทั้งสองตัวจะสงผานออป
เจ็คชนิด String เมธอด remove() ในที่นี้จะใชในการลบสมาชิกที่มีคาของคียเปน
String ที่มีคา เปน “3” โปรแกรมนี้จะใหผลลัพธดังแสดงในรูปที่ 8.15

Java Programming 279

 โปรแกรมที่ 8.11 ตัวอยางการใชคลาส HashMap
import java.util.*;

public class SampleMap {

public static void main(String args[]) {
Map m = new HashMap();
m.put("1","C#");
m.put("2","Java");
m.put("3","Pascal");
System.out.println("Removing Pascal");
m.remove("3");
System.out.println("The size is "+m.size());
System.out.println("The first one is "+
m.get("1"));
m.put("3","Java");
System.out.println("The key of this map are "+
m.keySet());
System.out.println("The contents are "+
m.entrySet());
}
}

รูปที่ 8.15 ผลลัพธที่ไดจากการรันโปรแกรมที่ 8.11

8.6.5 อินเตอรเฟส Iterator

Iterator เปนอินเตอรเฟสที่ใชในการเรียกดูสมาชิกของคอลเล็กชั่น ทั้งนี้
อินเตอรเฟส Collection จะมีเมธอด iterator() ซึ่งจะสงออปเจ็คของคลาสประเภท
Iterator กลับคืนมา อินเตอรเฟส Iterator จะมีเมธอดตางๆ ที่ใชในการเรียกดูขอมูล
ดังนี้
• boolean hasNext()

280 คณะเทคโนโลยีสารสนเทศ สถาบันเทคโนโลยีพระจอมเกลาเจาคุณทหารลาดกระบัง

 เปนเมธอดที่จะตรวจสอบวายังมีขอมูลอยูใน Iterator อีกหรือไม
• Object next()
เปนเมธอดที่จะเรียกดูคาของออปเจ็คของสมาชิกตัวถัดไปของ Iterator โดย
จะสงคากลับมาเปนออปเจ็คของคลาสที่ชื่อ Object
• void remove()
เปนเมธอดที่ใชในการลบสมาชิกตําแหนงปจจุบันออกจาก Iterator
โดยทั่วไปตําแหนงเริ่มตนของ Iterator จะชี้ไปที่ตําแหนงกอนสมาชิกของ
Iterator ตัวแรกและจะใชเมธอด next() ในการเรียกดูสมาชิกตัวตอๆไป โปรแกรมที่
8.12 แสดงตัวอยางการใชอินเตอรเฟส Iterator ในการเรียกดูขอมูลของสมาชิกของ
ออปเจ็คชนิด ArrayList โปรแกรมนี้จะใหผลลัพธดังแสดงในรูปที่ 8.16

โปรแกรมที่ 8.12 ตัวอยางการใชอินเตอรเฟส Iterator

import java.util.*;

public class SampleIterator {

public static void main(String args[]) {
Set scrSet = new HashSet();
scrSet.add("C#");
scrSet.add("Java");
scrSet.add("Pascal");
Iterator it = scrSet.iterator();
Set dstSet = new HashSet();
for(int i=0; i<scrSet.size(); i++) {
if(it.hasNext()) {
dstSet.add(it.next());
}
}
System.out.println(dstSet);
}
}

รูปที่ 8.16 ผลลัพธที่ไดจากการรันโปรแกรมที่ 8.12

Java Programming 281

 Collection API ยังมีอินเตอรเฟสประเภท Iterator ที่สําคัญอีกสองตัวคือ
ListIterator และ Enumeration อินเตอรเฟส ListIterator จะใชในการ
เรียกดูขอมูลของคอลเล็กชั่นประเภท List โดยมีเมธอดที่สําคัญที่เพิ่มมาจากเมธอดของ
อินเตอรเฟส Iterator ดังนี้
• boolean hasPrevious()
เปนเมธอดที่จะตรวจสอบวามีขอมูลในตําแหนงกอนหนานี้ใน ListIterator
หรือไม
• Object previous()
เปนเมธอดที่จะเรียกดูคาของออปเจ็คของสมาชิก ในตําแหนงกอนหนานี้ของ
ListIterator โดยจะสงคากลับมาเปนออปเจ็คของคลาสที่ชื่อ Object
• void add(Object element)
เปนเมธอดในการใสสมาชิกตัวใหมลงใน ListIterator
• void set(Object element)
เปนเมธอดที่ใชในการแทนคาสมาชิกของ ListIterator ในตําแหนงปจจุบัน
ดวยคาที่สงผานมาทาง argument
อินเตอรเฟส List จะมีเมธอด listIterator() ซึ่งเปนเมธอดที่สงคากลับ
เปนออปเจ็คประเภท ListIterator() เพื่อใชในการแจกแจงขอมูลของสมาชิกของ
คอลเล็กชั่นประเภท List
อินเตอรเฟส Enumeration จะมีลักษณะคลายกับอินเตอรเฟส Iterator
โดยจะใชในการแจกแจงของขอมูลของคอลเล็กชั่นตางๆ อินเตอรเฟสนี้จะมีเมธอดที่สําคัญสอง
เมธอดคือ
• boolean hasMoreElement()
เปนเมธอดที่ใชในการตรวจสอบวายังมีสมาชิกใน Enumeration อีกหรือไม
• Object nextElement()
เปนเมธอดที่ใชในการเรียกดูคาของสมาชิกใน Enumeration ที่อยูในตําแหนง
ถัดไป
โดยทั่วไปการเรียกดูคาของสมาชิกของออปเจ็คประเภท Enumeration จะมี
รูปแบบของคําสั่งดังนี้
while(e.hasMoreElements()){
System.out.print(e.nextElement()+" ");
}

282 คณะเทคโนโลยีสารสนเทศ สถาบันเทคโนโลยีพระจอมเกลาเจาคุณทหารลาดกระบัง

8.6.6 คลาส Vector
Vector เปนคลาสประเภทคอลเล็กชั่นที่กําหนดไวใน Collection API คลาส
Vector ใชเก็บกลุมของออปเจ็คของคลาสใดๆ โดยไมจํากัดจํานวน คลาส Vector เปน
คลาสที่ implements อินเตอรเฟส List เราสามารถสรางออปเจ็คของคลาส Vector
โดยเรียกใช constructor ในรูปแบบตางๆ ดังนี้
• Vector()
• Vector(int initialCapacity)
• Vector(int initialCapacity, int capacityIncrement)
โดยที่
• initialCapacity คือขนาดเริ่มตนของ Vector
• capacityIncrement คือขนาดที่จะเพิ่มขึ้นเมื่อ Vector มีขนาดเต็มแลว
โปรแกรมที่ 8.13 เปนตัวอยางการใชออปเจ็คของคลาส Vector และใชอินเตอรเฟส
Enumeration ในการเรียกดูขอมูล โปรแกรมนี้จะใหผลลัพธดังแสดงในรูปที่ 8.17

โปรแกรมที่ 8.13 ตัวอยางการใชออปเจ็คของคลาส Vector

import java.util.*;

public class SampleEnumeration {

public static void main(String args[]) {
Vector v = new Vector();
v.add("C#");
v.add("Java");
v.add("Pascal");
Enumeration e = v.elements();
while (e.hasMoreElements()) {
System.out.print(e.nextElement()+" ");

}
}
}

รูปที่ 8.17 ผลลัพธที่ไดจากการรันโปรแกรมที่ 8.13

Java Programming 283

 สรุปเนื้อหาของบท
• โดยทั่วไปโครงสรางขอมูลแบบอะเรยจะถูกนํามาใช เมื่อตองการเก็บขอมูลชนิด
เดียวกันหลายคา แตใชตัวแปรอะเรยตัวเดียวกัน
• อะเรยแบงออกไดเปน 2 ประเภท คืออะเรยของขอมูลชนิดพื้นฐาน และอะเรยของ
ขอมูลชนิดคลาสขั้นตอนในการสรางอะเรยของขอมูลชนิดพื้นฐานคือ การประกาศ
ตัวแปรอะเรย และการสรางอะเรย
• ขั้นตอนในการสรางอะเรยของขอมูลชนิดคลาสคือ การประกาศตัวแปรอะเรย การ
สรางอะเรย และการสรางออปเจ็คใหกับสมาชิกของอะเรยแตละตัว
• ขนาดของอะเรยสามารถหาไดจากคุณลักษณะ length
• คําสั่ง for นิยมนํามาใชในการอางถึงสมาชิกของอะเรย
• เราสามารถสรางอะเรยหลายมิติได โดยจํานวนเครื่องหมาย [ ] บงบอกถึงจํานวน
มิติของอะเรย
• สําหรับอะเรยสองมิติ จํานวนคอลัมนในแตละแถวไมจําเปนตองเทากัน
• ในคลาสที่ชื่อ Arrays มีเมธอดสําคัญที่เกี่ยวของกับอะเรยคือ sort(),
binarySearch() และ fill()

• เมธอด arraycopy() จากคลาส System ใชในการคัดลอกคาของสมาชิก

ของอะเรย
• Collection, Set, List และ Map เปนอินเตอรเฟสสําคัญที่อยูใน
Collection API โดยที่อินเตอรเฟส Set และ List สืบทอดมาจากอินเตอรเฟส
Collection
• อินเตอรเฟส Set จะไมสามารถมีคาขอมูลของสมาชิกที่ซ้ํากันได และไมมีลําดับ
ของสมาชิก
• สวนอินเตอรเฟส List จะสามารถมีคาขอมูลของสมาชิกที่ซ้ํากันได และมีลําดับ
ของสมาชิก
• สําหรับอินเตอรเฟส Map จะมีการเก็บคาคียคูกับคาขอมูลของสมาชิก โดยที่คาคีย
ของสมาชิกจะตองไมซ้ํากัน แตคาขอมูลของสมาชิกสามารถซ้ํากันได
• เราสามารถนําคลาสที่ implements อินเตอรเฟสเหลานี้ไปใชในการเก็บขอมูล
ที่เปนออปเจ็คไดหลายตัวคลายกับอะเรย แตสามารถเปลี่ยนแปลงขนาดได

284 คณะเทคโนโลยีสารสนเทศ สถาบันเทคโนโลยีพระจอมเกลาเจาคุณทหารลาดกระบัง

• อินเตอรเฟส Iterator,ListIterator และ Enumeration ใชในการ
อางถึงขอมูลสมาชิกของคลาสที่อยูใน Collection API
• คลาส Vector เปนคลาสที่ใชในการเก็บกลุมของออปเจ็คของคลาสใดๆโดยไม
จํากัดจํานวน

Java Programming 285

286 คณะเทคโนโลยีสารสนเทศ สถาบันเทคโนโลยีพระจอมเกลาเจาคุณทหารลาดกระบัง
 บทที่ 9
การจัดการกับขอผิดพลาด
เนื้อหาในบทนี้ เปนการแนะนําหลักการของการจัดการกับขอผิดพลาดในภาษาจาวา
แนะนําคลาสที่เกี่ยวของกับการจัดการกับขอผิดพลาดที่กําหนดไวใน Java API อธิบายคําสั่งที่
ใชในการจัดการกับขอผิดพลาดคือคําสั่ง try, catch และ finally อธิบายกฎการ
จัดการกับขอผิดพลาด และตอนทายของบทจะเปนการแนะนําการสรางคลาสประเภท
ขอผิดพลาดขึ้นมาใหม

9.1 ขอผิดพลาด
โปรแกรมภาษาจาวาอาจเกิดขอผิดพลาด (Exception) ขึ้นในขั้นตอนการรันโปรแกรม
โดยที่ขอผิดพลาดเหลานี้จะไมสามารถตรวจสอบไดในขั้นตอนการคอมไพลโปรแกรม ตัวอยาง
เชน คําสั่ง
offset = x/n;
สําหรับตัวแปรที่มีชนิดขอมูลเปน int ที่ชื่อ offset, x และ n จะเปนคําสั่งที่
สามารถคอมไพลผานได แตถาคาของ n เปนศูนย โปรแกรมนี้จะเกิดขอผิดพลาดขึ้นใน
ขั้นตอนการรันโปรแกรม ซึ่งโปรแกรมภาษาจาวาจะตรวจสอบพบขอผิดพลาดในการหารดวย
จํานวนเต็มศูนย และจะสงขอผิดพลาด (throwing an exception) ที่เกิดขึ้นกลับมา
โปรแกรมภาษาจาวาแบงขอผิดพลาดที่อาจเกิดขึ้นขณะรันโปรแกรมเปนสองประเภท
คือ
1. Error เปนขอผิดพลาดที่ไมสามารถแกไขและจัดการได เชน Virtual
MemoryError และ OutOfMemoryError เปนตน เราจะไมกลาวถึง
Error เนื่องจาก Error เปนขอผิดพลาดที่เราไมสามารถเขียนโปรแกรมเพื่อแกไข
และจัดการได
2. Exception เปนขอผิดพลาดที่สามารถแกไขและจัดการได เชน ขอผิดพลาด
จากการเปดไฟลที่ไมมีอยูในไดเร็กทอรี่ (FileNotFoundException)
หรือขอผิดพลาดจากการอางอิงหมายเลขของสมาชิกของอะเรยที่ไมถูกตอง คือ
ไมไดมีอยูจริง (ArrayIndexOutOfBoundsException)

Java Programming 287

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

รูปที่ 9.1 คลาสของขอผิดพลาดตางๆที่สืบทอดมาจากคลาสที่ชื่อ Throwable

9.1.1 Exception
คลาสที่ชื่อ Exception เปนคลาสที่กําหนดใน Java API เพื่อระบุขอผิดพลาดที่
เกิดขึ้นในขณะรันโปรแกรมภาษาจาวา Exception แบงออกเปนสองประเภทคือ
1. RuntimeException เปนขอผิดพลาดที่อาจหลีกเลี่ยงไดหากมีการเขียน
โปรแกรมที่ถูกตอง ตัวอยางเชน ArrayIndexOutOfBoundsException
ซึ่งเปนขอผิดพลาดเพราะมีการอางอิงสมาชิกของอะเรยที่ไมถูกตอง สามารถ
แกไขโปรแกรมใหดีขึ้นไดถามีการตรวจสอบหมายเลขสมาชิกของอะเรยกอนที่จะ
อางอิง โดยใชคําสั่ง if

288 คณะเทคโนโลยีสารสนเทศ สถาบันเทคโนโลยีพระจอมเกลาเจาคุณทหารลาดกระบัง

 2. IOException เปนขอผิดพลาดที่อาจจะไมสามารถแกไขโดยการปรับปรุง
โปรแกรมใหสมบูรณขึ้นได เชน UnknownHostException ที่อาจเกิดขึ้นใน
ขณะที่โปรแกรมกําลังพยายามติดตอกับระบบอินเตอรเน็ต แตเครื่อง
คอมพิวเตอรไมสามารถติดตอกับระบบเครือขายได ซึ่งขอผิดพลาดประเภทนี้ไม
สามารถตรวจสอบไดโดยใชคําสั่ง if แตการเรียกใชเมธอดที่อาจเกิด
ขอผิดพลาดประเภท IOException จะตองมีการเขียนคําสั่ง try/catch
ในการจัดการกับขอผิดพลาดที่เกิดขึ้น
คลาสประเภท Exception ที่สําคัญและพบบอยในโปรแกรมภาษาจาวามีดังนี้
• ArithmeticException
เปนการระบุวามีขอผิดพลาดในนิพจนคณิตศาสตรเชน การหารดวยเลขจํานวน
เต็มศูนย
• ArrayIndexOutOfBoundsException
เปนการระบุวามีการอางอิงสมาชิกของอะเรยไมถูกตอง (เปนเลขจํานวนเต็มลบ
หรือมีคามากกวาหมายเลขสมาชิกของอะเรยที่มีอยู)
• EOFException
เปนการระบุวาตําแหนงสิ้นสุดของไฟลไดผานมาแลว
• FileNotFoundException
เปนการระบุวาไมพบไฟลที่ตองการอางอิง
• InterruptedException
เปนการระบุวา process บาง process ถูกระงับ (interrupt)
• IOException
เปนการระบุขอผิดพลาดที่เกิดขึ้นจากขบวนการอินพุตหรือเอาทพุตใดๆ
• NullPointerException
เปนการระบุวามีการเรียกใชเมธอดของคลาสจากออปเจ็คที่ยังมีตําแหนงอางอิง
เปน null อยู (ออปเจ็คยังไมไดถูกสราง)
• NumberFormatException
เปนการระบุวารูปแบบของตัวเลขที่ใชอยูไมถูกตอง
โปรแกรมที่ 9.1 แสดงตัวอยางโปรแกรมที่เกิดขอผิดพลาดที่ชื่อ ArrayIndex
OutOfBoundsException แตเนื่องจากโปรแกรมนี้ไมมีการจัดการกับขอผิดพลาด
ดังกลาวจึงหยุดทํางานเมื่อพบขอผิดพลาดขณะรันโปรแกรม โดยจะใหผลลัพธดังแสดงในรูปที่
9.2

Java Programming 289

 โปรแกรมที่ 9.1 ตัวอยางแสดงขอผิดพลาดที่ชื่อ ArrayIndexOutOfBoundsException
public class ExceptionDemo {
public static void main(String args[]) {
System.out.println(args[2]);
System.out.println("Hello");
}
}

รูปที่ 9.2 ผลลัพธที่ไดจากการรันโปรแกรมที่ 9.1

9.2 คําสั่ง try..catch

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

try {
[statements]
}

โปรแกรมภาษาจาวาจะสั่งงานชุดคําสั่งที่อยูในบล็อกทีละคําสั่ง และหากเกิด
ขอผิดพลาดขึ้นในคําสั่งใดก็จะมีการสงออปเจ็คของขอผิดพลาดประเภท Exception นั้นขึ้นมา
ซึ่งโปรแกรมจะยกเลิกการทํางานคําสั่งที่อยูในบล็อกที่เหลือทั้งหมด แตหากทุกคําสั่งที่อยูใน
บล็อกไมมีขอผิดพลาดใดเกิดขึ้น โปรแกรมจาวาก็จะทํางานตอไปตามปกติเสมือนวาไมมี
คียเวิรด try อยู ในกรณีที่ตองการจัดการกับขอผิดพลาดที่เกิดขึ้น โปรแกรมจะตองมีชุดคําสั่ง
อยูในบล็อกของคียเวิรด catch ที่จะระบุชนิดของออปเจ็คในคลาสประเภท Exception ที่
ตองการจัดการโดยมีรูปแบบคําสั่งดังนี้

catch(ExceptionType argumentName){
[statements]
}

290 คณะเทคโนโลยีสารสนเทศ สถาบันเทคโนโลยีพระจอมเกลาเจาคุณทหารลาดกระบัง

 โดยที่
• ExceptionType คือชื่อคลาสประเภท Exception ที่ตองการจะจัดการเมื่อมี
ขอผิดพลาดเกิดขึ้น
• argumentName คือชื่อของออปเจ็คที่จะเปน argument ที่ใชในบล็อกคําสั่ง
ของ catch
โปรแกรมภาษาจาวาจะทําชุดคําสั่งในบล็อก catch ถามีคําสั่งในบล็อก try คําสั่ง
ใดคําสั่งหนึ่งเกิดขอผิดพลาดโดยสงออปเจ็คประเภท Exception ตามชนิดที่สอดคลองกับคลาส
ที่ระบุใน ExceptionType และโปรแกรมจะขามคําสั่งที่เหลืออยูในบล็อก try
ทั้งหมด สวนในกรณีที่ไมมีคําสั่งใดในบล็อก try เกิดขอผิดพลาดขึ้น โปรแกรมภาษาจาวาจะ
ไมมีการทําชุดคําสั่งในบล็อก catch โปรแกรมที่ 9.2 แสดงตัวอยางการจัดการกับขอผิดพลาด
ที่อาจเกิดขึ้นในโปรแกรมที่ 9.1 โดยโปรแกรมนี้ไดเพิ่มชุดคําสั่ง try และ catch ขึ้นมา ซึ่ง
โปรแกรมนี้จะใหผลลัพธดังแสดงในรูปที่ 9.3

โปรแกรมที่ 9.2 ตัวอยางการจัดการกับขอผิดพลาดที่อาจเกิดขึ้น

public class ExceptionHandlingDemo {

public static void main(String args[]) {
try {
System.out.println(args[2]);
} catch(ArrayIndexOutOfBoundsException ex) {
System.out.println("There is no third command
line argument");
}
}
}

รูปที่ 9.3 ผลลัพธที่ไดจากการรันโปรแกรมที่ 9.2

Java Programming 291

 9.2.1 การจัดการกับขอผิดพลาดหลายๆประเภท
โปรแกรมภาษาจาวาสามารถจะมีชุดคําสั่งของบล็อก catch ไดมากกวาหนึ่งชุด
สําหรับในแตละบล็อกคําสั่ง try โดยที่ชนิดของออปเจ็คประเภท Exception ที่อยูในชุดคําสั่ง
ของบล็อก catch จะตองเรียงตามลําดับการสืบทอด โปรแกรมที่ 9.3 แสดงตัวอยางการ
จัดการกับขอผิดพลาดมากกวาหนึ่งประเภท โดยมีชุดคําสั่งในบล็อก catch สองชุดเพื่อ
จัดการกับขอผิดพลาดสองชนิดคือ ArithmeticException และ ArrayIndexOutOf
BoundsException โปรแกรมนี้จะรับ argument ผานทาง command line ซึ่งจะเปนตัว
เลขที่มีชนิดขอมูลเปน String แลวจึงจะถูกแปลงใหมีชนิดขอมูลเปน int ซึ่งหากขอมูลเปน
จํานวนเต็มศูนยก็จะทําใหเกิดขอผิดพลาดชนิด ArithmeticException ขึ้นได โดย
โปรแกรมจะขามมาทําชุดคําสั่งในบล็อก catch ที่ตรวจจับออปเจ็คชนิดดังกลาว และ
โปรแกรมจะจัดการกับขอผิดพลาดชนิด NumberFormatException ถา argument ที่รับ
ผานทาง command line ไมใชขอความที่แปลงเปนตัวเลขจํานวนเต็มได โดยโปรแกรมจะขาม
มาทําชุดคําสั่งในบล็อก catch ที่ตรวจจับออปเจ็คชนิด NumberFormatException
โดยมีผลลัพธของโปรแกรมดังตัวอยางที่แสดงในรูปที่ 9.4
ในกรณีที่มีขอผิดพลาดเกิดขึ้น ภาษาจาวาจะพิจารณาวาเปนขอผิดพลาดชนิดใด ซึ่ง
การที่จะจัดการกับออปเจ็คประเภท Exception นั้นจะพิจารณาจากคลาสที่มีการสืบทอดตาม
ลําดับชั้น ทั้งนี้เราสามารถจะจัดการกับออปเจ็คประเภท Exception โดยใชคลาสที่เปน
superclass ของออปเจ็คนั้นได อาทิเชนออปเจ็คชนิด FileNotFoundException
สามารถจัดการไดโดยใชคลาส IOException หรือ Exception แทนไดเนื่องจากคลาส
FileNotFoundException สืบทอดมาจากคลาส IOException ซึ่งสืบทอดมาจาก
คลาส Exception อีกชั้นหนึ่ง

โปรแกรมที่ 9.3 ตัวอยางการจัดการกับขอผิดพลาดมากกวาหนึ่งประเภท

public class ExceptionHandlingDemoV2 {
public static void main(String args[]) {
try {
int i = Integer.parseInt(args[0]);
System.out.println(4 / i);
} catch(ArithmeticException ex) {
System.out.println(ex.toString());
} catch(NumberFormatException ex) {
System.out.println("Invalid numeric format");
}
}
}

292 คณะเทคโนโลยีสารสนเทศ สถาบันเทคโนโลยีพระจอมเกลาเจาคุณทหารลาดกระบัง

 รูปที่ 9.4 ผลลัพธที่ไดจากการรันโปรแกรมที่ 9.3

ภาษาจาวากําหนดใหชุดคําสั่งในบล็อก catch จะตองเรียงออปเจ็คของคลาส

ประเภท Exception ตามลําดับการสืบทอด ตัวอยางเชน โปรแกรมที่ 9.3 ถึงแมวาจะมี
คลาสประเภท Exception ที่จะตรวจจับสองชนิด แตเนื่องจากคลาสทั้งสองตางก็สืบทอดมาจาก
RunTimeException และอยูในลําดับชั้นเดียวกันจึงสามารถที่จะสลับชุดคําสั่งในบล็อก
catch ทั้งสองได แตในกรณีของโปรแกรมที่ 9.4 ชุดคําสั่งในบล็อก catch ที่จะจัดการกับ
คลาส RunTimeException อยูลําดับกอนหนาชุดคําสั่งในบล็อก catch ที่จะจัดการกับ
คลาส ArrayIndexOutOfBoundsException ดังนั้นโปรแกรมนี้จึงไมมีโอกาสที่จะทํา
ชุดคําสั่งที่สองไดเนื่องจากคลาส ArrayIndexOutOfBoundsException สืบทอดมา
จากคลาส RunTimeException จึงทําใหโปรแกรมนี้ไมสามารถคอมไพลผานได

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

public class ExceptionHandlingDemoV3 {
public static void main(String args[]) {
try {
int i = Integer.parseInt(args[0]);
System.out.println(4 / i);
System.out.println(args[2]);
} catch(RuntimeException ex) {
System.out.println(ex.toString());
} catch(ArrayIndexOutOfBoundsException ex) {
System.out.println("There is no third command
line argument");
}
}
}

Java Programming 293

 9.2.2 บล็อก finally
ภาษาจาวามีคียเวิรด finally ที่จะมีชุดคําสั่งอยูในบล็อกเพื่อระบุใหโปรแกรมทํา
ชุดคําสั่งดังกลาวหลังจากสิ้นสุดการทํางานของชุดคําสั่งในบล็อก try หรือ catch โปรแกรม
ที่ 9.5 แสดงตัวอยางการกําหนดชุดคําสั่งในบล็อก finally ซึ่งโปรแกรมนี้จะใหผลลัพธดัง
แสดงในรูปที่ 9.5
ภาษาจาวาจะทําชุดคําสั่งในบล็อก finally เสมอ แมวาจะมีคําสั่ง return ใน
บล็อก try หรือ catch กอนก็ตาม กรณีเดียวที่จะไมทําชุดคําสั่งในบล็อก finally คือมี
คําสั่ง System.exit(); เพื่อที่จะออกจากโปรแกรม โปรแกรมที่ 9.6 แสดงตัวอยางที่มี
คําสั่ง return อยูกอนชุดคําสั่งในบล็อก finally โดยโปรแกรมนี้จะไดผลลัพธดังรูปที่ 9.6

โปรแกรมที่ 9.5 ตัวอยางการกําหนดชุดคําสั่งในบล็อก finally

public class FinallyDemo {

public static void main(String args[]) {
try {
System.out.println(args[2]);
System.out.println("Hello");
} catch(ArrayIndexOutOfBoundsException ex) {
System.out.println("There is no third argument");
} finally {
System.out.println("Finish running the program");
}
}
}

294 คณะเทคโนโลยีสารสนเทศ สถาบันเทคโนโลยีพระจอมเกลาเจาคุณทหารลาดกระบัง

โปรแกรมที่ 9.6 ตัวอยางที่มีคําสั่ง return อยูกอนชุดคําสั่งในบล็อก finally
public class FinallyDemoV2 {
public static void main(String args[]) {
FinallyDemoV2 obj = new FinallyDemoV2();
obj.myMethod(args);
}
public int myMethod(String args[]) {
try {
System.out.println(args[2]);
return 0;
} catch(ArrayIndexOutOfBoundsException ex) {
System.out.println("There is no third argument");
} finally {
System.out.println("Finish running the program");
return 1;
}
}
}

รูปที่ 9.5 ผลลัพธที่ไดจากการรันโปรแกรมที่ 9.5

รูปที่ 9.6 ผลลัพธที่ไดจากการรันโปรแกรมที่ 9.6

9.3 การจัดการกับเมธอดที่สงออปเจ็คประเภท Exception

เมธอดบางเมธอดที่กําหนดใน Java API อาจสงออปเจ็คประเภท Exception เมื่อเกิด
ขอผิดพลาดขึ้นในการเรียกใชคําสั่ง อาทิเชน constructor ของคลาส FileInputStream

Java Programming 295

 อาจสงออปเจ็คของคลาส FileNotFoundException ถาไมพบไฟลดังกลาว หรือเมธอด
getLocalHost() ของคลาส InetAddress อาจสงออปเจ็คของคลาส
UnknownHostException ถาไมทราบ IP address ของเครื่อง ภาษาจาวากําหนดใหเรา
ตองเขียนโปรแกรมจัดการกับขอผิดพลาด เมื่อมีการเรียกใชเมธอดที่อาจสงออปเจ็คประเภท
IOException สําหรับเมธอด ซึ่งการจัดการกับขอผิดพลาดแบงออกเปน

1. ใชคําสั่ง try/catch ดังที่กลาวไวในหัวขอที่ผานมา

2. ใชคําสั่ง throws ในการประกาศเมธอดที่จะมีการเรียกใชเมธอดใดๆที่อาจสง
ออปเจ็คประเภท Exception ในกรณีนี้หมายความวาเมธอดที่ประกาศไมตองการ
จัดการกับออปเจ็คประเภท Exception ดังกลาวเอง แตตองการจะใหเมธอดอื่นๆ
ที่เรียกใชเมธอดนี้เปนตัวจัดการแทน รูปแบบการใชคําสั่ง throws มีดังนี้
[modifier] return_type methodName([arguments]) throws
ExceptionType[,ExceptionType2]{
...
}

ตัวอยางเชน
public void openFile(String s)throws FileNotFoundException {
}
เมธอดใดๆสามารถที่จะจัดการกับออปเจ็คประเภท Exception โดยใชคําสั่ง throws
ไดมากกวาหนึ่งชนิด ตัวอยางเชน
public void openFile(String s)throws FileNotFoundException,
UnknownHostException {
}
กรณีที่มีการใชคําสั่ง throws แลวสงตอใหเมธอดอื่นๆที่เรียกใชเปนตัวจัดการกับ
ออปเจ็คประเภท Exception ดังกลาวไปเรื่อยๆ แตถาเมธอดที่ชื่อ main() ซึ่งเรียกใช
เมธอดสุดทายที่ใชคําสั่ง throws ไมมีการจัดการกับออปเจ็คประเภท Exception ดังกลาว
โปรแกรมจะเกิดขอผิดพลาดในขั้นตอนการรันโปรแกรม เมือ่ มีขอผิดพลาดของออปเจ็คประเภท
Exception ดังกลาวเกิดขึ้น ตัวอยางเชนโปรแกรมที่ 9.7 ซึ่งผลลัพธที่ไดจากการรันเปนดังแสดง
ในรูปที่ 9.7

296 คณะเทคโนโลยีสารสนเทศ สถาบันเทคโนโลยีพระจอมเกลาเจาคุณทหารลาดกระบัง

โปรแกรมที่ 9.7 ตัวอยางที่ไมมีการจัดการกับออปเจ็คประเภท Exception
public class ExceptionDemo1 {
public static void main(String args[]) {
ExceptionDemo1 ex1 = new ExceptionDemo1();
ex1.method1();
}
public void method1() throws ArithmeticException {
method2();
}
public void method2() throws ArithmeticException {
System.out.println(2/0);
}
}

รูปที่ 9.7 ผลลัพธที่ไดจากการรันโปรแกรมที่ 9.7

เราสามารถที่จะใชคําสั่ง throws ในเมธอดที่ชื่อ main() ได แตจะเปนการ

ยกเลิกการจัดการใดๆกับขอผิดพลาดทั้งหมดที่อาจเกิดขึ้น นอกจากนี้ภาษาจาวาไมได
กําหนดใหเราจะตองเขียนคําสั่งในการจัดการกับเมธอด ที่อาจสงขอผิดพลาดของออปเจ็ค
ประเภท RuntimeException แตจะกําหนดไวเฉพาะเมธอดที่อาจสงขอผิดพลาดของ
ออปเจ็คประเภท IOException
เมธอดที่มีคําสั่ง throws จะมีผลตอการสืบทอด ทั้งนี้เนื่องจากกฎของการกําหนด
เมธอดแบบ overridden จะไมอนุญาตใหมีการจัดการออปเจ็คประเภท Exception โดยใช
คําสั่ง throws มากชนิดกวาที่เมธอดเดิมจัดการอยู โปรแกรมที่ 9.8 และโปรแกรมที่ 9.9
แสดงตัวอยางโปรแกรมที่มีเมธอดแบบ overridden ที่ถูกตองและไมถูกตองตามลําดับ

Java Programming 297

 โปรแกรมที่ 9.8 ตัวอยางที่มีเมธอดแบบ overridden ที่ถูกตอง

import java.io.*;

public class Parent {

public void myMethods() throws IOException { }
}

public class OverrideException extends Parent{

public void myMethods() throws IOException {
new FileInputStream("temp.txt");
}
}

โปรแกรมที่ 9.9 ตัวอยางที่มีเมธอดแบบ overridden ที่ไมถูกตอง

import java.io.*;

public class Parent {

public void myMethods() throws FileNotFoundException { }
}

public class OverrideExceptionV2 extends Parent{

public void myMethods() throws
FileNotFoundException,IOException {
new FileInputStream("temp.txt");
}
}

9.4 การสรางคลาสประเภท Exception ขึ้นใหม

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

298 คณะเทคโนโลยีสารสนเทศ สถาบันเทคโนโลยีพระจอมเกลาเจาคุณทหารลาดกระบัง

คลาสนั้นในกรณีที่เกิดขอผิดพลาดขึ้น หรือนิยามคลาสใดๆใหสืบทอดมาจากคลาส Runtime
Exception ในกรณีที่ไมตองการใหเมธอดใดๆจําเปนตองจัดการกับขอผิดพลาดดังกลาว

โดยทั่วไปคลาสที่ชื่อ Exception จะมี constructor สองรูปแบบคือ

- public Exception()
- public Exception(String s)
ดังนั้นคลาสที่สืบทอดมาจากคลาสที่ชื่อ Exception ควรจะมี constructor ทั้งสอง
โดยรูปแบบหนึ่งจะมี argument ที่มีชนิดขอมูลเปน String เพื่อรับขอความที่จะอธิบาย
ขอผิดพลาดและคําสั่งแรกใน constructor ดังกลาวควรเปนคําสั่ง super(s); เพื่อสง
ขอความดังกลาวใหกับ constructor ของ superclass (คลาสที่ชื่อ Exception) โปรแกรมที่
9.10 แสดงตัวอยางของคลาส MyOwnException ซึ่งเปนคลาสประเภท Exception ที่
กําหนดขึ้นใหม

โปรแกรมที่ 9.10 ตัวอยางคลาสประเภท Exception ที่กําหนดขึ้นใหม

public class MyOwnException extends Exception {
public MyOwnException (String s) {
super(s);
}
}

9.4.1 การเขียนเมธอดเพื่อสงออปเจ็คประเภท Exception

เมธอดที่ตองการสงออปเจ็คประเภท Exception เมื่อเกิดขอผิดพลาดขึ้นในคําสั่งใด
จะตองเรียกใชคําสั่งที่ชื่อ throw เพื่อจะสรางออปเจ็คของคลาสประเภท Exception ขึ้นมา
โดยมีรูปแบบคําสั่งดังนี้

throw new ExceptionType([arguments])

โดยที่
• ExceptionType คือชื่อของคลาสประเภท Exception ที่ตองการจะสราง
ออปเจ็คโดยมี argument สอดคลองกับที่ระบุใน constructor ของคลาสดังกลาว
นอกจากนี้คําสั่งประกาศเมธอดนั้นจะตองมีคําสั่ง throws เพื่อกําหนดใหคําสั่งใน
เมธอดอื่นๆที่เรียกใชเมธอดนี้ตองเขียนคําสั่งในการจัดการกับขอผิดพลาดนี้ โปรแกรมที่ 9.11

Java Programming 299

 แสดงตัวอยางการเขียนคลาส FileHandler โดยมีเมธอด openFile() ซึ่งจะสงออปเจ็ค
ของคลาส MyOwnException ขึ้นมาเมื่อไมพบไฟลที่ระบุ สวนโปรแกรมที่ 9.12 แสดง
ตัวอยางโปรแกรมที่มีการจัดการกับขอผิดพลาดดังกลาว

โปรแกรมที่ 9.11 ตัวอยางคลาส FileHandler

import java.io.*;

public class FileHandler {

public static void openFile(String filename) throws
MyOwnException {
File f = new File(filename);
if (!f.exists()) {
throw new MyOwnException("File Not Found");
}
}
}

โปรแกรมที่ 9.12 ตัวอยางที่มีการจัดการกับขอผิดพลาด

public class FileOpener {
public static void main(String args[]) {
try {
FileHandler.openFile(args[0]);
System.out.println("Open successful");
} catch (MyOwnException ex) {
System.out.println(ex);
}
}
}

สรุปเนื้อหาของบท
• ขอดีประการหนึ่งของภาษาจาวาคือ เราสามารถเขียนโปรแกรมใหมีการตรวจจับและ
จัดการกับขอผิดพลาดที่อาจเกิดขึ้นได โดยที่การทํางานไมตองหยุดลง
• Error เปนขอผิดพลาดที่ไมสามารถแกไขและจัดการได สวน Exception เปน
ขอผิดพลาดที่สามารถแกไขหรือจัดการได

300 คณะเทคโนโลยีสารสนเทศ สถาบันเทคโนโลยีพระจอมเกลาเจาคุณทหารลาดกระบัง

• คําสั่ง try และ catch เปนคําสั่งที่ใชในการตรวจจับและจัดการกับขอผิดพลาดที่
อาจเกิดขึ้นได โดยบล็อกคําสั่ง catch สามารถมีไดมากกวาหนึ่งบล็อกสําหรับในแต
ละบล็อกคําสั่ง try
• คําสั่ง finally เปนคําสั่งที่อยูตอจากคําสั่ง try/catch ถูกใชเมื่อมีบางคําสั่งที่
ตองการใหมีการทําเสมอ ยกเวนเจอคําสั่ง System.exit(0); กอนเทานั้น
• คําสั่ง throws จะใสไวตรงคําสั่งประกาศเมธอด สําหรับเมธอดที่ยังไมตองการ
จัดการกับขอผิดพลาดแตจะใหเมธอดที่เรียกใชเมธอดนี้เปนตัวจัดการแทน
• เราสามารถสรางคลาสประเภท Exception ชนิดใหมขึ้นได โดยจะตองสืบทอดมา
จากคลาส Exception และตองมีการเรียกใช constructor ของคลาส
Exception ดวย

Java Programming 301

302 คณะเทคโนโลยีสารสนเทศ สถาบันเทคโนโลยีพระจอมเกลาเจาคุณทหารลาดกระบัง
 บทที่ 10
โปรแกรมจาวาแอปเพล็ต
เนื้อหาในบทนี้เปนการแนะนําโปรแกรมจาวาแอปเพล็ต โดยแนะนําการเขียน
โปรแกรมจาวาแอปเพล็ตและตัวอยางไฟล HTML ที่มี tag ที่ชื่อ <APPLET> เพื่อเรียกใช
โปรแกรมจาวาแอปเพล็ต แนะนําคลาสที่ชื่อ Applet และคลาสที่ชื่อ Graphics และเมธอด
ที่สําคัญๆที่เกี่ยวของกับคลาสทั้งสอง แนะนําวิธีการเขียนโปรแกรมจาวาแอปเพล็ตเพื่อจัดการ
กับไฟลภาพและไฟลเสียง และตอนทายของบทเปนการแนะนําการเขียนโปรแกรมจาวา
แอปเพล็ตที่มีสวนติดตอกับผูใช

10.1 โปรแกรมจาวาแอปเพล็ต
โปรแกรมจาวาแอปเพล็ต (Java Applet) คือโปรแกรมภาษาจาวาที่สามารถทํางาน
ภายใตโปรแกรมเว็บบราวเซอร (Web Browser) ที่มี JVM อยู โปรแกรมจาวาแอปเพล็ตจะ
ประกอบดวยไฟลโปรแกรมสองไฟลคือ
- โปรแกรมภาษาจาวา (.java)
- โปรแกรมภาษา HTML (.html)
โปรแกรมที่ 10.1 เปนตัวอยางของโปรแกรมจาวาแอปเพล็ตเพื่อแสดงขอความ Hello
World โปรแกรมนี้จะแตกตางจากโปรแกรมจาวาประยุกตตรงที่ไมมีเมธอดที่ชื่อ main()
และจะไมสามารถทํางานตามลําพังได แตจะตองเรียกใชโดยผานโปรแกรมภาษา HTML
ตัวอยางเชนโปรแกรมที่ 10.2 เปนโปรแกรมภาษา HTML ที่เรียกใชโปรแกรม
HelloWorldApplet.class เพื่อประมวลผลภายใตโปรแกรมเว็บบราวเซอรที่มี JVMอยู

โปรแกรมที่ 10.1 โปรแกรมจาวาแอปเพล็ตเพื่อพิมพขอความ Hello World

import java.awt.*;
import java.applet.*;

public class HelloWorldApplet extends Applet {

public void paint(Graphics g) {
g.drawString("Hello World",20,20);
}
}

Java Programming 303

 โปรแกรมที่ 10.2 โปรแกรมภาษา HTML ที่เรียกใช HelloWorldApplet.class

<HTML>
<HEAD>
<TITLE>HelloWorld Example</TITLE>
</HEAD>
<BODY>
<APPLET CODE=”HelloWorldApplet.class”
WIDTH=”300” HEIGHT=”300”>
</APPLET>
</BODY>
</HTML>

โปรแกรมภาษา HTML จะมี tag ที่ชื่อ <APPLET> เพื่อใชในการระบุโปรแกรมไบท

โคดที่ไดมาจากการคอมไพลโปรแกรมจาวาแอปเพล็ตซึ่งภายใน tag นี้จะมีคุณลักษณะ
(attribute)ตางๆคือ ชื่อของโปรแกรมไบทโคด (.class)และขนาดของโปรแกรมแอปเพล็ตที่
ตองการจะแสดงบนเว็บเพจ
ขั้นตอนการพัฒนาโปรแกรมจาวาแอปเพล็ตที่แสดงในตัวอยางที่ผานมาจะมีดังนี้
1. เขียนโปรแกรมซอรดโคด (HelloWorldApplet.java) และโปรแกรม
เว็บเพจ (HelloWorld.html) โดยใชโปรแกรมอิดีเตอรใดๆ
2. คอมไพลโปรแกรม HelloWorldApplet.java โดยใชคอมไพเลอรดังนี้
javac HelloWorldApplet.java
ตัวอยางนี้จะไดโปรแกรมไบทโคดที่ชื่อ HelloWorldApplet.class
3. ใชโปรแกรมเว็บบราวเซอรใดๆเชน Internet Explorer หรือ Netscape เปด
โปรแกรมเว็บเพจที่ชื่อ HelloWorld.html ซึ่งจะเรียกโปรแกรมไบทโคดที่
ชื่อ HelloWorldApplet.class โดยอัตโนมัติและจะมีผลรันดังแสดงใน
รูปที่ 10.1

304 คณะเทคโนโลยีสารสนเทศ สถาบันเทคโนโลยีพระจอมเกลาเจาคุณทหารลาดกระบัง

 รูปที่ 10.1 ผลลัพธที่ไดจากการรันโปรแกรมที่ 10.2 บนเว็บบราวเซอร

การรันโปรแกรมจาวาแอปเพล็ตภายในโปรแกรมเว็บบราวเซอร จะมีขั้นตอนการ
ทํางานดังรูปที่ 8.2 โดยมีขั้นตอนการทํางานดังนี้
1. โปรแกรมเว็บบราวเซอรจะโหลด URL ตามตําแหนงที่ระบุ
2. โปรแกรมเว็บบราวเซอรจะโหลดไฟล HTML ที่ระบุและกระทําคําสั่ง tag ตางๆที่
ระบุในไฟล HTML
3. โปรแกรมเว็บบราวเซอรจะโหลดโปรแกรมโปรแกรมไบทโคด ที่เปนโปรแกรม
จาวาแอปเพล็ตที่ระบุใน tag ที่ชื่อ APPLET ตาม URL ที่ระบุ
4. โปรแกรมเว็บบราวเซอรจะรันโปรแกรมจาวาแอปเพล็ต
โปรแกรมเว็บบราวเซอรที่รันโปรแกรมจาวาแอปเพล็ตจะตองมี JVM อยูและเนื่องจาก
โปรแกรมเว็บบราวเซอรสามารถโหลดโปรแกรมจาวาแอปเพล็ต มาจากเครื่องคอมพิวเตอรแม
ขายอื่นๆได ดังนั้นภาษาจาวาจึงไดกําหนดระบบความปลอดภัยในการรันโปรแกรมจาวา
แอปเพล็ต เพื่อปองกันไมใหโปรแกรมจาวาแอปเพล็ตทํางานตางๆดังนี้
- อานหรือเขียนไฟลอื่นๆที่อยูในเครื่องที่รันโปรแกรมอยู

Java Programming 305

 - เรียกใชโปรแกรมอื่นๆที่อยูในเครื่องที่รันโปรแกรมอยู
- ติดตอกับเครื่องแมขายอื่น
- เรียกใช native method (คําสั่งเรียกเมธอดในโปรแกรมภาษาอื่น)
กรณีที่โปรแกรมภาษาจาวาแอปเพล็ตพยายามเรียกใชคําสั่งที่โปรแกรมเว็บบราวเซอร
ไมอนุญาตใหทําเหลานี้ โปรแกรมจะสงขอผิดพลาดที่ชื่อ SecurityException กลับมา

รูปที่ 8.2 การทํางานของโปรแกรมจาวาแอปเพล็ต

10.1.1 tag ที่ชื่อ <APPLET>

การรันโปรแกรมจาวาแอปเพล็ตจะตองมีการสรางไฟล HTML ซึ่งตองมี tag ที่ชื่อ
<APPLET> ซึ่งจะมีคุณลักษณะตางๆเพื่อระบุตําแหนงและชื่อของโปรแกรมไบทโคดของ
โปรแกรมจาวาแอปเพล็ต และรายละเอียดอื่นๆ โดยมีรูปแบบดังนี้

<APPLET code = filename.class width = widthPixels

height = heigthPixels [archive = archivefile]
[codeapplet = url] [vspace = vMargin]
[hspace = hMargin] [align = alignment]
[alt = text]>
[<PARAM name = attrl value = val1>
<PARAM name = attrN value = valN>]
</APPLET>

306 คณะเทคโนโลยีสารสนเทศ สถาบันเทคโนโลยีพระจอมเกลาเจาคุณทหารลาดกระบัง

 tag ที่ชื่อ <APPLET> จะมีคุณลักษณะที่ตองระบุสามอยางคือ
- code เพื่อระบุชื่อโปรแกรมไบทโคดของโปรแกรมจาวาแอปเพล็ต
- width เพื่อระบุความกวางของโปรแกรมแอปเพล็ตที่ตองแสดงบนเว็บเพจ
- height เพื่อระบุความสูงของโปรแกรมแอปเพล็ตที่ตองการแสดงบนเว็บเพจ

นอกจากนี้ยังมีคุณลักษณะอื่นๆที่เปนเงื่อนไขเพิ่มเติมดังนี้
• ALIGN เพื่อกําหนดการวางตําแหนงของโปรแกรมจาวาแอปเพล็ตเชน left,
right, top, textop, middle, absmiddle, baseline,
bottom และ absbottom เปนตน

• CODEBASE เพื่อระบุตําแหนงของ URL ที่เก็บโปรแกรมไบทโคดของโปรแกรม

จาวาแอปเพล็ต
• ARCHIVE เพื่อระบุคลาสหรือไฟลแบบ JAR ที่ตองการใหโหลดขึ้นมาไว
• ALT เพื่อระบุขอความที่ตองการใหเว็บเพจแสดงในกรณีที่ไมสามารถโหลด
โปรแกรมไบทโคดได
• VSPACE คือระยะหางทางแนวตั้งของโปรแกรมจาวาแอปเพล็ต
• HSPACE คือระยะหางทางแนวนอนของโปรแกรมจาวาแอปเพล็ต

10.1.2 การสงพารามิเตอร
คุณลักษณะที่ชื่อ PARAM จะใชในการสงผานพารามิเตอรไปยังโปรแกรมจาวา
แอปเพล็ตไดโดยมีรูปแบบดังนี้

<PARAM name = attr1 VALUE = val1>

โดยที่
- attr1 คือชื่อของพารามิเตอรที่จะปรากฏอยูในโปรแกรมจาวาแอปเพล็ต
- val1 คือคาของพารามิเตอรที่จะสงใหกับโปรแกรมจาวาแอปเพล็ต
ตัวอยางเชน
<PARAM name = speed VALUE = “25”>

Java Programming 307

 โปรแกรมจาวาแอปเพล็ตสามารถเรียกดูคาพารามิเตอร ที่จะสงผานมาจากโปรแกรม
.html โดยใชคุณลักษณะใน tag ที่ชื่อ APPLET นีไ้ ด โดยใชเมธอดที่ชื่อ
getParameter() ที่มีรูปแบบเปน

String getParameter(String paramName)

โดยที่
paramName คือชื่อพารามิเตอร
เมธอดนี้จะสงคาเปนชนิดขอมูลแบบ String คืนมาโดยจะเปนคาที่อยูใน
<PARAM> ที่ชื่อ VALUE คาที่สงกลับมาจะเปน case-sensitive แตชื่อพารามิเตอรจะไมใช
case-sensitive
ตัวอยางเชน
getParameter(“SPEED”)
จะให ค า กลั บ มาเป น “25” ตามที่ ร ะบุ ไ ว ใ นตั ว อย า งของ <PARAM> ข า งต น
ในกรณีที่ไมพบพารามิเตอรตามชื่อที่ระบุใน tag ที่ชื่อ <APPLET> คาที่ไดกลับมาจะมีคาเปน
null

10.2 คลาส Applet

Applet เปนคลาสที่กําหนดไวใน Java API ที่อยูในแพคเก็จ java.applet
โปรแกรมจาวาแอปเพล็ตทุกโปรแกรมจะตองสืบทอดมาจากคลาสนี้โดยใชคําสั่ง extends
Applet คลาสที่ชื่อ Applet จัดเปนคลาสประเภท Container ที่สืบทอดมาจากคลาสที่
ชื่อ Panel โดยมีการจัดวางผังเปนแบบ FlowLayout คลาสที่ชื่อ Applet จึงสามารถที่จะ
ใสออปเจ็คที่เปนสวนประกอบกราฟฟกของแพคเก็จ AWT ได ในกรณีที่ตองการใช
สวนประกอบกราฟฟกของแพคเก็จ javax.swing โปรแกรมจาวาแอปเพล็ตจะตองสืบทอด
มาจากคลาสที่ชื่อ JApplet แตเนื้อหาในบทนี้จะกลาวถึงคลาสที่ชื่อ Applet สวนการพัฒนา
โปรแกรมโดยใชคลาสที่ชื่อ JApplet จะมีหลักการคลายกัน
โปรแกรมจาวาแอปเพล็ตจะแตกตางจากโปรแกรมจาวาประยุกต ตรงที่ไมมีเมธอดที่
ชื่อ main() แตโปรแกรมเว็บบราวเซอรจะรันโปรแกรมจาวาแอปเพล็ตโดยพิจารณาจาก
เมธอดที่อยูในโปรแกรมซึ่งเปนเมธอดของคลาสที่ชื่อ Applet 5 เมธอดคือ init(),
start(), stop(), destroy() และ paint() โดยมีหลักการทํางานดังแสดงในรูป
ที่ 10.2

308 คณะเทคโนโลยีสารสนเทศ สถาบันเทคโนโลยีพระจอมเกลาเจาคุณทหารลาดกระบัง

เมธอด init()
เมธอดนี้จะถูกเรียกเพียงครั้งเดียวเมื่อมีการโหลดโปรแกรมจาวาแอปเพล็ต หรือเมื่อมี
การรีโหลด (reload) โปรแกรมเว็บบราวเซอร โดยทั่วไปโปรแกรมจาวาแอปเพล็ตจะ override
เมธอดนี้ในกรณีที่ตองมีคําสั่งที่ตองทําเริ่มตนเชน การกําหนดคาเริ่มตนหรือการโหลดรูปภาพ
เปนตน

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

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

เมธอด destroy()
เมธอดนี้จะถูกเรียกครั้งเดียวเมื่อมีการปดเว็บบราวเซอร โดยทั่วไปโปรแกรมจาวา
แอปเพล็ตจะไม override เมธอดนี้ยกเวนจะตองการลบขอมูลในหนวยความจําบางอยางเชน
โปรแกรมแบบเธรดที่สรางขึ้น

เมธอด paint()
เมธอด paint() จะเปนเมธอดที่มีคําสั่งที่เกี่ยวของกับการวาดรูปกราฟฟกตางๆ
โดยเมธอด paint() มีรูปแบบดังนี้

Java Programming 309

 public void paint(Graphics g) {
[statements]
}

โดยที่
• g คือออปเจ็คของคลาส Graphics ที่สามารถใชในการวาดรูปกราฟฟกตางๆ
• statements คือคําสั่งในการวาดรูปกราฟฟกตางๆ

คําสั่งในเมธอด paint() จะถูกเรียกใชงานหลังจากการทําคําสั่งในเมธอด

start()ทําใหสามารถที่จะเขียนรูปทรงหรือขอความที่เปนกราฟฟกได นอกจากนี้เมธอด
paint() จะถูกเรียกซ้ําทุกครั้งที่เว็บบราวเซอรมีการเปลี่ยนแปลงเชน การปรับขนาดหรือมี
การเคลื่อนที่

รูปที่ 10.2 หลักการทํางานของเมธอดในโปรแกรมจาวาแอปเพล็ต

10.3 คลาส Graphics

การสรางภาพกราฟฟกในโปรแกรมจาวาแอปเพล็ต จะทําไดโดยการ override เมธอด
paint() แลวเขียนคําสั่งในการวาดรูปทรงกราฟฟกตางๆในเมธอด ตัวอยางเชน โปรแกรมที่
10.3 แสดงตัวอยางของคลาส MyApplet ซึ่งจะลากเสนตรงจากพิกัด (10,10) ไปยังพิกัด
(100,100) ซึ่งโปรแกรมนี้จะไดผลลัพธดังแสดงในรูปที่ 10.3

310 คณะเทคโนโลยีสารสนเทศ สถาบันเทคโนโลยีพระจอมเกลาเจาคุณทหารลาดกระบัง

โปรแกรมที่ 10.3 คลาส MyApplet ที่ใชในการลากเสนตรง

import java.awt.*;
import java.applet.*;

public class MyApplet extends Applet {

public void paint(Graphics g) {
g.drawLine(10,10,100,100);
}
}

รูปที่ 10.3 ผลลัพธที่ไดจากการรันโปรแกรมที่ 10.3

10.3.1 เมธอดในการวาดรูปทรงตางๆ
คลาสที่ชื่อ Graphics จะมีเมธอดในการวาดรูปทรงกราฟฟกตางๆหลายเมธอด
ดังนี้
• drawLine(int x1, int y1, int x2, int y2)
เปนเมธอดที่ใชในการวาดเสนตรงจากพิกัด (x1,y1)ไปยังพิกัด (x2,y2)
• drawRect(int x, int y, int width, int height)
เปนเมธอดที่ใชในการวาดสี่เหลี่ยมผืนผา โดยจะมีตําแหนงเริ่มตนที่พิกัด (x,y)
ซึ่งมีความกวางและความสูงเปน width และ height ตามลําดับ
• fillRect(int x, int y, int width, int height)
เปนเมธอดที่ใชในการวาดสี่เหลี่ยมผืนผา เชนเดียวกับเมธอด drawRect() แต
จะมีสีเติมเต็มในสี่เหลี่ยมผืนผา

Java Programming 311

 • drawRoundRect(int x, int y, int width, int height,
int arcWidth, int arcHieght)

• fillRoundRect(int x, int y, int width, int height,

int arcWidth, int arcHieght)
เมธอดทั้งสองเมธอดนี้เปนเมธอดที่ใชในการวาดสี่เหลี่ยมผืนผามุมมน (round-
edged rectangle) โดยจะมีรัศมีความโคงเปน arcWidth และ arcHieght
ในแกนนอนและแกนตั้งตามลําดับ โดยเมธอด fillRoundRect() จะเปน
การวาดสี่เหลี่ยมผืนผามุมมนที่มีสีเติมเต็ม
• drawOval(int x, int y, int width, int height)

• fillOval(int x, int y, int width, int height)

เมธอดทั้งสองเมธอดนี้ เปนเมธอดที่ใชในการวาดรูปวงรีที่มีมุมซายบนอยูที่
ตําแหนงพิกัด(x,y)โดยมีความกวางและความสูงเปน width และ heigth
ตามลําดับ สวนเมธอด fillOval() จะมีสีเติมเต็มในวงรี
• drawArc(int x, int y, int width, int height, int
startAngle, int arcAngle)

• fillArc(int x, int y, int width, int height, int

startAngle, int arcAngle)
เมธอดทั้งสองเมธอดนี้เปนเมธอดที่ใชในการวาดเสนโคง (arc) ที่มีมุมซายบนอยูที่
ตําแหนงพิกัด (x,y) มีความกวางเปน width มีความสูงเปน height เริ่ม
วาดจากมุม startAngle องศา ไปจํานวน arcAngle องศา สวนเมธอด
fillArc() จะมีสีเติมเต็มในเสนโคง

• drawPolygon(int []x, int []y, int numPoints)

• fillPolygon(int []x, int []y, int numPoints)

• drawPolyline(int []x, int []y, int numPoints)

เมธอดทั้งสามเมธอดนี้เปนเมธอดที่ใชในการวาดรูปหลายเหลี่ยม (polygon) โดย
จะมีตําแหนงของมุม numPoints ตําแหนง ซึ่งจะมีตําแหนงมุมอยูในพิกัดที่เปน
ตัวแปรอะเรยที่ชื่อ x และ y เมธอด fillPolygon()จะมีสีเติมเต็มในรูป
หลายเหลี่ยม สวนเมธอด drawPolyline()จะเปนเสนหลายเหลี่ยมเปด
• drawString(String s, int x, int y)
เปนเมธอดนี้ใชในการแสดงขอความของตัวแปรที่ชื่อ s ที่ตําแหนงพิกัด (x,y)

312 คณะเทคโนโลยีสารสนเทศ สถาบันเทคโนโลยีพระจอมเกลาเจาคุณทหารลาดกระบัง

 โปรแกรมที่ 10.4 แสดงตัวอยางของโปรแกรม GUI ที่วาดรูปทรงตางๆ โดยโปรแกรม
นี้จะใหผลลัพธดังแสดงในรูปที่ 10.4

โปรแกรมที่ 10.4 ตัวอยางการใชเมธอดในคลาส Graphics การวาดรูปทรงตางๆ

import java.awt.*;
import java.applet.*;

public class GUIApplet extends Applet {

public void paint(Graphics g) {
g.drawRect(5,5,15,15);
g.fillOval(50,50,20,20);
g.drawArc(75,25,40,40,0,135);
g.fillArc(80,80,30,30,90,270);
g.drawString("Hello",5,90);
}
}

รูปที่ 10.4 ผลลัพธที่ไดจากการรันโปรแกรมที่ 10.4

10.3.2 เมธอดที่ใชในการจัดการคุณลักษณะของกราฟฟก
ออปเจ็คของคลาสที่ชื่อ Graphics มีคุณลักษณะตางๆของรูปทรงกราฟฟกที่วาด
เชน สีของพื้นหนา (Foreground) ลักษณะของเสน และรูปแบบของฟอนต เราสามารถที่จะ
กําหนดคุณลักษณะตางๆเหลานี้ได โดยเรียกใชเมธอดตางๆของคลาสดังนี้

Java Programming 313

 • การกําหนดสี
เมธอด setColor() เปนเมธอดที่ใชในการกําหนดสีจะใชในการวาดรูปทรง
ของออปเจ็คของคลาส Graphics โดยมีรูปแบบดังนี้
setColor(Color c)
โดยที่ออปเจ็คที่ชื่อ c เปนออปเจ็คของคลาส Color ซึ่ง Java API จะนิยามสีที่
เปนสีหลักไวอยูแลว เชน Color.red คือสีแดง หรือ Color.pink คือสี
ชมพู เปนตน ตัวอยางเชนคําสั่ง
g.setColor(Color.red);
เปนการกําหนดรูปทรงทางกราฟฟกใหถูกวาดดวยสีแดง
• การกําหนด Font
เมธอด setFont() เปนเมธอดที่ใชในการกําหนดฟอนตที่เขียนขอความลงใน
ออปเจ็คของคลาส Graphics โดยมีรูปแบบดังนี้
setFont(Font f)
โดยที่คลาส Font จะมี constructor ในการสรางออปเจ็คดังนี้
Font(String s, int style, int size)
ตัวอยางเชนคําสั่ง
Font fn1 = new Font(“Courier New”,Font.BOLD,24);
g.setFont(fn1);
เปนการกําหนดใหขอความในออปเจ็คของคลาส Graphics ที่ชื่อ g มีฟอนต
เปน Courier New ที่เปนตัวเขมขนาด 24
โปรแกรมที่ 10.5 แสดงตัวอยางโปรแกรม GUI ที่มีขอความเขียนดวยสีและฟอนต
ตางๆ ซึ่งโปรแกรมนี้จะใหผลลัพธดังแสดงในรูปที่ 10.5

เมธอด repaint()
โปรแกรม GUI จะมีโปรแกรมแบบเธรดที่เรียกวา AWTThread ที่เปนโปรแกรมที่
ประมวลผลพรอมกัน ซึ่งจะทําหนาที่คอยตรวจสอบวา จะตองมีการเรียกใชเมธอด paint()
เพื่อวาดรูปทรงกราฟฟกตามคําสั่งที่ระบุใหแสดงบนออปเจ็คประเภท Container (เชน
Applet) ใหมหรือไม ซึ่งโปรแกรม AWTThread จะเรียกใชเมธอด paint() ใหมในกรณี
ตางๆอาทิเชน
• เมื่อมีการโหลดออปเจ็คของคลาสประเภท Container เพื่อแสดงผลครั้งแรก
• เมื่อโปรแกรมเปลี่ยนจากไอคอนกลับมาเปนโปรแกรมที่แสดงผลตามหนาจอปกติ

314 คณะเทคโนโลยีสารสนเทศ สถาบันเทคโนโลยีพระจอมเกลาเจาคุณทหารลาดกระบัง

 • เมื่อโปรแกรมเว็บบราวเซอร กลับมาแสดงเว็บเพจหนาที่มีโปรแกรมจาวา
แอปเพล็ตอยู

โปรแกรมที่ 10.5 ตัวอยางโปรแกรม GUI ที่มีขอความเขียนดวยสีและฟอนตตางๆ

import java.awt.*;
import java.applet.*;
public class ColFontApplet extends Applet {
public void paint(Graphics g) {
g.setColor(Color.red);
g.fillOval(10,10,40,10);
g.setColor(Color.pink);
g.fillArc(95,50,30,30,0,210);
g.setColor(Color.black);
Font fn1 = new Font("Courier New",Font.BOLD,24);
g.setFont(fn1);
g.drawString("Font",5,95);
}
}

รูปที่ 10.5 ผลลัพธที่ไดจากการรันโปรแกรมที่ 10.5

โปรแกรม AWTThread จะเรียกใชเมธอด repaint() เมื่อตองการวาดรูปทรง

กราฟฟกใหม ซึ่งเมธอด repaint() จะเรียกใชเมธอด update() อีกตอหนึ่ง
ดังแสดงในรูปที่ 10.6

Java Programming 315

 รูปที่ 10.6 การเรียกใชเมธอดตางๆของโปรแกรม AWTThread

โดยทั่วไปเมธอด update() จะมีคําสั่งในการลบภาพกราฟฟกเดิมและเรียกใช

เมธอดที่ชื่อ paint() โดยมีรูปแบบดังนี้
public void update(Graphics g){
g.clearRect(0, 0, width, height);
paint(g);
}
เราสามารถที่จะ override เมธอด update()ใหม เพื่อไมใหมีการลบภาพกราฟฟก
เดิมได โดยกําหนดรูปแบบคําสั่งดังนี้
public void update(Graphics g){
paint(g);
}

10.4 คําสั่งดาน Multimedia

โปรแกรมจาวาแอปเพล็ตสามารถที่จะแสดงรูปภาพที่อยูฟอรแมตตางๆเชน GIF หรือ
JPG ได และสามารถที่จะเลนไฟลเสียงไดโดยมีคลาสที่สําคัญสองคลาสคือ
• คลาส Image ซึ่งเปนคลาสที่ใชในการสรางออปเจ็คเพื่อจัดการกับไฟลรูปภาพ
• คลาส AudioClip ซึ่งเปนคลาสที่ใชในการสรางออปเจ็คเพื่อจัดการกับไฟล
เสียง

316 คณะเทคโนโลยีสารสนเทศ สถาบันเทคโนโลยีพระจอมเกลาเจาคุณทหารลาดกระบัง

10.4.1 คลาส Image
โปรแกรมจาวาแอปเพล็ตสามารถสรางออปเจ็คของคลาส Image ไดโดยเรียกใช
เมธอด getImage() ที่อยูในคลาสที่ชื่อ Applet ซึ่งมีรูปแบบดังนี้
• Image getImage(URL u)

• Image getImage(URL u, string name)

โดยที่
• URL เปนคลาสที่ใชสรางออปเจ็คเพื่อระบุตําแหนง URL ของรูปภาพอาทิเชน
URL u = new URL(“http://java.sun.com”)
• name คือชื่อของไฟลรูปภาพที่มีฟอรแมตเปน GIF หรือ JPG
ในกรณีที่ตําแหนงของไฟลรูปภาพมี URL เดียวกับตําแหนงของโปรแกรมเว็บเพจ
เราสามารถเรียกใชเมธอดที่ชื่อ getDocumentBase() เพื่อระบุ URL ดังกลาวอาทิเชน
Image cat = getImage(getDocumentBase(),“cat.gif”)
สวนในกรณีที่ตําแหนงของไฟลรูปภาพมี URL ตรงกับตําแหนงของโปรแกรมไบทโคด
ของโปรแกรมจาวาแอปเพล็ต เราสามารถเรียกใชเมธอดที่ชื่อ getCodeBase() เพื่อระบุ
URL ดังกลาวอาทิเชน
Image cat = getImage(getCodeBase(), “cat.gif”)
การแสดงรูปภาพที่อยูในออปเจ็คของคลาส Image จะทําไดโดยเรียกใชเมธอดที่ชื่อ
drawImage() ที่อยูในคลาสที่ชื่อ Graphic ซึ่งมีรูปแบบดังนี้
drawImage(Image im, int x, int y, ImageObserver ob)
โดยที่
- im คือชื่อออปเจ็คของคลาส Image ที่ตองการแสดง
- x และ y คือตําแหนงพิกัดที่ตองการแสดง
- ob คือออปเจ็คของคลาสที่ implements อินเตอรเฟส ImageObserver
ที่ใชระบุการเปลี่ยนแปลงสถานะของรูปภาพ ซึ่งคลาส Applet ได
implements อินเตอรเฟสดังกลาวไว เราจึงสามารถมี argument โดยใช
ออปเจ็คที่ชื่อ this ได
โปรแกรมที่ 10.6 แสดงตัวอยางของโปรแกรมจาวาแอปเพล็ตที่มีการแสดงรูปภาพที่
ชื่อ duke.gif ซึ่งเก็บอยูในตําแหนงเดียวกับโปรแกรม .html

Java Programming 317

 โปรแกรมที่ 10.6 ตัวอยางของโปรแกรมจาวาแอปเพล็ตที่มีการแสดงรูปภาพ

import java.awt.*;
import java.applet.*;

public class ImageDemo extends Applet{

Image im;
public void init() {
im = getImage(getDocumentBase(), "duke.gif");
}
public void paint(Graphics g){
g.drawImage(im, 20, 20, this);
}
}

10.4.2 คลาส AudioClip

โปรแกรมจาวาแอปเพล็ตสามารถสรางออปเจ็คของคลาส AudioClip ไดโดยใช
เมธอด getAudioClip() ซึ่งมีรูปแบบดังนี้
• AudioClip getAudioClip(URL u)

• AudioClip getAudioClip(URL u, String name)

โดยที่
name คือชื่อของไฟลเสียงที่มีฟอรแมตเปน au
คลาส AudioClip จะมีเมธอดที่เกี่ยวของกับการเลนเสียงดังนี้
- play() คือเมธอดที่ใชในการเลนเสียง

- loop() คือเมธอดที่ใชในการเลนเสียงแบบวนรอบ

- stop() คือเมธอดที่ใชในการหยุดการเลนเสียง

นอกจากนี้คลาส Applet ยังมีเมธอด play() ที่สนับสนุนการเลนไฟลเสียงโดย

ไมจําเปนตองสรางออปเจ็คของคลาส AudioClip โดยมีรูปแบบดังนี้
- play(URL u)

- play(URL u, string name)

318 คณะเทคโนโลยีสารสนเทศ สถาบันเทคโนโลยีพระจอมเกลาเจาคุณทหารลาดกระบัง

 โปรแกรมที่ 10.7 แสดงตัวอยางโปรแกรมจาวาแอปเพล็ตที่จะเลนไฟลเสียงอยาง
วนรอบ และจะหยุดเลนเมื่อออกจากเว็บเพจหนาที่มีโปรแกรมจาวาแอปเพล็ตอยู

โปรแกรมที่ 10.7 ตัวอยางโปรแกรมจาวาแอปเพล็ตที่มีการเลนไฟลเสียง

import java.awt.*;
import java.applet.*;

public class MusicDemo extends Applet{

AudioClip sound;
public void init() {
sound = getAudioClip(getDocumentBase(),
"spacemusic.au");
}
public void paint(Graphics g){
sound.loop();
}
public void stop() {
sound.stop();
}
}

10.5 โปรแกรมจาวาแอปเพล็ตที่โตตอบกับผูใช
คลาสที่ชื่อ Applet เปนคลาสประเภท Container และสามารถที่จะรับฟง
เหตุการณทางกราฟฟกตางๆไดอาทิเชน ActionListener, MouseListener,
MouseMotionListener, KeyListener, และ FocusListener เปนตน
ดังนั้นเราจึงสามารถที่จะเขียนโปรแกรมจาวาแอปเพล็ตเพื่อโตตอบกับผูใชได
โปรแกรมที่ 10.8 แสดงตัวอยางของโปรแกรมจาวาแอปเพล็ตที่มีออปเจ็คของคลาสที่
เปนสวนประกอบกราฟฟกอื่นๆ โดยมีปุมสองปุมเพื่อทําหนาที่เลนและหยุดไฟลเพลงที่โหลด
เขามาในโปรแกรม

Java Programming 319

 โปรแกรมที่ 10.8 ตัวอยางของโปรแกรมจาวาแอปเพล็ตที่มีสวนติดตอกับผูใช

import java.awt.*;
import java.awt.event.*;
import java.applet.*;

public class MusicGUI extends Applet implements

ActionListener{

AudioClip sound;
Button bn1, bn2;
public void init() {
sound = getAudioClip(getDocumentBase(),
"spacemusic.au");
bn1 = new Button("PLAY");
bn2 = new Button("STOP");
add(bn1);
add(bn2);
bn1.addActionListener(this);
bn2.addActionListener(this);
bn1.setEnabled(true);
bn2.setEnabled(false);
}

public void stop() {

sound.stop();
}

public void actionPerformed(ActionEvent ev) {

String cmd = ev.getActionCommand();
if (cmd.equals("PLAY")) {
sound.loop();
bn2.setEnabled(true);
bn1.setEnabled(false);
} else if (cmd.equals("STOP")) {
sound.stop();
bn2.setEnabled(false);
bn1.setEnabled(true);
}
}
}

320 คณะเทคโนโลยีสารสนเทศ สถาบันเทคโนโลยีพระจอมเกลาเจาคุณทหารลาดกระบัง

สรุปเนื้อหาของบท
• โปรแกรมจาวาแอปเพล็ตสามารถรันภายใตเว็บบราวเซอรได โดยจะตองระบุชื่อ
โปรแกรมไวภายใน tag <APPLET> ในไฟล HTML

• โปรแกรมจาวาแอปเพล็ตทุกโปรแกรมจะตองสืบทอดมาจากคลาสที่ชื่อ Applet
โดยใชคําสั่ง extends Applet และจะเริ่มตนทํางานที่เมธอด init()

• คลาส Applet มีเมธอดที่สําคัญคือเมธอด init(), start(), stop(),

destroy() และ paint()

• เมธอดของคลาสที่ชื่อ Graphics สามารถนําไปใชในการวาดรูปกราฟฟกตางๆได

เชน drawLine(), drawPolyline(), drawRect() และ
fillRect() เปนตน

• เมธอดที่รับ argument เขามาเปนออปเจ็คของคลาส Graphics คือเมธอด

paint() และ update()

• คลาสที่ชื่อ Image เปนคลาสที่เก็บออปเจ็คของไฟลภาพ

• คลาสที่ชื่อ AudioClip เปนคลาสที่เก็บออปเจ็คของไฟลเสียง

• Applet สามารถที่จะรับฟงเหตุการณทางกราฟฟกตางๆได อาทิเชน

ActionListener, MouseListener และ KeyListener เปนตน

Java Programming 321

322 คณะเทคโนโลยีสารสนเทศ สถาบันเทคโนโลยีพระจอมเกลาเจาคุณทหารลาดกระบัง
 บทที่ 11
คลาสอินพุตและเอาทพตุ
เนื้อหาในบทนี้เปนการแนะนําคลาสและเมธอดตางๆ ที่เกี่ยวกับอินพุตและเอาทพุต
และอธิบายความหมายของ stream โดยอธิบายคลาสที่เกี่ยวของกับอินพุตและเอาทพุตที่อยู
ในแพคเก็จ java.io แนะนําคลาส InputStream, OutputStream, Reader และ
Writer อธิบายการสรางและใช stream แบบตางๆ แนะนําคลาสและเมธอดของคลาส
File และ RandomAccessFile อธิบายการใชอินเตอรเฟสที่ชื่อ Serializable และ
อธิบายวิธีการเขียนและอานขอมูลของออปเจ็คผาน stream

11.1 Stream
ภาษาจาวาจัดการกับขบวนการอินพุตและเอาทพุตโดยใชหลักการของ stream ซึ่ง
เปรียบเสมือนทอสงขอมูลจากตนทาง (source) ไปยังปลายทาง (sink) โดยที่ตนทางเปน
ตําแหนงเริ่มตนของ stream ที่เรียกวา input stream และปลายทางเปนตําแหนงสิ้นสุดของ
stream ที่เรียกวา output stream ดังแสดงในรูปที่ 11.1 stream จะชวยใหนักพัฒนาโปรแกรม
สามารถที่เขียนโปรแกรมเพื่อสงขอมูลจากตนทางไปยังปลายทางได โดยไมจําเปนตองทราบ
รายละเอียดภายในของการติดตอกับฮารดแวรหรือซอฟตแวรที่ในการสงขอมูล ซึ่งสามารถ
เขียนโปรแกรมไดโดยเพียงแตรูเมธอดที่ใชในการรับหรือสงขอมูลเทานั้น

รูปที่ 11.1 หลักการของ stream

ตนทางและปลายทางของ stream อาจเปนฮารดแวรหรือซอฟตแวร โดยจะเรียกวา

โหนด (node) เชน ไฟล หนวยความจํา หรือ socket เปนตน ซึ่งตนทางและปลายทางอาจมี
ชนิดของโหนดที่ตางกัน อาทิเชน การอานขอมูลจากตัวแปรที่เก็บในหนวยความจําที่เปนตน
ทางผาน stream ลงไปเก็บไวในไฟลที่เปนปลายทาง

Java Programming 323

 stream ที่ใชในการสงขอมูลของภาษาจาวาจะแบงออกเปนสองประเภทคือ
- byte stream เปน stream ที่ใชในการรับหรือสงขอมูลชนิด byte
- character stream เปน stream ที่ใชในการรับหรือสงขอมูลชนิด char
โดยทั่วไปคําวา stream จะหมายถึง byte stream สวน character stream ภาษา
จาวาจะใชคําวา reader และ writer สําหรับ stream ในการรับและสงชนิดขอมูล char
ตามลําดับ

11.1.1 แพคเก็จ java.io

คลาสที่เกี่ยวกับอินพุตและเอาทพุตจะถูกกําหนดโดย Java API ในแพคเก็จ
java.io ซึ่งจะมีคลาสพื้นฐานอยู 4 คลาสคือ

• InputStream
เปนคลาสที่ใชในการสรางออปเจ็คที่เปน stream ในการรับชนิดขอมูลแบบ
byte

• OutputStream
เปนคลาสที่ใชในการสรางออปเจ็คที่เปน stream ในการสงชนิดขอมูลแบบ
byte

• Reader
เปนคลาสที่ใชในการสรางออปเจ็คที่เปน stream ในการรับชนิดขอมูลแบบ
char

• Writer
เปนคลาสที่ใชในการสรางออปเจ็คที่เปน stream ในการสงชนิดขอมูลแบบ
char
ซึ่งคลาสทั้งสี่นี้จะเปนคลาสที่เปนคลาสรากของคลาสอื่นๆที่จะสืบทอดมา ดังแสดงใน
รูปที่ 11.2 ถึง รูปที่ 11.5

324 คณะเทคโนโลยีสารสนเทศ สถาบันเทคโนโลยีพระจอมเกลาเจาคุณทหารลาดกระบัง

รูปที่ 11.2 คลาสประเภท InputStream

รูปที่ 11.3 คลาสประเภท OutputStream

รูปที่ 11.4 คลาสประเภท Reader

Java Programming 325

 รูปที่ 11.5 คลาสประเภท Writer

11.1.2 คลาสประเภท Byte Stream

ภาษาจาวาจะมีคลาสพื้นฐานในการจัดการกับอินพุตและเอาทพุต ที่เปนชนิดขอมูล
แบบ byte อยูสองคลาสที่คูกันคือ InputStream และ OutputStream คลาสทั้งสอง
เปนคลาสแบบ abstract ซึ่งเราไมสามารถที่จะสรางออปเจ็คของคลาสทั้งสองได แตคลาส
ทั้งสองจะมีคลาสที่เปน subclass ซึ่งจะใชในการสรางออปเจ็คสําหรับการรับและสงขอมูลแบบ
byte ของโหนดที่มีตนทางและปลายทางแบบตางๆอาทิเชน

• FileInputStream และ FileOutputStream เปนคลาสที่ใชในการ

สรางออปเจ็คสําหรับตนทางและปลายทางที่เปนไฟล
• ByteArrayInputStream และ ByteArrayOutputStream เปน
คลาสที่ใชในการสรางออปเจ็คสําหรับตนทางและปลายทาง ที่เปนอะเรยของชนิด
ขอมูลแบบ byte

11.1.3 คลาส InputStream

คลาส InputStream จะใชในการอานขอมูลของ stream ที่เปนชนิดขอมูลแบบ
byte คลาส InputStream จะนําขอมูลจากโหนดตนทางเขามาใน stream และการอาน

326 คณะเทคโนโลยีสารสนเทศ สถาบันเทคโนโลยีพระจอมเกลาเจาคุณทหารลาดกระบัง

ขอมูลจาก stream จะเปนการลบขอมูลที่อานออกจาก stream ดังแสดงในรูปที่ 11.6 โดยมี
เมธอดที่ใชสําหรับการอานขอมูลที่เปน byte หรืออะเรยของ byte เทานั้นดังนี้
• int read()
เปนเมธอดที่ใชในการอานขอมูลจาก stream มาหนึ่งไบทโดยจะสงคากลับมา
เปนคาที่อานไดระหวาง 0 ถึง 255 และจะสงคากลับเปน –1 ถาไมมีขอมูลจาก
โหนดตนทาง เมธอดนี้จะสงออปเจ็คชนิด IOException ในกรณีที่มี
ขอผิดพลาดเกิดขึ้นจากการอานขอมูล ตัวอยางเชน ไฟลที่อานขอมูลเสีย เมธอด
นี้เปนเมธอดแบบ abstract ซึ่งคลาสที่เปน subclass จะตองกําหนดบล็อก
คําสั่งสําหรับเมธอดนี้
• int read(byte []b)
เปนเมธอดที่ใชในการอานขอมูลจากโหนดตนทางทีละหลายไบท โดยจะอาน
ขอมูลครั้งละไมเกินจํานวนสมาชิกของอะเรยของ argument ที่ชื่อ b โดยจะเก็บ
ขอมูลที่อานเขาไวในอะเรยของ byte เมธอดนี้จะสงจํานวนไบทที่อานไดคืนมา
และจะมีคาเปน –1 ถาไมสามารถอานขอมูลได
• int read (byte []b, int offset, int length)
เปนเมธอดที่ใชในการอานขอมูลจากโหนดตนทางทีละหลายไบทเชนกัน แตจะ
สามารถกําหนดตําแหนงในการเก็บขอมูลที่อานลงในอะเรยของ argument ที่ชื่อ
b ได โดยเริ่มที่ตําแหนง offset และอานครั้งละ length ไบท ซึ่งเมธอดจะ
สงจํานวนขอมูลที่อานไดจริงคืนมา การอานขอมูลเปนอะเรยของชนิดขอมูล
byte จะชวยเพิ่มประสิทธิภาพ ทั้งนี้จะอานขอมูลไดเร็วกวา

รูปที่ 11.6 การอานขอมูลจาก stream

Java Programming 327

 คลาส InputStream ยังมีเมธอดอื่นๆที่สําคัญอีกดังนี้
• int available()
เมธอดนี้จะสงจํานวนไบทที่ยังสามารถอานไดจาก stream คืนมา
• void close()
เมธอดนี้ใชในการปด stream การเรียกใชเมธอดจะชวยทําใหลดการใชทรัพยากร
ในระบบ (หนวยความจําหรือจํานวนไฟลที่เปด)
• int skip(long n)
เมธอดนี้จะเปนการลบขอมูลจํานวน n ไบทออกจาก stream และขามไปขอมูล
ตําแหนงถัดไป
• void mark(int readlimit)
เมธอดนี้ใชระบุตําแหนงของขอมูลใน stream ที่ตองการจะระบุไวเพื่อที่จะตองการ
ให stream กลับมาที่ตําแหนงนี้หลังจากเรียกใชเมธอด reset()
• void reset()
เมธอดนี้ใชเพื่อให stream กลับมาชี้ในตําแหนงที่ระบุไวในเมธอด mark()

• boolean markSupported()
เมธอดนี้ใชตรวจสอบวา stream ที่ใชอยูสนับสนุนการใชเมธอด mark() และ
reset() หรือไม

11.1.4 คลาส OutputStream

คลาส OutputStream จะใชการสงขอมูลของ stream ที่เปนชนิดขอมูลแบบ
byte การสงขอมูลของออบเจ็คชนิด Outputstream จะเปนการเพิ่มขอมูลลงใน stream
ดังแสดงในรูปที่ 11.7 คลาส OutputStream จะมีเมธอดในการสงขอมูลชนิด byte ที่
สอดคลองกับเมธอด read() ในคลาส InputStream โดยคลาสนี้จะมีเมธอด write()
ที่เปนเมธอดแบบ abstract ในรูปแบบตางๆดังนี้
• void write(int i)
เมธอดนี้ใชการเขียน (สง) ขอมูลลงใน stream โดยจะสงขอมูลเพียงแปดบิตทาย
ของ argument ที่ชื่อ i อาทิเชน ถา i มีคาเปน 781 ก็จะเขียนขอมูล 00001101
ลงใน stream ทั้งนี้เพราะ 781 มีคาเปน 00000000 00000000 00000011

328 คณะเทคโนโลยีสารสนเทศ สถาบันเทคโนโลยีพระจอมเกลาเจาคุณทหารลาดกระบัง

 00001101 ในเลขฐานสอง เมธอดนี้จะสงออปเจ็คประเภท IOException คืน
มากรณีที่เกิดขอผิดพลาดในการเขียนขอมูล
• void write(byte [] b)
เมธอดนี้ใชในการเขียนอะเรยของชนิดขอมูล byte ลงใน stream ซึ่งเมธอดนี้
อาจสงออปเจ็คชนิด NullPointerException ในกรณีที่ตัวแปรอะเรย b
ยังไมมีการสรางขึ้นมาโดยใชคําสั่ง new
• int write (byte []b, int offset, int length)
เมธอดนี้ใชในการเขียนอะเรยของชนิดขอมูล byte ลงใน stream โดยจะเขียน
ขอมูลของอะเรยของ argument ที่ชื่อ b ตั้งแตตําแหนงที่ offset ไปจํานวน
length ไบท เมธอดจะสงจํานวนไบทที่สามารถเขียนลงใน stream ไดจริง
กลับคืนมา และอาจสงออปเจ็คชนิด IndexOutOfBoundsException เพิ่ม
ขึ้นมาในกรณีที่หมายเลขของสมาชิกของอะเรยใน argument ที่ชื่อ b ไมอยูในชวง
ที่ถูกตอง

รูปที่ 11.7 การเพิ่มขอมูลลงใน stream

นอกจากนี้คลาส OutputStream ยังมีเมธอดอื่นๆที่สําคัญอาทิเชน

- void close()
เปนเมธอดที่ใชในการปด stream
- void flush()
เปนเมธอดที่ใชในกรณีที่ stream มีบัฟเฟอร (buffer) ในการเก็บขอมูลที่เขียนไว
ชั่วคราว ซึ่งการเรียกใชเมธอดนี้จะเปนการเขียนขอมูลที่อยูในบัฟเฟอรลง stream

Java Programming 329

 11.1.5 คลาสประเภท Character Stream
ภาษาจาวากําหนดคลาสพื้นฐานในการจัดการกับอินพุตและเอาทพุตที่เปนชนิดขอมูล
แบบ char อยูสองคลาสคือ Reader และ Writer คลาสทั้งสองเปนคลาสแบบ
abstract โดยมี subclass ที่สืบทอดมาเพื่อใชในการสรางออปเจ็คสําหรับจัดการกับโหนด
ตนทางและปลายทางในรูปแบบตางๆเชน ไฟล หนวยความจํา และไบท เปนตน
Reader เปนคลาสที่ใชในการอานขอมูลของ stream ที่เปนชนิดขอมูลแบบ char
Reader จะมีเมธอดที่เหมือนกับคลาส InputStream และมีหลักการทํางานที่สอดคลองกัน
แตจะรับขอมูลหรือ argument ที่เปนชนิดขอมูล char โดยมีเมธอดตางๆดังนี้
• int read()

• int read(char []c)

• int read(char []c, int offset, int length)

• void close()

• void skip(long n)

• boolean markSupported()

• void mark(int readAheadlimit)

• void reset()

• boolean ready()
Writer เปนคลาสที่ใชในการเขียนขอมูลของ stream ที่เปนชนิดขอมูลแบบ char
Writer จะมีเมธอดที่เหมือนกับคลาส OutputStream และมีหลักการทีสอดคลองกันแตจะ
รับขอมูลหรือ argument ที่เปนชนิดขอมูล char โดยมีเมธอดตางๆดังนี้
• void write(int c)
• void write(char []c)
• void write(char []c, int offset, int length)
• void close()
• void flush()
นอกจากนี้คลาส Writer จะมีเมธอดเพิ่มเติมขึ้นมาเพื่อเขียนชนิดขอมูลที่เปน
String ดังนี้

• void write(String s)

• void write(String s, int offset, int length)

330 คณะเทคโนโลยีสารสนเทศ สถาบันเทคโนโลยีพระจอมเกลาเจาคุณทหารลาดกระบัง

11.2 โหนดสําหรับ Stream
ภาษาจาวากําหนดโหนดที่เปนตนทางและปลายทางของ stream ไวสามแบบคือ ไฟล
หนวยความจํา และไปป (pipe)
• ไฟลคือโหนดสําหรับ stream ที่เปนไฟลสําหรับอานหรือเขียนขอมูลชนิด byte
คลาสที่เปนโหนดแบบไฟลสําหรับ byte stream คือ FileInputStream
และ FileOutputStream สวนคลาสที่เปนโหนดแบบไฟลสําหรับ character
stream คือ FileReader และ FileWriter
• หนวยความจําคือโหนดสําหรับ stream ที่ใชสําหรับอานหรือเขียนขอมูลที่เปน
อะเรยหรือ String คลาสที่เปนโหนดแบบหนวยความจํา สําหรับ byte stream
คือ ByteArrayInputStream และ ByteArrayOutputStream
สวนคลาสที่เปนโหนดแบบหนวยความจําสําหรับ character stream ในภาษา
จาวาจะมีสองแบบคือ อะเรยของชนิดขอมูลแบบ char และ string โดยมี
คลาสที่ชื่อ CharArrayReader, CharArrayWriter,
StringReader และ StringWriter ตามลําดับ

• ไปปคือโหนดสําหรับ stream ที่จะสงหรือรับขอมูลระหวาง process หรือ

โปรแกรมเธรด อาทิเชน stream แบบไปปที่เปนเอาทพุต (output pipe stream)
ของ process หนึ่งอาจเชื่อมตอกับ stream แบบไปปที่เปนอินพุต (input pipe
stream) ของอีก process หนึ่ง คลาสที่เปนโหนดแบบไปปสําหรับ byte stream
คือ PipedInputStream และ PipedOutputStream สวนคลาสที่เปน
โหนดแบบไปปสําหรับ character stream คือ PipedReader และ
PipedWriter
ตารางที่ 11.1 สรุปชื่อคลาสที่เปนโหนดสําหรับ stream ตางๆของโหนดทั้งสามแบบ

โปรแกรมที่ 11.1 แสดงตัวอยางของการก็อบปขอมูลของไฟลหนึ่งไฟลไปยังไฟลอื่น

โดยใช byte stream โปรแกรมนี้จะเปดไฟลที่มีชื่อตาม argument ที่ชื่อ args[0] สําหรับ
อานขอมูลชนิด byte โดยสรางออปเจ็คของคลาส FileInputStream ที่ชื่อ fin และ
โปรแกรมนี้จะเปดไฟลที่มีชื่อตาม argument ที่ชื่อ args[1] สําหรับเขียนขอมูลชนิด byte
โดยสราง ออปเจ็คของคลาส FileOutputStream ที่ชื่อ fout จากนั้นโปรแกรมจะ
อานขอมูลจาก ออปเจ็ค fin ทีละ 100 ไบท แลวนําไปเขียนลงในออปเจ็ค fout จนกระทั่ง
ไมมีขอมูลที่จะอานตอไปจึงทําการปดไฟลทั้งสอง

Java Programming 331

 โปรแกรมที่ 11.2 แสดงตัวอยางของก็อปปขอมูลของไฟลเชนเดียวกับโปรแกรมที่
11.1แตจะใช character stream โดยสรางออปเจ็คของคลาส FileReader และ
FileWriter แทน

ตารางที่ 11.1 คลาสที่เปนโหนดสําหรับ stream ตางๆ

ชนิด Byte Stream Character Stream
FileInputStream FileReader
File
FileOutputStream FileWriter
ByteArrayInputStream CharArrayReader
Memory: Array
ByteArrayOutputStream CharArrayWriter
StringReader
Memory: String -
StringWriter
PipedInputStream PipedReader
Pipe
PipedOutputStream PipedWriter

โปรแกรมที่ 11.1 การก็อบปขอมูลของไฟลหนึ่งไฟลไปยังไฟลอื่นโดยใช byte stream

import java.io.*;

public class FileCopy {

public static void main(String args[]) {
try {
FileInputStream fin = new
FileInputStream(args[0]);
FileOutputStream fout = new
FileOutputStream(args[1]);
byte b[] = new byte[100];
int i = fin.read(b);
while (i != -1) {
fout.write(b,0,i);
i = fin.read(b);
}
fin.close();
fout.close();
} catch (IOException e) { }
}
}

332 คณะเทคโนโลยีสารสนเทศ สถาบันเทคโนโลยีพระจอมเกลาเจาคุณทหารลาดกระบัง

โปรแกรมที่ 11.2 การก็อบปขอมูลของไฟลหนึ่งไฟลไปยังไฟลอื่นโดยใช character stream

import java.io.*;

public class FileCopyReader {

public static void main(String args[]) {
try {
FileReader fr = new FileReader(args[0]);
BufferedReader br = new BufferedReader(fr);
FileWriter fw = new FileWriter(args[1]);
BufferedWriter bw = new BufferedWriter(fw);
String line = br.readLine();
while (line != null) {
bw.write(line,0,line.length());
bw.newLine();
line = br.readLine();
}
br.close();
bw.close();
} catch (IOException e) { }
}
}

11.3 คลาสประเภท Stream ระดับสูง

โดยทั่วไปโปรแกรมภาษาจาวาจะใชออปเจ็คประเภท stream มากกวาหนึ่งออปเจ็ค
โดยจะเชื่อมออปเจ็คของ stream ตางๆเขาดวยกันเพื่อใชในการแปลงชนิดขอมูลประเภทตางๆ
ตัวอยางเชนรูปที่ 11.8 เปนการเชื่อมตอออปเจ็คของคลาส FileInputStream เขากับ
ออปเจ็คของคลาส DataInputStream โดยออปเจ็คของคลาส FileInputStream จะ
อานขอมูลของไฟลเขามาโดยมีชนิดขอมูลแบบ byte สวนออปเจ็คของคลาส
DataInputStream จะทําการแปลงชนิดขอมูลแบบ byte ใหเปนชนิดขอมูลอื่นๆทําใหมี
เมธอดในการอานขอมูลมากขึ้น การเชื่อมตอออปเจ็คประเภท stream สามารถทําไดโดยการ
เขียนคําสั่งในโปรแกรม เพื่อนําออปเจ็คของคลาสประเภท stream ชนิดหนึ่งไปเปน argument
ใน constructor ของคลาสประเภท stream ที่ตองการเชื่อมตออาทิเชน ตัวอยางในรูปที่ 11.8
สามารถเขียนเปนคําสั่งไดดังนี้
FileInputStream fin = new FileInputStream(“test.dat”);
DataInputStream din = new DataInputStream(fin);

Java Programming 333

 รูปที่ 11.8 การเชื่อมตอออปเจ็คของคลาส

ออปเจ็คที่ใชในการเชื่อมตอ stream จะเปนออปเจ็คของคลาสประเภท steam

ระดับสูง (high-level stream) ซึ่งสามารถที่จะอานหรือเขียนขอมูลที่เปนชนิดขอมูลอื่นๆแลว
แปลงขอมูลใหเปนชนิดขอมูลแบบ byte หรือมีบัฟเฟอรในการเพิ่มประสิทธิภาพในการอาน
หรือเขียนขอมูล คลาสเหลานี้จะไมสามารถอานหรือเขียนขอมูลไปยังโหนดตนทางหรือ
ปลายทางที่เปนไฟล หนวยความจํา หรือ Pipe ไดโดยตรง แตจะรับขอมูลมาจาก stream อื่นๆ
ที่เปนคลาสพื้นฐานในการอานหรือเขียนขอมูลตามตารางที่ 11.1 แทน ตารางที่ 11.2 แสดง
คลาสประเภท steam ระดับสูงที่กําหนดไวใน Java API ซึ่งมีคลาสที่สําคัญดังนี้
• DataInputStream และ DataOutputStream
เปนคลาสที่ใชในการแปลงชนิดขอมูลระหวางชนิดขอมูลแบบ byte กับชนิด
ขอมูลแบบอื่นๆ
• BufferedInputStream และ BufferedOutputStream
เปนคลาสที่มีบัฟเฟอรสําหรับชนิดขอมูล byte อยูภายในเพื่อใหสามารถอาน
หรือเขียนขอมูลขนาดใหญได ซึ่งจะชวยเพิ่มประสิทธิภาพในการอานหรือเขียน
ขอมูล
• PrintStream
เปนคลาสที่ใชในการเขียนขอความที่เปน String ที่แปลงมาจากชนิดขอมูล
แบบ byte ออปเจ็ค out และ err ที่อยูในคลาส System เปนตัวอยาง
ของออปเจ็คที่ใชคลาสนี้
• PushbackInputStream
เปนคลาสที่อนุญาตใหสงขอมูลชนิด byte ที่เพิ่งอานมากลับไปยัง stream ได
• BufferedReader และ BufferedWriter
เปนคลาสที่มีบัฟเฟอรสําหรับชนิดขอมูลแบบ char เพื่อใหสามารถอานหรือ
เขียนขอมูลขอใหญได

334 คณะเทคโนโลยีสารสนเทศ สถาบันเทคโนโลยีพระจอมเกลาเจาคุณทหารลาดกระบัง

 • InputStreamReader และ OutputStreamWriter
เปนคลาสที่ใชในการแปลงชนิดขอมูลระหวางชนิดขอมูลแบบ char กับชนิด
ขอมูลแบบอื่นๆ
• PrintWriter
เปนคลาสที่ใชในการเขียนขอความที่เปน String ที่แปลงมาจากชนิดขอมูล
แบบ char
• PushbackReader
เปนคลาสที่อนุญาตใหสงขอมูลชนิด char ที่เพิ่งอานมากลับไปยัง stream ได

ตารางที่ 11.2 คลาสประเภท stream ระดับสูง

ชนิด Byte Stream Character Stream
BufferedInputStream BufferedReader
Buffering
BufferedOutputStream BufferedWriter
FilterInputStream FilterReader
Filtering
FilterOutputStream FilterWriter
Data DataInputStream
-
conversion DataOutputStream

Printing PrintStream PrintWriter

Peeking ahead PushbackInputStream PushbackReader

การเชื่อมตอออปเจ็คของคลาสประเภท stream ระดับสูงเหลานี้สามารถที่จะเชื่อมตอ

กันไดหลายๆชั้น อาทิเชนรูปที่ 11.9 แสดงตัวอยางของการเชื่อมออปเจ็คของคลาส
FileInputStream เขากับออปเจ็คของคลาส BufferedInputStream เพื่อเพิ่ม
ประสิทธิภาพในการอานขอมูลแลวจึงไปเชื่อมตอกับออปเจ็คของคลาส DataInputStream
เพื่อใชในการแปลงชนิดขอมูลแบบ byte ใหเปนชนิดขอมูลแบบอื่นๆโดยจะมีรูปแบบคําสั่ง
ดังนี้
FileInputStream f = new FileInputStream(“test.dat”);
BufferedInputStream b = new BufferedInputStream(f);
DataInputStream d = new DataInputStream(b);

Java Programming 335

 รูปที่ 11.9 การเชื่อมออปเจ็คของคลาสหลายๆชั้น

11.3.1 DataInputStream และ DataOutputStream

คลาส DataInputStream เปนคลาสที่ใชในการแปลงชนิดขอมูลแบบ byte ให
เปนชนิดขอมูลแบบอื่นๆ คลาส DataInputStream เปนคลาสที่สืบทอดมาจากคลาส
FilterInputStream และ implements อินเตอรเฟส DataInput โดยจะมีเมธอด
ในการอานชนิดขอมูลแบบตางๆเพิ่มขึ้นมาดังนี้
• boolean readBoolean() throws IOException
เปนเมธอดที่ใชในการอานชนิดขอมูลแบบ boolean มาหนึ่งคา
• byte readByte() throws IOException
เปนเมธอดที่ใชในการอานชนิดขอมูลแบบ byte มาหนึ่งไบท
• char readChar() throws IOException
เปนเมธอดที่ใชในการอานชนิดขอมูลแบบ char มาหนึ่งตัวอักษร
• double readDouble() throws IOException
เปนเมธอดที่ใชในการอานชนิดขอมูลแบบ double มาหนึ่งคา
• float readFloat() throws IOException
เปนเมธอดที่ใชในการอานชนิดขอมูลแบบ float มาหนึ่งคา
• int readInt() throws IOException
เปนเมธอดที่ใชในการอานชนิดขอมูลแบบ int มาหนึ่งคา
• long readLong() throws IOException
เปนเมธอดที่ใชในการอานชนิดขอมูลแบบ long มาหนึ่งคา
• short readShort() throws IOException
เปนเมธอดที่ใชในการอานชนิดขอมูลแบบ short มาหนึ่งคา

336 คณะเทคโนโลยีสารสนเทศ สถาบันเทคโนโลยีพระจอมเกลาเจาคุณทหารลาดกระบัง

 • String readUTF() throws IOException
เปนเมธอดที่ใชในการอานชนิดขอมูลแบบ String มาหนึ่งคาโดยใชรูปแบบ
การเขารหสขอมูลเปน UTF-8
คลาส DataOutputStream เปนคลาสที่ใชในการแปลงชนิดขอมูลใดๆมาเปน
ชนิดขอมูลแบบ byte DataOutputStream เปนคลาสที่สืบทอดมาจากคลาส
FilterOutputStream และ implements อินเตอรเฟส DataOutput โดยจะมี
เมธอดในการอานชนิดขอมูลแบบตางๆเพิ่มขึ้นมาดังนี้
• void writeBoolean(boolean b) throws IOException
เปนเมธอดที่ใชในการเขียนชนิดขอมูลแบบ boolean หนึ่งคา
• void writeByte(int b) throws IOException
เปนเมธอดที่ใชในการเขียนชนิดขอมูลแบบ byte หนึ่งไบท
• void writeBytes(String s) throws IOException
เปนเมธอดที่ใชในการเขียนชนิดขอมูลแบบ String หนึ่งคา
• void writeChar(int c) throws IOException
เปนเมธอดที่ใชในการเขียนชนิดขอมูลแบบ char หนึ่งตัวอักขระ
• void writeDouble(double b) throws IOException
เปนเมธอดที่ใชในการเขียนชนิดขอมูลแบบ double หนึ่งคา
• void writeFloat(float f) throws IOException
เปนเมธอดที่ใชในการเขียนชนิดขอมูลแบบ float หนึ่งคา
• void writeInt(int i) throws IOException
เปนเมธอดที่ใชในการเขียนชนิดขอมูลแบบ int หนึ่งคา
• void writeLong(long l) throws IOException
เปนเมธอดที่ใชในการเขียนชนิดขอมูลแบบ long หนึ่งคา
• void writeShort(int s) throws IOException
เปนเมธอดที่ใชในการเขียนชนิดขอมูลแบบ short หนึ่งคา
• void writeUTF(String s) throws IOException
เปนเมธอดที่ใชในการเขียนชนิดขอมูลแบบ String หนึ่งคาโดยใชรูปแบบการ
เขารหัสแบบ UTF-8

Java Programming 337

 โปรแกรมที่ 11.3 แสดงตัวอยางของการใชคลาส DataOutputStream เพื่อเก็บ
ชนิดขอมูลแบบตางๆลงในไฟล สวนโปรแกรมที่ 11.4 แสดงตัวอยางของการใชคลาส
DataInputStream เพื่อนําขอมูลที่เก็บไวในไฟลดังกลาวมาแสดงผล โดยจะไดผลลัพธดัง
แสดงในรูปที่ 11.10

โปรแกรมที่ 11.3 ตัวอยางของการใชคลาส DataOutputStream

import java.io.*;

public class DataWriterDemo {

public static void main (String args[]) {

try {
FileOutputStream fout;
DataOutputStream dout;
fout = new FileOutputStream("data.dat");
dout = new DataOutputStream(fout);
dout.writeInt(124);
dout.writeDouble(2.45);
dout.writeChar('a');
dout.writeUTF("test");
dout.close();
fout.close();
} catch (IOException ex) {
System.out.println(ex.toString());
}
}
}

338 คณะเทคโนโลยีสารสนเทศ สถาบันเทคโนโลยีพระจอมเกลาเจาคุณทหารลาดกระบัง

โปรแกรมที่ 11.4 ตัวอยางของการใชคลาส DataInputStream

import java.io.*;
public class DataReaderDemo {
public static void main (String args[]) {
try {
FileInputStream fin;
DataInputStream din;
fin = new FileInputStream("data.dat");
din = new DataInputStream(fin);
int x = din.readInt();
double d = din.readDouble();
char ch = din.readChar();
String line = din.readUTF();
System.out.println("x=" + x + " d="
+ d + " ch=" + ch);
System.out.println(line);
din.close();
fin.close();
} catch (IOException ex) {
System.out.println(ex.toString());
}
}
}

รูปที่ 11.10 ผลลัพธที่ไดจากการรันโปรแกรมที่ 11.3 และโปรแกรมที่ 11.4

11.3.2 InputStreamReader และ OutputStreamWriter

เราสามารถที่จะแปลง stream ระหวางชนิดขอมูลแบบ byte และชนิดขอมูลแบบ
char ไดโดยใชคลาส InputStreamReader ซึ่งจะอานชนิดขอมูลแบบ byte แลว
แปลงเปนชนิดขอมูลแบบ char และคลาส OutputStreamWriter ซึ่งจะอานชนิด
ขอมูลแบบ char แลวแปลงเปนชนิดขอมูลแบบ byte

Java Programming 339

 โปรแกรมที่ 11.5 แสดงตัวอยางของการใชคลาสดังกลาวเพื่อเก็บขอความลงในไฟลที่
เปนชนิดขอมูลแบบ byte โปรแกรมนี้จะสรางออปเจ็คของคลาส FileOutputStream
แลวนําไปเชื่อมตอกับออปเจ็คของคลาส OutputStreamWriter เพื่อจะแปลงชนิดขอมูล
แบบ char ใหมาเปนชนิดขอมูลแบบ byte สวนออปเจ็คของคลาส PrintWriter ที่
เชื่อมตอกับออปเจ็คของคลาส OutputStreamWriter จะทําหนาที่แปลงชนิดขอมูลแบบ
String ใหเปนชนิดขอมูลแบบ char สวนโปรแกรมที่ 11.6 จะเปนตัวอยางในการอาน
ขอมูลจากไฟลแลวมาแสดงผลโดยใชออปเจ็คของคลาส BufferedReader

โปรแกรมที่ 11.5 ตัวอยางของการใชคลาสเพื่อเก็บขอความลงในไฟล

import java.io.*;

public class FileWriter {

public static void main(String args[]) {

FileOutputStream fout;
OutputStreamWriter oout;
PrintWriter p;

String line1 = "This is a test message";

String line2 = "This is another line";

try {
fout = new FileOutputStream("data.dat");
oout = new OutputStreamWriter(fout);
p = new PrintWriter(oout);
p.println(line1);
p.println(line2);
p.close();
oout.close();
fout.close();
} catch (IOException ex) {
System.out.println(ex.toString());
}
}
}

340 คณะเทคโนโลยีสารสนเทศ สถาบันเทคโนโลยีพระจอมเกลาเจาคุณทหารลาดกระบัง

11.4 คลาส File
คลาสที่ชื่อ File เปนคลาสที่อยูในแพคเก็จ java.io เปนคลาสที่ใชในการสราง
ออปเจ็คที่เปนไฟลหรือไดเร็กทอรี่ คลาส File จะมีเมธอดในการจัดการกับไฟลหรือ
ไดเร็กทอรี่ และเมธอดในการสืบคนขอมูลตางๆอยูหลายเมธอด ออปเจ็คของคลาส File จะ
สรางมาจาก constructor ที่มีรูปแบบดังนี้
• public File(String name)
• public File(String dir, String name)
• public File(File dir, String name)
โดยที่
• name คือชื่อของไฟลหรือไดเร็กทอรี่ที่ตองการเปดขึ้นมา
• dir คือชื่อของไดเร็กทอรี่ในกรณีที่ไฟลหรือไดเร็กทอรี่นั้นอยูภายในไดเร็กทอรี่
อื่น
ในกรณีที่ไมพบไฟลหรือไดเร็กทอรี่ตามชื่อที่ระบุ constructor จะสงออปเจ็คของ
คลาส FileNotFoundException เพื่อระบุวามีขอผิดพลาดจากการเปดไฟลหรือ
ไดเร็กทอรี่

โปรแกรมที่ 11.6 ตัวอยางของการใชคลาสเพื่ออานขอมูลจากไฟล

import java.io.*;

public class FileReader {

public static void main(String args[]) {
FileInputStream fin;
InputStreamReader in;
BufferedReader bin;
try {
fin = new FileInputStream("data.dat");
in = new InputStreamReader(fin);
bin = new BufferedReader(in);
System.out.println(bin.readLine());
System.out.println(bin.readLine());
bin.close();
in.close();
fin.close();
} catch (IOException ex) {
System.out.println(ex.toString());
}
}
}

Java Programming 341

 เมธอดของคลาส File ที่ใชในการสืบคนขอมูลหรือจัดการกับไฟลที่สําคัญมีดังนี้
• boolean exists()
เปนเมธอดที่ใชในการตรวจสอบวาไฟลหรือไดเร็กทอรี่วามีปรากฏอยูจริงหรือไม
• boolean isDirectory()
เปนเมธอดที่ใชในการตรวจสอบวาออปเจ็คของคลาส File นี้เปนไดเร็กทอรี่
หรือไม
• boolean isFile()
เปนเมธอดที่ใชในการตรวจสอบวาออปเจ็คของคลาส File นี้เปนไฟลหรือไม
• boolean canRead()
เปนเมธอดที่ใชในการตรวจสอบวาไฟลนี้สามารถใชในการอานขอมูลไดหรือไม
• boolean canWrite()
เปนเมธอดที่ใชในการตรวจสอบวาไฟลนี้สามารถใชในการเขียนขอมูลไดหรือไม
• String getName()
เปนเมธอดที่ใชในการเรียกดูชื่อไฟลหรือไดเร็กทอรี่ของออปเจ็คของคลาส File
นี้
• String getParent()
เปนเมธอดที่ใชในการเรียกดูชื่อไดเร็กทอรี่รากของออปเจ็คของคลาส File นี้
• String []list()
เปนเมธอดที่ใชในการเรียกดูชื่อไฟลหรือไดเร็กทอรี่ยอยทั้งหมด ที่อยูในออปเจ็ค
ของคลาส File นี้ในกรณีที่เปนไดเร็กทอรี่
• boolean mkdir()
เปนเมธอดที่ใชในการสรางไดเร็กทอรี่ยอย
• boolean renameTo(File newName)
เปนเมธอดที่ใชในการเปลี่ยนชื่อออปเจ็คของคลาส File นี้ใหเปนชื่อใหมตามที่
ระบุไวในออปเจ็คของ argument ที่ชื่อ newName
คลาส File สามารถใชในการจัดการกับการเปดไฟลเพื่อตรวจสอบวามีไฟล
ดังกลาวหรือไม ซึ่ง constructor ของคลาส FileInputStream และ
FileOutputStream หรือ FileReader และ FileWriter จะมีรูปแบบที่มี

342 คณะเทคโนโลยีสารสนเทศ สถาบันเทคโนโลยีพระจอมเกลาเจาคุณทหารลาดกระบัง

argument เปนออปเจ็คของคลาส File เพื่อชวยในการตรวจสอบไฟลกอนที่จะใชในการอาน
หรือเขียนขอมูลดังตัวอยางตอไปนี้
File f = new File(“Test.dat”);
if (f.exists()) {
FileInputStream fir = new FileInputStream(f);
}

11.4.1 คลาส RandomAccessFile

ภาษาจาวามีคลาสที่สนับสนุนการอานหรือเขียนไฟลเปนแบบ random access
กลาวคือไมจําเปนจะตองอานหรือเขียนขอมูลของไฟลเรียงตามลําดับจากตําแหนงแรกสุดไปยัง
ตําแหนงสุดทายของไฟล คลาสประเภทนี้คือคลาส RandomAccessFile ซึ่งจะใชเวลาใน
การอานหรือเขียนขอมูลในตําแหนงตางๆเทากัน คลาส RandomAccessFile จะมี
constructor อยูสองรูปแบบดังนี้
• public RandomAccessFile(String name, String mode)

• public RandomAccessFile(File file, String mode)

โดยที่
• name คือชื่อของไฟล
• file คือออปเจ็คของคลาสไฟล
• mode คือรูปแบบในการเปดไฟลที่มีดังนี้ “r” เปนการเปดไฟลหรืออานขอมูล
หรือ “rw” เปนการเปดไฟลเพื่ออานและเขียนขอมูล
ตัวอยางเชนคําสั่ง
RandomAccessFile myFile;
MyFile = new RandomAccessFile(“test.dbf”,”rw”);
เปนการเปดไฟลที่ชื่อ test.dbf สําหรับการอานและเขียนขอมูล
คลาส RandomAccessFile จะมีเมธอดสําหรับการอานและเขียนขอมูล
ที่เปนชนิดขอมูลแบบพื้นฐานชนิดตางๆคลายกับคลาส DataInputStream และ
DataOutputStream และมีเมธอดอื่นๆที่สําคัญเพิ่มเติมมาดังนี้

• long getFilePointer()
เปนเมธอดที่ใชในการเรียกดูตําแหนงชี้ของไฟล

Java Programming 343

 • void seek(long pos)
เปนเมธอดที่ใชในการเลื่อนตําแหนงชี้ของไฟลไปที่ตําแหนง pos
• long length()
เปนเมธอดที่ใชในการเรียกดูความยาวของไฟล

11.4.2 ObjectInputStream และ ObjectOutputStream

ภาษาจาวามีคลาสที่ใชในการรับและสงขอมูลของออปเจ็ค ObjectInputStream
และ ObjectOutputStream ทั้งนี้ออปเจ็คที่จะสามารถสงผาน stream เหลานี้ไดจะตอง
เปนออปเจ็คของคลาสที่ implements อินเตอรเฟส Serializable ซึ่งเปนอินเตอรเฟส
ในแพคเก็จ java.io ซึ่งไมมีเมธอดใดๆอยู แตจะเปนอินเตอรเฟสที่ใชระบุวา ออปเจ็ค
ดังกลาวสามารถเก็บขอมูลหรือดึงขอมูลของออปเจ็คกลับคืนมาได ออปเจ็คที่สามารถเก็บหรือ
ดึงขอมูลไดเปนออปเจ็คประเภทที่เรียกวา persistence ซึ่งขอมูลที่จะเก็บหรือเรียกดูไดจะมี
เฉพาะคุณลักษณะของออปเจ็คหรือคุณลักษณะของคลาสเทานั้น สวนเมธอดจะไมสามารถเก็บ
ได
ออปเจ็คบางประเภทจะไมสามารถที่จะ implements อินเตอรเฟส
Serializable ได เนื่องจากขอมูลของออปเจ็คอาจเปลี่ยนแปลงไดตลอดเวลา อาทิเชน
ออปเจ็คของคลาส Thread หรือ FileInputStream ในกรณีที่ออปเจ็คใดเปน
ออปเจ็คประเภท Serializable แลวมีสมาชิกที่เปนออปเจ็คประเภท non-serializable
อยู การเก็บหรือเรียกดูขอมูลของออปเจ็คจะไมสามารถทําไดและจะเกิดขอผิดพลาดประเภท
NotSerializableException ขึ้นมา

เราสามารถจะระบุคุณลักษณะของออปเจ็คหรือคุณลักษณะของคลาสที่ไมตองการจะ
เก็บหรือเรียกดูขอมูลผาน stream ไดโดยการระบุใหคุณลักษณะดังกลาวมี modifier เปน
คียเวิรด transient ตัวอยางเชน
public class Student implements Serializable {
private String id,name;
private double gpa;
private transient String parent;
}
เปนคลาสที่มีคียเวิรด transient ในคุณลักษณะชื่อ parent ซึ่งจะมีผลทําให
คุณลักษณะนี้ไมสามารถเก็บหรือเรียกดูขอมูลผาน stream คียเวิรด transient สามารถใช
กับคุณลักษณะที่เปนออปเจ็คประเภท non-serializable เพื่อปองกันไมใหเกิดขอผิดพลาดใน
การเก็บหรือเรียกดูขอมูลเชน

344 คณะเทคโนโลยีสารสนเทศ สถาบันเทคโนโลยีพระจอมเกลาเจาคุณทหารลาดกระบัง

 public class Student implements Serializable {
public transient Thread myThread;
private String id,name;
private double gpa;
}
คลาส ObjectOutputStream เปนคลาสที่ใชในการเขียนออปเจ็คใดๆลงใน
stream โดยมีเมธอด writeObject() ที่ใชในการเขียนขอมูล สวนคลาส
ObjectInputStream เปนคลาสที่ใชในการรับออปเจ็คใดๆมาจาก stream โดยมีเมธอด
readObject() ที่ใชในการอานขอมูลซึ่งจะไดออปเจ็คของคลาสที่ชื่อ Object คืนมา
ดังนั้นจึงจําเปนที่จะตองทําการ casting ออปเจ็คใหสอดคลองกับชนิดขอมูลของคลาสที่
ตองการ โปรแกรมที่ 11.7 แสดงตัวอยางของการเขียนและอานขอมูลของออปเจ็คลงในไฟล
data.dat โดยจะใหผลลัพธดังแสดงในรูปที่ 11.11

โปรแกรมที่ 11.7 การเขียนและอานขอมูลของออปเจ็คลงในไฟล

import java.io.*;

public class ObjectPersistenceDemo {

public static void main(String args[]) {
Student s = new Student("451442-1","Somchai",3.21);
FileOutputStream fout;
ObjectOutputStream oout;
FileInputStream fin;
ObjectInputStream oin;
try {
fout = new FileOutputStream("data.dat");
oout = new ObjectOutputStream(fout);
oout.writeObject(s);
System.out.println("Write to file successfully");
oout.close();
fout.close();
fin = new FileInputStream("data.dat");
oin = new ObjectInputStream(fin);
Student s2 = (Student) oin.readObject();
oin.close();
fin.close();
s2.showAllDetails();
} catch (ClassNotFoundException ex) {
System.out.println(ex.toString());
} catch (IOException ex) {
System.out.println(ex.toString());
}
}
}

Java Programming 345

 รูปที่ 11.11 ผลลัพธที่ไดจากการรันโปรแกรมที่ 11.7

สรุปเนื้อหาของบท
• stream เปรียบเสมือนทอสงขอมูล สามารถแบงออกไดเปน 2 ประเภทคือ byte
stream และ character stream
• byte stream มีคลาสพื้นฐานคือ คลาส InputStream และ
OutputStream
• character stream มีคลาสพื้นฐานคือ คลาส Reader และ Writer
• คลาส InputStream และ OutputStream เปน low-level stream ที่
สามารถอานหรือเขียนขอมูลชนิด byte ไดเทานั้น
• คลาส Reader และ Writer เปน low-level stream ที่สามารถอานหรือเขียน
ขอมูลชนิด char ไดเทานั้น
• คลาสที่เปน high-level stream สําหรับ byte stream จะสืบทอดมาจากคลาส
FilterInputStream หรือ FilterOutputStream

• คลาสที่เปน high-level stream สําหรับ character stream คือคลาส

BufferedReader, BufferedWriter, InputStreamReader,
OutputStreamReader, LineNumberReader, PrintWriter
และ PushbackReader
• การเชื่อมตอ stream หลายชั้น จะทําใหสามารถเรียกใชเมธอดไดหลายรูปแบบ
ตามความตองการในการใชงาน
• คลาส File ใชในการสรางออปเจ็คของไฟลหรือไดเร็กทอรี่ โดยจะมีเมธอดที่ใช
ในการจัดการกับไฟล

346 คณะเทคโนโลยีสารสนเทศ สถาบันเทคโนโลยีพระจอมเกลาเจาคุณทหารลาดกระบัง

• คลาส RandomAccessFile จะมีรูปแบบในการอานและเขียนขอมูลเปนแบบ
random access
• ออปเจ็คที่จะสามารถรับหรือสงผาน stream ไดจะตองเปนออปเจ็คของคลาสที่
implements อินเตอรเฟส Serializable

Java Programming 347

348 คณะเทคโนโลยีสารสนเทศ สถาบันเทคโนโลยีพระจอมเกลาเจาคุณทหารลาดกระบัง
 บทที่ 12
โปรแกรมแบบเธรด
เนื้อหาในบทนี้เปนการแนะนําการเขียนโปรแกรมแบบเธรด โดยเริ่มตนจากการ
อธิบายความหมายและองคประกอบของเธรด แนะนําวิธีการสรางคลาสแบบเธรดโดยการสืบ
ทอดจากคลาสที่ชื่อ Thread หรือ implements อินเตอรเฟสที่ชื่อ Runnable อธิบาย
ขั้นตอนการทํางานของโปรแกรมแบบเธรด เมธอดตางๆที่เกี่ยวของกับการทํางานของคลาส
Thread และตอนทายของบทเปนการอธิบายการใชคียเวิรด synchronized เพื่อปองกัน
การผิดพลาดของการอานหรือเขียนขอมูลที่อาจเกิดขึ้นจากโปรแกรมแบบเธรด

12.1 โปรแกรมแบบมัลติเธรด
คุณลักษณะเดนขอหนึ่งของภาษาจาวาคือ ความสามารถในการพัฒนาโปรแกรม
แบบมัลติเธรด (multithreaded) ที่สามารถทํางานพรอมกันได ซึ่งโปรแกรมแบบมัลติเธรดนี้ใช
หลักการของระบบปฏิบัติการแบบ Multitasking ในการกําหนดใหโปรแกรมสามารถทํางาน
หลายงาน (task) ไดพรอมกัน ระบบปฏิบัติการแบบ Multitasking จะเปนระบบปฏิบัติที่
อนุญาตใหผูใช สามารถสงโปรแกรมใหระบบปฏิบัติการทํางานไดมากกวาหนึ่งโปรแกรมพรอม
กัน ซึ่งโปรแกรมแตละโปรแกรมที่รันอยูในระบบปฏิบัติการจะสราง process ขึ้นมา และ
ระบบปฏิบัติการแบบ Multitasking จะมี process หลายๆ process เขาคิวรอการทํางาน โดย
ระบบปฏิบัติการจะกําหนดลําดับของการทํางานของ process เอง
โปรแกรมมัลติเธรดจะเปนการทํางานหลายงานพรอมกันโดยแตละงานจะเรียกวาเธรด
ซึ่งจะแตกตางจาก process ที่ทํางานภายใตระบบปฏิบัติการแบบ Multitasking ตรงที่ process
แตละ process จะมีความเปนอิสระตอกัน แตเธรดแตละเธรดอาจใชขอมูลรวมกันซึ่ง
เปรียบเสมือนซีพียูจําลอง (Virtual CPU)
โปรแกรมแบบเธรดจะมีหลักการทํางานที่แตกตางกัน ทั้งนี้ขึ้นอยูกับระบบปฏิบัติการ
และจํานวนซีพียู ในระบบคอมพิวเตอรที่มีซีพียูหลายตัวโปรแกรมแบบเธรดแตละโปรแกรม
สามารถที่จะรันพรอมกันไดดังแสดงในรูปที่ 12.1 (ก) สวนในระบบคอมพิวเตอรที่มีซีพียูตัว
เดียว ระบบปฏิบัติการจะเปนสวนที่จะจัดการตารางการทํางานของโปรแกรมเธรด ซึ่งอาจแบง
เวลาการทํางานของซีพียูดังแสดงในรูปที่ 12.1 (ข)

Java Programming 349

 (ก) (ข)
รูปที่ 12.1 การทํางานของโปรแกรมแบบเธรด

องคประกอบของโปรแกรมแบบเธรดจะมีสามสวนดังแสดงในรูปที่ 12.2 คือ

• ซีพียู คือการจัดการทํางานของโปรแกรมแบบเธรด
• ซอรดโคด คือคลาสในภาษาจาวาที่เปนคลาสแบบเธรด
• ออปเจ็ค คือออปเจ็คของคลาสแบบเธรด

รูปที่ 12.2 องคประกอบของโปรแกรมแบบเธรด

โปรแกรมภาษาจาวาสามารถกําหนดใหออปเจ็คของคลาสใดๆ ทํางานเปนแบบเธรด
ได ซึ่งก็จะทําใหสามารถรันโปรแกรมของออปเจ็คแบบเธรดหลายๆออปเจ็คพรอมกันได โดย
ภาษาจาวาจะมีตัวจัดตารางเวลา (Thread Scheduler) ของออปเจ็คแบบเธรดเพื่อจัดลําดับการ
ทํางานของออปเจ็คแบบเธรด ทั้งนี้โปรแกรมบางประเภทจําเปนตองพัฒนาเปนแบบเธรดอาทิ
เชน โปรแกรมภาพกราฟฟกแบบเคลื่อนไหว (Graphics Animation) โปรแกรมนาฬิกา และ
โปรแกรมแมขาย (Application Server) เปนตน

350 คณะเทคโนโลยีสารสนเทศ สถาบันเทคโนโลยีพระจอมเกลาเจาคุณทหารลาดกระบัง

12.2 การสรางคลาสแบบเธรด
โปรแกรมแบบเธรดในภาษาจาวาจะใช หลักการของการสรางออปเจ็คของคลาสแบบ
เธรดแลวเรียกใชเมธอดเพื่อสงใหออปเจ็คดังกลาวทํางานพรอมกัน คลาสแบบเธรดในภาษา
จาวาคือคลาสที่สืบทอดมาจากคลาสที่ชื่อ Thread หรือคลาสที่ implements อินเตอรเฟส
Runnable ออปเจ็คที่สรางมาจากคลาสแบบเธรดจะเรียกวาออปเจ็คแบบ runnable

เพื่อความเขาใจการเขียนโปรแกรมแบบเธรดจงพิจารณาโปรแกรมที่ 12.1 โปรแกรม

นี้เปนโปรแกรมที่ทํางานในรูปแบบปกติ ซึ่งจะมีคลาส PrintName ที่มีเมธอด run() ซึ่งจะ
พิมพขอความในคุณลักษณะ name จํานวน 100 ครั้ง คลาส TestPrintName จะสราง
ออปเจ็คของคลาส PrintName ขึ้นมาสองออปเจ็คคือ p1 และ p2 จากนัน้ จะเรียกใชเมธอด
run() เพื่อพิมพขอความออกมา เนื่องจากโปรแกรมนี้ไมไดเปนโปรแกรมแบบเธรด ดังนั้น
ซีพียูจะทําคําสั่ง p1.run() ใหเสร็จกอนแลวจึงจะทําคําสั่ง p2.run() ดังแสดงในรูปที่
12.3

โปรแกรมที่ 12.1 ตัวอยางโปรแกรมที่ทํางานในรูปแบบปกติ

class PrintName {
String name;
public PrintName(String n) {
name = n;
}
public void run() {
for(int i=0; i<100; i++) {
System.out.println(name);
}
}
}
public class TestPrintName {
public static void main(String args[]) {
PrintName p1 = new PrintName("Thana");
PrintName p2 = new PrintName("Somchai");
p1.run();
p2.run();
}
}

Java Programming 351

 รูปที่ 12.3 ขั้นตอนการทํางานของโปรแกรมที่ 12.1

12.2.1 การ implements อินเตอรเฟส Runnable

คลาสแบบเธรดสามารถสรางไดโดยการ implements อินเตอรเฟส Runnable
ซึ่งเมธอดเดียวที่จะตองเขียนบล็อกคําสั่งคือเมธอด run() ซึ่งมีรูปแบบดังนี้

public class ClassName implements Runnable {

public void run(){
[statements]
}
}

คําสั่งที่อยูในเมธอด run() คือชุดคําสั่งที่ตองการใหโปรแกรมทํางานในลักษณะ

แบบเธรด โปรแกรมจาวาที่รันออปเจ็คของคลาสแบบเธรด ในลักษณะนี้จะตองมีการสราง
ออปเจ็คของคลาสที่ชื่อ Thread กอนโดย constructor ของคลาสที่ชื่อ Thread จะมี
argument เพื่อรับออปเจ็คของคลาสที่ implements อินเตอรเฟส Runnable โดยมี
รูปแบบดังนี้

public Thread(Runnable obj)

โดยที่
• obj คือออปเจ็คของคลาสที่ implements อินเตอรเฟส Runnable
ภายหลังจากที่สรางออปเจ็คของคลาสแบบเธรดแลว เราสามารถจะสั่งงานให
ออปเจ็ค obj เริ่มทํางานไดโดยการเรียกใชเมธอด start() ที่อยูในคลาสที่ชื่อ Thread
ซึ่งคลาสที่ชื่อ Thread จะลงทะเบียนออปเจ็คดังกลาวลงในตัวจัดตารางเวลา และเมื่อซีพียู
เรียกรันโปรแกรมของออปเจ็คดังกลาว คําสั่งในเมธอด run() จะถูกสั่งงานตามลําดับ
โปรแกรมที่ 12.2 เปนตัวอยางการปรับปรุงคลาส PrintName ใหเปนคลาสแบบ
เธรด โดยการ implements อินเตอรเฟส Runnable คลาส PrintNameThread จะ
สรางออปเจ็คของคลาส PrintName ขึ้นมาสองออปเจ็คคือ p1 และ p2 ซึ่งทั้งสองเปน

352 คณะเทคโนโลยีสารสนเทศ สถาบันเทคโนโลยีพระจอมเกลาเจาคุณทหารลาดกระบัง

ออปเจ็คแบบ runnable จากนัน้ โปรแกรมไดสรางออปเจ็คของคลาสที่ชื่อ Thread ขึ้นมาสอง
ออปเจ็คคือ t1 และ t2 ซึ่งออปเจ็คทั้งสองจะมีซอรดโคดเดียวกันคือ PrintName แตจะมี
ออปเจ็คแบบ runnable ตางกันคือ p1 และ p2 การเรียกใชเมธอด t1.start() และ
t2.start() จะเปนการสงออปเจ็คแบบเธรดทั้งสองเขาไปจองคิวกับตัวจัดตารางเวลา ซึ่ง
ซีพียูก็จะแบงเวลาใหออปเจ็คทั้งสองทํางานพรอมกันดังแสดงตัวอยางในรูปที่ 12.4

โปรแกรมที่ 12.2 ตัวอยางแสดงคลาสที่ implements อินเตอรเฟส Runnable

class PrintName implements Runnable {
String name;
public PrintName(String n) {
name = n;
}
public void run() {
for(int i=0; i<100; i++) {
System.out.println(name);
}
}
}
public class PrintNameThread {
public static void main(String args[]) {
PrintName p1 = new PrintName("Thana");
PrintName p2 = new PrintName("Somchai");
Thread t1 = new Thread(p1);
Thread t2 = new Thread(p2);
t1.start();
t2.start();
}
}

รูปที่ 12.4 ขั้นตอนการทํางานของโปรแกรมที่ 12.2

Java Programming 353

 12.2.2 การ extends คลาสที่ชื่อ Thread
คลาสแบบเธรดสามารถสรางไดโดยการสืบทอดคลาสที่ชื่อ Thread ซึ่งมีรูปแบบ
ดังนี้
public class ClassName extends Thread {
public void run(){
[statements]
}
}

ซึ่งในกรณีนี้จะตองมีการ override เมธอด run() โดยมีชุดคําสั่งที่ตองการให

โปรแกรมทํางานในลักษณะแบบเธรดอยูภายในบล็อกคําสั่ง และเนื่องจากคลาสแบบเธรด
ลักษณะนี้จะสืบทอดมาจากคลาสที่ชื่อ Thread โดยตรง ดังนั้นเมื่อสรางออปเจ็คของคลาสนี้
แลว เราสามารถที่จะเรียกใชเมธอด start() เพื่อลงทะเบียนออปเจ็คดังกลาวในตัวจัด
ตารางเวลาไดโดยไมจําเปนตองสรางออปเจ็คของคลาสที่ชื่อ Thread และเมื่อซีพียูเรียกรัน
โปรแกรมของออปเจ็ค คําสั่งในเมธอดแบบ overridden ที่ชื่อ run() จะถูกสั่งงานตอไป
โปรแกรมที่ 12.3 แสดงตัวอยางของการปรับปรุงคลาส PrintName ให
สืบทอดมาจากคลาสที่ชื่อ Thread ซึ่งโปรแกรมนี้จะใหผลลัพธเชนเดียวกับโปรแกรมที่ 12.2

โปรแกรมที่ 12.3 ตัวอยางแสดงคลาสที่สืบทอดมาจากคลาสที่ชื่อ Thread

class PrintName extends Thread {

String name;
public PrintName(String n) {
name = n;
}
public void run() {
for(int i=0; i<100; i++) {
System.out.println(name);
}
}
}
public class PrintNameThread {
public static void main(String args[]) {
PrintName p1 = new PrintName("Thana");
PrintName p2 = new PrintName("Somchai");
p1.start();
p2.start();
}
}

354 คณะเทคโนโลยีสารสนเทศ สถาบันเทคโนโลยีพระจอมเกลาเจาคุณทหารลาดกระบัง

 การสรางคลาสแบบเธรดทั้งสองวิธีมีขอดีตางกันดังนี้
• การสรางคลาสโดยการสืบทอดคลาสที่ชื่อ Thread จะเปนการเขียนโปรแกรมที่
สั้นกวา
• การสรางคลาสโดย implements อินเตอรเฟส Runnable จะมีหลักการเชิง
ออปเจ็คที่ดีกวา เนื่องจากคลาสดังกลาวไมใชคลาสที่สืบทอดมาจากคลาสที่ชื่อ
Thread โดยตรง นอกจากนี้ยังทําใหการเขียนโปรแกรมมีรูปแบบเดียวกันเสมอ
เพราะคลาสในจาวาจะสืบทอดไดเพียงคลาสเดียว

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

รูปที่ 12.5 วงจรการทํางานของเธรด

Java Programming 355

 • สถานะ New
เปนสถานะเมื่อมีการสรางออปเจ็คของคลาสแบบเธรด กอนที่จะมีการเรียกใช
เมธอด start()
• สถานะ Runnable และสถานะ Running
Runnable เปนสถานะที่ออปเจ็คแบบเธรดพรอมที่จะทํางาน ซึ่งอาจเกิดจากการ
เรียกใชเมธอด start() หรือเกิดจากการกลับมาจากสถานะที่เปนการบล็อก
เธรด ออปเจ็คแบบเธรดที่อยูในสถานะ Runnable จะเขาสูสถานะ Running ซึ่ง
เปนสถานะที่ซีพียูรันคําสั่งของออปเจ็คแบบเธรด เมื่อตัวจัดตารางเวลาจัดเวลา
ทํางานใหโดยจะทํางานตามชุดคําสั่งในเมธอด run()
ออปเจ็คแบบเธรดจะหยุดการทํางานและกลับเขาสูสถานะ Runnable อีก
ครั้ง เมื่อตัวจัดตารางเวลาเปลี่ยนใหออปเจ็คแบบเธรดอื่นๆ ที่อยูในสถานะ
Runnable เขามาทํางานแทน โดยทั่วไปตัวจัดตารางเวลาจะพยายามจัดการ
ทํางานของออปเจ็คแบบเธรดตามลําดับความสําคัญที่กําหนดไว และในกรณีที่
ออปเจ็คแบบเธรดงานอยูใน ระบบปฏิบัติการแบบ non-preemtive เชน Microsoft
Windows 3.1 โปรแกรมอาจตองเรียกใชเมธอด yield() ในบล็อกคําสั่งของ
run() เพื่อเปดโอกาสใหออปเจ็คแบบเธรดอื่นๆไดทํางานดวย

• สถานะ Blocked
ออปเจ็คแบบเธรดที่อยูในสถานะ Running อาจถูกบล็อกแลวยายไปอยูในสถานะ
Blocked ไดเนื่องจากเหตุการณตางๆดังนี้
− มีการเรียกใชเมธอด sleep()

− ออปเจ็คแบบเธรดรอรับการทํางานที่เปนอินพุตหรือเอาทพุต

− มีการเรียกใชเมธอด wait()

− ออปเจ็คแบบเธรดถูกเรียกโดยเมธอด suspend()

ออปเจ็คแบบเธรดที่อยูในสถานะ Blocked จะกลับเขาสูสถานะ Runnable

ไดอีกครั้งหนึ่งจากเหตุการณตางๆดังนี้
− เมื่อหมดระยะเวลาการพักที่กําหนดในเมธอด sleep() หรือถูกระงับการ
ทํางาน (interrupt)
− เมื่อมีการสงขอมูลอินพุตหรือเอาทพุต ในกรณีที่ออปเจ็คแบบเธรดรอรับหรือ
สงขอมูล

356 คณะเทคโนโลยีสารสนเทศ สถาบันเทคโนโลยีพระจอมเกลาเจาคุณทหารลาดกระบัง

 − เมื่อมีออปเจ็คแบบเธรดตัวอื่นเรียกเมธอด notify() หรือ
notifyAll() ในกรณีที่ออปเจ็คแบบเธรดถูกบล็อกดวยเมธอด
wait()
− เมื่อมีการเรียกใชเมธอด resume() ในกรณีที่ออปเจ็คแบบเธรดถูกบล็อก
ดวยเมธอด suspend()
• สถานะ Dead
ออปเจ็คแบบเธรดจะเขาสูสถานะ Dead เมื่อสิ้นสุดการทํางานเนื่องจากสิ้นสุดการ
ทํางานในชุดคําสั่งของเมธอด run() หรือเมื่อมีการสงออปเจ็คประเภท
Exception ที่ไมไดมีการตรวจจับ (catch) ในเมธอด run()

12.3.1 เมธอดของคลาส Thread

คลาสที่ชื่อ Thread มีเมธอดตางๆที่สําคัญดังนี้
• void run()
เปนเมธอดที่จะถูกเรียกใชเมื่อซีพียูรันโปรแกรมออปเจ็คแบบเธรด
• void start()
เปนเมธอดที่เรียกใชงานเพื่อกําหนดใหออปเจ็คแบบเธรด เริ่มทํางานโดยเขาสู
สถานะ Runnable
• void suspend()
เปนเมธอดที่ใชในการหยุดการทํางานของออปเจ็คแบบเธรด เมธอดนี้ไมมีการ
แนะนําใหใชในภาษาจาวาตั้งแตเวอรชั่น 1.2 เพื่อปองกันไมใหเกิดเหตุการณ
deadlock ที่จะกลาวถึงตอไป
• void resume()
เปนเมธอดที่ใชในการสั่งใหออปเจ็คแบบเธรดกลับเขาสูสถานะ Runnable
ภายหลังจากที่ถูกสั่งใหหยุดการทํางาน
• static void sleep(long mills)
เปนเมธอดที่กําหนดใหออปเจ็คแบบเธรดที่อยูในสถานะ Running หยุดการ
ทํางานเปนเวลา mills มิลลิวินาที หรือจนกวาถูกระงับการทํางาน
• boolean isAlive()
เปนเมธอดที่ใชตรวจสอบวาออปเจ็คแบบเธรดยังมีสถานะ Running อยูหรือไม

Java Programming 357

 • void setPriority(int p)
เปนเมธอดที่ใชในการกําหนดลําดับความสําคัญของออปเจ็คแบบเธรด ซึ่งจะมีคา
ไดระหวาง 1 ถึง 10 โดยที่คา 10 เปนคาสูงสุด
• int getPriority()
เปนเมธอดที่ใชในการเรียกดูคาลําดับความสําคัญของออปเจ็คแบบเธรด

12.4 Synchronization
กรณีที่ออปเจ็คแบบเธรดใชขอมูลรวมกันอาจเกิดปญหาที่เรียกวา race condition ขึ้น
ได ซึ่งเปนกรณีที่ออปเจ็คแบบเธรดตางแยงกันจัดการขอมูลทําใหไดขอมูลที่ผิดพลาด
โปรแกรมที่ 12.4 เปนตัวอยางกรณีของโปรแกรมจําลองระบบธนาคารซึ่งจะมีคลาส Bank ที่มี
บัญชีลูกคาอยู 10 บัญชีโดยมียอดเงินรวมของทุกบัญชีทั้งสิ้นจํานวน 100,000 บาท และมี
เมธอด transfer() ที่ใชในการโอนเงินระหวางบัญชีหนึ่งไปยังอีกบัญชีหนึ่งโดยใชคําสั่ง
accounts[from] -= amount
accounts[to] += amount
โดยที่ตัวแปร from คือหมายเลขบัญชีที่ตองการตัดโอนเงินไปและ to คือหมายเลข
บัญชีที่ตองการรับเงินเขามา คลาส TransferThread เปนคลาสแบบเธรดที่มีเมธอด
run() ซึ่งเรียกใชออปเจ็คของคลาส Bank เพื่อโอนเงินระหวางบัญชีใดๆแบบสุมโดยจะทํา
การโอนเงินซ้ําไปไมมีที่สิ้นสุด และทุกๆการโอนเงินจํานวน 10,000 ครั้ง จะพิมพยอดเงินรวม
ของบัญชีทุกบัญชีออกมาซึ่งควรจะมีคาเปน 100,000 บาท ตัวอยางผลลัพธที่ไดจากการรัน
โปรแกรมนี้ อาจเกิดปญหาที่แสดงใหเห็นวาเมื่อรันโปรแกรมไปไดระยะหนึง่ จะมีผลรวม
ยอดเงินที่ผิดพลาด ทั้งนี้เนื่องจากเกิดปญหาที่เรียกวา race condition ซึ่งออปเจ็คแบบเธรดแต
ละตัวอาจหยุดทํางานระหวางขั้นตอนใดๆของคําสั่งในเมธอด run() เพื่อใหออปเจ็คแบบเธ
รดตัวอื่นไดทํางาน ซึ่งคําสั่งแตละคําสั่งอาจมีขั้นตอนการทํางานหลายขั้นเชนคําสั่ง
account[to] += amount
จะไมใชเปนเพียงคําสั่งเดียวแตจะมีขั้นตอนตางๆดังนี้
1. โหลด account[to] เขาสูรีจิสเตอรในซีพียู
2. บวกคาในรีจิสเตอรดวยคาของ amount

3. มีผลลัพธจากรีจิสเตอรกลับมายัง account[to]

358 คณะเทคโนโลยีสารสนเทศ สถาบันเทคโนโลยีพระจอมเกลาเจาคุณทหารลาดกระบัง

โปรแกรมที่ 12.4 ตัวอยางกรณีของโปรแกรมจําลองระบบธนาคาร

public class BankSystemUnSync{

public static void main(String[] args){

final int NACCOUNTS = 10;

final int INITIAL_BALANCE = 10000;

Bank b = new Bank(NACCOUNTS, INITIAL_BALANCE);

int i;
for (i = 0; i < NACCOUNTS; i++){
Transfer t = new Transfer(b, i,
INITIAL_BALANCE);
t.setPriority(Thread.NORM_PRIORITY + i % 2);
t.start();
}
}
}

class Bank{
public static final int NTEST = 10000;
private final int[] accounts;
private long ntransacts = 0;

public Bank(int n, int initialBalance){

accounts = new int[n];
for (int i = 0; i < accounts.length; i++){
accounts[i] = initialBalance;
}
ntransacts = 0;
}

public void transfer(int from, int to, int amount){

if (accounts[from] < amount){
return;
}
accounts[from] -= amount;
accounts[to] += amount;
ntransacts++;
if (ntransacts % NTEST == 0) {
test();
}
}

Java Programming 359

 public void test() {
int sum = 0;
for (int i = 0; i < accounts.length; i++){
sum += accounts[i];
}
System.out.println("Transactions:" + ntransacts
+ " Sum: " + sum);
}

public int size() {

return accounts.length;
}
}

class Transfer extends Thread{

private Bank bank;
private int fromAccount;
private int maxAmount;

public Transfer(Bank b, int from, int max){

bank = b;
fromAccount = from;
maxAmount = max;
}

public void run(){

try{
while (!interrupted()){
int toAccount = (int)(bank.size() *
Math.random());
int amount = (int)(maxAmount *
Math.random());
bank.transfer(fromAccount, toAccount,
amount);
Thread.sleep(1);
}
}
catch(InterruptedException e) {}
}
}

360 คณะเทคโนโลยีสารสนเทศ สถาบันเทคโนโลยีพระจอมเกลาเจาคุณทหารลาดกระบัง

 ซึ่งการที่ออปเจ็คแบบเธรดหยุดการทํางานในขั้นตอนใดขั้นตอนหนึ่ง เพื่อเปดโอกาส
ใหออปเจ็คแบบเธรดตัวอื่นๆเขามาทํางาน ก็อาจจะทําใหไดผลลัพธผิดพลาดไดดังแสดงในรูปที่
12.6 (ก)
เราสามารถที่จะใชคียเวิรด synchronized เพื่อล็อก (lock) ชุดคําสั่งที่ออปเจ็ค
แบบเธรดตองกระทําพรอมกันไวได เพื่อแกปญหา race condition ซึ่งในกรณีนี้ออปเจ็คแบบ
เธรดจะไมหยุดการทํางานระหวางบล็อกคําสั่งที่ถูกล็อกไว และออปเจ็คแบบเธรด
ตัวอื่นๆจะตองรอใหซีพียูทําชุดคําสั่งที่ถูกล็อกไวใหเสร็จกอนแลวจึงเขามาทํางานตอไดดังแสดง
ในรูปที่ 12.6 (ข) ซึ่งออปเจ็คแบบเธรดจะปลดล็อก เมื่อสิ้นสุดคําสั่งที่ใชบล็อกคําสั่งของ
synchronized หรือเมื่อไดรับขอผิดพลาดจากออปเจ็คแบบ Exception

(ก) (ข)
รูปที่ 12.6 เปรียบเทียบการทํางานแบบ Unsynchronized และแบบ Synchronized

การใชคียเวิรด synchronized เพื่อล็อกคําสั่งทําไดสองรูปแบบคือ

1. กําหนดคียเวิรด synchronized ที่เมธอด
2. กําหนดบล็อกคียเวิรด synchronized
ตัวอยางของการกําหนดเมธอด transfer() ใหเปนแบบ synchronized
สามารถทําไดดังนี้

Java Programming 361

 public synchronized void transfer(int from, int to,
int amount) {
try {
if (accounts[from] < amount){
return;
}
accounts[from] -= amount;
accounts[to] += amount;
ntransacts++;
if (ntransacts % NTEST == 0) {
test();
}
}
catch(InterruptedException e) {}
}

12.4.1 เมธอด wait() และ notify()

เมธอด wait() และ notify() หรือ notifyAll() เปนเมธอดที่ใชกับเมธอด
หรือบล็อกคําสั่งที่เปน synchronized เมธอด wait() จะมีผลใหออปเจ็คแบบเธรดที่อยู
ในสถานะ Running กลับเขาสูสถานะบล็อกเพื่อรอใหออปเจ็คแบบเธรดตัวอื่นๆแจงใหกลับเขา
สูสถานะ Runnable โดยใชเมธอด notify() หรือ notifyAll()
ตัวอยางของโปรแกรมการโอนเงิน ที่อาจมีกรณีที่มีเงินอยูในบัญชีนอยกวายอดเงินที่
ตองการโอน ซึ่งในทีนี้จะไมอนุญาตใหโอนเงินโดยใชคําสั่ง
if (account[from]<amount) {
return;
}
แตก็อาจจะมีกรณีที่บัญชีเงินดังกลาวอาจไดรับการโอนเงินมาจากบัญชีอื่นๆแลวทําให
ยอดเงินในบัญชีเพิ่มขึ้นมาเพียงพอที่จะโอนเงินตามจํานวนเดิมที่กําหนดไวได ซึ่งกรณีนี้แสดง
วาจะตองมีคําสั่งใหรอจนกวายอดเงินในบัญชีเพียงพอ ซึ่งเราสามารถที่จะเขียนโปรแกรมได
โดยใชเมธอด wait() ปรับเปลี่ยนคําสั่งเปน
while(account[from]<amount){
wait();
}
คําสั่งนี้จะมีผลใหออปเจ็คแบบเธรดที่เรียกใชคําสั่งรอจนกวาจะมีออปเจ็คแบบเธรดตัวอื่นๆ
ใชคําสั่งในเมธอด notify() หรือ notifyAll() เพื่อระบุใหออปเจ็คนั้นๆสามารถทํางาน
ตอได ซึ่งในกรณีนี้จะเรียกใชเมื่อเมธอดสิ้นสุดคําสั่งในการโอนเงินไป
โปรแกรมที่ 12.5 แสดงตัวอยางของการปรับปรุงโปรแกรมจําลองระบบธนาคารโดย
ใชคียเวิรด synchronized เพื่อปองกันการผิดพลาดระหวางการโอนเงิน

362 คณะเทคโนโลยีสารสนเทศ สถาบันเทคโนโลยีพระจอมเกลาเจาคุณทหารลาดกระบัง

โปรแกรมที่ 12.5 ตัวอยางกรณีของโปรแกรมจําลองระบบธนาคารที่มี synchronized
public class BankSystem{
public static void main(String[] args){

final int NACCOUNTS = 10;

final int INITIAL_BALANCE = 10000;

Bank b = new Bank(NACCOUNTS, INITIAL_BALANCE);

int i;
for (i = 0; i < NACCOUNTS; i++){
Transfer t = new Transfer(b, i,
INITIAL_BALANCE);
t.setPriority(Thread.NORM_PRIORITY + i % 2);
t.start();
}
}
}

class Bank{
public static final int NTEST = 10000;
private final int[] accounts;
private long ntransacts = 0;

public Bank(int n, int initialBalance){

accounts = new int[n];
for (int i = 0; i < accounts.length; i++){
accounts[i] = initialBalance;
}
ntransacts = 0;
}

public synchronized void transfer(int from, int to,

int amount){
try{
while (accounts[from] < amount){
wait();
}
accounts[from] -= amount;
accounts[to] += amount;
ntransacts++;
notifyAll();
if (ntransacts % NTEST == 0) {
test();
}
}
catch(InterruptedException e) {}
}

Java Programming 363

 public synchronized void test(){
int sum = 0;

for (int i = 0; i < accounts.length; i++){

sum += accounts[i];
}

System.out.println("Transactions:" + ntransacts
+ " Sum: " + sum);
}

public int size(){

return accounts.length;
}
}

class Transfer extends Thread{

private Bank bank;
private int fromAccount;
private int maxAmount;

public Transfer(Bank b, int from, int max){

bank = b;
fromAccount = from;
maxAmount = max;
}

public void run(){

try{
while (!interrupted()){
int toAccount = (int)(bank.size() *
Math.random());
int amount = (int)(maxAmount *
Math.random());
bank.transfer(fromAccount, toAccount,
amount);
Thread.sleep(1);
}
}
catch(InterruptedException e) {}
}
}

364 คณะเทคโนโลยีสารสนเทศ สถาบันเทคโนโลยีพระจอมเกลาเจาคุณทหารลาดกระบัง

12.4.2 Deadlock
ในกรณีที่ออปเจ็คแบบเธรดทุกออปเจ็คถูกเรียกใชคําสั่ง wait() ทั้งหมดโดยไมมี
ออปเจ็คใดสามารถเรียกคําสั่ง notify() หรือ notifyAll() ได จะเปนกรณีที่ออปเจ็ค
แตละตัวรอการปลดล็อกจากกันและกัน จึงทําใหเกิดสถานการณที่เรียกวา dead lock ซึ่งจะทํา
ใหไมมีการทํางานใดๆเกิดขึ้น ตัวอยางเชน ถาคลาส Bank ของโปรแกรมที่ผานมามีบัญชี
เพียงสองบัญชีโดยบัญชีที่หนึ่งมียอดเงิน 2,000 บาท และบัญชีที่สองมียอดเงิน 3,000 บาท
และถาออปเจ็คแบบเธรดตัวที่หนึ่งมีคําสั่ง transfer() เพื่อโอนเงินจากบัญชีที่หนึ่งไปยัง
บัญชีที่สองเปนเงิน 3,000 บาท และออปเจ็คแบบเธรดตัวที่สองมีคําสั่ง transfer() เพื่อ
โอนเงินจากบัญชีที่สองไปยังบัญชีที่หนึ่งเปนเงิน 4,000 บาท กรณีนี้จะเกิดเหตุการณ
deadlock ขึ้นดังแสดงในรูปที่ 12.7
การปองกันการเกิด deadlock สามารถทําไดโดยการจัดลําดับการล็อกออปเจ็คแบบ
เธรดใหถูกตอง

รูปที่ 12.7 เหตุการณ deadlock

Java Programming 365

 สรุปเนื้อหาของบท
• เธรดจะแตกตางจาก process ที่ทํางานภายใตระบบปฏิบัติการแบบ Multitasking
ตรงที่ process แตละ process จะมีความเปนอิสระตอกัน แตเธรดแตละเธรดอาจ
ใชขอมูลรวมกันซึ่งเปรียบเสมือนซีพียูจําลอง (Virtual CPU)
• เธรดประกอบไปดวยซีพียู ซอรดโคดและออปเจ็ค
• คลาสแบบเธรดในภาษาจาวาคือคลาสที่สืบทอดมาจากคลาสที่ชื่อ Thread หรือ
คลาสที่ implements อินเตอรเฟสที่ชื่อ Runnable
• ภายในคลาสแบบเธรดจะตองมีเมธอด run() ที่ไมมีการรับ argument ใดๆเขา
มา
• สถานะของเธรดอาจจะเปน New, Runnable, Running, Blocked หรือ Dead
โดยการเขาสูสถานะ Running จะขึ้นอยูกับตัวจัดตารางเวลา
• เราสามารถที่จะใชคียเวิรดที่ชื่อ synchronized เพื่อล็อก (lock) ชุดคําสั่งที่
ออปเจ็คแบบเธรดตองกระทําพรอมกันไวได
• Deadlock หมายถึงการที่ออปเจ็คแตละตัวรอการปลดล็อกจากกันและกัน ทําให
ไมมีการทํางานใดๆเกิดขี้น

366 คณะเทคโนโลยีสารสนเทศ สถาบันเทคโนโลยีพระจอมเกลาเจาคุณทหารลาดกระบัง

 ศัพทานุกรม
คําศัพท ความหมาย
abstract class คลาสที่มีการนิยามเมธอดบางเมธอดภายในคลาส
ขึ้นมากอน แตยังไมไดกําหนดบล็อกคําสั่งตางๆ
ภายในเมธอดเหลานั้น
access modifier คียเวิรดที่ใชเพื่อระบุระดับการเขาถึง
argument ตัวแปรที่ใชในการรับขอมูลที่ออปเจ็คสงมาเพื่อ
นําไปใชในเมธอด
arithmetic expression นิพจนคณิตศาสตร ซึ่งจะใหผลลัพธเปนขอมูล
ชนิดจํานวนเต็มหรือจํานวนทศนิยม
arithmetic operator ตัวดําเนินการทางคณิตศาสตร โดยจะใหผลลัพธ
เปนขอมูลชนิดจํานวนเต็มหรือจํานวนทศนิยม
array อะเรย ซึ่งเปนชนิดขอมูลแบบอางอิงที่สามารถใช
เก็บขอมูลชนิดเดียวกันไดหลายคา
assignment statement คําสั่งที่ใชในการกําหนดคาใหกับตัวแปร
attribute คุณลักษณะหรือขอมูลที่เก็บอยูในออปเจ็ค
AWT (Abstract Windowing Toolkit) แพคเก็จที่ประกอบไปดวยคลาสตางๆที่เปน
ประเภทสวนประกอบกราฟฟก
bitwise operator ตัวดําเนินการแบบบิต เปนตัวดําเนินการที่ใชกับ
ขอมูลชนิดตัวเลขจํานวนเต็ม
byte code โปรแกรมที่ไดจากการคอมไพลโปรแกรมภาษา
จาวา
byte code verifier โปรแกรมที่ใชในการตรวจสอบโปรแกรมไบทโคด
วาถูกตองตามขอกําหนดของ JVM หรือไม
byte stream stream ที่ใชในการรับหรือสงขอมูลชนิด byte
case sensitive การที่ถือวาตัวอักษรพิมพใหญและตัวอักษรพิมพ
เล็กตางกัน

Java Programming 367

 คําศัพท ความหมาย
character stream stream ที่ใชในการรับหรือสงขอมูลชนิด char
class เปรียบเสมือนพิมพเขียวของออปเจ็ค
class data value คุณลักษณะของคลาส ซึ่งจะเปนคุณลักษณะที่ใช
รวมกันของทุกออปเจ็ค
class diagram เปนสัญลักษณที่ใชแสดงคลาสใน UML
class loader โปรแกรมที่ใชในการโหลดทุกคลาสที่จําเปนตอ
การรันโปรแกรม
comment ขอความที่แทรกอยูภายในโปรแกรมซึ่งจะไมมผี ล
ตอการทํางานของโปรแกรม
compiler ตัวแปลภาษาที่จะแปลชุดคําสั่งของภาษา
คอมพิวเตอรระดับสูงใหเปนภาษาเครื่องทั้งหมด
ในหนึ่งครั้ง
constant คาคงที่ที่ไมสามารถเปลี่ยนคาได
constructor เมธอดที่มีชื่อเดียวกับชื่อคลาสซึ่งจะถูกเรียกใช
งานเมื่อมีการสรางออปเจ็คโดยใชคําสั่ง new
container ตัวใสสวนประกอบกราฟฟก
control structure คําสั่งที่ใชในการกําหนดลําดับการทํางานของ
คําสั่งตางๆ
delegation model หลักการหรือวิธีการที่จะจัดการกับเหตุการณ
encapsulation คุณลักษณะเดนของโปรแกรมเชิงออปเจ็คที่จะทํา
การซอนเรนขอมูลไว
error ขอผิดพลาดที่เราไมสามารถเขียนโปรแกรมเพื่อ
แกไขและจัดการได
event เหตุการณหรือสถานการณที่เกิดขึ้นในขณะรัน
โปรแกรม
event handler ออปเจ็คที่จะทําหนาที่จัดการกับเหตุการณที่
เกิดขึ้น

368 คณะเทคโนโลยีสารสนเทศ สถาบันเทคโนโลยีพระจอมเกลาเจาคุณทหารลาดกระบัง

คําศัพท ความหมาย
event source ออปเจ็คที่ทําใหเกิดเหตุการณ
exception ขอผิดพลาดที่สามารถแกไขและจัดการได
executable code โปรแกรมที่ไดมาจากการแปลภาษาคอมพิวเตอร
ระดับสูง
exponential form รูปแบบของเลขยกกําลังสิบ อาทิเชน 6.02E23
หรือ 2e-7
expression นิพจนที่อาจประกอบไปดวยคาคงที่ขอมูล
ตัวแปร และตัวดําเนินการตางๆ
final class คลาสที่จะไมสามารถใหคลาสอื่นสืบทอดได
floating point ตัวเลขทศนิยม
flowchart ผังงานที่แสดงใหเห็นถึงลําดับการทํางานของ
โปรแกรม
graphical component สวนประกอบกราฟฟก
GUI (Graphical User Interface) สวนติดตอกับผูใชเปนแบบกราฟฟก
heterogenous collection การเก็บขอมูลที่มีชนิดขอมูลตางกันในกลุม
เดียวกัน
high-level stream ออปเจ็คของคลาสประเภท steam ระดับสูง ซึ่งจะ
รับขอมูลมาจาก stream อื่นๆที่เปนคลาสพื้นฐาน
ในการอานหรือเขียนขอมูลแลวแปลงขอมูลใหมี
ชนิดขอมูลเปนแบบ byte
homogeneous collection การเก็บขอมูลชนิดเดียวกันในตัวแปรชื่อเดียวกัน
HTML (HyperText Markup Language) ภาษาที่ใชในการเขียนโปรแกรมเว็บเพจ
IDE (Integrated Development Environment) โปรแกรมที่ใชในการพัฒนาโปรแกรมภาษา
คอมพิวเตอรใดๆ ซึ่งจะประกอบไปดวยโปรแกรม
อีดิเตอร คอมไพเลอร และดีบักเกอร
identifier ชื่อที่ตั้งขึ้นเพื่อเปนชื่อของคลาส ชื่อของตัวแปร
ชื่อของเมธอด หรือชื่อของคาคงที่

Java Programming 369

 คําศัพท ความหมาย
immutable object ออปเจ็คที่เปลี่ยนคาไมได ตัวอยางเชน ออปเจ็ค
ของคลาส String
implementation สวนของออปเจ็คที่ไมสามารถเขาถึงไดจาก
ภายนอก
import คําสั่งที่ใชในการเรียกใชคลาสในแพคเก็จตางๆ
information hiding การซอนเรนคุณลักษณะของออปเจ็คไวภายใน
ออปเจ็ค
inheritance คุณลักษณะเดนของโปรแกรมเชิงออปเจ็คที่
กําหนดใหคลาสใดๆสามารถสืบทอดคลาสอื่นได
inner class คลาสที่ประกาศอยูภายในคลาสอื่น
input stream ตําแหนงเริ่มตนของ stream ที่ตนทาง
instance ออปเจ็คที่ถูกสรางมาจากคลาส
interface สวนของออปเจ็คที่อนุญาตใหออปเจ็คอื่นสามารถ
เรียกใชงานได หรือคลาสที่มีลักษณะคลายกับ
คลาสแบบ abstract แตจะประกอบดวย
เมธอดที่ยังไมสมบูรณเทานั้น
interpreter ตัวแปลภาษาที่จะแปลชุดคําสั่งของ
ภาษาคอมพิวเตอรระดับสูงทีละคําสั่งใหเปน
ภาษาเครื่อง
J2EE (Java 2 Platform, Enterprise Edition) แพลตฟอรมที่ใชเพื่อพัฒนาโปรแกรมภาษาจาวา
บนเครื่องแมขายสําหรับระบบงานในองคกร
J2ME (Java 2 Platform, Micro Edition) แพลตฟอรมที่ใชเพื่อพัฒนาโปรแกรมภาษาจาวา
บนอุปกรณขนาดเล็ก เชน โทรศัพทเคลื่อนที่
หรือ PDA เปนตน
J2SE (Java 2 Platform, Standard Edition) แพลตฟอรมที่ใชเพื่อพัฒนาโปรแกรมภาษาจาวา
บนเครื่องไมโครคอมพิวเตอรทั่วไป
Java 2 SDK (Software Development Kit) ชุดพัฒนาโปรแกรมภาษาจาวาของบริษัทซัน
ไมโครซิสเต็มส ซึ่งแตเดิมเรียกวา JDK

370 คณะเทคโนโลยีสารสนเทศ สถาบันเทคโนโลยีพระจอมเกลาเจาคุณทหารลาดกระบัง

คําศัพท ความหมาย
Java API (Application Programming เปนชุดแพ็คเกจที่รวบรวมคลาสและอินเตอรเฟส
Interface) ตางๆที่เปนประโยชนตอการใชงานของโปรแกรม
ที่พัฒนาโดยภาษาจาวา
Java Applet โปรแกรมภาษาจาวาที่จะทํางานภายใตโปรแกรม
เว็บบราวเซอรที่มี JVM อยู
Java Application โปรแกรมประยุกตใชงานทั่วไป โดยโปรแกรม
แบบนี้จะทํางานภายใตโปรแกรมอินเตอร-
พรีตเตอรโดยตรง
JFC (Java Foundation Classes) แพคเก็จซึ่งประกอบดวยแพคเก็จยอยตางๆที่
สําคัญในการพัฒนาโปรแกรมทางดานกราฟฟก
JRE (Java Runtime Environment) เทคโนโลยีจาวาที่ใชในการรันโปรแกรม
JVM (Java Virtual Machine) เครื่องจักรสมมุติจาวาที่ทําหนาที่เปนอินเตอร-
พรีตเตอร ซึ่งจะแปลโปรแกรมไบทโคดแลว
สั่งงานไปยังเครื่องคอมพิวเตอร
keyword ชื่อที่มีความหมายเฉพาะ ซึ่งกําหนดเปนคําสั่งใน
ภาษาจาวา
layout manager ตัวจัดวางผังสวนประกอบ
listener การรับฟงเหตุการณ
literal ขอมูลคาคงที่ที่ใชแสดงขอมูลที่เปนตัวเลข
ตัวอักขระ ขอความ หรือคาทางตรรกะ
local variable ตัวแปรที่อยูภายในบล็อกของเมธอด
lock ล็อกชุดคําสั่งที่ออปเจ็คแบบเธรดตองกระทํา
พรอมกันไวได
logical expression นิพจนตรรกศาสตร ซึ่งจะใหผลลัพธเปนขอมูล
ตรรกะ

Java Programming 371

 คําศัพท ความหมาย
logical operator ตัวดําเนินการทางตรรกศาสตร ซึ่งจะใชกับตัวถูก
ดําเนินการที่เปนนิพจนตรรกศาสตร หรือชนิด
ขอมูล boolean โดยจะใหผลลัพธเปนขอมูล
ชนิดตรรกะ
look and feel รูปแบบการแสดงโปรแกรมกราฟฟกที่ขึ้นอยูกับ
แพลตฟอรมที่ใชงาน
method วิธีการหรือการกระทําที่นิยามอยูในคลาสเพื่อใช
ในการจัดการกับคุณลักษณะของออปเจ็คหรือ
คุณลักษณะของคลาส
modifier คียเวิรดที่ใชในการบอกคุณลักษณะของตัวแปร
หรือเมธอด
modularity ความเปนอิสระตอกันของออปเจ็คแตละออปเจ็ค
multiple inheritance การที่คลาสใดๆสามารถสืบทอดคลาสอื่นไดหลาย
คลาส
multitasking การกําหนดใหโปรแกรมสามารถทํางานหลายงาน
พรอมกันได
multithreaded การทํางานหลายงานพรอมกันโดยแตละงานจะ
เรียกวาเธรด ซึ่งเธรดอาจมีการใชขอมูลรวมกัน
narrowing conversion การแปลงจากชนิดขอมูลที่มีขนาดใหญกวาไป
เปนชนิดขอมูลที่มีขนาดเล็กลง
nested structure โครงสรางที่มีคําสั่งโครงสรางควบคุมอยูซอนกัน
node ตนทางและปลายทางของ stream อาจเปน
ฮารดแวรหรือซอฟตแวร เชน ไฟล socket หรือ
หนวยความจํา เปนตน
null ขอมูลคาคงที่สําหรับชนิดขอมูลแบบอางอิงที่ยัง
ไมมีการกําหนดคาเริ่มตน
object สิ่งตางๆที่มีอยูในชีวติ ประจําวันทั้งที่เปนรูปธรรม
และนามธรรม

372 คณะเทคโนโลยีสารสนเทศ สถาบันเทคโนโลยีพระจอมเกลาเจาคุณทหารลาดกระบัง

คําศัพท ความหมาย
object diagram ไดอะแกรมที่ใชแสดงออปเจ็คใน UML
OMG (Object Management Group) องคกรที่กําหนดมาตรฐานที่ใชในการจําลองระบบ
ซอฟตแวร
OOP (Object Oriented Programming) โปรแกรมเชิงออปเจ็คที่จําลองปญหาวาประกอบ
ไปดวยออปเจ็คใดบาง
operand ตัวถูกดําเนินการของนิพจน ตัวอยางเชน 3/6
ตัวเลข 3 และ 6 เปนตัวถูกดําเนินการ
operator ตัวดําเนินการของนิพจน ตัวอยางเชน 3/6
เครื่องหมาย / เปนตัวดําเนินการ
output stream ตําแหนงสิ้นสุดของ stream ที่ปลายทาง
overloaded method เมธอดที่ใชชื่อเดียวกัน แตจะมีรปู แบบของการ
ประกาศที่แตกตางกัน
overridden method เมธอดที่สรางขึ้นมาใหมใน subclass โดยใชชื่อ
และรูปแบบของการประกาศเหมือนเมธอดใน
superclass แตคําสั่งที่อยูภายในเมธอดจะ
แตกตางจากเดิม
package คําสั่งที่ใชในการระบุวาโปรแกรมไฟลอยูใน
แพคเก็จใด
platform ฮารดแวรและสภาวะแวดลอมทางซอฟตแวรที่
โปรแกรมจะใชในการประมวลผลโดยทั่วไป
polymorphism คุณลักษณะเดนของโปรแกรมเชิงออปเจ็คที่
สามารถกําหนดออปเจ็คไดหลายรูปแบบ
primitive data type ชนิดขอมูลแบบพื้นฐาน ซึ่งภาษาจาวากําหนดไว
8 ชนิดคือ boolean,char,byte,
short,int,long,float และ double

race condition กรณีที่ออปเจ็คแบบเธรดตางแยงกันจัดการขอมูล

ซึ่งจะทําใหไดขอมูลที่ผิดพลาด

Java Programming 373

 คําศัพท ความหมาย
reference data type ชนิดขอมูลแบบอางอิง ซึ่งแบงออกไดเปนสอง
แบบคือ ชนิดขอมูลที่เปนคลาส และชนิดขอมูลที่
เปนอะเรย
relational operator ตัวดําเนินการแบบสัมพันธ ซึ่งใชในการเปรียบ
เทียบคาของขอมูลชนิดใดๆสองคา โดยจะให
ผลลัพธเปนขอมูลชนิดตรรกะ
return type ชนิดขอมูลของคาที่สงกลับหลังจากเสร็จสิ้นการ
ทํางานของคําสั่งในเมธอด
runtime interpreter โปรแกรมที่ใชในการรันโปรแกรมไบทโคด
SDLC (Software Development Life Cycle) วัฎจักรการพัฒนาโปรแกรม ซึง่ จะเปนขั้นตอน
ทั้งหมดในการพัฒนาโปรแกรม
selection structure โครงสรางแบบเลือกทํา ซึ่งจะเลือกทําชุดคําสั่งใน
กรณีที่นิพจนตรรกศาสตรมีคาเปนจริงตาม
เงื่อนไขที่กําหนดไว
separator สัญลักษณแยกคํา ตัวอยางเชน เครื่องหมาย , ที่
ใชสําหรับแยกตัวแปรหรือคําสั่งในภาษาจาวา
sequential structure โครงสรางแบบตามลําดับ ซึ่งจะทํางานตามลําดับ
ของคําสั่งที่มีอยูในโปรแกรม
shortcut operator ตัวดําเนินการแบบยอ เพื่อใชแทนตัวดําเนินการ
ทางคณิตศาสตรท่ตี องการเปลี่ยนแปลงคาของตัว
แปรทางดานซายของคําสั่ง ตัวอยางเชน +=
sink ปลายทางของ stream
source ตนทางของ stream
source code โปรแกรมที่เขียนขึ้นโดยใชภาษาคอมพิวเตอร
ระดับสูง
stream สวนที่เปรียบเสมือนทอในการสง

374 คณะเทคโนโลยีสารสนเทศ สถาบันเทคโนโลยีพระจอมเกลาเจาคุณทหารลาดกระบัง

คําศัพท ความหมาย
strongly typed language ภาษาที่ตองระบุชนิดขอมูลอยางชัดเจน กลาวคือ
ตัวแปรหรือคาคงที่ทุกตัวที่ใชในโปรแกรม จะตอง
ระบุชนิดขอมูลดวยเสมอ
subclass คลาสที่เปนคลาสเฉพาะ ซึ่งจะสืบทอดมาจาก
คลาสแบบทั่วไปโดยใชคียเวิรด extends
superclass คลาสที่เปนคลาสแบบทั่วไป ซึ่งจะมีคุณลักษณะ
และเมธอดเพื่อใหคลาสอื่นๆที่เปนคลาสเฉพาะ
สืบทอดได
tag องคประกอบที่สําคัญในการเขียนไฟล HTML ซึ่ง
จะใชเพื่อระบุคุณลักษณะตางๆ เชน ชื่อของ
โปรแกรมไบทโคด โดยจะอยูภายในเครื่องหมาย
< และ >
typecasting การแปลงชนิดขอมูลใหเปนชนิดขอมูลที่มีขนาด
เล็กลง
UML (Unified Modeling Language) ภาษาที่ใชรูปกราฟฟกเพื่อจําลองระบบซอฟตแวร
variable ตัวแปรที่สามารถเปลี่ยนคาได
web browser โปรแกรมเว็บบราวเซอร
whitespace ชองวางเพื่อแยกคํา ประโยค หรือคําสั่งตางๆ
ภายในโปรแกรม
widening conversion การแปลงจากชนิดขอมูลที่มีขนาดเล็กกวาไปเปน
ชนิดขอมูลที่มีขนาดใหญกวา

Java Programming 375

376 คณะเทคโนโลยีสารสนเทศ สถาบันเทคโนโลยีพระจอมเกลาเจาคุณทหารลาดกระบัง
 ดัชนี

-- 49 Arithmetic Operator 47
! 53 ArrayIndexOutOfBoundException 260
!= 50 ArrayList 278
%= 49 attribute 99
& 53, 55 AudioClip 318
&& 53, 55 AWT 125
*= 49 AWTEvent 235
/= 49 binarySearch() 271
^ 53, 55 Bitwise Operator 47
++ 49 boolean 34, 35
+= 49 BorderLayout 132
< 50 break 94
<= 50 Button 138
-= 49 byte 34, 37
== 50 Canvas 161, 171
> 50 Casting 203
>= 50 catch 290
abstract 182, 221 char 34, 36
access modifier 106 character stream 324
ActionEvent 237 Checkbox 143
addActionListener 243 CheckboxGroup 145
AND 53 CheckboxMenuItem 155
Applet 130, 308 child class 113
args[] 69 Choice 146
argument 176, 230 class 104

Java Programming 377

 Class Loader 12 Exception 287
Collection 274 Exclusive-OR 54
Collection API 274 extends 114, 190
Color 159, 314 false 32
Component 125 File 341
constructor 206, 208 FileNotFoundException 341
constructor แบบ overloaded 208 FileReader 332
Container 126 FileWriter 332
content pane 166 fill() 271
continue 94 final 42, 70, 182, 220
DataInputStream 336 finally 294
DataOutputStream 337 float 35, 39
Deadlock 365 FlowLayout 134
default 183 Font 159, 314
default constructor 206 for 89
Delegation Model 242 Foreground 158
Dialog 130 Frame 127
do..while 88 Graphics 161, 310
double 35, 39 GridLayout 136
double precision 38 GUI 123
Dynamic Binding 196 HashMap 279
Encapsulation 111 HashSet 276
Enumeration 282 Hot Java 9
equals() 215 identifier 30, 70
Error 287 if 74
Event 235 if แบบซอน 79
Event Adapter 250 if..else 76
Event Handler 236 if..else if..else 81

378 คณะเทคโนโลยีสารสนเทศ สถาบันเทคโนโลยีพระจอมเกลาเจาคุณทหารลาดกระบัง

Image 316 Label 139
immutable object 65 LayoutManager 131
implementation 111 LinkedList 278
import 230 List 148, 274, 277
Inheritance 111 ListIterator 282
input stream 323 ll 53, 55
InputStream 326 Logical Operator 47
InputStreamReader 339 long 34, 37
instance 100 main() 107
instanceof 202 Map 274, 279
int 34, 37 Math 66
interface 111, 223 Menu 151
IOException 289 MenuBar 150
ItemEvent 239 MenuComponent 149
Iterator 280 MenuItem 153
J2EE 16, 18 modifier 104
J2ME 16, 19 MouseEvent 238
J2SDK 10 Multitasking 349
J2SE 16, 17 multithreaded 349
Java 2 SDK 13 new 207
Java API 15 notify() 362
Java Foundation Classes 123 null 33, 62
JComponent 164 NullPointerException 289
JFrame 166 Oak 8

JRE 10, 12, 371 Object 195, 213

JVM 11, 15 ObjectInputStream 344
l 53, 55 ObjectOutputStream 344
label 96 OR 53

Java Programming 379

 output stream 323 Serializable 344
OutputStream 328 Set 274, 276
OutputStreamWriter 340 setLayout() 131
package 230 short 34, 37
paint() 161 single precision 38
Panel 129, 162 sleep() 356
PARAM 307 software maintenance 120
parent class 113 sort() 271
Platform 15 specific class 113
Polymorphism 111 start() 357
primitive data type 34 static 176, 182, 217, 220
print() 68 Static Initializer 219
println() 68 stream 323
PrintWriter 340 String 63
private 183 subclass 113
process 349 super 195, 231
protected 182, 194 super() 211
public 182 superclass 113
race condition 358 Swing 124, 164
RandomAccessFile 343 switch 82
Reader 330 synchronized 182, 361
reference data type 34 System.err 68
Relational Operator 47 System.in 67
repaint() 314 System.out 67
run() 352 tag 304
Runnable 352 TextArea 141
RuntimeException 288 TextField 139
SDLC 118 this 188

380 คณะเทคโนโลยีสารสนเทศ สถาบันเทคโนโลยีพระจอมเกลาเจาคุณทหารลาดกระบัง

this() 209, 210, 232 ขอกําหนดตามความตองการ 119
Thread 351, 354 ขอผิดพลาด 287
throw 299 ขอมูลคาคงที่ 34, 70
Throwable 288 ขอมูลชนิดตัวเลขทศนิยม 38
throws 296, 297 ขาวสาร 103
toString() 214 คลาส 100, 104, 120
true 32 คลาสแบบ anonymous 251
try 290 คลาสประเภท Wrapper 216
type conversion 57 คลาสภายใน 225
typecasting 60 ความเปนโมดูล 112
UML 116, 121 คอมไพเลอร 5
Unicode 36 คอมเม็นต 29, 70
Vector 283 คอลเล็กชั่น 274
wait() 362 คอลเล็กชั่นแบบ Heterogeneous 201
while 85 คาคงที่ 39, 42, 70, 101
Window 127 คาคงที่ภายใน 44
WindowEvent 238 คาที่สงกลับ 106, 181, 231
Writer 330 คําสั่งกําหนดคา 40
การกลับคา 53 คําสั่งโครงสรางควบคุม 73, 97
การซอนเรนขอมูล 112, 184 คียเวิรด 32, 70
การบํารุงรักษาโปรแกรม 120 คุณลักษณะ 99, 101
การแปลงขอมูลที่กวางขึ้น 58 คุณลักษณะของคลาส 102
การแปลงขอมูลที่แคบลง 58 คุณลักษณะของออปเจ็ค 101, 105
การแปลงชนิดขอมูล 57 คูมือ Java API 25
การมีไดหลายรูปแบบ 115 เครื่องจักรสมมุติจาวา 11
การศึกษาความเปนไปได 119 โครงสรางแบบซอน 92
การสืบทอด 113, 189 โครงสรางแบบตามลําดับ 73
การหอหุม 111, 184 โครงสรางแบบทําซ้ํา 85

Java Programming 381

 โครงสรางแบบเลือกทํา 74 โปรแกรมแบบมัลติเธรด 349
จาวาแอปเพล็ต 17 โปรแกรมไบทโคด 10, 11
ชนิดขอมูลตรรกะ 35 โปรแกรมประยุกต 1
ชนิดขอมูลตัวเลขจํานวนเต็ม 37 พฤติกรรม 99
ชนิดขอมูลตัวอักขระ 36 แพคเก็จ 25, 228
ชนิดขอมูลที่เปนคลาส 61, 71 แพลตฟอรม 15
ชนิดขอมูลแบบพื้นฐาน 34 ฟอนต 158
ชนิดขอมูลแบบอางอิง 34, 61, 71 ภาษา C++ 4
ชองวาง 33 ภาษา Smalltalk 5
ซีพียูจําลอง 349 ภาษาเครื่อง 2
ไดอะแกรมของคลาส 116 ภาษาโคบอล 3
ไดอะแกรมของออปเจ็ค 117 ภาษาเชิงกระบวนการ 4
ตัวดําเนินการ 40, 47 ภาษาซี 4
ตัวดําเนินการทางคณิตศาสตร 47 ภาษาเบสิก 3
ตัวดําเนินการทางตรรกศาสตร 52 ภาษาปาสคาล 4
ตัวดําเนินการทางตรรกศาสตรแบบ ภาษาฟอรแทรน 3
short circuit 54 ภาษาระดับสูง 3
ตัวดําเนินการแบบบิต 54 ภาษาแอสเซมบลี 2
ตัวดําเนินการแบบยอ 48 เมธอด 99, 103, 105, 173
ตัวดําเนินการแบบสัมพันธ 50 เมธอดแบบ accessor 185
ตัวดําเนินการเพิ่มคา 49 เมธอดแบบ getter 186
ตัวดําเนินการลดคา 49 เมธอดแบบ overloaded 198
ตัวแปร 39, 70, 101 เมธอดแบบ overriden 199
ตัวแปรชั่วคราว 45 เมธอดแบบ setter 185
ตัวแปรภายใน 44 เมนู 149
นิพจน 40 เมนูยอย 157
โปรแกรมจาวาประยุกต 17, 20 ระบบปฏิบัติการ 1
โปรแกรมจาวาแอปเพล็ต 22, 303 เลขฐานแปด 37

382 คณะเทคโนโลยีสารสนเทศ สถาบันเทคโนโลยีพระจอมเกลาเจาคุณทหารลาดกระบัง

เลขฐานสิบหก 37 อะเรยของขอมูลชนิดคลาส 261
วงจรการทํางานของเธรด 355 อะเรยของขอมูลชนิดพื้นฐาน 254
วัฎจักรการพัฒนาโปรแกรม 118, 121 อะเรยหลายมิติ 264
สมาชิกของออปเจ็ค 109 อินเตอรพรีตเตอร 6
สมาชิกของอะเรย 257 อินเตอรเฟส 223
สัญลักษณแยกคํา 33 อินเตอรเฟสประเภท Listener 240
เหตุการณ 235 อินพุต 67
โหนด 323 เอาทพุต 67
ออปเจ็ค 99, 107, 120 ฮารดแวร 1
อะเรย 253, 367

Java Programming 383

384 คณะเทคโนโลยีสารสนเทศ สถาบันเทคโนโลยีพระจอมเกลาเจาคุณทหารลาดกระบัง
 บรรณานุกรม

Java Programming Language for Non-Programmers SL-110, Rev C.2, Sun

Educational Service, June 2001
Java Programming Language SL-275, Rev E.1, Sun Educational Service, Rev E.1,
May 2001
C. Thomas Wu, An introduction to Object-Oriented Programming with Java, 2nd
Edition, McGraw-Hill, 2001
Cay S. Horstmann and Gray Cornell, Core Java 1.2 Fundamentals, Volume I,
Pearson Education, 1999
Cay S. Horstmann and Gray Cornell, Core Java 2 Advanced Features, Volume II,
Pearson Education, 2000
Duane A. Bailey and Duane W. Bailey, Java Elements Principles of Programming
in Java, McGraw-Hill, 2000
H. M. Deitel and P. J. Deitel, Jave How To Program, Prentice Hall, 1997
Jacquie Barker, Beginning Java Objects from Concepts to Code, Wrox Press, 2001
Judy Bishop, Java Gently, Addison Wesley, 1997
Michael Smith, Java an Object-Oriented Language, McGraw-Hill, 1999
Patrick Chan, The Java Developers ALMANAC, Addison-Wesley, 1999
Rick Decker and Stuart Hirshfield, An Introduction to Programming Using Java, 2nd
Edition, Brooks/Cole Thomson Learning, 2000
Stephen J. Chapman, Introduction to Java, Prentice Hall, 2000
Y. Daniel Liang, Introduction to Java Programming, 3rd Edition, Pearson Education,
2001
ดร. วีระศักดิ์ ซึงถาวร, Java Programming Volume I, บริษัท ซีเอ็ดยูเคชั่น, 2543
http://java.sun.com

Java Programming 385

2 ศูนยเทคโนโลยีอเิ ล็กทรอนิกสและคอมพิวเตอรแหงชาติ