Basic Java

บทที่ 2 ขอมูล ตวั แปร และ การประมวลผล 46เรม่ิ ตนกับ Javaและ operator ! น้นั เม่อื ไปอยูหนา ตวั แปรหรอื ประโยคทม่ี คี า ทาง boolean คาใดคาหนึ่งกจ็ ะเปล่ยี นคานน้ัใหเ ปน ตรงกันขา มทนั ทีOperator ตัวอนื่ ๆ ทีใ่ ชกับตวั แปรหรือประโยคที่มคี า เปน boolean มดี งั น้ี< ใชในการเปรียบเทียบวา คา ทางดา นซา ยของเคร่อื งหมาย นอ ยกวา คาทางดา นขวาหรือไม> ใชในการเปรยี บเทยี บวา คาทางดา นซา ยของเครือ่ งหมาย มากกวา คาทางดา นขวาหรอื ไม<= ใชในการเปรียบเทียบวา คาทางดานซายของเคร่ืองหมาย นอ ยกวา หรอื เทา กบั คาทางดา นขวา หรือไม>= ใชใ นการเปรยี บเทยี บวา คาทางดานซายของเคร่อื งหมาย มากกวา หรือเทา กับ คาทางดานขวา หรอื ไม== ใชใ นการเปรียบเทยี บวา คาทางดานซายของเครื่องหมาย เทากับ คาทางดานขวาหรอื ไม!= ใชในการเปรียบเทยี บวา คาทางดานซายของเครื่องหมาย ไมเทา กับ คา ทางดานขวาหรือไมเราเรียก operator เหลา นีว้ า Relational operator ซงึ่ เอาไวใชใ นการตรวจสอบความสมั พันธของตวั แปรหรอื ประโยควา มคี า แตกตางกนั อยางไรเมื่อนํามาเปรียบเทียบกนัเราจะลองเขียนโปรแกรมตรวจสอบ operator ตาง ๆ เหลา นด้ี ู/* BooleanOp.java - Testing boolean operations */class BooleanOp { public static void main(String[] args) { boolean A = true, B = false; System.out.println(\"Conditional AND\"); System.out.println(\"F && F is \" + (B && B)); System.out.println(\"F && T is \" + (B && A)); System.out.println(\"T && F is \" + (A && B)); System.out.println(\"T && T is \" + (A && A)); System.out.println(\"Conditional OR\"); System.out.println(\"F || F is \" + (B || B)); System.out.println(\"F || T is \" + (B || A)); System.out.println(\"T || F is \" + (A || B)); System.out.println(\"T || T is \" + (A || A)); System.out.println(\"Logical AND\"); System.out.println(\"F & F is \" + (B & B)); System.out.println(\"F & T is \" + (B & A)); System.out.println(\"T & F is \" + (A & B)); System.out.println(\"T & T is \" + (A & A)); System.out.println(\"Logical OR\"); System.out.println(\"F | F is \" + (B | B)); System.out.println(\"F | T is \" + (B | A)); System.out.println(\"T | F is \" + (A | B)); System.out.println(\"T | T is \" + (A | A)); System.out.println(\"Logical NOT\"); System.out.println(\"!F is \" + (!B)); System.out.println(\"!T is \" + (!A)); }}โปรแกรมประกาศตัวแปรสองตวั A และ B ดว ยคา true และ false ตามลําดับ และทาํ การแสดงผลลพั ธของการประมวลผลดว ย operator ผานทาง System.out.println() ผลลัพธท แ่ี สดงออกทางหนาจอ คอื ภาควิชาคอมพิวเตอรธุรกิจ วทิ ยาลยั ฟารอ สี เทอรน

บทท่ี 2 ขอ มลู ตวั แปร และ การประมวลผล 47เร่มิ ตน กับ JavaConditional ANDF && F is falseF && T is falseT && F is falseT && T is trueConditional ORF || F is falseF || T is trueT || F is trueT || T is trueLogical ANDF & F is falseF & T is falseT & F is falseT & T is trueLogical ORF | F is falseF | T is trueT | F is trueT | T is trueLogical NOT!F is true!T is falseทีนล้ี องมาดูโปรแกรมการใช Relational operator/* BooleanOp2.java - Using relational operators */class BooleanOp2 { public static void main(String[] args) { int i = 5, j = 10; System.out.println(\"i = \" + i); System.out.println(\"j = \" + j); System.out.println(\"i > j is \" + (i > j)); System.out.println(\"i < j is \" + (i < j)); System.out.println(\"i >= j is \" + (i >= j)); System.out.println(\"i <= j is \" + (i <= j)); System.out.println(\"i == j is \" + (i == j)); System.out.println(\"i != j is \" + (i != j)); System.out.println(\"(i < 10) && (j < 10) is \" + ((i < 10) && (j < 10))); System.out.println(\"(i < 10) || (j < 10) is \" + ((i < 10) || (j < 10))); }}โปรแกรม BooleanOp2.java ทาํ การหาคา ของประโยคตา ง ๆ ในรปู แบบงา ย ๆ เพ่อื ใหผ อู า นไดเห็นถงึผลลพั ธของการใช operator ตาง ๆ ไดอยางชดั เจน เราประกาศตัวแปรท่ีเปน int สองตัว คอื i และ j ซ่ึงกําหนดใหม ีคาเปน 5 และ 10 ตามลําดบั หลงั จากนนั้ โปรแกรมกใ็ ช operator ตาง ๆ กบั ตัวแปรสองตวั น้ีและเม่อื run โปรแกรมนแ้ี ลวผลลพั ธท ี่ได คอื ภาควิชาคอมพิวเตอรธุรกจิ วทิ ยาลัยฟารอสี เทอรน

บทที่ 2 ขอมูล ตวั แปร และ การประมวลผล 48เร่ิมตน กับ Javai=5j = 10i > j is falsei < j is truei >= j is falsei <= j is truei == j is falsei != j is true(i < 10) && (j < 10) is false(i < 10) || (j < 10) is trueเพ่ือใหเ หน็ ภาพของการประมวลของ operator && และ operator || ไดชดั เจนยิ่งข้นึ ผอู า นควรตรวจสอบจากแผนภาพของการประมวลผลนี้ โดยเราไดกาํ หนดใหต วั แปร p และ q มีคาเปน 5 และ 10ตามลาํ ดับในการประมวลผลทางดานซาย และใหม คี า เปน 10 และ 5 ในการประมวลผลทางดานขวา(p < q) p = 5, q = 10 (p < q) p = 10, q = 5 && (q <= 10) && (q <= 10)TT F ไมตองประมวลตอ เพราะ F && กบั อะไรก็ได F Tภาพท่ี 2.4 การประมวลผลดวย &&(p < q) p = 5, q = 10 (p < q) p = 10, q = 5 || (q <= 10) || (q <= 10)T ไมต อ งประมวลผลตอเพราะ T || กับ F T อะไรก็ได T Tภาพท่ี 2.5 การประมวลผลดวย ||ตาราง 2.8 ไดส รปุ คาของการประมวลผลดว ย operator && || & | ดังทีไ่ ดก ลาวมาแลว ภาควิชาคอมพิวเตอรธ รุ กิจ วทิ ยาลยั ฟารอ สี เทอรน

บทท่ี 2 ขอ มลู ตัวแปร และ การประมวลผล 49เริม่ ตนกับ Javaตาราง 2.8 การใช operator && || & และ |P Q P && Q P || Q P&Q P|Q true truetrue true true true false true false truefalse true false true false falsetrue false false truefalse false false falseเราคงมองไมเห็นถงึ ประโยชนของการใชตวั แปรที่เปน boolean และการใช operator ตา ง ๆ ทไี่ ดพ ดู ถึงในตอนนอี้ ยางมากมายนกั การประมวลผลของตวั แปรทเี่ ปน boolean สวนใหญจ ะเอาไวช ว ยการตรวจสอบถงึ เหตกุ ารณ (condition) ตา ง ๆ ที่อาจเกดิ ขึ้นในโปรแกรม เชน ถา ประโยคท่หี นง่ึ เม่อื นาํ มาประมวลผลกับ ประโยคทส่ี องแลว ผลลพั ธท ี่ไดเ ปน true หรือ false ซง่ึ ถา เปน true เราจะทําการอยา งอ่นื และกจ็ ะทาํ การอ่ืนหากเปน false เปนตน เราจะพูดถึง boolean operator ตา ง ๆ เมื่อเราพูดถงึ เร่อื งของ logicและเร่อื งของการประมวลผลในรปู แบบของการวนซ้าํ (logic and loop)การประมวลผลในระดบั bit ดว ยการใช operator Shift และ Bitwiseในการทํางานในระดบั bit น้นั มี operator ไมกตี่ วั ท่เี ราสามารถเรยี กใชได ซงึ่ การใชงานโดยทั่วไปก็ไมงา ยนัก เพราะตองทาํ ในระดับ bit และผูใชต อ งมคี วามเขา ใจในเรือ่ งของเลขฐานสองอยางดีพอสมควร เราจะยกตัวอยางเพยี งไมก ี่ตัวอยางเพอื่ ใหเห็นถงึ การใชง านของ operator shift ตา ง ๆ ท่ี Java มีให คือ <<>> และ >>>ตาราง 2.9 การใช operator shift << >> และ >>>Operator วิธใี ช ความหมาย<< operand1 << operand2 โยก bit ของ operand1 ไปทางซา ยจาํ นวนเทากบั คา ของ operand2 เติม 0 ทกุ ๆ bit ทางขวา>> operand1 >> operand2 โยก bit ของ operand1 ไปทางขวาจาํ นวนเทากับคา ของ operand2 เตมิ ดว ยคา bit (sign bit)สงู สดุ ทางซาย>>> operand1 >>> operand2 โยก bit ของ operand1 ไปทางขวาจํานวนเทากบั คาของ operand2 เติม 0 ทกุ ๆ bit ทางซา ยตัวอยา ง13 >> 113 = 000011012 เมื่อ shift ไปทางขวา 1 bit ผลลัพธท ไี่ ดค ือ 000001102 (เทา กับ 6 ในเลขฐาน 10)13 << 1shift ไปทางซา ย 1 bit ผลลพั ธท ีไ่ ดค อื 000110102 (เทา กบั 26 ในเลขฐาน 10)13 >>> 1shift ไปทางขวา 1 bit ผลลัพธท ี่ไดค อื 000001102 (เทากับ 6 ในเลขฐาน 10)การโยก bit ไปทางซายครั้งละหนึง่ bit น้นั ทีจ่ ริงแลว กค็ ือการคูณดว ยสอง เรามาดตู วั อยางโปรแกรมการโยก bit ไปทางซา ยกัน จากโปรแกรม ShiftLeftOp.java ท่ีเห็นดานลา งนี้/* ShiftLeftOp.java - Using shift operators */class ShiftLeftOp { public static void main(String[] args) { byte bits = 1; System.out.println(\"Value of bits is \" + bits); bits = (byte) (bits << 1); System.out.println(\"Value of bits is \" + bits); bits = (byte) (bits << 1); ภาควิชาคอมพิวเตอรธ รุ กิจ วทิ ยาลยั ฟารอ สี เทอรน

บทท่ี 2 ขอมูล ตวั แปร และ การประมวลผล 50เร่ิมตนกับ Java System.out.println(\"Value of bits is \" + bits); bits = (byte) (bits << 1); System.out.println(\"Value of bits is \" + bits); bits = (byte) (bits << 1); System.out.println(\"Value of bits is \" + bits); bits = (byte) (bits << 1); System.out.println(\"Value of bits is \" + bits); }}เราเริ่มดว ยการกาํ หนดใหต วั แปร bits มีชนดิ เปน byte และมคี าเทา กับหนง่ึ โปรแกรมทาํ การโยก bit ไปทางซายจาํ นวนเทากับหา คร้งั ซงึ่ ในการโยกแตล ะคร้งั เราก็จะไดคา ใหมท ม่ี ีคา เทา กบั คาเดิมคณู ดว ยสองดังท่ีเหน็ จากผลลพั ธข องการ run โปรแกรมน้ีValue of bits is 1Value of bits is 2Value of bits is 4Value of bits is 8Value of bits is 16Value of bits is 32เราเลือกใชข อมลู ชนิดทเ่ี ปน byte ก็เพ่ือใหเ ห็นวาถาเราโยก bit อกี คร้งั ดว ยจํานวน bit ทต่ี อ งการโยกเทากบั สอง bit (ครั้งที่หก) เราจะไดค าทตี่ ัวแปร bits ไมส ามารถเก็บได ลองดู code ท่ีเพิ่ม และ ผลลพั ธของการ runbits = (byte) (bits << 2);System.out.println(\"Value of bits is \" + bits);ผลลัพธเมื่อ run อกี คร้งั ดวย code ท่ีเพม่ิ ขึ้นจะเห็นวา คา ของ bits ท่ไี ดมีคา เปน -128 ซง่ึ เปนคาท่ี Javaเปน ผกู าํ หนดให แตไ มใ ชคา ทีถ่ ูกตอ ง เพราะขอ มูลที่เปน byte น้นั เกบ็ คาสงู สดุ ท่ีเปนบวกไดเพียงแค 127เทาน้ันValue of bits is 1Value of bits is 2Value of bits is 4Value of bits is 8Value of bits is 16Value of bits is 32Value of bits is -128ส่งิ สาํ คญั อีกส่ิงหนึง่ ก็คอื การ cast เราจําเปน ตอ งเปลยี่ นขอมลู ใหถ กู ตอ งตามชนิดของตวั แปร เนอ่ื งจากวาJava ไดท าํ การเปล่ยี นตวั แปร bits ของเราใหเ ปน int กอ นที่จะทาํ การ shift ดงั นน้ั เราตอ งเปลยี่ นขอ มูลใหกลบั มาเปน ชนดิ เดมิ กอ นการจดั เกบ็ (หลงั จากการ shift สน้ิ สุดลง)เราไดพดู ถงึ การประกาศตัวแปร การกําหนดคา ใหก บั ตัวแปรทีอ่ ยูภ ายในตัวโปรแกรม ดวยขอ มูลท้ังท่มี ีชนิดเปน integer และ floating-point ซึ่งการกําหนดคาใหกบั ตัวแปรภายในโปรแกรมนน้ั ไมม ีความยืดหยนุของขอ มลู ทถี่ ูกเก็บอยูในตวั แปรน้นั หากผูใช หรือ ผเู ขยี นโปรแกรมตอ งการทจ่ี ะเปลย่ี นคา ทต่ี วั แปรน้ันเกบ็อยู ผเู ขยี นจะตอ งเปนผูแ กไ ขแตเ พยี งฝายเดยี ว ผใู ชโ ปรแกรมไมสามารถทจี่ ะเปล่ียนคา เหลาน้นั ได ดังนั้นการเขียนโปรแกรม จะตองใหโ อกาสผใู ชโปรแกรมในการเปลีย่ นแปลงคา เหลานั้น Java มี method อยูหลายตัวทีร่ องรบั การใสข อมลู ผานทาง keyboard เราจะมาทาํ ความรจู กั และเขาใจถงึ วธิ กี าร ซึ่งคอ นขา งจะซับซอ นพอสมควรสาํ หรับผเู ร่มิ หัดเขียนโปรแกรมใหม อยา งไรก็ตามหลงั จากท่ีไดท าํ ความเขาใจแลว ก็จะเห็นวาการรบั คา ตาง ๆ ผา นทาง keyboard นัน้ เปนเร่ืองท่ี (จริง ๆ แลว) ไมย ุง ยากเลย ภาควิชาคอมพิวเตอรธรุ กจิ วทิ ยาลัยฟารอสี เทอรน

บทที่ 2 ขอมูล ตวั แปร และ การประมวลผล 51เร่มิ ตน กบั Javaการกาํ หนดคา ใหก บั ตวั แปรผา นทางสอื่ การนาํ เขา ขอมลู มาตรฐานJava ไมม ี method ใด ๆ ทร่ี บั คาขอมูลตามชนิดนน้ั ๆ ของขอมูลที่เขา มาเลย เชน ถา ผใู ชโ ปรแกรมตอ งการทจี่ ะใสค าท่เี ปน int float double หรือ char ผเู ขยี นโปรแกรมก็ไมส ามารถทจ่ี ะรบั คา ตา ง ๆเหลา นไ้ี ดโ ดยตรง เหมอื นกบั การเขียนโปรแกรมดว ยภาษาอ่ืน ๆ เชน C หรือ C++ แตต ัวผเู ขยี นเองจะตอ งเขยี น code ขึ้นมารองรับคาเหลา นผี้ า นทางการอานเขา แบบทีเ่ รียกวา การรบั ขอมูลท่ีเปน String ซ่งึ เมอื่อาน String ไดแ ลวก็ตอ งแปลง String ใหเปนชนิดของขอ มลู ทผ่ี ูเขียนโปรแกรมตอ งการใหเ ปนผูอานอาจสงสยั วา String คืออะไร ในท่นี จี้ ะอธบิ ายอยา งครา ว ๆ เนือ่ งจากวา เราจะพดู ถงึ String ในบทอื่นตอ ไป ใน Java นั้น String เปน object (อกี แลว object? เชน เดยี วกนั เราจะพดู ถึง object อยา งละเอียดในบทอ่ืน) ซงึ่ สามารถเกบ็ ตวั อกั ษรไดคราวละมาก ๆ ขอยกตวั อยางงาย ๆ ใหด กู แ็ ลวกันPeople of Thailandสวสั ดีprice_of_coffee123456789023+popOfRockตวั อยา งท่ีเหน็ ดา นบนนี้ลว นแลว แตเ ปน String ทัง้ น้ัน ทีน้เี รามาลองดวู ธิ กี ารอา น String เขามาจากkeyboard แลวกเ็ ปลยี่ น String ใหเ ปน ขอ มูลชนิดตา ง ๆ ทเ่ี ราตองการ เรม่ิ ดว ยการเปลยี่ นแปลง codeของโปรแกรม Radius.java ใหร ับคา ของ area จาก keyboard แทนการกาํ หนดภายในโปรแกรม/* Radius2.java - Reading data from keyboard */import java.io.*;class Radius2 { public static void main(String[] args) throws IOException { double radius, area; int meters, centimeters; //prompt user for area of a circle System.out.print(\"Please enter area of a circle: \"); //get string from keyboard InputStreamReader in = new InputStreamReader(System.in); BufferedReader buffer = new BufferedReader(in); String inputString = buffer.readLine(); //convert string to double area = Double.parseDouble(inputString); //calculate radius radius = Math.sqrt(area / Math.PI); //convert to meters and centimeters meters = (int)Math.floor(radius); centimeters = (int)Math.round(100.0 * (radius - meters)); System.out.print(\"Circle with area of \" + area + \" square meters \"); System.out.print(\"has a radius of \" + meters + \" meters and \"); System.out.println(centimeters + \" centimeters\"); }}โปรแกรม Raadius2.java เพม่ิ code ใหอา น String จาก keyboard ดวยประโยคSystem.out.print(\"Please enter area of a circle: \"); ภาควิชาคอมพิวเตอรธ ุรกจิ วทิ ยาลยั ฟารอ สี เทอรน

บทท่ี 2 ขอ มูล ตวั แปร และ การประมวลผล 52เร่มิ ตนกับ JavaInputStreamReader in = new InputStreamReader(System.in);BufferedReader buffer = new BufferedReader(in);String inputString = buffer.readLine();ประโยคแรกสดุ เปน การสง ขอความไปยัง user ใหรวู าตองใสข อ มลู อะไรเขา สโู ปรแกรม ประโยคถดั มาอานขอมูลในรปู แบบของ byte จากระบบ (System.in) เปลย่ี นขอ มลู เหลา นั้นใหเปน character แลว จงึ นาํ มาเกบ็ ไวใ นตวั แปร in ประโยคทส่ี ามทาํ การจองเน้ือทใี่ หกับตวั แปร buffer พรอมกับนําคา character ท่อี ยูในตัวแปร in มาเกบ็ ไวในรปู แบบของ String เมอื่ ได String (ซึง่ ตอนน้ีอยูในตัวแปร buffer) เรากท็ ําการอาน String ท่ีวา นี้ดว ย method readLine() ผา นทางตัวแปร buffer แลว จงึ นําไปเก็บไวในตัวแปรชนดิString ท่มี ชี ่ือวา inputStringฟง ดแู ลว รสู ึกวา มขี นั้ ตอนมากมายในการอา น String แตตอนนีข้ อเพียงแตจาํ วา ถาจะอา น String จากkeyboard ตองทําดว ยวธิ ีนี้ (ณ เวลาน้ี เพราะมอี ีกหลายวธิ )ีเม่อื เราได String แลวข้ันตอนตอ ไปกค็ อื การเปลย่ี น String ใหเ ปน ขอมูลชนดิ ทีเ่ ราตองการใชใ นโปรแกรมซ่งึ โปรแกรม Radius.java ของเราตอ งการใชข อ มูลชนดิ ที่เปน double เราจงึ ตองทําการเปลย่ี น String นี้ใหเปน double ดวยการเรียกใช method parseDouble() จาก class Double พรอ มท้งั สง ตวั แปรทเ่ี ก็บขอ มูลจาก keyboard ไปใหแก method นีด้ วยarea = Double.parseDouble(inputString);หลังจากน้ัน code ของโปรแกรมทเ่ี หลือก็เหมือนกบั ทเ่ี ราไดเ ขียนกอ นหนานี้ และเมื่อ run โปรแกรมดูสองคร้งั ดว ยคา 850 ในครัง้ แรกและคา 54 ในคร้งั ทส่ี อง เรากไ็ ดผ ลลัพธ ดงั ทีแ่ สดงใหเ หน็ นี้Please enter area of a circle: 850Circle with area of 850.0 square meters has a radius of 16 meters and45 centimetersPlease enter area of a circle: 54Circle with area of 54.0 square meters has a radius of 4 meters and15 centimetersถาสังเกตใหด จี ะเหน็ วา โปรแกรม Radius2.java น้นั มขี อ ความเพมิ่ ตอทายของ main(..) คือthrows IOExceptionเหตผุ ลทเ่ี ราตองเพิ่ม throws IOException ใหกบั main(…) ก็เพราะวา การอานขอมลู เขาสูโปรแกรมน้นับางคร้งั กอ็ าจเจอกบั ปญ หาในการอาน เชน อา นไมได และเหตผุ ลอีกอนั หนง่ึ คอื Java บงั คบั ใหเราตองตรวจสอบการทํางานกับ I/O เอง ซ่งึ ถา หากมปี ญหาเกิดขน้ึ เราจะไดแกไขไดถูกตอ ง มีวธิ กี ารตรวจสอบและปองกันไมใ หก ารอา นมปี ญ หาหลากหลาย ซงึ่ เราจะไดด กู นั ในโอกาสตอไป (บทท่ี 7) ลองมาดวู า ถาเราไมใ สขอ ความที่วาลงไปในโปรแกรม Radius2.java เราจะได error อะไรRadius2.java:16: unreported exception java.io.IOException; must becaught or declared to be thrown String inputString = buffer.readLine(); ^1 errorจะเห็นวา Java จะบอกใหเรารวู าเราไมส ามารถทจ่ี ะอานขอมลู เขา สูโปรแกรมได ถา เราไมท ําการตรวจสอบดว ยวธิ ที ีไ่ ดกลา วไว ประโยคทว่ี าmust be caught or declared to be thrownกลาวถงึ วธิ ี สองวธิ ี ทเ่ี ราสามารถใชไ ดในการอา นขอ มลู เขาสูโปรแกรม คอื (1) ตรวจจับ – catch และ (2)เรียกใช throws ของ Java ภาควิชาคอมพิวเตอรธ รุ กจิ วิทยาลยั ฟารอีสเทอรน

บทที่ 2 ขอมูล ตวั แปร และ การประมวลผล 53เริ่มตน กบั Javaตอไปจะไดแสดงการใชว ิธที ่หี น่งึ ซ่งึ เปน การตรวจจับ error ในการอา นขอมลู แตจ ะพดู เพียงเพ่ือใหการอา นขอ มูลทาํ ไดสมบรูณเ ทา นน้ั คงจะไมก ลา วถึงอยา งละเอยี ดมากมายนัก เรามาเริม่ ตน ดวยการเขยี นcode เพิม่ ข้ึนใหม ดงั ทแี่ สดงใหเ หน็ น้ี/* Radius2.java - Reading data from keyboard */import java.io.*;class Radius2 { public static void main(String[] args) throws IOException { double radius, area; int meters, centimeters; String inputString = null; try { //prompt user for area of a circle System.out.print(\"Please enter area of a circle: \"); //get string from keyboard InputStreamReader in = new InputStreamReader(System.in); BufferedReader buffer = new BufferedReader(in); inputString = buffer.readLine(); } catch(IOException ioe) {} //convert string to double area = Double.parseDouble(inputString); //calculate radius radius = Math.sqrt(area / Math.PI); //convert to meters and centimeters meters = (int)Math.floor(radius); centimeters = (int)Math.round(100.0 * (radius - meters)); System.out.print(\"Circle with area of \" + area + \" square meters \"); System.out.print(\"has a radius of \" + meters + \" meters and \"); System.out.println(centimeters + \" centimeters\"); }}ส่ิงทเ่ี ราไดป รับปรงุ คือประโยค ตอ ไปน้ีString inputString = null;//prompt user for area of a circleSystem.out.print(\"Please enter area of a circle: \");try { //get string from keyboard InputStreamReader in = new InputStreamReader(System.in); BufferedReader buffer = new BufferedReader(in); inputString = buffer.readLine();}catch(IOException ioe) {}เรายายการประกาศตัวแปร inputString ไปอยกู อ นประโยคทอ่ี านขอมลู เขา พรอมกับเพม่ิ ประโยคtry { … ภาควิชาคอมพิวเตอรธ ุรกจิ วิทยาลยั ฟารอสี เทอรน

บทท่ี 2 ขอมูล ตวั แปร และ การประมวลผล 54เรม่ิ ตนกับ Java … …}catch(IOException ioe) {}เขา สโู ปรแกรมดวยการนาํ เอาประโยคการอานขอ มูลเขาสู string ท้ังสามประโยคไวใน block ของ try {}สว นคาํ วา catch(IOException ioe) {} นัน้ เราก็เพิม่ เขาหลังจาก block ของ try {} เราไมจ าํ เปน ตองใสcode อะไรเขา ไปใน code ของ catch(IOExcpetion ioe) {} เพราะเราเพียงแตตองการใหการอานเปน ไปไดดว ยดเี ทา นัน้ เรายังจะไมก ังวลถงึ error ที่เกดิ ข้นึ ซงึ่ ถา มี error เกิดข้ึน Java ก็จะเปน ผฟู อ งใหเราทันทีเพ่อื ใหเกดิ ความเขา ใจอกี สกั หนอย เราจะมาตรวจสอบการใสข อ มูลของผใู ชด ูวา ไดม กี ารใสข อ มลู เขา สูโปรแกรม หรือเพยี งแตก ดปุม Enter เฉย ๆ เราทําการตรวจสอบดวยการเพิ่ม try {..} และ catch() {}ใหก ับโปรแกรม Radius2.java ดังนี้/* Radius2.java - Reading data from keyboard */import java.io.*;class Radius2 { public static void main(String[] args) { double radius, area; int meters, centimeters; String inputString = null; //prompt user for area of a circle System.out.print(\"Please enter area of a circle: \"); try { //get string from keyboard InputStreamReader in = new InputStreamReader(System.in); BufferedReader buffer = new BufferedReader(in); inputString = buffer.readLine(); try { //convert string to double area = Double.parseDouble(inputString); //calculate radius radius = Math.sqrt(area / Math.PI); //convert to meters and centimeters meters = (int)Math.floor(radius); centimeters = (int)Math.round(100.0 * (radius - meters)); System.out.print(\"Circle with area of \" + area + \" square meters \"); System.out.print(\"has a radius of \" + meters + \" meters and \"); System.out.println(centimeters + \" centimeters\"); } //catch empty string (user hits Enter) catch(Exception e) { System.out.println(\"Error! you must supply input\"); e.printStackTrace(); System.exit(1); } } //catch other I/O error - do nothing catch(IOException ioe) { /* leave it to Java! */ } } ภาควิชาคอมพิวเตอรธ ุรกิจ วิทยาลัยฟารอสี เทอรน

บทท่ี 2 ขอ มูล ตัวแปร และ การประมวลผล 55เริ่มตน กับ Java}โปรแกรม Radius2.java ทีเ่ ราเขียนข้ึนใหมม ี try {…} และ cath() {} อยูสองตัว ตัวแรกใชตรวจสอบเรื่องของการอานท่วั ไปทไี่ ดก ลา วไปแลว สว นตวั ทสี่ องเปน การตรวจสอบวาผูใชม ีการใสข อมลู หรือไม ซึง่ถาไมใ ส เราก็จะ1. สง ขอความไปยังหนา จอดวยคาํ สง่ั System.out.println(\"Error! you must supply input\");2. สง ขอ ความ error ที่ Java ไดฟ อ งไว ดว ยคาํ สง่ั e.printStackTrace();3. ออกจากโปรแกรมโดยไมมีการประมวลผลใด ๆ ท้ังส้นิ ดว ยคําสง่ั System.exit(1);และเม่อื execute ดเู รากจ็ ะไดข อความดังน้ีPlease enter area of a circle: < ผใู ชก ดปมุ Enter >Error! you must supply inputjava.lang.NumberFormatException: empty String atjava.lang.FloatingDecimal.readJavaFormatString(FloatingDecimal.java:986) at java.lang.Double.parseDouble(Double.java:202) at Radius2.main(Radius2.java:22)โดยทั่วไปการออกจากโปรแกรมทไี่ มมีปญหาใด ๆ ในการเขยี นดว ยภาษา Java นั้นเราจะใชก ารออกดวยเลข 1 ในประโยค System.exit(1) หรอื เลขอน่ื ๆ ที่ไมใช 0 สวนการออกแบบปกตนิ น้ั เราใชเ ลข 0 แทนเลข 1เราคงจะพักการตรวจสอบ หรอื ตรวจจบั error ไวเ พยี งแคน ก้ี อนเราจะกลบั มาพูดถงึ การเขียน codeรองรบั error ในบทอนื่ ตอไปสรปุเราไดเ รยี นรูถ ึงขอมลู ชนิดตา ง ๆ ท่เี ปน ขอ มูลแบบพนื้ ฐาน หรือทเ่ี รยี กวา primitive datatype ท่ี Java มีให รวมไปถึงการประกาศตวั แปร การกาํ หนดคา ใหกับตัวแปร การประมวลตวั แปรชนดิ เดยี วกัน และ ตางชนิดกนั การเปลย่ี นชนดิ ของขอ มูล (casting) การใช method ทีเ่ ก่ียวของกับตัวเลข การแสดงผลตัวเลขทีม่ ีจดุ ทศนยิ ม การอา นขอมูลเขา สโู ปรแกรม และการตรวจสอบ และตรวจจบั error ทีอ่ าจเกดิ ขึน้ ในการอานขอ มูลแบบฝก หดั1. จงอธิบายถึงความหมายของคาํ วา final พรอมท้ังยกตวั อยางประกอบ2. จงอธบิ ายถึงความแตกตา งระหวาง 5, 5.0, '5', \"5\", และ \"5.0\"3. จงหาผลลพั ธของการประมวลผลประโยคตอไปน้ี ถา กําหนดให double x = 4.5; double y = -45.25; int p = 12; int q = 2; 3.1. x + p * y / (p – y) * x 3.2. p % (p – q) 3.3. (int) y 3.4. (int) p 3.5. Math.round(x) 3.6. (int) Math.round(y) ภาควิชาคอมพิวเตอรธ ุรกิจ วิทยาลัยฟารอ สี เทอรน

บทท่ี 2 ขอ มลู ตวั แปร และ การประมวลผล 56เริ่มตนกับ Java3.7. -2 * y + (int) x3.8. q/p3.9. p%q3.10. y * y – y + (x * (int) x)4. จงเขยี นโปรแกรมทรี่ ับตวั เลขชนดิ int จาก keyboard จาํ นวน 2 ตัว และขอมลู ชนิด double อีก 2 ตัว หลังจากนั้นใหโ ปรแกรมคํานวณหาผลรวมของเลขทง้ั 4 ตวั ใหเ กบ็ ผลลัพธท ่ีหาไดไวใ นตวั แปรตวั ใหม สง ผลลพั ธทไ่ี ดไ ปยงั หนา จอ5. จงเขียนประโยคดว ยภาษา Java จากสมการท่ีใหนี้5.1. a + bc / 25.2. a(a – c) + b(b – c) – (c(c – a) / d)5.3. b2 – 4ac5.4. (4/3)2 / 25.5. q =  T1 xM  + T2  D−k 6. จงเขียนโปรแกรมทท่ี าํ การเปลยี่ น องศา Celsius ใหเ ปนองศา Fahrenheit โดยกาํ หนดใหข อ มลู ท่ี ตองการเปลยี่ น นําเขาจาก keyboard โดยกําหนดใหส ตู รการเปลี่ยน คือCelsius = 5 (Fahrenheit – 32) 97. จงเขียนโปรแกรมทท่ี ําการเปลย่ี น องศา Fahrenheit ใหเปนองศา Celsius โดยกาํ หนดใหข อ มลู ท่ี ตองการเปลยี่ น นําเขาจาก keyboard8. จงเขียนโปรแกรมทร่ี ับขอ มลู ทเ่ี ปน จํานวนกิโลกรัมจาก keyboard เปลี่ยนใหเ ปน mile สง ผลลัพธไป ยงั หนาจอ9. จงเขียนโปรแกรมทีอ่ านขอมูลจาก keyboard ท่เี ปนอายขุ องผใู ชใ นรูปแบบของป ใหโปรแกรม เปลีย่ นเปนจาํ นวนวนั สงผลลพั ธอ อกทางหนา จอ (กําหนดให 1 ปเ ทา กบั 365 วัน)10. จงเขียนโปรแกรมทร่ี บั int จาํ นวน 5 ตวั หาคา เฉลยี่ ของตวั เลขเหลา นี้ เสรจ็ แลวสงผลลพั ธไ ปยงั หนาจอ11. จงเขยี นโปรแกรมทคี่ าํ นวณหาเวลาท่ีแสงเดินทางจากโลกไปยังดวงอาทติ ย ใหส ง ผลลพั ธของการ คํานวณในรปู แบบของนาที สง ผลลพั ธท หี่ าไดไ ปยงั หนา จอ12. สมมตวิ า อาจารยท ุกคนในวทิ ยาลยั แหง หน่งึ ดม่ื beer 1 ขวดตอ วนั และในการทาํ beer 1 ลัง (24 ขวด) น้นั ตองใชข า ว barley จํานวน 1 ถงั ถา จํานวนของอาจารยใ นวทิ ยาลยั ทวี่ าน้มี ที ง้ั สิน้ 200 คน จงเขียนโปรแกรมในการคํานวณหาจาํ นวนของขาว barley ที่ตอ งใชในการทาํ beer ใหเ พียงพอตอ การบริโภคของอาจารยใ นวทิ ยาลยั น้ีตลอดภาคการศึกษา13. จงเขียนโปรแกรมทรี่ ับขอ มูลชนิด long ท่มี จี าํ นวนของตวั เลข (digit) อยูร ะหวาง 10 – 12 ตวั ใหส ง ผลลัพธใ นรูปแบบของ ตวั เลขทใ่ี ชเ ครอื่ งหมาย , เปน ตัวแบงกลุม โดยเร่มิ ตน จากทางขวามอื และให มีตัวเลขกลมุ ละ 3 ตัวไปยงั หนา จอ14. จงเขยี นโปรแกรมทร่ี บั คา ความยาวของดา นทกุ ดา นของสามเหล่ียม จากน้ันใหค ํานวณหาคา ของเสน รอบรปู (perimeter) สงผลลพั ธไปยงั หนา จอ15. จงเขยี นโปรแกรมทค่ี าํ นวณหาพืน้ ทข่ี องวงกลม จากรัศมที ร่ี ับเขามาจาก keyboard ภาควิชาคอมพิวเตอรธ ุรกจิ วทิ ยาลยั ฟารอ สี เทอรน

บทที่ 2 ขอ มลู ตัวแปร และ การประมวลผล 57เร่มิ ตน กบั Java16. จงเขียนโปรแกรมทร่ี บั ขอ มูลชนดิ double จาํ นวน 5 ตัวจาก keyboard จากนั้นใหค ํานวณหา คา เฉลย่ี ของตวั เลขเหลา นน้ั สงผลลพั ธท ห่ี าไดไปยังหนาจอ17. กาํ หนดใหเสน ผา ศนู ยกลางของดวงอาทติ ยเทากับ 865,000 ไมล และเสน ผา ศูนยกลางของโลก เทา กบั 7,600 ไมล จงเขียนโปรแกรมที่คาํ นวณหา17.1. ปรมิ าตรของโลก (cubic mile หรือ mile3)17.2. ปรมิ าตาของดวงอาทิตย (cubic mile)17.3. อตั ราสวนของปริมาตรของดวงอาทิตยต อ ปรมิ าตรของโลก18. จงเขยี นโปรแกรมทรี่ ับขอ มลู ชนดิ double ท่อี ยใู นรูปแบบ 123.4567 จาก keyboard จากน้ันใหด งึ เอาสว นของขอ มลู ท่อี ยหู นาจดุ ทศนยิ มไปเกบ็ ไวในตัวแปรท่ีมชี นิดเปน long ตัวหนึง่ เสร็จแลวใหเ กบ็ ขอ มูลทีอ่ ยูหลังจดุ ทศนยิ มไปเก็บไวใ นตัวทเี่ ปน long อกี ตวั หนง่ึ สงผลลพั ธท ีอ่ ยูในตัวแปร long ทงั้ สองไปยังหนา จอ ภาควิชาคอมพิวเตอรธ ุรกจิ วทิ ยาลยั ฟารอ สี เทอรน

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

บทท่ี 3 การประมวลผลแบบวน (Repetition) 59เริ่มตน กบั Javaif(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 ใสเ ขาสโู ปรแกรมเปน เลขคหู รอื ไม/* IfStatement.java - Using if statement to find out whether a number * is odd or even*/import java.io.*;import java.lang.Integer;class IfStatement { public static void main(String[] args) throws IOException { ภาควิชาคอมพิวเตอรธ ุรกจิ วทิ ยาลัยฟารอีสเทอรน

บทท่ี 3 การประมวลผลแบบวน (Repetition) 60เรม่ิ ตน กับ Java int number; //set up buffer stream InputStreamReader isr = new InputStreamReader(System.in); BufferedReader buffer = new BufferedReader(isr); //get input string System.out.print(\"Enter a number (int): \"); String input = buffer.readLine(); //convert string to int number = Integer.parseInt(input); //check if number is even or not if(number % 2 == 0) System.out.println(number + \" is an even number.\"); }}โปรแกรม IfStatement.java บอก user ใหใสต วั เลขหน่งึ ตวั ซง่ึ โปรแกรมไดจัดเก็บไวในตัวแปรชอื่number หลงั จากนั้นก็ทําการตรวจสอบวาตวั เลขท่อี านมาเปน เลขคูหรอื ไมด ว ยประโยคif(number % 2 == 0) System.out.println(number + \" is an even number.\");ซงึ่ ถา นําสองไปหาร number แลวไมม ีเศษ (หารลงตวั ) แสดงวาตวั เลขท่ีวา น้เี ปน เลขคู ซงึ่ โปรแกรมก็จะแสดงขอ ความไปยังหนาจอบอกผูใชวา ตวั เลขทใ่ี สเ ขา มาเปน เลขคู ดงั เชน ผลลัพธของการ run น้ีEnter a number (int): 45Enter a number (int): 2020 is an even number.โปรแกรมของเรายงั ไมใ ชโ ปรแกรมทสี่ มบรูณ ดังจะเห็นไดจ ากผลลัพธท ีไ่ ด ถาเราใส 45 โปรแกรมกจ็ ะไมแสดงอะไรเลย จะแสดงกต็ อ เมอ่ื ตัวเลขท่ีใสเปน เลขคูเ ทา น้ัน เราจะกลับมาดวู าเราตองทาํ อยา งไร ถึงจะสามารถท่จี ะแสดงขอความไปยงั หนาจอโดยแบงแยกวาตัวเลขนน้ั เปน เลขคูหรอื เลขคี่การใช 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!\");} ภาควิชาคอมพิวเตอรธรุ กิจ วิทยาลยั ฟารอีสเทอรน

บทที่ 3 การประมวลผลแบบวน (Repetition) 61เร่ิมตนกับ Javaทนี เ้ี ราจะกลับไปยงั ประเดน็ ที่เราพดู ถงึ กอ นหนา น้ี เกีย่ วกบั เรือ่ งของการแสดงผลทง้ั ท่ีเปนจรงิ และไมเปนจริง ในการตรวจสอบดวยการใช if น้ันเราสามารถท่ีจะบังคับการประมวลผลใหเ กิดขน้ึ ทั้งท่ีเปน จรงิ และเปนเทจ็ อยา งใด อยางหนึง่ ดวยการใช else ตามหลงั ประโยคท่ีตาม if มาอกี ทีหน่งึรปู แบบโครงสรา งของประโยค if – else นีม้ ดี ังนี้if(expression) statement;else other_statement;another_statement;ภาพท่ี 3.2 แสดงถึงโครงสรา งของ if – else yes เปน จริง? no statement other_statement another_statementภาพที่ 3.2 การใช if - elseจากโปรแกรม IfStatement.java ถา เราตองการทจ่ี ะแสดงผลถา ตวั เลขท่ี user ใสเขา สูโปรแกรมเปนเลขคี่ เรากต็ อ งเปลย่ี น code ของเราใหเ ปนดังนี้/* IfElse.java - Using if - else statement to find out whether a * number is odd or even*/import java.io.*;import java.lang.Integer;class IfElse { public static void main(String[] args) throws IOException { int number; //set up buffer stream InputStreamReader isr = new InputStreamReader(System.in); BufferedReader buffer = new BufferedReader(isr); //get input string System.out.print(\"Enter a number (int): \"); String input = buffer.readLine(); ภาควิชาคอมพิวเตอรธ ุรกจิ วทิ ยาลัยฟารอีสเทอรน

บทที่ 3 การประมวลผลแบบวน (Repetition) 62เรม่ิ ตนกับ Java//convert string to intnumber = Integer.parseInt(input);//check if number is even or notif(number % 2 == 0) System.out.println(number + \" is an even number.\");else System.out.println(number + \" is an odd number.\"); System.out.println(\"Good Bye.\"); }}ประโยคทีเ่ ราไดเขียนเพิม่ เขาสูโ ปรแกรมของเรา คือelse System.out.println(number + \" is an odd number.\");System.out.println(\"Good Bye.\");ซ่งึ จะทาํ ใหโ ปรแกรมของเราทาํ การประมวลผลประโยคทอ่ี ยถู ัดมาจาก else ถา number % 2 == 0 เปนเทจ็ และตัวเลขที่จะทําใหป ระโยคนถี้ ูกประมวลผลกค็ ือ ตวั เลขท่ีเปนเลขค่ี (นาํ 2 ไปหารแลว เหลอื เศษ)ลองดูผลลัพธของการ run นี้Enter a number (int): 4545 is an odd number.Good Bye.Enter a number (int): 8080 is an even number.Good Bye.จะเหน็ วาการนาํ เอา if – else มาใชท าํ ใหโ ปรแกรมของเราสนองตอบความตอ งการในการแสดงผล เมอื่การตรวจสอบไดผลที่เปน จริงทางหนึง่ และเมือ่ ผลของการตรวจสอบเปนเทจ็ อีกทางหนง่ึเนอื่ งจาก 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) หรือ statement 3; if(expression 2) else { statement 3; statement 4; else { statement 5; statement 4; } statement 5; }จากโครงสรา งตัวอยา งดา นบนนป้ี ระโยคทจ่ี ะไดรบั การประมวลผลถา expression 1 เปนจริงคือstatement 1 และ statement 2 สว น statement 3 จะไดร บั การประมวลผล ถา expression 2 เปน จริงและ statement 4 และ statement 5 จะไดร บั การประมวลผลกต็ อเมื่อ expression 1 และ expression 2เปน เท็จ ภาควิชาคอมพิวเตอรธรุ กจิ วทิ ยาลัยฟารอีสเทอรน

บทที่ 3 การประมวลผลแบบวน (Repetition) 63เรมิ่ ตนกับ Javaลองมาดูโปรแกรมตวั อยา งการใช Nested – if ในโปรแกรม Grades.java/* Grades.java - Using Nested - if finding letter grade * from a given score*/import java.io.*;import java.lang.Integer;class Grades { public static void main(String[] args) throws IOException { int score; char grade; //set up buffer stream InputStreamReader isr = new InputStreamReader(System.in); BufferedReader buffer = new BufferedReader(isr); //get input string System.out.print(\"Enter your score: \"); String input = buffer.readLine(); //convert string to int score = Integer.parseInt(input); //determine grade by given score if(score >= 90) grade = 'A'; else if(score >= 80) grade = 'B'; else if(score >= 70) grade = 'C'; else if(score >= 60) grade = 'D'; else grade = 'F'; System.out.println(\"Your grade is \" + grade); }}โปรแกรม Grades.java ใชเกณฑก ารใหเ กรดคอื ถา score มีคามากกวา หรือเทา กบั 90 ได Aมากกวา หรอื เทา กับ 80 ได B (อยูระหวา ง 80 ถงึ 89)มากกวา หรือเทา กบั 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 ดว ยขอมลู บางสว น ภาควิชาคอมพิวเตอรธ รุ กจิ วทิ ยาลัยฟารอ สี เทอรน

บทท่ี 3 การประมวลผลแบบวน (Repetition) 64เร่มิ ตนกบั JavaEnter your score: 87Your grade is BEnter your score: 45Your grade is FEnter your score: 92Your grade is Aเราสามารถทจ่ี ะเขียนโปรแกรม Grades.java ขึน้ ใหมดว ยการใช operator && หรือ || ชว ยในการตรวจสอบถงึ สถานะภาพของ score วา อยูใ นกลมุ ใด ลองมาดูกัน/* Grades2.java - Using Nested - if finding letter grade * from a given score*/import java.io.*;import java.lang.Integer;class Grades2 { public static void main(String[] args) throws IOException { int score; char grade; //set up buffer stream InputStreamReader isr = new InputStreamReader(System.in); BufferedReader buffer = new BufferedReader(isr); //get input string System.out.print(\"Enter your score: \"); String input = buffer.readLine(); //convert string to int score = Integer.parseInt(input); //determine grade by given score if(score >= 90) grade = 'A'; else if(score >= 80 && score <= 89) grade = 'B'; else if(score >= 70 && score <= 79) grade = 'C'; else if(score >= 60 && score <= 69) grade = 'D'; else grade = 'F'; System.out.println(\"Your grade is \" + grade); }}เราเปล่ยี น code ในการตรวจสอบใหมใ หเปนif(score >= 90) grade = 'A';else if(score >= 80 && score <= 89) grade = 'B';else if(score >= 70 && score <= 79) ภาควิชาคอมพิวเตอรธ รุ กิจ วทิ ยาลัยฟารอสี เทอรน

บทที่ 3 การประมวลผลแบบวน (Repetition) 65เริม่ ตน กับ Java grade = 'C';else if(score >= 60 && score <= 69) grade = 'D';else grade = 'F';ซงึ่ เมื่อไดลอง run ดูแลวกไ็ ดผ ลลัพธเหมือนกนั กับท่ีไดจากโปรแกรม Grades.java แตขน้ั ตอนของการตรวจสอบไมเหมือนกนั เราไดพ ดู กอ นหนาน้วี า ถา มีการใช && และคาของประโยคท่อี ยูท างดา นหนา ของ&& มีคา เปนจรงิ ประโยคทีอ่ ยทู างดา นหลังกจ็ ะไดร บั การประมวลผลดว ย เชน สมมตวิ า score มีคาเปน85 การประมวลผลใน if แรกจะเปนเทจ็ Java ก็จะประมวลผล if ท่ีสอง คอื else if(score >= 80 &&score <= 89) ซึ่งท่ีนเ่ี องที่ Java จะประมวลผลประโยคทอ่ี ยูหลัง && ดว ยเพราะประโยคที่อยทู างดา นหนา คือ score >= 80 นนั้ เปนจรงิ กรณีอื่น ๆ ทีม่ ีลกั ษณะคลายกนั กจ็ ะถกู ประมวลผลในแบบเดียวกันนี้ซง่ึ เปนการประมวลผลทซ่ี าํ้ ซอ น ทั้ง ๆ ทไี่ มม คี วามจาํ เปน ที่ตอ งทําเลย แตน เี่ ปน เพยี งตวั อยา งเดียวเทา นั้นมีกรณอี กี หลายกรณที ่ี ตองใช && หรอื || เขา มาชว ยในการตรวจสอบจรงิ ๆ เชน ในกรณีของโปรแกรมตอไปน้ี ซึง่ เปน โปรแกรมตรวจสอบวา ตวั อกั ษรทีก่ ําหนดใหอ ยูในกลุมนน้ั ๆ หรือไม/* UpperLower.java - Using && in if - else statement */import java.io.*;class UpperLower { public static void main(String[] args) throws IOException { char ch = 'F'; if(ch >= 'A' && ch <= 'Z') System.out.println(ch + \" is an uppercase letter.\"); else if(ch >= 'a' && ch <= 'z') System.out.println(ch + \" is a lowercase letter.\"); }}โปรแกรมกาํ หนดใหต วั แปร ch มีคา เปน อกั ษร F ตัวใหญ และใชประโยค if – else ทําการตรวจสอบวาตวั อกั ษรทวี่ า นเ้ี ปน อักษรตัวใหญหรือตวั เล็ก ซ่งึ กแ็ นนอนวา ผลลัพธท ีไ่ ดจ ะตอ งเปนตวั ใหญ แตเ ราตองการทีจ่ ะแสดงใหเหน็ ถึงการใช && เขามาชวยในการตรวจสอบคา ของ ch ทเ่ี ราไดก ําหนดข้ึนในการเปรียบเทยี บนนั้ Java จะใชค า ASCII (Unicode) ในการเปรียบเทยี บตัวอกั ษรทั้งสองตวั โดยในตอนแรกจะเปรยี บเทียบ F กบั A (70 กบั 65) ซง่ึ ผลของการเปรยี บเทยี บเปนจรงิ จึงตอ งเปรียบเทยี บ Fกับ Z (70 กบั 90) ซึง่ กเ็ ปน จรงิ ดงั น้ันประโยคทตี่ ามมา System.out.println(ch + \" is an uppercaseletter.\"); จงึ ไดรบั การประมวลผล เชน เดยี วกนั กับตวั อกั ษรตวั เลก็ ถา ch เกบ็ อกั ษรท่ีเปนตัวเล็กอยูการเปรยี บเทยี บจะเกิดขึ้นในประโยค else – if ทต่ี ามมาโปรแกรมตอ ไปนี้แสดงการใช || ในการตรวจสอบวาเดอื นทก่ี าํ หนดใหอ ยูในฤดูอะไร/* Season.java - Using || in if - else statement */import java.io.*;import java.lang.Integer;class Season { public static void main(String[] args) throws IOException { int month; String season, input; InputStreamReader in; BufferedReader buffer; System.out.print(\"Enter month (1 – 12): \"); in = new InputStreamReader(System.in); ภาควิชาคอมพิวเตอรธ รุ กิจ วิทยาลยั ฟารอสี เทอรน

บทที่ 3 การประมวลผลแบบวน (Repetition) 66เร่ิมตนกับ Java buffer = new BufferedReader(in); input = buffer.readLine(); month = Integer.parseInt(input); if(month == 3 || month == 4 || month == 5 || month == 6) season = \"Summer\"; else if(month == 7 || month == 8 || month == 9 || month == 10) season = \"Rainy\"; else if(month == 11 || month == 12 || month == 1 || month == 2) season = \"Winter\"; else season = \"Never heard of it!\"; System.out.println(month + \" is in \" + season); }}โปรแกรม Season.java ใช || ในการตรวจสอบวา month ท่ี user ใสเ ขา สูโปรแกรมนน้ั อยูใ นฤดอู ะไรโดยเรากําหนดใหเดอื น 3 – 6 เปนฤดรู อ น 7 – 10 เปน ฤดูฝน และ 11 – 2 เปน ฤดูหนาว (ซงึ่ เดยี วนช้ี ักจะไมแนนอนเสียแลว) ลองมาดผู ลลัพธจ ากการ run ดกี วาEnter month (1 – 12): 44 is in SummerEnter month (1 – 12): 88 is in RainyEnter month (1 – 12): 11 is in WinterEnter month (1 – 12): 2020 is in Never heard of it!Operator || นั้นเปน การเปรยี บเทยี บขอ มูลทอ่ี าจเปนไดหลาย ๆ อยา ง ดงั ทเี่ หน็ ในโปรแกรม ถาเราใหคาของ month เปน 3 4 5 หรือ 6 เรากก็ าํ หนดให season มคี า เปน Summer สว นเดือนอื่น ๆ กเ็ ชน เดยี วกันในทางตรงกนั ขา มถา เราใช && แทนโปรแกรมของเรากจ็ ะไมทาํ งานตามท่เี ราคาดหวงั ไว กลา วคอื คา ของmonth ไมสามารถเปนไปไดท ง้ั สคี่ า โปรแกรมกจ็ ะประมวลผลประโยคท่ีตาม else ตัวสดุ ทา ยตลอดไปผูอา นควรตรวจสอบวาทก่ี ลา วมาน้ี เปนจรงิ หรอื ไมในการใช Nested if – else นนั้ เราจะตอ งระวงั วา ทกุ ๆ if ท่ีเราใชจะตองมี else หรือไมเ พราะ Java จะตรวจสอบวา else ท่ใี ชน ้นั วามี if อยูกอ นหนาหรอื ไม สมมติวา มเี ราก็ตอ งระวงั ในเรื่องของขน้ั ตอนการตรวจสอบ วา เปน ไปอยางท่ีเราตง้ั ใจหรอื ไม เชนตวั อยา งนี้/* DanglingElse.java */import java.io.*;class DanglingElse { public static void main(String[] args) { int x = 7, y = 99; if(x > 5) if(y > 5) System.out.println(\"x and y is greater than 5\"); else System.out.println(\"x is less than 5\"); ภาควิชาคอมพิวเตอรธ รุ กจิ วิทยาลยั ฟารอ สี เทอรน

บทท่ี 3 การประมวลผลแบบวน (Repetition) 67เร่ิมตนกบั Java }}โปรแกรม 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) System.out.println(\"x and y is greater than 5\"); else System.out.println(\"x is less than 5\");เพราะฉะน้นั ถาเราตอ งการใหการประมวลผลเปน ไปตามทีเ่ ราตอ งการ เราตอ งใช {} เปนตวั ชวย ดงั นี้if(x > 5) { if(y > 5) System.out.println(\"x and y is greater than 5\"):}else System.out.println(\"x is greater than 5\");ซึ่งเม่ือ run ดแู ลวก็จะไดผ ลลพั ธเ ปน ไปตามทเ่ี ราตอ งการ คอื ไมมีผลลพั ธใ ด ๆ แสดงไปยงั หนาจอถา yมนี อยกวา หรอื เทากบั 0ถงึ เวลาท่เี ราจะกลบั ไปปรบั ปรงุ โปรแกรม Quadratic.java ที่เราไดพ ดู ถงึ ในบททสี่ อง เพอื่ ใหม กี ารตรวจสอบคา ของ determinant ทีอ่ าจเปน 0 ดว ยการใช if ในประโยค//calculate determinantdouble d = b * b – 4 * a * c;if(d <= 0) { System.err.println(\"Error: cannot find square root\"); System.exit(1);}double det = Math.sqrt(d);เราไดกาํ หนดใหม ีการตรวจสอบคา ของ d กอนการเรยี กใช Math.sqrt() ถา คาของ d นอ ยกวา หรอื เทากับ0 เราจะฟอ งไปยงั user พรอมกบั ยุตกิ ารทาํ งานของโปรแกรมทันที ดวยการเรียกใช System.exit(1)/* Quadratic.java - Calculating roots of function */class Quadratic { public static void main(String[] args) { double a, b, c; //4x2 + 20x + 16 = 0 a = 4; b = 20; c = 16; //calculate determimant double d = b * b – 4 * a * c; ภาควิชาคอมพิวเตอรธ รุ กจิ วิทยาลยั ฟารอีสเทอรน

บทที่ 3 การประมวลผลแบบวน (Repetition) 68เรม่ิ ตน กับ Java if(d <= 0) { System.err.println(\"Error: cannot find square root\"); System.exit(1); } double det = Math.sqrt(d); //calculate roots double x1 = (-b + det) / (2 * a); double x2 = (-b - det) / (2 * a); System.out.println(\"Root 1 = \" + x1); System.out.println(\"Root 2 = \" + x2); }}การใช Conditional Operator (? :)Java มี operator อีกตัวหนงึ่ ทเ่ี ราสามารถนาํ มาใชแทน if – else ได เราเรียก operator ตวั นีว้ าConditional operator หรอื operator ทีม่ ี expression (statement) อยสู ามตวั ซ่งึ มโี ครงสรางดงั นี้ คือ(expression) ? (true statement) : (false statement);เชน(number % 2 == 0) ? System.out.println(\"Even number.\") : System.out.println(\"Odd number.\");ลองดโู ปรแกรมตวั อยางกนั/* OddEven.java */import java.io.*;class OddEven { public static void main(String[] args) { int num; String result; num = (int)(Math.random() * 100; result = (num % 2 == 0) ? \"Even\" : \"Odd\"; System.out.println(num + \" is an \" + result + \" number.\"); }}โปรแกรม OddEven.java ใช operator ? : ในการตรวจสอบวา num เปนเลขคูหรือ เลขคี่ ซึ่งถา เปนอยางใดอยา งหนง่ึ ก็จะเก็บขอมลู นนั้ (Even หรอื Odd) ไวใ นตวั แปร result แลว จึงแสดงผลไปยังหนา จอหลังจากน้นั ดงั น้ี65 is an Odd number.โปรแกรม Min.java ที่เห็นดานลางนใี้ ช operator ? : ในการหาคา ตัวเลขทนี่ อ ยทสี่ ดุ ระหวา งเลขสองตวั ท่ีกาํ หนดให/* Min.java */import java.io.*;class Min { ภาควิชาคอมพิวเตอรธรุ กิจ วิทยาลัยฟารอสี เทอรน

บทท่ี 3 การประมวลผลแบบวน (Repetition) 69เร่มิ ตนกบั Java public static void main(String[] args) { int num1 = 45, num2 = 89; int min = (num1 < num2) ? num1 : num2; System.out.println(\"Min number is \" + min); }}ผลลัพธท ไ่ี ดจ ากการ run คอืMin number is 45การใช operator ? : ก็คอื การใช if – else นนั่ เองดงั น้ันก็เปนเรือ่ งของผเู ขียนโปรแกรมเองวาอยากทจี่ ะใชoperator ตวั ไหน เพราะท้งั สองใหผลการประมวลผลในลกั ษณะเดียวกันการใช switchJava มคี าํ สง่ั อกี ตัวหน่งึ ที่เราสามารถนํามาใชแ ทน 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 ภาควิชาคอมพิวเตอรธ ุรกิจ วทิ ยาลัยฟารอ ีสเทอรน

บทที่ 3 การประมวลผลแบบวน (Repetition) 70เร่ิมตน กบั Java เปน จริง? yes break no statement break ทาํ คําส่ังอืน่ ๆ เปน จริง? yes statement ในโปรแกรม no break defaultภาพท่ี 3.3 ขน้ั ตอนการทาํ งานของ switchคาํ สง่ั break ใน switch น้ันสาํ คญั มาก ๆ ถา เราไมใ ส การทํางานของ switch ก็จะไมไดผ ลลพั ธด งั ทเี่ ราไดค าดการณไว เราลองมาดตู วั อยางโปรแกรมการใช switch ดู/* Switch.java - Using switch * to differentiate input*/import java.io.*;import java.lang.Integer;class Switch { public static void main(String[] args) throws IOException { int month; String season, input; InputStreamReader in; BufferedReader buffer; System.out.print(\"Enter month (1 – 12): \"); in = new InputStreamReader(System.in); buffer = new BufferedReader(in); input = buffer.readLine(); month = Integer.parseInt(input); switch(month) { case 3: case 4: case 5: case 6: season = \"Summer\"; break; case 7: case 8: case 9: case 10: season = \"Rainy\"; break; case 11: case 12: case 1: case 2: season = \"Winter\"; break; default : season = \"Never heard of it!\"; ภาควิชาคอมพิวเตอรธ ุรกจิ วทิ ยาลยั ฟารอ ีสเทอรน

บทที่ 3 การประมวลผลแบบวน (Repetition) 71เรม่ิ ตนกบั Java break; } System.out.println(month + \" is in \" + season); }}เราไดท าํ การเปล่ยี นแปลงโปรแกรม 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 4case 5 และจนกระทัง่ มาถึง case 6 ซ่ึงเปน case สุดทา ยในกลมุ Java จงึ ประมวลผลประโยค season =\"Summer\" และ breakการนําเอา case ตา ง ๆ มาตอกันในลักษณะนมี้ ผี ลเหมอื นการประมวลผลดว ยการใช operator || ในประโยคทเ่ี รียกใช if ผอู า นควรสงั เกตถงึ การใช switch ในลกั ษณะน้ใี หดี เพราะเปนวิธกี ารทช่ี ว ยลดขนั้ ตอนการเขียนไดด ีพอสมควรผลลัพธท ี่ไดจ ากการ run โปรแกรม Switch.java ก็เหมอื นกันกับการ run โปรแกรม Season.javaเรามาลองดตู วั อยางการใช switch อกี สักตัวหนง่ึ/* Switch2.java */import java.io.*;import java.lang.Integer;class Switch2 { public static void main(String[] args) throws IOException { int digit; BufferedReader buffer; InputStreamReader isr; String input; System.out.print(\"Enter a digit: \"); isr = new InputStreamReader(System.in); buffer = new BufferedReader(isr); input = buffer.readLine(); digit = Integer.parseInt(input); switch(digit) { case 1: System.out.println(\"You entered ONE.\"); break; case 2: System.out.println(\"You entered TWO.\"); break; case 3: System.out.println(\"You entered THREE.\"); break; case 4: System.out.println(\"You entered FOUR.\"); break; case 5: System.out.println(\"You entered FIVE.\"); break; case 6: System.out.println(\"You entered SIX.\"); ภาควิชาคอมพิวเตอรธ รุ กจิ วิทยาลยั ฟารอ สี เทอรน

บทที่ 3 การประมวลผลแบบวน (Repetition) 72เร่มิ ตนกับ Java break; case 7: System.out.println(\"You entered SEVEN.\"); break; case 8: System.out.println(\"You entered EIGHT.\"); break; case 9: System.out.println(\"You entered NINE.\"); break; case 0: System.out.println(\"You entered ZERO.\"); break; default: System.out.println(\"Sorry - not a digit!\"); break; } }}โปรแกรม Switch2.java บอก User ใหใ สต ัวเลขระหวาง 0 – 9 และจะแสดงตัวหนังสือแทนตวั เลขเหลานน้ั กลับไปยงั หนาจอ ซงึ่ เมอื่ run แลว กจ็ ะไดผ ลลพั ธด งั น้ีEnter a digit: 9You entered NINE.Enter a digit: 2You entered TWO.Enter a digit: 36Sorry - not a digit!เม่ือเราใส 36 โปรแกรมกลับบอกวา ไมใชตัวเลข ทงั้ น้ีเพราะโปรแกรมของเราตรวจสอบเฉพาะตวั เลขเพยี งตวั เดยี วเทาน้ัน เราตองปรบั ปรงุ โปรแกรมของเราใหมถ าเราตอ งการทจี่ ะตรวจสอบตัวเลขจรงิ ๆ ท้ังหมดการทาํ งานแบบวน (Loop)หลาย ๆ ครัง้ ทโ่ี ปรแกรมเมอรต อ งการทจี่ ะใหโ ปรแกรมทําการประมวลผลในรปู แบบเดิมซา้ํ ๆ กนั เชน คณูตวั เลข 1 – 10 ดวย 2 หรือ อา นขอ มูลจาก keyboard จนกวา user จะพอใจ เราสามารถนาํ เอาชดุ คาํ ส่งั ท่ีJava มใี หม าใชก ับการทาํ งานทวี่ าน้ไี ดอ ยางไมย ากนัก ลองดโู ปรแกรมทที่ าํ การแสดงคา จาก 1 – 10 ไปยงั หนา จอน้ี/* ForLoop.java */import java.io.*;class ForLoop { public static void main(String[] args) { int number = 1; System.out.println(\"Number now is \" + number); number++; System.out.println(\"Number now is \" + number); number++; System.out.println(\"Number now is \" + number); number++; System.out.println(\"Number now is \" + number); number++; System.out.println(\"Number now is \" + number); number++; System.out.println(\"Number now is \" + number); number++; ภาควิชาคอมพิวเตอรธรุ กิจ วิทยาลยั ฟารอ ีสเทอรน

บทที่ 3 การประมวลผลแบบวน (Repetition) 73เรม่ิ ตนกบั Java System.out.println(\"Number now is \" + number); number++; System.out.println(\"Number now is \" + number); number++; System.out.println(\"Number now is \" + number); number++; System.out.println(\"Number now is \" + number); }}แนนอนผลลพั ธท ่ไี ดก ็ตองเปนNumber now is 1Number now is 2Number now is 3Number now is 4Number now is 5Number now is 6Number now is 7Number now is 8Number now is 9Number now is 10การแสดงคา จาก 1 – 10 น้นั ยังไมมีปญหาอะไรมากมายนัก ถา เราตองการท่ีจะแสดงคา จาก 1 – 100 หรอืจาก 1 – 1000 หละ เราคงตองพมิ พจนมือเม่ือยแนเ ลย ลองมาดวู า เราจะใช loop ชว ยในการทาํ งานในลกั ษณะนีไ้ ดอยา งไรJava มีโครงสรา งหลายตวั ท่ีเราสามารถนาํ มาใชใ นการทาํ งานแบบวนได คาํ สงั่ ทวี่ าน้ี คือ while,do..while และ for ชุดคําสั่งแรกทเี่ ราจะดูกนั คอื for loopการใช for loopกอ นท่ีเราจะไปดโู ครงสรา งของ for loop กันเรามาดกู ันวา โปรแกรมกอนหนา นี้ ถา ใช for loop แลวจะมีหนาตาเปนอยางไร/* ForLoop2.java */import java.io.*;class ForLoop2 { public static void main(String[] args) { int number; for(number = 1; number <= 10; number++) System.out.println(\"Number now is \" + number); }}จะเหน็ วาโปรแกรมของเราสน้ั ลงมาก คําส่ังใน for loop บอกให Java รูวาการประมวลผลตอ งทําทัง้ หมด10 ครัง้ โดยเริม่ ตนการประมวลผล เม่อื number มคี า เทา กบั 1 ไปจนกวา number จะมีคา เปน 10 ซงึ่ เมื่อnumber มีคา เปน 10 Java ก็จะยตุ กิ ารประมวลผลทง้ั หมด และผลลพั ธท ่ีไดกเ็ หมอื นกนั กบั โปรแกรมForLoop.java ทีเ่ ราเขียนขึ้นมากอ นหนาน้ีโครงสรางของ for loop มดี งั นคี้ อืfor(expression1 ; expression2 ; expression3) statement; ภาควิชาคอมพิวเตอรธ ุรกิจ วิทยาลัยฟารอีสเทอรน

บทที่ 3 การประมวลผลแบบวน (Repetition) 74เร่มิ ตนกับ Javaโดยที่ 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 วา incrementexpressionภาพท่ี 3.4 แสดงแผนผงั การทาํ งานของ for loop expression1 expression2 no (จรงิ ?) statement อ่ืน ๆ ในโปรแกรม yes statement expression3ภาพที่ 3.4 ข้นั ตอนการทํางานของ for loopเรากลบั มาดโู ปรแกรม ForLoop2.java ทเ่ี ราเขียนกอ นหนานวี้ ามกี ารทํางานอยา งไร เราเรมิ่ ตน ดวยการเขียน for loopfor(number = 1; number <= 10; number++) System.out.println(\"Number now is \" + number);ส่ิงที่ Java ทํากอ นก็คือ กําหนดคา ตัวแปร number ใหเปน หนึ่ง หลงั จากนนั้ กท็ าํ การตรวจสอบวา ตวั แปรnumber มีคา นอ ยกวา หรอื เทา กบั สิบหรอื ไม ซงึ่ กเ็ ปนจรงิ ดงั น้ัน Java จึงประมวลผลประโยคทีอ่ ยูใ น forloop เมอ่ื เสร็จแลวจึงไปประมวลผลประโยค number++ ซึ่งเปนการเพม่ิ คา ใหก บั ตัวแปร number เสรจ็แลวจึงกลบั ไปตรวจสอบวา number <= 10 อีกคร้ัง ทาํ ไปเรอื่ ย ๆ จนกวา number จะมคี า มากกวาสิบจึงจะยตุ กิ ารทํางาน โดยสรปุ แลวขั้นตอนของ for loop มดี ังน้คี อื1. กาํ หนดคา เบื้องตน ใหกับ number2. ตรวจสอบวา number <= 10 หรือไม ถาเปนจริง ประมวลผลประโยค System.out.println(\"Number now is \" + number); ถาเปนเทจ็ ยตุ กิ ารทํางานของ for loop3. ประมวลผลประโยค number++4. กลบั ไปทาํ คาํ สง่ั ในขอสองใหม ภาควิชาคอมพิวเตอรธ ุรกจิ วทิ ยาลัยฟารอสี เทอรน

บทท่ี 3 การประมวลผลแบบวน (Repetition) 75เรมิ่ ตน กบั JavaExpression ท่สี าํ คญั ทส่ี ดุ ทจี่ ะทําให 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/* Add1To100.java */import java.io.*;class Add1To100 { public static void main(String[] args) { int total = 0; for(int i = 1; i <= 100; i++) total += i; System.out.println(\"Sum of 1 - 100 is \" + total); }}ผลลัพธข องการ run คือSum of 1 – 100 is 5050ตัวอยา งโปรแกรมตอ ไปน้ีทาํ การคาํ นวณหาดอกเบยี้ ทบตน ในแตละป เปนจาํ นวนเทากับจํานวนปที่ userเปนผกู ําหนดจากเงนิ ฝากเริ่มตน ทห่ี น่ึงพนั บาท (หรือเทากบั จาํ นวนที่ user เปน ผใู สเ ขา สโู ปรแกรม) โดยใชส ูตรการในการคาํ นวณ คือamount = p(1 + r)nโดยที่ ภาควิชาคอมพิวเตอรธุรกจิ วิทยาลยั ฟารอ สี เทอรน

บทท่ี 3 การประมวลผลแบบวน (Repetition) 76เรม่ิ ตนกบั Javap คือ จํานวนเงนิ เริม่ ตน (principal)r คือ อัตราดอกเบย้ี ประจําปn คอื จํานวนของปท ่ตี องการหาamount คือ เงินตน ทน่ี ําฝากของทกุ ป/* Interests.java */import java.io.*;import java.lang.Integer;class Interests {public static void main(String[] args) throws IOException { double amount; //amount at the end of year double principal; //first deposit double rate; //annual interests rate int years; //number of years BufferedReader buffer; InputStreamReader isr; String input; //get input from user (principal, rate, years) System.out.print(\"Enter amount to deposit: \"); isr = new InputStreamReader(System.in); buffer = new BufferedReader(isr); input = buffer.readLine(); principal = Double.parseDouble(input); System.out.print(\"Enter interests rate: \"); input = buffer.readLine(); rate = Double.parseDouble(input); System.out.print(\"Enter number of year: \"); input = buffer.readLine(); years = Integer.parseInt(input); //calculate and display amount System.out.println(\"\nYear\tAmount on deposit\"); for(int y = 1 y <= years; y++) { amount = principal * Math.pow(1.0 + rate, y); System.out.println(y + \"\t\" + amount); } System.out.print(\"\nTotal interests after \" + years); System.out.println(\" years is \" + (amount - principal)); }}ผลลัพธข องการ run ดว ย principal = 10000 rate = 0.25 และ years = 5Enter amount to deposit: 10000Enter interests rate: .25Enter number of year: 5Year Amount on deposit1 12500.02 15625.03 19531.254 24414.06255 30517.578125 ภาควิชาคอมพิวเตอรธรุ กจิ วิทยาลยั ฟารอ ีสเทอรน

บทท่ี 3 การประมวลผลแบบวน (Repetition) 77เร่ิมตน กบั JavaTotal interests after 5 years is 20517.578125สว นประกอบทสี่ ําคญั คือ for loop ท่ที าํ หนาทค่ี าํ นวณหาจํานวนเงินท่ีไดร ับในแตล ะป (พรอ มทัง้ ดอกเบย้ี )เราใช method Math.pow() ในการหาคาของดอกเบีย้ ในแตล ะป ซงึ่ เมอ่ื หาไดแลว เรากแ็ สดงผลลพั ธไ ปยังหนาจอทันที for loop ของเรายตุ กิ ารประมวลผลเมือ่ คา ของตวั แปร y มคี า มากกวา ตวั แปร yearsหลงั จากแสดงจาํ นวนของเงินในแตล ะปแ ลว เมอื่ ออกจาก for loop เราก็แสดงจาํ นวนของดอกเบย้ีทง้ั หมดที่ไดจากการฝากในชว งนั้นถา หากเราไมต อ งการใชส ตู รในการคํานวณหาดอกเบ้ยี เราก็สามารถทาํ ไดด ว ยการคาํ นวณหาดอกเบีย้ กอ นแลวจงึ นําเอาดอกเบย้ี ที่หาไดไ ปบวกกับเงนิ ตน หลงั จากนน้ั กค็ ํานวณหาดอกเบีย้ จากเงนิ ตนใหมน ้ี ทําการคํานวณจนกวาจะครบตามจาํ นวนปท ีไ่ ดก ําหนดไว ดงั ทแ่ี สดงดว ย code น้ีamount = principal;System.out.println(\"\nYear\tAmount on deposit\");for(int y = 1; y <= years; y++) { double interests = amount * rate; //calculate interests amount += interests; //calculate new principal System.out.println(y + \"\t\" + amount);}เราลองมาดโู ปรแกรมตวั อยา งอกี ตัวหนง่ึ ทใี่ ช for loop ในการควบคุมการทาํ งานของโปรแกรม พรอ มทงั้ยอมให user ใสขอมลู หลาย ๆ ตวั ในบรรทดั เดียวกันได/* AddNumbers.java - reading numbers from input line * user must specify space between those numbers and * hit <enter> when done.*/import java.io.*;import java.text.DecimalFormat;class AddNumbers { public static void main(String[] args) throws IOException { double number, sum = 0; //a number read and sum of numbers int count = 0; //total numbers read BufferedReader buffer; //input buffer InputStreamReader isr; //input stream StreamTokenizer token; //token from input stream DecimalFormat f = new DecimalFormat(\"0.00\"); System.out.print(\"Enter numbers (space between – enter when done): \"); isr = new InputStreamReader(System.in); buffer = new BufferedReader(isr); //get tokens from input buffer token = new StreamTokenizer(buffer); //set priority to EOL so that we can break out of the loop token.eolIsSignificant(true); //get each number from tokens //calculate the sum until EOL is reached for(; token.nextToken() != token.TT_EOL ;) { switch(token.ttype) { //token is a number case StreamTokenizer.TT_NUMBER: number = token.nval; //save token in number count++; //number of tokens read ภาควิชาคอมพิวเตอรธ ุรกิจ วิทยาลยั ฟารอีสเทอรน

บทท่ี 3 การประมวลผลแบบวน (Repetition) 78เร่ิมตน กบั Java sum += number; //calculate sum break; default: System.out.println(\"Token is not a number! \" + token.toString()); break; } } //calculate average and display result double average = sum / count; System.out.println(\"Sum of numbers = \" + sum); System.out.println(\"Average of numbers = \" + f.format(average)); }}โปรแกรม 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 พรอ มกับเพิ่มคา ใหกบั ตวั แปร countfor(; token.nextToken() != token.TT_EOL ;) { switch(token.ttype) { //token is a number case StreamTokenizer.TT_NUMBER: number = token.nval; //save token in number count++; //number of tokens read sum += number; //calculate sum break; 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; ภาควิชาคอมพิวเตอรธุรกิจ วทิ ยาลยั ฟารอ สี เทอรน

บทท่ี 3 การประมวลผลแบบวน (Repetition) 79เริม่ ตน กับ Javaเนอื่ งจากวาเราสนใจเฉพาะ 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 34Sum of numbers = 930.0Average of numbers = 155.0Enter numbers (space between - enter when done): 45 68 95Sum of numbers = 208.0Average of numbers = 69.33Class StreamTokenizer ยงั มี field อน่ื ๆ ที่เราสามารถเรียกใชไ ด แตไ มไ ดก ลาวไวในทนี่ เี้ พราะวาโปรแกรม AddNumbers.java ของเราสนใจแตเฉพาะการอา นตวั เลขเทา นั้น ผูอานสามารถหาขอ มลู ไดจาก javadoc ของ Sun เองในการใช for loop นน้ั เราสามารถทจี่ ะใช , (comma) เปน ตัวแบง การประมวลในแตละ expression ไดดงั ตัวอยา งโปรแกรมการหาผลรวมและคา เฉลย่ี นของเลขจากหนงึ่ ถึงสิบนี้/* Sum.java */import java.io.*;class Sum { public static void main(String[] args) { int i, sum; for(i = 1, sum = 0; i <= 10; sum += i, i++) ; System.out.println(\"Sum = \" + sum); System.out.println(\"Average = \" + (double)sum / (i-1)); }}เรากาํ หนดให 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++) ;หรือfor(i = 1, sum = 0; i <= 10; sum += i, i++) { }การทาํ งานของ for loop ทวี่ าน้กี ็เหมือนกันกับการเขียน for loop แบบเดิม ตางกนั ตรงท่ีเราไดย า ยตําแหนงของประโยคสองประโยค เทา นัน้ เอง ภาควิชาคอมพิวเตอรธรุ กจิ วิทยาลยั ฟารอสี เทอรน

บทท่ี 3 การประมวลผลแบบวน (Repetition) 80เริ่มตนกับ Javasum = 0;for(i = 1; i <= 10; i++) sum += i;ตาํ แหนงของขอ ความการหาผลรวมก็มคี วามสาํ คัญ เราตอ งกําหนดใหป ระโยค sum += i นนั้ อยูกอ นประโยค i++ ทัง้ นีก้ เ็ พราะวา Java จะประมวลผลประโยคทอี่ ยูท างซา ยของเครื่องหมาย , กอ น แลว จึงจะประมวลผลประโยคทอี่ ยถู ดั ไปทางขวา ซึ่งถาเรากาํ หนดให i++ อยูกอ น sum += i การประมวลผลของเรากจ็ ะผดิ พลาด คา ของผลรวมท่ไี ดค ลาดเคล่อื นสว นทีส่ าํ คัญอกี สวนหนง่ึ กค็ อื คาของ i สาํ หรับการคาํ นวณหาคาเฉล่ยี เราตอ งหกั คาของ i ออกหนง่ึ คากอนนําไปหาร sum กเ็ น่อื งจากวา ในขณะที่ for loop ยุติการทาํ งานน้นั คาของ i มคี า เปน 11การหาผลรวมของ for loop ทกี่ ลาวมาแลวนนั้ เราสามารถทจ่ี ะเขยี นไดอกี หลายรูปแบบ เชนi=;sum = 0;for( ; i <= 10; i++) ; sum += i;หรือi = 1;sum = 0;for( ; i <= 10; ) { sum += i; i++;}หรือsum = 0;for( i = 1; i <= 10; ) { sum += i; i++;}ผอู า นควรคาํ นงึ ถงึ การเขยี น code ท่ดี แู ลวอา นไดงา ย มโี ครงสรางทีม่ องดูเปน สากล ดงั นั้นถึงแมว า Javaจะยอมใหเราเขยี น code ไดอยา งอิสระและหลายรปู แบบ เรากไ็ มค วรเขยี น code ท่ยี ากตอ การทาํ ความเขาใจ ยกเวนวา การเขยี น code น้นั ๆ มีความจาํ เปน ทต่ี องใชร ปู แบบนั้น ๆ ในการเขียน (จาํ เปน จรงิ หรอื ?)การใช 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 ภาควิชาคอมพิวเตอรธรุ กิจ วิทยาลยั ฟารอีสเทอรน

บทที่ 3 การประมวลผลแบบวน (Repetition) 81เร่ิมตน กบั Java Expression no (จรงิ ?) yes statement Next statementภาพที่ 3.5 ข้นั ตอนการทํางานของ while loopเรามาลองใช while loop แทน for loop ท่ีเราไดใชใ นโปรแกรมตวั อยา งบางตัวกอนหนานี้/* Sum.java */import java.io.*;class Sum { public static void main(String[] args) { int i, sum; i = 0; sum = 0; while(i <= 10) { sum += i; i++; } System.out.println(\"Sum = \" + sum); System.out.println(\"Average = \" + (double)sum / (i-1)); }}สิง่ แรกที่เราตองทํากค็ อื การกําหนดคา เบอื้ งตน ใหก บั ตวั แปร i และ sum หลงั จากนน้ั เรากท็ าํ การตรวจสอบดวู าประโยค i <= 10 เปน จรงิ หรอื ไม ซึ่งถา เปนจริงเรากใ็ ห while loop ของเราทําการบวกคา ของ i เขากับตัวแปร sum พรอ มท้ังเพิม่ คา ใหก บั i เมอ่ื เสรจ็ แลว ถา เราลองเปรยี บเทยี บการใช while loop กับ forloop เราจะเห็นวา ประโยคi = 0;sum = 0;คอื expression ทหี่ น่งึ ของ for loop และประโยค ภาควิชาคอมพิวเตอรธรุ กิจ วทิ ยาลยั ฟารอีสเทอรน

บทที่ 3 การประมวลผลแบบวน (Repetition) 82เรม่ิ ตนกบั Javai <= 10 ก็คือ expression ทส่ี องใน for loop สวนประโยค i++ ก็คือ expression ทส่ี ามใน for loopนั่นเอง (ถงึ แมว า เราไดก ําหนดคา ของ i ใหเริม่ ตน ที่ 0 ก็ไมท ําใหการประมวลผลเปลีย่ นไป เพยี งแตว าloop ของเราทํางานมากขนึ้ อกี หน่งึ คร้ัง เทา น้ัน)ทนี ีเ้ รามาลองใช while loop แทน for loop ในโปรแกรม AddNumbers.java กนั/* AddNumbers2.java - reading numbers from input line user must specify space between those numbers and hit <enter> when done. (using while loop) */import java.io.*;import java.text.DecimalFormat;class AddNumbers2 { public static void main(String[] args) throws IOException { double number, sum = 0; //a number read and sum of numbers int count = 0; //total numbers read BufferedReader buffer; //input buffer InputStreamReader isr; //input stream StreamTokenizer token; //token from input stream DecimalFormat f = new DecimalFormat(\"0.00\"); System.out.print(\"Enter numbers (space between – enter when done): \"); isr = new InputStreamReader(System.in); buffer = new BufferedReader(isr); //get tokens from input buffer token = new StreamTokenizer(buffer); //set priority to EOL so that we can break out of the loop token.eolIsSignificant(true); //get each number from tokens //calculate the sum until EOL is reached while(token.nextToken() != token.TT_EOL) { switch(token.ttype) { //token is a number case StreamTokenizer.TT_NUMBER: number = token.nval; //save token in number count++; //number of tokens read sum += number; //calculate sum break; default: System.out.println(\"Token is not a number! \" + token.toString()); break; } } //calculate average and display result double average = sum / count; System.out.println(\"Sum of numbers = \" + sum); System.out.println(\"Average of numbers = \" + f.format(average)); }}เราแทบทีจ่ ะไมต องเปลย่ี นอะไรเลย เพียงแตเ ปล่ยี นประโยคfor(; token.nextToken() != token.TT_EOL ;) ภาควิชาคอมพิวเตอรธ ุรกิจ วิทยาลยั ฟารอสี เทอรน

บทท่ี 3 การประมวลผลแบบวน (Repetition) 83เร่มิ ตน กับ Javaใหเปนwhile(token.nextToken() != token.TT_EOL)เทา น้ันเอง สวน code อ่นื ๆ กย็ ังคงเหมือนเดมิทัง้ for loop และ while loop เปนโครงสรางของการทาํ งานแบบวนทต่ี องมกี ารตรวจสอบกอนวาประโยคในการควบคมุ ของ loop ทงั้ สองเปนจริงหรอื เทจ็ ซึ่งหมายถงึ วาการทาํ งานของ loop ทั้งสองอาจไมเกดิ ขึ้นเลยถา การประมวลผลประโยคควบคมุ เปน เท็จ แตถ าเราตองการทีจ่ ะประมวลผลกอ นอยางนอ ยหนง่ึครงั้ เราจะทาํ อยางไรการใช do..whileJava มีโครงสรา งการใช loop อกี ตวั หนึ่งทย่ี อมใหม กี ารทาํ งานอยา งนอยกอ นหน่ึงครง้ั แลวจงึ จะทาํ การประมวลผลประโยคควบคุม นนั่ ก็คือ do … while ซ่ึงมีโครงสรา งดงั นี้do { statement}while(expression);ภาพที่ 3.6 แสดงขนั้ ตอนการทาํ งานของ do … while loop statement yes Expression (จริง ?) no statementภาพท่ี 3.6 ขั้นตอนการทํางานของ do … whileถาเราตองการทจี่ ะทาํ งานอยา งนอ ยหนึง่ คร้ังกอ นทีจ่ ะมกี ารตรวจสอบเพ่ือยตุ กิ ารทาํ งาน หรือทาํ งานตอ ไปdo … while loop จะเปนโครงสรางท่ีเหมาะสมทส่ี ุด โปรแกรมตวั อยางตอ ไปนีแ้ สดงถงึ การใช do …while loop ในการตรวจสอบน้นั ๆ/* DoWhile.java - do .. while to repeat the program until user enter a letter other than 'y' */import java.io.*; ภาควิชาคอมพิวเตอรธ รุ กจิ วิทยาลยั ฟารอ สี เทอรน

บทท่ี 3 การประมวลผลแบบวน (Repetition) 84เริม่ ตนกบั Javaimport java.lang.Integer;class DoWhile { public static void main(String[] args) throws IOException { int score; char grade, ch; //set up buffer stream InputStreamReader isr = new InputStreamReader(System.in); BufferedReader buffer = new BufferedReader(isr); do { //get input string System.out.print(\"Enter your score: \"); String input = buffer.readLine(); //convert string to int score = Integer.parseInt(input); //determine grade by given score if(score > 90) grade = 'A'; else if(score > 80) grade = 'B'; else if(score > 70) grade = 'C'; else if(score > 60) grade = 'D'; else grade = 'F'; System.out.println(\"Your grade is \" + grade); System.out.print(\"\nDO you want to continue? <y/n> : \"); String response = buffer.readLine(); ch = (char)response.charAt(0); } while(ch == 'y'); }}เราเพียงแตด ดั แปลงโปรแกรมการหาเกรดของเรา ดว ยการเพมิ่ do … while และประโยคSystem.out.print(\"\nDO you want to continue? <y/n> : \");String response = buffer.readLine();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: 89Your grade is B ภาควิชาคอมพิวเตอรธ ุรกจิ วทิ ยาลยั ฟารอสี เทอรน

บทท่ี 3 การประมวลผลแบบวน (Repetition) 85เรม่ิ ตนกบั JavaDO you want to continue? <y/n> : yEnter your score: 12Your grade is FDO you want to continue? <y/n> : yEnter your score: 75Your grade is CDO you want to continue? <y/n> : nเรามาลองดโู ปรแกรมตัวอยางอกี ตวั หน่ึงทใ่ี ช do … while loop ในการหาผลรวมของเลขระหวา ง 1 –100/* Sum2.java */import java.io.*;class Sum2 { public static void main(String[] args) { int i, sum; i = 0; sum = 0; do { sum += i; i++; } while(i <= 100); System.out.println(\"Sum = \" + sum); System.out.println(\"Average = \" + (double)sum / (i-1)); }}ซึง่ เมื่อ run ดกู ็ไดผ ลลัพธดงั นี้Sum = 5050Average = 50.5เราไมไ ดเปล่ียนแปลงอะไรมากมายใน loop ของเราเพียงแตเปล่ียนมาใช do … while loop เทานนั้ เองเพ่อื ใหเ กิดความเขาใจในการทาํ งานของ loop ดีย่ิงขึน้ เราจงึ นาํ เอาตวั อยางของ code ทใี่ ช loop ในรูปแบบตา ง ๆ มาใหด กู ัน ผูอานควรตรวจสอบถงึ ผลลัพธทค่ี วรจะไดจ ากการทาํ งานของ loop เหลา นด้ี ว ยมอื กอนทีจ่ ะเขยี นโปรแกรมตรวจสอบตวั อยา งท่ี 1class Loops { public static void main(String[] args) { int index = 1; while(index != 9) { index += 2; System.out.println(index); index--; } ภาควิชาคอมพิวเตอรธ รุ กจิ วิทยาลยั ฟารอ ีสเทอรน

บทที่ 3 การประมวลผลแบบวน (Repetition) 86เริ่มตน กับ Java }}ตัวอยางท่ี 2class 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; } }}ตัวอยางท่ี 3class Loops2 { public static void main(String[] args) { int index = 1; while(index != 33) { index++; System.out.println(index); index++; } }}การใช break และ continueหลาย ๆ คร้ังท่เี ราตอ งการยตุ กิ ารทาํ งานของ loop โดยที่ loop ยังไมส ิน้ สดุ การทาํ งานของมนั เอง เชนกาํ หนดให loop หยดุ การทาํ งานเมอื่ คา ของ loop index มีคา ตรงตามเงอื่ นไขทีไ่ ดกําหนดไว ดังแสดงใหเหน็ ในโปรแกรมตัวอยางนี้/* Sum3.java */import java.io.*;class Sum3 { public static void main(String[] args) { int i, sum; i = 0; sum = 0; do { sum += i; i++; //break out of loop when i >= 50 if(i >= 50) break; } ภาควิชาคอมพิวเตอรธุรกิจ วทิ ยาลยั ฟารอ สี เทอรน

บทที่ 3 การประมวลผลแบบวน (Repetition) 87เริม่ ตน กบั Java while(i <= 100); System.out.println(\"Sum = \" + sum); System.out.println(\"Average = \" + (double)sum / (i-1)); }}เราใชโปรแกรม Sum2.java เปนพนื้ ฐานของการเปลี่ยนแปลง โดยเรากาํ หนดใหมีการตรวจสอบคาของ iวา มากกวา หรือเทา กนั กับ 50 หรือไมซ ึ่งถา เปน จรงิ เราก็จะ break ออกจาก loop ทันทีif(i >= 50) break;เม่อื เราลอง run ดูเราไดผ ลลพั ธด งั น้ีSum = 1225Average = 25.0ลองมาดโู ปรแกรมทใี่ ช break ในการหยุดการทาํ งานของ loop ทใี่ ชห าคา ของตวั เลขทกี่ าํ หนดใหวา เปนเลขคูจ าํ นวนสบิ ตัว/* Break.java */import java.io.*;class Break { public static void main(String[] args) { for(int number = 1; ; number++) if(number % 2 == 0) { System.out.println(\"Number is \" + number); //break out of loop when number >= 10 if(number >= 10) break; } }}เราจะตรวจสอบวา ตัวเลขเปนเลขคกู อ นแลว จงึ ทาํ การแสดงตัวเลขนน้ั ๆ ไปยังหนาจอ เมอ่ื ครบสิบตัวแลวเรากจ็ ะหยุดการทํางานของ loop ดงั ทแ่ี สดงใหเห็นจากผลลพั ธท ไี่ ดน้ีNumber is 2Number is 4Number is 6Number is 8Number is 10ทนี ี้เรามาลองใช continue ดูบาง/* Continue.java */import java.io.*;class Continue { public static void main(String[] args) { for(int number = 1; number <= 10; number++) { ภาควิชาคอมพิวเตอรธุรกิจ วทิ ยาลัยฟารอสี เทอรน

บทที่ 3 การประมวลผลแบบวน (Repetition) 88เรม่ิ ตนกับ Java //skip if number is 5 if(number == 5) continue; System.out.println(\"Number is \" + number); } }}การประมวลของ code ที่เหลืออยใู นโปรแกรมจะถูกประมวลผล ยกเวนเมอื่ คา ของ number มคี า เทา กับหา ดังแสดงใหเ ห็นจากผลลัพธน ี้Number is 1Number is 2Number is 3Number is 4Number is 6Number is 7Number is 8Number is 9Number is 10การใช continue นัน้ โดยทั่วไปมกั จะไมคอยมที ใี่ ชเ ทาไรนัก เพราะการเขยี นโปรแกรมโดยท่ัวไปมักจะทาํการประมวลผลกลุมของคาํ ส่งั ทั้งหมดจนเสรจ็ หรอื ไมกย็ ตุ ิการทาํ งานเมอ่ื เงื่อนไขบางอยางเปนจรงิ การกระโดดขา มการประมวลผลชดุ คําสงั่ ไมค อ ยจะมใี หเ ห็นมากมายนัก ดังน้นั ก็คงตอ งขน้ึ อยูกับการออกแบบโปรแกรมของผอู า นเองวา เหมาะสมอยางไรตอ การใชช ดุ คําสงั่ ตาง ๆการใช Nested Loopเราสามารถทจ่ี ะนําเอา loop ตา ง ๆ ทเี่ ราไดพ ดู ถงึ มาใสไ วใ น loop ได เชน เดยี วกับที่เราทาํ กบั if – elseเนอ่ื งจากวาตัว loop เองกเ็ ปน ประโยคอยางหนง่ึ ดงั นัน้ การนาํ ประโยคมาวางซอนกนั ในการเขียนโปรแกรมกย็ อมทีจ่ ะทําได เรามาลองดตู วั อยา งการใช nested loop กนั/* NestedLoop.java */import java.io.*;class NestedLoop { public static void main(String[] args) { for(int row = 1; row <= 10; row++) { for(int column = 1; column <= 10; column++) { if(column > row) continue; System.out.print(\"*\"); } System.out.println(); } }}โปรแกรม NestedLoop.java ของเราใช for loop สองตัวในการแสดงจํานวนของ '*' ในแตละแถว ดังที่แสดงใหเห็นจากผลลพั ธนี้ (หนาถดั ไป) ภาควิชาคอมพิวเตอรธุรกจิ วทิ ยาลัยฟารอ ีสเทอรน

บทท่ี 3 การประมวลผลแบบวน (Repetition) 89เริ่มตนกับ Java*******************************************************ใน 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 ในรปู แบบตาง ๆ (ผอู านควรตรวจสอบผลลพั ธด วยมือกอนการเขียนโปรแกรมทดสอบ)ตัวอยา งที่ 1class Loops3 { public static void main(String[] args) { int j, k = 0; while(k < 3) { j = 5; while(j > 0) { System.out.println(j); j -= 2; } System.out.println(\"k = \" + k); k++; } }} ภาควิชาคอมพิวเตอรธ ุรกจิ วิทยาลัยฟารอ ีสเทอรน

บทที่ 3 การประมวลผลแบบวน (Repetition) 90เร่มิ ตน กบั Javaตัวอยา งที่ 2class 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; } }}ตวั อยางที่ 3class 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; } }}การใช Labeled continue และ Labeled break ใน for loopJava ยอมใหมกี ารใช label ในการหยดุ และเร่ิมการประมวลผลใหม ซ่ึงโปรแกรมเมอรห ลาย ๆ ทา นไมคอ ยจะเหน็ ดว ยกบั การใชก ารประมวลผลในลกั ษณะนเี้ ทา ใดนกั เรามาดตู วั อยา งกัน/* LabledContinue.java */import java.io.*;class LabeledContinue { public static void main(String[] args) { label: for(int row = 1; row <= 10; row++) { System.out.println(); for(int column = 1; column <= 10; column++) { if(column > row) continue label; //goto label System.out.print(\"*\"); } } }} ภาควิชาคอมพิวเตอรธรุ กจิ วทิ ยาลัยฟารอสี เทอรน

บทท่ี 3 การประมวลผลแบบวน (Repetition) 91เรมิ่ ตนกบั Javaเราไดดดั แปลงโปรแกรม Continue.java ของเราสําหรับการแสดงการใช labeled continue ในโปรแกรมLabeledContinue.java เรากาํ หนดใหม ี identifier ทีม่ ชี อื่ วา label อยูกอ นหนา for loop ดานนอกของเรา ซึง่ ตอ งมเี ครอื่ งหมาย ':' ตามหลงั เสมอ และในการใช continue ใน for loop ดา นในนนั้ เราจะตองมีidentifier ทเี่ ราใชตามหลัง continue เสมอการประมวลดว ย labeled continue ก็ไมยากนกั ทจ่ี ะทาํ ความเขาใจ เมอ่ื คา ของ column มากกวา คาของrow การทํางานใน for loop ดานในกส็ ้ินสดุ ลงและไปเริ่มตน ใหมท ่ี for loop ดา นนอก เพราะนั่นเปน ทท่ี ีม่ ีlabel อยู การทาํ งานแบบน้กี ็เหมือนกบั การกระโดดไปยังตาํ แหนงทเ่ี ราตองการจะไปนนั่ เอง ท้งั น้ีก็ตองข้นึ อยูก ับเงือ่ นไขท่เี ราไดตงั้ ไวถา เราเปลยี่ น continue ใหเปน break เราจะไดผ ลลพั ธอ ะไร เรามาลองดูโปรแกรมท่ีใช labeled breakกันดู/* LabledContinue.java */import java.io.*;class LabeledContinue { public static void main(String[] args) { System.out.println(\"Statement before first label.\"); first: for(int i = 1; i <= 10; i++) { for(int j = 1; j <= 10; j++) { if(j > i) break first; System.out.println('*'); } } System.out.println(\"Statement after first label.\"); }}เราไดเพ่ิมประโยคท้ังกอนและหลัง label ท่ชี อื่ วา first ของเราเพอ่ื จะไดดวู า การประมวลผลเกิดขึ้นที่ใดบา ง กอนที่เราจะประมวลผลของประโยคท่ตี ามหลัง first เราสง ขอความไปยงั หนา จอวาStatement before first label.และ for loop ของเราทง้ั สองตัวสงตัวอักษรเพียงตัวเดยี วไปยงั หนา จอคอื*หลังจากนน้ั กส็ ง ขอความStatement after first label.ไปยงั หนาจอ จะเหน็ วาการใช labeled break นนั้ ทาํ ใหการประมวลผลของเรายตุ ลิ ง เพราะวา ประโยคทมี่ ีอยูใน block ของ first นน้ั มีเพียงประโยคเดยี วดงั นั้น Java จะประมวลผลประโยคที่อยูถดั ไป หลังจากblock ของ first ซึ่งกค็ อื ประโยคSystem.out.println(\"Statement after first label.\");เราสามารถทจี่ ะมี label block ก่ี block กไ็ ดใ นโปรแกรมของเรา การใช labeled break ถา ใชไดอยา งเหมาะสมแลว จะทําใหการเขยี น code เปนไปไดอ ยางสะดวกยงิ่ ขึน้ ทั้งน้กี ็เพราะวา เราสามารถท่จี ะกระโดดไปยงั block ตาง ๆ ไดอยางงาย ๆลองมาดโู ปรแกรมตวั อยา งอีกตวั หนง่ึ ทใี่ ช labeled break ในการหาผลคูณของเลขระหวาง 1 – 5 ภาควิชาคอมพิวเตอรธ รุ กิจ วิทยาลัยฟารอีสเทอรน

บทท่ี 3 การประมวลผลแบบวน (Repetition) 92เริ่มตน กบั Java/* LabledBreak.java */import java.io.*;class LabeledBreak { public static void main(String[] args) { int prod = 1; int i = 1; outer: while(true) { prod *= i; i++; if(i > 5) break outer; } System.out.println(\"Product = \" + prod); }}เราใช while loop ทที่ ํางานอยตู ลอดเวลาโดยไมมีการกาํ หนดใหห ยดุ (ใช true ใน expression) แตเ รากําหนดใหมีการหยดุ จากการใช labeled break ใน while loop เอง ตวั โปรแกรมจะคํานวณหาผลคูณไปจนกวาคาของ i จะเปนหา กจ็ ะ break ออกจาก block ท่ีชือ่ outer ทนั ที และจะไปประมวลผลประโยคท่ีอยถู ัดมาจาก block ซงึ่ ก็คอื System.out.println(\"Product = \" + prod)Loop เปน โครงสรางทใี่ ชมากในการเขียนโปรแกรมตาง ๆ ทั้งนี้เพราะ loop เออ้ื อาํ นวยใหผ เู ขียนเรยี กใชชดุ คาํ สัง่ ตา ง ๆ ซาํ้ กนั ได ทาํ ใหก ารเขยี นโปรแกรมลดขั้นตอนการทาํ งานลง และการทาํ งานของโปรแกรมกก็ ระชบั ยง่ิ ขน้ึ เราจะกลบั มาพดู ถงึ loop อกี หลาย ๆ คร้งั ในบทตอ ๆ ไป โดยเฉพาะในเรอื่ งของ Arrayและ Stringสรปุในบทน้ีเราไดพ ดู ถงึ การใชประโยคของการเปรียบเทยี บ และการตัดสนิ ใจ การใชป ระโยคควบคมุ การทํางาน การใช loop ในการประมวลผลตดิ ตอกนั โดยรวมแลว เราไดพ ดู ถงึ9 การใช if และ if-else9 การใช nested-if9 การใช Tertiary operator - ? :9 การใช switch9 การใช loop ตา ง ๆ เชน for-loop while-loop และ do-while-loop9 การใช break continue และการใชประโยคทใ่ี ช labelแบบฝก หดั1. จงเขียนโปรแกรมทรี่ ับ int จาก keyboard จํานวน 10 ตวั หลังจากน้ันใหค าํ นวณหาผลรวม และ คา เฉลยี่ ของขอมูลท้งั 10 ตวั ใหส งผลลัพธอ อกทางหนา จอ2. จงเขียนโปรแกรมทสี่ รา งตัวเลขแบบสมุ จาํ นวน 100 ตวั เสรจ็ แลว ใหแ สดงผลลพั ธอ อกทางหนา จอ เฉพาะตัวเลขทเ่ี ปน เลขคเี่ ทานนั้ โดยกําหนดใหก ารแสดงผลเปน 10 ตัวตอหนง่ึ บรรทัด3. จากโจทยในขอ 2 แทนทจี่ ะแสดงผลเปน เลขคใ่ี หแ สดงผลเฉพาะทเี่ ปนเลขคเู ทาน้ัน โดยแสดงเฉพาะ เลขคูท ีม่ ากกวา 20 เทานน้ั4. จงเขียนโปรแกรมทแ่ี สดงตวั อกั ษรตั้งแต A ไปจนถึง Z ดว ยการใช while loop โดยไมม ีการรับคาใด ๆ จาก keyboard ภาควิชาคอมพิวเตอรธรุ กจิ วทิ ยาลัยฟารอ ีสเทอรน

บทท่ี 3 การประมวลผลแบบวน (Repetition) 93เร่มิ ตน กบั Java5. จงเขียนโปรแกรมทคี่ าํ นวณหาคา ท่ีเล็กทสี่ ุดในกลุมตัวอักษรท่ีอา นเขามาจาก keyboard ทีละตัว (ตวั อักษรทน่ี ําเขาควรมจี าํ นวนไมน อยกวา 10 ตัว)6. จงเขยี นโปรแกรมท่อี านขอ มูล 2 ตวั จาก keyboard โดยทต่ี วั แรกเปน หมายเลขของสนิ คา (product number) และตวั ทสี่ องเปน จาํ นวนท่ขี ายไปในแตล ะวัน (quantity sold) กาํ หนดใหมสี นิ คา อยู 5 ชนดิ ทีม่ รี าคาตา งกัน ดังน้ีสนิ คาที่ 1 ราคา 500.0 บาทสนิ คา ท่ี 2 ราคา 750.0 บาทสนิ คาที่ 3 ราคา 850.0 บาทสินคา ท่ี 4 ราคา 950.0 บาทสนิ คาท่ี 5 ราคา 1000.0 บาทโปรแกรมจะคาํ นวณหายอดเงนิ ท่ขี ายไดของสนิ คา ทกุ ตวั ในอาทิตยท ผี่ านมา โดยท่ีจํานวนของสนิ คาแตล ะชนิดท่ีขายไปจะนําเขามาจาก keyboard โปรแกรมที่เขียนข้ึนตอ งใช switch ในการแยกแยะราคาของสินคาแตล ะชนดิ ทีเ่ ขา มา ใหแ สดงผลลัพธออกทางหนาจอ7. จงเขยี นโปรแกรมทคี่ าํ นวณหาดอกเบย้ี ทบตน จากเงินตน ทอ่ี านเขา มาจาก keyboard ดว ยสตู รที่ กําหนดให ตอ ไปน้ี (คลาย ๆ กับตัวอยางในบทนี้)a = p(1 + r)np หมายถึงเงนิ ลงทนุ คร้ังแรกr หมายถงึ อตั ราดอกเบีย้ ตอ ปn หมายถงึ จาํ นวนปทต่ี อ งการฝากเงินa จํานวนเงนิ ทฝ่ี ากเขา ทกุ ๆ สนิ้ ปโปรแกรมควรแสดงรายการออกเปนสอง column โดยท่ี column แรกเปน ปท ่ฝี าก และ column ท่ีสองเปนดอกเบี้ยทีไ่ ดใ นแตละป ใหท ดลอง run โปรแกรมดว ยอัตราดอกเบยี้ 5% ตอป และเงินตน ท่ี1000 บาท เปน เวลา 10 ป8. จงเขยี นโปรแกรมทแี่ สดงผลลพั ธ ดงั ท่ีเหน็ นี้ ดว ยการใช loop เทา นั้น********** ******************* ***************** *************** ************* *********** ********* ******* ***** *** *9. จงเขยี นโปรแกรมทรี่ บั คา int หนงึ่ ตัว (n) ที่มากกวาศนู ย หลงั จากน้ันใหแสดงผล ดังนี้1 2 3 … n-1 n1 2 3 … n-1…123121 ภาควิชาคอมพิวเตอรธ ุรกิจ วิทยาลยั ฟารอ ีสเทอรน

บทท่ี 3 การประมวลผลแบบวน (Repetition) 94เรม่ิ ตน กบั Java10. จงเขียนโปรแกรมทรี่ ับคาเปน วัน เดือน ป จาก keyboard หลงั จากน้นั ใหแ สดงตําแหนงของวนั ท่นี น้ั ในป เชน 12 29 2002 จะแสดงเปน 36311. จงเขียนโปรแกรมทรี่ ับคา ตา ง ๆ จาก keyboard เฉพาะท่เี ปน 0 มากกวาศนู ย และ นอยกวา ศนู ย ให นับจาํ นวนของคา ทงั้ สามวา มอี ยา งละก่ตี วั โปรแกรมจะหยดุ ทํางานไดก ็ตอ เมื่อ user ใสข อ มูลทไี่ มใ ช ตวั เลข12. จงเขยี นโปรแกรมทร่ี บั คาระหวา ง 1 – 100 หลังจากน้นั ใหแ สดงคา ทรี่ ับเขามาในรูปแบบของ ตัวหนงั สือ เชน ถาขอ มูลนาํ เขา เปน 11 ผลลพั ธท่ไี ดคอื สบิ เอด็13. จงเขียนโปรแกรมทที่ ําการเขา รหสั ของขอ มลู ท่นี าํ เขาจาก keyboard โดยนาํ เอาตัวอกั ษรท่ีอานเขา บวกกบั คาของตัวอกั ษรทอี่ ยถู ดั ไป 2 ตวั อกั ษร mod ดว ยจาํ นวนของตวั อักษรท่มี อี ยู (26 ใน ภาษาอังกฤษ) เชน ถา คานําเขาเปน a ผลลัพธท่ไี ดจ ากการเขา รหสั จะเปน a + c ซึ่งจะมคี า เทากบั 97 + 99 = 196 % 26 = 14 ใหใ ชค านเี้ ปน ตวั บอกตาํ แหนง ของตวั อักษรทจ่ี ะแสดงไปยงั หนาจอ ซ่ึง ตัวอกั ษร ณ ตําแหนงท่ี 14 นคี้ อื n14. จงเขยี นโปรแกรมทร่ี ับคา เปนประโยคทางคณติ ศาสตร เชน 9 + 5 – 2 * 4 + 2 / 3 หลังจากน้นั ให ทาํ การประมวลผลประโยคดังกลาว ตามลําดบั ของขอ มลู ทนี่ าํ เขา15. จงเขียนโปรแกรมทร่ี ับคา เดือนทเ่ี ปนตัวเลขระหวา ง 1 – 12 หลงั จากน้นั ใหแ สดงผลเปน จาํ นวนของ วนั ท่ีมีอยใู นเดอื นดงั กลา ว16. จงหาผลลพั ธข องตัวแปร sum จาก code ทใ่ี ห class Loops6 { public static void main(String[] args) { int j = 0, k, m, n, sum = 0; while(j != 20) { k = 0; while(k != 100) { m = 0; while(m != 50) { n = 0; while(n != 10) { sum++; n++; } m++; } k++; } j++; } } }17. จงเขยี นโปรแกรมทค่ี าํ นวณหา ตวั หารรวมมาก (GCD – Greatest Common Divisor) ของตัวเลข สองตวั ทีร่ ับเขา มาจาก keyboard เชน gcd ของ 24 และ 15 คอื 3 note: gcd ของ x และ y คอื integer ทีใ่ หญท ่ีสดุ ที่หาร x และ y ลงตวั (เหลอื เศษ 0)18. จงเขยี นโปรแกรมทค่ี าํ นวณหา ตวั คูณรว มนอ ย (LCD – Least Common Multiple) ของตัวเลขสอง ตัวทร่ี บั เขา มาจาก keyboard เชน lcd ของ 24 และ 15 คือ 120 note: lcd ของ x และ y คือ integer ทนี่ อยทส่ี ดุ ทีท่ ง้ั x และ y หารลงตวั ภาควิชาคอมพิวเตอรธุรกจิ วทิ ยาลัยฟารอีสเทอรน

บทที่ 3 การประมวลผลแบบวน (Repetition) 95เร่มิ ตนกบั Java19. จงเขียนโปรแกรมทห่ี า factor ของตวั เลขท่รี ับเขามาจาก keyboard เชน ถาขอมลู เทากบั 18 factor ที่ไดค อื 2 3 และ 3 (8 = 2 * 3 * 3) ภาควิชาคอมพิวเตอรธรุ กิจ วทิ ยาลัยฟารอ ีสเทอรน