Introduction to Programming Java Language

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

3: */ intro. to Java (FEU.faa)

4:
5: import static java.lang.System.out;

6:
7: class StaticImport {
8: public static void main(String[] args) {

9: String name = "Jennie Xumsai";
10: int age = 9;
11:

12: out.printf("%s is %s%n", name, age);
13:

14: long maxLong = Long.MAX_VALUE;
15: double maxDouble = Double.MAX_VALUE;
16: out.printf("Maximum long: %d%n", maxLong);

17: out.printf("Maximum double: %E%n", maxDouble);
18: }
19: }

เรากําหนดใหม ีการ import แบบ static ในบรรทดั ที่ 5 ซ่งึ เปน การบอกให Java รวู า เราตอ งการใชส ่ิง
ท่ี Java เรียกวา 'static field' ท่ชี ือ่ 'out' พรอ มท้ัง method ท้ังหลายทม่ี ใี หใ ช เชน printf() เปน ตน
ดงั นน้ั การแสดงผลลัพธใ นบรรทัดที่ 12, 16 และบรรทดั ท่ี 17 จึงไมตอ งมีคําวา 'System' อยูอกี ตอไป
ผลลพั ธท ีเ่ ราไดค อื

Jennie Xumsai is 9

Maximum long: 9223372036854775807
Maximum double: 1.797693E+308

ผอู านจะเห็นวา ถา โปรแกรมของเรามกี ารแสดงผลไปยังหนา จอมาก ๆ การใช static import จะชวย
ใหเ ราเขยี นโปรแกรมไดไวยิง่ ขน้ึ

2.9 การประมวลผลขอมลู ตา งชนดิ กนั (Mixed Type Calculations)

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

1: /**

2: Demonstrates mixed-type calculations
3: */

4:

5: class FloatingPoint4 {

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

7: double hourlyPay = 85.50D; //85.50 per hour

8: int hoursPerDay = 8; //8 hours per day

9: int numberOfDays = 5; //total days worked

10: int extraHoursWorked = 15; //overtime hours

11: final double TAX_RATE = 8.5D; //tax rate in percent

12:

13: //calculate weekly pay
14: double weeklyPay = hourlyPay * hoursPerDay * numberOfDays;

15: //calculate extra pay

16: double extras = extraHoursWorked * (hourlyPay + (hourlyPay / 2.0));

17: //calculate tax

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

19: //calculate total income

20: double totalIncome = (weeklyPay + extras) - tax;

21:

22: System.out.printf("Income before tax = %.2f%n", (weeklyPay + extras));

23: System.out.printf("Tax = %.2f%n", tax);

24: System.out.printf("Income after tax = %.4f%n", totalIncome);
25: }

26: }

โปรแกรม FloatingPoint4.java ใชต ัวแปรท่มี ชี นิดเปน ทั้ง double และ integer ปนกันในการ
คํานวณหารายไดต อหนงึ่ อาทติ ย โดยกําหนดใหต ัวแปร hoursPerDay, numberOfDays และ

47

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

extraHoursWorked เปน integer สวนตัวแปร hourlyPay, weeklyPay, extras, tax และ
totalIncome เรากําหนดใหเ ปน double

การประมวลผลก็ไมยงุ ยากอะไร Java จะเปล่ยี นตัวแปรทเี่ ปน int ใหเปน double กอ นการประมวลผล
เพราะฉะน้ันการจดั เก็บผลลัพธกไ็ มม คี าความคลาดเคลือ่ นใด ๆ เกดิ ขึน้ ดังผลลพั ธท ี่แสดงนี้

Income before tax = 5343.75
Tax = 454.22
Income after tax = 4889.5313

ขอควรจาํ ในการประมวลผลขอมูลตา งชนิดกนั (ในประโยคเดียวกนั )

o ถามีตวั แปรใดเปน double ตัวแปรท่นี ํามาประมวลผลดว ยจะถูกเปลีย่ นใหเ ปน double กอ น
การประมวลผล

o ถา มีตวั แปรใดเปน float ตวั แปรที่นาํ มาประมวลผลดว ยจะถกู เปลี่ยนใหเปน float กอ นการ
ประมวลผล

o ถา มตี วั แปรใดเปน long ตัวแปรท่ีนาํ มาประมวลผลดว ยจะถกู เปลยี่ นใหเ ปน long กอ นการ
ประมวลผล

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

1: /**
2: Demonstrates mixed-type calculations
3: */
4:
5: class MixedTypes {
6: public static void main(String[] args) {
7: double result = 0.0;
8: int one = 1, two = 2;
9:
10: result = 1.5D + one / two;
11:
12: System.out.printf("Result is %.2f%n", result);
13: }
14: }

ผลลพั ธที่เราคาดหวังวา จะได คือ 2.0 แต Java กลบั ให 1.5 ซึง่ เปนผลลพั ธท ่เี ราไมตอ งการ ถา
สงั เกตใหด จี ะเห็นวาประโยค

result = 1.5 + one / two;

น้นั การหารจะเกดิ กอน และเน่ืองจากวา ทัง้ one และ two เปน int ดังน้ันผลลัพธข องการหารจึงมคี า
เปน int และมีคาเปน 0 หลงั จากน้นั Java ก็จะเปลย่ี น 0 ท่ีไดใหเปน double แลวจึงทาํ การบวกเขา
กับ 1.5 เพอื่ ใหผลลัพธเปน ที่เราตอ งการ ดงั นัน้ เราจงึ ตอ งทําการ cast ใหต ัวแปร one เปน double
เสยี กอ น ดงั น้ี

1: /**
2: Demonstrates mixed-type calculations
3: */
4:
5: class MixedTypes {
6: public static void main(String[] args) {
7: double result = 0.0;
8: int one = 1, two = 2;
9:
10: result = 1.5D + (double)one / two;
11:
12: System.out.printf("Result is %.2f%n", result);
13: }
14: }

เราก็จะไดผ ลลพั ธเปน 2.0 ดงั ทีเ่ ราตองการ

48

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

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

2.9.1 Autoboxing และ Unboxing

เราไดพูดถงึ การใชข อ มลู ชนิดตาง ๆ เชน int, short, float และอ่ืน ๆ ซงึ่ เปนขอมูลพน้ื ฐานที่ใชเก็บคา
ตา ง ๆ ที่ user ตองการ และขอมูลเหลาน้ไี มใชขอ มูลท่ีเปน object ดงั นั้นในการเลอื กใชต ัวแปรเราจึง
ตองระมัดระวังท่จี ะใหขอ มูลเหลา น้ันเปน ขอ มลู ทีถ่ กู ตอ ง ตวั อยา งเชน ถา เราประกาศใหต วั แปร
myNum มีเปนชนดิ เปน Integer และ myNumToo มีชนดิ เปน int ซึง่ ทั้งสองตวั แปร ถา พดู งาย ๆ ก็
คอื เก็บขอมูลชนดิ เดียวกนั ตา งกนั ตรงท่ีตวั หน่งึ เปน object อกี ตวั หนึ่งเปน ขอมลู ชนิดพน้ื ฐาน ซง่ึ ทั้ง
สองไมส ามารถนาํ มาใชแ ทนกันได (ในอดตี กอ น java 1.5) เชน ถา เราใชค ําส่ัง

Integer myNum = new Integer(35);
int myNumToo = 35;

เราไมส มารถกําหนด

myNum = myNumToo; หรือ myNumToo = myNum;

ได แตพอมาถึง Java 1.5 กระบวนการที่เรยี กวา Autoboxing และ Unboxing ยอมใหเราทาํ ได
กลา วคอื เราสามารถท่จี ะกาํ หนดชดุ คาํ สงั่ ดังกลา วได

Boxing หมายถงึ การเปลีย่ นขอมลู จากชนดิ พนื้ ฐานใหเ ปน wrapper type (object น้นั ๆ ท่ีรองรบั กับ
ขอมลู พื้นฐาน) เชน Boolean, Byte, Short, Character, Integer, Long, Float, หรอื Double และ
เนอื่ งจากวา เหตุการณน เี้ กดิ ข้ึนโดยอัตโนมตั ิ เราจงึ เรียกวา Autoboxing ในทางตรงกนั ขามการ
เปลยี่ นให wrapper type เปนขอ มูลชนิดพื้นฐานเราเรียกวา unboxing

1: /**
2: From wrapper type to primitives and vice versa
3: */
4:
5: import static java.lang.System.out;
6:
7: class WrapPrim {
8: public static void main(String[] argas) {
9: Integer myInteger = new Integer(35);
10: int myInt = 4;
11:
12: out.printf("MyInt = %d%n", myInt);
13: //boxing
14: myInt = myInteger;
15: out.printf("Now MyInt = %d%n", myInt);
16:
17: double myD = 3.145;
18: //unboxing
19: Double myDouble = myD;
20: out.printf("myD = %.3f, myDouble = %.3f%n", myD, myDouble);
21: }
22: }

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

MyInt = 4
Now MyInt = 35
myD = 3.145, myDouble = 3.145

โปรแกรมตัวอยา งของเราใช boxing ในบรรทัดที่ 14 และ unboxing ในบรรทดั ท่ี 19 ผูอา นจะเห็นวา
เราไมต อ งทําอะไรเลยเพยี งแตใ ชตวั แปรทัง้ สองชนิดเสมือนกับวาเปน ตัวแปรท่ีไดประกาศใหเปน ชนดิ
เดยี วกัน ใน Java รนุ กอน ๆ การเปลีย่ นขอมูลตอ งมีกระบวนการเพม่ิ อีก ดังตวั อยา งนี้

Integer num1 = new Integer(35);
int num2 = num1.intValue();
Integer num3 = Integer.valueOf(num2);

49

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

เรากําหนดใหต ัวแปร num1 เปน Integer มคี าเปน 35 และกาํ หนดให num2 เปน int มคี า ท่เี ปน int
จาก num1 ดว ยการใช method intValue() ของ class Integer และกาํ หนดให num3 เปน Integer
ทม่ี คี าเปน Integer จากการเปล่ียนคา int ของ num2 ดวยการเรยี กใช valueOf() ของ class
Integer เชน เดียวกัน เพราะฉะน้นั ตัวแปรทง้ั สามจงึ มคี าเหมอื นกันคือ 35

ในสว นของ wrapper type อ่นื ๆ เชน Double หรอื Character ก็ทาํ งานคลา ย ๆ กันผูอานสามารถ
หาดไู ดจ าก Java API ของ Sun ได

2.10 การประมวลผลเลขทม่ี ขี นาดใหญ

ถา เราตอ งการท่จี ะทาํ งานกบั ตัวเลขทมี่ คี า เกินกวา ที่ int จะเกบ็ คาได Java กม็ ีวธิ ีทที่ ําใหเ ราสามารถ
ประมวลผลเลขใหญๆ เหลา นนั้ ได

2.10.1 การใช BigInteger

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

1. จะตอ งสรา งตวั เลยใหเ ปน Object จาก class BigInteger
2. การประมวลผลจะตองทําผาน method ท่ีมใี หตัวอยาง เชน

ลองมาดูโปรแกรมตัวอยางการใชด ู

1: /**
2: Big Integers Operations Demo
3: */
4:
5: import java.math.BigInteger;
6:
7: class BigIntegerDemo {
8: public static void main(String[] args) {
9: BigInteger big1 = new BigInteger("999999999999999999999999999999");
10: BigInteger big2 = new BigInteger("999999999999999999999999999999");
11: BigInteger result;
12:
13: //add big1 and big2
14: result = big1.add(big2);
15: System.out.println("big1 + big2 = " + result);
16:
17: //subtract big1 and big2
18: result = big1.subtract(big2);
19: System.out.println("big1 - big2 = " + result);
20:
21: //multiply big1 and big2
22: result = big1.multiply(big2);
23: System.out.println("big1 * big2 = " + result);
24:
25: //divide big1 and big2
26: result = big1.divide(big2);
27: System.out.println("big1 / big2 = " + result);
28: }
29: }

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

big1 + big2 = 1999999999999999999999999999998
big1 - big2 = 0
big1 * big2 = 999999999999999999999999999998000000000000000000000000000001
big1 / big2 = 1

สําหรบั class BigDecimal กค็ ลายๆ กับ BigInteger เพียงแตเ ปน การทํางานกับตวั เลขท่ีมีจดุ ทศนิยม
เทา นน้ั เอง ผูอานคงตอ งหาดขู อมูลที่เก่ียวของกบั การทํางานกบั ตัวเลขใหญๆ เหลา นี้เสริมเอง

50

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

2.11 การใช Mathematical Functions ตา ง ๆ ท่ี Java มีให intro. to Java (FEU.faa)

หลาย ๆ ครั้งทกี่ ารเขยี นโปรแกรมตอ งการใช function ทเี่ ก่ียวของกับการหาคา ทางคณติ ศาสตร เชน
การหาคา ของ sine cosine tangent หรอื คา อืน่ ๆ ที่เกย่ี วของกบั การคํานวณทางคณติ ศาสตร Java
กไ็ ดท ําการออกแบบและจดั สรร function เหลา น้ีไวใหผใู ชไ ดเ รยี กใชอยางเต็มท่ี เราจะมาทดลอง
เรยี กใช function ตาง ๆ เหลา นดี้ ู

ตัวอยางตอ ไปนีจ้ ะเปน การคาํ นวณหาคา ของสมการ ท่เี รยี กวา Quadratic Equation Æ ax2 + bx +
c = 0 ซึง่ หาไดจ ากการใชสตู ร

x1 = − b + b2 − 4ac
2a

x2 = − b − b2 − 4ac
2a

ซ่งึ mathematical function ท่เี ราตองใชก็คือ การหา square root และ Java ไดจ ัดเตรยี ม method
ตัวน้ไี วใ หเ ราแลวกค็ ือ Math.sqrt() เรามาลองดูโปรแกรมทห่ี าคาของสมการตวั นีก้ นั ดู

1: /**

2: Calculating roots of a function
3: */

4:

5: class Quadratic {
6: public static void main(String[] args) {
7: double a, b, c;
8:

9: //4x2 + 20x + 16 = 0
10: a = 4;
11: b = 20;

12: c = 16;

13:
14: //calculate determinant

15: double det = Math.sqrt(b * b - 4 * a * c);

16:
17: //calculate roots
18: double x1 = (-b + det) / (2 * a);

19: double x2 = (-b - det) / (2 * a);
20:
21: System.out.printf("Root 1 = %.4f%n", x1);
22: System.out.printf("Root 2 = %.4f", x2);

23: }

24: }

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

Root 1 = -1.0000
Root 2 = -4.0000

ในการเขียนโปรแกรม Quadratic. java ในคร้ังนน้ี ้นั เราจะยังไมส นใจในเรื่องทีค่ า ของ determinant
จะเปน 0 เนอื่ งจากวาเราไมส ามารถหาคา ของ square root ของ 0 ได เราจะใชต วั เลขทีท่ ําใหคา ของ
b2 – 4ac เปนบวกเทานน้ั เพ่ือหลกี เล่ยี งเหตกุ ารณด งั กลาว อีกอยางหนึ่งกค็ อื เรายงั ไมไ ดเรยี นเร่ือง
การใช ชดุ คาํ สง่ั ในการตรวจสอบ (if –else) เราจะกลับมาดูตวั อยางนี้อีกครัง้ หนึ่งเม่อื เราไดเ รียนเรือ่ ง
ของการใช ชุดคําสง่ั ในการตรวจสอบ ในท่ีนเี้ ราสนใจแตเร่อื งของการใช Math.sqrt() เทานั้นเอง

เรามาลองใช Mathematical function อ่ืน ๆ ดูกนั ดีกวา

1: /**

2: Finding max and min
3: */
4:

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

51

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

7: int num1 = 58, num2 = 97, num3 = 15;
8:
9: //finding maximum between num1, num2, and num3
10: int maxOfTwo = Math.max(num1, num2);
11: int maxOfAll = Math.max(maxOfTwo, num3);
12:
13: //finding minimum between num1, num2, and num3
14: int minOfTwo = Math.min(num1, num2);
15: int minOfAll = Math.min(minOfTwo, num3);
16:
17: System.out.printf("Maximum number is %d%n", maxOfAll);
18: System.out.printf("Minimum number is %d", minOfAll);
19: }
20: }

โปรแกรม MaxMin.java แสดงการเรียกใช method max() และ min() ในการเปรยี บเทียบและหา
คา ที่มากทสี่ ดุ และคาที่นอยที่สดุ ของ integer 3 ตวั ตามลาํ ดับ และเน่อื งจากวา method ทง้ั สอง
ยอมรบั parameter เพียงแคสองตัวเทาน้นั เราจงึ ตอ งทําการหาคาสองครง้ั คร้ังแรกระหวาง integer
2 ตวั แรก และคร้ังที่สองระหวางคาทีห่ าได กบั integer ท่ีเหลือ และเมื่อ execute โปรแกรมเราก็จะ
ไดผ ลลัพธด ังทเี่ ห็นน้ี

Maximum number is 97
Minimum number is 15

โปรแกรมทแ่ี สดงใหด ตู อไปนีเ้ ปน โปรแกรมทีเ่ รยี กใช method ตาง ๆ ท่ีมอี ยใู น class Math

1: /**
2: Other math functions
3: */
4:
5: class Maths {
6: public static void main(String[] args) {
7: double angle = 0.7853982; //45 degrees angle in radians
8:
9: System.out.println("sin(45) is " + Math.sin(angle));
10: System.out.println("cos(45) is " + Math.cos(angle));
11: System.out.println("tan(45) is " + Math.tan(angle));
12:
13: System.out.println("Absolute value of -456 is " + Math.abs(-456));
14: System.out.println("2 to the 4th power is " + Math.pow(2D, 4D));
15: System.out.println("2.345267 rounded to " + Math.round(2.345267));
16: System.out.println("2.859 rounded to " + Math.round(2.859));
17: System.out.println("The remainder of 3.25 / 2.25 is " +

Math.IEEEremainder(3.25, 2.25));
18: System.out.println("The nearest integer of PI is " + Math.rint(Math.PI));
19: }
20: }

โปรแกรม Maths.java ใช method จาก class Math ทําการหาคาของ sine cosine และ tangent
ของมุม 45 ซง่ึ มีคา เทา กบั 0.7853982 radians สาเหตุท่ีตอ งใชมุมที่เปน radians ก็เพราะวา
method เหลา น้ีบังคบั ใหม มุ ท่รี ับเขาเปน parameter มีชนดิ เปน radians

หลังจากน้ันกท็ าํ การหาคา absolute ของ -456 คา 24 และคา การปด เศษในรปู แบบตาง ๆ ผลลัพธท่ี
ไดจ ากการ run คือ

sin(45) is 0.7071068070684596
cos(45) is 0.7071067553046345
tan(45) is 1.0000000732051062
Absolute value of -456 is 456
2 to the 4th power is 16.0
2.345267 rounded to 2
2.859 rounded to 3
The remainder of 3.25 / 2.25 is 1.0
The nearest integer of PI is 3.0

โปรแกรมตัวอยา งการใช method toRadians() สําหรับการเปลย่ี นมุมทเี่ ปน degrees ใหเ ปน
radians

52

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

1: /** intro. to Java (FEU.faa)

2: Other math functions

3: */

4: import java.text.DecimalFormat;

5:

6: class Maths1 {

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

8: double angle = 45; //45 degrees angle
9: double sin, cos, tan;

10:

11: //set format output

12: DecimalFormat f = new DecimalFormat("0.00000");

13:

14: //calculate sin, cos, and tan

15: sin = Math.sin(Math.toRadians(angle));

16: cos = Math.cos(Math.toRadians(angle));
17: tan = Math.tan(Math.toRadians(angle));

18:

19: System.out.println("sin(" + angle + ") = " + f.format(sin));
20: System.out.println("cos(" + angle + ") = " + f.format(cos));

21: System.out.println("tan(" + angle + ") = " + f.format(tan));

22: }

23: }

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

sin(45.0) = 0.70711
cos(45.0) = 0.70711

tan(45.0) = 1.00000

โปรแกรมตวั อยางอีกตัวหน่งึ ที่ใช math function ในการคํานวณหาคา ของรัศมขี องวงกลม จากพนื้ ที่
ของวงกลมที่กําหนดให

1: /**

2: Other math functions
3: */
4:

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

7: double radius;
8: double area = 850.0;
9: int meters, centimeters;

10:
11: //calculate radius
12: radius = Math.sqrt(area / Math.PI);

13:
14: //convert to meters and centimeters

15: meters = (int)Math.floor(radius);
16: centimeters = (int)Math.round(100.0 * (radius - meters));
17:

18: System.out.printf("Circle with area of %.2f %s", area, "square meters ");
19: System.out.printf("has a radius of %d %s", meters, "meters and ");
20: System.out.printf("%d %s%n", centimeters, "centimeters");

21: }
22: }

เราใช floor() ในการหาคาของรัศมีทเ่ี ปนจํานวนเต็ม และใช round() ในการคํานวณหาคา ของ
centimeters ที่เหลือจากการนําเอา meters ไปลบออกจาก radius ซึ่งเม่ือ run ก็จะไดผลลพั ธดังน้ี

Circle with area of 850.00 square meters has a radius of 16 meters and 45
centimeters

ยงั มี method อกี หลายตวั ทผี่ ูเขยี นโปรแกรมอาจตอ งใช ซ่งึ ไดสรุปไวใ นตารางที่ 2.7

53

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

ตาราง 2.7 Mathematical Functions intro. to Java (FEU.faa)

Method Function Argument Result Type
double (radians) double
sin(arg) หาคา sine double (radians) double
double (radians) double
cos(arg) หาคา cosine double double (radians

tan(arg) หาคา tangent double ระหวาง – π /2
และ π /2)
asin(arg) หาคา arc sine double
double (radians
acos(arg) หาคา arc cosine double ระหวา ง 0.0 และ

atan(arg) หาคา arc tangent int long float π)
double
atan2(arg1, arg2) หาคา arc tangent of arg1 int long float double (radians
และ arg2 double
abs(arg) int long float ระหวา ง – π /2
max(arg1, arg2) หาคา absolute ของ arg double และ π /2 )
min(arg1, arg2) double
ceil(arg) หาคาสูงสดุ ระหวาง arg1 double (radians
floor(arg) และ arg2 double
หาคาตา่ํ สดุ ระหวา ง arg1 ระหวาง – π และ
และ arg2 π)
หาคา ที่เล็กที่สดุ ท่ีใหญกวา
หรอื เทา กับ arg เหมอื นกนั กับ
หาคาท่ีใหญท ส่ี ุดทน่ี อ ยกวา Argument
หรือเทากบั arg เหมือนกนั กบั
Argument
เหมอื นกนั กับ
Argument
double

Double

round(arg) หาคา integer ทใี่ กลเ คยี ง float double ได int ถา
กบั arg ทส่ี ดุ argument เปน
float และ long ถา
rint(arg) หาคา integer ที่ใกลเ คียง double เปน double
กบั arg ทสี่ ดุ double
IEEEremainder(arg1, double
arg2) หาคา เศษที่เหลอื จากการ double
sqrt(arg) หาร arg1 ดว ย arg2 double
pow(arg1, arg2) double double
หาคา root ทสี่ องของ arg double
exp(arg) หาคา ของ arg1 ยกกําลัง double
log(arg) arg2 double double
Random() ไมม ี double
หาคา e ยกกําลัง arg double
หาคา log ของ arg
หาคาสมุ ท่มี ากกวา 0.0 แต
นอยกวา 1.0

2.12 การใชขอมลู ที่เปนตวั อักษร (char)

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

1: /**
2: Using character data
3: */
4:
5: class Characters {

54

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

6: public static void main(String[] args) { intro. to Java (FEU.faa)
char H, e, l, o;
7:
8: H = 72; //ASCII for 'H'
e = 101; //ASCII for 'e'
9: l = 108; //ASCII for 'l'
10: o = 111; //ASCII for 'o'
11:
System.out.printf("%c", H);
12: System.out.printf("%c", e);
13: System.out.printf("%c", l);
14: System.out.printf("%c", l);
System.out.printf("%c", o);
15: System.out.println(" World");
16: }

17:
18:
19:

20:
21: }

ผลลัพธจ ากการ run โปรแกรม Characters. java ก็คอื คาํ วา Hello World ซึ่งตัวโปรแกรมเองใชร หสั
Unicode ในการกําหนดคา ใหกบั ตวั แปร H e l และ o ซง่ึ เมื่อนาํ ไปแสดงผลก็จะไดคาท่ีตวั แปร
เหลาน้ันเปน อยู เรามาลองดูการประมวลผลดว ยการใช character ดว ย operator งาย ๆ ทมี่ อี ยู

1: /**

2: Using operators on characters

3: */

4:

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

7: char ch1 = 88, ch2 = 77;

8:

9: System.out.printf("ch1 = %c%n", ch1);

10: System.out.printf("ch2 = %c%n", ch2);

11:

12: ch1 -= 23; //Unicode for 'A'

13: ch2 += 6; //Unicode for 'S'

14:

15: System.out.println("ch1 = " + ch1);

16: System.out.println("ch2 = " + ch2);
17: }

18: }

โปรแกรมเร่มิ ตนดว ยการกําหนดคา ให ch1 และ ch2 มีคาเปน ตวั อกั ษร X และ M ตามลาํ ดบั และเมอ่ื
แสดงผลของท้งั สองตัวแปรแลว โปรแกรมกเ็ ปลีย่ นคา ใหกบั ตวั แปร ch1 และ ch2 ดวยการลดคา ของ
ch1 ลงเปน จาํ นวนเทา กับ 23 และเพ่ิมคาใหกบั ตัวแปร ch2 อีก 6 เพ่ือใหไ ดต ัวอกั ษร A และ X และ
เมอื่ execute โปรแกรมเราก็จะไดผ ลลพั ธท งั้ หมดเปน

ch1 = X
ch2 = M
ch1 = A
ch2 = S

ทีน้เี รามาลองดูการใช Unicode ในการแสดงผลตวั อักษรตา ง ๆ

1: /**
2: Unicode character
3: */

4:

5: class Characters2 {
6: public static void main(String\u005B\u005D args) {

7: char ch1 = '\u0058'; //unicode for 'X'
8: char ch2 = '\u004D'; //unicode for 'M'
9: char ch3 = '\u0041'; //unicode for 'A'

10: char ch4 = '\u0053'; //unicode for 'S'
11:

12: System.out.println("ch1 = " + ch1);
13: System.out.println("ch2 = " + ch2);
14: System.out.println("ch3 = " + ch3);

15: System.out.println("ch4 = " + ch4);

16: }
17: }

55

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

ซ่งึ เม่ือ run แลว กจ็ ะไดผ ลลัพธเ หมอื นกันกับผลลัพธข องโปรแกรม Characters1.java intro. to Java (FEU.faa)

เราสามารถท่ีจะใช Unicode ในการแสดงตัวอกั ษรในภาษาไทยได เชนเดียวกันกบั ที่เราใช Unicode
ในการแสดงตัวอกั ษรในภาษาองั กฤษ แตวาระบบของเราจะตองเออ้ื ตอ การแสดงผลท่เี ปนตัว
อกั ษรไทยดวย ไมเชนนน้ั แลวผลลัพธท ่ไี ดกจ็ ะเปนตัวอักษรท่อี านไมรูเรอื่ ง หรอื ไมก็แสดงผลเปน
เคร่ืองหมาย '?' ทุกตัว

ถา ผูอา นสงั เกตใหดจี ะเห็นวาในบรรทดั ที่ 6 เราใช Unicode \u005B และ \u005D แทนเครอ่ื งหมาย
[] ซึ่งเปน การใชท่ี Java ยอมรบั เหมอื นกับการใช [] โดยตรง

ตารางท่ี 2.7 แสดงถงึ ตวั อักษรทใ่ี ชในการแสดงผลลพั ธท ่ีไมใชต วั อกั ษรธรรมดา หรอื ที่ภาษาองั กฤษ
เรยี กวา Character Escape Sequences ซึง่ เราสามารถนาํ มาใชในการจดั วางรปู แบบของผลลพั ธท ี่
เราตองการใหด แู ลวสวยงามขึ้น (อยา งหยาบ ๆ และ งาย ๆ)

ตาราง 2.7 Character Escape Sequence

Escape Sequence ความหมาย

\ddd แสดงผลลัพธเ ปน เลขฐานแปด (Octal)

\uxxxx แสดงตัวอักษร Unicode (Hexadecimal)

\' ตัว ' (Single quote)

\" ตัว " (Double quote)

\\ ตวั \ เอง

\r กลับไปยงั จดุ เร่ิมตน ของบรรทัด (Carriage return)

\n ข้ึนบรรทัดใหม (New line หรือ Linefeed)

\f เลอ่ื นไปหนาถดั ไป (Form feed)

\t เลื่อนไปยงั ตาํ แหนงถดั ไป (Tab)

\b เลอื่ นไปทางซา ยหน่งึ ตัวอักษร

2.13 การใชตัวแปรชนิด boolean

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

โดยทัว่ ไปเราสามารถประมวลผลขอ มูลท่ีเปน boolean ดว ย operator ตาง ๆ ท่เี หน็ นี้

&& หรอื ทเ่ี รียกวา Conditional AND
|| หรือทีเ่ รียกวา Conditional OR
& หรือทเ่ี รยี กวา Logical AND
| หรอื ท่เี รยี กวา Logical OR
! หรือทเ่ี รียกวา Logical NOT

&& และ || มกี ารประมวลผลในรปู แบบท่หี นงั สือหลาย ๆ เลม ใหช่ือวา Lazy หรอื Short Circuit ซงึ่ มี
รูปแบบการประมวลผลที่แตกตา งจาก & และ |

operator && ตา งจาก & โดยท่ี && นน้ั จะไมป ระมวลผล ประโยคหรอื ตวั แปรทต่ี ามหลงั ตวั มนั เอง ถา
ประโยคหรอื ตัวแปรทอ่ี ยกู อนหนา มีคา เปน false เพราะวาคา ท่เี ปน false เม่ือนาํ มาประมวลผลกับคา
อน่ื ๆ แลว จะได false เสมอ

operator || ก็เชน เดียวกันกบั && แตจะประมวลผลประโยคหรอื ตวั แปรทีต่ ามมาเมอื่ ประโยคแรกหรือ
ตวั แปรตัวแรกมีคา เปน true เพราะวา ประโยคหรอื ตวั แปรท่ีมีคา เปน true เม่อื นํามาประมวลกับคา ใด ๆ
ก็ตามจะไดค า true เสมอ

56

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

สว น operator & และ | จะประมวลผลประโยคและตัวแปรทงั้ สองเสมอ

และ operator ! น้นั เมื่อไปอยูหนาตวั แปรหรือประโยคที่มีคาทาง boolean คาใดคา หน่งึ กจ็ ะเปลี่ยน
คานน้ั ใหเ ปนตรงกนั ขามทันที

Operator ตวั อน่ื ๆ ที่ใชกับตัวแปรหรอื ประโยคทม่ี ีคา เปน boolean มีดงั น้ี

< ใชในการเปรียบเทยี บวา คาทางดา นซา ยของเคร่อื งหมาย นอ ยกวา คาทางดานขวาหรอื ไม
> ใชในการเปรียบเทยี บวา คา ทางดานซา ยของเครอื่ งหมาย มากกวา คา ทางดา นขวาหรอื ไม
<= ใชในการเปรียบเทยี บวา คา ทางดา นซา ยของเคร่ืองหมาย นอ ยกวาหรือเทา กบั คาทางดานขวา

หรือไม
>= ใชในการเปรยี บเทยี บวา คาทางดานซายของเครอื่ งหมาย มากกวาหรอื เทา กบั คาทางดา นขวา

หรอื ไม
== ใชในการเปรียบเทียบวา คา ทางดา นซา ยของเคร่อื งหมาย เทากบั คาทางดานขวาหรอื ไม
!= ใชในการเปรียบเทยี บวา คา ทางดา นซา ยของเครอื่ งหมาย ไมเทา กบั คา ทางดา นขวาหรอื ไม

เราเรียก operator เหลานว้ี า Relational operator ซึง่ เอาไวใ ชในการตรวจสอบความสมั พนั ธข องตวั
แปรหรอื ประโยควา มีคา แตกตา งกนั อยา งไรเม่ือนาํ มาเปรียบเทียบกนั

เราจะลองเขียนโปรแกรมตรวจสอบ operator ตาง ๆ เหลา นด้ี ู

1: /**
2: Testing boolean operations
3: */
4:
5: class BooleanOp {
6: public static void main(String[] args) {
7: boolean A = true, B = false;
8:
9: System.out.println("Conditional AND");
10: System.out.println("F && F is " + (B && B));
11: System.out.println("F && T is " + (B && A));
12: System.out.println("T && F is " + (A && B));
13: System.out.println("T && T is " + (A && A));
14:
15: System.out.println("Conditional OR");
16: System.out.println("F || F is " + (B || B));
17: System.out.println("F || T is " + (B || A));
18: System.out.println("T || F is " + (A || B));
19: System.out.println("T || T is " + (A || A));
20:
21: System.out.println("Logical AND");
22: System.out.println("F & F is " + (B & B));
23: System.out.println("F & T is " + (B & A));
24: System.out.println("T & F is " + (A & B));
25: System.out.println("T & T is " + (A & A));
26:
27: System.out.println("Logical OR");
28: System.out.println("F | F is " + (B | B));
29: System.out.println("F | T is " + (B | A));
30: System.out.println("T | F is " + (A | B));
31: System.out.println("T | T is " + (A | A));
32:
33: System.out.println("Logical NOT");
34: System.out.println("!F is " + (!B));
35: System.out.println("!T is " + (!A));
36: }
37: }

โปรแกรมประกาศตวั แปรสองตวั A และ B ดว ยคา true และ false ตามลําดบั และทําการแสดงผล
ลัพธข องการประมวลผลดวย operator ผานทาง System.out.println() ผลลพั ธท่แี สดงออกทาง
หนา จอ คอื

Conditional AND
F && F is false
F && T is false

57

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

T && F is false
T && T is true

Conditional OR
F || F is false
F || T is true
T || F is true
T || T is true

Logical AND
F & F is false
F & T is false
T & F is false
T & T is true

Logical OR
F | F is false
F | T is true
T | F is true
T | T is true

Logical NOT
!F is true
!T is false

ทีนลี้ องมาดโู ปรแกรมการใช Relational operator (BooleanOp2.java)

1: /**
2: Using relational operators
3: */
4:
5: class BooleanOp2 {
6: public static void main(String[] args) {
7: int i = 5, j = 10;
8:
9: System.out.println("i = " + i);
10: System.out.println("j = " + j);
11: System.out.println("i > j is " + (i > j));
12: System.out.println("i < j is " + (i < j));
13: System.out.println("i >= j is " + (i >= j));
14: System.out.println("i <= j is " + (i <= j));
15: System.out.println("i == j is " + (i == j));
16: System.out.println("i != j is " + (i != j));
17: System.out.println("(i < 10) && (j < 10) is " + ((i < 10) && (j < 10)) );
18: System.out.println("(i < 10) || (j < 10) is " + ((i < 10) || (j < 10)) );
19: }
20: }

โปรแกรม BooleanOp2.java ทาํ การหาคา ของประโยคตาง ๆ ในรปู แบบงาย ๆ เพ่อื ใหผ อู า นไดเหน็
ถึงผลลัพธของการใช operator ตาง ๆ ไดอ ยา งชัดเจน เราประกาศตัวแปรทเ่ี ปน int สองตวั คอื i
และ j ซึง่ กาํ หนดใหมคี าเปน 5 และ 10 ตามลาํ ดับ หลงั จากนน้ั โปรแกรมก็ใช operator ตาง ๆ กบั ตัว
แปรสองตวั น้ี

และเมอื่ run โปรแกรมนี้แลว ผลลัพธท่ีได คอื

i=5
j = 10
i > j is false
i < j is true
i >= j is false
i <= j is true
i == j is false
i != j is true
(i < 10) && (j < 10) is false
(i < 10) || (j < 10) is true

เพอื่ ใหเห็นภาพของการประมวลของ operator && และ operator || ไดชัดเจนยง่ิ ขึ้น ผูอ านควร
ตรวจสอบจากแผนภาพของการประมวลผลนี้ (ภาพที่ 2-4 และ 2-5) โดยเราไดกาํ หนดใหต ัวแปร p

58

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

และ q มีคา เปน 5 และ 10 ตามลําดบั ในการประมวลผลทางดา นซา ย และใหม คี าเปน 10 และ 5 ใน intro. to Java (FEU.faa)
การประมวลผลทางดา นขวา

(p < q) p = 5, q = 10 (p < q) p = 10, q = 5
&& (q <= 10) && (q <= 10)

T TF
ไมตองประมวลตอ เพราะ 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.8 การใช operator && || & และ |

P Q P && Q P || Q P&Q P|Q
true true
true true true true false true
false true
false true false true false false

true false false true

false false false false

เราคงมองไมเห็นถึงประโยชนข องการใชต ัวแปรทเ่ี ปน boolean และการใช operator ตาง ๆ ทไ่ี ดพูด
ถึงในตอนนอ้ี ยา งมากมายนัก การประมวลผลของตวั แปรทเ่ี ปน boolean สวนใหญจ ะเอาไวชวยการ
ตรวจสอบถึงเหตกุ ารณ (condition) ตา ง ๆ ทอ่ี าจเกิดขึ้นในโปรแกรม เชน ถา ประโยคที่หนง่ึ เมอ่ื
นาํ มาประมวลผลกบั ประโยคที่สองแลว ผลลพั ธทไี่ ดเ ปน true หรือ false ซ่งึ ถาเปน true เราจะทํา
การอยางอ่ืน และก็จะทาํ การอ่ืนหากเปน false เปน ตน เราจะพดู ถึง boolean operator ตาง ๆ เมอ่ื
เราพูดถงึ เร่อื งของ logic และเรอ่ื งของการประมวลผลในรปู แบบของการวนซ้าํ (logic and loop)

59

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

2.14 การประมวลผลในระดบั bit ดวยการใช operator Shift และ Bitwise

ในการทํางานในระดบั bit นน้ั มี operator ไมก่ตี ัวทเ่ี ราสามารถเรียกใชได ซึ่งการใชง านโดยทัว่ ไปก็ intro. to Java (FEU.faa)
ไมงายนกั เพราะตอ งทาํ ในระดับ 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 >> 1
13 = 000011012 เมอื่ shift ไปทางขวา 1 bit ผลลัพธท ไ่ี ดค อื 000001102 (เทากับ 6 ในเลขฐาน
10)

13 << 1
shift ไปทางซาย 1 bit ผลลัพธท ่ีไดค อื 000110102 (เทากบั 26 ในเลขฐาน 10)

13 >>> 1
shift ไปทางขวา 1 bit ผลลพั ธท่ไี ดคอื 000001102 (เทา กับ 6 ในเลขฐาน 10)

การโยก bit ไปทางซา ยคร้งั ละหนึ่ง bit นัน้ ท่ีจรงิ แลว ก็คือการคณู ดวยสอง เรามาดูตวั อยางโปรแกรม
การโยก bit ไปทางซา ยกัน จากโปรแกรม ShiftLeftOp.java ทเ่ี หน็ ดา นลา งนี้

1: /**

2: Using left-shift operator
3: */
4:

5: class ShiftLeftOp {
6: public static void main(String[] args) {
7: byte bits = 1;

8:

9: System.out.println("Value of bits is " + bits);
10: bits = (byte) (bits << 1);

11: System.out.println("Value of bits is " + bits);
12: bits = (byte) (bits << 1);

13: System.out.println("Value of bits is " + bits);
14: bits = (byte) (bits << 1);
15: System.out.println("Value of bits is " + bits);

16: bits = (byte) (bits << 1);
17: System.out.println("Value of bits is " + bits);
18: bits = (byte) (bits << 1);

19: System.out.println("Value of bits is " + bits);

20: bits = (byte) (bits << 2);
21: System.out.println("Value of bits is " + bits);

22: }
23: }

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

Value of bits is 1

Value of bits is 2
Value of bits is 4

60

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

Value of bits is 8
Value of bits is 16
Value of bits is 32

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

bits = (byte) (bits << 2);
System.out.println("Value of bits is " + bits);

ผลลัพธเม่ือ run อกี คร้ังดวย code ท่ีเพิ่มขึ้นจะเห็นวาคา ของ bits ทไ่ี ดม ีคา เปน -128 ซึง่ เปน คาที่
Java เปนผูกาํ หนดให แตไมใ ชค า ที่ถูกตอง เพราะขอมูลที่เปน byte น้ันเก็บคา สงู สดุ ทเี่ ปน บวกได
เพียงแค 127 เทานนั้

Value of bits is 1
Value of bits is 2
Value of bits is 4
Value of bits is 8
Value of bits is 16
Value of bits is 32
Value of bits is -128

สง่ิ สาํ คญั อีกสง่ิ หน่ึงกค็ อื การ cast เราจาํ เปน ตอ งเปลีย่ นขอ มูลใหถกู ตอ งตามชนดิ ของตวั แปร
เน่อื งจากวา Java ไดท ําการเปลย่ี นตัวแปร bits ของเราใหเปน int กอ นท่ีจะทําการ shift ดงั น้ันเรา
ตองเปลีย่ นขอมูลใหก ลบั มาเปน ชนดิ เดิมกอ นการจัดเกบ็ (หลงั จากการ shift สน้ิ สดุ ลง)

การใช >> และ << นน้ั สามารถทําใหจาํ งายข้นึ ดังนีค้ อื การโยก bit ไปทางขวาดวย >> นน้ั เปน
การหารตวั เลขน้ัน ๆ ดว ยสองยกกาํ ลังของจํานวน bit ทต่ี องการโยก เชน

128 >> 4 จะใหค า 128/24 = 16
-256 >> 4 จะใหค า -256/24 = -16

สวนการโยก bit ไปทางซา ยดว ย << นัน้ หมายถงึ การคณู ตวั เลขน้นั ๆ ดวยสองยกกาํ ลังจํานวน bit ท่ี
ตองการโยก เชน

128 << 1 จะใหคา 128 * 21 = 256
16 << 2 จะใหค า 16 * 22 = 64

โปรแกรมตัวอยา งตอ ไปน้ีเปน การแสดงการใช bitwise operator สามตวั คอื bitwise AND (&),
bitwise OR (|) และ bitwise exclusive OR (XOR)

1: /**
2: Show bitwise operations
3: */
4:
5: class BitwiseOperations {
6: public static void main(String[] args) {
7: byte bits = 5;
8:
9: System.out.println("Value of bits is " + bits);
10:
11: //using bitwise AND
12: bits = (byte)(bits & 5);
13: System.out.println("Value of bits is " + bits);
14:
15: //using bitwise OR
16: bits = (byte)(bits | 7);
17: System.out.println("Value of bits is " + bits);
18:
19: //using bitwise exclusive OR (XOR)
20: bits = (byte)(bits ^ 4);
21: System.out.println("Value of bits is " + bits);
22: }
23: }

61

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

การใช bitwise operator ทง้ั สามตัวมหี ลักการทําดงั ทีแ่ สดงในตารางที่ 2.10 นี้ intro. to Java (FEU.faa)

ตาราง 2.10 การใช bitwise operator &, |, และ ^

Operator วธิ ีใช ผลลัพธ

& operand1 & operand2 ถาคาของ bit เปน 1 ทัง้ คูผ ลลัพธท ไ่ี ดจะมีคาเปน

1

| operand1 | operand2 ถาคา ของ bit ตวั ใดตัวหนง่ึ เปน 1 ผลลพั ธท ีไ่ ดจ ะมี
คาเปน 1

^ operand1 ^ operand2 ถาคาของ bit ตางกนั ผลลัพธท ีไ่ ดจะมคี าเปน 1

โปรแกรม BitwiseOperations.java ทําการ & คา 5 กบั 5 ในบรรทดั ที่ 12 ซงึ่ ทําใหเ ราไดผลลพั ธ
เปน 5 (00000101 & 00000101 = 00000101) ในบรรทัดท่ี 16 เราทาํ การ | คา 5 กับ 7 เราก็ได
ผลลัพธเ ปน 7 (00000101 | 00000111 = 00000111) และในบรรทัดที่ 20 เราทําการ ^ คาของ 7
กบั 4 ซ่ึงไดผ ลลัพธเ ปน 3 (00000111 ^ 00000100 = 00000011)

เราไดพ ดู ถึงการประกาศตัวแปร การกาํ หนดคาใหก บั ตัวแปรท่อี ยภู ายในตัวโปรแกรม ดว ยขอมูลท้งั ที่มี
ชนดิ เปน integer และ floating-point ซึ่งการกําหนดคา ใหกับตัวแปรภายในโปรแกรมนั้น ไมมคี วาม
ยดื หยนุ ของขอมูลท่ถี กู เก็บอยูในตัวแปรนนั้ หากผูใช หรือ ผูเขียนโปรแกรมตองการท่ีจะเปล่ยี นคาท่ี
ตัวแปรนน้ั เกบ็ อยู ผูเขยี นจะตองเปนผูแกไ ขแตเพยี งฝา ยเดียว ผูใชโ ปรแกรมไมสามารถท่ีจะเปล่ียนคา
เหลาน้ันได ดังนน้ั การเขียนโปรแกรม จะตองใหโอกาสผใู ชโปรแกรมในการเปลีย่ นแปลงคา เหลาน้นั
Java มี method อยูหลายตวั ทรี่ องรบั การใสขอ มูลผา นทาง keyboard เราจะมาทําความรูจัก และ
เขา ใจถึงวิธีการ ซึง่ คอนขางจะซับซอนพอสมควรสาํ หรับผูเร่ิมหัดเขยี นโปรแกรมใหม อยา งไรก็ตาม
หลังจากท่ีไดทําความเขาใจแลว กจ็ ะเห็นวา การรับคาตาง ๆ ผา นทาง keyboard นั้นเปน เรื่องที่ (จริง
ๆ แลว) ไมยงุ ยากเลย

2.15 การกาํ หนดคาใหกบั ตวั แปรผา นทางสื่อการนําเขา ขอมลู มาตรฐาน

ใน Java รุนกอ น 1.5 เราไมส ามารถเรยี กใช method ใด ๆ ทรี่ บั คาขอ มูลตามชนิดนั้น ๆ ของขอมลู ท่ี
เขา มาเลย เชน ถา ผใู ชโปรแกรมตองการท่ีจะใสค า ทเ่ี ปน int float double หรอื char ผเู ขียน
โปรแกรมก็ไมสามารถทจี่ ะรบั คาตา ง ๆ เหลา นไี้ ดโ ดยตรง เหมือนกับการเขียนโปรแกรมดวยภาษาอ่นื
ๆ เชน C หรือ C++ แตต ัวผูเขยี นเองจะตอ งเขียน code ข้นึ มารองรบั คาเหลานผี้ า นทางการอา นเขา
แบบทเ่ี รียกวา การรับขอมลู ท่ีเปน String ซง่ึ เมื่ออาน String ไดแ ลว ก็ตอ งแปลง String ใหเปน ชนิด
ของขอ มูลท่ีผูเขยี นโปรแกรมตองการใหเ ปน [แตใ น Java รุน 1.5 เราสามารถอานคา เหลานผี้ านทาง
keyboard ไดเลย ซึ่งเราจะไดพดู ตอไปในเรือ่ งของ Scanner]

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

People of Thailand
สวสั ดี
price_of_coffee
1234567890
23+popOfRock

ตวั อยางท่เี หน็ ดานบนน้ลี ว นแลวแตเ ปน String ทั้งนัน้ ทีน้เี รามาลองดูวิธกี ารอา น String เขามาจาก
keyboard แลว กเ็ ปลยี่ น String ใหเ ปน ขอมูลชนิดตา ง ๆ ที่เราตองการ เริ่มดว ยการเปลย่ี นแปลง
code ของโปรแกรม Radius.java ใหรบั คาของ area จาก keyboard แทนการกําหนดภายใน
โปรแกรม

1: /**
2: Reading data from keyboard
3: */
4: import java.io.*;

5:
6: class Radius2 {
7: public static void main(String[] args) throws IOException {

8: double radius, area;

62

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

9: int meters, centimeters;
10: String inputString = null;
11:
12:
13: //prompt user for area of a circle
14: System.out.print("Enter area of a circle: ");
15:
16: //get string from keyboard
17: InputStreamReader in = new InputStreamReader(System.in);
18: BufferedReader buffer = new BufferedReader(in);
19: inputString = buffer.readLine();
20:
21: //convert string to double
22: area = Double.parseDouble(inputString);
23:
24: //calculate radius
25: radius = Math.sqrt(area / Math.PI);
26:
27: //convert to meters and centimeters
28: meters = (int)Math.floor(radius);
29: centimeters = (int)Math.round(100.0 * (radius - meters));
30:
31: System.out.print("Circle with area of " + area + " square meters ");
32: System.out.print("has a radius of " + meters + " meters and ");
33: System.out.println(centimeters + " centimeters");
34: }
35: }

โปรแกรม Raadius2.java เพ่ิม code ใหอาน String จาก keyboard ดว ยประโยค

System.out.print("Please enter area of a circle: ");
InputStreamReader 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 ใหเ ปน ขอ มูลชนิดท่ีเราตองการใชใน
โปรแกรม ซึง่ โปรแกรม Radius2.java ของเราตอ งการใชข อมลู ชนดิ ทเ่ี ปน double เราจึงตองทําการ
เปลยี่ น String นี้ใหเ ปน double ดวยการเรียกใช method parseDouble() จาก class Double พรอม
ทั้งสง ตวั แปรทเ่ี กบ็ ขอมูลจาก keyboard ไปใหแก method นด้ี ว ย

area = Double.parseDouble(inputString);

หลังจากนัน้ code ของโปรแกรมท่เี หลือกเ็ หมือนกับท่ีเราไดเขียนกอนหนานี้ และเมือ่ run โปรแกรม
ดู สองครง้ั ดวยคา 850 ในครัง้ แรกและคา 54 ในคร้งั ทส่ี อง เรากไ็ ดผ ลลัพธ ดังที่แสดงใหเห็นนี้

Please enter area of a circle: 850
Circle with area of 850.0 square meters has a radius of 16 meters and 45
centimeters

Please enter area of a circle: 54
Circle with area of 54.0 square meters has a radius of 4 meters and 15 centimeters

ถาสงั เกตใหด ีจะเห็นวา โปรแกรม Radius2.java นนั้ มีขอ ความเพ่ิมตอ ทา ยของ main(..) คอื

throws IOException

63

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

เหตผุ ลที่เราตองเพมิ่ throws IOException ใหกบั main(…) กเ็ พราะวา การอา นขอมลู เขาสู
โปรแกรมน้ัน บางคร้ังกอ็ าจเจอกับปญหาในการอา น เชน อานไมได และเหตผุ ลอกี อนั หนึ่ง คือ Java
บงั คับใหเราตองตรวจสอบการทาํ งานกับ I/O เอง ซึ่งถา หากมปี ญหาเกดิ ขน้ึ เราจะไดแกไขไดถ กู ตอง
มวี ธิ กี ารตรวจสอบและปอ งกนั ไมใ หการอานมีปญ หาหลากหลาย ซ่งึ เราจะไดด กู นั ในโอกาสตอไป
(บทที่ 7) ลองมาดูวา ถา เราไมใสข อ ความทวี่ า ลงไปในโปรแกรม Radius2.java เราจะได error อะไร

Radius2.java:16: unreported exception java.io.IOException; must be caught 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

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

1: /**
2: Reading data from keyboard with error detection
3: */
4:
5: import java.io.*;
6:
7: class Radius3 {
8: public static void main(String[] args) throws IOException {
9: double radius, area;
10: int meters, centimeters;
11: String inputString = null;
12:
13: try {
14: //prompt user for area of a circle
15: System.out.print("Please enter area of a circle: ");
16:
17: //get string from keyboard
18: InputStreamReader in = new

InputStreamReader(System.in);
19: BufferedReader buffer = new BufferedReader(in);
20: inputString = buffer.readLine();
21: }
22: catch(IOException ioe) {}
23:
24: //convert string to double
25: area = Double.parseDouble(inputString);
26:
27: //calculate radius
28: radius = Math.sqrt(area / Math.PI);
29:
30: //convert to meters and centimeters
31: meters = (int)Math.floor(radius);
32: centimeters = (int)Math.round(100.0 * (radius - meters));
33:
34: System.out.print("Circle with area of " + area + " square meters ");
35: System.out.print("has a radius of " + meters + " meters and ");
36: System.out.println(centimeters + " centimeters");
37: }
38: }

สงิ่ ท่เี ราไดปรบั ปรงุ คือประโยค ตอ ไปนี้

String inputString = null;

64

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

//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();
}
catch(IOException ioe) {}

เรายายการประกาศตัวแปร inputString ไปอยกู อ นประโยคท่ีอานขอ มลู เขาพรอมกบั เพม่ิ ประโยค

try {
…
…
…

}
catch(IOException ioe) {}

เขาสูโ ปรแกรมดวยการนําเอาประโยคการอา นขอ มลู เขา สู string ทัง้ สามประโยคไวใ น block ของ try
{} สว นคาํ วา catch(IOException ioe) {} นน้ั เรากเ็ พ่มิ เขาหลังจาก block ของ try {} เราไม
จาํ เปน ตอ งใส code อะไรเขาไปใน code ของ catch(IOExcpetion ioe) {} เพราะเราเพียงแต
ตอ งการใหการอา นเปน ไปไดดวยดเี ทานั้น เรายังจะไมกังวลถงึ error ทเี่ กดิ ขน้ึ ซงึ่ ถามี error เกดิ ขึน้
Java กจ็ ะเปนผูฟองใหเ ราทนั ที

เพื่อใหเ กิดความเขาใจอีกสกั หนอย เราจะมาตรวจสอบการใสขอมลู ของผใู ชดวู า ไดม กี ารใสขอ มลู เขา
สโู ปรแกรม หรือเพียงแตกดปมุ Enter เฉย ๆ เราทําการตรวจสอบดว ยการเพม่ิ try {..} และ catch()
{} ใหก ับโปรแกรม Radius3.java ดังนี้

1: /**
2: Reading data from keyboard with error detection
3: */
4: import java.io.*;
5:
6: class Radius4 {
7: public static void main(String[] args) {
8: double radius, area;
9: int meters, centimeters;
10: String inputString = null;
11:
12: //prompt user for area of a circle
13: System.out.print("Please enter area of a circle: ");
14: try {
15: //get string from keyboard
16: InputStreamReader in = new InputStreamReader(System.in);
17: BufferedReader buffer = new BufferedReader(in);
18: inputString = buffer.readLine();
19:
20: try {
21: //convert string to double
22: area = Double.parseDouble(inputString);
23:
24: //calculate radius
25: radius = Math.sqrt(area / Math.PI);
26:
27: //convert to meters and centimeters
28: meters = (int)Math.floor(radius);
29: centimeters = (int)Math.round(100.0 * (radius - meters));
30:
31: System.out.print("Circle with area of " +

area + " square meters ");
32: System.out.print("has a radius of " +

meters + " meters and ");
33: System.out.println(centimeters + " centimeters");
34: }
35: //catch empty string (user hits Enter)
36: catch(Exception e) {
37: System.out.println("Error! you must supply input");
38: e.printStackTrace();

65

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

39: System.exit(1);
40: }
41: }
42: //catch other I/O error - do nothing
43: catch(IOException ioe) { /* leave it to Java! */ }
44: }
45: }

โปรแกรม Radius3.java ท่ีเราเขียนขึ้นใหมม ี try {…} และ cath() {} อยูสองตวั ตัวแรกใชตรวจสอบ
เร่อื งของการอานทวั่ ไปทีไ่ ดก ลาวไปแลว สวนตัวที่สองเปน การตรวจสอบวา ผูใชมีการใสข อ มูลหรือไม
ซ่ึงถา ไมใส เราก็จะสง ขอ ความไปยังหนา จอดวยคาํ สัง่ System.out.println("Error! you must
supply input");

1. สงขอ ความ error ที่ Java ไดฟ องไว ดว ยคําสงั่ e.printStackTrace();
2. ออกจากโปรแกรมโดยไมมกี ารประมวลผลใด ๆ ท้งั สิ้น ดว ยคาํ ส่ัง System.exit(1);

และเม่ือ execute ดเู รากจ็ ะไดข อ ความดงั นี้

Please enter area of a circle: < User กดปุม Enter >
Error! you must supply input
java.lang.NumberFormatException: empty String

at sun misc FloatingDecimal.readJavaFormatString (Unknown Source)
at java.lang.Double.parseDouble(Unknown Source)
at Radius4.main(Radius4.java:22)

โดยท่ัวไปการออกจากโปรแกรมทีไ่ มม ปี ญ หาใด ๆ ในการเขียนดว ยภาษา Java น้นั เราจะใชการออก
ดว ยเลข 1 ในประโยค System.exit(1) หรือเลขอ่ืน ๆ ท่ีไมใ ช 0 สวนการออกแบบปกตินั้นเราใชเลข
0 แทนเลข 1

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

2.15.1 การนาํ ขอมูลเขา ผา นทาง Scanner

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

Scanner เปน ตัวกลางทย่ี อมใหม กี ารโยกยา ยขอมูลจากแหลง หนึ่งไปอีกแหลง หนงึ่ เชน จาก
keyboard เขาสตู วั แปรเปนตน โปรแกรมตวั อยางท่เี หน็ เปนการอา นขอ มลู เขา จาก keyboard ผาน
ทาง Scanner

1: /**
2: Reading numbers via Scanner
3: */
4:
5: import java.util.Scanner;
6: import static java.lang.System.out;
7:
8: class AddIntegers {
9: public static void main(String[] args) {
10: //setup input channel via command prompt
11: Scanner input = new Scanner(System.in);
12:
13: int number1, number2;
14: int sum;
15: float average;
16:
17: //prompt for two integers
18: out.print("Enter first integer: ");
19: number1 = input.nextInt();
20: out.print("Enter second integer: ");
21: number2 = input.nextInt();
22:
23: //find sum and average

66

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

24: sum = number1 + number2;
25: average = sum / 2.0F;
26:
27: //display results
28: out.printf("Sum of two integers is %d%n", sum);
29: out.printf("Average of two integers is %.2f%n", average);
30: }
31: }

ในบรรทัดท่ี 11 เรากําหนดใหก ารนําขอ มลู เขาผา นทาง command prompt โดยใช Scanner เปน
ตัวกลาง และเราอา นขอมูลท่ีเปน integer ในบรรทัดที่ 19 และ 21 ซง่ึ เราจําเปนตอ งอาศัย method
nextInt() เปนตัวอา นให class Scanner มี method หลายตัวท่ีเราสามารถเรยี กใชอานขอ มลู ชนดิ
ตา ง ๆ ได เชน

ขอ มูลที่เปน integer ใช nextInt()
ขอ มลู ท่ีเปน float และ double เรยี กใช nextFloat() และ nextDouble() ตามลําดบั
ขอมลู ท่ีเปน long และ short เรียกใช nextLong() และ nextShort() ตามลาํ ดบั

ถา ตองการอา นขอ มูลอน่ื ๆ โดยไมสนใจชนดิ เราก็เรยี กใช next() ซ่งึ หมายถงึ การอา นขอมูลตวั ถัดไป
หรอื nextLine() ท่ีหมายถงึ การอา นขอมลู ท้งั บรรทดั

สวนการตรวจสอบวามีขอ มูลอยูอ ีกหรือไมเ รากเ็ รยี กใช hasNext(), hasNextInt(), หรือ
hasNextDouble()

Class Scanner ยงั มี method อน่ื ๆ ใหเ ราเรยี กใชไดอีกมาก ทั้งนี้ผูอา นสามารถหาดไู ดจาก Java
API ไดเอง

2.15.2 การนําขอมลู เขา และออกผาน Dialog Box

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

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

1: /**
2: Reading input via InputDialog
3: */
4: import javax.swing.*;
5:
6: class InputTest {
7: public static void main(String[] args) {
8: //get name
9: String name = JOptionPane.showInputDialog("What is your name?");
10:
11: //get age
12: String ageStr = JOptionPane.showInputDialog("Tell me you age.");
13: int age = Integer.parseInt(ageStr);
14:
15: //send output to standard output device (console)
16: System.out.println("Hello " + name + " " +
17: age + " is very young!");
18:
19: System.exit(0);
20: }
21: }

หลงั จากที่ compile และ run โปรแกรม หนาตา งแรกทเ่ี ราไดค ือ

67

เรมิ่ ตนการเขียนโปรแกรมดว ย Java intro. to Java (FEU.faa)
Prompt user เพ่ือใสข อมลู

กดปมุ OK เพื่อยอมรับขอมูล ซึ่ง กดปุม Cancel เพอ่ื ยกเลิกขอมลู
จะทาํ ให dialog box ปดตวั เอง พรอ มกบั ปด dialog box

ลงดว ย

หลงั จากท่ีใสขอมลู Peter Pan เรากก็ ดปุม OK ซึ่งจะทําใหหนาตา งที่สองเกดิ ขน้ึ

ซ่ึงเม่อื กดปุม OK แลวผลลัพธท่ีไดจากการประมวลผลจะถูกนาํ ไปแสดงยงั console ที่เราไดเ ปดอยู
ดังนี้

Hello Peter Pan 42 is very young!

ในโปรแกรม Inputtest.java เราใชตัวแปร 3 ตัวเปน ตัวเก็บขอมูล 2 ตัวแรก name และ ageStr เปน
String ทีเ่ กบ็ ขอมลู ที่ user ใสเขา สูโ ปรแกรมผานทาง

String name = JOptionPane.showInputDialog ("What is your name?");
String ageStr = JOptionPane.showInputDialog ("Tell me your age.");

สวนตวั แปร age เปนการแปลง string ท่ี user ใสเขามาใหเปน int เชนเดียวกบั ท่เี ราไดทํามากอน
หนาน้ี

สาํ หรับประโยคที่อยูในบรรทดั สดุ ทา ยนัน้ (System.exit(0)) เราจําเปน จะเห็นที่จะตองใสไว เนื่องจาก
เปน ขอกําหนดของ Java เมอื่ ไรกต็ ามทเ่ี ราใช JOptionpane.showInputDialog เราจะตองมปี ระโยค
นีเ้ พื่อบังคบั ให Java ทําการยุตกิ ารทํางานของ Thread ทคี่ วบคมุ InputDialog อยู

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

1: /**
2: Reading input via InputDialog
3: Sending output via MessageDialog
4: */
5: import javax.swing.*;

68

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

6:
7: class OutputTest {
8: public static void main(String[] args) {
9: //get name
10: String name = JOptionPane.showInputDialog("What is your name?");
11:
12: //get age
13: String ageStr = JOptionPane.showInputDialog("Tell me you age.");
14: int age = Integer.parseInt(ageStr);
15: age += 5;
16:
17: JOptionPane.showMessageDialog(null,
18: "Hello " + name + ", " +
19: " 5 years from now you will be " + age +
20: ".\nWhich is still very young!",
21: "Output",
22: JOptionPane.INFORMATION_MESSAGE);
23:
24: System.exit(0);
25: }
26: }

โปรแกรม OutputTest.java ไดถ ูกปรับปรงุ ขนึ้ จากโปรแกรม InputTest.java ท่เี ราเขยี นขึ้นกอ นหนา
น้ี ส่งิ ท่เี ราไดเพม่ิ ข้ึนมากค็ อื

JOptionPane.showMessageDialog(null,
"Hello " + name + ", " +
" 5 years from now you will be " + age +
".\nWhich is still very young!",
"Output",
JOptionPane.INFORMATION_MESSAGE);

ซ่งึ เปนการสง ขอมูลไปยัง user ผานทาง Dialog Window โดยท่ี showMessageDialog() จะตอ งมี
parameter สงไปทง้ั หมด 4 ตวั ดงั น้ี

1. Component
2. Object ทีเ่ ปน message ทต่ี อ งการสง ออก
3. string ทีเ่ ปน หัว หรือ title ของ MessageDialog
4. ชนดิ ของ Message

เรากําหนดให Component เปน null (เร่ืองน้อี ยนู อกเหนือ scope ของหนงั สอื เลม นี้) สว น Object ที่
เปน message เรากําหนดใหเปน

"Hello " + name + ", " +
" 5 years from now you will be " + age +
".\nWhich is still very young!",

String ท่ีเปน title ของ MessageDialog น้นั เรากําหนดใหม ีคาเปน "Output" ซึง่ ผอู านและสุดทา ย
เรากําหนดใหช นดิ ของ message เปนเพยี งแคข อ มูล (INFORMATION_MESSAGE) ซง่ึ การบอก
ชนดิ ของ message จะทาํ ให icon ของ MessageDialog เปลี่ยนไป ผอู านควรเปรียบเทียบขอ ความ
ดงั กลา วกบั ผลลัพธทีไ่ ดจากการ run น้ี (ขอมูลเขาเหมือนเดมิ )

ขนาดของ MessageDialog จะขนึ้ อยกู ับความยาวของ message ทีถ่ กู สงออกกไป เราสามารถท่ีจะ
ใช "\n" เปน ตัวกาํ หนดการขึน้ บรรทดั ใหมข องขอ มูลได ผูอา นควรสงั เกตถึงการสง ขอมลู ท่เี ปน int ไป

69

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

ยัง MessageDialog (ตวั แปร age) เราไมจ ําเปนทจี่ ะตองเปลี่ยนใหเปน string กอนการสงแตอ ยา ง
ใด การแปลงชนิดจะทําโดยอตั โนมตั ิ

ถาระบบของผูอานรองรบั การใชภ าษาไทย และใช Java ท่รี องรบั ภาษาไทยเหมือนกัน การเปลีย่ น
ขอ มูลบางอยางในโปรแกรมจะทาํ ใหผลลัพธมหี นาตาคลา ยๆ แบบนี้

ตวั อยางท่ีเราแสดงใหดูเปน การอานขอมลู เพียงตัวเดยี วจาก keyboard ถา เราตอ งการอานขอ มลู ท่ีมี
มากกวา หนึ่งตวั เราตอ งทาํ อยา งไรบาง คําตอบงาย ๆ ทเี่ ราสามารถทาํ ไดทนั ทกี ็คือ ใช dialog box
อานทลี ะตัว แตว ธิ ีการแบบน้ี ทาํ ใหเราตองเสียเวลาในการนําขอ มูลเขา มากเกินไป (หน่งึ dialog box
ตอหนงึ่ ขอ มลู ) เพราะฉะน้นั เราตองหาวธิ ใี หมใ นการนาํ ขอ มูลเขา ซึ่งเราจะกลับมาดูกนั ถึงวิธดี งั กลา ว
ในบทที่ 3 เมอ่ื เราไดพดู ถงึ เรื่องของการประมวลผลแบบวน (loop)

2.16 การใช enum

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

1: /**
2: Shows simple usage of enum
3: */
4:
5: enum Season {SUMMER, RAINNY, WINTER};
6:
7: class UseOfEnum {
8: public static void main(String[] args) {
9: //printing values of enum
10: System.out.println("Seasons in Thailand are: " +
11: Season.SUMMER + ", " +
12: Season.RAINNY + ", and " +
13: Season.WINTER);
14: }
15: }

ในการประกาศใช enum นั้นเราตอ งขนึ้ ตนการประกาศดว ยคําวา enum ตามดวยชื่อของ enum ทีเ่ รา
ตอ งการใช ตามดวยเครือ่ งหมาย { ซึ่งในเคร่ืองหมาย { นีเ้ ราสามารถใสข อ มลู ท่ีเราตองการไว ดงั ที่
เราทําใน enum Season เพราะวา เราตอ งการเรยี กใชค า ของฤดตู า ง ๆ ท่มี ีอยูในบา นเราดงั นนั้ เราจงึ
กาํ หนดใหมี 3 ฤดูคอื SUMMER, RAINNY, และ WINTER พรอ มกบั ปดทา ยดว ยเครอ่ื งหมาย }

ในการเรยี กใช enum นน้ั เราตองขึ้นตน ดว ยชอื่ ของ enum ตามดว ยจดุ (.) และชอื่ แทนขอมลู ท่ีเราได
ประกาศภายใน enum นน้ั เชน

Season.WINTER

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

System.out.println("SUMMER = " + Season.SUMMER.ordinal() + "\n" +
"RAINNY = " + Season.RAINNY.ordinal() + "\n" +
"WINTER = " + Season.WINTER.ordinal());

70

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

ซึ่งจะใหผ ลลพั ธค อื

Seasons in Thailand are: SUMMER, RAINNY, and WINTER
SUMMER = 0
RAINNY = 1
WINTER = 2

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

โปรแกรมตวั อยางทเ่ี ห็นอาจไมมปี ระโยชนอะไรมากมายนัก แต enum ยังมีวธิ กี ารใชแบบอน่ื ๆ อีกให
เราไดใ ช ซ่ึงเราจะไดดูในบทตอ ๆ ไป

สรุป

เราไดเรียนรูถ งึ ขอมลู ชนดิ ตา ง ๆ ทเ่ี ปนขอ มูลแบบพืน้ ฐาน หรอื ท่ีเรียกวา primitive datatype ที่ Java
มีให รวมไปถึงการประกาศตัวแปร การกําหนดคา ใหกบั ตัวแปร การประมวลผลตัวแปรชนดิ เดยี วกัน
และ ตา งชนดิ กนั การเปล่ียนชนิดของขอ มลู (casting) การใช method ท่เี กีย่ วของกบั ตัวเลข การ
แสดงผลตวั เลขทม่ี ีจุดทศนยิ ม การอา นขอ มูลเขา สูโปรแกรม การตรวจสอบ และตรวจจับ error ทอ่ี าจ
เกิดข้นึ ในการอานขอ มลู การทํางานในระดบั bit และการใช dialog box ในการอา นและแสดงผล
ขอ มลู

แบบฝก หัด

1. จงอธบิ ายถงึ ความหมายของคาํ วา final พรอ มทัง้ ยกตัวอยา งประกอบ

2. จงอธบิ ายถงึ ความแตกตา งระหวาง 5, 5.0, '5', "5", และ "5.0"

3. จงแสดงผลลัพธของประโยคตอ ไปน้ี

3.1. System.out.println("4" + 4);
3.2. System.out.println('4' + 4);
3.3. System.out.println("4" + 4 + 4);
3.4. System.out.println("4" + (4 + 4));
3.5. System.out.println('4' + 4 + 4);

4. จงแสดงผลลพั ธของประโยคตอ ไปน้ี

4.1. System.out.println("Value is %f %e\n", 45.25, 45.25);
4.2. System.out.println("Value is %5.4f %5.4e\n", 45.25, 45.25);
4.3. System.out.println("%4b%n", (4 > 5));
4.4. System.out.println("%6s\n", "Java");

5. จงหาวา ประโยคตอ ไปนเ้ี ก่ยี วขอ งกบั การ cast หรือไมถ าเกี่ยวขอ งใหห าผลลพั ธข องการ cast นนั้

char c = 'A';
in = (int)c;

boolean b = true;
in = (int)b;

float f = 500.44f;
in = (int)f;

double d = 500.44d;
in = (int)d;

71

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

int x = 65; intro. to Java (FEU.faa)
char c = (char)x;

int v = 1000;
Boolean b = (Boolean)v;

6. กาํ หนดให x มคี าเปน 1 จงหาคาของการประมวลผลตอ ไปน้ี

6.1. (x > 1) & (x++ > 1)
6.2. (x > 1) && (x++ > 1)
6.3. x >> 1
6.4. x << 1
6.5. x >>> 1
6.6. x ^ 1
6.7. x & 1
6.8. x | 1

7. จงหาผลลัพธข องการประมวลผลประโยคตอ ไปน้ี ถา กําหนดให

double x = 4.5;
double y = -45.25;
int p = 12;
int q = 2;

7.1. x + p * y / (p – y) * x
7.2. p % (p – q)
7.3. (int) y
7.4. (int) p
7.5. Math.round(x)
7.6. (int) Math.round(y)
7.7. -2 * y + (int) x
7.8. q/p
7.9. p%q
7.10. y * y – y + (x * (int) x)

8. จงเขียนโปรแกรมทรี่ ับตวั เลขชนิด int จาก keyboard จํานวน 2 ตัว และขอมลู ชนดิ double อกี
2 ตวั หลังจากนนั้ ใหโ ปรแกรมคาํ นวณหาผลรวมของเลขท้ัง 4 ตวั ใหเก็บผลลพั ธท่หี าไดไ วในตัว
แปรตัวใหม สงผลลพั ธท ี่ไดไปยงั หนา จอ

9. จงเขยี นประโยคดวยภาษา Java จากสมการท่ใี หน ี้

9.1. a + bc / 2
9.2. a(a – c) + b(b – c) – (c(c – a) / d)
9.3. b2 – 4ac
9.4. (4/3)2 / 2

9.5. q = ⎛⎜ T1 xM ⎟⎞ + T2
⎝ D−k ⎠

10. จงเขยี นโปรแกรมท่ที ําการเปลีย่ น องศา Celsius ใหเ ปนองศา Fahrenheit โดยกําหนดใหข อ มลู
ทีต่ องการเปลยี่ น นําเขาจาก keyboard โดยกําหนดใหสตู รการเปล่ียน คอื

Celsius = 5 (Fahrenheit – 32)
9

72

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

11. จงเขียนโปรแกรมท่ีทําการเปล่ยี น องศา Fahrenheit ใหเปนองศา Celsius โดยกาํ หนดใหข อมูล intro. to Java (FEU.faa)
ท่ีตอ งการเปล่ียน นําเขาจาก keyboard

12. จงเขียนโปรแกรมทรี่ ับขอมูลที่เปนจาํ นวนกิโลกรมั จาก keyboard เปลี่ยนใหเปน mile สง
ผลลพั ธไปยังหนา จอ

13. จงเขียนโปรแกรมท่อี านขอมูลจาก keyboard ท่เี ปน อายุของผใู ชในรปู แบบของป ใหโปรแกรม
เปล่ยี นเปน จาํ นวนวนั สง ผลลพั ธออกทางหนา จอ (กาํ หนดให 1 ปเทากบั 365 วัน)

14. จงเขียนโปรแกรมทร่ี ับ int จํานวน 5 ตัว หาคา เฉลยี่ ของตัวเลขเหลานี้ เสร็จแลวสง ผลลัพธไปยัง
หนาจอ

15. จงเขียนโปรแกรมท่คี ํานวณหาเวลาท่แี สงเดินทางจากโลกไปยังดวงอาทิตย ใหส ง ผลลัพธข อง
การคาํ นวณในรูปแบบของนาที สง ผลลพั ธท ห่ี าไดไ ปยังหนา จอ

16. สมมติวาอาจารยท กุ คนในวิทยาลัยแหง หนง่ึ ดมื่ beer 1 ขวดตอ วัน และในการทาํ beer 1 ลัง (24
ขวด) นน้ั ตองใชข า ว barley จํานวน 1 ถัง ถาจํานวนของอาจารยในวทิ ยาลยั ท่ีวาน้มี ที ้ังสน้ิ 200
คน จงเขียนโปรแกรมในการคาํ นวณหาจาํ นวนของขา ว barley ที่ตองใชในการทาํ beer ให
เพียงพอตอการบรโิ ภคของอาจารยใ นวทิ ยาลัยนต้ี ลอดภาคการศึกษา

17. จงเขยี นโปรแกรมที่รบั ขอมลู ชนิด long ทม่ี ีจาํ นวนของตัวเลข (digit) อยรู ะหวาง 10 – 12 ตวั ให
สง ผลลัพธในรูปแบบของ ตวั เลขที่ใชเคร่อื งหมาย , เปน ตัวแบงกลุม โดยเร่มิ ตนจากทางขวามือ
และใหมตี ัวเลขกลุมละ 3 ตวั ไปยังหนาจอ

18. จงเขยี นโปรแกรมที่รบั คา ความยาวของดา นทกุ ดา นของสามเหล่ียม จากนั้นใหค ํานวณหาคา ของ
เสนรอบรปู (perimeter) สง ผลลพั ธไ ปยังหนา จอ

19. จงเขยี นโปรแกรมทค่ี าํ นวณหาพนื้ ทีข่ องวงกลม จากรศั มีท่ีรับเขา มาจาก keyboard

20. จงเขียนโปรแกรมทรี่ บั ขอมูลชนดิ double จาํ นวน 5 ตัวจาก keyboard จากนน้ั ใหค าํ นวณหา
คา เฉล่ียของตวั เลขเหลา น้ัน สงผลลพั ธทหี่ าไดไ ปยังหนาจอ

21. กาํ หนดใหเสนผา ศนู ยก ลางของดวงอาทติ ยเทากับ 865,000 ไมล และเสนผาศูนยก ลางของโลก
เทา กับ 7,600 ไมล จงเขียนโปรแกรมทคี่ าํ นวณหา

21.1. ปริมาตรของโลก (cubic mile หรอื mile3)
21.2. ปริมาตาของดวงอาทิตย (cubic mile)
21.3. อัตราสว นของปรมิ าตรของดวงอาทติ ยต อปรมิ าตรของโลก

22. จงเขยี นโปรแกรมท่รี ับขอมูลชนิด double ท่อี ยใู นรปู แบบ xxx.xxxx เชน 123.4567 จาก
keyboard จากนัน้ ใหดงึ เอาสว นของขอมลู ทอี่ ยูหนาจดุ ทศนยิ มไปเกบ็ ไวใ นตัวแปรที่มีชนิดเปน
long ตัวหน่งึ เสรจ็ แลว ใหเ กบ็ ขอ มลู ท่อี ยหู ลงั จุดทศนยิ มไปเก็บไวในตัวทเี่ ปน long อกี ตัวหนง่ึ
สงผลลพั ธท ีอ่ ยใู นตัวแปร long ท้งั สองไปยังหนาจอ

23. จงเขียนโปรแกรมแสดงผลการยกกําลังของ integer จาก 0 ถงึ 10 ดงั เชนตวั อยา งท่ีแสดงใน
ตารางน้ี

number square cube
0 00
1 11
2 48
3 9 27
4 16 64
5 25 125
6 36 216
7 49 343
8 64 512
9 81 729

10 100 1000

73

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

24. จากขอ 4 จงเขียนโปรแกรมทรี่ ับขอมูลผา นทาง JOptionPane.showInputDialog เมื่อ
คํานวณหาคาเสนรอบรปู ไดแลว ใหส ง ผลลพั ธอ อกทาง JOptionPane.messageDialog

25. ใช JOptionPane เขียนโปรแกรมแกปญหาของโจทยในขอ 19
26. จงเขยี นโปรแกรมท่ีทาํ หนาทีเ่ ปลี่ยนตวั อกั ษรภาษาอังกฤษตวั เล็ก (lower case) ใหเปน ตัวใหญ

(upper case) โดยไมม กี ารเรยี กใช method ใด ๆ ของ Java (ดตู าราง ASCII เพอ่ื หาคาความ
ตา งของตวั อกั ษรท้ังสองแบบ)
27. จงเขยี นโปรแกรมทีอ่ า นคาสามคาทเี่ ปน คา ของสามเหลี่ยมทง้ั สามดาน พรอ มทั้งคํานวณวา คาที่
อา นเขา มานัน้ สามารถสรางสามเหลย่ี มไดจ รงิ โดยแสดงผลกลับออกไปในรปู แบบของ true หรอื
false เชน
Can edges 1, 2, and 1 form a triangle? False
Can edges 2, 2, and 1 form a triangle? True
[ดานสามดา นจะเปนสามเหลี่ยมได ถา ผลรวมของดา นสองดา นใด ๆ มีค่ ามากกวา ดา นอกี ดา นท่ี
เหลอื อย]ู
28. จงเขียนโปรแกรมท่อี านคา ระหวาง 0 ถงึ 1000 เพ่อื นาํ มาคํานวณหารผลรวมของตวั เลขทีอ่ ยใู น
คา ทอ่ี านเขามา เชน ถา คา ทอ่ี า นมีคาเปน 345 ผลลพั ธท่ีไดคือ 12
[ใช operator % เพอ่ื ดึงตวั เลขออกจากคา ที่อา นเขามา และใช operator / ในการลบตัวเลข
ออกจากคานั้น เชน 654 % 10 = 4 และ 654 / 10 = 65]
29. ใช JOptionPane เขียนโปรแกรมแกปญ หาของโจทยใ นขอ 20 ขอสังเกตของการใช
JOptionPane มีขีดจํากดั ในเร่ืองของการใสขอมลู คอื จะใสไดเพยี งแค string หนงึ่ ตัว ดงั นนั้ ถา
ตอ งใสข อ มูลท่ีเปน double 5 ตัวเราจําเปนท่ีจะตองมาตรการอน่ื เขา มาชว ย เชน ใชชองวางเปน
ตวั แบง ขอ มูลใน string ทนี่ าํ เขาดังตวั อยา งตอ ไปนี้

ผลลัพธทไ่ี ดจ าการคาํ นวณของ input ดา นบนคือ

ผลลพั ธท ี่ไดมาจากการใช method ของ class StringTokenizer ซ่งึ อยใู น package
java.util.StringTokenizer (ดบู ทที่ 3)

74

ในบททสี่ ามน้เี ราจะมาทําความรจู ักกบั การทํางานในรปู แบบของการประมวลผลชุดคําสง่ั ซา้ํ ๆ กันตาม 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