Important Announcement
PubHTML5 Scheduled Server Maintenance on (GMT) Sunday, June 26th, 2:00 am - 8:00 am.
PubHTML5 site will be inoperative during the times indicated!

Home Explore Java-Loops

Java-Loops

Published by Pakorn Suntornmeth, 2022-11-15 06:25:35

Description: ch3-Loops

Search

Read the Text Version

ในบททสี่ ามน้เี ราจะมาทําความรจู ักกบั การทํางานในรปู แบบของการประมวลผลชุดคําสง่ั ซา้ํ ๆ กันตาม intro. to Java (FEU.faa) เง่อื นไขที่กาํ หนดให หรือท่ีเรียกวาการประมวลผลแบบวน (repetition หรือ loop) การใชชดุ คําส่งั ใน การตัดสนิ ใจ และ การใชป ระโยคในการเปรียบเทยี บขอมลู ตาง ๆ หลงั จากจบบทเรียนนแี้ ลวผอู า นจะไดทราบถึง o การเปรียบเทียบขอมูล (comparison) o การกําหนดประโยคในการเปรียบเทยี บ (logical expression) o การเปล่ยี นแปลงข้นั ตอนการประมวลผลในแบบตาง ๆ (control statement) o การทาํ งานแบบวน (loop) ƒ for/loop และ for-in/loop (หรอื ทีเ่ รยี กวา for-each/loop) ƒ while/loop ƒ do-while/loop o การยตุ กิ ารทํางานของ loop ดวยการใชคําส่งั break และ continue หลาย ๆ ครั้งการเขยี นโปรแกรมตอ งมีการเลือกท่ีจะประมวลผล ไมวาจะเปนการเลอื กตามขอมลู ที่ นําเขา หรือ การเลอื กประมวลผลตามขั้นตอน กระบวนการที่ไดก าํ หนดไว เชน ถาขอ มูลนําเขา มีคา นอยกวาศูนย เราจะยุติการทาํ งานของโปรแกรม ถา มากกวา เราจะมวลผลตอไป อะไรทํานองนี้ ในการ ตดั สนิ ใจที่จะให code ทาํ อยา งใด อยางหนง่ึ นัน้ เราจะตอ งรูจกั วธิ กี ารสรา งประโยคที่ใชในการ เปรยี บเทยี บ ขั้นตอนของการใชป ระโยคเปรียบเทียบในรปู แบบตาง ๆ 3.1 การตดั สนิ ใจ และ การเปรยี บเทยี บ การตดั สนิ ใจเปนสวนประกอบทสี่ าํ คญั มาก ๆ สว นหน่งึ ของการเขียนโปรแกรม โปรแกรมของเราตองมี ความสามารถในการตัดสินใจท่ีจะเลอื กวาจะทาํ อะไรตอไป เชน ถา จาํ นวนของนกั ศกึ ษาท่มี าสมัคร เรียนในภาควิชาคอมพวิ เตอรธรุ กจิ มมี ากกวา หา รอ ย เราจะมีการสอบคัดเลอื ก หรือ เชน ถาเงินเดือน เพม่ิ ขึ้นฉันจะซ้ือบาน อะไรทาํ นองน้ี ซ่ึงในดานของการเขยี น code นั้น การตัดสินใจจะทาํ ได โปรแกรมกต็ องมคี วามสามารถท่ีจะเปรียบเทียบไดกอน เชน เปรยี บเทียบถงึ ความมากกวา นอยกวา หรือ เปรียบเทียบถึงความเทา กัน และความไมเทา กัน ในบททีส่ องเราไดพดู ถึง relational operator เพียงเลก็ นอยในเร่ืองของการทาํ งานกบั ตัวแปรทีม่ ี ชนดิ เปน boolean และ operator ทวี่ า น้กี ็คอื < (นอ ยกวา เชน x < y) <= (นอยกวา หรอื เทา กบั เชน x <= y) > (มากกกวา เชน x > y) >= (มากกวา หรือเทากบั เชน x >= y) == (เทากัน เชน x == y) != (ไมเ ทา กัน เชน x != y) เราจะมาดูถึงการใช operator เหลานี้ในประโยคคาํ สั่งตา ง ๆ 3.1.1 การใช if เพ่ือการตัดสนิ ใจ if เปนคาํ ส่ังท่เี รานํามาใชใ นการเลอื กวา เราจะประมวลผลอะไรตามผลลพั ธที่เกดิ ขึ้น if มีรปู แบบดังนี้ คือ


เรม่ิ ตนการเขยี นโปรแกรมดวย Java intro. to Java (FEU.faa) if(expression) statement; โดยมขี อกาํ หนดวา expression จะตอ งเปนประโยคทเี่ มอ่ื มกี ารประมวลผลแลว จะไดค าท่เี ปน boolean ซงึ่ เปนไปไดเพียงแคสองคา คอื จรงิ (true) หรือเท็จ (false) เทานัน้ เชน if(numberOfStudents >= 500) entranceExam = true; หรอื if(number < 0) number *= 10; number++; ถา คา ของ expression เปน จรงิ ประโยคที่ตามหลงั if จะถูกประมวลผล แตถ า เปน เท็จกจ็ ะไมถูก ประมวลผล เชนตวั อยางทีเ่ หน็ ดานบนนี้ ถา คา ของ number < 0 เปนจรงิ ประโยค number *= 10 ก็ จะไดร บั การประมวลผล ภาพท่ี 3-1 แสดงถงึ ขน้ั ตอนของการประมวลผลดว ยการใช if กับประโยคใน รูปแบบท่ัวไป และประโยคการเปรยี บเทียบ number ทไี่ ดก ลา วถงึ กอ นหนา น้ี if(expression) statement; other_statement; เปนจรงิ ? no number no <0 yes yes statement number *= 10; other_statement number++; ภาพที่ 3-1 การใชประโยค if ในบางครัง้ เราก็อาจเขียนประโยค if ใหเ ปน รปู แบบทีอ่ ยูในบรรทัดเดียวกัน เชน ถา เราเปลีย่ นประโยค ตวั อยา งกอนหนา น้ีใหอยูใ นบรรทัดเดียวกนั เรากจ็ ะได if(number < 0) number *= 10; number++; ซ่ึงถกู ตองตามหลักไวยากรณข อง Java แตโ ดยทว่ั ไปแลว การข้นึ บรรทดั ใหมส ําหรับประโยคที่ตามมา หลงั จากการเปรยี บเทียบส้ินสุดลง จะทําใหดู code ไดง ายขน้ึ ลองดโู ปรแกรมตวั อยางการตรวจสอบ วา ตวั เลขที่ user ใสเ ขาสูโปรแกรมเปน เลขคูหรอื ไม 1: /** 2: Using if-statement to determine if a number is even 3: */ 4: 5: import java.util.Scanner; 6: import static java.lang.System.out; 7: 8: class IfStatement { 9: public static void main(String[] args) { 76


บทท่ี 3: การตดั สนิ ใจ และการประมวลผลแบบวน intro. to Java (FEU.faa) 10: Scanner input = new Scanner(System.in); 11: 12: //get an integer 13: out.print(\"Enter a number: \"); 14: int number = input.nextInt(); 15: 16: //check if number is even 17: if(number % 2 == 0) 18: out.println(number + \" is an even number.\"); 19: } 20: } โปรแกรม IfStatement.java บอก user ใหใสต วั เลขหนึง่ ตวั ซ่ึงโปรแกรมไดจดั เก็บไวใ นตัวแปรช่ือ number หลังจากนนั้ ก็ทาํ การตรวจสอบวาตัวเลขทอ่ี านมาเปน เลขคูหรือไมด ว ยประโยค if(number % 2 == 0) out.println(number + \" is an even number.\"); ซง่ึ ถา นาํ สองไปหาร number แลวไมม ีเศษ (หารลงตวั ) แสดงวาตัวเลขท่วี า น้เี ปน เลขคู ซง่ึ โปรแกรม ก็จะแสดงขอความไปยงั หนา จอบอกผูใชว า ตัวเลขทีใ่ สเขา มาเปน เลขคู ดงั เชน ผลลัพธข องการ run นี้ Enter a number: 45 Enter a number: 20 20 is an even number. โปรแกรมของเรายังไมใ ชโ ปรแกรมที่สมบรณู  ดงั จะเหน็ ไดจากผลลพั ธท ี่ได ถา เราใส 45 โปรแกรมก็ จะไมแ สดงอะไรเลย จะแสดงกต็ อเมอ่ื ตวั เลขทีใ่ สเปน เลขคูเ ทานัน้ เราจะกลับมาดูวา เราตองทาํ อยางไร ถงึ จะสามารถทีจ่ ะแสดงขอความไปยงั หนา จอโดยแบง แยกวาตวั เลขนั้นเปน เลขคูห รอื เลขคี่ 3.1.2 การใช if ในประโยคที่มีมากกวาหนึ่งประโยค (if – block) การเขยี น code ทีม่ มี ากกวา หน่งึ ประโยคน้ัน ทาํ ไดดว ยการใชเ ครื่องหมาย {} ลอ มรอบประโยค เหลานนั้ (compound statement) ดังตัวอยางทเี่ หน็ นี้ if(expression) { statement 1; statement 2; statement 3; … statement n; } เชน if(number % 2 == 0) { System.out.println(number + \" is an even number.\"); number++; System.out.println(\"But \" + number + \" is not!\"); } ทนี ี้เราจะกลับไปยงั ประเด็นท่ีเราพูดถงึ กอนหนา นี้ เกย่ี วกับเร่ืองของการแสดงผลท้ังท่เี ปน จริง และไม เปนจริง ในการตรวจสอบดวยการใช if น้ันเราสามารถทจี่ ะบังคับการประมวลผลใหเ กิดขน้ึ ทั้งท่ีเปน จรงิ และเปน เท็จ อยางใด อยางหนึ่งดว ยการใช else ตามหลงั ประโยคท่ตี าม if มาอกี ทหี น่ึง รปู แบบโครงสรางของประโยค if – else นี้มีดงั นี้ if(expression) statement; else other_statement; another_statement; ภาพท่ี 3-2 แสดงถึงโครงสรา งของ if – else 77


เรม่ิ ตน การเขยี นโปรแกรมดวย Java yes เปน จรงิ ? no intro. to Java (FEU.faa) statement other_statement another_statement ภาพท่ี 3-2 การใช if - else จากโปรแกรม IfStatement.java ถาเราตองการท่จี ะแสดงผลถา ตวั เลขที่ user ใสเ ขา สูโปรแกรมเปน เลขค่ี เราก็ตองเปลี่ยน code ของเราใหเปนดังนี้ 1: /** 2: Using if - else statement to find 3: out whether a number is odd or even 4: */ 5: 6: import java.util.Scanner; 7: import static java.lang.System.out; 8: 9: class IfElse { 10: public static void main(String[] args) { 11: Scanner input = new Scanner(System.in); 12: 13: //get an integer 14: out.print(\"Enter a number: \"); 15: int number = input.nextInt(); 16: 17: //check if number is even or odd 18: if(number % 2 == 0) 19: out.println(number + \" is an even number.\"); 20: else 21: out.println(number + \" is an odd number.\"); 22: } 23: } ประโยคที่เราไดเขียนเพมิ่ เขาสโู ปรแกรมของเรา คอื else out.println(number + \" is an odd number.\"); ซ่ึงจะทําใหโปรแกรมของเราทําการประมวลผลประโยคที่อยถู ัดมาจาก else ถา number % 2 == 0 เปน เท็จ และตวั เลขทจี่ ะทําใหประโยคนถี้ ูกประมวลผลก็คือ ตัวเลขทเ่ี ปน เลขค่ี (นํา 2 ไปหารแลว เหลือเศษ) ลองดูผลลพั ธของการ run นี้ Enter a number: 45 45 is an odd number. Enter a number: 80 80 is an even number. 78


บทที่ 3: การตัดสินใจ และการประมวลผลแบบวน จะเหน็ วาการนําเอา if – else มาใชท าํ ใหโปรแกรมของเราสนองตอบความตองการในการแสดงผล intro. to Java (FEU.faa) เมอ่ื การตรวจสอบไดผลท่เี ปนจริงทางหนึ่ง และเมื่อผลของการตรวจสอบเปนเทจ็ อกี ทางหน่งึ เน่อื งจาก if – else ก็เปน statement ตวั หนงึ่ ดังน้ันเรากส็ ามารถที่จะนาํ เอา if – else ไปใสไวใ น ประโยคทเี่ ปน if – else อีกประโยคหน่งึ ได หรือแมแ ตก ระทั่งหลาย ๆ ประโยค เราเรยี กประโยคทีใ่ ช if – else แบบนี้วา Nested – if ซ่งึ มรี ูปแบบโครงสราง ที่มลี ักษณะคลา ย ๆ กบั ทเ่ี หน็ นี้ (อาจมี ประโยค if – else มากกวา หรือนอ ยกวา) if(expression 1) { หรอื if(expression 1) { statement 1; statement 1; statement 2; statement 2; } else } else if(expression 2) if(expression 2) statement 3; statement 3; else { else { statement 4; statement 4; statement 5; statement 5; } } จากโครงสรางตวั อยางดานบนนปี้ ระโยคทจ่ี ะไดร บั การประมวลผลถา expression 1 เปนจริงคือ statement 1 และ statement 2 สว น statement 3 จะไดร ับการประมวลผล ถา expression 2 เปน จรงิ และ statement 4 และ statement 5 จะไดร บั การประมวลผลกต็ อเมอ่ื expression 1 และ expression 2 เปน เท็จ ลองมาดโู ปรแกรมตัวอยางการใช Nested – if ในโปรแกรม Grades.java 1: /** 2: Using Nested - if 3: finding letter grade from a given score 4: */ 5: 6: import java.util.Scanner; 7: import static java.lang.System.out; 8: 9: class Grades { 10: public static void main(String[] args) { 11: Scanner input = new Scanner(System.in); 12: int score; 13: char grade; 14: 15: //getting a score 16: out.print(\"Enter your score: \"); 17: score = input.nextInt(); 18: 19: //determine grade by given score 20: if(score >= 90) 21: grade = 'A'; 22: else if(score >= 80) 23: grade = 'B'; 24: else if(score >= 70) 25: grade = 'C'; 26: else if(score >= 60) 27: grade = 'D'; 28: else 29: grade = 'F'; 30: 31: out.printf(\"Your grade is %c%n\", grade); 32: } 33: } โปรแกรม Grades.java ใชเกณฑการใหเกรดคอื ถา score มีคา มากกวา หรอื เทากับ 90 ได A มากกวา หรือเทากับ 80 ได B (อยรู ะหวา ง 80 ถึง 89) 79


เรม่ิ ตน การเขยี นโปรแกรมดว ย Java intro. to Java (FEU.faa) มากกวา หรอื เทากบั 70 ได C (อยรู ะหวาง 70 ถึง 79) มากกวาหรอื เทากบั 60 ได D (อยรู ะหวา ง 60 ถึง 69) ตา่ํ กวา 60 ได F เราไดอ อกแบบใหการตรวจสอบเปน ไปไดท ุกกรณดี ว ยการใชการเปรยี บเทียบจาก 90 ลงไปถงึ 60 ตามขน้ั ตอน คอื ถา user ใส score ที่มีคาเทา กบั 75 การเปรียบใน if แรก และ if ท่สี องจะเปน เท็จ แตจะมาเปน จริงใน if ทส่ี ามคอื score >= 70 ประโยคท่ีตามมา grade = 'C' ก็จะไดรับการ ประมวลผล สวนในกรณีสุดทา ยนน้ั ประโยค grade = 'F' จะไดรับการประมวลผลกต็ อเม่อื ทุก ๆ กรณี ของการตรวจสอบกอ นหนานี้เปนเท็จทั้งหมด ผอู า นควรตรวจสอบประโยค if – else จากตวั อยางดว ย คา score ทแี่ ตกตา งกนั เพื่อใหเกิดความเขา ใจมากย่งิ ขน้ึ ผลลพั ธของการ run ดว ยขอ มลู บางสว น Enter your score: 87 Your grade is B Enter your score: 45 Your grade is F Enter your score: 92 Your grade is A เราสามารถทจี่ ะเขียนโปรแกรม Grades.java ขน้ึ ใหมด วยการใช operator && ชวยในการตรวจสอบ ถงึ สถานะภาพของ score วาอยใู นกลุมใด ลองมาดกู นั 1: /** 2: Using Nested - if 3: finding letter grade from a given score 4: */ 5: 6: import java.util.Scanner; 7: import static java.lang.System.out; 8: 9: class Grades2 { 10: public static void main(String[] args) { 11: Scanner input = new Scanner(System.in); 12: int score; 13: char grade; 14: 15: out.print(\"Enter your score: \"); 16: score = input.nextInt(); 17: 18: //determine grade by given score 19: if(score >= 60 && score <= 69) 20: grade = 'D'; 21: else if(score >= 70 && score <= 79) 22: grade = 'C'; 23: else if(score >= 80 && score <= 89) 24: grade = 'B'; 25: else if(score >= 90 && score <= 100) 26: grade = 'A'; 27: else 28: grade = 'F'; 29: 30: out.println(\"Your grade is \" + grade); 31: } 32: } เราเปลีย่ น code ในการตรวจสอบใหมใหเ ปน if(score >= 60 && score <= 69) grade = 'D'; else if(score >= 70 && score <= 79) grade = 'C'; else if(score >= 80 && score <= 89) grade = 'B'; else if(score >= 90 && score <= 100) grade = 'A'; 80


บทที่ 3: การตัดสินใจ และการประมวลผลแบบวน intro. to Java (FEU.faa) else grade = 'F'; ซ่งึ เมอื่ ไดลอง run ดแู ลว ก็ไดผ ลลัพธเ หมือนกันกบั ทีไ่ ดจากโปรแกรม Grades.java แตขนั้ ตอนของ การตรวจสอบไมเหมือนกนั เราไดพดู กอ นหนา น้วี า ถา มีการใช && และคาของประโยคท่อี ยูทางดาน หนา ของ && มคี า เปนจริง ประโยคทอี่ ยทู างดา นหลังกจ็ ะไดรับการประมวลผลดวย 3.1.3 การใช enum กบั if-else เราสามารถนําเอา enum มาใชกบั โปรแกรมตัวอยา งทเ่ี ราใช if-else กอ นหนา นี้ได ดงั น้ี 1: /** 2: Using Nested - if and enum 3: finding letter grade from a given score 4: */ 5: 6: import java.util.Scanner; 7: import static java.lang.System.out; 8: 9: enum Grade {A, B, C, D, F}; 10: 11: class GradesWithEnum { 12: public static void main(String[] args) { 13: Scanner input = new Scanner(System.in); 14: int score; 15: Grade grade; 16: 17: out.print(\"Enter your score: \"); 18: score = input.nextInt(); 19: 20: //determine grade by given score 21: if(score >= 60 && score <= 69) 22: grade = Grade.D; 23: else if(score >= 70 && score <= 79) 24: grade = Grade.C; 25: else if(score >= 80 && score <= 89) 26: grade = Grade.B; 27: else if(score >= 90 && score <= 100) 28: grade = Grade.A; 29: else 30: grade = Grade.F; 31: 32: out.println(\"Your grade is \" + grade); 33: } 34: } เราประกาศในบรรทดั ที่ 8 กําหนดให Grade เปน enum มีคา เปน A, B, C, D, และ F ภายในตัว main() เราสรางตวั แปร grade จาก Grade ดงั นน้ั เราจึงสามารถกาํ หนดคา ให grade ในบรรทดั ท่ี 28, 30, 32, 34, และ 35 ได ผลลพั ธท่เี ราไดจ ากการ run โปรแกรมก็เหมอื นกับโปรแกรม Grades2.java โปรแกรมตอไปนี้ เปน โปรแกรมการใช if-else ตรวจสอบวา ตวั อักษรที่กําหนดใหอยใู นกลมุ นนั้ ๆ หรือไม 1: /** 2: Using && in if - else statement 3: */ 4: 5: import static java.lang.System.out; 6: 7: class UpperLower { 8: public static void main(String[] args) { 9: char ch = 'F'; 10: 11: if(ch >= 'A' && ch <= 'Z') 12: out.printf(\"%c is an uppercase letter.\", ch); 13: else if(ch >= 'a' && ch >= 'z') 14: out.printf(\"%c is a lowercase letter.\", ch); 15: } 16: } 81


เร่ิมตน การเขียนโปรแกรมดว ย Java intro. to Java (FEU.faa) โปรแกรมกําหนดใหตัวแปร ch มีคาเปนอกั ษร F ตัวใหญ และใชประโยค if – else ทาํ การตรวจสอบ วาตัวอักษรที่วาน้ีเปน อักษรตวั ใหญห รอื ตวั เล็ก ซึง่ ก็แนนอนวาผลลัพธท ีไ่ ดจ ะตองเปนตัวใหญ แตเ รา ตองการทีจ่ ะแสดงใหเ ห็นถึงการใช && เขา มาชว ยในการตรวจสอบคา ของ ch ที่เราไดกําหนดข้ึน ในการเปรียบเทยี บนัน้ Java จะใชค า ASCII ในการเปรยี บเทยี บตวั อกั ษรทัง้ สองตัว โดยในตอนแรก จะเปรียบเทยี บ F กับ A (70 กับ 65) ซึ่งผลของการเปรยี บเทยี บเปนจริง จึงตองเปรียบเทียบ F กบั Z (70 กับ 90) ซึง่ ก็เปน จริง ดงั นัน้ ประโยคท่ตี ามมา out.printf(\"%c is an uppercase letter.\", ch); จงึ ไดรับการประมวลผล เชน เดียวกันกับตัวอกั ษรตัวเลก็ ถา ch เก็บอกั ษรที่เปน ตวั เลก็ อยกู าร เปรยี บเทียบจะเกิดขนึ้ ในประโยค else – if ที่ตามมา โปรแกรมตอไปนแ้ี สดงการใช || ในการตรวจสอบวา เดือนทก่ี ําหนดใหอยูในฤดอู ะไร 1: /** 2: Using || in if - else statement 3: */ 4: 5: import static java.lang.System.out; 6: import java.util.Scanner; 7: 8: class Season { 9: public static void main(String[] args) { 10: int month; 11: String season; 12: Scanner input = new Scanner(System.in); 13: 14: out.print(\"Enter month (1 - 12): \"); 15: month = input.nextInt(); 16: 17: if(month == 3 || month == 4 || month == 5 || month == 6) 18: season = \"Summer\"; 19: else if(month == 7 || month == 8 || month == 9 || month == 10) 20: season = \"Rainy\"; 21: else if(month == 11 || month == 12 || month == 1 || month == 2) 22: season = \"Winter\"; 23: else 24: season = \"neverland!!\"; 25: 26: out.printf(\"%d is in %s\", month, season); 27: } 28: } โปรแกรม Season.java ใช || ในการตรวจสอบวา month ท่ี user ใสเ ขา สโู ปรแกรมน้นั อยูใ นฤดู อะไร โดยเรากําหนดใหเ ดอื น 3 – 6 เปนฤดรู อ น 7 – 10 เปนฤดูฝน และ 11 – 2 เปน ฤดูหนาว (ซึ่ง เดยี วน้ชี กั จะไมแนน อนเสยี แลว ) ลองมาดผู ลลพั ธจ ากการ run ดกี วา Enter month (1 – 12): 4 4 is in Summer Enter month (1 – 12): 8 8 is in Rainy Enter month (1 – 12): 1 1 is in Winter Enter month (1 – 12): 20 20 is in neverland!! Operator || น้ันเปน การเปรยี บเทียบขอมูลท่ีอาจเปนไดห ลาย ๆ อยา ง ดังทเ่ี ห็นในโปรแกรม ถาเรา ใหคาของ month เปน 3 4 5 หรือ 6 เราก็กําหนดให season มคี า เปน summer สว นเดือนอื่น ๆ ก็ เชน เดียวกนั ในทางตรงกนั ขามถา เราใช && แทนโปรแกรมของเราก็จะไมทาํ งานตามทเ่ี ราคาดหวัง ไว กลา วคอื คา ของ month ไมส ามารถเปนไปไดท ้งั สค่ี า โปรแกรมก็จะประมวลผลประโยคทตี่ าม else ตัวสุดทายตลอดไป ผูอ า นควรตรวจสอบวาทกี่ ลา วมาน้ี เปนจรงิ หรอื ไม 82


บทที่ 3: การตดั สนิ ใจ และการประมวลผลแบบวน intro. to Java (FEU.faa) ในการใช Nested if – else นน้ั เราจะตอ งระวังวาทกุ ๆ if ท่ีเราใชจ ะตอ งมี else หรือไมเพราะ Java จะตรวจสอบวา else ทใ่ี ชนนั้ วามี if อยกู อ นหนาหรอื ไม สมมตวิ า มีเรากต็ องระวังในเรอ่ื งของขนั้ ตอน การตรวจสอบ วาเปนไปอยา งท่ีเราตั้งใจหรอื ไม ดังเชนตวั อยา งน้ี 1: /** 2: Dangling Else 3: */ 4: 5: import static java.lang.System.out; 6: 7: class DanglingElse { 8: public static void main(String[] args) { 9: int x = 7, y = 99; 10: 11: if(x > 5) 12: if(y > 5) 13: out.println(\"x and y is greater than 5\"); 14: else 15: out.println(\"x is less than 5\"); 16: } 17: } โปรแกรม DanglingElse.java ท่เี ห็นนี้เมื่อ run แลว ผลลัพธท ี่ไดค อื x and y is greater than 5 ซง่ึ เปนไปตามทเ่ี ราคดิ ไว แตถ า เราเปลยี่ นคา ของ y ใหเปน 2 ผลลพั ธท่ีไดกลับเปน x is less than 5 ซึ่งไมใ ชส ิง่ ทเ่ี ราตอ งการ เพราะเรารูวา x มคี า มากกวา 5 ส่งิ ท่เี กิดข้ึนคอื Java จัดให else นัน้ คูก ับ if ตวั ท่สี อง ดังนี้ if(x > 5) if(y > 5) out.println(\"x and y is greater than 5\"); else out.println(\"x is less than 5\"); เพราะฉะน้ันถา เราตองการใหการประมวลผลเปน ไปตามที่เราตอ งการ เราตองใช {} เปน ตวั ชว ย ดังนี้ if(x > 5) { if(y > 5) out.println(\"x and y is greater than 5\"): } else out.println(\"x is less than 5\"); ซง่ึ เมอ่ื run ดแู ลว ก็จะไดผลลัพธเปนไปตามทีเ่ ราตองการ คือ ไมมผี ลลพั ธใด ๆ แสดงไปยงั หนาจอ ถา y มีคา นอ ยกวา หรือเทา กับ 0 ถงึ เวลาท่เี ราจะกลบั ไปปรับปรุงโปรแกรม Quadratic.java ทเี่ ราไดพ ูดถึงในบทที่สอง เพ่ือใหม ีการ ตรวจสอบคาของ determinant ท่ีอาจเปน 0 ดวยการใช if ในประโยค //calculate determinant double d = b * b – 4 * a * c; if(d <= 0) { err.println(\"Error: cannot find square root\"); System.exit(1); } double det = Math.sqrt(d); เราไดก ําหนดใหมีการตรวจสอบคา ของ d กอนการเรยี กใช Math.sqrt() ถา คา ของ d นอยกวา หรอื เทากับ 0 เราจะฟองไปยัง user พรอมกับยตุ ิการทํางานของโปรแกรมทันที ดว ยการเรียกใช System.exit(1) 83


เรมิ่ ตน การเขยี นโปรแกรมดว ย Java intro. to Java (FEU.faa) 1: /** 2: Calculating roots of function 3: */ 4: 5: import static java.lang.System.out; 6: import static java.lang.System.err; 7: 8: class Quadratic2 { 9: public static void main(String[] args) { 10: double a, b, c; 11: //4x2 + 20x + 16 = 0 12: a = 4; 13: b = 20; 14: c = 16; 15: 16: //calculate determinant 17: double d = b * b - 4 * a * c; 18: if(d <= 0) { 19: err.println(\"Error: cannot find square root\"); 20: System.exit(1); 21: } 22: double det = Math.sqrt(d); 23: 24: //calculate roots 25: double x1 = (-b + det) / (2 * a); 26: double x2 = (-b - det) / (2 * a); 27: 28: out.println(\"Root 1 = \" + x1); 29: out.println(\"Root 2 = \" + x2); 30: } 31: } 3.2 การใช Conditional Operator (? :) Java มี operator อกี ตวั หนึ่งทเี่ ราสามารถนํามาใชแ ทน if – else ได เราเรยี ก operator ตัวน้ีวา Conditional operator หรอื operator ทมี่ ี expression อยสู ามตัว ซ่งึ มโี ครงสรา งดงั นี้ คือ (expression) ? (true statement) : (false statement); เชน (number % 2 == 0) ? System.out.println(\"Even number.\") : System.out.println(\"Odd number.\"); จากประโยคตวั อยางดานบนน้ี การประมวลผลประโยค System.out.println(\"Even number.\"); จะ เกิดข้นึ ถาผลลพั ธของการประมวลผลประโยค number % 2 == 0 เปนจริง สว นประโยค System.out.println(\"Odd number.\"); จะเกิดข้นึ ถาการประมวลผลของประโยค number % 2 == 0 เปน เท็จ โดยหลกั การแลวการประมวลผลประโยคทอ่ี ยูถ ัดจากเคร่ืองหมาย '?' จะไดรบั การประมวลผลถา ประโยคเปรียบเทียบเปนจรงิ และประโยคที่ตามหลังเครือ่ งหมาย ':' จะไดรับการประมวลถาประโยค เปรียบเทยี บเปนเท็จ ลองดโู ปรแกรมตัวอยางกัน 1: /** 2: Finding odd and even number 3: */ 4: 5: import static java.lang.System.out; 6: 7: class OddEven { 8: public static void main(String[] args) { 9: int num; 10: String result = \"\"; 11: 84


บทท่ี 3: การตดั สนิ ใจ และการประมวลผลแบบวน 12: num = (int)(Math.random() * 100); intro. to Java (FEU.faa) 13: 14: result = (num % 2 == 0) ? \"even\" : \"odd\"; 15: 16: out.println(num + \" is an \" + result + \" number.\"); 17: } 18: } โปรแกรม OddEven.java ใช operator ? : ในการตรวจสอบวา num เปนเลขคหู รือ เลขคี่ ซึง่ ถาเปน อยา งใดอยางหนึง่ กจ็ ะเกบ็ ขอมูลนั้น (even หรอื odd) ไวในตัวแปร result แลว จึงแสดงผลไปยัง หนาจอหลังจากนน้ั ดังตวั อยางผลลพั ธของการ run น้ี 65 is an odd number. โปรแกรม Min.java ท่เี ห็นดานลา งนใี้ ช operator ? : ในการหาคาตวั เลขทน่ี อ ยทีส่ ุดระหวางเลขสอง ตัวทีก่ าํ หนดให 1: /** 2: Finding minimum number 3: */ 4: 5: import java.io.*; 6: import static java.lang.System.out; 7: import static java.lang.System.err; 8: 9: class MinNumber { 10: public static void main(String[] args) throws IOException { 11: if(args.length <= 0) { 12: err.println(\"No arguments supplied.\"); 13: System.exit(1); 14: } 15: int num1 = Integer.parseInt(args[0]); 16: int num2 = Integer.parseInt(args[1]); 17: 18: //if num1 < num assign num1 to min 19: //otherwise assign num2 to min 20: int min = (num1 < num2) ? num1 : num2; 21: 22: out.println(\"Minimum number is: \" + min); 23: } 24: } ผลลัพธท่ไี ดจ ากการ run คือ D:\\source>java MinNumber 23 45 Minimum number is: 23 การใช operator ? : ก็คอื การใช if – else น่นั เองดังนั้นก็เปนเรอ่ื งของผเู ขียนโปรแกรมเองวา อยากท่ี จะใช operator ตวั ไหน เพราะทั้งสองใหผ ลการประมวลผลในลักษณะเดียวกนั แตผ อู านควรคํานึงถงึ ความชัดเจนของการใช operator ตวั น้ี ถา ใชแลวทาํ ใหเ ขา ใจคอนขา งยากกไ็ มควรใช เชน ตวั อยา ง การใชแบบน้ี grade = score > 89 ? (score > 94 ? \"A+\" : \"A\") : score > 79 ? (score > 84 ? \"B+\" : \"B\") : score > 69 ? (score > 74 ? \"C+\" : \"C\") : score > 59 ? (score > 64 ? \"D+\" : \"D\") : จาก code ของการหาเกรดจากคะแนนทเ่ี ห็นน้ี ผอู านคงสงั เกตเห็นความซบั ซอนของ code เมอื่ นาํ ไป เปรยี บเทียบกบั การคาํ นวณหาเกรดดว ยการใช if – else กอนหนาน้ี ยิง่ ถามกี ารเปรยี บเทยี บมาก เทา ไร การมองดู code กย็ ากตามไปดวย ที่เหน็ ดา นลา งน้คี อื code ทัง้ หมดจากโปรแกรม 1: /** 2: conditional operator 3: How confuse can it be? 4: */ 5: 6: import javax.swing.*; 85


เรม่ิ ตน การเขยี นโปรแกรมดวย Java intro. to Java (FEU.faa) 7: 8: class GradeCond { 9: public static void main(String[] args) { 10: String grade = \"\"; 11: int score; 12: 13: //get score from dialog box 14: String in = JOptionPane.showInputDialog(\"Enter your score.\"); 15: score = Integer.parseInt(in); 16: 17: //compute a letter grade from score 18: grade = score > 89 ? (score > 94 ? \"A+\" : \"A\") : 19: score > 79 ? (score > 84 ? \"B+\" : \"B\") : 20: score > 69 ? (score > 74 ? \"C+\" : \"C\") : 21: score > 59 ? (score > 64 ? \"D+\" : \"D\") : \"F\"; 22: 23: //display result via message dialog 24: String msg = \"Score \" + score + 25: \" is equivalent to grade \" + grade; 26: JOptionPane.showMessageDialog(null, msg, 27: \"Grade\", 28: JOptionPane.INFORMATION_MESSAGE); 29: } 30: } ผลลัพธท่ไี ดจาการ run คอื ลองมาดูโปรแกรมตัวอยางการใช ? : อีกตัวอยา งหนึ่งทไี่ ดด ดั แปลงมาจากโปรแกรม Season.java ท่ไี ดเขียนมากอนหนา นี้ 1: /** 2: Determine season from given months 3: */ 4: 5: import java.io.*; 6: import java.lang.Integer; 7: import javax.swing.JOptionPane; 8: 9: class SeasonCond { 10: public static void main(String[] args) { 11: int month; 12: String season, input, monthTitle; 13: 14: //prompt user for month (1 - 12) 15: //if user hit cancel button, assign 0 to month 16: input = JOptionPane.showInputDialog(\"Enter month (1 - 12).\"); 17: month = (input != null) ? Integer.parseInt(input) : 0; 18: 19: //determine season from a given month 86


บทท่ี 3: การตดั สนิ ใจ และการประมวลผลแบบวน intro. to Java (FEU.faa) 20: season = (month >= 11) ? \"Winter\" : 21: (month >= 7) ? \"Rainy\" : 22: (month >= 3) ? \"Summer\" : \"Unknown\"; 23: 24: //determine month's title from month number 25: monthTitle = (month == 1) ? \"January\" : 26: (month == 2) ? \"February\" : 27: (month == 3) ? \"March\" : 28: (month == 4) ? \"April\" : 29: (month == 5) ? \"May\" : 30: (month == 6) ? \"June\" : 31: (month == 7) ? \"July\" : 32: (month == 8) ? \"August\" : 33: (month == 9) ? \"September\" : 34: (month == 10) ? \"October\" : 35: (month == 11) ? \"November\" : 36: (month == 12) ? \"December\" : \"Unknown\"; 37: 38: //display result 39: JOptionPane.showMessageDialog(null, 40: \"Month \" + month + \" (\" + monthTitle + \" )\" + 41: \" is in \" + season + \" season.\", 42: \"Season\", 43: JOptionPane.INFORMATION_MESSAGE); 44: 45: System.exit(0); 46: } 47: } โปรแกรม SeasonCond.java ใช ? : ในการตรวจสอบและกาํ หนดคา ใหก บั ตวั แปร moth (บรรทัด ท่ี 21 ถึง 23) พรอ มทง้ั ทําการกําหนดชือ่ ของเดือนใหก บั ตวั เลขประจาํ เดอื นที่ user ไดใ สเ ขา สู โปรแกรมดว ย (บรรทดั ท่ี 25 ถงึ 37) โปรแกรมตัวอยา งนี้ ถึงแมว า ใช ? : เยอะมากกไ็ มดูสบั สนเทาไร ตา งกบั โปรแกรมท่คี าํ นวณหาเกรด กอนหนานี้ ผลลพั ธท เี่ ราไดจาการ run คอื 87


เริ่มตนการเขยี นโปรแกรมดว ย Java intro. to Java (FEU.faa) 3.3 การใชค าํ สง่ั switch Java มคี ําส่งั อีกตวั หนึง่ ทเ่ี ราสามารถนาํ มาใชแ ทน if – else ได คําสัง่ นี้กค็ ือ switch ซ่งึ มีโครงสรา ง ดังนี้ switch(expression) { case value1 : statement; break; case value2 : statement; break; … default : statement; break; } คา ทไ่ี ดจ าก expression ของ switch นัน้ จะตองเปนคา ท่มี ชี นิดเปน char byte short หรอื int เทาน้นั ถา เปน คา ชนดิ อนื่ Java จะฟองดวย error ทนั ที ภาพที่ 3-3 แสดงถึงขัน้ ตอนการทาํ งานของ switch เปน จริง? yes break no statement break ทําคาํ สัง่ อืน่ ๆ เปนจริง? yes statement ในโปรแกรม no break default ภาพที่ 3-3 ขน้ั ตอนการทาํ งานของ switch คําสั่ง break ใน switch นน้ั สาํ คัญมาก ๆ ถา เราไมใส การทาํ งานของ switch กจ็ ะไมไดผลลพั ธด งั ที่ เราไดค าดการณไ ว 1: /** 2: Using switch statement 3: */ 4: 5: import java.io.*; 6: import javax.swing.JOptionPane; 7: 8: class Switch { 9: public static void main(String[] args) throws IOException { 10: int month; 11: String season, input; 12: 13: //getting month number from user 14: input = JOptionPane.showInputDialog(\"Enter month (1 - 12).\"); 88


บทที่ 3: การตัดสินใจ และการประมวลผลแบบวน intro. to Java (FEU.faa) 15: month = (input != null) ? Integer.parseInt(input) : 0; 16: 17: switch(month) { 18: //summer months 19: case 3: case 4: case 5: case 6: 20: season = \"summer\"; 21: break; 22: //rainy months 23: case 7: case 8: case 9: case 10: 24: season = \"rainy\"; 25: break; 26: //winter months 27: case 11: case 12: case 1: case 2: 28: season = \"winter\"; 29: break; 30: //not summer, rainy or winter months 31: default : 32: season = \"Unrecognized input!\"; 33: break; 34: } 35: 36: //display result 37: JOptionPane.showMessageDialog(null, 38: \"Month \" + month + 39: \" is in \" + season + \" season.\", 40: \"Season\", 41: JOptionPane.INFORMATION_MESSAGE); 42: 43: System.exit(0); 44: } 45: } เราไดท ําการเปลย่ี นแปลงโปรแกรม Season.java ท่ีใช if – else ใหมาใช switch แทน โดยเราได รวมเอาเดือนที่อยใู นฤดูเดียวกนั เหมอื นท่เี ราทํากับโปรแกรม Season.java มาอยใู นกลุมของ case เดียวกัน จะเห็นวา เราเขียน case ตาง ๆ ทอี่ ยูใ นกลุมเดียวกนั ตามหลังกันไปโดยไมม ีการประมวลผล ใด ๆ จนกวาจะจบ case สดุ ทา ยในกลมุ นั้น เชน case 3: case 4: case 5: case 6: season = \"summer\"; break; Java จะประมวลผล case 3 กอนแตเราไมม ปี ระโยคใด ๆ ใน case นด้ี งั นั้น Java จึงประมวลผล case 4 case 5 และจนกระทั่งมาถึง case 6 ซึ่งเปน case สุดทายในกลมุ Java จงึ ประมวลผลประโยค season = \"summer\" และ break การนาํ เอา case ตา ง ๆ มาตอกันในลกั ษณะนี้มผี ลเหมือนการประมวลผลดว ยการใช operator || ใน ประโยคทเ่ี รยี กใช if ผอู านควรสงั เกตถงึ การใช switch ในลักษณะน้ีใหดี เพราะเปน วิธีการท่ชี วยลด ข้นั ตอนการเขยี นไดดพี อสมควร เรามาลองดูตัวอยา งการใช switch อกี สักตัวหน่ึง 1: /** 2: Using switch statement 3: */ 4: 5: import java.io.*; 6: import javax.swing.JOptionPane; 7: 8: class Switch2 { 9: public static void main(String[] args) throws IOException { 10: int digit; 11: String input, result = \"\"; 12: 13: //getting a digit from user 14: input = JOptionPane.showInputDialog(\"Enter a digit:\"); 15: 16: try { 17: digit = Integer.parseInt(input); 18: switch(digit) { 89


เร่มิ ตน การเขียนโปรแกรมดว ย Java intro. to Java (FEU.faa) 19: case 1: result = \"You entered ONE.\"; 20: break; 21: case 2: result = \"You entered TWO.\"; 22: break; 23: case 3: result = \"You entered THREE.\"; 24: break; 25: case 4: result = \"You entered FOUR.\"; 26: break; 27: case 5: result = \"You entered FIVE.\"; 28: break; 29: case 6: result = \"You entered SIX.\"; 30: break; 31: case 7: result = \"You entered SEVEN.\"; 32: break; 33: case 8: result = \"You entered EIGHT.\"; 34: break; 35: case 9: result = \"You entered NINE.\"; 36: break; 37: case 0: result = \"You entered ZERO.\"; 38: break; 39: } 40: //display result 41: JOptionPane.showMessageDialog(null, result, 42: \"What Digit\", JOptionPane.INFORMATION_MESSAGE); 43: } 44: catch(Exception e) { 45: JOptionPane.showMessageDialog(null, \"You chose to cancel or ERROR occurred!\", 46: \"Cancel or Error\", JOptionPane.ERROR_MESSAGE); 47: } 48: System.exit(0); 49: } 50: } โปรแกรม Switch2.java บอก User ใหใสต วั เลขระหวา ง 0 – 9 และจะแสดงตวั หนังสือแทนตวั เลข เหลา น้นั กลับไปยงั หนาจอ ซง่ึ เมื่อ run แลวกจ็ ะไดผ ลลัพธด งั นี้ แตถา ขอมูลนําเขา ไมเปนไปตามทเี่ ราไดกําหนดไวในโปรแกรม หนาจอท่ีเราไดจ ะเปน เราไดพ ูดกอนหนา นวี้ า การใส break ไวในแตละ case ของ switch นั้นสาํ คญั มาก ๆ ในการกาํ หนด ข้นั ตอนของการประมวลผล เพอื่ ใหผ ูอ านไดเหน็ ภาพชัดข้ึนเราจะลบคําสัง่ break ทุกตวั ออกจาก โปรแกรม Switch2.java เราก็จะไดหนาจอท่ีแสดงผลลัพธท ีใ่ นบรรทัดสดุ ทายเสมอ นัน่ กค็ ือประโยค \"You entered ZERO\" ประโยคทกุ ประโยคทต่ี ามมาจาก case ทเ่ี ปนจริงจะถกู ประมวลผลท้งั หมด ดังนัน้ ไมวา เราจะใสขอมูล ณ ตาํ แหนง ไหน เราก็จะไดส วนประมวลผลทีเ่ กนิ มาเสมอ เพราะฉะน้นั ผูอา นจะตอ งระมดั ระวังเปน พเิ ศษในเร่ืองของการใส break ใหก บั case ตา ง ๆ ที่มอี ยูใ น switch 90


บทที่ 3: การตดั สนิ ใจ และการประมวลผลแบบวน intro. to Java (FEU.faa) 3.4 การทํางานแบบวน (Repetition หรือท่ีเรยี กกนั งา ยๆ วา Loop) หลาย ๆ ครั้งทโ่ี ปรแกรมเมอรตองการท่จี ะใหโปรแกรมทาํ การประมวลผลในรูปแบบเดมิ ซํา้ ๆ กนั เชน คณู ตวั เลข 1 – 10 ดวย 2 หรอื อา นขอมลู จาก keyboard จนกวา user จะพอใจ เราสามารถนําเอา ชดุ คาํ ส่งั ที่ Java มใี หม าใชก บั การทํางานทวี่ า น้ไี ดอยางไมย ากนกั ลองดโู ปรแกรมทที่ าํ การแสดงคา จาก 1 – 10 ไปยงั หนาจอน้ี 1: /** 2: Printing 1 to ten without using for/loop 3: */ 4: 5: import static java.lang.System.out; 6: 7: class NotAforLoop { 8: public static void main(String[] args) { 9: int number = 1; 10: 11: out.printf(\"Number now is %d\\n\", number++); 12: out.printf(\"Number now is %d\\n\", number++); 13: out.printf(\"Number now is %d\\n\", number++); 14: out.printf(\"Number now is %d\\n\", number++); 15: out.printf(\"Number now is %d\\n\", number++); 16: out.printf(\"Number now is %d\\n\", number++); 17: out.printf(\"Number now is %d\\n\", number++); 18: out.printf(\"Number now is %d\\n\", number++); 19: out.printf(\"Number now is %d\\n\", number++); 20: out.printf(\"Number now is %d\\n\", number++); 21: } 22: } แนน อนผลลัพธท ไี่ ดก ต็ องเปน Number now is 1 Number now is 2 Number now is 3 Number now is 4 Number now is 5 Number now is 6 Number now is 7 Number now is 8 Number now is 9 Number now is 10 การแสดงคา จาก 1 – 10 น้นั ยงั ไมม ีปญ หาอะไรมากมายนกั แตถ า เราตอ งการที่จะแสดงคา จาก 1 – 100 หรอื จาก 1 – 1000 เราคงตองพิมพจนมือเมอื่ ยแนเ ลย ลองมาดูวาเราจะใช loop ชวยในการ ทํางานในลกั ษณะนี้ไดอยา งไร Java มีโครงสรางหลายตัวทเี่ ราสามารถนาํ มาใชในการทาํ งานแบบวนได คาํ สง่ั ที่วา นี้ คือ while/loop, do..while/loop และ for/loop ชดุ คาํ สง่ั แรกทีเ่ ราจะดูกัน คือ for/loop 3.4.1 การใช for/loop กอนท่เี ราจะไปดโู ครงสรางของ for/loop กนั เรามาดกู ันวา โปรแกรมกอ นหนาน้ี ถา ใช for/loop แลว จะมีหนาตาเปนอยางไร 1: /** 2: Printing 1 to ten using for/loop 3: */ 4: 5: import static java.lang.System.out; 6: 7: class ForLoop { 8: public static void main(String[] args) { 9: int number = 1; 10: 11: //printing 1 - 10 using for/loop 91


เรม่ิ ตนการเขียนโปรแกรมดว ย Java intro. to Java (FEU.faa) 12: for(number = 1; number <= 10; number++) 13: out.printf(\"Number now is %d\\n\", number); 14: } 15: } จะเหน็ วาโปรแกรมของเราสัน้ ลงมาก คําส่งั ใน for/loop บอกให Java รูว า การประมวลผลตอ งทํา ทั้งหมด 10 ครงั้ โดยเร่ิมตนการประมวลผล เม่ือ number มคี า เทากับ 1 ไปจนกวา number จะมคี า เปน 10 ซึ่งเม่อื number มีคา เปน 10 Java ก็จะยตุ ิการประมวลผลทงั้ หมด และผลลพั ธทไ่ี ดก็ เหมือนกนั กับโปรแกรม NotAforLoop.java ทีเ่ ราเขยี นข้นึ มากอ นหนา น้ี โครงสรา งของ for/loop มีดังนคี้ ือ for(expression1 ; expression2 ; expression3) statement; โดยท่ี expression ทง้ั สามตัวมีการทํางานที่ตางกัน expression1 จะถกู ประมวลผลเปนตวั แรกสดุ ซ่ึง โดยทั่วไป expression น้ีมักจะถกู เรยี กวา initialization expression คอื ทําหนาทีใ่ นการกําหนดคา เบอื้ งตน ใหกบั ตัวแปรท่จี ะนาํ มาใชใ น for/loop หลงั จากนนั้ expression2 กจ็ ะถูกประมวลผล ซ่ึงถา การประมวลผลเปนจริงตามเงือ่ นไข statement ที่อยใู น for loop กจ็ ะถูกประมวลผล และ for/loop จะยตุ ิการทํางานทันทที ีก่ ารประมวลของ expression2 เปน เท็จ เมือ่ statement ทอี่ ยูใน for/loop สิ้นสดุ การประมวลผลแลว expression3 ก็จะไดร ับการประมวลผล และ for/loop จะกลับไป ประมวลผล expression2 อกี คร้งั ซงึ่ ถาเปน จรงิ statement กจ็ ะถกู ประมวลผลอีกครัง้ ทําอยางนีไ้ ป จนกวา expression2 จะเปนเท็จ เราเรียก expression2 วา loop condition และ expression3 วา increment expression ภาพที่ 3-4 แสดงแผนผังการทาํ งานของ for/loop expression1 expression2 no (จริง ?) yes statement expression3 statement อ่ืน ๆ ในโปรแกรม ภาพท่ี 3-4 โครงสรา ง (ขั้นตอน) การทาํ งานของ for/loop เรากลบั มาดโู ปรแกรม ForLoop.java ทเ่ี ราเขียนกอนหนา น้วี า มีการทํางานอยา งไร เราเริม่ ตน ดว ยการ เขยี น for/loop for(number = 1; number <= 10; number++) out.printf(\"Number now is %d\\n\", number); สิง่ ที่ Java ทาํ กอ นก็คอื กาํ หนดคาตวั แปร number ใหเ ปนหนงึ่ หลังจากนนั้ ก็ทาํ การตรวจสอบวาตวั แปร number มีคา นอ ยกวา หรือเทา กับสิบหรือไม ซง่ึ กเ็ ปน จรงิ ดงั นั้น Java จึงประมวลผลประโยคท่ี อยใู น for/loop เมื่อเสรจ็ แลวจงึ ไปประมวลผลประโยค number++ ซึ่งเปน การเพ่มิ คาใหก บั ตัวแปร number เสร็จแลว จึงกลบั ไปตรวจสอบวา number <= 10 อกี คร้ัง ทําไปเรือ่ ย ๆ จนกวา number จะ มคี า มากกวาสบิ จงึ จะยุตกิ ารทํางาน โดยสรปุ แลวขนั้ ตอนของ for/loop ดงั กลา วมีดงั นค้ี ือ 92


บทที่ 3: การตัดสินใจ และการประมวลผลแบบวน intro. to Java (FEU.faa) 1. กาํ หนดคา เบอ้ื งตน ใหกบั number 2. ตรวจสอบวา number <= 10 หรือไม ถา เปนจรงิ ประมวลผลประโยค System.out.println(\"Number now is \" + number); ถาเปนเทจ็ ยตุ กิ ารทํางานของ for/loop 3. ประมวลผลประโยค number++ 4. กลับไปทําคาํ สัง่ ในขอ สองใหม Expression ที่สําคัญที่สุดท่ีจะทาํ ให for/loop ทํางานตอ หรือยตุ ิการทาํ งานก็คือ expression ที่สอง ดงั น้ันในการใช for/loop เราจึงตอ งระมัดระวังถึงประโยคท่ีใชในการตรวจสอบวา สามารถทจี่ ะทําได ทงั้ สองกรณีหรือไม เพราะถา เราตรวจสอบไมด กี ารทํางานของ for/loop อาจทําไปโดยไมม ีการสนิ้ สุด หรอื ท่ีเรยี กวา Infinite loop ตวั อยา งเชน ถา เราเปลี่ยน for/loop ของเราใหเปน ดงั นี้ for(number = 1; number > 0; number++) System.out.println(\"Number now is \" + number); for/loop ใหมของเราก็จะทาํ งานโดยไมมีทส่ี ิ้นสุด เพราะวา คา ของ number จะมากกวา ศูนยอ ยู ตลอดเวลา ทาํ ใหป ระโยคของการตรวจสอบเปน จริงเสมอ การเขยี น for/loop ใหท าํ งานตลอดเวลาน้ันสามารถเขยี นไดหลายแบบ ตวั อยา งเชน int number = 1; for(;;) System.out.println(\"Number now is \" + number); เราให for/loop ทํางานไปเร่ือย ๆ ดว ยการยกเลิก expression ทั้งสามตัวทอ่ี ยใู น loop หรือยกเลกิ expression ที่หนึง่ และสาม ดงั นี้ int number = 1; for(;number > 0;) System.out.println(\"Number now is \" + number); ถาเราตองการ infinite loop ท่ไี มมปี ระโยคใด ๆ เลยก็ทําได ดังน้ี for( ; ;) ; เราลองมาดกู ารใช for/loop ในการบวกเลขจาก 1 ถึง 100 1: /** 2: Summation of 1 to n 3: */ 4: 5: import static java.lang.System.out; 6: import javax.swing.JOptionPane; 7: 8: class Add1To100 { 9: public static void main(String[] args) { 10: int total = 0; 11: int n = 100; 12: 13: //adding 1, 2, 3, ..., n 14: //save result in total 15: for(int i = 1; i <= n; i++) 16: total += i; 17: 18: JOptionPane.showMessageDialog(null, \"Total of 1 to \" + 19: n + \" is \" + total, 20: \"Summation\", JOptionPane.INFORMATION_MESSAGE); 21: } 22: } ผลลัพธของการ run คอื 93


เริ่มตน การเขยี นโปรแกรมดว ย Java ตัวอยา งโปรแกรมตอ ไปนี้ทําการคาํ นวณหาดอกเบยี้ ทบตนในแตล ะป เปนจํานวนเทา กบั จาํ นวนปท ่ี intro. to Java (FEU.faa) user เปน ผกู าํ หนดจากเงินฝากเรม่ิ ตน ท่ีหนง่ึ พนั บาท (หรอื เทา กบั จํานวนท่ี user เปนผใู สเขาสู โปรแกรม) โดยใชสตู รการในการคํานวณ คอื amount = p(1 + r)n โดยท่ี p คือ จาํ นวนเงินเรม่ิ ตน (principal) r คอื อตั ราดอกเบ้ียประจาํ ป n คือ จํานวนของปท ่ีตองการหา amount คือ เงนิ ตน ทนี่ ําฝากของทกุ ป 1: /** 2: Demonstrating for/loop on compound interests 3: */ 4: 5: import javax.swing.JOptionPane; 6: 7: class Interests { 8: public static void main(String[] args) { 9: double amount = 0;//amount at the end of year 10: double principal; //first deposit 11: double rate; //annual interests rate 12: int years; //number of years 13: String input; //input string 14: 15: //get input from user (principal, rate, years) 16: input = JOptionPane.showInputDialog(\"Enter principal\"); 17: principal = Double.parseDouble(input); 18: 19: input = JOptionPane.showInputDialog(\"Enter interests rate\"); 20: rate = Double.parseDouble(input); 21: 22: input = JOptionPane.showInputDialog(\"Enter number of years\"); 23: years = Integer.parseInt(input); 24: 25: //calculate interests 26: String result = \"\"; 27: String yAmount; 28: for(int y = 1; y <= years; y++) { 29: amount = principal * Math.pow(1.0 + rate, y); 30: yAmount = String.format(\"%2d%8c%.2f%n\", y, ' ', amount); 31: result += yAmount; 32: } 33: 34: //display output 35: String header = String.format(\"Year%5cAmount%n\", ' '); 36: JOptionPane.showMessageDialog(null, 37: header+result + \"\\nPrincipal: \" + 38: String.format(\"%.2f%n\", principal) + 39: \"Total interests: \" + 40: String.format(\"%.2f\", (amount-principal)), 41: \"Interests\", 42: JOptionPane.INFORMATION_MESSAGE); 43: } 44: } 94


บทที่ 3: การตัดสินใจ และการประมวลผลแบบวน ผลลัพธข องการ run ดวย principal = 10000 rate = 0.25 และ years = 5 สว นประกอบที่สําคญั คอื for/loop ท่ีทําหนา ทีค่ าํ นวณหาจํานวนเงินทไ่ี ดร บั ในแตล ะป (พรอมทง้ั intro. to Java (FEU.faa) ดอกเบ้ีย) เราใช method Math.pow() ในการหาคา ของดอกเบีย้ ในแตล ะป ซ่งึ เมอ่ื หาไดแลวเราก็ แสดงผลลพั ธไ ปยังหนา จอทันที for loop ของเรายตุ กิ ารประมวลผลเม่อื คาของตวั แปร y มีคา มากกวา ตวั แปร years หลังจากแสดงจาํ นวนของเงนิ ในแตล ะปแ ลว เม่อื ออกจาก for/loop เรากแ็ สดง จํานวนของเงนิ ตนและดอกเบ้ยี ท้ังหมดทไ่ี ดจ ากการฝากในชวงน้ัน ในการแสดงผลน้ันเราใช method format() ทมี่ ีอยใู น class String เปนตัวกาํ หนดรูปแบบของ ผลลัพธทแี่ สดงไปยังหนา จอ (บรรทัดที่ 30) ซ่ึงมรี ายละเอยี ดในการกาํ หนดดงั นี้ yAmount = String.format(\"%2d%8c%.2f%n\", y, ' ', amount); การกําหนดก็คลายกับการใชขอกาํ หนดของ printf() ทเ่ี ราไดแ สดงใหด กู อนหนานี้ เพียงแตว า เรา เลอื กใช format() จาก class String กเ็ พราะวาเราตอ งการที่จะนาํ เอาผลลัพธท ้งั หมดไปเก็บไวใน string1 กอนที่จะแสดงออกทางหนา จอ ถา หากเราไมตอ งการใชส ตู รในการคํานวณหาดอกเบี้ย เราก็สามารถทําไดด ว ยการคํานวณหาดอกเบย้ี กอ นแลวจงึ นาํ เอาดอกเบ้ยี ทีห่ าไดไ ปบวกกบั เงินตน หลังจากนั้นกค็ าํ นวณหาดอกเบ้ยี จากเงินตนใหม นี้ ทําการคํานวณจนกวาจะครบตามจํานวนปท ีไ่ ดกําหนดไว ดังทีแ่ สดงดว ย code น้ี amount = principal; //calculate interests for(int y = 1; y <= years; y++) { //calculate new principal double interests = amount * rate; amount += interests; } เราลองมาดูโปรแกรมตวั อยางอีกตวั หนงึ่ ทใี่ ช for/loop ในการควบคมุ การทํางานของโปรแกรม พรอม ทง้ั ยอมให user ใสขอมูลหลาย ๆ ตัว2ในบรรทัดเดยี วกันได 1: /** 2: Reading numbers from input line 3: user must specify space between those numbers and 4: hit <enter> when done. 5: */ 6: 7: import java.io.BufferedReader; 8: import java.io.InputStreamReader; 9: import java.io.StreamTokenizer; 10: import java.io.IOException; 11: import static java.lang.System.out; 12: 1 เราจะพูดถึงการใช String ในบทที่ 4 2 วิธกี ารรบั ขอ มูลแบบนอ้ี าจดูยุงยากไปสกั เลก็ นอย มีวิธีการอื่นท่สี ้นั กวา ในตอนตอไป 95


เรม่ิ ตน การเขียนโปรแกรมดว ย Java 13: class AddNumbers { 14: public static void main(String[] args) throws IOException { 15: double number, sum = 0; //number and sum intro. to Java (FEU.faa) 16: int count = 0; //total numbers read 17: BufferedReader buffer; //input buffer 18: InputStreamReader isr; //input stream 19: StreamTokenizer token; //token from input stream 20: 21: out.print(\"Enter numbers (space between then <enter>): \"); 22: isr = new InputStreamReader(System.in); 23: buffer = new BufferedReader(isr); 24: 25: //get tokens from input buffer 26: token = new StreamTokenizer(buffer); 27: 28: //set priority to EOL so that we 29: //can break out of the loop 30: token.eolIsSignificant(true); 31: 32: //get each number from tokens 33: //calculate the sum until EOL is reached 34: for( ; token.nextToken() != token.TT_EOL ; ) { 35: switch(token.ttype) { 36: //token is a number 37: case StreamTokenizer.TT_NUMBER: 38: number = token.nval; //save token in number 39: count++; //number of tokens read 40: sum += number; //calculate sum 41: break; 42: default: 43: out.printf(\"Token is not a number! %s\\n\", token.toString()); 44: break; 45: } 46: } 47: //calculate average and display result 48: double average = sum / count; 49: out.printf(\"Sum of numbers is %.0f\\n\", sum); 50: out.printf(\"Average of numbers is %.2f\\n\", average); 51: } 52: } โปรแกรม AddNumbers.java ใช method จาก class StreamTokenizer และ for/loop เปนตวั ชว ย ในการดึงเอาขอมลู แตล ะตวั ที่ User ใสเขา สโู ปรแกรม เรากําหนดให user กดปมุ <enter> เม่อื สิ้นสุดการใสข อมลู ดงั นน้ั เราจึงจําเปน ท่จี ะตองบอกให Java รวู า ปมุ <enter> มคี วามสาํ คญั ในการ ยตุ ิการทํางานของ loop ซงึ่ เราทําไดด ว ยการเรยี กใช method eolIsSignificant() ดวยคา ที่เปน จริง ดังนี้ eolIsSignificant(true); ถาเราไมเรยี ก method นีม้ าใชก ารกดปุม <enter> ของ user ก็จะไมมีผลใด ๆ ตอโปรแกรม (โปรแกรมจะไมยตุ ิการทาํ งาน และเราตอ งกดปมุ <ctrl> + c เพอื่ ใหโ ปรแกรมหยุดการทาํ งาน) เมอ่ื เรากาํ หนดความสาํ คญั ของปุม <enter> แลวเราก็เรมิ่ อาน token แตละตวั ทเี่ ราไดด งึ มาจาก keyboard จนกวา token นั้นจะมคี าเปน EOL (End Of Line) ซ่ึงเปน ตวั กําหนดการส้ินสุดของขอมูล ในบรรทดั นัน้ เราอา น token ทีม่ ีอยูท้งั หมดใน buffer มาเกบ็ ไวในตวั แปร token ดวยคาํ สั่ง token = new StreamTokenizer(buffer); หลังจากน้ันเรากต็ รวจสอบดูวา token ท่อี ยถู ัดไปใน buffer เปน EOL หรือไม ซึ่งถาไมเปน เราก็ เรียกใช switch เพอ่ื ตรวจสอบดูวา token ที่อานมานัน้ เปน ตัวเลขหรือไม ถา เปน เราก็จะทําการบวก ตวั เลขนีเ้ ขากับตัวแปร sum พรอมกบั เพมิ่ คา ใหกบั ตัวแปร count for(; token.nextToken() != token.TT_EOL ;) { switch(token.ttype) { //token is a number case StreamTokenizer.TT_NUMBER: number = token.nval; //save token in number 96


บทที่ 3: การตดั สินใจ และการประมวลผลแบบวน count++; //number of tokens read sum += number; //calculate sum break; intro. to Java (FEU.faa) default: System.out.println(\"Token is not a number! \" + token.toString()); break; } } เราตรวจสอบความเปนตวั เลขของ token ไดดวยการเปรยี บเทยี บ token.ttype กบั StreamTokenizer.TT_NUMBER และถาเปน จริง token ท่ีเปนตัวเลขจะถูกเก็บไวในตัวแปร nval (และมชี นดิ เปน double) ดังนัน้ ตัวแปร number จงึ ตองประกาศใหเ ปน double และการดึงคามาเก็บ ในตวั แปร number ทาํ ไดด ว ยการกําหนดคาจากประโยค number = token.nval; เนอื่ งจากวา เราสนใจเฉพาะ token ท่เี ปน ตัวเลขเทา นน้ั เราจึงไมส นใจ token ทีเ่ ปนชนิดอ่ืน ดังนั้นเรา จึงเพยี งแตสง คา ของ token กลับคนื ไปยังหนา จอถา token น้ันเปน ชนดิ อน่ื ทีไ่ มใชตวั เลข for loop ของเราจะทํางานไปเรอื่ ย ๆ จนกวา user จะกดปุม <enter> ซึง่ การกดปมุ <enter> น้ีจะ ทาํ ให expression ท่ีมอี ยเู พียงตวั เดียวใน for loop เปนเท็จ การทาํ งานของ for loop จึงสิน้ สดุ ลง ผอู านจะสังเกตไดวาเราไมส นใจกบั expression ที่ 1 และ expression ที่ 3 ของ for loop เลยทั้งน้กี ็ เพราะวาเราไมตองมกี ารกาํ หนดคา เบ้อื งตน หรอื เพม่ิ คาใด ๆ เลย การยุตกิ ารทาํ งานของ for loop เกดิ จากการกดปมุ <enter> ของ user เทานัน้ ผลลพั ธของการ run ดวยคาสมมติตา ง ๆ Enter numbers (space between - enter when done): 20 30 45 789 12 34 Sum of numbers = 930.0 Average of numbers = 155.0 Enter numbers (space between - enter when done): 45 68 95 Sum of numbers = 208.0 Average of numbers = 69.33 Class StreamTokenizer ยังมี field อืน่ ๆ ที่เราสามารถเรียกใชได แตไ มไ ดก ลา วไวในทน่ี เ้ี พราะวา โปรแกรม AddNumbers.java ของเราสนใจแตเฉพาะการอานตัวเลขเทา นน้ั ผูอานสามารถหาขอ มลู ไดจาก javadoc ของ Sun เอง การอา นขอมูลจากโปรแกรมการบวกเลขที่เราเหน็ น้ันมีขน้ั ตอนที่ยุงยาก (ดงั ทไ่ี ดกลา วไวแ ลว ) แตเ รา นําแสดงใหดูก็เพื่อใหเ ห็นวาทําได แตก ม็ ีวธิ ที ส่ี ้นั กวา นัน่ ก็คือการใช Class Scanner เหมือนกับท่ีเรา ไดทํามากอ นหนาน้ี โปรแกรม SumOfNumbers.java แสดงถงึ การใช class Scanner ในรูปแบบท่ี คลายกนั กบั โปรแกรม AddNumbers.java 1: /** 2: Reading numbers from input line 3: */ 4: 5: import static java.lang.System.out; 6: import java.util.Scanner; 7: 8: class SumOfNumbers { 9: public static void main(String[] args) { 10: double number, sum = 0; 11: int count = 0; 12: 13: out.print(\"Enter numbers: \"); 14: Scanner input = new Scanner(System.in); 15: 16: //loop through numbers until EOF is found 17: //for windows: <ctrl/z> 18: for(; input.hasNext(); count++) { 19: sum += input.nextDouble(); 20: } 21: 97


เรม่ิ ตนการเขียนโปรแกรมดวย Java intro. to Java (FEU.faa) 22: //calculate average and display result 23: double average = sum / count; 24: out.printf(\"Sum of numbers is %.0f\\n\", sum); 25: out.printf(\"Average of numbers is %.2f\\n\", average); 26: } 27: } การนําขอ มลู เขาเรมิ่ ตนดว ยการตรวจสอบวา input มีขอมูลอยหู รือไมดว ยการใชค าํ ส่งั input.hasNext() ซึง่ ถา hasNext() สง คา ทเี่ ปน จริงกลบั มาเราก็จะรวู ามีขอ มูลอยู และจะทาํ ใหเราสามารถดึงขอมูล ออกมาไดดว ยคาํ ส่ัง (บรรทดั ท่ี 19) sum += input.nextDouble() ทง้ั น้ี user จะตอ งใสข อมูลโดยมีชอ งวางอยรู ะหวา งเหมอื นกับโปรแกรมกอนหนา น้เี ชนเดยี วกนั แต การบอกใหโ ปรแกรมรูว า การนําขอ มูลเขา ไดสิ้นสดุ ลง เราตอ งกดปมุ <enter> ตามดว ย <ctrl/z> และกดปมุ <enter> อีกครั้งหนง่ึ ดงั ทแ่ี สดงจากตวั อยา งผลลัพธนี้ Enter numbers: 1 2 3 4 5 ^Z Sum of numbers is 15 Average of numbers is 3.00 ผอู านจะเหน็ วา โปรแกรมของเราสัน้ ลงกวา เกามาก และกไ็ ดผ ลเชน เดยี วกนั ถึงแมวา การยตุ ิการนาํ ขอมลู เขา จะยงุ ยากกวาก็ตาม เราสามารถท่จี ะเรยี กใช scanner ในการอานขอ มูลจาก dialog box ไดเ ชน เดยี วกบั ทเ่ี ราใช scanner อานขอมูลจาก command line วิธกี ารกไ็ มยาก เพยี งแตเ ปลย่ี นการสง ชอ งทางนําขอ มลู เขา ของ scanner จาก System.in ใหเปน การอานจาก String ทเี่ ก็บขอมลู จาก dialog box ดังนี้ String in = JOptionPane.showInputDialog(null, \"Enter int values (separate by space)\", \"Sum of numbers\", JOptionPane.QUESTION_MESSAGE); Scanner input = new Scanner(in); ซ่ึงเราไดแ สดงการใชด งั กลาวในโปรแกรม SumDialog.java ทเ่ี ห็นนี้ 1: /** 2: Reading numbers from dialog box using scanner 3: */ 4: 5: import java.util.Scanner; 6: import javax.swing.JOptionPane; 7: 8: class SumInDialog { 9: public static void main(String[] args) { 10: double number, sum = 0; 11: int count = 0; 12: 13: //getting numbers from a dialog box 14: String in = JOptionPane.showInputDialog(null, 15: \"Enter int values (separate by space)\", 16: \"Sum of numbers\", JOptionPane.QUESTION_MESSAGE); 17: 18: Scanner input = new Scanner(in); 19: 20: //loop through numbers and add them up 21: for(; input.hasNext(); count++) { 22: sum += input.nextDouble(); 23: } 24: 25: //calculate average 26: double average = sum / count; 27: 98


บทที่ 3: การตัดสนิ ใจ และการประมวลผลแบบวน intro. to Java (FEU.faa) 28: //display result via dialog box 29: JOptionPane.showMessageDialog(null, \"The sum is \" + 30: String.format(\"%.0f\\n\", sum) + 31: \"Average is \" + String.format(\"%.2f\\n\", average), 32: \"Sum of numbers\", JOptionPane.INFORMATION_MESSAGE); 33: } 34: } เราเก็บขอมูลที่ user ใสใน dialog box ไวในตวั แปร in ซึ่งเมอ่ื เราไดแลวเรากส็ งตัวแปร in นใ้ี หก บั scanner (ในบรรทัดท่ี 14 และ 18 ตามลาํ ดบั ) ผลลพั ธของการทดลอง run โปรแกรมก็เปน อยางที่ เราคาดไวคือ ในการใช for/loop นนั้ เราสามารถทีจ่ ะใช , (comma) เปน ตัวแบงการประมวลในแตล ะ expression ได ดังตัวอยางโปรแกรมการหาผลรวมและคา เฉลยี่ นของเลขจากหนง่ึ ถึงรอ ย 1: /** 2: Adding numbers using for/loop 3: with comma 4: */ 5: 6: import static java.lang.System.out; 7: 8: class SumUsingFor { 9: public static void main(String[] args) { 10: int i, sum; 11: 12: for(i = 1, sum = 0; i <= 100; sum += i, i++) ; 13: 14: out.printf(\"Sum = %d%n\", sum); 15: out.printf(\"Average = %.2f\", (double)sum / (i-1)); 16: } 17: } เรากําหนดให expression1 ของเรามขี อ ความอยสู องขอ ความคือ i = 0 และ sum = 0 โดยเราใช , เปนตัวแบงขอ ความทง้ั สอง เชนเดียวกันกับ expression3 เรากําหนดใหมีขอ ความ sum += i และ i++ อยู และในตวั for/loop นั้นเราไมม ีการกาํ หนดประโยคใด ๆ เลย ทงั้ น้ีกเ็ พราะวาเราไดก ําหนดให การหาผลรวมน้นั อยูใน expression3 แลว แตเ ราจะตอ งใส ; (หรือเราอาจใส {})เพือ่ ให Java รวู าเรา ไดจ บ for loop ของเราแลว for(i = 1, sum = 0; i <= 10; sum += i, i++) ; หรือ 99


เร่ิมตนการเขยี นโปรแกรมดวย Java intro. to Java (FEU.faa) for(i = 1, sum = 0; i <= 10; sum += i, i++) { } การทาํ งานของ for/loop ท่วี า นี้กเ็ หมือนกันกบั การเขยี น for/loop แบบเดมิ ตางกันตรงทีเ่ ราไดย า ย ตําแหนงของประโยคสองประโยค เทา น้นั เอง sum = 0; for(i = 1; i <= 10; i++) sum += i; ตําแหนง ของขอ ความการหาผลรวมกม็ คี วามสาํ คัญ เราตอ งกําหนดใหป ระโยค sum += i นนั้ อยกู อ น ประโยค i++ ทง้ั น้ีก็เพราะวา Java จะประมวลผลประโยคท่ีอยทู างซายของเคร่อื งหมาย , กอน แลว จึงจะประมวลผลประโยคทอี่ ยถู ัดไปทางขวา ซงึ่ ถา เรากําหนดให i++ อยกู อ น sum += i การ ประมวลผลของเราก็จะผดิ พลาด คา ของผลรวมทไี่ ดคลาดเคลือ่ น สวนท่สี ําคญั อีกสวนหนึ่งกค็ อื คาของ i สําหรบั การคาํ นวณหาคา เฉล่ีย เราตอ งหกั คาของ i ออกหนึง่ คา กอ นนาํ ไปหาร sum กเ็ นอ่ื งจากวาในขณะท่ี for/loop ยุตกิ ารทํางานนน้ั คา ของ i มีคาเปน 101 การหาผลรวมของ for/loop ทีก่ ลาวมาแลว นนั้ เราสามารถท่ีจะเขียนไดอีกหลายรูปแบบ เชน i=; sum = 0; for( ; i <= 100; i++) ; sum += i; หรือ i = 1; sum = 0; for( ; i <= 100; ) { sum += i; i++; } หรอื sum = 0; for( i = 1; i <= 100; ) { sum += i; i++; } ผูอา นควรคํานงึ ถงึ การเขียน code ท่ีดแู ลวอานไดงาย มีโครงสรางทม่ี องดเู ปนสากล ดงั นนั้ ถงึ แมวา Java จะยอมใหเ ราเขียน code ไดอ ยางอสิ ระและหลายรูปแบบ เรากไ็ มควรเขยี น code ทย่ี ากตอการ ทําความเขาใจ ยกเวนวา การเขียน code นัน้ ๆ มคี วามจําเปนท่ตี อ งใชรปู แบบนนั้ ๆ ในการเขียน (จําเปนจริงหรือ?) 3.4.1.1 การใช for-in/loop (for-each) Java 1.5 ไดก าํ หนดใหม กี ารใช for/loop อกี รูปแบบหนึ่งทีเ่ รียกวา for-in/loop ซ่งึ เปน for/loop ท่ี ใชในการดึงเอาขอ มลู ออกมาจากทีเ่ กบ็ เชน ขอมูลท่ีเก็บอยใู น array ซง่ึ เราจะพูดถึงในบทที่ 4 แต เน่ืองจากวาเราตองการใหผูอา นไดร ูจกั ถึง for-in/loop นีอ้ ยางครา ว ๆ กอน เราจงึ ไดน าํ เอาตวั อยาง ของ for-in/loop มาแสดงใหด ใู นที่น้ี โปรแกรมตวั อยางที่เราแสดงใหด ูเปน โปรแกรมงาย ๆ ทร่ี บั ขอมูลมาจาก command-line โดย user จะเปนผูใสข อ มูลถัดจากช่ือของโปรแกรม เชน ถา โปรแกรมของเราชือ่ ForInLoop เราก็จะเรยี กใช โปรแกรมดวยคาํ สง่ั ทเี่ ห็นนี้ พรอมท้ังใสข อมลู ของโปรแกรมตามหลงั คอื I love for/loop d:\\source>java ForInLoop I love for/loop โปรแกรมตัวอยางของเรามีหนา ตาดงั น้ี 1: /** 100


บทที่ 3: การตดั สนิ ใจ และการประมวลผลแบบวน intro. to Java (FEU.faa) 2: Using for-in/loop 3: */ 4: 5: import javax.swing.JOptionPane; 6: 7: class ForInLoop { 8: public static void main(String[] args) { 9: //get each word from command-line 10: //and display them 11: for(String str : args) { 12: JOptionPane.showMessageDialog(null, 13: str, \"Words in sentence\", 14: JOptionPane.INFORMATION_MESSAGE); 15: } 16: } 17: } ผอู า นจะเห็นวา ในบรรทดั ท่ี 11 เราเรยี กใช for-in/loop ในการดงึ เอาขอ มูลออกจากตวั แปรท่ีชอ่ื args ซึง่ เปน command-line argument ของตวั โปรแกรมเองโดยทชี่ นดิ ของขอ มลู จะตองเปนชนดิ เดียวกนั กบั ท่เี ขามา และทไี่ ดก ําหนดไวใ น for-in/loop ดงั ทเี่ ราไดทาํ ไว รูปแบบของ for-in/loop มี ดังนี้ for(declaration : expression) statement จากรูปแบบของ for-in/loop และที่เราไดเขียนไวในบรรทดั ที่ 11 declaration คอื String str expression คอื args (args ของเราเปน array ทีเ่ กบ็ String) พดู ภาษางาย ๆ กค็ ือ for-in/loop ท่ีเราใชใ นบรรทดั ท่ี 12 เปน loop ทบ่ี อกใหเ กิดการทํางานทีว่ า \"สาํ หรับ String str ทุกตัวทอี่ ยใู น args\" เราจะทํากระบวนการตอ ไปนี้ … สิ่งที่เราทําไมไดใ น for-in/loop กค็ ือการทาํ แบบทว่ั ไปกับ loop ตา ง ๆ ที่เราเคยทาํ เชน ถาเรา ตอ งการดึงเอาขอมูลจากตําแหนง ใด ๆ ใน loop หรือแสดงขอ มลู ณ ตําแหนง น้ันๆ เปน ตน ขอ ควร ระวังในการใช for-in/loop ก็คือ expression จะตอ งเปน array หรือ object ท่มี าจาก java.lang.Iterable declaration โดยท่ัวไปจะเปน ชนิด และตัวแปร (การประกาศตวั แปรน่ันเอง) เราจะกลบั มาดูตวั อยางการใช for-in/loop อกี ในบทอืน่ ๆ ตอไป 3.4.2 การใช while/loop การใช while/loop ก็คลาย ๆ กับการใช for/loop ตา งกนั เฉพาะโครงสรา งบางโครงสรา งเทานั้นเอง (ตาํ แหนง ของ expression) เรามาดโู ครงสรางของ while/loop กัน while(expression) statement while/loop จะตรวจสอบวา คาของ expression นน้ั เปน จรงิ หรือเท็จ ถา เปน จริงก็จะประมวลผล ประโยคตา ง ๆ ทีอ่ ยภู ายใน while/loop และจะประมวลผลประโยคอน่ื ๆ ที่ตามมา (ภายนอก while/ loop) หลงั จากท่ีหลุดออกจาก while/loop แลว ภาพท่ี 3-5 แสดงขัน้ ตอนการทํางานของ while/ loop 101


เริม่ ตน การเขยี นโปรแกรมดว ย Java Expression no intro. to Java (FEU.faa) (จรงิ ?) yes statement Next statement ภาพที่ 3-5 ขนั้ ตอนการทาํ งานของ while/loop เรามาลองใช while/loop แทน for/loop ทเ่ี ราไดใ ชในโปรแกรมตวั อยา งบางตวั กอ นหนา น้ี 1: /** 2: Adding numbers using while/loop 3: */ 4: import static java.lang.System.out; 5: 6: class SumUsingWhile { 7: public static void main(String[] args) { 8: int i, sum; 9: 10: //initialize i and sum 11: i = 0; 12: sum = 0; 13: 14: //repeat process as long as i 15: //less than or equals to 100 16: while(i <= 100) { 17: sum += i; //add i to sum 18: i++; //increment i 19: } 20: 21: //print sum and average 22: out.printf(\"Sum = %d%n\", sum); 23: out.printf(\"Average = %.2f\", (double)sum / (i-1)); 24: } 25: } สิง่ แรกทเี่ ราตองทํากค็ อื การกาํ หนดคา เบอ้ื งตน ใหกับตวั แปร i และ sum หลงั จากน้ันเรากท็ ําการ ตรวจสอบดูวาประโยค i <= 10 เปนจรงิ หรอื ไม ซึง่ ถา เปน จรงิ เราก็ให while/loop ของเราทําการบวก คา ของ i เขากับตัวแปร sum พรอมท้ังเพิม่ คาใหก ับ i เม่อื เสร็จแลว ถา เราลองเปรยี บเทียบการใช while/loop กบั for/loop เราจะเหน็ วา ประโยค i = 0; sum = 0; คอื expression ท่หี นึง่ ของ for/loop และประโยค i <= 10 ก็คอื expression ทส่ี องใน for/loop สว นประโยค i++ ก็คอื expression ทส่ี ามใน for/ loop นนั่ เอง (ถึงแมวาเราไดก ําหนดคาของ i ให เรมิ่ ตนท่ี 0 กไ็ มทาํ ใหก ารประมวลผลเปล่ยี นไป เพียงแตว า loop ของเราทํางานมากข้ึนอกี หนงึ่ คร้งั เทานั้น) ทนี ีเ้ รามาลองใช while/loop แทน for/loop ในโปรแกรม AddNumbers.java พรอ มทง้ั เปลยี่ นการ อานขอมลู และการแสดงผล 102


บทท่ี 3: การตดั สนิ ใจ และการประมวลผลแบบวน 1: /** intro. to Java (FEU.faa) 2: Calculating sum and average of numbers 3: using split() to get each token from input string 4: */ 5: 6: import javax.swing.JOptionPane; 7: import static java.lang.System.out; 8: 9: class AddNumbers2 { 10: public static void main(String[] args) { 11: double number, sum = 0; //a number and sum 12: int count = 0; //total numbers read 13: String input; //input string 14: 15: //get input from user 16: input = JOptionPane.showInputDialog(\"Enter numbers: \"); 17: String[] tokens = input.split(\"\\\\s\"); 18: while(count < tokens.length) { 19: try { 20: number = Integer.parseInt(tokens[count]); 21: sum += number; 22: count++; 23: } 24: //display error and exit from program 25: catch(Exception e) { 26: JOptionPane.showMessageDialog(null, 27: \"Invalid input: \" + tokens[count] + 28: \"\\nBefore invalid input\\n\" + 29: \"Sum is \" + 30: String.format(\"%.0f\", sum) + 31: \"\\nAverage is \" + 32: String.format(\"%.2f\", (sum/count)), 33: \"Error\", 34: JOptionPane.ERROR_MESSAGE); 35: System.exit(1); 36: } 37: } 38: //calculate average and display result 39: double average = sum / count; 40: JOptionPane.showMessageDialog(null, 41: \"Sum of numbers: \" + input + \" is \" + 42: String.format(\"%.2f%n\", sum) + 43: \"Average of numbers: \" + 44: String.format(\"%.2f\", average), 45: \"Sum and Average\", 46: JOptionPane.INFORMATION_MESSAGE); 47: } 48: } ในโปรแกรม AddNumbers2.java เราจะใช method split() ของ class String เปน ตวั ดึงเอาขอมลู ออกจาก String ที่ user ใสเ ขามาแทนการใช StreamTokenizer ดงั ทีเ่ ห็นในบรรทดั ท่ี 173 ซงึ่ ขอมลู แตล ะตวั ทถี่ ูกดงึ ออกมานน้ั เราจะนาํ ไปเกบ็ ไวใน array ชือ่ tokens การดึงขอ มลู แตล ะตวั ออกมานนั้ เราตอ งกาํ หนดให split() รูวาเราใชอะไรเปน ตวั กาํ หนดการแบงขอ มลู ท่มี ีอยูใน input ในทีน่ ้ีเราใช ชองวาง (space) เปนตวั แบงโดยเราตองบอกให split() รูดวยการใช \\s แตเน่ืองจากวา \\s เปน escape sequence เราจึงตองกาํ หนดใหม ี '\\' อีกหน่งึ ตัวนาํ หนา '\\s' หลังจากน้นั เรากเ็ ขา หาขอมลู แตละตวั ดว ย while/loop โดยเรียกใช length เปนตัวกําหนดจาํ นวนคร้ัง ของการวน loop และเราจะคาํ นวณหาผลรวมของขอ มลู ทเ่ี ปน Integer เทา นนั้ ถาหากวามขี อมลู ตวั ใดก็ตามท่ไี มใ ช Integer โปรแกรมกจ็ ะยุตกิ ารทาํ งานพรอมทงั้ สง ผลรวมและคา เฉล่ยี ของขอ มูลท่ี ถกู ตองมีอยูกอนหนา ออกทางหนา จอ สว นการแสดงผลของขอ มูลทีถ่ ูกตองกเ็ ปน ไปตามปกติ ดงั ตวั อยา งน้ี 3 เราใชโ ครงสรา งท่ีเรยี กวา array ในการเกบ็ ตัวเลขแตละตัว ซ่งึ เราจะไดอธิบายอยางละเอยี ดตอ ไปในบทที่ 4 103


เรมิ่ ตนการเขียนโปรแกรมดวย Java จากผลลพั ธจะเหน็ วาโปรแกรมจะยตุ ิการประมวลผลถา เจอขอมลู ท่ีไมใ ช Integer ตง้ั แตต ัวแรกท่ีเจอ intro. to Java (FEU.faa) ซงึ่ ตา งจากการใช StreamTokenizer กอนหนา นี้ที่ยังสามารถประมวลผลเฉพาะขอ มลู ท่ีถกู ตอ ง ทงั้ หมดท่ีมอี ยู ท้งั for/loop และ while/loop เปน โครงสรา งของการทํางานแบบวนที่ตองมกี ารตรวจสอบกอนวา ประโยคในการควบคุมของ loop ทั้งสองเปน จรงิ หรือเท็จ ซ่ึงหมายถงึ วาการทาํ งานของ loop ท้ังสอง อาจไมเกดิ ขน้ึ เลยถา การประมวลผลประโยคควบคมุ เปน เทจ็ แตถาเราตอ งการท่ีจะประมวลผลกอน อยางนอยหน่งึ ครัง้ เราจะทาํ อยา งไร 3.4.3 การใช do-while/loop Java มีโครงสรา งการใช loop อกี ตวั หน่ึงท่ียอมใหม ีการทาํ งานอยางนอ ยกอ นหนึง่ คร้งั แลว จึงจะทาํ การประมวลผลประโยคควบคุม น่นั ก็คือ do-while/loop ซง่ึ มโี ครงสรางดังน้ี do { statement } while(expression); statement yes Expression (จริง ?) no statement ภาพที่ 3-6 ขนั้ ตอนการทํางานของ do-while/loop 104


บทท่ี 3: การตัดสินใจ และการประมวลผลแบบวน intro. to Java (FEU.faa) ถาเราตองการที่จะทํางานอยางนอ ยหนงึ่ ครง้ั กอ นที่จะมกี ารตรวจสอบเพื่อยตุ ิการทํางาน หรือทํางาน ตอ ไป do-while/loop จะเปนโครงสรา งที่เหมาะสมทีส่ ุด โปรแกรมตวั อยางตอไปนี้แสดงถงึ การใช do/while loop ในการตรวจสอบนน้ั ๆ 1: /** 2: do/while loop demonstration 3: until user enter a letter other than 'y' 4: */ 5: 6: import static java.lang.System.out; 7: import java.util.Scanner; 8: 9: class DoWhile { 10: public static void main(String[] args) { 11: int score; 12: char grade, ch; 13: Scanner input = new Scanner(System.in); 14: 15: do { 16: //get input string 17: out.print(\"Enter your score: \"); 18: score = input.nextInt(); 19: 20: //determine grade by given score 21: if(score > 90) 22: grade = 'A'; 23: else if(score > 80) 24: grade = 'B'; 25: else if(score > 70) 26: grade = 'C'; 27: else if(score > 60) 28: grade = 'D'; 29: else 30: grade = 'F'; 31: 32: out.println(\"Your grade is \" + grade); 33: out.print(\"\\nDo you want to continue? <y/n> : \"); 34: String response = input.next(); 35: ch = (char)response.charAt(0); 36: } 37: while(ch == 'y' || ch == 'Y'); 38: } 39: } เราเพียงแตด ดั แปลงโปรแกรมการหาเกรดของเรา ดวยการเพิม่ do/while และประโยค out.print(\"\\nDo you want to continue? <y/n> : \"); String response = input.next(); ch = (char)response.charAt(0); ทใี่ ชสาํ หรับการถาม user วา ตองการทาํ งานตอ หรอื ไม โดยเราทําการดึงเอาตัวอักษรตวั แรกทอ่ี ยใู น บรรทัดนนั้ ออกมา ทําการเปรยี บเทียบกบั ตัวอักษร y ใน expression ของ do-while/loop ซง่ึ ถา การ เปรียบเทียบนนั้ เปน จริงเราก็จะทํางานไปเร่ือย ๆ วธิ ีการเดียวทีจ่ ะทาํ ให do-while/loop ยตุ กิ ารทาํ งาน ก็คอื การใสตวั อักษร n (หรอื อนื่ ๆ ทไี่ มใ ช y) เราใช method chatAt() ดว ยคา parameter ที่เปน ศูนยเพ่อื ดึงเอาอกั ษรตัวแรกสดุ ใน buffer มาเก็บ ไวในตัวแปร ch สําหรับการเปรียบเทยี บประโยคควบคุมของ do-while/loop ผลลพั ธก าร run โปรแกรมดว ยคา ตา ง ๆ Enter your score: 89 Your grade is B Do you want to continue? <y/n> : y Enter your score: 12 Your grade is F 105


เรมิ่ ตนการเขยี นโปรแกรมดวย Java Do you want to continue? <y/n> : y intro. to Java (FEU.faa) Enter your score: 75 Your grade is C Do you want to continue? <y/n> : n เรามาลองดูโปรแกรมตัวอยางอีกตวั หนึง่ ที่ใช do-while/loop ในการหาผลรวมของเลขระหวาง 1 – 100 1: /** 2: Adding numbers using do-while/loop 3: */ 4: 5: import static java.lang.System.out; 6: 7: class SumUsingDoWhile { 8: public static void main(String[] args) { 9: int i = 0; //loop counter 10: int sum = 0; //sum of i 11: 12: //repeat process until i is 13: //no longer less than or equal to 100 14: do { 15: sum += i; //add i to sum 16: i++; //increment i 17: } 18: while(i <= 100); 19: 20: out.printf(\"Sum = %d%n\", sum); 21: out.printf(\"Average = %.2f\", (double)sum / (i-1)); 22: } 23: } ซงึ่ เมื่อ run ดูก็ไดผลลพั ธด ังน้ี Sum = 5050 Average = 50.5 เราไมไ ดเ ปลย่ี นแปลงอะไรมากมายใน loop ของเราเพียงแตเ ปลยี่ นมาใช do-while/loop เทาน้ันเอง การใช do-while/loop รับรองวา จะเกดิ การทํางานอยา งนอ ยหน่ึงครง้ั เสมอดงั ทเ่ี ห็นจากตวั อยางทัง้ สอง เพราะฉะน้ันถาผอู า นไมต อ งการตรวจสอบเง่อื นไขกอ นการประมวลผล do-while/loop กเ็ ปน ตัวเลอื กที่คอ นคา งเหมาะสมท่สี ดุ 3.5 การใช break และ continue หลาย ๆ คร้ังทเี่ ราตองการยุติการทาํ งานของ loop โดยท่ี loop ยังไมส ิ้นสดุ การทํางานของมันเอง เชน กาํ หนดให loop หยุดการทํางานเมอื่ เงื่อนไขทไี่ ดก าํ หนดไวเ ปน จริง ดงั แสดงใหเหน็ ในโปรแกรม ตวั อยางน้ี 1: /** 2: Using break to get out of the loop 3: */ 4: 5: import static java.lang.System.out; 6: 7: class SumWithBreak { 8: public static void main(String[] args) { 9: int i = 1, sum = 0; 10: 11: //repeat the task until i > 200 12: do { 13: sum += i; 14: i++; 15: 16: //break out of loop when i > 100 17: if(i > 100) 18: break; 106


บทท่ี 3: การตัดสินใจ และการประมวลผลแบบวน intro. to Java (FEU.faa) 19: } 20: while(i <= 200); 21: 22: out.println(\"Sum = \" + sum); 23: out.println(\"Average = \" + (double)sum / (i-1)); 24: } 25: } เราใชโปรแกรม SumWithBreak.java เปน พน้ื ฐานของการเปลยี่ นแปลง โดยเรากําหนดใหม ีการ ตรวจสอบคา ของ i วา มากกวา 100 หรือไมซึง่ ถาเปน จรงิ เรากจ็ ะ break ออกจาก loop ทันที if(i >= 100) break; เมอ่ื เราลอง run ดเู ราไดผลลัพธด ังน้ี Sum = 5050 Average = 50.5 ลองมาดโู ปรแกรมท่ีใช break ในการหยุดการทาํ งานของ loop ทใี่ ชห าคาของตวั เลขทรี่ ะหวางหน่ึง ถึงสิบทเี่ ปนเลขคู 1: /** 2: Using break in a loop 3: */ 4: 5: class Break { 6: public static void main(String[] args) { 7: 8: for(int number = 1; ; number++) 9: if(number % 2 == 0) { 10: System.out.println(\"Number is \" + number); 11: 12: //break out of loop when number >= 10 13: if(number >= 10) 14: break; 15: } 16: } 17: } เราจะตรวจสอบวา ตัวเลขเปนเลขคกู อนแลว จึงทาํ การแสดงตัวเลขนนั้ ๆ ไปยังหนา จอเมื่อคาของ number เปนสบิ เราก็จะยุติการทํางานของ loop ดงั ท่แี สดงใหเ ห็นจากผลลพั ธท่ีไดน้ี Number is 2 Number is 4 Number is 6 Number is 8 Number is 10 การใช break ใน loop เปน การกาํ หนดให loop หยดุ การทํางานทันที ท่เี จอ break แตถ า เราตอ งการ ทีจ่ ะกระโดดขามคําสัง่ หรอื ชุดคาํ ส่งั ทมี่ ีอยูเมอ่ื เงือ่ นไขบางอยา งเปนจรงิ เราตองใช continue แทน ดงั โปรแกรมตวั อยางนี้ 1: /** 2: Using continue in a loop 3: */ 4: 5: import static java.lang.System.out; 6: 7: class Continue { 8: public static void main(String[] args) { 9: 10: for(int number = 1; number <= 10; number++) { 11: 12: //skip if number is 5 13: if(number == 5) { 14: out.printf(\"%d is skipped!%n\", number); 15: continue; 107


เรม่ิ ตน การเขียนโปรแกรมดวย Java intro. to Java (FEU.faa) 16: } 17: 18: out.println(\"Number is \" + number); 19: } 20: } 21: } การประมวลของประโยคในบรรทัดที่ 18 จะเกิดขนึ้ ทุกคา ของ number ยกเวนเมอ่ื คา ของ number มี คาเทา กบั หา ดงั แสดงใหเหน็ จากผลลพั ธนี้ Number is 1 Number is 2 Number is 3 Number is 4 5 is skipped! Number is 6 Number is 7 Number is 8 Number is 9 Number is 10 การใช continue นนั้ โดยท่วั ไปมักจะไมค อยมที ใ่ี ชเทาไรนัก เพราะการเขยี นโปรแกรมโดยท่วั ไปมกั จะ ทาํ การประมวลผลกลุมของคาํ สั่งทัง้ หมดจนเสร็จ หรอื ไมกย็ ุติการทาํ งานเม่อื เงื่อนไขบางอยางเปน จรงิ การกระโดดขา มการประมวลผลชดุ คําส่งั ไมค อ ยจะมีใหเห็นมากมายนัก ดังน้นั กค็ งตองขึ้นอยกู บั การออกแบบโปรแกรมของผูอานเองวา เหมาะสมอยางไรตอการใชช ดุ คําส่ังตา ง ๆ 3.6 การใช loop ใน loop (Nested Loop) เราสามารถท่จี ะนาํ เอา loop ตาง ๆ ท่ีเราไดพ ูดถึงมาใสไ วใน loop ได เชน เดยี วกับท่ีเราทาํ กับ if – else เนื่องจากวา ตัว loop เองกเ็ ปนประโยคอยางหนึ่ง ดังนั้นการนําประโยคมาวางซอนกนั ในการ เขยี นโปรแกรมกย็ อมทีจ่ ะทําได เรามาลองดตู ัวอยา งการใช nested loop กนั 1: /** 2: Using loop inside another loop 3: */ 4: 5: class NestedLoop { 6: public static void main(String[] args) { 7: 8: for(int row = 1; row <= 10; row++) { 9: for(int column = 1; column <= 10; column++) { 10: 11: //break out of inner loop when 12: //column is greater than row 13: if(column > row) 14: continue; 15: System.out.print(\"*\"); 16: } 17: System.out.println(); 18: } 19: } 20: } โปรแกรม NestedLoop.java ของเราใช for/loop สองตวั ในการแสดงจํานวนของ '*' ในแตละแถว ดงั ทแี่ สดงใหเ หน็ จากผลลพั ธน้ี * ** *** **** ***** ****** ******* ******** ********* ********** 108


บทท่ี 3: การตดั สนิ ใจ และการประมวลผลแบบวน intro. to Java (FEU.faa) ใน for/loop ตวั แรกของเรา เราใชต ัวแปร row เปน loop index ซงึ่ จะประมวลผลเปนจํานวนเทากับ สิบคร้งั และในแตละครง้ั ท่ี row มีการประมวลผล for/loop ตัวทสี่ องทม่ี ี column เปน loop index จะ ประมวลผลเปนจํานวนเทากบั สิบครง้ั เพราะฉะน้นั การประมวลผลของ for/loop ทัง้ สองตัวจึงมีคา เปน จาํ นวนเทา กับหน่ึงรอยคร้งั ทกุ ๆ การประมวลผลของ for/loop ตวั ทสี่ องเราจะตรวจสอบวาคา ของ column มากกวาคา ของ row หรอื ไม ซงึ่ ถามากกวา เราจะหยุดการแสดงคา '*' ไปยงั หนาจอทันทีดวยการเรยี กใช continue ที่เรา ไดพดู ถึงกอนหนาน้ี ในขณะที่ row และ column มคี าเทากับหน่ึงน้ันเราก็สง '*' ไปยงั หนา จอ หลังจากนัน้ column กม็ ีคา เปนสอง ซง่ึ มีคา มากกวา row การกระโดดขา มจงึ เกิดขึน้ ซ่ึงจะเปน ไปจนกระทง่ั column มคี า เทากับ สบิ เอ็ดการประมวลผลของ for/loop ดานในจึงยตุ ิลง หลังจากนั้น row กม็ ีคา เปนสอง เหตกุ ารณเ ดมิ กเ็ กิดข้นึ อกี แตต อนนกี้ ารแสดงผล '*' จะมีเพ่ิมขึ้นจนกวา คาของ column จะมากกวา row เปนเชน นี้ ไปเรอ่ื ย ๆ จนกระทง่ั คา ของ row มคี าเปนสบิ เอ็ดการประมวลผลของ for/loop ดา นนอกจงึ ยตุ ลิ ง โดยความเปนจรงิ แลวเราสามารถทจี่ ะใช break แทนการใช continue ได ซึ่งกจ็ ะไดผลลพั ธ เหมอื นกนั ทั้งนี้เพราะการใช break จะทาํ ใหเ ราหลดุ ออกจาก for/loop ดานในทันที ซ่งึ เปน การ ประมวลผลทีด่ กี วา การใช continue เนอื่ งจากวา เราประมวลผล for/loop ดา นในดว ยจํานวนครัง้ ท่ี เทากบั คา ของ row ทเ่ี ปน อยขู ณะนัน้ (ผอู านควรตรวจสอบดวู าการประมวลผลของ for/loop ดานในมี จาํ นวนเทา กับก่ีครงั้ ในทุก ๆ การประมวลผลของ for/loop ดา นนอก - ทกุ คาของ row) ลองมาดูโปรแกรมตัวอยางอีกโปรแกรมหน่ึงที่ใช Nested – loop ในการแสดงผลของตัวเลขทเี่ รยี ง กันเปนรปู สามเหลยี่ ม 1: /** 2: Triangle of numbers 3: */ 4: 5: import static java.lang.System.out; 6: 7: class NumberTri { 8: public static void main(String[] args) { 9: int row, col; 10: int num; 11: 12: for(row = 0; row <= 7; row++) { 13: //print leading blanks 14: for(col = 1; col <= 7 - row; col++) 15: out.print(\" \"); 16: //print left half 17: for(col = 0; col <= row; col++) { 18: num = (int)Math.pow(2, col); 19: //print 4 blanks for a single digit number 20: //print 3 blanks for two-digit number 21: //print 2 blanks for three-digit number 22: if(num < 10) 23: out.print(\" \" + num); 24: else if(num < 100) 25: out.print(\" \" + num); 26: else 27: out.print(\" \" + num); 28: } 29: //print same format as before 30: for(col = row - 1; col >= 0; col--) { 31: num = (int)Math.pow(2, col); 32: if(num < 10) 33: out.print(\" \" + num); 34: else if(num < 100) 35: out.print(\" \" + num); 36: else 37: out.print(\" \" + num); 38: } 39: out.println(); 40: } 41: } 42: } 109


เรมิ่ ตน การเขยี นโปรแกรมดว ย Java intro. to Java (FEU.faa) ผลลัพธท ีไ่ ดจากการ run โปรแกรม NumberTri.java คือ 1 12 1 124 2 1 1248 4 2 1 1 2 4 8 16 8 4 2 1 1 2 4 8 16 32 16 8 4 2 1 1 2 4 8 16 32 64 32 16 8 4 2 1 1 2 4 8 16 32 64 128 64 32 16 8 4 2 1 เราไดทาํ การตรวจสอบถงึ คา ของตวั เลขทจี่ ะแสดงไปยงั หนาจอวา เปน ตัวเลขก่ี digit โดยเราจะ กําหนดใหมีการเวน ชอ งวา งไวดานหนาตวั เลขตามคา ของ digit น้นั ๆ เชน ตัวเลขหนงึ่ digit เราจะ แสดงชอ งวาง 3 ชอง ตวั เลข 2 digit เราจะแสดงชองวา ง 2 ชอ งและตวั เลขสาม digit เราจะแสดง 1 ชอ ง เพือ่ การเรียงลาํ ดบั ตัวเลขทดี่ แู ลวสวยงาม 3.7 การใช Label continue และ Label break ใน for loop Java ยอมใหมกี ารใช label ในการหยุดและเรมิ่ การประมวลผลใหม ซง่ึ โปรแกรมเมอรหลาย ๆ ทาน ไมค อยจะเหน็ ดวยกบั การใชการประมวลผลในลักษณะนเี้ ทา ใดนกั เรามาดูตวั อยา งกนั 1: /** 2: Using a label/continue 3: */ 4: 5: 6: class LabeledContinue { 7: public static void main(String[] args) { 8: 9: label: for(int row = 1; row <= 10; row++) { 10: System.out.println(); 11: 12: for(int col = 1; col <= 10; col++) { 13: 14: //go to label when column 15: //is greater than row 16: if(col > row) 17: continue label; 18: 19: System.out.print(\"*\"); 20: } 21: } 22: } 23: } เราไดด ัดแปลงโปรแกรม Continue.java ของเราสําหรับการแสดงการใช labeled continue ใน โปรแกรม LabeledContinue.java เรากาํ หนดใหมี identifier ท่ีมชี อ่ื วา label อยกู อนหนา for loop ดา นนอกของเรา ซง่ึ ตองมเี คร่ืองหมาย ':' ตามหลงั เสมอ และในการใช continue ใน for loop ดาน ในนนั้ เราจะตองมี identifier ทเ่ี ราใชต ามหลงั continue เสมอ การประมวลดว ย labeled continue ก็ไมย ากนกั ที่จะทําความเขา ใจ เมื่อคา ของ col มากกวา คา ของ row การทํางานใน for/loop ดา นในก็ส้นิ สดุ ลงและไปเรม่ิ ตนใหมท ่ี for/loop ดา นนอก เพราะนนั่ เปน ทท่ี ีม่ ี label อยู การทํางานแบบนีก้ เ็ หมอื นกบั การกระโดดไปยงั ตาํ แหนง ท่ีเราตองการจะไปน่ันเอง ทั้งน้ีก็ตอ งขน้ึ อยูกบั เงื่อนไขท่เี ราไดตั้งไว (ผลลพั ธเ หมือนเดมิ คอื ) * ** *** **** ***** ****** ******* ******** ********* 110


บทท่ี 3: การตัดสนิ ใจ และการประมวลผลแบบวน intro. to Java (FEU.faa) ถา เราเปลีย่ น continue ใหเปน break เราจะไดผ ลลพั ธอ ะไร เรามาลองดโู ปรแกรมที่ใช labeled break กันดู 1: /** 2: Using label/break 3: */ 4: 5: import java.io.*; 6: 7: class LabeledBreak1 { 8: public static void main(String[] args) { 9: 10: label: for(int row = 1; row <= 10; row++) { 11: System.out.println(\"Before inner loop\"); 12: 13: for(int column = 1; column <= 10; column++) { 14: //break at label when column 15: //is greater than row 16: if(column > row) 17: break label; 18: 19: System.out.print(\"*\"); 20: } 21: 22: System.out.println(\"After inner loop\"); 23: } 24: System.out.println(\"\\nAfter outter loop\"); 25: } 26: } เราไดเพิม่ ประโยคทง้ั กอนและหลงั for/loop ดา นในของเราเพอื่ จะไดด ูวา การประมวลผลเกิดขน้ึ ที่ ใดบา ง ผลลัพธทเ่ี ราไดค อื Before inner loop * After label ขอความทีอ่ ยใู นบรรทัดที่ 24: System.out.println(\"After inner loop\"); จะไมไดรับการประมวลผล ท้งั น้กี เ็ พราะวาคําสั่งของ break กาํ หนดใหการทํางานยุติลงที่ label เราสามารถท่จี ะมี label block ก่ี block ก็ไดในโปรแกรมของเรา การใช labeled break ถาใชไ ด อยางเหมาะสมแลวจะทําใหก ารเขยี น code เปนไปไดอ ยางสะดวกยง่ิ ขน้ึ ท้ังนก้ี เ็ พราะวาเราสามารถท่ี จะกระโดดไปยัง block ตา ง ๆ ไดอยา งงาย ๆ ลองดโู ปรแกรมตัวอยา งอีกตวั หน่ึงท่ีใช labeled break ในการหาผลคณู ของเลขระหวาง 1 – 5 1: /** 2: Using label/break 3: */ 4: 5: import static java.lang.System.out; 6: 7: class LabeledBreak { 8: public static void main(String[] args) { 9: int prod = 1; 10: int i = 1; 11: 12: here: while(true) { 13: //calculate product 14: prod *= i++; 15: 16: //go to label: here when i 17: //is greater than 5 18: if(i > 5) 19: break here; 20: else 21: out.printf(\"Value of prod is %d%n\", prod); 22: } 23: 111


เร่มิ ตน การเขยี นโปรแกรมดวย Java intro. to Java (FEU.faa) 24: out.println(\"\\nFinal product is \" + prod); 25: } 26: } เราใช while/loop ทท่ี าํ งานอยตู ลอดเวลาโดยไมม กี ารกาํ หนดใหห ยดุ (ใช true ใน expression) แต เรากําหนดใหมกี ารหยุดจากการใช labeled break ใน while/loop เอง ตวั โปรแกรมจะคาํ นวณหาผล คณู ไปจนกวา คา ของ i จะเปนหา ก็จะ break ออกจาก block ทช่ี อ่ื here ทนั ที และจะไปประมวลผล ประโยคที่อยถู ัดมาจาก block ซ่งึ ก็คอื System.out.println(\"\\n Final product is \" + prod) ทาํ ให เราไดผ ลลัพธดงั นี้ Value of prod is 1 Value of prod is 2 Value of prod is 6 Value of prod is 24 Final product is 120 Loop เปน โครงสรางท่ีใชม ากในการเขียนโปรแกรมตา ง ๆ ท้ังนี้เพราะ loop เอ้อื อาํ นวยใหผเู ขียน เรยี กใชชุดคําสั่งตา ง ๆ ซ้าํ กนั ได ทาํ ใหการเขียนโปรแกรมลดขั้นตอนการทํางานลง และการทํางาน ของโปรแกรมก็กระชับย่ิงขน้ึ เราจะกลับมาพูดถึง loop อกี หลาย ๆ คร้งั ในบทตอ ๆ ไป โดยเฉพาะใน เร่ืองของ Array และ String สรุป ในบทน้เี ราไดพูดถงึ การใชป ระโยคของการเปรียบเทียบ และการตดั สนิ ใจ การใชประโยคควบคุมการ ทํางาน การใช loop ในการประมวลผลตดิ ตอ กนั โดยรวมแลว เราไดพดู ถึง 9 การใช if และ if-else 9 การใช nested-if 9 การใช Conditional operator (? :) 9 การใช switch 9 การใช loop ตา ง ๆ เชน for/loop for-in/loop while/loop และ do-while/loop 9 การใช break continue และการใชประโยคท่ใี ช label แบบฝก หัด 1. จงเขียนโปรแกรมท่ีรับ int จาก keyboard จํานวน 10 ตวั หลังจากนนั้ ใหคาํ นวณหาผลรวม และ คาเฉล่ียของขอ มูลท้งั 10 ตวั ใหส ง ผลลัพธออกทางหนา จอ 2. จงหาผลลพั ธของ code ตอไปนโี้ ดยไมใช compiler ชว ย class Loops { public static void main(String[] args) { int index = 1; while(index != 9) { index += 2; System.out.println(index); index--; } } } 112


บทท่ี 3: การตดั สินใจ และการประมวลผลแบบวน intro. to Java (FEU.faa) class Loops1 { public static void main(String[] args) { int index1, index2; index1 = 33; index2 = 1; while(index1 < index2) { index1 = index1 + 10; System.out.println(index1); index2 = index2 * 2; } } } class Loops2 { public static void main(String[] args) { int index = 1; while(index != 33) { index++; System.out.println(index); index++; } } } class Loops4 { public static void main(String[] args) { int j, k = 1; while(k < 7) { j = 5; while(j > 0) { System.out.println(\"j = \" + j); System.out.println(\"k = \" + k); j--; } k *= 2; } } } class Loops5 { public static void main(String[] args) { int j = 10, k = 1; while(k < 8) { while(j > 0) { System.out.println(\"j = \" + j); System.out.println(\"k = \" + k); j--; } k = k * 2; } } } 3. จงเขียนโปรแกรมที่สรางตวั เลขแบบสมุ จํานวน 100 ตวั เสร็จแลวใหแ สดงผลลพั ธอ อกทาง หนา จอเฉพาะตัวเลขท่เี ปน เลขคเี่ ทานน้ั โดยกาํ หนดใหการแสดงผลเปน 10 ตวั ตอ หนงึ่ บรรทดั 4. จากโจทยใ นขอ 2 แทนท่ีจะแสดงผลเปนเลขคใี่ หแ สดงผลเฉพาะที่เปนเลขคูเทานั้น โดยแสดง เฉพาะเลขคูทีม่ ากกวา 20 เทา นัน้ 5. จงเขียนโปรแกรมทแี่ สดงตัวอักษรตงั้ แต A ไปจนถึง Z ดวยการใช while/loop โดยไมมกี ารรบั คา ใด ๆ จาก keyboard 6. จงเขยี นโปรแกรมทีค่ าํ นวณหาคาท่เี ล็กท่ีสดุ ในกลุมตัวอกั ษรท่ีอา นเขา มาจาก keyboard ทีละตวั (ตวั อกั ษรท่นี าํ เขา ควรมจี าํ นวนไมนอ ยกวา 10 ตวั ) 113


เร่ิมตนการเขยี นโปรแกรมดวย Java 7. จงเขยี นโปรแกรมทีอ่ า นขอ มูล 2 ตัวจาก keyboard โดยทตี่ วั แรกเปน หมายเลขของสินคา intro. to Java (FEU.faa) (product number) และตัวทสี องเปน จํานวนท่ีขายไปในแตละวัน (quantity sold) กาํ หนดใหมี สินคา อยู 5 ชนิดท่ีมีราคาตางกนั ดังน้ี สินคา ท่ี 1 ราคา 500.0 บาท สนิ คา ที่ 2 ราคา 750.0 บาท สินคา ท่ี 3 ราคา 850.0 บาท สนิ คาท่ี 4 ราคา 950.0 บาท สินคาท่ี 5 ราคา 1000.0 บาท โปรแกรมจะคํานวณหายอดเงนิ ทขี่ ายไดของสนิ คา ทกุ ตวั ในอาทิตยทีผ่ านมา โดยที่จํานวนของ สินคาแตล ะชนิดทข่ี ายไปจะนําเขามาจาก keyboard โปรแกรมท่ีเขียนขนึ้ ตอ งใช switch ในการ แยกแยะราคาของสนิ คา แตล ะชนดิ ทีเ่ ขามา ใหแ สดงผลลพั ธอ อกทางหนา จอ 8. จงเขยี นโปรแกรมทแ่ี สดงผลลัพธ ดงั ท่ีเห็นน้ี ดวยการใช loop เทานนั้ *********** ********** ********* ********* ******** ******** ******* ******* ****** ****** ***** ***** **** **** *** *** ** ** * * 9. จงเขียนโปรแกรมทรี่ ับคา int หน่ึงตวั (n) ท่มี ากกวา ศูนย หลงั จากน้ันใหแ สดงผล ดงั นี้ 1 2 3 ... n-1 n 1 2 3 … n-1 … 123 12 1 10. จงเขยี นโปรแกรมท่รี บั คาเปน วัน เดอื น ป จาก keyboard หลงั จากนั้นใหแสดงตาํ แหนงของวันที น้นั ในป เชน 12 29 2002 จะแสดงเปน 363 11. จงเขียนโปรแกรมท่รี ับคาตา งๆ จาก keyboard เฉพาะท่เี ปน 0 มากกวา ศนู ย และนอ ยกวาศนู ยให นับจาํ นวนของคาท้ังสามวา มอี ยางละก่ีตัว โปรแกรมจะหยดุ ทาํ งานไดก ต็ อ เม่ือ user ใสขอ มูลท่ี ไมใชต วั เลข 12. จงเขยี นโปรแกรมท่ีรบั คาระหวา ง 1 – 100 หลงั จากนน้ั ใหแ สดงคา ทีร่ ับเขา มาในรูปแบบของ ตวั หนงั สอื เชน ถาขอ มลู เขาเปน 11 ผลลัพธท ่ีไดค ือ สบิ เอ็ด 13. จงเขียนโปรแกรมท่ที ําการเขา รหัสของขอ มูลที่นําเขา จาก keyboard โดยนําเอาตัวอกั ษรทอี า น เขา บวกกบั คา ของตัวอกั ษรทอ่ี ยถู ัดไป 2 ตัวอกั ษร mod ดวยจํานวนของตัวอักษรทีม่ อี ยู (26 ตัว ในภาษาองั กฤษ) เชน ถา คา นาํ เขา เปน a ผลลัพธท ีไ่ ดจากการเขารหัสจะเปน a + c ซ่ึงจะมีคา เทากบั 97 + 99 =196 % 26 = 14 ใหใ ชคา นี้เปนตัวบอกตาํ แหนงของตวั อักษรท่ีจะแสดงไป ยงั หนาจอ ซ่ึงตวั อกั ษร ณ ตําแหนง ที่ 14 นคี้ ือ n 14. จงเขยี นโปรแกรมท่ีรับคา เปน ประโยคทางคณติ ศาสตร เชน 9 + 5 – 2 * 4 + 2 /3 หลงั จากนน้ั ใหทําการประมวลผลประโยคดงั กลา ว ตามลาํ ดบั ของขอ มูลทน่ี าํ เขา 15. จงเขียนโปรแกรมทร่ี บั คา เดือนทีเ่ ปน ตัวเลขระหวาง 1 – 12 หลงั จากนั้นใหแสดงผลเปนจาํ นวน ของวนั ท่ีมีอยูในเดอื นดังกลา ว 114


บทที่ 3: การตัดสนิ ใจ และการประมวลผลแบบวน intro. to Java (FEU.faa) 16. จงเขียนโปรแกรมที่คาํ นวณหา ตวั หารรว มมาก (GCD – Greatest Common Divisor) ของ ตัวเลขสองตวั ทรี่ ับเขา มาจาก keyboard เชน gcd ของ 24 และ 15 คอื 3 Note: gcd ของ x และ y คอื integer ทีใ่ หญทสี่ ดุ ทห่ี าร x และ y ลงตวั 17. จงเขียนโปรแกรมทคี่ าํ นวณหา ตวั คูณรวมนอย (LCM – Least Common Multiple) ของตวั เลข สองตัวทร่ี บั เขามาจาก keyboard เชน lcm ของ 24 และ 15 คอื 120 Note: LCM ของ x และ y คือ integer ท่นี อ ยท่สี ดุ ที่ทง้ั x และ y หารลงตวั 18. จงเขยี นโปรแกรมที่หา factor ของตัวเลขท่รี บั เขามาจาก keyboard เชน ถา ขอมลู เทากบั 18 factor ทไ่ี ดคอื 2 3 และ (18 = 2 * 3 * 3) 19. จงเขียนโปรแกรมท่มี ี menu ให user ในการเลอื กการทํางานระหวางการหา LCM หรือการหา GCD การออกจากโปรแกรมจะถกู กาํ หนดโดย user 20. จงเขยี นโปรแกรมท่ีคาํ นวณหาผลลัพธของ series ทีใ่ หน ้ี 1/3 + 3/5 + 5/7 + 7/9 + 9/11 + … + 95/97 + 97/99 21. จงเขียนโปรแกรมทค่ี าํ นวณหาคาของ pi ดว ย series ท่ีใหน้ี pi = 4(1 – 1/3 + 1/5 – 1/7 + 1/9 – 1/11 + 1/13 - … - 1/(2i – 1) + 1/(2i +1)) 22. จงเขยี นโปรแกรมที่คาํ นวณหารคาของ e ดว ย series ทใ่ี หน้ี e = 1 + 1/1! + 1/2! + 1/3! + 1/4! + … + 1/i! 115


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


Like this book? You can publish your book online for free in a few minutes!
Create your own flipbook