Java Tutor1

Introduction to Java Programming - 01 Computer Programming using Java 1
CHAPTER เริม่ ต้นการเขียนโปรแกรมภาษาจาวา

01 (Introduction to Java Programming)
1. แนวคิดการเขียนโปรแกรมภาษาจาวา (Java Programming Concept)
1. หลักการเขียนโปรแกรมคอมพิวเตอร์
การเขียนโปรแกรมคอมพิวเตอร์ ที่ดีและให้ ประมวลผลได้ อย่างถูกต้ องนันจะต้
้ องมีข้อปฏิบตั ิ 2 ข้ อที่สําคัญ คือ
1) เขียนให้ ถกู ต้ องตามหลักไวยากรณ์ (Syntax) ของภาษาคอมพิวเตอร์ ที่ใช้ Æ ต้ องรู้องค์ประกอบของภาษา
และชุดคําสัง่ ของภาษา
2) เขียนให้ เป็ นระเบียบเรี ยบร้ อย สวยงาม และอ่านง่าย Æ ฝึ กนิสยั การเป็ นโปรแกรมเมอร์ ที่ดี
2. องค์ ประกอบหลักของโปรแกรมภาษาจาวา
1 public class HelloJava {
2 public static void main(String[] args) { ตัวอย่างโปรแกรมภาษาจาวา
3 System.out.println("Hello Java");
4 } ขันพื
้ ้นฐาน
5 }
องค์ประกอบของโปรแกรมภาษาจาวาแบบพื ้นฐานที่สดุ จะต้ องประกอบไปด้ วยองค์ประกอบ 3 ส่วนหลัก ได้ แก่

1) คลาส (Class)
ใช้ เครื่ องหมายปี กกาในการบอกขอบเขตของคลาส
1 2 3 4
1 public class HelloJava { ปี กกาปิ ดต้ องเขียนตรงกับตัว p ของคําว่า public บนหัวคลาส
2
3 ชื่อคลาส นิยมขึ ้นต้ นด้ วยตัวพิมพ์ใหญ่
4 คําหรื อคีย์เวิร์ดแต่ละคําต้ องมีการ
5 } ตัวพิมพ์ใหญ่และตัวพิมพ์เล็กมีความหมายไม่เหมือนกัน เว้ นช่องว่างอย่างน้ อย 1 ช่องว่าง
2) เมท็อด (Method) ใช้ เครื่ องหมายปี กกาในการบอกขอบเขตของเมท็อดซึง่ อยูซ่ ้ อน

1 2 3 4 เข้ าไปภายในขอบเขตของคลาสอีกชันหนึ
้ ง่
2 public static void main(String[] args) { ปี กกาปิ ดต้ องเขียนตรงกับตัว
3 p ของคําว่า public บนหัว
4 }
5 } ชื่อเมท็อด นิยมขึ ้นต้ นด้ วยตัวพิมพ์เล็ก เมท็อด
3) คําสั่ง (Statement)
1 2 3 4 ขอบเขตของคําสัง่ จะอยูซ่ ้ อนเข้ าไปภายในขอบเขตของเมท็อดอีกชันหนึ
้ ง่
2 public static void main(String[] args) {
3 System.out.println("Hello Java");
4 } คําสัง่ แต่ละคําสัง่ จะจบด้ วยเครื่ อง
5 } เมื่อจบ 1 คําสัง่ ควรขึ ้นบรรทัดใหม่ หมายอัฒภาค (Semicolon)
© สงวนลิขสิทธิ์ พฤศจิกายน 2553 (ปรับปร ุงครัง้ ที่ 7 ฉบับใช้ติวภาค 2/2553) เรียบเรียงโดย วงศ์ยศ เกิดศรี (แบงค์)
2 Computer Programming using Java 01 - Introduction to Java Programming
3. องค์ ประกอบเพิ่มเติมของโปรแกรมภาษาจาวา
ภายในโปรแกรมนอกจากจะมี 3 องค์ประกอบหลักแล้ ว ก็ยงั มีสว่ นที่เรี ยกว่า “หมายเหตุ (Comment)” ซึง่ เป็ น
ข้ อความหรื อคําบรรยายสันๆ
้ ที่ใช้ สําหรับจดทันทึกรายละเอียดบางอย่างภายในโปรแกรมที่เขียนขึ ้น ดังตัวอย่าง
1 public class HelloJava { หมายเหตุสามารถอยูบ่ ริเวณใด
3 System.out.println("Hello Java"); หรื อบรรทัดใดของโปรแกรมก็ได้
4 } // End of method
5 } /* End of class */ หมายเหตุจะมีปรากฏในโปรแกรมหรื อตัดออกไปก็ได้
โดยไม่มีผลต่อการทํางานของโปรแกรมแต่อย่างใด
หมายเหตุในภาษาจาวามี 3 รูปแบบดังนี ้
1. หมายเหตุแบบบรรทัดเดี่ยว (Single Line Comment) เช่น // Text ซึง่ มีความหมายว่าสิ่งใดก็ตามที่
อยูห่ ลังเครื่ องหมาย // ภายในบรรทัดเดียวกันนันจะเป็
้ นหมายเหตุทงหมด
ั้
2. หมายเหตุแบบหลายบรรทัด (Multiple Line Comment) เช่น /* Text */ ซึง่ มีความหมายว่าสิง่ ใดก็
ตามที่อยูร่ ะหว่างเครื่ องหมาย /* กับ */ จะกี่บรรทัดก็ได้ จะเป็ นหมายเหตุทงหมด
ั้
3. หมายเหตุสาํ หรั บสร้ างแฟ้มเอกสารจาวา (Java Documentation Comment) เช่น /** Text */ มี
ความหมายเหมือนกับหมายเหตุแบบที่สอง แต่ใช้ สําหรับการสร้ าง Java Document เท่านัน้
โจทย์ ข้อที่ 1 [ระดับง่ าย] จงพิจารณาโปรแกรมภาษาจาวาต่ อไปนี ้ เขียนถูก (;) หรื อผิด (:) ตามหลัก
ไวยากรณ์ ของภาษา และเขียนได้ สวยงาม (;) หรื อไม่ สวยงาม (:) (8 คะแนน)
1) public class TestTestTestTestTest {
ไวยากรณ์ สวยงาม public static void main (String [] args) {
System. out . println ("Test Java Programming") ;
}
}
2) Public class Test {
ไวยากรณ์ สวยงาม Public static void main(String[] args) {
System.out.print("Test Java\n")
}
}
3) public class Test { public static void main(String args[]) {
System.out.println("Test Java"); } //End of main
ไวยากรณ์ สวยงาม
} //End of class
4) public class Test {
ไวยากรณ์ สวยงาม public static viod main(String[] args) {
System.out.println("Test Java");
}
}
5) public class Test Java {
public static void main(String[] args) {
System.err.println("Test Java");
}
}
6) public class test {
public static void main(String[] bank) {
System.out.print("Test Java");
}
}
7) public class Test
ไวยากรณ์ สวยงาม { //Start Class
public static void main(String args[])
{ //Start Mathod
System.out.println("Test Java");
} //End of Class
} //End of Method
ไวยากรณ์ สวยงาม public static void main(String[] arg) {
/* System.out.println("Test Java"); */
}
}
โจทย์ ข้อที่ 2 [ระดับง่ าย] จงปิ ดบังโปรแกรมจากโจทย์ ข้อที่ 1 ให้ มิดชิดแล้ วจงเขียนโปรแกรมภาษาจาวา
อย่ างง่ ายให้ ถูกต้ องสมบรณ์ ู และสวยงาม โดยมีคลาสชื่อ MyFirstJavaProgram เมท็อดชื่อ main และมี
คําสั่ง 4 คําสั่ง ได้ แก่ คาํ สั่ง int x = 5 คําสั่ง double y = 3.10000001 คําสั่ง y = y + x และคําสั่ง
System.out.print("y = " + y + "\n") (6 คะแนน)
1 2 3 4
4. รายละเอียดเบือ้ งต้ นของ คลาส เมท็อด และ คําสั่ง

โปรแกรมภาษาจาวาจะต้ องประกอบด้ วยองค์ประกอบ 3 ส่วนหลัก คือ คลาส เมท็อด และคําสัง่ โดยมีนิยามอยูว่ า่
1) โปรแกรมหนึ่งโปรแกรมสามารถมีได้ หลายคลาส เช่น (ให้สงั เกตุเพียงแค่วิธีการเขี ยนและขอบเขตของคําสัง่ )
1 2 3 4
2 public ...
3 }
4 class HiJava { คลาสแต่ละคลาสต่างก็ใช้ เครื่ องหมายปี กกาในการบอกขอบเขต
5 public ... ของคลาสนันๆ
้
6 }
class HeyJava {
7
8 public ...
คลาสแต่ละคลาสมีศกั ดิศ์ รี เท่ากันจึงต้ องอยูใ่ นระดับเดียวกัน
9 }
2) คลาสหนึ่งคลาสสามารถมีได้ หลายเมท็อด เช่น (ให้สงั เกตุเพียงแค่วิธีการเขี ยนและขอบเขตของคําสัง่ )

1 2 3 4
เมท็อดแต่ละเมท็อดต่างก็ใช้ เครื่ อง
3 ... หมายปี กกาในการบอกขอบเขต
4 }
5 public int add(int x, int y) { ของเมท็อดนันๆ ้ ซึง่ อยูซ่ ้ อนเข้ าไป
6 ... ภายในขอบเขตของคลาสอีกชันหนึ ้ ง่
7 }
8 public static boolean check(double n) {
9 ...
10 } เมท็อดแต่ละเมท็อดมีศกั ดิ์ศรี เท่ากันจึงต้ องอยูใ่ นระดับเดียวกัน
11 }
3) เมท็อดหนึ่งเมท็อดสามารถมีได้ หลายคําสั่ง เช่น (ให้สงั เกตุเพียงแค่วิธีการเขี ยนและขอบเขตของคําสัง่ )

1 2 3 4
คําสัง่ แต่ละคําสัง่ จะอยูซ่ ้ อนเข้ าไป
1 public class HelloJava { ภายในขอบ เขตของเมท็อดอีก
3 int x = 5; ้ ง่ และถ้ าคําสัง่ มีศกั ดิ์ ศรี
ชันหนึ
4 while (x >= 0) { เท่ากันจะต้ องอยูใ่ นระดับเดียวกัน
5 System.out.println(x);
6 x--; สัง่ ที่มีเพียงบรรทัดเดียวจะจบคําสัง่ ด้ วย
7 }
8 if (x == 0) { เครื่ องหมาย Semicolon
9 System.out.println(y);
10 } ระบบจะเริ่มประมวลผลคําสัง่ แรกจนถึง
11 System.out.print("End of Program"); คําสัง่ สุดท้ ายจากบนลงล่าง
12 }
13 } คําสัง่ ที่มีหลายบรรทัดหรื อที่เรี ยกว่าชุดคําสัง่ จะกําหนดขอบเขตด้ วยเครื่ องหมายปี กกา
4) คําสั่งมีมากมายหลายรปแบบ
ู เช่น (ให้สงั เกตุเพียงแค่วิธีการเขี ยนและขอบเขตของคําสัง่ )
1. คําสั่งกําหนดค่ า
1 2 3 4
3 int x = 5;
4 double y = 3.14;
5 } จบคําสัง่ ด้ วยเครื่ องหมาย Semicolon
6 }
2. คําสั่งคํานวณ
1 2 3 4
3 x = n++ / 2;
4 y = y + x;
5 }
จบคําสัง่ ด้ วยเครื่ องหมาย Semicolon
6 }
3. คําสั่งรั บค่ า การ import เป็ นส่วนที่เพิ่มเข้ ามานอกเหนือจาก
1 2 3 4 3 องค์ประกอบหลักที่กล่าวไปแล้ ว เพื่อเรี ยกใช้ งาน
1 import java.util.Scanner; Class Library เมื่อต้ องการใช้ คําสัง่ พิเศษ
4 Scanner kb = new Scanner(System.in);
5 int n = kb.nextInt();
6 } จบคําสัง่ ด้ วยเครื่ องหมาย Semicolon
7 }
คําสัง่ รับค่า (ซึง่ ในที่นี ้ใช้ คลาส Scanner) เป็ นคําสัง่ พิเศษดังนันจึ
้ งต้ อง import
4. คําสั่งแสดงผล
1 2 3 4
1 public class HelloJava { จบคําสัง่ ด้ วยเครื่ องหมาย
3 System.out.println("result : " + n);
Semicolon
4 }
5 }
5. คําสั่งตัดสินใจ คําสัง่ ตัดสินใจเป็ นกลุม่ หรื อชุดคําสัง่ จึงต้ องใช้ เครื่ องหมาย
1 2 3 4
ปี กกาในการบอกขอบเขตของคําสัง่
3 if (x > 10) {
4 y = y + x;
5 } else { คําสัง่ ตัดสินใจประกอบด้ วย 2 ส่วนคือ ส่วน if และ else
6 y = y – x;
7 } และทังสองส่
้ วนต้ องอยูใ่ นระดับเดียวกัน
8 }
9 } ภายในแต่ละส่วนสามารถมีคําสัง่ อื่นๆ ซ้ อนเข้ าไปได้ อีก
6. คําสั่งวนซํา้
1 2 3 4
3 while (i <= 5) {
4 ... คําสัง่ วนซํ ้า เป็ นกลุม่ หรื อชุดคําสัง่ จึงต้ องใช้ เครื่ องหมายปี กกาใน
5 }
6 }
การบอกขอบเขตของคําสัง่
7 }
ภายในคําสัง่ สามารถมีคําสัง่ อื่นๆ ซ้ อนเข้ าไปได้ อีก
1 2 3 4
3 for (int i = 1; i <= 5; i++) {
4 ...
5 } คําสัง่ วนซํ ้า มี 2 รูปแบบคือ คําสัง่ while และคําสัง่ for ซึง่ ทังสอง
้
6 }
7 } แบบทํางานเหมือนกันแต่เขียนต่างกัน
5) เพื่อการเข้ าใจให้ ตรงกันจะขอแบ่ งการเขียนโปรแกรมออกเป็ น 2 ช่ วง ดังนี ้

ช่ วงที่หนึ่ง ตังแต่
้ บทที่ 1 ถึงบทที่ 7 การเขียนโปรแกรมทุกโปรแกรมจะมีเพียง 1 คลาส และภายใน
คลาสจะมีเพียง 1 เมท็อดที่ชื่อว่า “main” และภายในเมท็อด main จะมีคําสัง่ ทุกรูปแบบอยูภ่ ายในนัน้
ช่ องที่สอง ตังแต่ ้ บทที่ 8 ถึงบทที่ 14 การเขียนโปรแกรมจะสามารถมีคลาสได้ มากกว่า 1 คลาส และ
ภายในคลาสหนึ่งๆ ก็สามารถมีเมท็อดได้ มากกว่า 1 เมท็อด ซึ่งภายในเมท็อดก็ยงั มีคําสัง่ ที่ใช้ งาน
ในช่วงที่หนึง่ อยูเ่ ช่นเดิม
โจทย์ ข้อที่ 3 [ระดับง่ าย] จงนับและระบุส่วนที่เขียนผิดตามหลักไวยากรณ์ ของภาษาจาวา พร้ อมทัง้ เขียน

โปรแกรมนีใ้ หม่ ให้ ถูกต้ องและสวยงาม (10 คะแนน)
1 import.java.util.scanner; {
ควรไล่ ทีละบรรทัด
2 public class java { จากบนลงล่ าง
3 Public static void /* public */ main(String a[]) {
4 Scanner kb = new Scanner(System.in)
5 int i = kb.nextInt();
6 If (i < 50) { System.out.println(Hello Java); }
7 else { System.out.Print(Hello Jaba) }}}
โปรแกรมนีเ้ ขียนผิดทัง้ หมด ตําแหน่ ง ซึ่งเขียนใหม่ ให้ ถกต้

ู องได้ เป็ น
1 2 3 4
โจทย์ ข้อที่ 4 [ระดับง่ าย] จงนับและระบุส่วนที่เขียนผิดตามหลักไวยากรณ์ ของภาษาจาวา พร้ อมทัง้ เขียน

โปรแกรมนีใ้ หม่ ให้ ถกต้
ู องและสวยงาม (10 คะแนน)
1 Import java.util.Scanner;
ควรไล่ ทีละบรรทัด
2 public Class LoveJava { จากบนลงล่ าง
3 public static viod Main(string arg) {
4 system.out.print("Give me A for this course;");
5 }
โปรแกรมนีเ้ ขียนผิดทัง้ หมด ตําแหน่ ง ซึ่งเขียนใหม่ ให้ ถกต้

ู องได้ เป็ น
1 2 3 4
โจทย์ ข้อที่ 5 [ระดับปานกลาง] จงประกอบโปรแกรมภาษาจาวาให้ สมบรณ์ ู ตามเงื่อนไขที่กําหนดมาให้

จากส่ วนของโปรแกรมภาษาจาวาต่ อไปนี ้ พร้ อมทัง้ เขียนเครื่ องหมายแสดงขอบเขตของส่ วนโปรแกรม
และเครื่องหมายจบคําสั่งให้ ถูกต้ อง (10 คะแนน)
คําสั่ง ส่ วนของโปรแกรม
คําสัง่ ที่ 1 int x = kb.nextInt()
คําสัง่ ที่ 2 x++
คําสัง่ ที่ 3 Scanner kb = new Scanner(System.in)
คําสัง่ ที่ 4 System.out.println("result = " + x)
คําสัง่ ที่ 5 System.out.println("error")
คําสัง่ ที่ 6 if(x != 0) ... else ...
คําสัง่ ที่ 7 while(x < 100)
กําหนดให้ คลาส A ประกอบไปด้ วยเมท็อด main โดยภายในเมท็อด main ประกอบไปด้ วยคําสั่งที่ 3, 1

และ 7 ตามลําดับ ภายในคําสั่งที่ 7 ประกอบไปด้ วยคําสั่งที่ 6 และ 2 ตามลําดับ ภายในส่ วนของ if ของ
คําสั่งที่ 6 ประกอบไปด้ วยคําสั่งที่ 4 และภายในส่ วนของ else ของคําสั่งที่ 6 ประกอบไปด้ วยคําสั่งที่ 5
(สามารถเพิ่มเติมส่ วนของโปรแกรมอื่นๆ ได้ ตามความเหมาะสม)
1 2 3 4 5
5. รายละเอียดเบือ้ งต้ นของคําสั่งแสดงผล

เนื่องจากคําสัง่ แสดงผลเป็ นคําสัง่ พื ้นฐานที่ต้องทําความเข้ าใจตังแต่
้ เริ่ มต้ นของการเขียนโปรแกรม (เริ่ มตังแต่้
บทที่ 1) จึงจําเป็ นต้ องรู้หลักการทํางานเบื ้องต้ นดังนี ้ ตําแหน่งเคอร์ เซอร์ (Cursor)
1) การแสดงผลลัพธ์ออกทางจอภาพแบบไม่ขึ ้นบรรทัดใหม่ จะใช้ คําสัง่ Hello Java.
System.out.print(...);
เช่น System.out.print("Hello Java");
Hello Java
2) การแสดงผลลัพธ์ออกทางจอภาพแบบขึ ้นบรรทัดใหม่ จะใช้ คําสัง่ .
System.out.println(...);
เช่น System.out.println("Hello Java");
3) รูปแบบการแสดงผลลัพธ์มีดงั นี ้ ผลลัพธ์
System.out.println("Hi" + "V"); ข้ อความ + ข้ อความ = ข้ อความ HiV
เอามาต่
เอามา อกัน ผลลัพธ์
System.out.println("Hi" + 5); ข้ อความ + ตัวเลข = ข้ อความ Hi5
ผลลัพธ์
System.out.println(8 + 5); ตัวเลข + ตัวเลข = ตัวเลข 13
เอามาบวกกัน
4) อักขระพิเศษ (Escape Characters)
(1) อักขระ \n คือ การขึ ้นบรรทัดใหม่ (New Line) แต่ใน JLab นัน้ 1 Tab = 6 Spaces
(2) อักขระ \t คือ การเลื่อนทีละช่วงในแนวนอน (Horizontal Tab) ซึง่ 1 Tab = 8 Spaces

(3) อักขระ \' คือ เครื่ องหมาย Single Quote (') ตัวอย่างเช่น
แสดงข้ อความว่า ‘J’ จะใช้ คําสัง่ System.out.println("\'J\'");
(4) อักขระ \" คือ เครื่ องหมาย Double Quote (") ตัวอย่างเช่น
แสดงข้ อความว่า Get “A” Java จะใช้ คําสัง่ System.out.println("Get \"A\" Java");
(5) อักขระ \\ คือ เครื่ องหมาย Backslash (\) ตัวอย่างเช่น
แสดงข้ อความว่า Tab key is \t จะใช้ คําสัง่ System.out.println("Tab key is \\t");
โจทย์ ข้อที่ 6 [ระดับง่ าย] จงแสดงคําตอบจากส่ วนของโปรแกรมต่ อไปนี ้ (12 คะแนน)

ข้ อ ส่ วนของโปรแกรม คําตอบ
1. System.out.println("0" + "2");
2. System.out.println(0 + 2);
3. System.out.println(0 + "2");
4. System.out.println(0 + 3 + "2");
5. System.out.println("0" + 3 + 2);
ข้ อ ส่ วนของโปรแกรม คําตอบ
6. System.out.println(0 + "3" + 2);
7. System.out.println("0" + (3 + 2));
8. System.out.println(032);
9. System.out.println("0"32);
10. System.out.println("Hello\tJava");
11. System.out.print("\\\t\\\xxx\n");
12. System.out.println("\"\\\\\'//\"");
โจทย์ ข้อที่ 7 [ระดับง่ าย] จงเขียนโปรแกรมภาษาจาวาเบือ้ งต้ นให้ ถูกต้ องและสวยงาม เพื่อสร้ างคลาสชื่อ
MyProfile โดยให้ โปรแกรมแสดงชื่อ นามสกุล ชื่อเล่ น และเบอร์ โทรศัพท์ ของตัวเองขึน้ บนจอภาพทีละ
บรรทัด (10 คะแนน)
1 2 3 4 5
Shape โดยให้ โปรแกรมแสดงรปสามเหลี ู ่ ยมตามที่กาํ หนดให้ ขึน้ บนจอภาพ และใช้ คาํ สั่งเพียงคําสั่งเดียว
เท่ านัน้ ในการแสดงผล (10 คะแนน) *
1 2 3 4 5 **
***
****
*****
****
***
**
*
Test โดยโปรแกรมนีจ้ ะแสดงข้ อความว่ า “My first JAVA program” ออกทางจอภาพพร้ อมทัง้ ขึน้ บรรทัด
ใหม่ และแสดงข้ อความว่ า My JAVA tutor web site is “http://www.javachula.co.cc” ออกทางจอภาพ (ยัง
ไม่ ขึน้ บรรทัดใหม่ ) แล้ วให้ โปรแกรมเลื่อนเคอร์ เซอร์ ไป 18 ช่ องว่ าง และแสดงคําว่ า Click บทจอภาพ
พร้ อมทัง้ ขึน้ บรรทัดใหม่ และในขณะที่เขียนเครื่ องหมายปิ ดขอบเขตของคลาสและเมท็อด ให้ เขี ยน
หมายเหตุว่า End of class และ End of method ต่ อท้ ายบรรทัดนัน้ ๆ ด้ วย โดยกําหนดให้ ใช้ คาํ สั่งเพียง
คําสั่งเดียวเท่ านัน้ ในการแสดงผล (10 คะแนน)
1 2 3 4 5
2. การแปลและสั่งงานโปรแกรม (Compiling and Running Program)

1. ขัน้ ตอนการแปลและสั่งงานโปรแกรม มีดงั ต่อไปนี ้
1 2 3 4 5 6
Edit/Coding Source Code Compile Byte Code Run/Execute Output/Result
Demo.java Demo.class
public class Demo { 1001101010111101
public static void …{ 1010101110101010
System.out … 1010010101010100 Hello!
} javac Demo.java 001011101111 java Demo
}
Demo.java
7
Debugging
โจทย์ ข้อที่ 10 [ระดับง่ าย] โปรแกรมที่กาํ หนดให้ ต่อไปนีแ้ ปลโปรแกรมผ่ าน (;) หรื อไม่ ผ่าน (:) สั่งงาน
ผ่ าน (;) หรือไม่ ผ่าน (:) และเขียนได้ สวยงาม (;) หรื อไม่ สวยงาม (:) (15 คะแนน)
แปล สวยงาม public static void main(String[] args) {
สั่งงาน
System. out.
println("xxxxx")
;
}
}
แปล สวยงาม public static void main(String[] args) {
System.out.println("xxxxx
xxxxx
xxxxx");
}
}
แปล สั่งงาน สวยงาม
System.out.println("xxxxx" +
"xxxxx" +
"xxxxx");
}
}
void main(String[] args) {
System.out.println("xxxxx");
}
}
public static void noob(String[] args) {
}
}
6) public class main {
แปล public static void main(String[] args) {
สั่งงาน สวยงาม
}
}
7) public class void {
}
}
8) public class เกรียน {
}
}
9) public class Strings }
System.err.println("xxxxx");
}
}
10) public class Public {
// System.out.println("xxxxx");
}
11) public class 3Girl_And_1Man {
// Love you "Java"
}
}
12) public class Swinging {
System.out.println("xxxxx");;;;;;;;;;;;;
}
}
13) public /* println */ class /* Class */ Test { // {

แปล สวยงาม public /* ??? */ static void main /* java */
(String[] args) {
/* // System.out.println("xxxxx"); */ }} // }
14) class Test {
public static void main(String[] args){
{ //Starting the program
{ //Starting the sub-program
System.out.println("yyyyy");
System.out.println("yyyyy");
} //Ending the sub-program
} //Ending the program
}
}
15) public class Class {
แปล // System.out.println("xxxxx");
public static void main(String[] args){}}
3. การเขียนผังงาน (Flowchart)
1. การเขียนผังงานก่ อนการเขียนโปรแกรม
โดยปกติแล้ วก่อนการเขียนโปรแกรมนักออกแบบโปรแกรมและโปรแกรมเมอร์ จะต้ องสร้ างผังงาน (Flowchart)
หรื อ รหัสเทียม (Psudocode) เพื่อใช้ สําหรับระบุกระบวนการทํางานของโปรแกรมนันอย่
้ างคร่าวๆ ก่อนเสมอ
2. สัญลักษณ์ ท่ ใี ช้ ในการเขียนผังงาน
ลําดับ สัญลักษณ์ ชื่อสัญลักษณ์ ความหมาย
1. Terminator การเริ่ มต้ นและการสิ ้นสุด
2. Data ข้ อมูลและการรับเข้ าข้ อมูล (ทุกรูปแบบ)
3. Manual Input การรับเข้ าข้ อมูลด้ วยมือ (กด, สัมผัส)
4. Process การกําหนดค่าและการคํานวน
5. Decision การตัดสินใจและการเปรี ยบเทียบ
6. Display การแสดงผลทางจอภาพ
7. Document การแสดงผลในรูปเอกสาร (การพิมพ์)
8. Predefined Process การเรี ยกไปยังโปรแกรมย่อย
9. On-page Connector จุดเชื่อมต่อภายในหน้ าเดียวกัน
10. Off-page Connector จุดเชื่อมต่อต่างหน้ ากัน
11. Arrow Line เส้ นลูกศรแสดงทิศทาง
โจทย์ ข้อที่ 11 [ระดับง่ าย] จงเติมเต็มผังงานที่กาํ หนดให้ ต่อไปนีใ้ ห้ สมบรณ์
ู (18 คะแนน)
1) เขียนผังงานเพื่อหาคําตอบของสมการ z = x + yโดยรั บค่ าตัวเลขจํานวนเต็ม (Integer) สองตัวจาก
แป้นพิมพ์ เข้ ามาเก็บไว้ ในตัวแปร x และ y ตามลําดับ จากนัน้ หาผลบวกของตัวแปร x และ y แล้ ว
เก็บไว้ ในตัวแปร z พร้ อมทัง้ แสดงผลลัพธ์ ท่ ไี ด้ ออกทางจอภาพ (4 คะแนน)
2) เขียนผังงานเพื่อรั บตัวเลขจํานวนจริง (Real) จากแป้นพิมพ์ สองค่ าเข้ ามาเก็บไว้ ในตัวแปร n1 และ n2
ตามลําดับ แล้ วทําการเปรี ยบเทียบค่ าระหว่ าง n1 และ n2 โดยถ้ าค่ าของ n1 มากกว่ า n2 ให้ พิมพ์ ค่า
n1 ลงบนเอกสาร แต่ ถ้าไม่ เช่ นนัน้ ให้ พมิ พ์ ค่า n2 ลงบนเอกสาร (6 คะแนน)
3) เขียนผังงานเพื่อรับค่ าตัวเลขจํานวนเต็มจากแหล่ งให้ กาํ เนิดข้ อมลเข้ ู ามาเก็บไว้ ในตัวแปร n พร้ อมทัง้
กําหนดค่ าเริ่มต้ นของตัวแปร i ให้ เท่ ากับ 0 แล้ วตรวจสอบว่ าตัวแปร i น้ อยกว่ าตัวแปร n หรื อไม่ ถ้ า
เป็ นจริงให้ แสดงคําว่ า “Java” ขึน้ บนจอภาพ แล้ วเพิ่มค่ า i ขึน้ ทีละ 1 (โดยใช้ คาํ สั่ง i++) ซึ่งจะวนรอบ
ทํางานแบบนีไ้ ปเรื่อยๆ จนกว่ าตัวแปร i ไม่ ได้ น้อยกว่ าตัวแปร n จึงจะจบการทํางาน (8 คะแนน)
ผังงานข้ อย่ อยที่ 1 ผังงานข้ อย่ อยที่ 2 ผังงานข้ อย่ อยที่ 3
โจทย์ ข้อที่ 12 [ระดับง่ าย] จงเขียนผังงานจากกระบวนการทํางานของร้ านขายเสือ้ ผ้ า “เกรี ยน ณ ลาน

เกียร์ ” ที่ต้องการรั บซือ้ เสือ้ หลากสีมือสองจากนิสิตคณะต่ างๆ ในจุฬาลงกรณ์ มหาวิทยาลัย เพื่อนํามาขาย
ต่ อในราคาถกู โดยมีกระบวนการซือ้ ขายอย่ ู 2 ส่ วนดังนี ้ (20 คะแนน)
1) กระบวนการรั บซือ้ ซึ่งจะรั บเสือ้ หลากสีจากนิสิตตามจํานวนเสือ้ (Unit) ที่นิสิตนํามา โดยที่ราคาเสือ้
(Price) อย่ ูท่ ตี วั ละ 30 บาท จากนัน้ คิดราคารวม (Amount) และออกใบเสร็จให้ กับนิสิต (8 คะแนน)
2) กระบวนการติดป้ายราคา ซึ่งจะนําเสือ้ หลากสีท่ ีได้ มาคัดแยกสี โดยถ้ าเป็ นเสือ้ ชมพจะติ ู ดป้ายราคา
100 บาท เสือ้ เหลืองติดป้ายราคา 60 บาท เสือ้ แดงติดป้ายแจกฟรี ไม่ มีราคา ส่ วนเสือ้ สีอ่ ืนๆ นอก
เหนือจาก 3 สีท่ กี ล่ าวมาติดป้ายราคา 20 บาท (12 คะแนน)
ผังงานข้ อย่ อยที่ 1 ผังงานข้ อย่ อยที่ 2
โจทย์ ข้อที่ 13 [ระดับง่ าย] จงพิจารณาผังงานต่ อไปนี ้ พร้ อมทัง้ หาคําตอบของตัวแปร B1, B2 และ C เมื่อ
กําหนดให้ ค่า A มีค่าต่ างๆ ดังตาราง (5 คะแนน)
Start A B1 B2 C
1
C=1
2
A 3
B1 = A + 2
4
B2 = A + C 5
No B1 = A + 2
C<6 B2 = A + C
Yes
C=A+2 End
Data Operations and Processing - 02 Computer Programming using Java 15
CHAPTER การดําเนินการและประมวลผลข้อมูล
02 (Data Operations and Processing)
1. ประเภทข้ อมลูและตัวแปร (Data Types and Variables)
1. ประเภทข้ อมลหรื
ู อชนิดตัวแปร (Data Types)
้ ม (Primitive Data Types) แบ่งออกเป็ น 4 กลุม่ ได้ แก่
1.1 ประเภทข้ อมูลแบบดังเดิ
1) ตัวเลขจํานวนเต็ม (Integer) Æ คือ จํานวนเต็มบวก จํานวนเต็มลบ จํานวนเต็มศูนย์
ชนิดตัวแปร ขนาดตัวแปร ช่ วงของข้ อมลู ค่ าเริ่มต้ น
byte 8 bits -128 ถึง 127 0
short 16 bits -32,768 ถึง 32,767 0
int 32 bits -2,147,483,648 ถึง 2,147,483,647 0
-9,223,372,036,854,775,808 ถึง
long 64 bits 0L
9,223,372,036,854,775,807
2) ตัวเลขจํานวนจริง (Floating Point / Real Number) คือ จํานวนที่มีจดุ ทศนิยม

float 32 bits -3.40292347E+38 ถึง 3.40292347E+38 0.0F
-1.79769313486231570E+308 ถึง
double 64 bits 0.0D
1.79769313486231570E+308
3) ตัวอักขระ (Character) Æ คือ ตัวอักษร (Letter) หรื อตัวเลข (Digit) หรื อสัญลักษณ์ (Symbol) เพียง 1 ตัว
char 16 bits '\u0000' ถึง '\uFFFF' (0 - 65535) '\u0000'
เช่น 'A' หรื อ 'a' (คล่อมด้ วยเครื่ องหมาย '…')
4) ตัวตรรกะ (Boolean) Æ คือ ค่าความจริง ซึง่ มีเพียงสองค่าคือ จริง (True) หรื อ เท็จ (False)
boolean ไม่ระบุ true หรื อ false false
1.2 ประเภทข้ อมูลแบบอ้ างอิง (Reference Data Types) แบ่งออกเป็ น 1 กลุม่ (ยังมีมากกว่านี ้) ได้ แก่
1) สตริง (String) หรื อข้ อความ Æ คือ กลุม่ ของอักขระหรือสายอักขระตังแต่ ้ 0 ตัวขึ ้นไปมาเรี ยงต่อกัน
String ไม่ระบุ เช่น "Java Chula" หรื อ "1" หรื อ "F50" หรื อ null
"" (Empty String) (คล่อมด้ วยเครื่ องหมาย "…")
16 Computer Programming using Java 02 - Data Operations and Processing
1.3 การเรี ยงลําดับขนาดและศักดิศ์ รี ของประเภทข้ อมูล (เฉพาะตัวเลข) มีดงั นี ้

byte short int long float double
เล็ก ใหญ่
2. การตัง้ ชื่อตัวแปร
1) กฎการตัง้ ชื่อตัวแปร (บังคับและต้ องทําตาม)
(1) ชื่อตัวแปรสามารถประกอบไปด้ วย ตัวอักษร ตัวเลข สัญลักษณ์ '$' (Dollar Sign) และสัญลักษณ์
'_' (Underscore) เช่น num, $_$, _hey, $1, xxx3, test1_$ เป็ นต้ น
(2) ชื่อตัวแปรห้ามขึ ้นต้ นชื่อด้ วยตัวเลข เช่น 3girl1man, 2you, 5hundredMile เป็ นต้ น
(3) ชื่อตัวแปรห้ามมีช่องว่างและสัญลักษณ์พิเศษอื่นๆ นอกเหนือจากที่กล่าวไว้ ในข้ อที่ 1
(4) ชื่อตัวแปรห้ามตังชื
้ ่อซํ ้ากับคําสงวน (Reserved Words / Keywords) ซึง่ มี 53 คําดังต่อไปนี ้
abstract assert boolean break byte case
catch char class const * continue default
do double else enum extends false
final finally float for goto * if
implements import instanceof int interface long
native new null package private protected
public return short static strictfp super
switch synchronized this throw throws transient
true try void volatile while
(5) ชื่อตัวแปรห้ามตังชื
้ ่อซํ ้ากันภายในเมท็อดเดียวกัน (แต่ตา่ งเมท็อดกันอาจตังชื
้ ่อซํ ้ากันได้ )
(6) ชื่อตัวแปรมีความยาวได้ ไม่จํากัด (จะยาวกี่กิโลเมตรก็ได้ แต่ควรให้ มีความยาวเหมาะสม)
(7) ตัวอักษรพิมพ์ใหญ่และพิมพ์เล็กมีความหมายต่างกันเสมอ (Case-Sensitive) เช่น var ต่างกับ Var
2) ธรรมเนียมการตัง้ ชื่อตัวแปร (ไม่ บังคับแต่ ควรทําตาม)
(1) ชื่อตัวแปร (และชื่อเมท็อด) นิ ยมขึ ้นต้ นด้ วยอักษรพิมพ์เล็ก / ชื่อคลาสนิ ยมขึ ้นต้ นด้ วยอักษรพิมพ์ใหญ่
(2) ชื่อตัวแปรนิ ยมใช้ เป็ นภาษาอังกฤษ (แต่อาจใช้ เป็ นภาษาใดก็ได้ ขึ ้นกับการรองรับของ Editor ที่เขียน)
(3) ชื่อตัวแปรควรตังชื้ ่อให้ สื่อความหมายกับค่าของตัวแปรนัน้ เช่น stdID, firstName, birthDate เป็ นต้ น
(4) ชื่อตัวแปรถ้ าประกอบด้ วยคําหลายคําให้ เขียนคําแรกขึ ้นต้ นด้ วยอักษรพิมพ์เล็ก ส่วนคําถัดๆ ไปขึ ้นต้ น
ด้ วยอักษรพิมพ์ใหญ่ เช่น hostName, numberOfCourse, currentTime, firstDayOfMonth เป็ นต้ น
(5) ชื่อตัวแปรถ้ าเป็ นค่าคงที่นิยมตังชื
้ ่อด้ วยอักษรพิมพ์ใหญ่ทงหมด
ั้ เช่น PI, MONTH_OF_YEAR เป็ นต้ น
(6) พยายามหลีกเลี่ยงการใช้ สญ ั ลักษณ์ '$' และ สัญลักษณ์ '_'
3. การประกาศและกําหนดค่ าตัวแปร
1) การประกาศตัวแปร
<ประเภทข้ อมูล> <ชื่อตัวแปร>;
ตัวอย่าง int x; double num; String lastName; boolean check;
2) การกําหนดค่ าตัวแปร อาจเป็ นค่าคงที่ (Constant) หรื อค่าจากตัวแปรอื่นก็ได้
<ชื่อตัวแปรที่ประกาศไว้ แล้ ว> = <ค่าของตัวแปร>;
ซ้ ายต้ องใหญ่หรื อพอดีกบั ขวา
ตัวอย่าง x = 5; num = 4.01; lastName = "Rukchula"; check = true; a = b;
3) การประกาศพร้ อมกับการกําหนดค่ าตัวแปร (รวมวิธีที่ 1 และ 2 เข้ าด้ วยกัน) ซ้ ายตังขวายั

้ ด
<ประเภทข้ อมูล> <ชื่อตัวแปร> = <ค่าของตัวแปร>;
ตัวอย่าง int x = n; double num = 4.01; char ch = 'A'; float y = 2.9f;
4) การประกาศและกําหนดค่ าตัวแปรหลายตัวที่มีประเภทข้ อมูลเดียวกัน คัน่ ด้ วย Comma

<ประเภทข้ อมูล> <ชื่อตัวแปร>, <ชื่อตัวแปร> = <ค่าของตัวแปร>, ...;
ตัวอย่าง int x = n, year, age = 18, z, a;
4. ค่ าของตัวแปรตามประเภทข้ อมลู
1) ค่ าของจํานวนเต็ม
ประเภทข้ อมลู รปแบบการเขี
ู ยน / ตัวอย่ างค่ าที่จัดเก็บ
byte และ short เขียนเลขจํานวนเต็มทัว่ ไป เช่น byte x = 12; short y = 199;
int (ฐานสิบ) เขียนเลขจํานวนเต็มทัว่ ไป เช่น int dec = 26;
int (ฐานแปด) เขียน 0 (ศูนย์) นําหน้ าเลขจํานวนเต็ม เช่น int oct = 032;
int (ฐานสิบหก) เขียน 0x หรื อ 0X นําหน้ าเลขจํานวนเต็ม เช่น int hex = 0x1A;
long เขียนเลขจํานวนเต็มแล้ วมีอกั ษร l หรื อ L ต่อท้ าย เช่น long n = 26L;
2) ค่ าของจํานวนจริง
float เขียนเลขจํานวนจริงแล้ วมีอกั ษร f หรื อ F ต่อท้ าย เช่น float f = 1.3F;
double (รูปทัว่ ไป) เขียนเลขจํานวนจริงทัว่ ไป เช่น double d = 1.3;
double (รูปเต็ม) เขียนเลขจํานวนจริงแล้ วมีอกั ษร d หรื อ D ต่อท้ าย เช่น double d = 1.3D;
double (รูป a x 10b) เขียนค่า a ในรูปของเลขจํานวนเต็มหรื อเลขจํานวนจริงทัว่ ไป ตามด้ วยอักษร e
หรื อ E และตามด้ วยค่า b ในรูปของเลขจํานวนเต็ม (เท่านัน) ้ เช่น
8
double s = 93.478e8; มีคา่ เท่ากับ 93.478 x 10
–5
double t = 631E-5; มีคา่ เท่ากับ 631 x 10
200
double u = 2.0e+200; มีคา่ เท่ากับ 2.0 x 10
3) ค่ าของตัวอักขระและสตริง
char (รู ปทัว
่ ไป) เขียนอักขระทัว่ ไปคล่อมด้ วย Single Quote เช่น char c = 'a';

char (รู ป Unicode) เขียนรหัส Unicode คล่อมด้ วย Single Quote เช่น char c = '\u0043';
'\u0030' หรื อ รหัส 48 (ฐานสิบ) Æ มีคา่ เท่ากับอักขระ '0'
'\u0041' หรื อ รหัส 65 (ฐานสิบ) Æ มีคา่ เท่ากับอักขระ 'A'
'\u0061' หรื อ รหัส 97 (ฐานสิบ) Æ มีคา่ เท่ากับอักขระ 'a'
'\u0E01' หรื อ รหัส 3585 (ฐานสิบ) Æ มีคา่ เท่ากับอักขระ 'ก'
char (รู ปพิเศษ) เขียนรหัสพิเศษคล่อมด้ วย Single Quote เช่น char tab = '\t';
String (รู ปทัว่ ไป) เขียนสายอักขระคล่อมด้ วย Double Quote เช่น String s = "Bank";
String (รู ปอ๊ อบเจ็ค) สร้ างอ๊ อบเจ็คจากคลาส String เช่น String t = new String("CU");
โจทย์ ข้อที่ 1 [ระดับง่ าย] จงพิจารณาคําสั่งต่ อไปนีผ้ ิด (:) หรื อถูก (;) พร้ อมบอกเหตุผล (15 คะแนน)
1) integer x; .
2) int x = 1.5; .
3) byte x = 1000; .
4) int null = 5; .
5) Int y = 1; .
6) float cal = 15.763; .
7) String id = "1"; .
8) char c = 'Tuksin'; .
9) String s1 = 'Apisit'; .
10) String 3Type = "One Two Three"; .
11) short _$abcdefghijklmnopqrstuvwxyz0123456789$_; .
12) boolean flag = 1; .
13) float ตัวเลข = 139L; .
14) String _ = "ヰベ㈣㈠ヘョ"; .
15) int ch = '\u0044'; .
โจทย์ ข้อที่ 2 [ระดับปานกลาง] จงเติมเต็มคําสั่งการประกาศและกําหนดค่ าของตัวแปรต่ อไปนีใ้ ห้ สมบรณ์

ู
พร้ อมทัง้ ระบุค่าที่เก็บอย่ ูในตัวแปรแต่ ละข้ อ (15 คะแนน)
ข้ อ ประเภทตัวแปร การประกาศและกําหนดค่ าตัวแปร ค่ าที่เก็บในตัวแปร
1. var1 = 014;
2. var2 = 014f;
3. int var3 = 'C';
ข้ อ ประเภทตัวแปร การประกาศและกําหนดค่ าตัวแปร ค่ าที่เก็บในตัวแปร
4. var4 = 0E-0;
5. double var5 = 0x1D;
6. var6 = 1.0e2.0;
7. var7 = .1000;
8. var8 = 08;
9. var9 = null;
10. var10 = 100E012;
11. var11 = 1f + "";
12. var12 = 1e1 + "";
13. var13 = 0d;
14. var14 = 3.f;
15. var15 = 0xbeef;
2. การรั บเข้ าและส่ งออกข้ อมลู (Input and Output the Data)
1. การรับเข้ าข้ อมลู (Input the Data)
การรับเข้ าข้ อมูลในภาษาจาวามีอยู่หลายวิธีด้วยกัน แต่ในเอกสารชุดนี ้จะนําเสนอการรับเข้ าข้ อมูลที่นิยมใช้ กนั
มากในปั จจุบนั นัน่ คือการรับเข้ าข้ อมูลด้ วยคลาส Scanner ซึง่ มีขนตอนการใช้
ั้ งานดังต่อไปนี ้
1) การนําเข้ าคลาส Scanner ก่อนเรี ยกใช้ งานคลาส Scanner จะต้ องนําเข้ าคลาส Scanner ก่อนเสมอ โดย
ใช้ คําสัง่ import java.util.Scanner; ซึง่ ระบุไว้ ก่อนเขียนหัวคลาส ดังตัวอย่าง
1 import java.util.Scanner;
2 public class Test {
3 ...
4 }
2) การสร้ างตัวอ่ านจากแป้นพิมพ์ เป็ นการกําหนดชื่อตัวอ่านเพื่อใช้ สําหรับรับค่าข้ อมูลต่างๆ จากแป้นพิมพ์

โดยจะสร้ างเพียงครัง้ เดียวเท่านัน้ และจะใช้ งานตัวอ่านนันตลอดทั
้ งโปรแกรม
้ ซึง่ มีคําสัง่ ดังนี ้
Scanner <ชื่อตัวอ่าน> = new Scanner(System.in);
System.in หมายถึง
4 Scanner kb = new Scanner(System.in); แป้นพิมพ์ (keyboard)
5 ...
6 } ตัวอ่านชื่อว่า kb
7 }
ู วยตัวอ่ านจากแป้นพิมพ์ ตัวอ่านจากแป้นพิมพ์ที่สร้ างขึ ้นสามารถรับค่าข้ อมูลประเภท

3) การรับค่ าข้ อมลด้
จํานวนเต็ม จํานวนจริ ง และสตริง โดยใช้ คําสัง่ และเมท็อดต่อไปนี ้
1) คําสัง่ รับค่าจํานวนเต็มประเภท int โดยใช้ เมท็อด nextInt() หลังชื่อเมท็อด nextInt ต้ องตามด้ วย
วงเล็บเสมอ จึงได้ เป็ น nextInt()
int <ชื่อตัวแปร> = <ชื่อตัวอ่าน>.nextInt(); (ห้ ามลืมเด็ดขาด)
เช่น int num = kb.nextInt(); (รับค่า int จากตัวอ่าน kb มาเก็บไว้ ที่ตวั แปร num)
2) คําสัง่ รับค่าจํานวนเต็มประเภท long โดยใช้ เมท็อด nextLong()
long <ชื่อตัวแปร> = <ชื่อตัวอ่าน>.nextLong();
เช่น long n = kb.nextLong(); (รับค่า long จากตัวอ่าน kb มาเก็บไว้ ที่ตวั แปร n)

3) คําสัง่ รับค่าจํานวนจริ งประเภท float โดยใช้ เมท็อด nextFloat()
float <ชื่อตัวแปร> = <ชื่อตัวอ่าน>.nextFloat();
เช่น float f = kb.nextFloat(); (รับค่า float จากตัวอ่าน kb มาเก็บไว้ ที่ตวั แปร f)

4) คําสัง่ รับค่าจํานวนจริงประเภท double โดยใช้ เมท็อด nextDouble()
double <ชื่อตัวแปร> = <ชื่อตัวอ่าน>.nextDouble();
เช่น double d = kb.nextDouble(); (รับค่า double จากตัวอ่าน kb มาเก็บไว้ ที่ตวั แปร d)

5) คําสัง่ รับค่าข้ อมูลประเภท String ทีละบรรทัด โดยใช้ เมท็อด nextLine()
String <ชื่อตัวแปร> = <ชื่อตัวอ่าน>.nextLine();
เช่น String s1 = kb.nextLine(); (รับค่า String ทังบรรทั ้ ดจากตัวอ่าน kb มาเก็บไว้ ที่ตวั แปร s1)
6) คําสัง่ รับค่าข้ อมูลประเภท String ทีละคําหรื อทีละช่วง (แต่ละช่วงคัน่ ด้ วยช่องว่างหรื อ \t หรื อ \n)
โดยใช้ เมท็อด next()
String <ชื่อตัวแปร> = <ชื่อตัวอ่าน>.next();
เช่น String s2 = kb.next(); (รับค่า String คําแรกจากตัวอ่าน kb มาเก็บไว้ ที่ตวั แปร s2)
โจทย์ ข้อที่ 3 [ระดับง่ าย] จงเติมเต็มคําสั่งการรั บค่ าของตัวแปรในแต่ ละข้ อต่ อไปนีใ้ ห้ สมบรณ์
ู พร้ อมทัง้
ระบุค่าที่เก็บอย่ ูในตัวแปรแต่ ละข้ อ (15 คะแนน)
Scanner kb = new Scanner(System.in);
ประเภท การรั บค่ าจากแป้นพิมพ์ เพื่อ ค่ าที่ป้อนเข้ ามา ค่ าที่เก็บใน

ข้ อ
ตัวแปร เก็บยังตัวแปรที่กาํ หนด ทางแป้นพิมพ์ ตัวแปร
1. var1 = kb.nextInt(); 087
2. var2 = kb.nextLong(); -0
ประเภท การรั บค่ าจากแป้นพิมพ์ เพื่อ ค่ าที่ป้อนเข้ ามา ค่ าที่เก็บใน
ข้ อ
ตัวแปร เก็บยังตัวแปรที่กาํ หนด ทางแป้นพิมพ์ ตัวแปร
3. int 7.0
4. var4 = kb.nextFloat(); 22.50000
5. long 46L
6. float 7.2F
7. double -0.1
8. double -13
9. double var10 = kb.nextInt(); 1
10. double var11 = kb.nextInt(); 1.0
11. int var12 = kb.nextDouble(); 1.0
12. var13 = kb.nextLine(); 22.50000
13. var14 = kb.nextLine(); Hi java CU
14. var15 = kb.next(); Hi java CU
15. String var16 = kb.nextInt(); 191
2. การส่ งออกข้ อมลู (Output the Data)

การส่งออกข้ อมูลหรื อการแสดงผลข้ อมูลสามารถทําได้ หลายช่องทาง แต่ช่องทางที่พื ้นฐานที่สดุ นัน่ ก็คือจอภาพ
(Monitor/Screen) โดยรายละเอียดของคําสัง่ เบื ้องต้ นได้ กล่าวไปแล้ วในบทที่ 1 ซึง่ มีคําสัง่ ดังนี ้
1) การแสดงผลออกทางจอภาพแบบไม่ขึ ้นบรรทัดใหม่ โดยใช้ เมท็อด print()
System.out.print(...); System.out หมายถึงจอภาพ
2) การแสดงผลลัพธ์ออกทางจอภาพแบบขึ ้นบรรทัดใหม่ โดยใช้ เมท็อด println()

System.out.println(...);
สิง่ ที่สามารถระบุและแสดงผลภายในวงเล็บของเมท็อดทังสองได้
้ นนมี
ั ้ ดงั นี ้
1) ตัวแปร เช่น System.out.print(num);
2) ตัวเลข เช่น System.out.print(13);
3) นิพจน์ เช่น System.out.print(x * y + (10 – z));
4) ข้ อความหรื อสตริง เช่น System.out.print("Hello Java");
5) ข้ อ 1-4 ปะปนกัน เช่น System.out.print("Money = " + (x * y + 92.4) + " Baht");
ใช้ เครื่ องหมาย + เป็ นตัวเชื่อม

แต่ละช่วงเข้ าด้ วยกัน
3. รปแบบการเขี
ู ู ่ ต้ องปฏิบตั ติ าม มีรายละเอียดดังตัวอย่างต่อไปนี ้
ยนโปรแกรมรับเข้ าและส่ งออกข้ อมลที
1 import java.util.Scanner; ต้ องนําเข้ าคลาส Scanner
4 Scanner kb = new Scanner(System.in); ต้ องสร้ างตัวอ่าน
5 System.out.print("Please enter number: ");
6 int num = kb.nextInt(); ต้ องแสดงข้ อความว่าต้ อง
7
8 ... หลังชื่อเมท็อดอย่าลืมใส่วงเล็บ การรับเข้ าข้ อมูลอะไร โดย
9
10
ใช้ เมท็อด print()
System.out.println("Result is " + num);
11 }
12 } ต้ องแสดงผลลัพธ์ โดยใช้ เมท็อด println()
โปรแกรมจะแสดงผลลัพธ์ออกทางจอภาพดังนี ้ โปรแกรมจะแสดงข้ อความเพื่อแจ้ งให้ ผ้ ใู ช้ ทราบว่า

Please enter number: . ระบบกําลังรอรับค่าตัวเลขหนึง่ ค่าจากแป้นพิมพ์
Please enter number: 15 .

ผู้ใช้ พิมพ์ตวั เลข 15 ผ่านทางแป้ นพิมพ์พร้ อมทังกดปุ่
้ ม Enter เพื่อขึ ้น
บรรทัดใหม่ ซึง่ ทําให้ คา่ ของตัวเลข 15 เข้ าไปเก็บอยูใ่ นตัวแปร num
Please enter number: 15 โปรแกรมแสดงค่าที่เก็บอยูใ่ นตัวแปร num

Result is 15
. ขึ ้นบนจอภาพ
โจทย์ ข้อที่ 4 [ระดับง่ าย] จงเขียนโปรแกรมภาษาจาวาที่สมบรณ์

ู เพื่อรั บเลขประจําตัวนิสิต ชื่อ-นามสกุล
นิสิต อายุนิสิต และผลการเรี ยนเฉลี่ยสะสมของนิสิต เข้ ามาทางแป้นพิมพ์ เก็บไว้ ในตัวแปร id, name,
age และ gpa ตามลําดับ และแสดงค่ าของทัง้ สี่ตว
ั แปรนัน้ ออกทางจอภาพให้ สวยงาม (10 คะแนน)
1 2 3 4
โจทย์ ข้อที่ 5 [ระดับปานกลาง] จงเขียนโปรแกรมภาษาจาวาที่สมบรณ์ ู เพื่อรั บตัวเลขจํานวนเต็ม สอง
จํานวนเข้ ามาทางแป้นพิมพ์ เก็บไว้ ในตัวแปร a และ b ตามลําดับ แล้ วทําการสลับค่ าของสองตัวแปรนัน้
โดยที่ค่าของตัวแปร a หลังการสลับจะเท่ ากับค่ าเก่ าของตัวแปร b และค่ าของตัวแปร b หลังการสลับจะ
เก็บค่ าเก่ าของตัวแปร a พร้ อมทัง้ แสดงผลลัพธ์ ออกทางจอภาพตามตัวอย่ างต่ อไปนี ้ (10 คะแนน)
1 2 3 4 Enter a: 13
Enter b: 21
Value of a: 21
Value of b: 13
3. ตัวดําเนินการและคลาสมาตรฐาน (Operators and Standard Class)

1. ตัวดําเนินการ (Operators) แบ่งออกเป็ น 5 กลุม่ หลักดังต่อไปนี ้
1) ตัวดําเนินการทางคณิตศาสตร์ (Arithmetic Operators) ได้ แก่
สัญลักษณ์ ความหมาย ตัวอย่ าง
+ การบวก x + y หรื อ a + b + c
- การลบ x - y หรื อ a - b - c
* การคูณ x * y หรื อ a * b * c
/ การหาร x / y หรื อ a / b / c
% การหารเอาแต่เศษ (Modulo) x % y หรื อ a % b % c
2) ตัวดําเนินการเพิ่มค่ าและลดค่ า (Increment and Decrement Operators) ได้ แก่

x++ ใช้ งานตัวแปร x ก่อนเพิ่มค่าขึ ้นอีก 1 ให้ x = 2, y = 1 จะได้ วา่ x++ + y = 3
++x เพิ่มค่าขึ ้นอีก 1 ก่อนใช้ งานตัวแปร x ให้ x = 2, y = 1 จะได้ วา่ ++x + y = 4
x-- ใช้ งานตัวแปร x ก่อนลดค่าลงอีก 1 ให้ x = 2, y = 1 จะได้ วา่ x-- + y = 3
--x ลดค่าลงอีก 1 ก่อนใช้ งานตัวแปร x ให้ x = 2, y = 1 จะได้ วา่ --x + y = 2
3) ตัวดําเนินการเปรียบเทียบค่ า (Comparison/Relational Operators) ได้ แก่

== เท่ากัน x == y (คําตอบเป็ นค่าจริ งหรื อเท็จเท่านัน) ้
!= ไม่เท่ากัน x != y (คําตอบเป็ นค่าจริ งหรื อเท็จเท่านัน) ้
< น้ อยกว่า x < y (คําตอบเป็ นค่าจริ งหรื อเท็จเท่านัน)
้
> มากกว่า x > y (คําตอบเป็ นค่าจริ งหรื อเท็จเท่านัน)้
<= น้ อยกว่าหรื อเท่ากัน x <= y (คําตอบเป็ นค่าจริ งหรื อเท็จเท่านัน) ้
>= มากกว่าหรื อเท่ากัน x >= y (คําตอบเป็ นค่าจริ งหรื อเท็จเท่านัน) ้
4) ตัวดําเนินการทางตรรกศาสตร์ (Logical Operators) ได้ แก่
&& และ (AND) (x >= y) && (x != 0)
|| หรื อ (OR) (x == y) || (x == z)
! นิเสธ (NOT) !(x <= y)
5) ตัวดําเนินการกําหนดค่ า (Assignment Operators) ได้ แก่

= เท่ากับ x = y นําค่า y เก็บไว้ ใน x
+= x += y มีคา่ เท่ากับ x = x + y x += 14 จะได้ วา่ x = x + 14
-= x -= y มีคา ่ เท่ากับ x = x - y x -= 1 จะได้ วา
่ x=x-1
*= x *= y มีคา ่ เท่ากับ x = x * y x *= y-- จะได้ วา ่ x = x * y--
/= x /= y มีคา ่ เท่ากับ x = x / y x /= 5.8 จะได้ วา ่ x = x / 5.8
โจทย์ ข้อที่ 6 [ระดับง่ าย] จงแสดงผลลัพธ์ จากส่ วนของโปรแกรมต่ อไปนี ้ (5 คะแนน)
ข้ อ ส่ วนของโปรแกรม ผลลัพธ์ ท่ แี สดง
1. int a = 21, b = 0;
System.out.println("a" + a - b);
2. double x = 1.0, y = 1.000;

System.out.println(x > y);
3. double a = 1.6; a += 5.1;

System.out.println(a % 4);
4. int x = 6;
System.out.println(x-- + ++x - --x - x-- + x++ + x);
5. boolean a = true, b = true, c = false;

System.out.println(a || b && c);
2. กฎการพิจารณาลําดับตัวดําเนินการ (เฉพาะที่ใช้ กนั บ่อยๆ)

ลําดับ ชื่อตัวดําเนินการ / ตัวดําเนินการ ตัวอย่ างการทํางาน
1. วงเล็บ (Parentheses) (…) x – (2 + y) จะทํา (2 + y) ก่อนนํา x มาลบออก
2. เรี ยกเมท็อด (Method Call) () Math.sqrt(a + 2) จะทํา Math.sqrt(…) ก่อน

ลําดับ ชื่อตัวดําเนินการ / ตัวดําเนินการ ตัวอย่ างการทํางาน
ค่าบวก (Unary Plus) + 2 * +a จะทํา +a ก่อนนํา 2 ไปคูณกับคําตอบ
3.
ค่าลบ (Unary Minus) - –a / 3 จะทํา –a ก่อนนําคําตอบไปหาร 3
คูณ (Multiplication) * x * 3 + 2 จะทํา x * 3 ก่อนนําคําตอบไปบวก 2
4. หาร (Division) / 3 – 5 / x จะทํา 5 / x ก่อนนํา 3 มาลบออก
หารเอาแต่เศษ (Modulo) % y % 2 + 1 จะทํา y % 2 ก่อนนําคําตอบไปบวก 1
บวก (Addition) + x + 17 > 19 จะทํา x + 17 ก่อนทํา >

5.
ลบ (Subtraction) - x – 9.5 = 42.5 จะทํา x – 9.5 ก่อนทํา =
6. การเปรี ยบเทียบค่า : น้ อยกว่า (<), น้ อยกว่าเท่ากัน (<=), มากกว่า (>), มากกว่าเท่ากัน (>=)
7. การเปรี ยบเทียบค่า : เท่ากัน (==), ไม่เท่ากัน (!=)
8. และ (Logical AND) && a || b && c จะทํา && ก่อน ||
9. หรื อ (Logical OR) || x = d > 3 || d <= 15 จะทํา || ก่อนทํา =
10. เท่ากับ (Assignment) = จะถูกพิจารณาหลังสุด

หมายเหตุ ในกรณีที่ตวั ดําเนินการมีลาํ ดับความสําคัญเท่ากัน ให้ พิจารณาการทํางานจากซ้ ายไปขวา
โจทย์ ข้อที่ 7 [ระดับง่ าย] จงแสดงลําดับการทํางานที่ถูกต้ องของตัวดําเนินการของนิพจน์ ต่อไปนี ้ โดยให้

เขียนหมายเลขลําดับกํากับไว้ บนตัวดําเนินการนัน้ (5 คะแนน)
1) a * (b + -(c / d) / e) + (f – g % h)
2) (1.0 / 2.0) * Math.sin(x – Math.PI / Math.sqrt(y))
3) a * b + (-c) / d / e * f - g % h
4) cal = (1 – x % 2.5 + y * z) + 3 * k – -7 / w
5) cal = x == 5 || x <= 3 && x >= -3 || (x != 0)
3. ประเภทข้ อมลที
ู ่ เป็ นผลลัพธ์ สุดท้ ายจากการดําเนินการ
สามารถสรุปความสัมพันธ์ของประเภทข้ อมูล ตัวเลข ตัวอักขระ ตัวตรรกะ และ สตริ ง ได้ 20 รูปแบบ ดังนี ้
รปแบบ
ู ข้ อมลที
ู ่1 กลุ่มของตัวดําเนินการ ข้ อมลที
ู ่ 2 ประเภทข้ อมลสุ ู ดท้ าย
1. ตัวเลข + - * / % ตัวเลข ตัวเลข (ที่มีศักดิ์ศรีสูงสุด)
2. ตัวเลข = += -= *= /= ตัวเลข[1] ตัวเลข (ของข้ อมลทีู ่ 1)
3. ตัวเลข == != < > <= >= ตัวเลข boolean
4. ตัวเลข + - * / % = += -= *= /= char ตัวเลข
รปแบบ
ู ข้ อมลที
ู ่1 กลุ่มของตัวดําเนินการ ข้ อมลที
ู ่ 2 ประเภทข้ อมลสุ ู ดท้ าย
5. ตัวเลข ++ -- - ตัวเลข
6. - ++ -- ตัวเลข ตัวเลข
7. char + - * / % char ตัวเลข (โดยทัว่ ไปคือ int)
8. char = += -= *= /= char char
9. char == != < > <= >= char boolean
10. char + - * / % ตัวเลข ตัวเลข

11. char += -= *= /= ตัวเลข char
12. char = ตัวเลข[2] char
13. char ++ -- - char
14. - ++ -- char char

15. String + ทุกประเภท String
16. ทุกประเภท + String String
17. String = String String
18. String == != String boolean
19. boolean = && || boolean boolean
20. - ! boolean boolean (ค่ าตรงข้ าม)
[1]
ประเภทข้ อมูลของข้ อมูลที่ 1 ต้ องมีศกั ดิศ์ รี สูงกว่าหรือเท่ากับประเภทข้ อมูลของข้ อมูลที่ 2
[2]
ประเภทข้ อมูลของข้ อมูลที่ 2 ต้ องเป็ นตัวเลขจํานวนเต็มที่มีศกั ดิศ์ รี ตํ่ากว่าหรื อเท่ากับ int เท่านัน้
โจทย์ ข้อที่ 8 [ระดับง่ าย] จงระบุประเภทข้ อมลูที่เป็ นผลลัพธ์ สุดท้ ายและค่ าคําตอบจากการดําเนินการ
ของนิพจน์ ต่อไปนี ้ (10 คะแนน)
ข้ อ นิพจน์ ประเภทข้ อมลสุู ดท้ าย คําตอบ
1. (5 + 4) + ((3 + 2L) – 1)
2. (5 – 2 / 1) + 0.000 + '\u0000'
3. 5.0F * 6 – ('D' - 'A')
*4. 2 % (0.4 + 0.3F)
*5. !("Java" == "Jaba");
6. (13 / 5) + (2 / 3)
7. '0' - '1' + "5" + false
8. 4E1 / 2
9. !false || true && false || !true
10. 0.0 / (10 + 'q' – 'Y') != 0L
4. การเปลี่ยนประเภทข้ อมลู (Type Conversions)
1) เปลี่ยนแบบอัตโนมัติ โดยทัว่ ไปคอมไพเลอร์ ของภาษาจาวาจะปรับเปลี่ยนประเภทข้ อมูลให้ อตั โนมัติตาม
ความเหมาะสม ซึง่ เป็ นไปตามความสัมพันธ์ทงั ้ 19 รูปแบบที่ได้ กล่าวไปในหัวข้ อที่แล้ ว ดังตัวอย่างต่อไปนี ้
double a = 34 + 1.0F; //a = 35.0 int c = 'A'; //c = 65
float b = 4L / 3; //b = 1.0F char d = 65; //d = 'A'
2) เปลี่ยนโดยการบังคับตามที่ระบุ (Casting) จะเป็ นการบังคับหรื อกําหนดประเภทข้ อมูลที่ต้องการจะให้

เป็ น โดยการใส่วงเล็บชื่อประเภทข้ อมูลหน้ าข้ อมูลที่จะเปลี่ยน ดังรูปแบบคําสัง่ และตัวอย่างต่อไปนี ้
(<ประเภทข้ อมูล>) <ข้ อมูล/ตัวแปร> ใช้ กบั ข้ อมูลประเภทตัวเลข (เต็ม/จริ ง) และอักขระ เท่านัน้
byte b = 50; char c = '1';

b = (byte)(b * 2); //b = 100 int num = (int) c; //num = 49
double x = 5.99; int ten = (int) "10"; //Error

long y = (long) x; //y = 5 boolean f = (boolean) 1; //Error
โจทย์ ข้อที่ 9 [ระดับง่ าย] จงระบุประเภทข้ อมลที

ู ่ เป็ นผลลัพธ์ สุดท้ ายและค่ าคําตอบจากการดําเนินการ
ของนิพจน์ หรื อคําสั่งต่ อไปนี ้ (10 คะแนน)
ข้ อ นิพจน์ ประเภทข้ อมลสุู ดท้ าย คําตอบ
1. (byte)(3 + 5.4) / 7
2. (3 + 5.4) / (float) 7
3. (float)((3 + 2) / 7)
4. char c = (double) 'A';
5. char c = (int) 'b'; c += 1.7;
6. char c = 67 + (int) 3.91
7. (int) 19.8E-1
8. (short)((double) 1 / 2) == 00L + 0
9. (byte) 011 + (short) 1.9991
10. (byte) '0' – '6' + (char) 1.5
5. คลาสมาตรฐานทางคณิตศาสตร์ (Mathematic Class) มีเมท็อดที่สําคัญดังนี ้

ลําดับ รปแบบคํ
ู าสั่ง ประเภทข้ อมลรั
ู บเข้ า หน้ าที่
1. Math.toRadians(degree) double เปลี่ยนองศาเป็ นเรเดียน
2. Math.toDegrees(radian) double เปลี่ยนเรเดียนเป็ นองศา
3. Math.sin(radian) double คํานวณค่าไซน์ (Sine)
4. Math.cos(radian) double คํานวณค่าโคไซน์ (Cosine)
ลําดับ รปแบบคํ
ู าสั่ง ประเภทข้ อมลรั
ู บเข้ า หน้ าที่
5. Math.sqrt(x) double คํานวณค่ารากที่สอง
6. Math.pow(x, y) double, double คํานวณค่าเลขยกกําลัง xy
7. Math.abs(x) double คํานวณค่าสัมบูรณ์ (Absolute)
8. Math.max(x, y) double, double คํานวณค่ามากระหว่าง x กับ y
9. Math.min(x, y) double, double คํานวณค่าน้ อยระหว่าง x กับ y
10. Math.log10(x) double คํานวณค่าล๊ อกาลิทมึ ฐานสิบ
11. Math.PI ค่าคงที่ PI ซึง่ เท่ากับ 3.141592653589793…
Math.random() ไม่มีข้อมูลรับเข้ า สร้ างตัวเลขสุม่ ในช่วง [0.0, 1.0)
12.
(int)(Math.random() * (b – a + 1) + a) สร้ างตัวเลขสุม ่ จํ านวนเต็มในช่วง a ถึง b
หมายเหตุ ผลลัพธ์ที่ได้ ทกุ ข้ อจะเป็ นประเภท double (ยกเว้ นข้ อที่ 12 ส่วนล่าง ผลลัพธ์จะเป็ นประเภท int)
โจทย์ ข้อที่ 10 [ระดับง่ าย] จงเขียนคําสั่งคํานวณ (Assignment Statement) จากนิพจน์ ต่อไปนีใ้ ห้ ถูกต้ อง
ตามหลักไวยากรณ์ ของภาษาจาวา พร้ อมทัง้ ประกาศประเภทตัวแปรที่ใช้ ให้ ครบสมบรณ์ ู (6 คะแนน)
ข้ อ นิพจน์ คําสั่ง
2πr 2
1.
b 2 − 4ac
m−n p2 − q2
2. −
2mn p+q
3x 3 + 4 y 4
3. + πxy
( x + y)( x − y)
โจทย์ ข้อที่ 11 [ระดับง่ าย] จงเขียนคําสั่งภาษาจาวาที่ถูกต้ องสมบรณ์

ู เพื่อกําหนดค่ าให้ กับตัวแปร n โดย
ใช้ การสุ่มค่ าตัวเลขจํานวนเต็มตามเงื่อนไขต่ อไปนี ้ (6 คะแนน)
ข้ อ เงื่อนไข คําสั่ง
1. สุม่ ตัวเลข 0 – 9
โจทย์ ข้อที่ 12 [ระดับปานกลาง] จงเขียนโปรแกรมภาษาจาวาที่สมบรณ์ ู เพื่อรั บตัวเลขจํานวนเต็มที่มี
ความยาว 4 หลักหนึ่งค่ าเข้ ามาทางแป้นพิมพ์ แล้ วทําการสลับหลักของตัวเลขนัน้ ดังตัวอย่ างการแสดงผล
ต่ อไปนี ้ (10 คะแนน) Enter number: 1234
1 2 3 4 Reversed number: 4321
Enter number: 9753

Reversed number: 3579
โจทย์ ข้อที่ 13 [ระดับปานกลาง] จงเขียนโปรแกรมภาษาจาวาที่สมบรณ์ู เพื่อรั บตัวเลขจํานวนเต็มจาก

แป้นพิมพ์ ยาว 6 หลัก แล้ วทําการตัดตัวเลข 2 หลักแรก และ 2 หลักสุดท้ าย เพื่อนํามาคํานวนหาค่ า
ผลบวกและผลต่ างของสองตัวเลขนัน้ พร้ อมทัง้ แสดงผลลัพธ์ ออกทางจอภาพให้ สวยงาม (10 คะแนน)
1 2 3 4
โจทย์ ข้อที่ 14 [ระดับยาก] ธนาคารลานเกียร์ แห่ งประเทศไทยได้ ว่าจ้ างให้ นิสิตชัน้ ปี ที่ 1 ของคณะวิศว-
กรรมศาสตร์ จุฬาลงกรณ์ มหาวิทยาลัย ซึ่งกําลังเรี ยนวิชาการเขียนโปรแกรมด้ วยภาษาจาวาเบือ้ งต้ น
เพื่อสร้ างเครื่ องคํานวณจํานวนเงิน (Money Machine) โดยเมื่อผ้ ูใช้ ระบุจาํ นวนเงินเข้ ามา โปรแกรมจะทํา
การคํานวณดวู่ าจะต้ องใช้ ธนบัตรใบละ 1000 บาท 500 บาท 100 บาท 50 บาท และ 20 บาท อย่ างละกี่
ใบ และเหรี ยญ 10 บาท 5 บาท 2 บาท และ 1 บาท อย่ างละกี่เหรี ยญ โดยมีตัวอย่ างของผลการทํางาน
ดังต่ อไปนี ้ (15 คะแนน) Money : 2897
1 2 3 4 1000 Baht : 2
500 Baht : 1
100 Baht : 3
50 Baht : 1
20 Baht : 2
10 Baht : 0
5 Baht : 1
2 Baht : 1
1 Baht : 0
Do you know?
1 / 0 = Error
1.0 / 0.0 = Infinity
-1.0 / 0.0 = -Infinity
1.0 / (1.0 / 0) = 0.0
0.0 / 0.0 = NaN
Decision Statements - 03 Computer Programming using Java 31
CHAPTER คําสัง่ ตัดสินใจ
03 (Decision Statements)
1. คําสั่งตัดสินใจแบบเบือ้ งต้ น (Basic Decision Statements)
1. นิยามและข้ อกําหนดของคําสั่งตัดสินใจ
1) คําสัง่ ตัดสินใจ คือ คําสัง่ ที่ใช้ สําหรับเลือกทํางานหรื อตัดสินใจทํางานตามเงื่อนไข (Condition) อย่างใด
อย่างหนึง่ ที่กําหนดขึ ้น เมื่อเงื่อนไขนันเป็
้ นจริง
2) คําสัง่ ตัดสินใจในภาษาจาวา ประกอบไปด้ วย 2 ชุดคําสัง่ ได้ แก่ [1] if-else และ [2] switch-case
โดยในเอกสารบทนี ้จะกล่าวถึงเพียงแค่คําสัง่ if-else เท่านัน้
3) ชุดคําสัง่ ตัดสินใจ ถ้ ามีหลายเงื่อนไขจะทํางานเพียงแค่กรณีใดกรณีหนึง่ ที่เป็ นจริ งเพียงกรณีเดียวเท่านัน้
2. คําสั่งตัดสินใจแบบ 1 เงื่อนไข
คําสัง่ ตัดสินใจแบบ 1 เงื่อนไขนี ้จะใช้ คําสัง่ if เพียงอย่างเดียวในการทํางาน โดยมีรูปแบบดังนี ้
1 if(Condition) { เงื่อนไข (Condition) จะเป็ นนิพจน์ตรรกะ (Boolean Expression)
2 Statement;
3 } ที่แสดงถึงค่าความจริงว่าเมื่อไรจะทําในคําสัง่ if หรื อเมื่อไรไม่ทํา
ผังงาน ภายในคําสัง่ if สามารถมีคําสัง่ ได้ มากกว่า 1 คําสัง่ แต่ถ้ามีเพียง

1 คําสัง่ ไม่ต้องมีเครื่ องหมายปี กกาเปิ ดปิ ดก็ได้
True
Condition
False Statement
พิจารณาเงื่อนไขของคําสัง่ if ว่าเป็ นจริงหรื อไม่ ถ้ าเป็ นจริงจะเข้ า
ทําคําสัง่ ภายในคําสัง่ if ทุกๆ คําสัง่ ถ้ าเป็ นเท็จจะไม่เข้ าทํา
ตัวอย่ าง
1 if(score >= 100) { ถ้ า score = 120 จะแสดงผล ABC
2 System.out.print("A");
3 } ถ้ า score = 100 จะแสดงผล ABC
4 System.out.print("B");
5 System.out.print("C"); ถ้ า score = 60 จะแสดงผล BC
โจทย์ ข้อที่ 1 [ระดับง่ าย] จงแสดงผลลัพธ์ จากส่ วนของโปรแกรมตามค่ า n ที่กาํ หนดให้ ต่อไปนี ้ (5 คะแนน)
1 if(n < 50) n = 49 n = 75 n = 60 n = 100 n = 123
2 System.out.println("1"+n);
3 System.out.println(n++);
4 if(n <= 75)
5 System.out.println("3");
6 if(n >= 100) {
7 System.out.println(n--);
8 System.out.println(--n);
9 }
32 Computer Programming using Java 03 - Decision Statements
โจทย์ ข้อที่ 2 [ระดับง่ าย] จงเขียนเฉพาะคําสั่ง if ตามเงื่อนไขที่กาํ หนดให้ ต่อไปนี ้ (15 คะแนน)
1) ถ้ าตัวแปร x มีค่ามากกว่ า 0 ให้ แสดงค่ ารากที่สองของตัวแปร x ขึน้ บนจอภาพ (5 คะแนน)
2) ถ้ าตัวแปร i มีค่าน้ อยกว่ าหรื อเท่ ากับ 10 ให้ เพิ่มค่ าตัวแปร i นัน้ ขึน้ อีก 1 (5 คะแนน)
3) ถ้ าตัวแปร gpa มีค่ามากกว่ าหรื อเท่ ากับ 2.00 ให้ แสดงข้ อความว่ า "Pass" ขึน้ บนจอภาพ ถ้ าไม่ เช่ นนัน้
ให้ แสดงข้ อความว่ า "Retire" ขึน้ บนจอภาพ (5 คะแนน)
3. คําสั่งตัดสินใจแบบ 2 เงื่อนไข
คําสัง่ ตัดสินใจแบบ 2 เงื่อนไขนี ้จะใช้ คําสัง่ if-else ในการทํางาน โดยมีรูปแบบดังนี ้
if(Condition) {
1
2
ถึงแม้ วา่ จะมี 2 เงื่อนไข ก็ตาม แต่ให้ ระบุเงื่อนไขไว้ ที่คําสัง่ if
Statement1;
3 } else { เท่านัน้ โดยไม่ต้องระบุเงื่อนไขที่คําสัง่ else (หลังคําสัง่ else
4 Statement2;
5 } ห้ามใส่เงือ่ นไข (Condition) โดยเด็ดขาด)
ภายในคําสัง่ if และ else สามารถมีคําสัง่ ได้ มากกว่า 1 คําสัง่
ผังงาน
แต่ถ้ามีเพียง 1 คําสัง่ ไม่ต้องมีเครื่ องหมายปี กกาเปิ ดปิ ดก็ได้
False True คําสัง่ if-else ไม่สามารถเข้ าทําคําสัง่ ภายในพร้ อมกันได้ โดย
Condition
จะเข้ าทําเพียงกรณี if หรื อ else กรณีใดกรณีหนึง่ เท่านัน้
Statement2 Statement1
พิจารณาเงื่อนไขของคําสัง่ if ว่าเป็ นจริงหรื อไม่ ถ้ าเป็ นจริงจะเข้ า
ทําคําสัง่ ภายใน if ทุกๆ คําสัง่ แต่ถ้าเป็ นเท็จจะเข้ าทําคําสัง่
ภายใน else ทุกๆ คําสัง่
1 if(score >= 100) {
2 System.out.print("A"); ถ้ า score = 120 จะแสดงผล AC
3 } else {
4 System.out.print("B"); ถ้ า score = 100 จะแสดงผล AC
5 }
6 System.out.print("C"); ถ้ า score = 60 จะแสดงผล BC
โจทย์ ข้อที่ 3 [ระดับง่ าย] จงแสดงผลลัพธ์ จากส่ วนของโปรแกรมตามค่ า s ที่กาํ หนดให้ ต่อไปนี ้ (5 คะแนน)
1 if(s >= 40) s = 39 s = 40 s = 89 s = 100 s = 0
2 System.out.println("1"+s);
3 else {
4 System.out.println("0");
5 System.out.println(++s);
6 }
7 if(s >= 90)
8 System.out.println(s++);
9 else
10 System.out.println(++s);
11 System.out.println(--s);
โจทย์ ข้อที่ 4 [ระดับง่ าย] จงเขียนเฉพาะคําสั่ง if-else เพื่อตรวจสอบตัวเลขจํานวนเต็มที่เก็บในตัวแปร n

เป็ นเลขคี่หรื อเลขค่ ู ถ้ าเป็ นเลขคี่ให้ แสดงค่ าตัวเลขนัน้ ตามด้ วยข้ อความ "is odd number" ขึน้ บนจอภาพ
ถ้ าเป็ นเลขค่ ูให้ แสดงค่ าตัวเลขนัน้ ตามด้ วยข้ อความ "is even number" ขึน้ บนจอภาพ (5 คะแนน)
4. คําสั่งตัดสินใจแบบมากกว่ า 2 เงื่อนไข (หลายเงื่อนไข)

คําสัง่ ตัดสินใจแบบมากกว่า 2 เงื่อนไขนี ้จะใช้ คําสัง่ if-else ซ้ อน if-else ในการทํางาน โดยมีรูปแบบดังนี ้
1 if(Condition1) {
2 Statement1; จะระบุ เงื่อนไข ที่คําสัง่ if หรื อ else if เท่านัน้ แต่จะไม่
3 } else if(Condition2) { ระบุเงื่อนไขที่คําสัง่ else โดยเด็ดขาด และสามารถตัดคําสัง่
4 Statement2;
5 } else if(Condition3) { else ออกไปได้ (จะกล่าวรายละเอียดอีกครัง้ ในบทที่ 9)
6 ...
7 } else { ถ้ ามีหลายเงื่อนไขที่เป็ นจริงจะเข้ าทําเพียงกรณีแรกที่พบว่าเป็ น
8 StatementN;
9 } จริ งเท่านัน้ (กรณีที่เหลือจะไม่เข้ าทําอีกถึงแม้ วา่ จะเป็ นจริง)
ผังงาน
พิจารณาเงื่อนไขของคําสัง่ if ว่าเป็ นจริงหรื อไม่ ถ้ าเป็ น
False True
จริ งจะเข้ าทําคําสัง่ ภายในคําสัง่ if ทุกๆ คําสัง่ ถ้ าเป็ น
Condition1
เท็จจะพิจารณาเงื่อนไขของคําสัง่ else if ว่าเป็ นจริง
False
Condition2
True
Statement1 หรื อไม่ ถ้ าเป็ นจริงจะเข้ าทําคําสัง่ ภายในคําสัง่ else
if ทุกๆ คําสัง่ ซึง่ จะทําแบบนี ้ไปเรื่ อยๆ จนถึงคําสัง่
Statement2
สุดท้ าย ถ้ าไม่มีเงื่อนไขใดเลยเป็ นจริงจะเข้ าทําภายใน
คําสัง่ else ทุกๆ คําสัง่ (เลือกทําเพียงกรณีเดียวเท่านัน) ้
โจทย์ ข้อที่ 5 [ระดับง่ าย] จงแสดงผลลัพธ์ จากส่ วนของโปรแกรมตามค่ า score ต่ อไปนี ้ (11 คะแนน)
1 if(score > 100) { ข้ อ ค่ า score ผลลัพธ์ ท่ แี สดง
2 System.out.println("Error 1");
3 } else if(score < 0) { 1. 90
5 } else if(score == 0) { 2. -3
7 } else if(score >= 80) { 3. 47
8 System.out.println("A");
9 } else if(score >= 75) { 4. 55
10 System.out.println("B+");
11 } else if(score >= 70) { 5. 64
12 System.out.println("B");
13 } else if(score >= 65) { 6. 79
14 System.out.println("C+");
15 } else if(score >= 60) { 7. 0
16 System.out.println("C");
17 } else if(score >= 55) { 8. 101
18 System.out.println("D+");
19 } else if(score >= 50) { 9. 71
20 System.out.println("D");
21 } else { 10. 50
22 System.out.println("F");
23 } 11. 66
โจทย์ ข้อที่ 6 [ระดับง่ าย] จงเขียนเฉพาะคําสั่ง if-else ซ้ อน if-else เพื่อตรวจสอบว่ าตัวเลขจํานวนเต็ม

ที่เก็บอย่ ใู นตัวแปร num เป็ นจํานวนเต็มประเภทใด ถ้ าเป็ นจํานวนเต็มบวกให้ แสดงข้ อความว่ า "Positive
Number" ขึน ้ บนจอภาพ ถ้ าเป็ นจํานวนเต็มลบให้ แสดงข้ อความว่ า "Negative Number" ขึน้ บนจอภาพ
ู ให้ แสดงข้ อความว่ า "Zero Number" ขึน้ บนจอภาพ (8 คะแนน)
ถ้ าเป็ นจํานวนเต็มศนย์
5. การเขียนเงื่อนไขหรื อนิพจน์ ตรรกะ (Condition / Boolean Expression)

1) เงื่อนไขหรื อนิพจน์ตรรกะจะเป็ นค่าความจริ ง (Boolean) ที่มีคา่ เป็ น True หรื อ False อย่างใดอย่างหนึ่ง
เท่านัน้ เช่น a == b, grade == 'A', x < 4, y >= 10.0, 1 == 1.0 เป็ นต้ น
2) ตัวดําเนินการที่ใช้ สําหรับการเขียนนิพจน์ตรรกะคือ ตัวดําเนินการเปรี ยบเทียบค่า (Comparison Opera-
tors) ซึง่ ได้ แก่เครื่ องหมาย == != < > <= >=
3) ถ้ าเงื่อนไขหรือนิพจน์ตรรกะมีหลายเงื่อนไขจะใช้ ตวั ดําเนินการทางตรรกศาสตร์ (Logical Operators) ซึง่
ได้ แก่เครื่ องหมาย && || ! ในการเชื่อมเงื่อนไขต่างๆ เข้ าด้ วยกัน
4) ข้ อมูลที่นํามาเปรี ยบเทียบต้ องเป็ นประเภทเดียวกัน ถ้ าไม่เช่นนันระบบจะปรั
้ บให้ เป็ นประเภทเดียวกัน
5) ระวังเครื่ องหมาย = และ == เช่น ให้ n = 1 ความหมายจะไม่เหมือนกับ n == 1 โดยที่ n = 1 เป็ นการ
กําหนดค่าให้ กบั ตัวแปร n ให้ เท่ากับ 1 ส่วน n == 1 เป็ นการเปรียบเทียบค่าว่า n เท่ากับ 1 จริงหรื อไม่
โจทย์ ข้อที่ 7 [ระดับง่ าย] จงหาคําตอบจากนิพจน์ ตรรกะต่ อไปนีว้ ่ าเป็ นจริง (T) หรื อเท็จ (F) (15 คะแนน)
ข้ อ นิพจน์ ตรรกะ คําตอบ (T/F) หมายเหตุ
1. (2 < 5) && (6 != 7) || (3 > 4) -
2. (x > 13) || (x <= 13) && x != 13 x = 13
3. (a++ != 2) a = 1
4. (--a == 2) a = 2
5. (x++ == 9) && (--x == 9) && (x == 9) x = 9
6. 50 <= a < 150 a = 100
7. a += 2 == 6 a = 4
8. 45 <= 'A' && '0' == 48 -

9. num <= 'B' num = 66.0F
10. 1 >= 1.00 -

11. 95.7 != 95.700000000 -
12. 2.0F != 2.0D -
13. 10 <= 10L -
*14. (1.1 + 2.2) == 3.3 -
*15. s == "java" s = "java"
6. ขอบเขตของตัวแปร (Scope Rule)

1) กฏของตัวแปรและการกําหนดขอบเขตของตัวแปร
(1) ตัวแปรประกาศภายใน Block ไหนสามารถเรี ยกใช้ ได้ ภายใน Block นันเท่
้ านัน้
(2) ตัวแปรประกาศที่บรรทัดใดจะสามารถเรี ยกใช้ ได้ ตงแต่
ั ้ บรรทัดนันลงไปจนสิ
้ ้นสุด Block ที่ประกาศเท่านัน้
1 int x;
2 x = 5; ตัวแปรต้ องประกาศก่อนเรี ยกใช้ งาน
3 y = 30.5; //Error
4 double y; ไม่สามารถเรี ยกใช้ งานตัวแปร y ก่อนการประกาศตัวแปรได้
1 {
2 int a = 1;
3 { int b = 2; }
4 { a = 3; } ไม่สามารถเรี ยกใช้ งานตัวแปร b หลังจากที่สิ ้นสุด Block
5
6
b = 4; //Error
int c = a;
ที่ประกาศได้
7 c = c + 1;
8 }
2) ขอบเขตของตัวแปรภายในและภายนอกคําสั่ง if-else
(1) ตัวแปรประกาศภายในคําสัง่ if หรื อ else จะสามารถเรี ยกใช้ งานได้ ภายในคําสัง่ if หรื อ else
เท่านัน้ เมื่อจบคําสัง่ if หรื อ else จะไม่สามารถเรียกใช้ ตวั แปรนันได้
้ อีก
(2) ตัวแปรประกาศภายนอกและอยูเ่ หนือคําสัง่ if หรื อ else จะสามารถเรี ยกใช้ งานได้ ภายในคําสัง่ if
หรื อ else และเมื่อจบคําสัง่ if หรื อ else ก็ยงั สามารถเรี ยกใช้ ตวั แปรนันได้
้ เช่นเดิม
1 int x = 5;
2 if (x < 10) { ตัวแปร y ถูกประกาศภายในคําสัง่ if สามารถ
3
4 }
int y = x;
เรี ยกใช้ งานได้ ภายในคําสัง่ if เท่านัน้ เมื่อจบ
5 System.out.println(x); คําสัง่ if แล้ ว จะไม่สามารถเรี ยกใช้ งานได้ อีก
6 System.out.println(y); //Error
โจทย์ ข้อที่ 8 [ระดับง่ าย] จงพิจารณาส่ วนของโปรแกรมภาษาจาวาต่ อไปนี ้ เขียนถูก (;) หรือผิด (:)
ตามหลักขอบเขตของตัวแปร พร้ อมอธิบายเหตุผล (6 คะแนน)
1) int y = 25;
if (y > 30) {
System.out.println(y);
}
2) int y;
if (y <= 10) {
}
3) int x = 1;
int y = 1;
if (x == y) {
int z = x + y;
}
System.out.println(z);
4) int x = 100;
if (x < 50) {
int y = ++x;
} else {
int y = --x;
}
5) int x = 100, y;
if (x < 50) {
int y = ++x;
} else {
int y = --x;
}
6) int x = 100, y;
if (x > 50) {
y = ++x;
}
if (x < 50) {
y = --x;
}
ู เพื่อรั บค่ าตัวเลขจํานวนเต็มหนึ่งค่ าเข้ ามา
ทางแป้นพิมพ์ เก็บไว้ ในตัวแปร n แล้ วหาค่ าสัมบรณ์
ู (Absolute) ของตัวแปร n นัน้ พร้ อมทัง้ แสดงผลลัพธ์
ขึน้ บนจอภาพ โดยห้ ามใช้ คาํ สั่งจากคลาส Math และห้ ามประกาศตัวแปรใดๆ เพิ่มเติม (10 คะแนน)
1 2 3 4
โจทย์ ข้อที่ 10 [ระดับง่ าย] จงเขียนโปรแกรมภาษาจาวาที่สมบรณ์ ู เพื่อรั บตัวเลขจํานวนเต็มจากทางแป้น-

พิมพ์ สองตัวเข้ ามาเก็บไว้ ในตัวแปร a และ b ตามลําดับ แล้ วทําการแสดงผลลัพธ์ ว่าจํานวนใดที่มีค่า
มากกว่ ากันหรือมีค่าเท่ ากันออกทางจอภาพ (ให้ ใช้ เพียงคําสั่ง if เท่ านัน้ ห้ ามใช้ คาํ สั่ง else) (10 คะแนน)
1 2 3 4
โจทย์ ข้อที่ 11 [ระดับปานกลาง] จงเขียนโปรแกรมภาษาจาวาที่สมบรณ์ ู เพื่อรั บวันเดือนปี เกิดของนิสิต

คณะวิศวกรรมศาสตร์ เข้ ามาทางแป้นพิมพ์ หนึ่งคน เพื่อใช้ คาํ นวณและแสดงค่ าระดับความเกรี ยน (Noob
Levels) ที่ประกอบไปด้ วยระดับที่ 1 เกรี ยน (Noob) ระดับที่ 2 เกรี ยนเรี ยกพ่ อ (Father Noob) ระดับที่ 3
เกรี ยนเทพ (God Noob) และระดับที่ 4 เกรี ยนเมพ (Hof Noob) โดยให้ รับข้ อมลทั ู ง้ สามค่ าอย่ ูภายใน
บรรทัดเดียวกัน และแต่ ละค่ าแบ่ งด้ วยช่ องว่ างอย่ างน้ อยหนึ่งช่ องว่ าง เช่ น "13 006 2526" หรื อ
"1 12 2535" หรื อ "04 08 2537" เป็ นต้ น และให้ ใช้ สูตรในการคํานวณหาค่ าระดับความเกรี ยน
ตามที่กาํ หนดให้ ดงั ต่ อไปนี ้ (10 คะแนน)
1 2 3 4 NoobLevel = (( day + month + year)%4) + 1
โจทย์ ข้อที่ 12 [ระดับปานกลาง] จงเขียนโปรแกรมภาษาจาวาที่สมบรณ์ ู เพื่อใช้ ในการคํานวณหาค่ าความ

ต้ านทานรวมของวงจรไฟฟ้าที่ประกอบไปด้ วยตัวต้ าน 3 ตัว ซึ่งต่ อแบบอนุกรมหรื อต่ อแบบขนาน โดยจะ
ต้ องรั บค่ าของตัวต้ านทานทัง้ 3 ตัว ที่เป็ นค่ าจํานวนเต็มเข้ ามาทางแป้นพิมพ์ ทีละค่ าเก็บไว้ ในตัวแปร r1,
r2 และ r3 ตามลําดับ พร้ อมทัง้ รั บจํานวนเต็มอีกหนึ่งค่ าเก็บไว้ ในตัวแปร type เพื่อใช้ แทนรปแบบการ
ู
ต่ อวงจร โดยถ้ าพิมพ์ ค่า 1 โปรแกรมจะแสดงค่ าความต้ านทานรวมของวงจรแบบอนุกรม ถ้ าพิมพ์ ค่า 2
โปรแกรมจะแสดงค่ าความต้ านทานรวมของวงจรแบบขนาน ถ้ าพิมพ์ ค่าอื่นๆ นอกเหนือจากนีใ้ ห้ แสดง
ข้ อความว่ า "Incorrect Circuit Type" โดยกําหนดให้ ใช้ สูตรดังต่ อไปนีใ้ นการคํานวณ และ
กําหนดให้ ใช้ ตวั แปร rTotal เก็บค่ าผลลัพธ์ ของความต้ านทานรวม (10 คะแนน)
แบบอนุกรม R total = R 1 + R 2 + R 3 แบบขนาน 1
=
1
+
1
+
1
R total R1 R2 R3
(กําหนดให้ ใช้ คาํ สั่ง if เท่ านั้นในการเขียนโปรแกรม ห้ ามใช้ คาํ สั่ง else if หรื อ else อย่ างเด็ดขาด)
1 2 3 4
โจทย์ ข้อที่ 13 [ระดับยาก] จงเขียนโปรแกรมภาษาจาวาที่สมบรณ์ ู เพื่อตรวจสอบเลขประจําตัวนิสิตที่

รั บเข้ ามาทางแป้นพิมพ์ ความยาว 10 หลัก ถ้ าไม่ ถูกต้ องให้ แสดงข้ อความว่ า "Invalid ID" และมี
รายละเอียดดังต่ อไปนี ้
1. ตรวจสอบว่ าใช่ นิสิตคณะวิศวกรรมศาสตร์ หรื อไม่ โดยตัวเลข 2 หลักสุดท้ ายจะต้ องเป็ นตัวเลข 21
แล้ วแสดงข้ อความว่ า "Engineering Student" ถ้ าใช่ นิสิตคณะวิศวกรรมศาสตร์ ถ้ าไม่ เช่ นนัน้ ให้
แสดงข้ อความว่ า "Unknown Student"
2. ตรวจสอบว่ าเป็ นนิ สิตในระดับปริ ญญาบัณฑิต (Undergraduate) หรื อนิ สิตระดับบัณฑิตศึกษา
(Graduate) โดยถ้ าหลักที่ 3 เป็ นตัวเลข 3 ให้ แสดงข้ อความว่ า "Undergraduate" ถ้ าเป็ นตัวเลข 7
ให้ แสดงข้ อความว่ า "Graduate" ถ้ าไม่ เช่ นนัน้ ให้ แสดงข้ อความว่ า "Unknown Levels"
3. ตรวจสอบว่ าเป็ นนิสิตชัน้ ปี ใด โดย 2 หลักแรกจะแสดงปี การศึกษาแรกที่นิสิตเข้ าเรียน ให้ คาํ นวนและ
แสดงชัน้ ปี ปั จจุบันของนิสิต และถ้ าเป็ นนิสิตระดับปริ ญญาบัณฑิตให้ แสดงข้ อความเพิ่มเติมต่ อท้ าย
ดังนี ้ นิสิตปี 1 แสดงคําว่ า "Freshmen" นิสิตปี 2 แสดงคําว่ า "Sophomore" นิสิตปี 3 แสดงคําว่ า
"Junior" นิสิตปี 4 แสดงคําว่ า "Senior" ส่ วนนิสิตปี อื่นๆ ไม่ ต้องแสดงข้ อความใดเพิ่มเติม
ผลลัพธ์ การทํางานของโปรแกรมแสดงดังตัวอย่ างต่ อไปนี ้ (15 คะแนน) Student ID : 5330123421
Engineering Student
1 2 3 4 5 6 Undergraduate
1 (Freshmen)
Student ID : 5271822821
Engineering Student
Graduate
2
Iteration Statements - 04 Computer Programming using Java 41
CHAPTER คําสัง่ วนซํ้า
04 (Iteration Statements)
1. คําสั่งวนซํา้ แบบเบือ้ งต้ นด้ วยคําสั่ง while
1. นิยามและข้ อกําหนดของคําสั่งวนซํา้ หรื อทําซํา้
1) คําสัง่ วนซํ ้าหรื อทําซํ ้า (Iteration/Repetition) คือ คําสัง่ ที่ใช้ สําหรับวนรอบเพื่อทํางานอย่างใดอย่างหนึ่ง
ตามเงื่อนไข (Condition) ที่กําหนดขึ ้น และจะวนทํางานแบบนันไปเรื ้ ่ อยๆ ตราบใดที่เงื่อนไขยังเป็ นจริง
2) คําสัง่ วนซํ ้าในภาษาจาวา ประกอบไปด้ วย 3 ชุดคําสัง่ ได้ แก่ [1] while, [2] do-while และ [3] for
2. คําสั่งวนซํา้ ด้ วยคําสั่ง while มี 3 ส่วนหลักดังรูปแบบคําสัง่ ต่อไปนี ้

1 Initial; 1 ค่าตังต้
้ น (Initial) เป็ นการกําหนดค่าเริ่มต้ นสําหรับการวนซํ ้า
2 while(Condition) {
3 Statement(s); 2 เงื่อนไข (Condition) จะเป็ นนิพจน์ตรรกะ (Boolean Expression)
4 Update;
5 } ที่แสดงถึงค่าความจริงว่าเมื่อไรจะวนซํ ้า เมื่อไรจะสิ ้นสุดการวนซํ ้า
ผังงาน 3 การเปลี่ยนรอบ (Update) เป็ นการเปลี่ยนรอบการวนซํ ้า (ถ้ าไม่ระบุ

ส่วนนี ้จะเกิดการวนซํ ้าแบบไม่ รู้จบ หรื อ Infinite Loop)
Initial
ภายในคําสัง่ while ถ้ ามีเพียง 1 คําสัง่ ไม่ต้องมีเครื่ องหมายปี ก
กาเปิ ดปิ ดก็ได้
False
Update
Condition พิจารณาเงื่อนไขของคําสัง่ while ว่าเป็ นจริงหรื อไม่ ถ้ าเป็ นจริง
True จะเข้ าทําคําสัง่ ทุกๆ คําสัง่ ภายในคําสัง่ while และจะวนทํางาน
Statement
แบบนี ้ไปเรื่ อยๆ จนกว่าเงื่อนไขของคําสัง่ while จะเป็ นเท็จ ก็จะ
สิ ้นสุดการวนซํ ้า
ตัวอย่ าง กําหนดค่าเริ่ มต้ นให้ ตวั แปร i เท่ากับ 1 แล้ วทําการวนซํ ้าเพื่อ
int i = 1;
1
2 while(i <= 5) {
แสดงค่า i ตังแต่้ 1 ถึง 5 โดยในแต่ละรอบการวนซํ ้าจะเพิ่มจํา
3 System.out.print(i); นวนรอบ (เพิ่มค่า i) ขึ ้นทีละ 1 (โดยใช้ คําสัง่ i++) ดังนัน้
4 i++;
5 } ผลลัพธ์ที่ได้ คือ 12345
1 int i = 0, j = 5; n = 1 n = 0 n = -1 n = 3 n = -2
2 while (i <= n) {
4 i = i + 2; }
5 while (j > n) {
6 System.out.println(--j);
7 j--;
8 }
42 Computer Programming using Java 04 - Iteration Statements
โจทย์ ข้อที่ 2 [ระดับง่ าย] จงเขียนเฉพาะคําสั่ง while ตามเงื่อนไขต่ อไปนี ้ (10 คะแนน)
1) แสดงคําว่ า "Java" ขึน้ บนจอภาพ 100 ครัง้ (5 คะแนน)
2) แสดงเลขค่ ู 10 ตัวแรกออกทางจอภาพ โดยเริ่มต้ นที่ตวั เลข 2 (5 คะแนน)
3. คําสั่งวนซํา้ ด้ วยคําสั่ง while (true) มีรูปแบบดังต่อไปนี ้

1 while(true) {
2 Statement(s);
คําสัง่ while(true) มีเงื่อนไข (Condition) เป็ นจริง
3 if(Condition) break; ตลอดกาล ดังนันจะวนซํ
้ ้าแบบไม่ร้ ูจบ
4 }
การออกจากคําสัง่ while(true) ทําได้ เพียงวิธีเดียวเท่านัน้ คือ

ผังงาน
ใช้ คําสัง่ if(…) break; โดยเมื่อเงื่อนไขของคําสัง่ if เป็ นจริง
ก็จะสิ ้นสุดการวนซํ ้า
True
เข้ าทําคําสัง่ ทุกๆ คําสัง่ ภายในคําสัง่ while ทันทีเพราะว่าเงื่อนไข
Statement เป็ นจริงตลอดกาล และจะวนทํางานแบบนี ้ไปเรื่ อยๆ จนกว่าเงื่อนไข
True False
ของคําสัง่ if ซึง่ อยูภ่ ายในคําสัง่ while เป็ นจริง ก็จะ break
Condition การทํางาน และสิ ้นสุดการวนซํ ้า
ตัวอย่ าง วนรับค่าตัวเลขจํานวนเต็ม 1 จํานวนทางแป้ นพิมพ์ แล้ วตรวจสอบ

1 Scanner kb = new ...; ว่าตัวเลขที่รับเข้ ามานันเท่
้ ากับ 0 หรื อไม่ ถ้ าใช่ก็จะสิ ้นสุดการวนซํ ้า
2 while(true) {
3 int x = kb.nextInt(); แต่ถ้าไม่เช่นนันก็
้ จะวนรับค่าตัวเลขจํานวนเต็มจากแป้นพิมพ์ไป
4 if(x == 0) break;
5 } เรื่ อยๆ
โจทย์ ข้อที่ 3 [ระดับง่ าย] จงเขียนเฉพาะคําสั่ง while(true) ตามเงื่อนไขต่ อไปนี ้ (10 คะแนน)
1) แสดงคําว่ า “เกรียน” ขึน้ บนจอภาพ 1000 ครัง้ (5 คะแนน)
2) สุ่มตัวเลขตัง้ แต่ 0-10 แล้ วแสดงผลขึน้ บนจอภาพไปเรื่อยๆ จะจบเมื่อสุ่มได้ เลข 5 (5 คะแนน)

ู เพื่อรั บค่ าตัวเลขจํานวนเต็มหนึ่งจํานวน
เข้ ามาทางแป้นพิมพ์ แล้ วทําการแสดงค่ าตัวเลขจํานวนเต็มตัง้ แต่ 0 จนถึงตัวเลขที่รับเข้ ามานัน้ ออกทาง
จอภาพทีละบรรทัดให้ สวยงาม (10 คะแนน)
1 2 3 4
โจทย์ ข้อที่ 5 [ระดับง่ าย] จงเขียนโปรแกรมภาษาจาวาที่สมบรณ์ู เพื่อรั บค่ าตัวเลขจํานวนเต็มหนึ่งจํานวน

เข้ ามาทางแป้นพิมพ์ แล้ ววนรอบแสดงเครื่ องหมายดอกจัน "*" ให้ มีจํานวนเท่ ากับค่ าของตัวเลขที่
รั บเข้ ามานัน้ และแสดงผลลัพธ์ ส่วนอื่นๆ ให้ เหมือนกับตัวอย่ างต่ อไปนี ้ (10 คะแนน)
1 2 3 4 Enter number: -1
-1
Enter number: 4
4 ****
Enter number: 6
6 ******
โจทย์ ข้อที่ 6 [ระดับปานกลาง] จงเขียนโปรแกรมภาษาจาวาที่สมบรณ์ู เพื่อรั บตัวเลขจํานวนเต็มหนึ่งจํา

นวนเข้ ามาเก็บไว้ ในตัวแปร n และหาผลบวกของตัวเลขตัง้ แต่ 1 จนถึง n เก็บไว้ ในตัวแปร sum พร้ อมทัง้
แสดงค่ าของตัวแปร sum ที่เป็ นผลคําตอบสุดท้ ายออกทางจอภาพ (10 คะแนน)
1 2 3 4
โจทย์ ข้อที่ 7 [ระดับปานกลาง] จงเขียนโปรแกรมภาษาจาวาที่สมบรณ์ ู เพื่อรั บตัวเลขจํานวนเต็มหนึ่งจํา
นวนเข้ ามาเก็บไว้ ในตัวแปร n และหาค่ าแฟคทอเรี ยล (Factorial) ของจํานวนนัน้ (ผลคณของตั ู วเลข 1
จนถึง n) เช่ น 4! = 1 x 2 x 3 x 4 = 24 เป็ นต้ น พร้ อมทัง้ แสดงผลลัพธ์ ออกทางจอภาพ (10 คะแนน)
1 2 3 4
โจทย์ ข้อที่ 8 [ระดับปานกลาง] จงเขียนโปรแกรมภาษาจาวาที่สมบรณ์ ู เพื่อรั บตัวเลขจํานวนเต็มสองจํา

นวนเข้ ามาเก็บไว้ ในตัวแปร a และ b ตามลําดับ และคํานวณหาค่ าเลขยกกําลังของ ab โดย a เป็ นเลข
ฐานและ b เป็ นเลขชีก้ าํ ลัง พร้ อมทัง้ แสดงผลลัพธ์ ออกทางจอภาพให้ สวยงาม (10 คะแนน)
1 2 3 4
ให้ b มีค่าตัง้ แต่ 0 ขึน้ ไป และ
ห้ ามใช้ เมท็อดในคลาส Math
ในการคํานวณ
โจทย์ ข้อที่ 9 [ระดับปานกลาง] จงเขียนโปรแกรมภาษาจาวาที่สมบรณ์ ู เพื่อรั บตัวเลขจํานวนเต็มสองจํา

นวนเข้ ามาเก็บไว้ ในตัวแปร a และ b ตามลําดับ และหาผลคณของตั
ู วเลขสองจํานวนนัน้ โดยใช้ หลักการ
ู ) เช่ น a x b มีความหมายเท่ ากับ a บวกกัน b ตัว พร้ อมทัง้ แสดงผลลัพธ์
บวก (ห้ ามใช้ เครื่ องหมายคณ
ออกทางจอภาพ (10 คะแนน)
1 2 3 4
โจทย์ ข้อที่ 10 [ระดับปานกลาง] จงเขียนโปรแกรมภาษาจาวาที่สมบรณ์ ู เพื่อรั บตัวเลขจํานวนเต็มหนึ่งจํา

นวนเข้ ามาเก็บไว้ ในตัวแปร n และคํานวณหาผลบวกของตัวเลขคี่ตงั ้ แต่ 1 ถึง n ที่หาร 3 ลงตัว พร้ อมทัง้
แสดงผลลัพธ์ ออกทางจอภาพ (10 คะแนน)
1 2 3 4 5
โจทย์ ข้อที่ 11 [ระดับยาก] จงเขียนโปรแกรมภาษาจาวาที่สมบรณ์ ู เพื่อรั บตัวเลขจํานวนเต็มบวกหนึ่งจํา-
นวนเข้ ามาทางแป้นพิมพ์ แล้ วแสดงผลลัพธ์ ท่ ีได้ เป็ นเลขฐานสองที่มีค่าเท่ ากับจํานวนนั น้ ดังตัวอย่ าง
ต่ อไปนี ้ (10 คะแนน) Decimal Number: 14
Binary Number: 1110
1 2 3 4 5
Decimal Number: 345
Binary Number: 101011001
2. คําสั่งวนซํา้ แบบเบือ้ งต้ นด้ วยคําสั่ง for

1. คําสั่งวนซํา้ ด้ วยคําสั่ง for มี 3 ส่วนหลักเช่นเดียวกับคําสัง่ while ดังรูปแบบต่อไปนี ้
1 for(Initial;Condition;Update) {
2 Statement(s); [1] ค่าตังต้
้ น (Initial) [2] เงื่อนไข (Condition)
3 } และ [3] การเปลี่ยนรอบ (Update) ทัง้ 3 ส่วนนี ้
จะอยูภ่ ายในส่วนหัวของคําสัง่ for ทังหมด
้
ผังงาน
ภายในคําสัง่ for ถ้ ามีเพียง 1 คําสัง่ ไม่ต้องมี

Initial
เครื่ องหมายปี กกาเปิ ดปิ ดก็ได้
พิจารณาเงื่อนไขของคําสัง่ for ว่าเป็ นจริง

False
Update
Condition หรื อไม่ ถ้ าเป็ นจริงจะเข้ าทําคําสัง่ ทุกๆ คําสัง่
True ภายในคําสัง่ for และจะวนทํางานแบบนี ้ไป
Statement
เรื่ อยๆ จนกว่าเงื่อนไขของคําสัง่ for จะเป็ นเท็จ
ก็จะจบการวนซํ ้า
ตัวอย่ าง กําหนดค่าเริ่ มต้ นให้ ตวั แปร i เท่ากับ 1 แล้ วทําการวนซํ ้า

1
2
for(int i = 1; i <= 5; i++) {
System.out.print(i);
เพื่อแสดงค่า i ตังแต่
้ 1 ถึง 5 โดยในแต่ละรอบการวนซํ ้า
3 } จะเพิ่มค่า i ขึ ้นทีละ 1 ดังนันผลลั
้ พธ์ที่ได้ คือ 12345
1 double c = 3.0; n = 3 n = 0 n = 1 n = 4
2 for(c = 1.0; c <= n; c += 0.1)
3 System.out.println(c++);
4 c++;
5 for(int i = 6; i > n; i--) {
6 System.out.print(i);
7 System.out.print(n++);
8 }
โจทย์ ข้อที่ 13 [ระดับง่ าย] จงเขียนเฉพาะคําสั่ง for ตามเงื่อนไขต่ อไปนี ้ (10 คะแนน)
1) แสดงคําว่ า "Get A" ขึน้ บนจอภาพ 1000 ครัง้ (5 คะแนน)
2) แสดงเลขค่ ู 900 ตัวแรกออกทางจอภาพ (เริ่มที่ 78) (5 คะแนน)
2. เปรี ยบเทียบคําสั่ง while และคําสั่ง for

1) คําสัง่ while และคําสัง่ for มีลกั ษณะการทํางานที่วนซํ ้าเหมือนกัน แต่มีรูปแบบขการเขียนที่แตกต่างกัน
2) คําสัง่ while ใช้ วนซํ ้าเมื่อไม่ทราบจํานวนรอบที่แน่ชดั แต่คําสัง่ for ใช้ วนซํ ้าเมื่อทราบจํานวนรอบที่แน่ชดั
3) การแปลงคําสัง่ while ให้ เป็ นคําสัง่ for
1
1 int i = 1; 1 for(int i = 1; i <= 5; i++) {

2 while(i <= 5) { 2 ...
3 ... 3 }
2
4 i++;
5 }
3
โจทย์ ข้อที่ 14 [ระดับง่ าย] จงเขียนส่ วนของโปรแกรมภาษาจาวาเพื่อเปลี่ยนคําสั่ง while ในโจทย์ ข้อที่ 6
ถึง 9 ให้ เป็ นคําสั่ง for โดยไม่ ต้องเขียนโปรแกรมในส่ วนของการรั บค่ าและแสดงผล และสามารถเรี ยก
ใช้ ตวั แปรเดิมของการรั บค่ าได้ เลย แต่ ตวั แปรอื่นๆ จะต้ องประกาศใหม่ ทงั ้ หมด (20 คะแนน)
1) แปลงเฉพาะคําสั่ง while ในโจทย์ ข้อที่ 6 ให้ เป็ นคําสั่ง for (5 คะแนน)
โจทย์ ข้อที่ 15 [ระดับง่ าย - ระดับยาก] จงเขียนเฉพาะคําสั่ง for เพื่อหาคําตอบของสมการต่ อไปนี ้ พร้ อม

ทัง้ ประกาศตัวแปรทุกตัวที่เรียกใช้ งาน และห้ ามเรียกใช้ เมท็อดในคลาส Math (30 คะแนน)
1) [ระดับง่ าย] 5 + 10 + 15 + ... + 40 (5 คะแนน)
2) [ระดับง่ าย] 1 + 8 + 27 + ... + 20 3 (5 คะแนน)
3) [ระดับปานกลาง] 1 + 3 + 7 + 15 + 31 + ... + (215 − 1) (5 คะแนน)
1 1 1 1 1
4) [ระดับปานกลาง] 1 + − + − + ... + (5 คะแนน)
2 3 4 5 30
23 25 27 29 211 219
5) [ระดับยาก] 2 − + − + − + ... − (10 คะแนน)
3! 5! 7! 9! 11! 19!
โจทย์ ข้อที่ 16 [ระดับปานกลาง] จงเขียนโปรแกรมภาษาจาวาที่สมบรณ์ ู เพื่อรั บตัวเลขจํานวนเต็ม 100 จํา-

นวนทางแป้นพิมพ์ แล้ วทําการหาค่ าสงสุ ู ด (Maximum) ค่ าตํ่าสุด (Minimum) และค่ าเฉลี่ย (Average) ของ
ตัวเลขทัง้ หมด พร้ อมทัง้ แสดงผลลัพธ์ ท่ ไี ด้ ออกทางจอภาพ (10 คะแนน)
1 2 3 4 5
โจทย์ ข้อที่ 17 [ระดับยาก] จงเขียนโปรแกรมภาษาจาวาที่สมบรณ์ ู เพื่อรั บตัวเลขจํานวนเต็มเข้ ามาทาง

แป้นพิมพ์ หนึ่งจํานวน แล้ วแสดงผลลัพธ์ ตามรปทรง
ู ต่ อไปนี ้ (10 คะแนน) Number: 5
1 2 3 4 5 *
**
***
****
*****
Number: 10
*
**
***
****
*****
******
*******
********
*********
**********
โจทย์ ข้อที่ 18 [ระดับยาก] จงเขียนโปรแกรมภาษาจาวาที่สมบรณ์ ู เพื่อรั บตัวเลขจํานวนเต็มหนึ่งจํานวน

ทางแป้นพิมพ์ และทําการตรวจสอบว่ าตัวเลขดังกล่ าวเป็ นจํานวนเฉพาะหรือไม่ พร้ อมทัง้ แสดงผลลัพธ์ ท่ ี
ได้ ดงั ตัวอย่ าง ซึ่งจํานวนเฉพาะ คือ จํานวนที่ค่า 1 และตัวมันเองเท่ านัน้ ที่หารลงตัว (15 คะแนน)
1 2 3 4 5
Number: 17
17 is a prime number
Number: 45
45 is not a prime number
One Dimensional Arrays - 07 Computer Programming using Java 77
CHAPTER อาเรย์หนึ่งมิติ
07 (One Dimensional Arrays)
1. ความร้ ูเบือ้ งต้ นเกี่ยวกับอาเรย์ (Introduction to Arrays)
1. นิยามของอาเรย์
1) อาเรย์ (Arrays) คือ โครงสร้ างข้ อมูลประเภทหนึ่งที่ใช้ เก็บรายการของข้ อมูลประเภทเดียวกัน โดยเก็บ
ข้ อมูลทังหมดเรี
้ ยงต่อกันไปในหน่วยความจํา เสมือนนําข้ อมูลเก็บไว้ ใน "ช่ อง" ที่วางเรี ยงกัน เช่น
6 1 7 9
'C' ไม่สนใจว่าช่องของอาเรย์จะวางเรี ยงกันในแนวตังหรื
้ อแนวนอน ซึง่
'U' จะเรี ยกว่าอาเรย์ทงหมด
ั้ โดยแต่ละช่องจะเก็บข้ อมูลได้ เพียง 1 ค่า
2) ตําแหน่ งของอาเรย์ อาเรย์แต่ละชุดจะมีชื่อของอาเรย์และหมายเลขช่องที่ระบุตําแหน่ง (Index) ของข้ อ-

มูลในอาเรย์แต่ละตัว ซึง่ จะเริ่มต้ นที่ตําแหน่งที่ 0 (Zero Index) เสมอ (เหมือนกับสตริ ง)
0 1 2 3
6 1 7 9 ตําแหน่ง (Index) เริ่มที่ 0 แต่ลําดับ (Order) เริ่มที่ 1
3) ขนาดหรือความยาวของอาเรย์ คือ จํานวนสมาชิกหรื อจํานวนข้ อมูลที่เก็บอยูใ่ นอาเรย์ชดุ นัน้

0 1 2 3
6 1 7 9 อาเรย์ยาว 4 (มีสมาชิก 4 ตัว)
4) มิตขิ องอาเรย์ สามารถมีได้ ไม่จํากัด เช่นอาเรย์หนึ่งมิติ สองมิติ สามมิติ หรื อ n มิติ แต่โดยทัว่ ไปแล้ วเรา
นิยมใช้ อาเรย์หนึง่ มิตแิ ละอาเรย์สองมิติ ซึง่ ในบทนี ้จะนําเสนออาเรย์หนึง่ มิติ
6 1 2 1
หนึง่ มิติ 7 0 สามมิติ

9 4
สองมิติ 5 3
2. การประกาศและสร้ างอาเรย์ หนึ่งมิติ

1. การประกาศและสร้ างอาเรย์ หนึ่งมิตโิ ดยใช้ Initialized List
การประกาศและสร้ างอาเรย์หนึ่งมิติโดยใช้ Initialized List เป็ นการสร้ างอาเรย์แบบง่าย ซึง่ จะประกาศใช้ ได้ ก็
ต่อเมื่อทราบค่าทุกค่าที่จะเก็บลงไปในอาเรย์แล้ ว โดยมีรูปแบบคําสัง่ ดังนี ้ หลังชื่ออาเรย์ต้องมีสญ
ั ลักษณ์ []
<ประเภทข้ อมูล> <ชื่ออาเรย์>[] = { สมาชิก ,..., สมาชิก }; สมาชิกแต่ละตัวคัน่ ด้ วย Comma
เช่น int a[] = {34, 56, 52, 12, 90, 0, 75, 23, 45, 8}; ซึง่ จะได้ เป็ นโครงสร้ างดังนี ้
0 1 2 3 4 5 6 7 8 9
34 56 52 12 90 0 75 23 45 8 มีสมาชิก 10 ตัว แต่ตําแหน่งสูงสุดคือ 9
78 Computer Programming using Java 07 - One Dimensional Arrays
ค่าสมาชิกแต่ละตัวของอาเรย์สามารถอ้ างอิงหรื อเรี ยกชื่อได้ โดยใช้ คําสัง่ <ชื่ออาเรย์ >[<ตําแหน่ ง>] เช่น
0 1 2 3 4 5 6 7 8 9
a[0] a[1] a[2] a[3] a[4] a[5] a[6] a[7] a[8] a[9]
โจทย์ ข้อที่ 1 [ระดับง่ าย] จงหาผลลัพธ์ จากส่ วนของโปรแกรมต่ อไปนี ้ โดยกําหนดให้ โปรแกรมสามารถ
ทํางานจนจบได้ แม้ มี Error พร้ อมทัง้ แสดงผลลัพธ์ สุดท้ ายของสมาชิกในอาเรย์ แต่ ละช่ อง (8 คะแนน)
1 int i = 3;
2 int a[] = { 0, 2, 4, 6, 8, 1, 3, 5, 7, 9 };
3 System.out.println(a[0] + a[6]);
4 System.out.println(a[1] * --a[4]);
5 System.out.println(a[9]++);
6 System.out.println(a[10] + a[4]);
7 System.out.println(a[1]++ + a[0]);
8 System.out.println(a[5 + 3]);
9 System.out.println(--a[2*i] + a[1]++);
10 System.out.println(a[1] + a[4] + a[9]);
0 1 2 3 4 5 6 7 8 9
ค่าของสมาชิกแต่ละช่องคือ
2. การประกาศและสร้ างอาเรย์ หนึ่งมิตโิ ดยการ new

การประกาศและการสร้ างอาเรย์โดยการ new นี ้จะเป็ นวิธีแบบทัว่ ไปที่ใช้ ในการเขียนโปรแกรมภาษาจาวา ซึง่ มี
ขันตอนดั
้ งต่อไปนี ้
1) การประกาศตัวแปรอาเรย์หนึง่ มิติ
<ประเภทข้ อมูล> <ชื่ออาเรย์>[]; หลังชื่ออาเรย์ต้องมีเครื่ องหมาย []
เช่น
a
int a[];
2) การสร้ างอาเรย์หนึง่ มิติ หลังชื่ออาเรย์ไม่ต้องมีเครื่ องหมาย []

<ชื่ออาเรย์> = new <ประเภทข้ อมูล>[<ขนาด>]; ระบุขนาดหรื อจํานวนช่องของอาเรย์
(ไม่ใช่ตําแหน่ง)
เช่น a = new int[3];
a 0 1 2
0 0 0
3) อาเรย์หนึง่ มิตทิ ี่ได้ หลังจากการประกาศและการสร้ าง มีคา่ เริ่มต้ นของทุกช่องเป็ น 0 (ประเภท int)
a[0] a[1] a[2]
4) การประกาศและการสร้ างอาเรย์หนึง่ มิตโิ ดยรวมขันตอนที

้ ่ 1 และ 2 เข้ าด้ วยกัน (มี 2 วิธีให้ เลือกใช้ )
<ประเภทข้ อมูล> <ชื่ออาเรย์>[] = new <ประเภทข้ อมูล>[<ขนาด>]; เครื่ องหมาย []
จะอยูห่ น้ าหรื อหลัง
<ประเภทข้ อมูล> []<ชื่ออาเรย์> = new <ประเภทข้ อมูล>[<ขนาด>]; ชื่ออาเรย์ก็ได้
เช่น int a[] = new int[3];
5) ข้ อสังเกตในการประกาศและสร้ างอาเรย์หนึง่ มิติ
ขนาดของอาเรย์ถก ู ระบุตอนสร้ างอาเรย์ ถ้ าต้ องการให้ อาเรย์มีกี่ช่องก็ให้ ระบุจํานวนช่องลงไป ซึง่ ส่วนนี ้
ไม่ใช่ตําแหน่งของอาเรย์ (อย่าสับสน) Æ ลําดับของอาเรย์เริ่มนับที่ 1 แต่ตําแหน่งของอาเรย์เริ่มนับที่ 0
ขนาดของอาเรย์เป็ นค่าของนิพจน์ได้ เช่น int data[] = new int[3 * n + 1]; เป็ นต้ น
อาเรย์ที่สร้ างขึ ้น ไม่สามารถเพิ่มหรื อลดขนาดได้ (สร้ างแล้ วต้ องใช้ อย่างเดิมตลอดไป)
ระบบจะตังค่ ้ าเริ่ มต้ นของข้ อมูลให้ กบั อาเรย์ทกุ ช่องโดยอัตโนมัตเิ มื่อเริ่มสร้ างอาเรย์ตามชนิดของอาเรย์
เช่น double a[] = new double[5]; จะได้ อาเรย์ 5 ช่องโดยมีคา่ เริ่มต้ นของทุกช่องเป็ น 0.0
3. การหาขนาดและความยาวของอาเรย์ หนึ่งมิติ
การหาขนาดของอาเรย์จะใช้ คําสัง่ .length โดยระบุเข้ าไปหลังชื่ออาเรย์โดยไม่ต้องใส่วงเล็บ ดังรูปแบบต่อไปนี ้
<ชื่ออาเรย์>.length
อย่าจําสับสนกับเมท็อดที่ใช้ หาความยาวของสตริงซึง่ ใช้ .length() เช่นเดียวกัน ดังตัวอย่าง

1 int a[] = new int[5]; หลัง length ไม่ใส่วงเล็บ
2 System.out.println(a.length);
3 String s = "JAVA!";
4 System.out.println(s.length()); หลัง length ใส่วงเล็บ
5 int b[] = new int[12];
6 System.out.println(b.length()); Error
โจทย์ ข้อที่ 2 [ระดับง่ าย] จงเขียนคําสั่งภาษาจาวาเพื่อประกาศและสร้ างอาเรย์ ต่อไปนี ้ (12 คะแนน)

1) สร้ างอาเรย์ ช่ อื num เก็บข้ อมลตั
ู วเลขจํานวนเต็มที่ยาว 15 หลักขึน้ ไป จํานวน 200 ค่ า (2 คะแนน)
2) สร้ างอาเรย์ ช่ อื dice เก็บหมายเลขหน้ าของลกเต๋

ู า (2 คะแนน)
3) สร้ างอาเรย์ ช่ อื avgGrade เก็บผลการเรี ยนเฉลี่ยของนิสิตจํานวน 451 คน (2 คะแนน)
4) สร้ างอาเรย์ ช่ อื grade เก็บผลการเรี ยนรายวิชา 2110101 ของนิสิตจํานวน 369 คน (2 คะแนน)
5) สร้ างอาเรย์ ช่ อื x เก็บค่ าความจริง ซึ่งมีตาํ แหน่ งสงสุ

ู ดของช่ องสมาชิกคือตําแหน่ งที่ 10 (2 คะแนน)
6) สร้ างอาเรย์ ช่ อื merge เก็บข้ อมลที

ู ่ได้ จากการนําอาเรย์ ในข้ อที่ 1 มาต่ อกับอาเรย์ ในข้ อที่ 2 (2 คะแนน)
4. การอ้ างอิงค่ า การกําหนดค่ า และการแสดงผลของอาเรย์ หนึ่งมิติ

1) การอ้ างอิงค่ าจากอาเรย์ มีรูปแบบคําสัง่ ดังนี ้
<ประเภทข้ อมูล> <ชื่อตัวแปร> = <ชื่ออาเรย์>[<ตําแหน่ง>];
เช่น int n = num[0]; (ให้ ตว

ั แปร n ประเภทจํานวนเต็ม เก็บค่าจากอาเรย์ num ตําแหน่งที่ 0)
2) การกําหนดค่ าลงไปในอาเรย์ มีรูปแบบคําสัง่ ดังนี ้
<ชื่ออาเรย์>[<ตําแหน่ง>] = <ค่าข้ อมูล>;
เช่น num[0] = 13; (ให้ อาเรย์ num ตําแหน่งที่ 0 มีคา

่ เท่ากับ 13)
3) การแสดงผลของอาเรย์ จะใช้ คําสัง่ for ในการเข้ าไปยังสมาชิกแต่ละตัวในอาเรย์ตงแต่ ั ้ ตวั แรก (ตําแหน่งที่
0) จนถึงตัวสุดท้ าย (ตําแหน่งที่ length - 1) ดังตัวอย่างต่อไปนี ้ ต้ องเขียน a.length ไม่ควรเขียนเป็ นตัว
1 int a[] = new int[5]; เลข และต้ องเป็ นเครื่ องหมาย < ไม่ใช่ <=
2 for(int i = 0; i < a.length; i++) {
3 a[i] = 100;
4 } i ต้ องเริ่ มที่ 0 ไม่ใช่ 1 (วนตําแหน่งของอาเรย์ ไม่ใช่วนลําดับ)
โจทย์ ข้อที่ 3 [ระดับง่ าย] จงเขียนคําสั่งภาษาจาวาเพื่ออ้ างอิงและกําหนดค่ าจากอาเรย์ ต่อไปนี ้ โดยสมมุตใิ ห้

อาเรย์ ในทุกข้ อมีการประกาศและสร้ างเรียบร้ อยแล้ วพร้ อมทัง้ มีค่าข้ อมลครบทุ
ู กช่ อง (12 คะแนน)
1) ประกาศตัวแปร x เพื่อเก็บข้ อมลูประเภทจํานวนเต็มที่ได้ จากอาเรย์ num ตัวที่ 50 (2 คะแนน)
2) ประกาศตัวแปร y เพื่อเก็บข้ อมลูประเภทจํานวนเต็มที่ได้ จากอาเรย์ num ตําแหน่ งที่ 50 (2 คะแนน)
3) ประกาศตัวแปร c เพื่อเก็บข้ อมลูประเภทอักขระที่ได้ จากอาเรย์ code ตําแหน่ งสุดท้ าย (2 คะแนน)
4) ให้ ค่าสมาชิกตําแหน่ งที่ 12 ของอาเรย์ bank เก็บข้ อมลูประเภทตรรกะจากตัวแปร var1 (2 คะแนน)

boolean var1 = 5 > 6;
5) ให้ ค่าสมาชิกตัวที่ 1 ของอาเรย์ bank เก็บข้ อมลูประเภทจํานวนจริงจากตัวแปร var2 (2 คะแนน)

double var2 = kb.nextDouble();
6) ให้ ค่าสมาชิกตัวรองสุดท้ ายของอาเรย์ bank เก็บข้ อมลูประเภทอักขระจากตัวแปร var3 (2 คะแนน)

char var3 = "java".charAt(3);
โจทย์ ข้อที่ 4 [ระดับง่ าย–ปานกลาง] จงเขียนส่ วนของโปรแกรมภาษาจาวาตามคําสั่งต่ อไปนี ้ (55 คะแนน)
1) สร้ างอาเรย์ ช่ ือ n แบบ Initialed List เพื่อเก็บเลขคี่ท่ อี ย่ ูในช่ วง 1 ถึง 20 พร้ อมทัง้ แสดงค่ าของตัวเลข
ทุกตัวในอาเรย์ n ขึน้ บนจอภาพทีละบรรทัด (5 คะแนน)
2) สร้ างอาเรย์ ช่ ือ m ขนาด 1000 ช่ อง พร้ อมทัง้ กําหนดค่ าให้ กับสมาชิกทุกตัวในอาเรย์ m ให้ มีค่าเป็ น
ตัวเลขตัง้ แต่ 1-1000 เรียงลําดับจากสมาชิกตัวแรกจนถึงสมาชิกตัวสุดท้ ายของอาเรย์ m (5 คะแนน)
3) สร้ างอาเรย์ ช่ ือ a เพื่อเก็บตัวเลขจํานวนจริงใดๆ ที่รับมาจากแป้นพิมพ์ จาํ นวน 100 ตัว (5 คะแนน)

4) นับจํานวนเลขคี่และค่ ทู ่ เี ก็บอย่ ูในอาเรย์ x ว่ ามีอย่ างละกี่จาํ นวนแล้ วแสดงผลขึน้ บนจอภาพ (10 คะแนน)
int x[] = { 7, 9, -1, 4, 12, 9, 3, 2, -7, 2, 1, 9, -15, 24, 11, 13 };
5) รับตัวเลขจํานวนเต็มจากแป้นพิมพ์ เก็บไว้ ในตัวแปร x แล้ วค้ นหาว่ า ค่ าสมาชิกตําแหน่ งแรกในอาเรย์

num ที่มีค่าเท่ า x คือตําแหน่ งใด พร้ อมทัง้ แสดงผลลัพธ์ ขน
ึ ้ บนจอภาพ (10 คะแนน)
int num[] = { 3, 2, 1, 10, 2, 8, 3, 2, 1, 1, 8, 5, 10, 11, 7, 6, 10 };
ถ้ าค้ นหาไม่ เจอให้ แสดงผลลัพธ์ เป็ นค่ า -1
โจทย์ ข้อที่ 5 [ระดับปานกลาง] จงเขียนโปรแกรมภาษาจาวาให้ สมบรณ์ ู เพื่อทําการผสาน (Merge) ข้ อมลู

ในอาเรย์ a และอาเรย์ b ซึ่งเป็ นจํานวนเต็มเข้ าเป็ นอาเรย์ เดียวกันในอาเรย์ ช่ ือ ab พร้ อมทัง้ แสดงค่ า
สมาชิกของอาเรย์ ab (10 คะแนน)
import java.util.Scanner;
public class MergeArrays {
int a[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
int b[] = { 1, 4, 6, 8, 10, 12 };
} //End of main
} //End of class
โจทย์ ข้อที่ 6 [ระดับยาก] จงเขียนโปรแกรมภาษาจาวาให้ สมบรณ์ ู เพื่อรับตัวเลขจํานวนเต็มจากแป้นพิมพ์

เก็บไว้ ในตัวแปร x แล้ วทําการแบ่ ง (Split) ค่ าสมาชิกในอาเรย์ num ออกเป็ นอาเรย์ ใหม่ โดยถ้ าค่ าสมาชิก
มีค่ามากกว่ าหรือเท่ ากับ x ให้ เก็บไว้ ในอาเรย์ upper ไม่ เช่ นนัน้ ให้ เก็บไว้ ในอาเรย์ lower (10 คะแนน)
public class SplitArray {
int num[] = {95, 1, 6, 34, 5, 9, 123, -2, 57, 82, 12, 79, 45, 34, 1};
} //End of main
} //End of class
โจทย์ ข้อที่ 7 [ระดับยาก] จงเขียนโปรแกรมภาษาจาวาให้ สมบรณ์ ู เพื่อทําการกลับค่ าสมาชิกในอาเรย์

(Reverse Array) ที่ช่ ือ num จากหลังมาหน้ า แล้ วเก็บค่ าไว้ ในอาเรย์ ตวั เดิม โดยในการเขียนโปรแกรมห้ าม
ประกาศอาเรย์ ตวั ใหม่ เพิ่มโดยเด็ดขาด (10 คะแนน)
public class ReverseArray {
int num[] = {95, 1, 6, 34, 5, 9, 123, -2, 57, 82, 12, 79, 45, 34, 1};
} //End of main
} //End of class
โจทย์ ข้อที่ 8 [ระดับยาก] จงเขียนโปรแกรมภาษาจาวาให้ สมบรณ์ ู เพื่อตรวจสอบและแสดงข้ อความว่ า

อาเรย์ a และอาเรย์ b เท่ ากันหรื อไม่ โดยการเท่ ากันของอาเรย์ คือ ความยาวของอาเรย์ ต้องเท่ ากัน และ
สมาชิกทุกตัวตําแหน่ งต่ อตําแหน่ งต้ องเท่ ากัน (10 คะแนน)
public class EqualityOfArrays {
int a[] = { 1, 2, 3, 4, 5, 6, 7 }, b[] = { 1, 2, 3, 5, 5, 7, 7 };
} //End of main
} //End of class
โจทย์ ข้อที่ 9 [ระดับยาก] จงเขียนโปรแกรมภาษาจาวาให้ สมบรณ์ ู เพื่อทําการรั บค่ าตัวเลขจํานวนเต็มจาก

แป้นพิมพ์ เก็บไว้ ในตัวแปร key เพื่อค้ นหาว่ าค่ าของตัวแปร key ปรากฏเป็ นลําดับรองสุดท้ ายที่ตาํ แหน่ ง
ใดในอาเรย์ num โดยถ้ าค้ นเจอให้ แสดงตําแหน่ งนัน้ แต่ ถ้าไม่ เจอให้ แสดงค่ า -1 (10 คะแนน)
public class LastSecondSearch {
int num[] = { 3, 2, 1, 10, 2, 8, 3, 2, 1, 1, 8, 5, 10, 11, 7, 6, 10 };
} //End of main
} //End of class
3. การประยุกต์ ใช้ อาเรย์ (Applications of Array)
1. การเรียงลําดับแบบเลือก (Selection Sort) (ดูการสาธิตตัวอย่างการจัดเรี ยงในโจทย์ข้อที่ 10)
1 for (int i = data.length - 1; i >= 1; i--) { จํา
2 int maxIndex = 0;
3 for (int j = 0; j <= i; j++)
4 if (data[j] > data[maxIndex]) maxIndex = j; เรี ยงจากน้ อยไปหามาก
5 int temp = data[i];
6 data[i] = data[maxIndex]; เลือกค่าที่สนใจในแต่ละรอบ ซึง่ อาจจะเป็ นค่ามาก
7 data[maxIndex] = temp;
8 } ที่สดุ หรื อค่าน้ อยที่สดุ ในรอบนัน้ เพื่อจัดเรี ยง
คําสัง่ for i ชันนอก

้ เป็ นการกําหนดช่องหรื อเลือกช่องตําแหน่งที่ i ที่ต้องการจะเรี ยงลําดับ
คําสัง่ for j ชันใน
้ เป็ นการหาค่าสมาชิกที่สงู สุดตังแต่
้ ช่องแรกจนถึงช่องตําแหน่งที่ i ที่เลือกไว้ เพื่อจะได้
สลับค่าสูงสุดไปไว้ ในช่องตําแหน่งที่ i นัน้
2. การเรียงลําดับแบบฟอง (Bubble Sort) (ดูการสาธิตตัวอย่างการจัดเรี ยงในโจทย์ข้อที่ 10)

1 for (int i = data.length - 1; i >= 1; i--) { จํา
2 for (int j = 0; j < i; j++) {
3 if (data[j] > data[j + 1]) { เรี ยงจากน้ อยไปหามาก
4 int temp = data[j];
5 data[j] = data[j + 1];
6 data[j + 1] = temp; จับค่ ูและขยับค่าที่สนใจในแต่ละรอบ อาจจะเป็ นค่า
7 }
8 } มากหรื อค่าน้ อยของคูน่ นั ้ เพื่อจัดเรี ยง
9 }
คําสัง่ for i ชันนอก

้ เป็ นการกําหนดช่องตําแหน่งที่ i ที่ต้องการจะเรี ยงลําดับ
คําสัง่ for j ชันใน
้ เป็ นการเปรี ยบเทียบค่าเป็ นคูๆ่ เริ่ มตังแต่
้ ช่องแรกจนถึงช่องตําแหน่งที่ i ที่กําหนดไว้
เพื่อจะขยับค่าหรื อดันค่าสมาชิกที่สงู สุดไปไว้ ในช่องตําแหน่งที่ i นัน้ (เหมือนฟองสบูท่ ี่ลอยขึ ้นไปเรื่ อยๆ)
โจทย์ ข้อที่ 10 [ระดับง่ าย] จงแสดงรายละเอียดในแต่ ละรอบของการจัดเรี ยงแบบเลือก (Selection Sort)

และรายละเอียดของรอบที่ 1 และรอบที่ 2 ของการจัดเรี ยงแบบฟอง (Bubble Sort) จากชุดข้ อมลในอาู -
เรย์ x ต่ อนีใ้ ห้ ถกต้
ู อง โดยให้ จัดเรี ยงข้ อมลจาก
ู น้ อยไปมาก (20 คะแนน)
int x[] = {30, 45, 23, 2, 19, 14, 5, 99, 9};
30 45 23 2 19 14 5 99 9
การจัดเรียงแบบเลือก
รอบที่ 1
การจัดเรียงแบบฟอง
3. การสืบค้ นแบบทวิภาค (Binary Search)

เป็ นการค้ นข้ อมูลโดยการแบ่งครึ่งข้ อมูลในอาเรย์ แล้ วพิจารณาเพื่อตัดข้ อมูลออกไปครึ่งหนึง่ (ครึ่งซ้ ายหรื อครึ่ง
ขวาของอาเรย์) โดยข้ อมูลต้ องจัดเรี ยงก่อนเสมอ ซึง่ มีอลั กอริทมึ ในการสืบค้ นดังนี ้ (กําหนดให้ อาเรย์ชื่อ data)
1 int left = 0, right = data.length - 1, mid = 0;
2 while (left <= right) {
3 mid = (left + right) / 2; left คือ ตําแหน่งทางซ้ ายของชุดข้ อมูล
4 if (key == data[mid]) {
5 break; right คือ ตําแหน่งทางขวาของชุดข้ อมูล
6 } else if (key < data[mid]) { mid คือ ตําแหน่งตรงกลางของชุดข้ อมูล
7 right = mid - 1;
8 } else {
9 left = mid + 1; คําตอบจากการสืบค้ นคือค่าของ mid
10 }
11 }
โจทย์ ข้อที่ 11 [ระดับง่ าย] จงเขียนลําดับการทํางานและนับจํานวนรอบจากการสืบค้ นข้ อมลูแบบทวิภาค

ู ่ เก็บอย่ ูในอาเรย์ x ต่ อไปนี ้ เพื่อค้ นหาค่ าว่ า 14 อย่ ู ณ ตําแหน่ งใดในอาเรย์ ชุดนี ้ และให้
ของข้ อมลที
เปรี ยบเทียบคําตอบที่ได้ จากการสืบค้ นนี ้ กับการสืบค้ นแบบลําดับ (10 คะแนน)
int x[] = {30, 45, 23, 2, 19, 14, 5, 99, 9};
30 45 23 2 19 14 5 99 9
โจทย์ ข้อที่ 12 [ระดับยาก] จงเขียนโปรแกรมภาษาจาวาให้ สมบรณ์ ู เพื่ออ่ านแฟ้มข้ อมลวั

ู นเกิดที่ช่ ือ
birthdate.txt ซึ่งเก็บข้ อมล ู ในรปแบบ
ู dd-mm-yyyy เช่ น 13-06-1987 เป็ นต้ น โดยมีข้อมลวัู นเกิด
ของคนทัง้ หมด 200 คน จงทําการจัดเรี ยงเดือนที่มีคนเกิดมากที่สุดจนถึงเดือนที่มีคนเกิดน้ อยที่สุด แล้ ว
แสดงผลลัพธ์ ท่ เี ป็ นชื่อเดือนทัง้ 12 เดือนที่ถูกจัดเรียงแล้ วขึน้ บนจอภาพตามลําดับ (10 คะแนน)
birthdate.txt ตัวอย่ างการแสดงผลบนจอภาพ
13-02-2000 September [25 people]
01-10-1989 March [22 people]
31-01-1999 January [21 people]
21-12-1995 May [19 people]
17-07-1994 June [19 people]
... ...
import java.io.*;
public class SortMonthByBirthDate {
public static void main(String[] args) throws IOException {
} //End of main
} //End of class
โจทย์ ข้อที่ 13 [ระดับเทพ] จงเขียนโปรแกรมภาษาจาวาให้ สมบรณ์ ู เพื่อใช้ สําหรั บประมวลผลคะแนนราย
วิชา “How To Be Noob” โดยโปรแกรมจะเริ่มอ่ านเลขประจําตัวนิสิตจากแฟ้มข้ อมลู student.txt แล้ ว
ทําการสร้ างคะแนนของนิสิตแต่ ละคนขึน้ มาโดยการสุ่ม ซึ่งประกอบไปด้ วย 5 ส่ วนได้ แก่ คะแนนสอบ
ย่ อย (5%) คะแนนการบ้ าน (10%) คะแนนปฏิบัติการ (10%) คะแนนสอบกลางภาค (30%) และคะแนน
สอบปลายภาค (45%) แล้ วนํากลับไปบันทึกไว้ ในแฟ้มข้ อมลู student.txt อีกครั ง้ จากนั น้ ให้ อ่านค่ า
คะแนนทัง้ 5 ส่ วนของนิสิตแต่ ละคนจากแฟ้มข้ อมลเดิ ู มเพื่อนํามาคํานวณหาค่ าคะแนนรวม (100%)
พร้ อมทัง้ ตัดเกรดรายวิชานัน้ แล้ วนําผลลัพธ์ ท่ ีได้ ไปบันทึกไว้ ในแฟ้มข้ อมลู totalscore.txt พร้ อมทัง้
บันทึกข้ อมลสรุ
ู ปต่ างๆ ไว้ ท้ายแฟ้ มข้ อมลนั
ู น้ ด้ วย โดยให้ เ ขียนโปรแกรมตามขัน้ ตอนต่ างๆ ที่โจทย์
กําหนดไว้ ดงั รายละเอียดต่ อไปนี ้ (85 คะแนน)
student.txt ก่ อนการประมวลผล student.txt หลังการประมวลผล
5131000121 5131000121 3 7 3 20 26
5331000221 5331000221 4 6 9 24 40
5231000321 5231000321 0 1 8 25 27
5031000421 5031000421 0 3 10 15 0
4931000521 4931000521 2 0 7 28 25
4931000621 4931000621 4 6 7 3 19
5231000721 5231000721 2 10 3 27 45
... ...
totalscore.txt หลังการประมวลผล totalscore.txt ท้ ายแฟ้มข้ อมลู

5131000121 59 D ...
5331000221 83 A Max Score: 87
5231000321 61 C Max Score Freq: 1
5031000421 28 F Max Score Year: 2
4931000521 62 C Min Score: 14
4931000621 39 F Min Score Freq: 1
5231000721 87 A Min Score Year: 4
5031000821 63 C Avg Score: 49.72
5131000921 44 F Max Freq: 5
... List Max Freq Score: 33 60
import java.io.*;
public class ScoreCalculator {
public static void main(String[] args) throws IOException {
//สร้ างตัวอ่ านชื่อ in1 เพื่อเปิ ดอ่ านแฟ้มข้ อมลู student.txt สําหรับนับจํานวนนิสิตทัง้ หมดที่
ปรากฎในแฟ้มนัน้ แล้ วเก็บผลลัพธ์ ไว้ ในตัวแปร count (5 คะแนน)
//สร้ างตัวอ่ านชื่อ in2 เพื่อเปิ ดอ่ านแฟ้มข้ อมลู student.txt อีกครั ง้ และสร้ างอาเรย์ ช่ อื id แล้ ว
ทําการอ่ านค่ าเลขประจําตัวนิสิตแต่ ละคนเก็บไว้ ในอาเรย์ id ทีละช่ อง (5 คะแนน)
//สร้ างตัวเขียนชื่อ out1 เพื่อเขียนแฟ้มข้ อมลู student.txt โดยในแต่ ละบรรทัดจะประกอบไป

ด้ วยเลขประจําตัวนิสิต ตามด้ วยข้ อมลคะแนนทั
ู ง้ 5 ส่ วนของของนิสิตที่ได้ จากการสุ่มตัวเลขจํา-
นวนเต็มตามขอบเขตดังต่ อไปนี ้ คะแนนสอบย่ อย (สุ่มตัวเลข 0-5) คะแนนการบ้ าน (สุ่มตัวเลข 0-
10) คะแนนปฏิบัตกิ าร (สุ่มตัวเลข 0-10) คะแนนสอบกลางภาค (สุ่มตัวเลข 0-30) และคะแนนสอบ
ปลายภาค (สุ่มตัวเลข 0-45) (10 คะแนน)
//สร้ างตัวอ่ านชื่อ in3 เพื่อเปิ ดอ่ านแฟ้มข้ อมลู student.txt อีกครั ง้ และสร้ างอาเรย์ ช่ อื sc แล้ ว
ทําการคํานวณคะแนนรวมของนิสิตแต่ ละคนเก็บไว้ ในอาเรย์ sc ทีละช่ อง (10 คะแนน)
//สร้ างตัวเขียนชื่อ out2 เพื่อเขียนแฟ้มข้ อมลู totalscore.txt โดยในแต่ ละบรรทัดจะประกอบ
ไปด้ วยเลขประจําตัวนิสิต คะแนนรวม และเกรดของนิสิตแต่ ละคน โดยเกรดมี 5 ระดับได้ แก่ A
(ช่ วงคะแนน 80-100) B (ช่ วงคะแนน 70-79) C (ช่ วงคะแนน 60-69) D (ช่ วงคะแนน 50-59) และ
F (ช่ วงคะแนน 0-49) (10 คะแนน)
//หาคะแนนรวมของนิสิตที่ได้ คะแนนสงสุ ู ด (Max Score) และตํ่าสุด (Min Score)

//หาจํานวนนิสิตที่ได้ คะแนนสงสุ ู ด (Max Score Freq) และตํ่าสุด (Min Score Freq) มีอย่ างละกี่คน
ู ดและตํ่าสุดเป็ นนิสิตชัน้ ปี ใด (ถ้ ามีหลายชัน้ ปี ให้ แสดงชัน้ ปี ใดก็ได้ )
//หาว่ านิสิตผ้ ูท่ ไี ด้ คะแนนสงสุ
//หาค่ าเฉลี่ยของคะแนนรวมของนิสิตทัง้ หมด (Average Score)
//หาความถี่สูงสุด (Max Freq) ของคะแนน
//หาว่ ามีคะแนนใดบ้ างที่มีนิสิตได้ กันมากที่สุด (List Max Freq Score) (15 คะแนน)
//แสดงผลลัพธ์ ท่ ไี ด้ จากการประมวลผลทัง้ หมดจากขัน้ ตอนก่ อนหน้ านี ้ ต่ อท้ ายแฟ้มข้ อมลู

totalscore.txt (10 คะแนน)
//คําสั่งในการปิ ดแฟ้มข้ อมลู (5 คะแนน)
} //End of main
} //End of class
Methods - 08 Computer Programming using Java 93
CHAPTER เมท็อด
08 (Methods)
1. ความร้ ูเบือ้ งต้ นเกี่ยวกับเมท็อด (Introduction to Methods)
1. นิยามของเมท็อด
1) เมท็อด (Methods) คือ โปรแกรมย่อยที่ทําหน้ าที่เฉพาะ ซึง่ มีลกั ษณะเดียวกับ Subroutine, Sub-program
และ Function โดยเมท็อดช่วยลดความซํ ้าซ้ อนของโปรแกรมที่ทํางานซํ ้าๆ ได้
2) เมท็อดทุกเมท็อดจะปรากฏอยูใ่ นคลาส (Class) ซึง่ คลาสจะรวบรวมเมท็อดเอาไว้ เป็ นกลุม่ ก้ อน
3) รู ปแบบของโปรแกรมในช่วงก่อนหน้ านี ้เป็ นโปรแกรมแบบ 1 คลาส 1 เมท็อด แต่รูปแบบของโปรแกรม
ในช่วงต่อจากนี ้เป็ นต้ นไปจะเป็ นโปรแกรมแบบ 1 คลาส หลายเมท็อด หรื อ หลายคลาสหลายเมท็อด
(1) โปรแกรมแบบ 1 คลาส 1 เมท็อด จะรวมส่วนของโปรแกรมทุกส่วนไว้ ในเมท็อด main และมีการประ-
มวลผลแบบตามลําดับจากบนลงล่าง
(2) โปรแกรมแบบ 1 คลาส หลายเมท็อด จะแบ่งส่วนของโปรแกรมแต่ละส่วนออกเป็ นเมท็อดแต่ละเมท็อด
โดยมีเมท็อด main เป็ นศูนย์กลาง และมีการประมวลผลแบบแยกส่วนย่อยกระโดดไปมาตามการเรี ยก
ใช้ งานของเมท็อดต่างๆ (การประมวลผลขึ ้นกับคําสัง่ ในเมท็อด main ถ้ าไม่มี main จะไม่ประมวลผล)
1 คลาส 1 เมท็อด (เมท็อด main) 1 1 คลาส หลายเมท็อด
7
class Operation {
2
เรี ยก class Operation {
main(...) { main(...) { ใช้ งาน

1 ส่งค่า add()
sub() 6
เริ่มต้ น 3 ...
//add } รับ
4
รับ
ทํางานแบบ add(...) {
ทํางาน 5
ตามลําดับ //sub }
คืนค่า
จากบนลงล่าง ทํางานแบบ sub(...) {
2
} แยกส่วนย่อย }
สิ ้นสุด กระโดดไปมา
} //End of class } //End of class
4) ตัวอย่างของโปรแกรมแบบ 1 คลาส หลายเมท็อด

1 เรี ยก add(4, 10)
2 ส่งค่า 4 กับ 10
1 public class Example {
3 int n = add(4, 10); 3 รับ add(int x, int y)
4 System.out.println(n);
5 } 4 ทํางาน 4 + 10
6 public static int add(int x, int y) {
7 return x + y; 5 คืนค่า return 14
8 }
9 } 7 ใช้ งาน System.out.println(n) 6 รับ int n = 14
94 Computer Programming using Java 08 - Methods
โจทย์ ข้อที่ 1 [ระดับง่ าย] จากตัวอย่ างโปรแกรมต่ อไปนี ้ จงพิจารณาคํากล่ าวแต่ ละข้ อว่ ากล่ าวผิด (:)
หรือถูก (;) (20 คะแนน)
5
6
double a = kb.nextDouble(); ตังใจจะใส่
้ คา่ 5.0
int b = kb.nextInt();
7 double n = mul(a, b);
8 int m = mod(13); ตังใจจะใส่
้ คา่ 2
9 System.out.println(n + m);
10 }
11 private static double mul(double x, int y) {
12 double n = x * y;
13
14 }
return n;
บางเมท็อดอาจเขียนอยูใ่ นรูปแบบอื่นที่ไม่ใช่ public
15 protected static int mod(int x) { static ก็ได้ เช่น private static เป็ นต้ น ซึง่
16 return x % 3;
17 } จะได้ กล่าวรายละเอียดอีกครัง้ ในบทที่ 12
18 }
1) คลาส Test มีเมท็อดทังหมด ้ 3 เมท็อด

2) ถ้ าตัดเมท็อด main ออกจะทําให้ แปลผล (Compile) ไม่ผา่ น และสัง่ งาน (Run) ไม่ผา่ น
3) เมท็อด main สามารถเรี ยกใช้ เมท็อด mod ก่อนเรี ยกใช้ เมท็อด mul ได้
4) เมท็อด mod สามารถเรี ยกใช้ เมท็อด mul ได้
5) เมท็อด mod สามารถเรี ยกใช้ เมท็อด main ได้
6) เมท็อด mod สามารถเรี ยกใช้ เมท็อด mod ได้
7) ถ้ าต้ องการเรี ยกใช้ เมท็อด mul จะต้ องส่งค่า 2 ค่าที่เป็ นจํานวนจริงและจํานวนเต็มไปยังเมท็อด mul
8) ถ้ าต้ องการเรี ยกใช้ เมท็อด mod จะต้ องส่งค่า 1 ค่าที่เป็ นจํานวนจริงไปยังเมท็อด mod
9) ค่า n ในบรรทัดที่ 7 กับค่า n ในบรรทัดที่ 12 มีคา่ เท่ากันเพราะเป็ นตัวแปรตัวเดียวกัน
10) ค่า x ในบรรทัดที่ 15 กับค่า x ในบรรทัดที่ 16 มีคา่ เท่ากันเพราะเป็ นตัวแปรตัวเดียวกัน
11) ค่า x ในเมท็อด mod จะมีคา่ เท่ากับ 4 เมื่อเรี ยกใช้ งานคําสัง่ mod(4)
12) ผลลัพธ์ที่ได้ จากการประมวลผลในเมท็อด mul จะมีประเภทข้ อมูลเป็ น int
13) ผลลัพธ์ที่ได้ จากการประมวลผลในเมท็อด mod จะมีประเภทข้ อมูลเป็ น int
14) ผลลัพธ์ที่ได้ จากการประมวลผลบรรทัดที่ 7 และ 8 คือ 10.0 และ 1.0 ตามลําดับ
15) ผลลัพธ์ที่ได้ จากการประมวลผลคําสัง่ mul(2, 1) คือ 2.0
16) ผลลัพธ์ที่ได้ จากการประมวลผลคําสัง่ mod(8, 3) คือ 2.0
17) ผลลัพธ์ที่แสดงผลบนจอภาพที่ได้ จากการประมวลผลของคลาส Test คือ 11.0
18) คําสัง่ return ในบรรทัดที่ 13 และ 16 เป็ นคําสัง่ ที่ใช้ คนื ผลคําตอบที่ได้ จากการประมวลผลของเมท็อด
19) คําสัง่ ภายในเมท็อด mul ตังแต่้ บรรทัดที่ 12-13 สามารถเขียนใหม่ได้ เป็ น return x * y;
20) เมท็อด main ไม่มีคําสัง่ return เพราะว่าเมท็อด main เป็ นประเภท void
2. โครงสร้ างของเมท็อดและการเขียนเมท็อด (Method Structure and Creating Method)
1. โครงสร้ างโดยรวมของเมท็อด
สามารถแบ่งออกเป็ น 2 ส่วนหลักได้ แก่ หัวเมท็อดและตัวเมท็อด ดังตัวอย่าง
คืนค่ าออกไป รั บค่ าเข้ ามา
ทางออก ทางเข้ า
public static double add(int x, int y) {
หัวเมท็อด
double cal = x + y;
ตัวเมท็อด ข้ อมูลจากทางเข้ าและข้ อมูลที่
return cal;
} ประมวลผล ทางออกไม่ได้ สมั พันธ์กนั
คืนค่า
จากตัวอย่างสามารถแจกแจงส่วนประกอบย่อยของเมท็อดออกเป็ น 6 ส่วนดังต่อไปนี ้
1 2 3 4
<ตัวบ่งคุณลักษณะ> <ประเภท> <ชื่อ> (<ตัวแปรรับเข้ า>) { ไม่วา่ ภายในเมท็อดจะมีกี่คําสัง่ ก็ตามจะ
ต้ องใส่เครื่ องหมายปี กกาเปิ ด-ปิ ดเสมอ
<คําสัง่ ประมวลผล> 5
...
ส่วนประกอบที่ 1-4 คือ หัวเมท็อด (Head)
<คําสัง่ ส่งกลับข้ อมูล> 6
ส่วนประกอบที่ 5-6 คือ ตัวเมท็อด (Body)
} .
2. หัวเมท็อด (Head)
เป็ นส่วนที่แสดงถึงรูปแบบ โครงสร้ างและข้ อกําหนดของเมท็อด ซึง่ มีสว่ นประกอบดังต่อไปนี ้
1) ตัวบ่ งคุณลักษณะ (Modifier) คือ ส่วนที่กําหนดคุณลักษณะและคุณสมบัติบางประการของเมท็อด ซึ่ง
ได้ แก่ public, private, protected, static ฯลฯ โดยจะอธิบายอีกครัง้ ในเรื่ องคลาสและอ๊ อบเจ็ค แต่
ในบทนี ้ให้ เขียนตัวบ่งคุณลักษณะของทุกเมท็อดเป็ นแบบ public static เท่านัน้ ดังตัวอย่าง
public static double power(double n) ส่วนนี ้มีก็ได้ ไม่มีก็ได้ ตัดออกได้
2) ประเภทเมท็อด (Method Type) หรื อประเภทข้ อมลที ู ่ ส่งกลับ (Return Type) คือ ประเภทข้ อมูลที่
เป็ นผลลัพธ์สดุ ท้ ายของเมท็อดที่จะคืนค่ากลับ ซึง่ ได้ แก่ประเภทข้ อมูล byte, short, int, long, float,
double ฯลฯ หากเมท็อดไม่มีการคืนค่ากลับให้ ระบุเป็ นประเภท void ดังตัวอย่าง
protected void show(float y, String s) ส่วนนี ้ต้ องมีเสมอ ตัดออกไม่ได้
ในกรณีที่ประเภทข้ อมูลที่ส่งกลับมีโครงสร้ างข้ อมูลเป็ นแบบอาเรย์ ให้ ระบุเครื่ องหมายวงเล็บเหลี่ยม

(Brackets) ต่อท้ายประเภทเมท็อดนันด้้ วย ดังตัวอย่าง ถ้ าเป็ นอาเรย์สองมิตใิ ห้ ระบุเป็ น int[][]
private static int[] sort(int x[])
ในกรณีที่คืนค่ามากกว่า 1 ค่าจะต้ องอยูใ่ นรูปอาเรย์
3) ชื่อเมท็อด (Method Name) คือ ชื่อที่อ้างถึงหรื อชื่อเรี ยกเมท็อด ซึ่งควรขึ ้นต้ นด้ วยอักษรตัวพิมพ์เล็ก
้ ่อตัวแปร) และชื่อควรเป็ นคํากริ ยาหรื อคําที่แสดงการกระทํา เช่น getID(…),
(เป็ นไปตามกฎการตังชื
addNumber(…) เป็ นต้ น และหลังชื่อเมท็อดต้ องตามด้ วยเครื่ องหมายวงเล็บเปิ ด-ปิ ดเสมอ ดังตัวอย่าง
public static double add (int x, int y) ส่วนนี ้ต้ องมีเสมอ ตัดออกไม่ได้
4) ตัวแปรรับเข้ า (Parameters) คือ ค่าหรื อตัวแปรที่รับเข้ ามายังเมท็อดเพื่อใช้ ประมวลผลภายในเมท็อด ซึง่

ตัวแปรรับเข้ าของเมท็อดหนึ่งๆ จะมีหรื อไม่มีก็ได้ ถ้ ามีจะมีกี่ตวั ก็ได้ ถ้ ามีหลายตัวแต่ละตัวต้ องคัน่ ด้ วย
เครื่ องหมายจุลภาค (Comma) และทุกตัวต้ องมีประเภทข้ อมูลกํากับเสมอ เช่น set(int a, int b)
ห้ ามเขียนเป็ น set(int a, b) โดยเด็ดขาด ดังตัวอย่าง คล้ ายกับการประกาศตัวแปร
public double mul(int x, double y, int z) ส่วนนี ้มีก็ได้ ไม่มีก็ได้ ตัดออกได้
ในกรณีที่พารามิเตอร์ มีโครงสร้ างข้ อมูลเป็ นแบบอาเรย์ ให้ ระบุเครื่ องหมายวงเล็บเหลี่ยมไว้ ข้างหน้าหรื อ

ต่อท้ายชื่อพารามิเตอร์ นนด้
ั ้ วย ดังตัวอย่าง
public static int find(int x, int y[][]) มีพารามิเตอร์ ที่เป็ นอาเรย์สองมิติ
โจทย์ ข้อที่ 2 [ระดับง่ าย] จงเติมเต็มส่ วนหัวเมท็อดให้ สมบรณ์ู ตามรปแบบของเมท็

ู อดต่ อไปนี ้ (10 คะแนน)
1) เมท็อดชื่อ square มีข้อมลรั ู บเข้ า 1 ค่ าที่เป็ นจํานวนจริ ง เพื่อใช้ คํานวณหาค่ ายกกําลังสองของ
จํานวนนัน้ พร้ อมทัง้ ส่ งค่ าคําตอบกลับ (2 คะแนน)
double square( )
2) เมท็อดชื่อ root มีข้อมูลรั บเข้ า 1 ค่ าที่เป็ นจํานวนเต็ม เพื่อใช้ คาํ นวณหาค่ ารากที่สองของจํานวนนัน้
พร้ อมทัง้ ส่ งค่ าคําตอบกลับ (2 คะแนน)
protected static ( )
3) เมท็อดชื่อ showName มีข้อมลรั

ู บเข้ า 1 ค่ าที่เป็ นชื่อของบุคคลใดๆ เพื่อใช้ แสดงชื่อของบุคคลนัน้ ขึน้
บนจอภาพ โดยไม่ ต้องส่ งค่ าคําตอบกลับ (2 คะแนน)
private static showName( )
4) เมท็อดชื่อ countX มีข้อมลรั

ู บเข้ าที่เป็ นอาเรย์ 1 มิตปิ ระเภทจํานวนเต็มและตัวเลขจํานวนเต็ม เพื่อ
ใช้ นับจํานวนสมาชิกในอาเรย์ ท่ มี ีค่าเท่ ากับจํานวนเต็มที่รับมา พร้ อมทัง้ ส่ งค่ าคําตอบกลับ (2 คะแนน)
static
5) เมท็อดชื่อ revArray มีข้อมลรั ู บเข้ า 1 ค่ าที่เป็ นอาเรย์ 1 มิติประเภทจํานวนจริง เพื่อใช้ กลับค่ า

(Reverse) สมาชิกในอาเรย์ นัน้ พร้ อมทัง้ ส่ งค่ าคําตอบกลับ (2 คะแนน)
revArray
3. ตัวเมท็อด (Body)
เป็ นส่วนที่แสดงรายละเอียดของการประมวลผลและการส่งกลับข้ อมูลของเมท็อด ซึง่ มีดงั ต่อไปนี ้
1) การประมวลผล ซึง่ ได้ แก่การประกาศตัวแปรเพื่อใช้ ภายในเมท็อด และการใช้ คําสัง่ ต่างๆ เช่น if-else,
while, for, Scanner ในการประมวลผลภายในเมท็อด ซึง่ หลักการเหล่านี ้จะเหมือนกับเนื ้อหาก่อนหน้ า
นี ้ตังแต่
้ บทที่ 1-7 ที่ได้ เรี ยนมาแล้ วทุกประการ
2) การส่ งกลับข้ อมลู เป็ นการส่งค่าหรื อคืนค่าคําตอบที่ได้ จากการประมวลผลในเมท็อดกลับไปยังเมท็อดที่
เรี ยกใช้ ซึง่ ค่าที่สง่ กลับ (Return Value) จะต้ องตรงกับประเภทเมท็อด (Method Type) หรื อ ประเภทข้ อมูล
ที่สง่ กลับ (Return Type) ที่ประกาศไว้ ที่หวั เมท็อดเสมอ หรื อถ้ าไม่ตรงกันจะต้ องสามารถสอดใส่กนั ได้ ซึง่
การส่งกลับจะใช้ คําสัง่ return และสามารถทําได้ เพียงครัง้ เดียวเท่านัน้ ถ้ ามีคําสัง่ return หลายกรณีจะ
ทําเพียงกรณีแรกที่เป็ นจริ ง แต่ถ้าประเภทเมท็อดเป็ น void ไม่ต้องมีคําสัง่ return ดังตัวอย่าง
1 public static double div(int a, int b){ เมท็อดเป็ นประเภท double
2 double x = (double) a / (double) b;
3 return x;
4 }
ค่าที่จะส่งกลับ (ค่าของตัวแปร x) จะต้ องมีประเภทข้ อมูลเป็ น double
3) การส่ งกลับข้ อมลแบบหลายค่

ู า ถ้ าเมท็อดประมวลผลแล้ วได้ ผลลัพธ์ที่เป็ นคําตอบสุดท้ ายมากกว่า 1 ค่า
จะต้ องส่งค่ากลับโดยใช้ อาเรย์ (หนึ่งมิติ) โดยการเก็บค่าคําตอบทุกค่าไว้ ในอาเรย์แล้ วคืนค่าของอาเรย์นนั ้
เพียงค่าเดียวกลับไปยังเมท็อดที่เรี ยกใช้ ซึง่ จะทําให้ ได้ ผลคําตอบทุกค่าคืนกลับมาด้ วย ดังตัวอย่าง
1 public static int[] findFirstLast(int a[]) {
2 int x[] = new int[2];
3 x[0] = a[0]; ประเภทข้ อมูลที่สง่ กลับที่หวั เมท็อดต้ องเป็ นอาเรย์
4 x[1] = a[a.length – 1];
5 return x; การส่งกลับข้ อมูลแบบอาเรย์จะเขียนเฉพาะชื่อของอาเรย์
6 }
โดยไม่ต้องใส่เครื่ องหมายวงเล็บเหลี่ยม
โจทย์ ข้อที่ 3 [ระดับง่ าย] จงพิจารณาเมท็อดต่ อไปนีเ้ ขียนผิด (:) หรื อถูก (;) ตามหลักไวยากรณ์ ของ
ภาษาจาวาพร้ อมทัง้ บอกเหตุผลกํากับ (10 คะแนน)
1) public static printError(String msg) {
System.err.println(msg);
}
2) protected static int flip(int n) {
if (n == 1) n = 0;
}
3) public static float max(long x, y) {
if (x > y) return x;
else return y;
}
4) private static void showChar() {
for(char i = '0'; i <= '9'; i++) {
System.out.println(i);
}
return;
}
5) static String calGrade(int x) {

if (x > 80) return "A";
else if (x < 50) return "F";
else System.out.println("C");
}
6) double getLen(double dx, double dy) {
double dx = Math.abs(dx);
return Math.sqrt(dx*dx + dy*dy);
}
7) public private boolean checkLen(int x[], int y[]) {
return x.length == y.length;
}
8) public float getLocationPoint() {
return 0.0;
}
9) public static int fac(int x) {
if(x <= 1) return 1;
else return fac(x – 1) * x;
}
10) int[] getThreeMember(int[] x) {
int n[] = { x[0], x[1], x[2] };
return n[];
}
โจทย์ ข้อที่ 4 [ระดับง่ าย] จงเขียนเมท็อดอย่ างง่ ายตามรปแบบการทํ

ู างานที่ระบุไว้ ต่อไปนี ้ (16 คะแนน)
1) เมท็อดชื่อ addRealNumber มีข้อมลรั ู บเข้ าเป็ นตัวเลขจํานวนจริ ง 3 จํานวน ซึ่งใช้ ในการหาผลบวก
ของตัวเลข 3 จํานวนนัน้ แล้ วมีการคืนค่ ากลับ (4 คะแนน)
2) เมท็อดชื่อ printX มีข้อมลรั

ู บเข้ าเป็ นตัวเลขจํานวนเต็ม 1 จํานวน เพื่อใช้ ในการแสดงผลลัพธ์ ออก
ทางจอภาพภายในเมท็อดนัน้ โดยไม่ คืนค่ ากลับ (4 คะแนน)
3) เมท็อดชื่อ divideByInt ใช้ ในการหาผลหารระหว่ างตัวเลข 2 จํานวน ซึ่งเป็ นจํานวนจริ งและจํานวน

เต็มอย่ างละ 1 จํานวน แล้ วมีการคืนค่ ากลับ (4 คะแนน)
4) เมท็อดชื่อ fullName ใช้ ในการรวมชื่อและนามสกุลที่รับเข้ ามาให้ เป็ นชื่อเต็ม (ระหว่ างชื่อและ
นามสกุลต้ องมีการเว้ นวรรคด้ วย) แล้ วคืนค่ ากลับ (4 คะแนน)
โจทย์ ข้อที่ 5 [ระดับง่ าย] จงเขียนเมท็อด fac(…) ที่สมบรณ์ู เพื่อใช้ ในการคํานวณหาค่ าแฟกทอเรี ยล
(Factorial) ของตัวเลขจํานวนเต็มที่ระบุ เช่ น fac(3) = 6, fac(5) = 120 เป็ นต้ น (10 คะแนน)
โจทย์ ข้อที่ 6 [ระดับง่ าย] เมท็อดชื่อ findMax มีข้อมลรั

ู บเข้ าที่เป็ นชุดของตัวเลขจํานวนจริง 50 จํานวน
เพื่อนํามาหาค่ าตัวเลขที่มากที่สุดใน 50 จํานวนนัน้ แล้ วมีการคืนค่ ากลับ (10 คะแนน)
โจทย์ ข้อที่ 7 [ระดับปานกลาง] จงเขียนเมท็อด underX(…) ที่สมบรณ์ ู เพื่อใช้ คํานวณและนับว่ ามีสมาชิก

ในอาเรย์ หนึ่งมิตชิ ่ ือ a กี่จาํ นวนที่มีค่าน้ อยกว่ าจํานวนเต็ม x โดยให้ รับอาเรย์ a และตัวแปร x ผ่ านทาง
พารามิเตอร์ (10 คะแนน)
โจทย์ ข้อที่ 8 [ระดับปานกลาง] จงเขียนเมท็อด isPrime(…)ที่สมบรณ์ ู เพื่อใช้ ตรวจสอบตัวเลขจํานวน

เต็มที่รับเข้ ามาทางพารามิเตอร์ ว่าเป็ นจํานวนเฉพาะหรือไม่ (10 คะแนน)
โจทย์ ข้อที่ 9 [ระดับปานกลาง] จงเขียนเมท็อด memberOfArray(…) ที่สมบรณ์ ู เพื่อค้ นหาลําดับของสมา-

ชิกตัวแรกในอาเรย์ หนึ่งมิตชิ ่ ือ a ที่มีค่าเท่ ากับจํานวนเต็ม x ถ้ าค้ นเจอมากกว่ า 1 จํานวนให้ คืนค่ าเพียง
สมาชิกตัวแรกที่ค้นเจอโดยเริ่มจากตัวซ้ ายสุด แต่ ถ้าค้ นไม่ เจอให้ คืนค่ า -1 (10 คะแนน)
โจทย์ ข้อที่ 10 [ระดับยาก] จงเขียนเมท็อด appendArray(…) เพื่อรั บพารามิเตอร์ สองค่ าที่เป็ นอาเรย์
ชนิ ด จํ า นวนเต็ ม ทั ง้ ค่ ู แ ล้ วคื น ค่ า เป็ นอาเรย์ ชนิ ด จํ า นวนเต็ ม ที่ เ กิ ด จากการเอาข้ อ มลในอาเรย์
ู ข อง
พารามิเตอร์ ตัวที่สองไปต่ อท้ ายตัวที่หนึ่ง เช่ น a[] = {1, 2, 3 } และ b[] = {5, 6} จะได้ ผลลัพธ์
ดังนี ้ appendArray(a, b) = {1, 2, 3, 5, 6} เป็ นต้ น (10 คะแนน)
3. การเรียกใช้ เมท็อดอย่ างง่ าย (Simple Method Calling)

1. บทบาทของเมท็อด ในการเรี ยกใช้ เมท็อดจะประกอบไปด้ วยเมท็อด 2 ฝ่ ายได้ แก่
1) เมท็อดผู้เรี ยก ทําหน้ าที่เป็ นผู้ไปเรี ยกใช้ เมท็อดอื่น
2) เมท็อดผู้ถกู เรี ยก ทําหน้ าที่เป็ นผู้ที่ให้ เมท็อดอื่นมาเรี ยกใช้ ตวั มัน
2 int n = add(5, 3); เมท็อด main เป็ นผู้เรี ยก
3 }
4 public static int add(int x, int y) { (เรี ยกใช้ เมท็อด add)
5 return x + y;
6 } เมท็อด add เป็ นผู้ถกู เรี ยก (ถูกเรี ยกใช้ โดยเมท็อด main)
2. ขัน้ ตอนการเรี ยกใช้ เมท็อดอย่ างง่ าย

1) ระบุชื่อเมท็อดที่ต้องการจะเรี ยก เช่น add(…) (ต้ องมีเครื่ องหมายวงเล็บเปิ ด-ปิ ดเสมอ)
2) ระบุคา่ พารามิเตอร์ ทกุ ตัวของเมท็อดให้ ถกู ต้ องตามประเภทข้ อมูล เช่น add(5, 3) (ค่าของพารามิเตอร์
สามารถระบุเป็ นชื่อตัวแปรหรื อนิพจน์ก็ได้ เช่น add(x, y * 2))
3) สร้ างตัวแปรเพื่อมารับคําตอบที่ได้ จากการประมวลผลของเมท็อด เช่น int n = add(5, 3);
(1) ถ้ าเมท็อดที่ต้องการจะเรี ยกคืนค่าข้ อมูลประเภท byte, short, int, long, float, double ฯลฯ ให้
สร้ างตัวแปรเพื่อรับคําตอบตามประเภทข้ อมูลนันๆ ้ เช่น String s = getName(53300121);
(2) ถ้ าเมท็อดที่ต้องการจะเรี ยกไม่คืนค่าหรื อมีประเภทข้ อมูลเป็ น void ไม่ต้องสร้ างตัวแปรเพื่อรับคําตอบ
(สามารถเรี ยกใช้ เมท็อดโดยไม่ต้องมีตวั แปรมารับ) เช่น showName(53300121);

String s = getName(53300121);
เมท็อด main เรี ยกใช้ เมท็อด
2
3 System.out.println(s); getName โดยส่งพารามิเตอร์
4 showName(53300121);
5 }
ประเภท int ไปประมวลผลและสร้ าง
6 public static String getName(int id) { ตัวแปร s เพื่อรับคําตอบที่คืนกลับมา
7 return "Wongyos";
8 }
9 public static void showName(int id) { เมท็อด main เรี ยกใช้ เมท็อด showName
10 System.out.println("Wongyos");
11 } แบบโดดๆ โดยส่งพารามิเตอร์ ประเภท int
ไปประมวลผล ซึง่ ไม่มีการคืนค่ากลับ
4) การส่งค่าและรับค่าอาเรย์
(1) การส่งค่าอาเรย์ไปยังเมท็อดใดๆ ให้ ระบุเพียงชื่ออาเรย์เท่านัน้ โดยไม่ต้องใส่วงเล็บเหลี่ยม เช่น
int n[] = { 1, 2, 3, 4 };
int c = underX(n, 3);
(2) การรับค่าที่คืนกลับมาจากเมท็อดใดๆ ในรูปของอาเรย์ ให้ ประกาศอาเรย์มารับ (ไม่ต้องใช้ คําสัง่ new) เช่น
int x[] = { 1, 2, 3, 4 }, y[] = { 5, 7, 9 };
int z[] = appendArray(x, y);
3. ข้ อสังเกตในการเรี ยกใช้ เมท็อด

1) การเรี ยกใช้ เมท็อด (ที่สร้ างเสร็ จสมบูรณ์แล้ ว) จะระบุเพียงค่าพารามิเตอร์ ของเมท็อดที่ต้องการจะเรี ยกใช้
เท่านัน้ โดยไม่ต้องระบุประเภทข้ อมูลของพารามิเตอร์ (byte, short ฯลฯ) เช่น int n = add(x, y);
2) การประกาศและสร้ างเมท็อด (ที่ยงั ไม่เคยสร้ างแต่กําลังจะสร้ าง) จะต้ องระบุทงชื
ั ้ ่อพารามิเตอร์ และประเภท
ข้ อมูลของพารามิเตอร์ ทกุ ๆ ตัว ของเมท็อดที่จะสร้ างขึ ้นใหม่ เช่น public ... add(int x, int y)
2 int x = 5, y = 3;
3 int n = add(x, y); การเรี ยกใช้ เมท็อด Æ ใส่คา่ พารามิเตอร์ โดยไม่ต้องระบุประเภทข้ อมูล
4 }
5 public static int add(int x, int y) { การประกาศและสร้ างเมท็อด Æ ใส่ชื่อพา-
6 return x + y;
7 } รามิเตอร์ และระบุประเภทข้ อมูล
ตัวแปร x และ y ในเมท็อด main จะเป็ นคนละตัว กับตัวแปร x และ y ในเมท็อด add
โจทย์ ข้อที่ 11 [ระดับง่ าย] จงเขียนคําสั่งการเรี ยกใช้ งานเมท็อด จากหัวเมท็อดที่กาํ หนดให้ ต่อไปนี ้ โดย
สามารถกําหนดค่ าของพารามิเตอร์ ของเมท็อดที่เรียกใช้ ได้ อย่ างอิสระ (10 คะแนน)
ข้ อ หัวเมท็อด เขียนคําสั่งเพื่อเรียกใช้ งานเมท็อด
1. public static void set(int m, int n)
2. public static int cals(int m, float n)
3. public static String toString(int[] n)
ข้ อ หัวเมท็อด เขียนคําสั่งเพื่อเรียกใช้ งานเมท็อด
4. public static int[] get(int m, String s)
5. public static void sort(double d[])
6. public static boolean check(long id)
7. public static int flip(int m, boolean b)
8. public static double[] inputArray()
9. public static void showLogo()
10. public static byte f(int m, int n, int p)
โจทย์ ข้อที่ 12 [ระดับง่ าย – ระดับยาก] จงเขียนเมท็อดต่ างๆ ในคลาส ArrayUtility ให้ สมบรณ์
ู เพื่อใช้
ประมวลผลกั บ อาเรย์ โดยมี ร ายละเอีย ดของเมท็อดดัง ต่ อไปนี ้ และกํา หนดให้ เ มท็อดแต่ ล ะเมท็อ ด
สามารถเรี ยกใช้ งานซึ่งกันและกันได้ อย่ างอิสระ (75 คะแนน)
public class ArrayUtility {
//[ระดับง่ าย] เมท็อด main(…) เพื่อเรียกใช้ งานเมท็อดอื่นๆ ให้ ครบถ้ วนพร้ อมทัง้ แสดงผลลัพธ์ ขึน้ บน
จอภาพให้ สวยงาม โดยสามารถกําหนดค่ าพารามิเตอร์ ของแต่ ละเมท็อดได้ อย่ างอิสระ (5 คะแนน)
int a[] = { 5, 1, 6, 1, 4, 1, 2, 1, 4, 3, 1, 5, 7, 2, 1, 1 };
sort(a);
System.out.println(max(a)); ตัวอย่ างการเรียกใช้ เมท็อดพร้ อมทัง้ การแสดงผล
System.out.println(min(a));
ข้ อ เขียนคําสั่งเพื่อเรียกใช้ งานเมท็อด เมท็อดที่เรียก
1. count(…)
2. mode(…)
3. majority(…)
4. median(…)
5. range(…)
} //End of main
//[ระดับปานกลาง] เมท็อด swap(…) ใช้ ในการสลับค่ าสมาชิกในอาเรย์ ตามตําแหน่ ง i และ j ที่ระบุ

เช่ นคําสั่ง swap(a, i, j) คือการสลับค่ าสมาชิกตําแหน่ งที่ i และ j ของอาเรย์ a เป็ นต้ น โดยไม่
ต้ องคืนค่ ากลับ (5 คะแนน)
//[ระดับปานกลาง] เมท็อด sort(…) ใช้ จัดเรี ยงข้ อมลในอาเรย์

ู จากน้ อยไปหามากโดยใช้ การจัดเรี ยง
แบบฟอง (Bubble Sort) โดยไม่ ต้องคืนค่ ากลับ (10 คะแนน)
//[ระดับปานกลาง] เมท็อด count(…) ใช้ นับจํานวนสมาชิกในอาเรย์ ท่ มี ีค่าเท่ ากับจํานวนเต็ม k ที่ระ-

บุ (นับความถี่) แล้ วคืนค่ าจํานวนที่นับได้ (10 คะแนน)
//[ระดับยาก] เมท็อด mode(…) ใช้ หาค่ าฐานนิยม โดยจะคืนค่ าสมาชิกในอาเรย์ ท่ ีมีค่าความถี่สูงสุด
หรือปรากฎจํานวนครัง้ มากที่สุด ถ้ ามีหลายค่ าให้ คืนค่ าใดก็ได้ เพียงค่ าเดียว (10 คะแนน)
//[ระดับยาก] เมท็อด majority(…) ใช้ หาค่ าหม่ ูมาก โดยจะคืนค่ าสมาชิกในอาเรย์ ท่ มี ีค่าความถี่มาก
กว่ าครึ่งหนึ่งของจํานวนสมาชิกทัง้ หมด ถ้ าหาไม่ ได้ ให้ คืนค่ า -1 (10 คะแนน)
//[ระดับปานกลาง] เมท็อด median(…) ใช้ หาค่ ามัธยฐาน พร้ อมทัง้ คืนค่ ากลับ (10 คะแนน)
//[ระดับง่ าย] เมท็อด max(…) ใช้ หาค่ าสงสุ

ู ดของสมาชิกในอาเรย์ พร้ อมทัง้ คืนค่ ากลับ (5 คะแนน)
//[ระดับง่ าย] เมท็อด min(…) ใช้ หาค่ าตํ่าสุดของสมาชิกในอาเรย์ พร้ อมทัง้ คืนค่ ากลับ (5 คะแนน)
//[ระดับง่ าย] เมท็อด range(…) ใช้ หาค่ าพิสัยของอาเรย์ พร้ อมทัง้ คืนค่ ากลับ (5 คะแนน)
} //End of class
โจทย์ ข้อที่ 13 [ระดับยาก] โปรแกรมต่ อไปนีเ้ ป็ นโปรแกรมที่เขียนคําสั่งทุกคําสั่งไว้ ในเมท็อด main(…)

เพียงเมท็อดเดียว โดยโปรแกรมนีใ้ ช้ สําหรั บสร้ างอาเรย์ 1 มิตปิ ระเภทจํานวนเต็ม 2 ตัว พร้ อมทัง้ รั บค่ า
สมาชิกผ่ านทางแป้นพิมพ์ เก็บไว้ ในอาเรย์ แต่ ละช่ องจนครบสมบรณ์ ู หลังจากนัน้ ทําการตรวจสอบการ
เท่ ากันของอาเรย์ ทัง้ สองว่ าเท่ ากันหรื อไม่ พร้ อมทัง้ แสดงผลลัพธ์ ขึน้ บนจอภาพ จากนัน้ ทําการจัดเรี ยง
ข้ อมลจากน้
ู อยไปหามากของอาเรย์ ทัง้ สองแล้ วตรวจสอบการเท่ ากันของอาเรย์ อีกครั ง้ หนึ่ งว่ าเท่ ากัน
หรื อไม่ พร้ อมทัง้ แสดงผลลัพธ์ ขึน้ บนจอภาพ สุดท้ ายทําการแสดงสมาชิกแต่ ละตัวของอาเรย์ ทัง้ สองขึน้
บนจอภาพอย่ างสวยงามดังตัวอย่ างข้ างล่ าง จากโปรแกรมที่กําหนดให้ จงเขียนโปรแกรมใหม่ โดยแบ่ ง
ส่ วนของโปรแกรมต่ างๆ ออกเป็ นเมท็อดย่ อยให้ เหมาะสม (ประมาณ 5-6 เมท็อด) เพื่อให้ การทํางานของ
โปรแกรมเป็ นสัดส่ วนยิ่งขึน้ แต่ ให้ คงไว้ ซ่ งึ การแสดงผลลัพธ์ ท่ เี หมือนเดิมทุกประการ (40 คะแนน)
Enter a[] size: 3
Enter member: 1 ระบุจํานวนสมาชิกของอาเรย์พร้ อมทังรั้ บค่าสมาชิกแต่ละตัวของอาเรย์
Enter member: 2
Enter member: 3
Enter b[] size: 3
Enter member: 2 ระบุจํานวนสมาชิกของอาเรย์พร้ อมทังรั้ บค่าสมาชิกแต่ละตัวของอาเรย์
Enter member: 1
Enter member: 3
Check array equals before sort: not equals ผลเปรี ยบเทียบการเท่ากันของอาเรย์ก่อนจัดเรี ยง
Check array equals after sort: equals
a[]: 1 2 3 ผลเปรี ยบเทียบการเท่ากันของอาเรย์หลังจัดเรี ยง
b[]: 1 2 3 แสดงสมาชิกแต่ละตัวของอาเรย์
1 import java.io.*;
3 import jlab.graphics.DWindow;
4 public class OneMainOneMethod {
7
8 System.out.print("Enter a[] size: ");
9 int x = kb.nextInt();
10 int a[] = new int[x];
11 for (int i = 0; i < a.length; i++) {
12 System.out.print("Enter member: ");
13 a[i] = kb.nextInt();
14 }
15
16 System.out.print("Enter b[] size: ");
17 int y = kb.nextInt();
18 int b[] = new int[y];
19 for (int i = 0; i < b.length; i++) {
20 System.out.print("Enter member: ");
21 b[i] = kb.nextInt();
22 }
23
24 System.out.print("Check array equals before sort: ");
25 if (a.length == b.length) {
26 int count = 0;
28 if (a[i] == b[i]) count++;
29 }
30 if (count == a.length) {
31 System.out.println("equals");
32 } else {
33 System.out.println("not equals");
34 }
35 } else {
37 }
38
39 for (int i = a.length - 1; i >= 1; i--) {
40 for (int j = 0; j < i; j++) {
41 if (a[j] > a[j + 1]) {
42 int t = a[j];
43 a[j] = a[j + 1];
44 a[j + 1] = t;
45 }
46 }
47 }
48 for (int i = b.length - 1; i >= 1; i--) {

49 for (int j = 0; j < i; j++) {
50 if (b[j] > b[j + 1]) {
51 int t = b[j];
52 b[j] = b[j + 1];
53 b[j + 1] = t;
54 }
55 }
56 }
57
58 System.out.print("Check array equals after sort: ");
59 if (a.length == b.length) {
60 int count = 0;
62 if (a[i] == b[i]) count++;
63 }
64 if (count == a.length) {
65 System.out.println("equals");
66 } else {
68 }
69 } else {
71 }
72
73 System.out.print("a[]: ");
75 System.out.print(a[i] + " ");
76 }
77 System.out.println();
78
79 System.out.print("b[]: ");
80 for (int i = 0; i < b.length; i++) {
81 System.out.print(b[i] + " ");
82 }
83 System.out.println();
84 } //End of main
85 } //End of class
เขียนโปรแกรมใหม่ โดยแบ่ งออกเป็ นเมท็อดย่ อย (ประมาณ 5-6 เมท็อด รวมเท็อด main(…) แล้ ว) โดย
วิธีการแบ่ งเมท็อดย่ อยให้ พจิ ารณาจากสัดส่ วนการทํางานย่ อยของโปรแกรมเดิม
public class OneMainManyMethods { คะแนนจะแปรผันไปตามโปรแกรมและเมท็อดที่ออกแบบ
} //End of class
4. เมท็อดหลายแบบในชื่อเดียวกัน (Overloading Methods)

1. นิยามของเมท็อดหลายแบบในชื่อเดียวกัน (Overloading Methods)
้ 2 เมท็อดใดๆ ขึ ้นไปที่มีชื่อเหมือนกันแต่มีรายการของพารามิเตอร์ ตา่ งกัน ดังรายละเอียดต่อไปนี ้
คือ เมท็อดตังแต่
1) จํานวนพารามิเตอร์ ตา่ งกัน เช่น
public static int test(int x) เมท็อด test ตัวที่หนึง่ มีพารามิเตอร์ 1 ตัว
public static int test(int x, int y) เมท็อด test ตัวที่สองมีพารามิเตอร์ 2 ตัว
2) ประเภทข้ อมูลของพารามิเตอร์ ตา่ งกัน

public static int test(int x) เมท็อด test ตัวที่หนึง่ มีพารามิเตอร์ ประเภท int
public static int test(double x) เมท็อด test ตัวที่สองมีพารามิเตอร์ ประเภท double
2. ข้ อสังเกตเกี่ยวกับเมท็อดหลายแบบในชื่อเดียวกัน
1) เมท็อดแต่ละเมท็อดจะมีประเภทข้ อมูลที่สง่ กลับ (Return Type) ที่ตา่ งกันหรื อเหมือนกันก็ได้ (ไม่ต้องไป
สนใจ และไม่ใช่เป็ นประเด็นที่จะใช้ พิจารณาเมท็อดประเภทนี ้)
2) การเปรี ยบเทียบความเหมือนหรื อไม่เหมือนของพารามิเตอร์ ของแต่ละเมท็อด ให้ พิจารณาที่ประเภทข้ อมูล
ของพารามิเตอร์ เท่านัน้ ไม่ได้ พิจารณาที่ชื่อของพารามิเตอร์ แต่อย่างใด (ต่างเมท็อดกันชื่อเหมือนกันได้ )
3) ระบบจะเลือกเมท็อดที่เหมาะสมที่สดุ เพียงเมท็อดเดียวขึ ้นมาใช้ งาน ถ้ าไม่มีเมท็อดใดเลยที่เหมาะสมจะ
แปลผลไม่ผา่ น (Compile-time Error)
โจทย์ ข้อที่ 14 [ระดับง่ าย] จงเลือกใช้ เมท็อดหลายแบบในชื่อเดียวกัน (Overloading Method) ที่เหมาะสม
ที่สุดจากคําสั่งต่ อไปนี ้ พร้ อมทัง้ แสดงผลลัพธ์ ท่ เี กิดจากคําสั่งนัน้ (15 คะแนน)
หมายเลขเมท็อด รายละเอียดของเมท็อด
public static double m(int n) {
1 return n * n;
}
public static int m(double n) {
2 return (int)(n * n);
}
public static boolean m(int n, int x) {
3 return n == x;
}
public static double m(int a, int b, int c) {
4 return (double)(a * b * c);
}
public static int m(char c) {
5 return (int) c;
}
public static String m(double n, int x) {
6 return n + "" + x;
}
public static int m(double x, double n) {
7 return (int)(n * x);
}
ข้ อ คําสั่ง หมายเลขเมท็อด ผลลัพธ์
1. System.out.println(m(10));
2. System.out.println(m(1, 2.5));
3. System.out.println(m(11.0));
4. System.out.println(m(6.0f));
5. System.out.println(m(12, 2));
6. System.out.println(m('1'));
7. System.out.println(m(10.0, 2));
8. System.out.println(m(2, 2, 1));
9. System.out.println(m(m(5, 1, 2)));
10. System.out.println(m(m(5, 1.0f)));
11. System.out.println(m(1.0f, 2));
12. System.out.println(m(0L, 1, 1));
13. System.out.println(m(0.0f, (byte) 1));
14. System.out.println(m((byte) 1.3, 1));
15. System.out.println(m(1.1));
โจทย์ ข้อที่ 15 [ระดับง่ าย] จงเขียนเมท็อดหลายแบบในชื่อเดียวกัน (Overloading Method) ตามข้ อกํา-

หนดต่ อไปนี ้ พร้ อมทัง้ เรี ยกใช้ งานเมท็อดเหล่ านีใ้ ห้ ถูกต้ องสมบรณ์
ู (15 คะแนน)
public class Overload {
//เมท็อด main(…) เพื่อเรี ยกใช้ เมท็อด showName(…) ทุกตัวให้ ครบสมบรณ์
ู และกําหนดค่ าพารามิ-
เตอร์ ได้ อย่ างอิสระ (3 คะแนน)
} //End of main
//เมท็อด showName(…) แบบที่ไม่ มีพารามิเตอร์ เพื่อใช้ แสดงชื่อของนิสิตขึน้ บนจอภาพ (3 คะแนน)
//เมท็อด showName(…) แบบที่มีพารามิเตอร์ 1 ตัวที่รับชื่อนิสิตชื่อใดๆ เข้ ามาเพื่อใช้ แสดงชื่อของ

นิสิตคนนัน้ ขึน้ บนจอภาพ (3 คะแนน)
//เมท็อด showName(…) แบบที่มีพารามิเตอร์ 2 ตัวที่รับคํานําหน้ าชื่อและชื่อนิสิตชื่อใดๆ เข้ ามาเพื่อ

ใช้ แสดงคํานําหน้ าชื่อตามด้ วยชื่อของนิสิตคนนัน้ ขึน้ บนจอภาพ (3 คะแนน)
//เมท็อด showName(…) แบบที่มีพารามิเตอร์ 2 ตัวที่รับชื่อนิสิตชื่อใดๆ และจํานวนเต็ม x อีกหนึ่งค่ า

เพื่อใช้ แสดงชื่อของนิสิตคนนัน้ จํานวน x ครัง้ ขึน้ บนจอภาพ (3 คะแนน)
} //End of class

Java Tutor1

Uploaded by

Document Information

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Java Tutor1

Uploaded by

Copyright:

Available Formats

Introduction to Java Programming - 01 Computer Programming using Java 1

CHAPTER เริม่ ต้นการเขียนโปรแกรมภาษาจาวา

องค์ประกอบของโปรแกรมภาษาจาวาแบบพื ้นฐานที่สดุ จะต้ องประกอบไปด้ วยองค์ประกอบ 3 ส่วนหลัก ได้ แก่

2) เมท็อด (Method) ใช้ เครื่ องหมายปี กกาในการบอกขอบเขตของเมท็อดซึง่ อยูซ่ ้ อน

4. รายละเอียดเบือ้ งต้ นของ คลาส เมท็อด และ คําสั่ง

2) คลาสหนึ่งคลาสสามารถมีได้ หลายเมท็อด เช่น (ให้สงั เกตุเพียงแค่วิธีการเขี ยนและขอบเขตของคําสัง่ )

3) เมท็อดหนึ่งเมท็อดสามารถมีได้ หลายคําสั่ง เช่น (ให้สงั เกตุเพียงแค่วิธีการเขี ยนและขอบเขตของคําสัง่ )

5) เพื่อการเข้ าใจให้ ตรงกันจะขอแบ่ งการเขียนโปรแกรมออกเป็ น 2 ช่ วง ดังนี ้

โจทย์ ข้อที่ 3 [ระดับง่ าย] จงนับและระบุส่วนที่เขียนผิดตามหลักไวยากรณ์ ของภาษาจาวา พร้ อมทัง้ เขียน

โปรแกรมนีเ้ ขียนผิดทัง้ หมด ตําแหน่ ง ซึ่งเขียนใหม่ ให้ ถกต้

โจทย์ ข้อที่ 4 [ระดับง่ าย] จงนับและระบุส่วนที่เขียนผิดตามหลักไวยากรณ์ ของภาษาจาวา พร้ อมทัง้ เขียน

โปรแกรมนีเ้ ขียนผิดทัง้ หมด ตําแหน่ ง ซึ่งเขียนใหม่ ให้ ถกต้

โจทย์ ข้อที่ 5 [ระดับปานกลาง] จงประกอบโปรแกรมภาษาจาวาให้ สมบรณ์ ู ตามเงื่อนไขที่กําหนดมาให้

คําสัง่ ที่ 2 x++

คําสัง่ ที่ 3 Scanner kb = new Scanner(System.in)

คําสัง่ ที่ 4 System.out.println("result = " + x)

คําสัง่ ที่ 5 System.out.println("error")

คําสัง่ ที่ 6 if(x != 0) ... else ...

คําสัง่ ที่ 7 while(x < 100)

กําหนดให้ คลาส A ประกอบไปด้ วยเมท็อด main โดยภายในเมท็อด main ประกอบไปด้ วยคําสั่งที่ 3, 1

5. รายละเอียดเบือ้ งต้ นของคําสั่งแสดงผล

(2) อักขระ \t คือ การเลื่อนทีละช่วงในแนวนอน (Horizontal Tab) ซึง่ 1 Tab = 8 Spaces

โจทย์ ข้อที่ 6 [ระดับง่ าย] จงแสดงคําตอบจากส่ วนของโปรแกรมต่ อไปนี ้ (12 คะแนน)

2. การแปลและสั่งงานโปรแกรม (Compiling and Running Program)

13) public /* println */ class /* Class */ Test { // {

โจทย์ ข้อที่ 12 [ระดับง่ าย] จงเขียนผังงานจากกระบวนการทํางานของร้ านขายเสือ้ ผ้ า “เกรี ยน ณ ลาน

ผังงานข้ อย่ อยที่ 1 ผังงานข้ อย่ อยที่ 2

short 16 bits -32,768 ถึง 32,767 0

int 32 bits -2,147,483,648 ถึง 2,147,483,647 0

2) ตัวเลขจํานวนจริง (Floating Point / Real Number) คือ จํานวนที่มีจดุ ทศนิยม

"" (Empty String) (คล่อมด้ วยเครื่ องหมาย "…")

1.3 การเรี ยงลําดับขนาดและศักดิศ์ รี ของประเภทข้ อมูล (เฉพาะตัวเลข) มีดงั นี ้

ตัวอย่าง int x; double num; String lastName; boolean check;

3) การประกาศพร้ อมกับการกําหนดค่ าตัวแปร (รวมวิธีที่ 1 และ 2 เข้ าด้ วยกัน) ซ้ ายตังขวายั

ตัวอย่าง int x = n; double num = 4.01; char ch = 'A'; float y = 2.9f;

4) การประกาศและกําหนดค่ าตัวแปรหลายตัวที่มีประเภทข้ อมูลเดียวกัน คัน่ ด้ วย Comma

ตัวอย่าง int x = n, year, age = 18, z, a;

ประเภทข้ อมลู รปแบบการเขี

 '\u0041' หรื อ รหัส 65 (ฐานสิบ) Æ มีคา่ เท่ากับอักขระ 'A'

 '\u0061' หรื อ รหัส 97 (ฐานสิบ) Æ มีคา่ เท่ากับอักขระ 'a'

 '\u0E01' หรื อ รหัส 3585 (ฐานสิบ) Æ มีคา่ เท่ากับอักขระ 'ก'

6) float cal = 15.763; .

10) String 3Type = "One Two Three"; .

11) short _$abcdefghijklmnopqrstuvwxyz0123456789$_; .

12) boolean flag = 1; .

13) float ตัวเลข = 139L; .

14) String _ = "ヰベ㈣㈠ヘョ"; .

15) int ch = '\u0044'; .

โจทย์ ข้อที่ 2 [ระดับปานกลาง] จงเติมเต็มคําสั่งการประกาศและกําหนดค่ าของตัวแปรต่ อไปนีใ้ ห้ สมบรณ์

3. int var3 = 'C';

5. double var5 = 0x1D;

10. var10 = 100E012;

11. var11 = 1f + "";

12. var12 = 1e1 + "";

13. var13 = 0d;

14. var14 = 3.f;

15. var15 = 0xbeef;

2) การสร้ างตัวอ่ านจากแป้นพิมพ์ เป็ นการกําหนดชื่อตัวอ่านเพื่อใช้ สําหรับรับค่าข้ อมูลต่างๆ จากแป้นพิมพ์

ู วยตัวอ่ านจากแป้นพิมพ์ ตัวอ่านจากแป้นพิมพ์ที่สร้ างขึ ้นสามารถรับค่าข้ อมูลประเภท

เช่น long n = kb.nextLong(); (รับค่า long จากตัวอ่าน kb มาเก็บไว้ ที่ตวั แปร n)

เช่น float f = kb.nextFloat(); (รับค่า float จากตัวอ่าน kb มาเก็บไว้ ที่ตวั แปร f)

เช่น double d = kb.nextDouble(); (รับค่า double จากตัวอ่าน kb มาเก็บไว้ ที่ตวั แปร d)

ประเภท การรั บค่ าจากแป้นพิมพ์ เพื่อ ค่ าที่ป้อนเข้ ามา ค่ าที่เก็บใน

4. var4 = kb.nextFloat(); 22.50000

13) public /* println / class / Class */ Test { // {

'\u0041' หรื อ รหัส 65 (ฐานสิบ) Æ มีคา่ เท่ากับอักขระ 'A'

'\u0061' หรื อ รหัส 97 (ฐานสิบ) Æ มีคา่ เท่ากับอักขระ 'a'

'\u0E01' หรื อ รหัส 3585 (ฐานสิบ) Æ มีคา่ เท่ากับอักขระ 'ก'