บทที่ 2 ชนิดของตัว

ชนิดของตัวแปร และตัวดําเนินการ
Data Type and Operator
วัตถุประสงค
♦ เพื่อใหมีความรูความเขาใจตัวแปรและตัวดําเนินการของภาษาจาวา
♦ เพื่อใหสามารถเขียนโปรแกรมที่ประกอบดวยตัวแปรและการดําเนินการได
♦ เพื่อใหมีความรูและความสามารถเขียนโปรแกรมจาวาประยุกตใชกับงานจริงได
บทที่
2

บทที่ 2 ชนิดของตัวแปร และตัวดําเนินการ หนาที่
เอกสารประกอบการสอน 305272 การเขียนโปรแกรมคอมพิวเตอรขั้นสูง
อ.สุรางคนา ระวังยศ
35
เนื้อหาบทเรียน
♦ ชื่อของตัวแปร
♦ คําสงวน
♦ คาคงที่สําหรับตัวแปร(Literals)
♦ ประโยคคําสั่ง(Statement)
♦ การประกาศตัวแปร
♦ ขอมูลชนิดพื้นฐาน(Primitive Data types)
♦ การเปลี่ยนชนิดของตัวแปร
♦ นิพจน : นิพจนคํานวณ นิพจนเชิงสัมพันธ และนิพจนเชิงตรรกะ
♦ ตัวดําเนินการ : ตัวดําเนินการคํานวณ ตัวดําเนินการสัมพันธ และตัวดําเนินการตรรกะ
♦ ลําดับการทํางานกอนหลังของตัวดําเนินการ

36
กอนที่เราจะศึกษาการเขียนโปรแกรมคอมพิวเตอรไมวาภาษาใดก็ตาม จําเปนตองรูไวยกรณ
(Syntax definition) ขอกําหนดของภาษา หรือองคประกอบพื้นฐาน(Elements)ของแตละภาษากอน และ
ในการเรียนโปรแกรมภาษาจาวาก็เชนกัน จําเปนตองศึกษาถึงองคประกอบพื้นฐานตางๆ เพื่อเปนความรู
เบื้องตนในการพัฒนาโปรแกรมตอไป ซึ่งองคประกอบพื้นฐานเหลานั้นคือ
• ชื่อของตัวแปร(Identifiers) ผูใชโปรแกรมสามารถตั้งขึ้นเพื่อใชงานเองไดแตมี
ขอกําหนดที่ควรเรียนรูของแตละภาษา
• คําสงวน(Keywords) ศึกษาถึงขอความที่ภาษานั้นนิยามไวใหเปนคําสั่ง ตัวดําเนินการ
ตัวควบคุมการทํางานของโปรแกรม หรืออื่นๆ ซึ่งไดกําหนดวิธีการใชงานไวและมี
ขอกําหนดในการใชขอความเหลานี้ในการเขียนโปรแกรมแลว
• คําที่ใชแสดงคาคงที่(Constants)ในโปรแกรม(Literals) ศึกษาถึงวิธีการกําหนดคาคงที่
ตางๆ หรือการกําหนดชนิดของตัวแปรในโปรแกรม
• ประโยคคําสั่ง(Statements) เรียนรูถึงโครงสรางการเขียนคําสั่งหนึ่งคําสั่งหรือหนึ่ง
ขั้นตอนในการคอมไพลของภาษา หรือเรียกไดวาเปนหนวยของภาษาที่ใชกําหนดการ
ทํางานของโปรแกรม
• ขอบเขตของตัวแปร(Code blocks) ศึกษาถึงการกําหนดขอบเขตใหกับ statements
• คําอธิบายโปรแกรม(Comments) ศึกษาถึงรูปบบ วิธีการเขียนคําอธิบายหรือหมายเหตุ
ใหกับโปรแกรม
• นิพจน(Expressions) เรียนรูถึงการเขียนนิพจน อยางไรถึงเรียกวาเปนนิพจน
• เครื่องหมายที่ใชในการดําเนินการ(Operators) เรียนรูถึงเครื่องหมายในการดําเนินการ
ของโปรแกรมวาใชงานกันอยางไร
ชื่อของตัวแปร(Identifiers)
ชื่อตัวแปร(variables) ชื่อคลาส(class) ชื่อเมธอด(methods) หรือไฟล(files) เรียกวา identifier
หมายถึงชื่อสําหรับอางอิงถึงพื้นที่ในหนวยความจําโดยโปรแกรม ตัวแปรมีหลายชนิด และหลายขนาด
ในระบบคอมพิวเตอรนิยมใชตัวแปรเพียง 2 ประเภท คือตัวแปรตัวเลข (Numeric Variable) และสตริง
(String) เชน ID = 98703
ITEM$ = "NOTEBOOK"
ตัวแปรทุกตัวในภาษาจาวาตองถูกประกาศกอนที่จะมีการใชตัวแปรนั้นๆ ในนิพจนหรือในคําสั่ง
การประกาศตัวแปร จะเปนการบอกจาวาคอมไพเลอรใหเก็บขอมูลตามชนิดของตัวแปรและขอมูลในตัว
แปรสามารถเปลี่ยนแปลงไดในขณะประมวลผล
กฎการตั้งชื่อตัวแปร คลาส เมธอด ในภาษาจาวามีดังตอไปนี้

37
• สามารถตั้งชื่อดวยตัวอักษร(A-Z , a-z) ตัวเลข(0-9) underscore( _ ) หรือ
dollar sign ($) เปนสวนหนึ่งของชื่อตัวแปรได
• ไมใช คําสงวน
• ไมเริ่มตนดวยตัวเลข
• ไมมีตัวอักขระไวทสเปส(white space : tab ,space ,linefeed or carriage return) เปน
สวนหนึ่งของชื่อ
• ชื่อตัวแปรที่เปนอักษรตัวเล็กลวน ตัวอักษรตัวใหญลวน หรือตัวอักษรเล็กปน
ตัวอักษรใหญ จะถือวาเปนคนละชื่อกัน(case sensitive) เชน GoOD ตางกับ good
ตัวอยางชื่อตัวแปรที่ถูกตอง
_age amount$ number Width error_count
Column1 Valid Buffer_Modified row
_attr_ $total Number_of_Attempts
ตัวอยางชื่อตัวแปรที่ไมถูกตอง
31flavors ไมถูกตองเพราะขึ้นตนดวยตัวเลข
max-min ไมถูกตองเพราะมีตัวอักขระไฮเฟน( - ) ปน
float ไมถูกตองเพราะเปนคําสงวนของภาษาจาวา
หมายเหตุ
ในการเขียนโปรแกรมภาษาจาวานิยมกําหนด identifier เพื่อใหสามารถอานโปรแกรมไดงาย
ถึงแมวาขอตกลงเหลานี้ไมมีผลกระทบในการคอมไพล แตบรรดาโปรแกรมเมอรจาวาทั้งหลายควร
ปฏิบัติและฝกเขียนโปรแกรมใหอยูในรูปแบบตามขอตกลงในการตั้งชื่อ ดังตารางตอไปนี้
ชนิด Identifier สิ่งที่นิยม ตัวอยาง
Class Name ตัวอักษรตัวแรกเปนตัวใหญ สวนตัวอื่นเปนอักษรตัวเล็ก Mammal , Car , Student
Function Name ตัวอักษรตัวเล็กหมด แตถาประกอบดวยคําหลายๆ คําจะ
ใชตัวพิมพใหญขึ้นตนคําทุกคําที่ตามมา
getAge , setName
Variable Name ตัวอักษรตัวเล็กหมด แตถาประกอบดวยคําหลายๆ คําจะ
ใชตัวพิมพใหญขึ้นตนคําทุกคําที่ตามมา
brainSize, age, colorCar
Constant Name ทุกตัวอักษรใชตัวใหญหมด MAX , MIN_AGE, PI

38
คําสงวน(Keywords)
คํา(หรือลําดับของตัวอักษร) ที่ถูกกําหนดความหมายไวแลว ในบางภาษามีขอกําหนดวาหามนํา
ketwords ไปใชในความหมายอื่นถือวา keywords ของภาษานั้นถูกสงวนไว หรือเรียกคําเหลานั้นวาเปน
Reserved words ในภาษาจาวากําหนดคําตอไปนี้เปนคําสงวน
abstract boolean break byte case catch
char class const continue default do
double else extends false final finally
float for goto if implements import
instanceof int interface long native new
null package private protected public return
short static super switch synchronized this
throw throws transient true try void
volatile while
จาก keywords เหลานี้สามารถแบงเปนหมวดหมูตามหลักการใชงานในภาษาจาวาดังตอไปนี้
• Access Modifier (private, public, transient)
• Class, Method, and Variable Modifiers (class, interface, extends, implements, static, final,
abstract, new, synchronized, strictfp, native, transient, volatile)
• Flow Control(if, else, switch, case, default, for, do, while, break, continue, instanceof,
return)
• Error Handling(try, catch, finally, throws, throw, assert)
• Package Control(import, package)
• Primitive Data Types(boolean, char, byte, short, int, long, float, double)
• Variable Keywords(super, this)
• Void Return Type Keyword(void)
• Unused Reserved Words(const, goto)
• Literal Words (true, false และ null)

39
public class InterLiteral {
public static void main(String args[]) {
System.out.println(15);
System.out.println(0xAF);
}
}
คาคงที่สําหรับตัวแปร(Literals)
คือคําที่ใชแสดงคาคงที่(Constants)ในโปรแกรมจะไมมีการเปลี่ยนคา ตางกับ identifier ตรงที่
identifier แทนคา ในขณะที่ literals คือคา(value) นั่นเอง เชน age = 30 ตัวเลข 30 คือ literal ในขณะ
ที่เราเรียก age วาเปน identifier เปนตน ในภาษาจาวา literals ประกอบดวย integer literal, floating-
point literal , boolean literal , character literal และ String literal
Integer literals หรือคาคงที่จํานวนเต็ม (Integer Constants) ไดแก คาคงที่ที่เปนจํานวนเต็มไมมี
จุดทศนิยม เปนไดทั้งคาบวกและลบ ซึ่งสามารถเก็บดวยรูปแบบของชนิดขอมูล(Data type) short, int,
หรือ long ได จํานวนเต็มเหลานี้สามารถเขียนไดสามแบบขึ้นกับฐานเลข ดังนี้
• คาคงที่ในระบบเลขฐานแปด (Octal Constants) ไดแก คาคงที่ที่เปนคาในระบบเลขฐานแปด
สามารถเขียนไดโดย ใชเลขศูนย นําหนาเลขฐานแปดนั้น เชน
025 มีคาเทากับ (25)8
• คาคงที่ในระบบเลขฐานสิบหก (Hexadecimal Constants)ไดแก คาคงที่ที่มีคาเปนเลขฐานสิบหก
สามารถเขียนไดโดยใชเลขศูนยและตัวอักษร x นําหนาคานั้นๆ เชน
0x19 มีคาเทากับ (19)16
0x344A มีคาเทากับ (344A)16
0xFF1 มีคาเทากับ (FF1)16
ตัวอยาง แสดงการใชคาคงที่จํานวนเต็มในโปรแกรม
คาคงที่จํานวนเต็มในตัวอยางที่ผานมาจะถูกเก็บคาในหนวยความจํา 32 bits (–214783648 ถึง
+2147483647) โดยปกติ(default) ซึ่งหากเกินขอบเขตที่กําหนดจะทําใหเกิดความผิดพลาดได ดังนั้น
หากตองการกําหนดคาที่ใชพื้นที่มากกวา 32 bits แตไมเกิน 64 bits ใหใสตัวอักษร “L” ตอทายตัวเลขนั้น
เพื่อบอกแกคอมไพลเลอรใหทราบ สําหรับ JDK version 1.6.0 นี้หากกําหนดเกินขอบเขตของชนิดตัว
แปรจะทําใหเกิด compile error ขึ้น ดังตัวอยางตอไปนี้
OUTPUT
15
53
175

40
public class InterLiteral64 {
System.out.println(2147483649L);
}
}
public class InterLiteral64 {
System.out.println(2147483649L);
}
}
=======================
D:javaInterLiteral64.java:13: integer number too large: 2147483649
^
1 error
ตัวอยาง แสดงการใชคาคงที่จํานวนเต็มในโปรแกรมมีขนาดเกิน 64 bits
ตัวอยาง แสดงการใชคาคงที่จํานวนเต็มในโปรแกรมมีขนาดเกิน 64 bits ที่เกิดขอผิดพลาด
Floating-point literal หรือ คาคงที่ที่มีจุดทศนิยมธรรมดา เชน 15.25,-20.17, 0.0004
และคาคงที่ที่อยูในรูปแบบทางวิทยาศาสตร (Scientific Notation) เชน 1E+04, 1.5E-06 เปนตน floating-
point literal ทําการเก็บขอมูลทศนิยมดวยชนิดขอมู double ขนาด 64 bits (default) เก็บทศนิยมได 16
ตําแหนง สามารถแสดงใหทราบวาเปนตัวเลขชนิด double ไดโดยระบุตัวอักษร “D” หรือ “d” ทายตัวเลข
หรือ เก็บตัวเลขที่เปนทศนิยมชนิด float ขนาด 32 bits เก็บตัวอักษรได 7 ตําแหนง ซึ่งหากตองการ
กําหนดใหเปนชนิด float ใหระบุตัวอักษร “F” หรือ “f” ทายตัวเลข แตหากไมกําหนดตัวอักษรใดๆ
ตอทายตัวเลขทศนิยม จะถูกกําหนดใหตัวเลขดังกลาวมีชนิดเปน double ดังตอไปนี้
OUTPUT
2147483649

41
ตัวอยาง โปรแกรมแสดงคาตัวเลขทศนิยม
Boolean literal แสดงคาคงที่ความจริง(Truth values) มีคาของตัวแปรเปน จริง(true) หรือเท็จ
(false) มีชนิดของขอมูลเปน Boolean ซึ่งตางกับภาษา C/C++ ซึ่งใชคา 0 แทน false และ 1 แทน true แต
ในภาษาจาวาใช keywords true และ false ดังตัวอยางโปรแกรมตอไปนี้
ตัวอยาง โปรแกรมแสดงคาคงที่ความจริง
Character literal แทนคาคงที่ตัวอักษร ตัวอักษรจะกําหนดคาโดยใสเครื่องหมาย single quotes
เชน ‘A’ หรือ ‘9’ เปนตน ในภาษาจาวาจะมีขอบเขต 16 บิต หรือเรียกวา 16-bit Unicode ซึ่งในการเก็บ
ขอมูลจริงๆ แลวจะเก็บคลายกับ number type แตจะมีดานบวกเทานั้น(Unsigned) ถาคิดเปนตัวเลขกับอยู
ในชวง 0-(216
-1) หรือ 0-65535 สําหรับตัวอักษรที่ใชควบคุมการพิมพจะใชสัญลักษณ ‘’ (escape
sequences) แลวตามดวยตัวอักษรหรือตัวเลข เหมือนในภาษา C/C++ ดังตอไปนี้
รหัสควบคุม ความหมาย
n ขึ้นบรรทัดใหม (new line)
f ขึ้นหนาใหม (form feed)
public class FloatLiteral {
System.out.println(0.12345);
System.out.println(0.12345E-2);
System.out.println(0.12345E3);
System.out.println(1.2345678901234f);
System.out.println(1.2345678901234567890);
System.out.println(1.2345678901234d);
}
}
OUTPUT
0.12345
0.0012345
123.45
1.2345679
1.2345678901234567
1.2345678901234
public class BooleanLiteral {
System.out.println(false);
System.out.println(true);
System.out.println(1 < 5);
System.out.println(10 == 5 );
}
}
OUTPUT
false
true
true
false

42
r ไปตนบรรทัด (carriage return)
t ไปแถวแทบถัดไป (horizontal tab)
v ไปสดมภถัดสสไป (vertical tab)
a สัญญาณเสียง (bell)
b ลบอักขระตําแหนงกอนหนานี้ 1 ตําแหนง (backspace)
” ตัวอักขระฟนหนู ( " )
’ ตัวอักขระฝนทอง ( ' )
? ตัวอักขระคําถาม ( ? )
ตัวอักขระแบคสเปส ( )
0 อักขระนัล (null character)
ddd แสดงตัวเลขฐาน 8
uHHHH แสดงตัวอักษรแบบ Unicode
กรณีที่ใชเลขฐานแปดตองขึ้นตนดวย ‘’ และตามดวย ddd ซึ่ง d หมายถึง ตัวเลขฐานแปด
ซึ่งอยูในชวง 0-7 ที่เปนรหัสแอสกี้ของตัวอักษรตัวนั้น กําหนดใหเลขฐานแปดสามหลัก หากตองการ
กําหนดเปนเลขฐานสิบหกใหขึ้นตนดว ‘u’ แลวตามดวย HHHH ซึ่ง H หมายถึง ตัวเลขใดๆของ
เลขฐานสิบหก หรือเปนตัวอักษร a-b หรือ A-F ซึ่ง a-b หรือ A-F แทนเลข 10-15 และ a หรือ A มีคา
เทากัน คือเทากับคา 10 ในระบบเลขฐานสิบ เชน หากคา ASCII ฐานสิบ = 65 คือตัวอักษร ‘A’ หาก
กําหนดใหแสดงดวยเลขฐานแปด คือ ‘101’ และหากตองการแสดงตัวอักษรแบบ Unicode ใหกําหนด
เปน ‘u0041’ ผลลัพธที่ไดแสดงดังตัวอยางตอไปนี้
ตัวอยาง โปรแกรมแสดงคาคงที่ตัวอักษร
หมายเหตุ สามารถหาขอมูลเพิ่มเติมเรื่อง ตัวอักษร Unicode ไดที่ www.unicode.org
public class Octal {
System.out.println("101");
System.out.println("u0041");
System.out.println("NametttIDn"Joe Smith"ttu0061");
}
}
OUTPUT
A
A
Name ID
"Joe Smith" a

43
String literal คาคงที่ที่ไมใชในการคํานวณ (String Constants) หมายถึง คาคงที่ที่ไมสามารถ
นําไปคํานวณไดซึ่งอาจประกอบดวย ตัวเลข ตัวอักษร หรืออักขระพิเศษอื่นที่ตองเขียนภายใตอักขระ
คําพูด (quatation mark) “ ” ตัวอักขระภายในอักขระคําพูดจะถูกบันทึกในหนวยความจําตอเนื่องกันไป
มีลักษณะเปนชุดของตัวอักขระ (array of characters) หนึ่งตัวอักษรของภาษาจาวา ใชหนวยความจํา 2
bytes ตัวอยางเชนคาคงที่แบบชุดตัวอักขระ "Hello" ,"This is a ”String” constant." , "1/2" เปนตน
ประโยคคําสั่ง(Statements)
ประโยคคําสั่ง(statements)คือคําสั่งหนึ่งคําสั่ง หรือการคอมไพลโคดหนึ่งบรรทัด แตไมใชหนึ่ง
บรรทัดคือ 1 ประโยคคําสั่ง เนื่องจากบางครั้ง 1 ประโยคคําสั่งอาจมีหลายบรรทัด เชน ใน if –statement
ในโคดโปรแกรมอาจมีหลายบรรทัดได ภาษาจาวาไมไดจํากัดวาในหนึ่ง statement จะตองเขียนเพียง 1
บรรทัด อาจเขียนหลายบรรทัดได แตตองจบ statement ดวยเครื่องหมาย ; หรือบางครั้งจบดวย
เครื่องหมายปกกาปด } ตัวอยางตอนี้แสดงใหเห็นวาทั้ง 2 statement นั้นมีความหมายเหมือนกัน
x = (y + z) / q; //statement 1
x = (y + z ) / q; //statement 2
ใน statement2 นั้นแยกกันดวย horizontal และ vertical tabs หรือ formfeed และ new-line
แตถึงแมวาจาวาคอมไพลเลอรจะมองทั้ง 2 statements เหมือนกัน แตในทางปฏิบัติแลววิธีการเขียน
เหมือน statement2 นั้นโปรแกรมเมอรไมนิยมเขียน เนื่องจากการเขียนโปรแกรมลักษณะนี้อานไดยาก
และอาจทําใหผิดไวยกรณภาษาไดงายอีกดวย
คําอธิบายโปรแกรม(Comments)
ในการเขียนโปรแกรมทุกภาษาจําเปนอยางยิ่งที่จะตองมีคําอธิบายโปรแกรมเพื่อเตือนความจํา
เมื่อเรากลับมาอานโปรแกรมหรือทําการแกไขโปรแกรมอีกครั้งหนึ่ง โดยเฉพาะอยางยิ่งโปรแกรมที่มี
ความซับซอน ซึ่งคําอธิบายนี้จะไมไดรับการ compile โดย compiler ดังนั้นผูเขียนโปรแกรมสามารถ
เขียนขอความใดๆ ก็ไดเพื่อประโยชนในการเขียนโปรแกรม ในภาษาจาวามีรูปแบบการเขียนคําอธิบาย
เหมือนกับภาษา C ประกอบดวย 2 รูปแบบ คือ
1. คําอธิบายหนึ่งบรรทัด ใชเครื่องหมาย // นําหนาประโยค
เชน // This is a comment
2. คําอธิบายหนึ่งบรรทัดหรือมากกวา ใชเครื่องหมาย /* เพื่อแสดงการเริ่มตนคําอธิบาย และจบ
ดวยเครื่องหมาย */ เพื่อแสดงการสิ้นสุดคําอธิบาย
เชน /* This is a comment */

44
ชนิดขอมูล(Data types)
ชนิดขอมูลคือ เซ็ทของคาที่เปนไปไดของชนิดขอมูล ซึ่งจะเปนตัวกําหนดวิธีการดําเนินการ
ใหกับแตละนิพจน ในภาษาจาวา มี 2 แบบ
• ชนิดขอมูลพื้นฐาน (Primitive Data Types) มีทั้งหมด 8 ตัว ไดแก Boolean, char , byte , short ,
int , long, float, double ซึ่งขอมูลเหลานี้จะเก็บอยูใน Execution Stack
• ชนิดขอมูลอางอิง(Reference Data Types) เปน classes ทั้งหลายทั้งที่เราสรางขึ้นมาเองและที่เปน
ของ API ของ JAVA ซึ่ง class ทุกตัวสืบทอดมาจาก object class ทําการเก็บขอมูลไว 2 สวน
o Execution Stack เก็บคาอางอิงที่ชี้ไปยัง Heap Memory
o Heap Memory เก็บขอมูลที่เรียกวา Object ซึ่งสรางขึ้นมาจาก Classes
รูปแสดงการเก็บขอมูลชนิดพื้นฐานและชนิดขอมูลอางอิง
การประกาศตัวแปร(Variable declaration)
หลังจากทราบหลักการตั้งชื่อของตัวแปร(variable) ในหัวขอ identifier วามีกฎการตั้งชื่ออยางไร
บางแลว และเรียนรูถึงชนิดของขอมูลหรือ primitive types ในภาษาจาวามาแลวตอไปเราจะเรียนถึง
วิธีการประกาศตัวแปร ซึ่งในภาษาจาวาจําเปนตองประกาศตัวแปรกอนการใชงาน จึงจะสามารถใชงาน
ตัวแปรเหลานั้นได
ประโยคประกาศตัวแปร
<data_type> <identifier> [,<identifier>] . . . ];
Data_type คือ ชนิดของตัวแปรซึ่งจะอธิบายตอไป
Identifier คือ ชื่อของตัวแปรตองเปนไปตามหลักการตั้งชื่อของตัวแปรดังหัวขอกอนหนา

45
ชนิดของตัวแปรพื้นฐาน(Primitive Data type)
ในภาษาจาวาแบงขอมูลชนิดพื้นฐานเปน 4 กลุม ไดแก
1. Logical ไดแก boolean
2. Textual ไดแก char
3. Integer ไดแก short , byte , int และ long
4. Floating point ไดแก float และ double
ขอมูลชนิดตัวเลข จะเก็บทั้งคาบวกและลบ(signed)โดยใชบิตซายสุดเปนตัวบอก ถาบิตแรกเปน
0 แสดงวาเปนคาบวก หากบิตแรกเปน 1 แสดงวาเปนคาลบ
รูปแสดงการเก็บขอมูลในรูปแบบ bite ของขอมูลชนิด byte และ short
ชนิดตัวแปรแตละชนิดจะใชจํานวนบิตในหนวยความจําที่แตกตางกันดังแสดงในตารางที่ 2.1
ชนิด (Type) จํานวน
บิต (bits)
Default Contains ชวง(Range)
boolean 1 False true or false ไมกําหนด
byte 8 0 signed integer -128(-27
) ถึง 127(-27
-1)
char 8 u0000 Unicode character u0000 to uFFFF
short 16 0 signed integer -32768(-215
)ถึง 32767(215
-1)
int 32 0 signed integer -2147483648(-231
) ถึง 2147483647(231
-1)
long 64 0 Singed integer -9223372036854775808 (-263
)ถึง
9223372036854775807(263
-1)
float 32 0.0 IEEE754 flt. pt. +/-3.40282347E+38 ถึง
+/-1.40239846E-45
double 64 0.0 IEEE754 flt. pt. +/-1.79769313486231570E+308 ถึง
+/-4.94065645841246544E-324
ตารางที่ 2.1 แสดงรายละเอียดของ ชนิดขอมูล จํานวนบิต คาพื้นฐาน และชวงของคา
byte 0 0 0 1 0 0 1 1
short 1 1 1 1 1 1 0 1 0 0 0 0 0 0 1 1
Sign bit value bits

46
เชน int x;
char myChar ;
float a , b, c ;
int numberOfStudents;
boolean isEnough;
double monthInterest, yearInterest;
short count;
short int i;// ในภาษาจาวาไมมี ชนิดขอมูล short int
หมายเหตุ หากประกาศตัวแปรแลวไมกําหนดคาเริ่มตนใหกับตัวแปรในเมธอด กอนนําไปใชโปรแกรม
จะเกิดขอผิดพลาดขึ้น ดังตัวอยางตอไปนี้
ตัวอยาง โปรแกรม ประกาศตัวแปร และไมไดกําหนดคาใหกับตัวแปร แตไมไดนําไปใชงาน
ตัวอยาง โปรแกรม ประกาศตัวแปร แตไมไดกําหนดคาใหกับตัวแปรกอนนําไปใชงาน
public class BooleanNotInitial {
boolean verify ;
System.out.println(verify);
}
}
---------- compile java ----------
BooleanNotInitial.java:4: variable verify might not have been initialized System.out.println(verify);
^
1 error
public class BooleanNotInitial {
boolean verify ;
char myChr1 ;
int numberOfPerson;
}
}
---------- compile java ----------
Output completed (0 sec consumed) - Normal Termination

47
ตัวอยางโปรแกรม ประกาศตัวแปร กําหนดคาใหกับตัวแปร กลุม logical
ตัวอยาง โปรแกรม ประกาศตัวแปร กําหนดคาใหกับตัวแปร กลุม Textual
public class BooleanInitial {
boolean answer = false;
boolean validate = ture ;
//boolean f=0; error
System.out.println(answer);
System.out.println(validate );
}
}
OUTPUT
false
true
public class TextualInitial {
char myChr1 = 'A';
char myChr2 = 'u0042';
char myChr3 = 't';
char myChr4 = 'u00A9';
char myChr5 = 0x59;
char myChr6 = 97;
//char myChr7 = “A”; error
System.out.println(myChr1);
System.out.println("A"+ myChr3 + "A");
}
}
OUTPUT
A
B
A A
©
Y
a

48
ตัวอยาง โปรแกรม ประกาศตัวแปร กําหนดคาใหกับตัวแปร กลุม Integer (เลขจํานวนเต็ม)
หมายเหตุ สังเกตผลลัพธที่ไดจากการเรียกใชงาน เมธอด println ตอไปนี้
1. System.out.println( a + " " + count + " " + num + " " + myLong); => 1 5 10 15
2. System.out.println( a + count + num + myLong); => 31
3. System.out.println( a + count + " " + num + myLong); = > 6 1015
4. System.out.println( “Value = ” + (a + count)); = > Value = 6
บรรทัดที่หนึ่ง แสดงคาของตัวแปรโดยทําการเชื่อมตอกันดวยตัวดําเนินการ + โดยมีคาของ
ขอความชองวาง (“ ”) เชื่อมตอกันกับตัวแปร
บรรทัดที่สอง หากไมมีขอความหรือตัวแปรชนิดขอความอยูระหวางตัวแปรชนิดตัวเลขผลลัพธ
ที่ไดจะแสดงคาการบวกของตัวแปรทั้งหมดรวมกัน
บรรทัดที่สาม เปนการรวมคาของตัวแปร a + count แลวเชื่อมตอดวยขอความชองวาง และ
คอมไพลเลอรจะมองคาที่อยูในตัวแปรชนิดตัวเลขเปน ชนิดขอความ ทําใหไดผลลัพธดังแสดง
บรรทัดที่สี่ แสดงขอความ Value ออกบนหนาจอ แลวแสดงผลบวกของตัวแปร a + count
class IntegerInitial {
public static void main(String[] args) {
byte a = 1;
int count = 5;
short num =10;
/* ขอมูล 1, 10 เปนชนิดตัวเลข int แตสามารถกําหนดใหกับตัวแปรที่เปน byte และ
short ได แตที่ควรทําคือประกาศในรูปแบบ byte a =(byte)1 ; short num = (short)10; ซึ่งจะ
ไดศึกษาในหัวขอถัดไป */
long myLong = 15L ;
/*การกําหนดคาใหตัวแปรชนิด long ตองใสตัวอักษร L หรือ l หลังตัวเลขจํานวนเต็มที่
กําหนด ไมเชนนั้นคาที่กําหนดใหตัวแปรจะถูกมองวาเปนชนิด int*/
System.out.println( a + " " + count + " " + num + " " + myLong);
System.out.println( a + count + num + myLong);
System.out.println( a + count + " " + num + myLong);
}
}
OUTPUT
1 5 10 15
31
6 1015

49
ตัวอยางโปรแกรม ประกาศตัวแปร กําหนดคาใหกับตัวแปร กลุม Floating Point
การเปลี่ยนชนิดของตัวแปร
คอมไพเลอรของภาษาจาวาจะทําหนาที่ตรวจสอบความถูกตองในการทําการกําหนดคา
(assignment) นั่นคือ คาที่นํามากําหนดให กับคาที่ถูกกําหนดคาจะตองมีชนิดขอมูลพื้นฐาน(primitive
data type)เหมือนกัน แตหากภาษามีขอจํากัดตรงนี้มากเกินไปจะทําใหไมสะดวกในการเขียนโปรแกรม
เชน ตองกําหนดคา short ใหกับตัวแปรชนิด short เทานั้น ไมสามารถกําหนดใหกับตัวแปรชนิด int
หรือ long ได ดังนั้นเพื่อความสะดวกในการเขียนโปรแกรมภาษาจาวาจึงสรางกลไกไว 2 รูปแบบคือ
1. การเปลี่ยนชนิดของตัวแปรโดยจาวาคอมไพลเลอร(Automatic Type Conversions)
การกําหนดคาระหวางตัวแปรที่มีชนิดขอมูลตางกันเชน จะทําการเปลี่ยนคาของตัวแปรจากชนิด
ที่มีหนวยความจํานอยกวาไปสูตัวแปรที่มีหนวยความจํามากกวาอยางอัตโนมัติ เชน x เปนตัวแปรชนิด
double แต y เปนตัวแปรชนิด integer เมื่อกําหนดให x = y แลวคอมไพลจะทําการเปลี่ยนคาของตัว
แปร y ใหเปนชนิด double แลวใหคาแกตัวแปร x เรียกการเปลี่ยนแปลงลักษณะนี้วา widening
conversion หรือ implicit type conversion จะทําการเปลี่ยนจาก
byte -> short -> int -> long -> float -> double
char -> int -> long -> float -> double
class FloatInitial{
public static void main(String[] args) {
float f1 = 2.48f;
float f2 = 1.234E-2f;
float f3 = 0.12345E3f;
//float f4 = 5.67; error
//float f5 = 1.2E5; error
double d1 = 3.59;
double d2 = 666e13;
//กําหนดในรูปแบบ exponential โดยใชตัว e หรือ Eเพื่อบอกเลข 10 ยกกําลัง
double d3 = 4.56d;
//สามารถใสตัวอักษร d หรือ D เพื่อแสดงใหทราบวาคาคงที่เปนชนิด double
System.out.println(f1);
System.out.println(d1);
System.out.println(d2);
}
}
OUTPUT
2.48
0.01234
123.45
3.59
6.66E15

50
นั่นคือ สามารถใหคาของตัวแปรชนิด int แกตัวแปรชนิด long , float หรือ double ได แตไม
สามารถใหคาแกตัวแปรชนิด byte หรือ short ได และนอกจาก หรือ ตัวแปรชนิด char สามารถใหคาแก
ตัวแปรชนิด int , long, float หรือ double ได
เชน short s1 = 5; int i1 = 10; char ch1 = 'A';
i1 = s1;
i1 = ch1;
s1 = ch1;// error
s1 = i1; // error
2. การเปลี่ยนชนิดของตัวแปรโดยกําหนดชนิดขอมูลของตัวแปรหรือคาคงที่(Casting conversion)
หากเราตองการเปลี่ยนชนิดของตัวแปรจากชนิดที่มีหนวยความจํามากกวาไปสูตัวแปรที่มี
หนวยความจํานอยกวาอาจมีขอมูลบางสวนหายไป ซึ่งจะทําใหเกิดขอผิดพลาด(Compile error) วิธีการ
เปลี่ยนแปลงลักษณะนี้เราเรียกวา narrowing conversion หรือ explicit type conversion แตเราสามารถ
กําหนดการเปลี่ยนชนิดของตัวแปรหรือคาคงที่ไดเองตามไวยกรณดังตอไปนี้
(<type>) <term>;
วิธีการ casting นี้ทําการเปลี่ยนคาของชนิดขอมูลหนึ่งไปเปนคาของชนิดขอมูลอื่นที่ตองการได
ยกเวนขอมูลชนิด boolean
เชน double d = 257.234;
int a = (int)d; // a = 257
ขอบเขตของตัวแปร(Code blocks)
ขอบเขตของตัวแปร(code blocks) เปนหนวยของ กลุม statements ภาษาจาวานิยมโดยใช
เครื่องหมายปกการ ({ และ }) เพื่อแสดงขอบเขตการทํางานของแตละตัวแปร
เชน for (int I = 0 ; I < 5 ; i++){
System.out.println(i);
}
System.out.println(i); // error

51
นิพจน(Statement)
นิพจนหมายถึง การนําตัวแปร คาคงที่มากระทําตอกันโดยใชตัวดําเนินการคํานวณ ตัว
ดําเนินการสัมพันธ หรือตัวดําเนินการตรรกะ นิพจนภาษาจาวามี 3 ชนิด คือ นิพจนคํานวณ
(Arithmetic Expressions) นิพจนเชิงสัมพันธ (Relational Expressions) และนิพจนตรรกะ (Logical
Expressions)
1 นิพจนคํานวณ
นิพจนคํานวณเปนนิพจนที่ใชตัวดําเนินการดําเนินการคณิตศาสตรเปนตัวกระทํา ตัวดําเนินการ
คณิตศาสตรแสดงดัง ในตารางที่ 2.2 หัวขอตัวดําเนินการทางคณิตศาสตร(arithmetic operator)
เชน
5a + 10b เขียนเปนนิพจนในภาษาจาวาเปน (5 * a) + (10 * b)
a / b - c เขียนเปนนิพจนในภาษาจาวาเปน (a / b) - c
x2 + y2 เขียนเปนนิพจนในภาษาจาวาเปน x * x + y * y
2. นิพจนเชิงสัมพันธ
เปนนิพจนที่ใชตัวดําเนินการเชิงสัมพันธดังแสดงในตาราง 2.6 ผลลัพธจากการประเมินผลนิพจน
นี้จะเปนจริงหรือเท็จ ถาผลลัพธจากการประเมินใหคาเปน 0 จะถือวาเปนเท็จ และถาใหคาเปนเลขอื่นจะ
ถือวาเปนจริง ดังตัวอยางตอไปนี้
ถากําหนดให a = 10 , b = 5 , c = 20
นิพจน a = = b ผลลัพธที่ไดเปนเท็จ (0)
นิพจน a > b ผลลัพธที่ไดเปนจริง (ไมใชเลขศูนย)
นิพจน a*b >=c ผลลัพธที่ไดเปนจริง (ไมใชเลขศูนย)
3. นิพจนตรรกะ
เปนนิพจนที่ใชตัวดําเนินการตรรกะ แสดงดังตารางที่ 2.7 ผลลัพธจากการประเมินผลนิพจนจะ
เปนจริงหรือเท็จ ถาผลลัพธจากการประเมินใหคาเปน 0 จะถือวาเปนเท็จ และถาใหคาเปนเลขอื่นจะถือ
วาเปนจริง ดังตัวอยางตอไปนี้
ถากําหนดให a = 10 , b = 5 , c = 20
นิพจน a + 1 < c && b == 2 ผลลัพธที่ไดเปนจริง (ไมใชเลขศูนย)
นิพจน a / 5 > c || b > 10 ผลลัพธที่ไดเปนเท็จ (0)

52
// Assignment.java
class Assignment{
char myChar = 'A';
System.out.println(myChar);
boolean isEnough = false;
System.out.println(isEnough);
float a = 1.0f , b = 1.5f , c =2.0f;
System.out.println(a+b+c);
double d = 0.0, e = 1.0;
int x,y,z;
x = 5 ;
y = 6;
z = x * y;
x =y = z = 1 ;
System.out.println(x + "," + y + "," + z);
x = (y = (z= z+1)+1)+1;
x = (y=1) + (z = 1);
}
}
ตัวดําเนินการ(Operators)
ในภาษาจาวามีการใชตัวดําเนินการที่กระทําระหวางตัวแปร หรือคาคงที่ ซึ่งแบงออกได 5 ชนิด
ไดแก ตัวดําเนินการในการกําหนดคา(assignment operator) ตัวดําเนินการทางคณิตศาสตร(arithmetic
operator) ตัวดําเนินการระดับบิต(bitwise operator) ตัวดําเนินการเชิงสัมพันธ(relational operator) และ
ตัวดําเนินการทางตรรก(logical operator)
1. ตัวดําเนินการในการกําหนดคา(assignment operator)
เปนการกําหนดคาของนิพจนที่อยูดานขวาใหกับตัวแปรที่อยูดานซายโดยใชตัวดําเนินการ = เชน
ตัวอยาง โปรแกรม ตัวดําเนินการในการกําหนดคา
OUTPUT
A
false
4.5
1,1,1
4,3,2
2,1,1

53
2. ตัวดําเนินการทางคณิตศาสตร(arithmetic operator)
ตัวดําเนินการ ความหมาย ตัวอยาง ลําดับการกระทํา
+ ยูนารี (Unary) +x 1
- ยูนารี (Unary) -x 1
+ บวก x+y 3
- ลบ x-y 3
* คูณ x*y 2
/ หาร x/y 2
% หารเก็บเศษ x%y 2
ตารางที่ 2.2 แสดง ตัวดําเนินการคํานวณทางคณิตศาสตร
ตัวดําเนินการยูนารี + และ - มีลําดับการกระทําเทากัน ซึ่งมีลําดับการกระทําสูงกวาตัว
ดําเนินการ * / และ % สวนตัวดําเนินการ * / และ % มีลําดับการกระทําสูงกวา ตัวดําเนินการ +
และ - ถานิพจนใดๆ ที่ประกอบดวย ตัวดําเนินการที่มีลําดับการกระทําเทากัน ก็จะยึดหลัก ตัวดําเนินการ
ที่อยูซายมือ มีความสําคัญมากกวา และ ถานิพจนมีวงเล็บอยูดวยเครื่องจะทําสิ่งที่อยูในวงเล็บกอน
หากมีวงเล็บหลายชั้นซอนกันจะทําวงเล็บในสุดกอน
สําหรับคํานวณทางคณิตศาสตร แบงเปน 4 ประเภท ไดแก
- Integer Arithmetic Operator ตัวดําเนินการกลุมนี้จะกระทํากับตัวแปรหรือคาคงที่(Operand) ที่มี
ชนิดเปนจํานวนเต็ม และจะไดผลลัพธเปนจํานวนเต็ม ไดแก ตัวดําเนินการบวก(+) ลบ(-) คูณ( *)
หาร( / ) modulus( %)
ตัวอยางโปรแกรมการคํานวณทางคณิตศาสตรดวยเลขจํานวนเต็ม
class IntArtOp{
System.out.println(4+5);
System.out.println(3-9);
System.out.println(3*4);
System.out.println(2/5);
System.out.println(30%7);
}
}
Output
9
-6
12
0
2

54
- Floating-point Arithmetic Operator ตัวดําเนินการกลุมนี้จะกระทํากับตัวแปรหรือคาคงที่
(Operand) ที่มีชนิดเปนทศนิยม และจะไดผลลัพธเปนทศนิยม ไดแก ตัวดําเนินการบวก(+) ลบ(-)
คูณ( *) หาร( / ) modulus( %) สังเกต modulus ในภาษาซีจะใชไดเฉพาะเลขจํานวนเต็มเทานั้น แต
ในภาษาจาวาสามารถใชคํานวณกับเลขทศนิยมได
ตัวอยางโปรแกรมตัวดําเนินการทางคณิตศาสตรดวยเลขทศนิยม
- Arithmetic Assignment Operators
คือตัวดําเนินการที่ทําการคํานวณพรอมกําหนดคาใหกับตัวแปรที่อยูดานซายมือ ไดแกตัว
ดําเนินการตอไปนี้
ตัวดําเนินการ ความหมาย ตัวอยาง ความหมาย
+= บวกและกําหนดคา x+= 4 x=x+ 4
-= ลบและกําหนดคา x-=5 x=x-5
*= คูณและกําหนดคา x*=6 x=x*6
/= หารและกําหนดคา x/=7 x=x/7
%= เก็บเศษจากการหารและกําหนดคา x%=8 x=x%8
ตารางที่ 2.3 แสดง ตัวดําเนินการกําหนดคาคํานวณ
- Increment and Decrement Operators :
ในภาษาจาวาตัวดําเนินการสําหรับการเพิ่มคาและลดคาคือ ++ และ -- การเพิ่มคาใหกับตัวแปร
อีก 1 จะใชตัวดําเนินการ ++ และ ลดคาใหกับตัวแปรลง 1 ดวยตัวดําเนินการ -- ซึ่งสามารถใชตัว
ดําเนินการ ++ หรือ -- ตามหลัง หรือ นําหนาตัวแปรก็ได ถาตามหลังตัวแปร เชน n++ จะหมายถึงใหมี
class FloatArtOp{
public static void main(String args[]){
System.out.println(4.0+5.0);
System.out.println(3.0-9.0);
System.out.println(3.0*4.0);
System.out.println(2.0/5.0);
System.out.println(30.0%7.0);
}
}
Output
9.0
-6.0
12.0
0.4
2.0

55
การเพิ่มคาอีก 1 ใหกับตัวแปร n หลังจากใชคาตัวแปรแลว และถานําหนาตัวแปร หมายถึงใหมีการเพิ่ม
คาตัวแปรอีก 1 กอนที่ คาตัวแปรจะถูกใช เชน ถา n มีคา 5 แลว
กําหนดให n = 5 ;
x = n++ ; // x จะมีคา เทากับ 5 แต n = 6
กําหนดให n = 5;
x = ++n ; // x จะมีคาเทากับ 6 และ n = 6
และทั้งสองกรณี n จะมีคาเปน 6 ตัวดําเนินการเพิ่มคาและลดคาใชกับตัวแปรเทานั้น ไมสามารถ
ใชกับนิพจนได เชน (i+j)++
การเพิ่มคาหรือลดคาโดยใชตัวดําเนินการ ++ หรือ -- ตามหลังหรือนําหนาตัวแปร จะใหผล
เหมือนกันคือคาของตัวแปรเทากัน ดังเชน
if (ch == ‘A’)
x++ ;
หรือ if (ch == ‘A’)
++x;
นั่นคือ x = x + 1 => x++ หรือ ++x
x = x - 1 => x-- หรือ --x
ตัวอยาง โปรแกรมตัวดําเนินการเพิ่มคา หรือลดคา
class IncDecOperator{
int x =1 , y=1;
int a , b ;
x++ ; ++y;
System.out.println(x + "," + y);
x-- ; --y ;
System.out.println(x + "," + y);
x =1; y =1;
a = x++ ;
b= ++y;
System.out.println(a + "," + b);
a= x-- ;
b= --y;
System.out.println(a + "," + b);
}
}
OUTPUT
2,2
1,1
1,2
2,1

56
3. ตัวดําเนินการระดับบิต(bitwise operator)
ตัวดําเนินการบิตไวสจะกระทําระหวางบิตตอบิตของ ขอมูลชนิด char short int และ long
ที่มีเครื่องหมายหรือไมมีเครื่องหมาย(Signed or unsigned) ผลลัพธที่ไดมีคาเปน true หรือ false เทานั้น
ตัวดําเนินการ ความหมาย ตัวอยางนิพจน
& บิตไวสแอน (and) ANS = A & B
| บิตไวสอินคลูซีฟออ (inclusive or) ANS = A | B
^ บิตไวสเอกซคลูซีฟออ (exclusive or) ANS = A ^ B
~ คอมพลีเมนต(complement) ANS = ~A
<< เลฟทชีฟท(left shift) ANS = A << 2
>> ไรทชีฟท (right shift) ANS = A >> 4
>>> unsigned right shift (zero-filled right shift) ANS = A >>>3
&= bitwise AND assignment ANS &= A
|= bitwise OR assignment ANS |= A
^= bitswise EXCLUSIVE OR assignment ANS ^= A
>>= shift right assignment ANS >>= A
<<= shift left assignment ANS <<= A
>>>= shift right zero fill assignment ANS >>>= A
ตารางที่ 2.4 แสดงตัวดําเนินการบิตไวส โดยที่ A B เปนตัวแปรชนิด byte
a b a&b a|b ~ a^b
0 0 0 0 1 0
1 0 0 1 0 1
0 1 0 1 1 1
1 1 1 1 0 0
ตารางที่ 2.5 แสดงตารางคาความเปนจริงของตัวดําเนินการบิตไวส
ตัวอยาง 1010 | 1001 = 1011
1 0 1 0
|
1 0 0 1
1 0 1 1

57
ตัวอยาง 1010 ^ 0101 = 1111
1 0 1 0
^
0 1 0 1
1 1 1 1
ตัวอยาง การดําเนินการดวย ~ ผลลัพธที่ไดจะทําการกลับคา bit จาก 1 เปน 0 , 0 เปน 1
5: 0000 0000 0000 0000 0000 0000 0000 0101
a = ~5 ; // -6;
-6: 1111 1111 1111 1111 1111 1111 1111 1010
ในคอมพิวเตอร จะเก็บเลขจํานวนเต็มที่เปนลักษณะติดลบในรูปแบบกระบวนการ two’s
complement นั่นคือ ทําการหาคา two’s complement โดย กลับคาbit แลวบวก 1
เชน –a == ~a+1
ตัวอยาง การดําเนินการดวย ตัวดําเนินการ บิตไวส
8 : 0000 0000 0000 0000 0000 0000 0000 1000
a = 8 >> 1; // a = 4;
4 : 0000 0000 0000 0000 0000 0000 0000 0100
a = 4 << 1; // a = 9;
8 : 0000 0000 0000 0000 0000 0000 0000 1000
-1 : 1111 1111 1111 1111 1111 1111 1111 1111
a = -1 >> 1; // a= -1;
a = -1 >>> 1; //a = 2,147,483,646;
0111 1111 1111 1111 1111 1111 1111 1111
หมายเหตุ
การดําเนินการดวยตัวดําเนินการ >>(right shift) นั้น หากเปนเลขจํานวนบวกจะทําการเติม 0 แต
หากเปนตัวเลขที่นํามาดําเนินการเปนลบจะทําการเติม 1 จากบิตที่อยูซายมือ ดังตัวอยาง a = 4 และ a = -1

58
ตัวอยางโปรแกรมตัวดําเนินการบิตไวส
class Binary{
static void print(int x,int n) {
int mask = 1 << n-1;
for (int i= 0 ; i < n ; i++){
if ((x & mask ) == 0)
System.out.print('0');
else
System.out.print("1");
x<<=1;
}
System.out.println();
}
}
class TestBinary{
public static void main (String args[]){
int A =1234,B=9876;
System.out.print("A ="); Binary.print(A,32);
System.out.print("B ="); Binary.print(B,32);
System.out.print("A&B ="); Binary.print(A&B,32);
System.out.print("A|B ="); Binary.print(A|B,32);
System.out.print("A^B ="); Binary.print(A^B,32);
System.out.print("A ="); Binary.print(A,32);
System.out.print("A>>4 ="); Binary.print(A>>4,32);
System.out.print("A<<4 ="); Binary.print(A<<4,32);
System.out.print("~A ="); Binary.print(~A,32);
System.out.print("-A ="); Binary.print(-A,32);
A = 1;
System.out.print("A>>>4 ="); Binary.print(A>>>4,32);
A = -1;
System.out.print("A ="); Binary.print(A, 32);
System.out.print("A>>>4 ="); Binary.print(A>>>=4,32);
System.out.println(A);
}
}

59
ทําการสรางคลาสทั้งสองและบันทึกไวดวยชื่อไฟล TestBinary (ภาษาจาวาในหนึ่งไฟลสามารถ
มีไดหลายคลาส และชื่อไฟลจะตองเปนชื่อเดียวกันกับ class ที่มีสวนขยายเปน public เทานั้น และใน
หนึ่งไฟลสามารถมี class ที่นําหนาดวย public เพียงหนึ่งคลาส)
จาก class Binary เปนคลาสที่ทําการเปลี่ยนเลขฐานสิบใหเปนฐานสอง เรียกใชงานโดย
Binary.print(เลขฐานสิบที่ตองการแปลงเปนเลขฐานสอง, จํานวนหลักฐานสองที่ตองการแสดง)
สวน class TestBinary เปนคลาสที่สรางขึ้นเพื่อทําการแสดงผลที่ไดจากการดําเนินการดวยตัว
ดําเนินการบิตไวส และมีการเรียกใชงานเมธอดที่มาจากคลาส Binary เพื่อแสดงผลลัพธในรูปแบบเลข
ฐาน 2 ดังนี้
4. ตัวดําเนินการเชิงสัมพันธ(relational operator)
ในภาษาจาวาตัวดําเนินการที่ใชสําหรับทดสอบหรือเปรียบเทียบคาสองคาที่มีชนิดขอมูลเปน
byte , char , short , int , long , float และ double ซึ่งคาทั้งสองอาจเปนตัวแปร คาคงที่ หรือนิพจน
สวน operands ที่มีชนิดขอมูลเปน boolean จะทําการเปรียบเทียบเทากับหรือไมเทากับเทานั้น
หรือบางครั้งเรียกวา สมการหรืออสมการตัวดําเนินการดังกลาวไดแก < , > , = = , != , <= , >= ซึ่ง
มีความหมายดัง ตารางที่ 2.6
OUTPUT
A =00000000000000000000010011010010
B =00000000000000000010011010010100
A&B =00000000000000000000010010010000
A|B =00000000000000000010011011010110
A^B =00000000000000000010001001000110
A =00000000000000000000010011010010
A>>4 =00000000000000000000000001001101
A<<4 =00000000000000000100110100100000
~A =11111111111111111111101100101101
-A =11111111111111111111101100101110
A>>4 =00000000000000000000000000000000
A>>>4=00000000000000000000000000000000
A =11111111111111111111111111111111
A>>4 =11111111111111111111111111111111
A>>>4=00001111111111111111111111111111
268435455

60
ตัวดําเนินการ นิพจน ความหมาย
< a < b a นอยกวา b หรือไม
> a > b a มากกวา b หรือไม
== a == b a เทากับ b หรือไม
!= a != b a ไมเทากับ b หรือไม
<= a <= b a นอยกวาหรือเทากับ b หรือไม
>= a >= b a มากกวาหรือเทากับ b หรือไม
ตารางที่ 2.6 แสดง ตัวดําเนินการสัมพันธ
ผลของการเปรียบเทียบนิพจนโดยใชตัวดําเนินการดังกลาวจะใหคาเปนจริง(true)หรือเท็จ(false)
เชน int b = 5;
boolean y = b > 4; // กรณีนี้ y มีคาเทากับ true
เครื่องหมายแบบสมการและอสมการ ไมตองมีการแคส แมวา b และ 4 ไมใชตัวแปรแบบ
Boolean เนื่องจากนิพจน b > 4 เปนนิพจนตรรกศาสตรมีคาเปนจริงหรือเท็จ ซึ่งเขากันไดกับตัวแปร y
ที่เปน Boolean อยูแลว
สังเกตวาเครื่องหมายเทากับใชเครื่องหมายเทากับสองอัน เพราะเครื่องหมายเทากับอันเดียวเปน
สัญลักษณของการกําหนดคาตัวแปร ไมใชเครื่องหมายสมการและอสมการ
5. ตัวดําเนินการทางตรรก(logical operator)
เครื่องหมายตรรกใชเชื่อม คาคงที่ตรรก ตัวแปรตรรก และนิพจนตรรก ที่เกิดจากเครื่องหมาย
แบบสมการและอสมการ ผลลัพธที่ไดเปนคาความจริงทางตรรก ซึ่งในการเขียนโปรแกรมบางครั้งมี
ความจําเปนที่จะทดสอบเงื่อนไขมากกวาหนึ่ง
ตัวอยางเชน ในงานทดลองหนึ่ง อาจตองการทดสอบทั้งอุณหภูมิและความกดอากาศ โดย
ตองการทดสอบคาอุณหภูมิที่ต่ํากวา 20 องศาเซลเซียส และทดสอบความกดอากาศ (pressure) ที่ต่ํากวา
50 หนวย สามารถทดสอบทั้งสองเงื่อนไขไดดังนี้ (temp <20) && (pressure < 50) เปนตน
ตัวดําเนินการทางตรรกในภาษาจาวามี 2 กลุมไดแก
• Short-Circuit Logical Operators ไดแก || และ &&
เปนการเช็คเงื่อนไขอยางรวดเร็ว สําหรับ || (OR) นั้นเมื่อกระทําการเชื่อมเงื่อนไข 2 เงื่อนไข
หากเงื่อนไขแรกเปน true จะไมสนใจอีกเงื่อนไขหนึ่งจะใหคาเปน true ทันที เชนเดียวกับ &&
(AND) ซึ่งจะใหคาเปน false ถาเงื่อนไขแรกเปน false

61
• Logical Operators (Non- Short-Circuit) ไดแก | & และ !
จะตางจาก Shot-cut ตรงที่จะเช็คทั้งสองเงื่อนไขทั้งหนาตัวดําเนินการและหลังตัวดําเนินการ
ทุกกรณี
ตัวดําเนินการตรรกะจะกระทํากับขอมูลที่ใหผลลัพธมีคาเปนจริง (true) หรือ มีคาเปนเท็จ
(false) สามารถกระทํารวมกับตัวดําเนินการอื่นๆ เชน ตัวดําเนินการทางคณิตศาสตร หรือตัว
ดําเนินการเชิงสัมพันธ เปนตน ตัวดําเนินการตรระ ไดแก ตัวดําเนินการ ! & | && และ || มี
ความหมายดังในตารางที่ 2.7
ตัวดําเนินการ ความหมาย ตัวอยางนิพจน ลําดับการทํางาน
! NOT ! (temp < 20 ) 1
& AND (temp <20) & (pressure<50) 2
| OR (temp <20) | (pressure<50) 3
&& AND (temp <20) && (pressure<50) 4
|| OR (temp <20) || (pressure<50) 5
ตารางที่ 2.7 แสดง ตัวดําเนินการตรรกะ
a b a&b a|b !a a&&b a||b
0 0 0 0 1 0 0
1 0 0 1 0 0 1
0 1 0 1 1 0 1
1 1 1 1 0 1 1
ตารางที่ 2.8 แสดงตารางคาความเปนจริงของตัวดําเนินการตรรก
ตัวอยางการใชงานเชน
boolean a = true;
boolean c = b & ( 4 > 5)
boolean d = !c;
ตัวแปร c ในตัวอยางขางตนมีคาเทากับ false สวนตัวแปร d มีคา true
สังเกตวาเครื่องหมาย & และ && มีคาความจริงเหมือนกันทุกประการ เครื่องหมาย | กับ | |
ก็เชนเดียวกัน ที่จริงแลวมีความแตกตางกันเล็กนอย กลาวคือ เครื่องหมาย & และ | จะหาผลลัพธโดย
ไมตองคํานวณจนจบนิพจน หากพบวาตรรกนี้จบไดจะหยุดคํานวณทันที ตัวอยางเชน

62
int i = 10 ;
boolean b = false & (i++ > 20);
ตัวอยางนี้ในที่สุดจะได b มีคา false และ i มีคาเปน 11 เปรียบเทียบกับตัวอยางตอไปนี้
int i = 10 ;
boolean b = false && (i++ > 11);
คา b ที่ไดจะมีคาเปน false เชนกัน แต i จะมีคาเปน 10 เนื่องจากตัวดําเนินการ && ถาพบวา
ดานใดดานหนึ่งมีคาเปน false จะทําใหทราบไดทันทีวานิพจนดังกลาวเปนเท็จแนนอน ในกรณีนี้
ดานซายของเครื่องหมายไมวาจะเปน true หรือ false ดังนั้นจาวาเวอรชัวนแมทชีนจะทิ้งสิ่งที่อยูทางขวา
ของเครื่องหมายไปเลย ทําใหไมมีการ +1 เกิดขึ้น หรือพิจารณาจากตัวอยางตอไปนี้
int a = 10;
char ch = ‘x’ ;
boolean b = ( a > 4) && (5.5 < 3.0) | | (m = = ‘x’ );
ตัวอยางนี้ตัวแปร b จะมีคาเปนจริง เพราะวลี d > 4 มีคาเปนจริง สวนวลี 15.5 < 3.0 เปนเท็จ
และ วลี m = =’x’ มีคาเปนจริง เมื่อนําสามวลีมากระทํากันจะไดเปน จริง && เท็จ | | จริง ซึ่งจาวา
เวอรชัวนแมทชีนจะเริ่มกระทําจากซายไปขวา หรือเทากับ ((จริง && เท็จ) || จริง) ซึ่งก็คือ (เท็จ || จริง)
ซึ่งก็คือ จริงในที่สุด
ลําดับความสําคัญของเครื่องหมายแบบสมการและอสมการที่มากกวาเครื่องหมายตรรก ดังนั้น
ถาไมใสวงเล็บ จาวาเวอรชัวนแมทชีนจะทําเครื่องหมายแบบสมการและอสมการจนเสร็จหมดกอน แลว
จึงคอยทําเครื่องหมายตรรก
ตัวดําเนินการเงื่อนไข (Conditional operator)
ภาษาจาวามีตัวดําเนินการเงื่อนไขคลายๆกับตัวดําเนินการเงื่อนไขใน ภาษา C หรือ Microsoft
Excel เปนตน ตัวดําเนินการเงื่อนไขจะประกอบดวยนิพจน 3 นิพจนโดยมีรูปแบบดังนี้
exp1 ? exp2 : exp3 ;
นิพจน exp1 เปนนิพจนตรรกะจะถูกประมวลผลกอน ถาไดผลลัพธเปนจริง (ไมเทากับศูนย)
แลวนิพจน exp2 จะถูกประมวลผล แตถาผลลัพธของนิพจน exp1 เปนเท็จ(เลขศูนย) นิพจน exp3 จะถูก
ประมวลผล เชน
z = (a > b) ? a : b ; / / ผลลัพธที่ไดเหมือนนิพจน z = max(a,b) ; ในภาษา C
z จะถูกกําหนดดวยคามากสุดของ a หรือ b คือ ถา a มีคามากกวา b จริงแลว z จะถูกกําหนดใหมี
คาเทากับคาของ a แตถา a มีคานอยกวาหรือเทากับ b แลว z จะถูกกําหนดคาใหมีคาเทากับคาของ b

63
ผลของการกระทําของตัวดําเนินการเงื่อนไขจะเหมือนกับการใชคําสั่ง if-else ดังเชน
if (a > b)
z = a;
else
z = b;
ลําดับการทํางานของตัวดําเนินการ (Operator Precedence)
นิพจนหนึ่งอาจประกอบดวยตัวดําเนินการมากกวาหนึ่งตัว ในการประมวลผลคานิพจนจะมี
ลําดับการทํางานกอนหลังตามตารางที่ 2.9 ตอไปนี้
ลําดับ
ความสําคัญ
ตัวดําเนินการ ชนิดตัวดําเนินการ การกระทํา การดําเนินการ
1 ++ Integer ขวา ไป ซาย Pre or post increment(unary)
-- Integer ขวา ไป ซาย Pre or post decrement(unary)
+ , - Integer ขวา ไป ซาย Unary plus, unary minus
~ Integer ขวา ไป ซาย Bitwise complement(unary)
! Boolean ขวา ไป ซาย Logical complement(unary)
(type) Any ขวา ไป ซาย Cast
2 * , / , % Arithmetic ซาย ไป ขวา Multiplication ,division ,modulus
3 + , - Arithmetic ซาย ไป ขวา Addition ,subtraction
+ String ซาย ไป ขวา String concatenation
4 << Integer ซาย ไป ขวา Left shift
>> Integer ซาย ไป ขวา Right shift with sign extension
>>> Integer ซาย ไป ขวา Right shift with zero extension
5 < , <= , > , >= Arithmetic ซาย ไป ขวา Less than , greater than, or equal to
Instance of Object,type ซาย ไป ขวา Type comparision
6 = = , ! = Native ซาย ไป ขวา Have same or different values
= = , != Object ซาย ไป ขวา Refer to the same or different object
7 & Int or boolean ซาย ไป ขวา Bitwise AND or Boolean AND
8 ^ Int or boolean ซาย ไป ขวา Bitwise XOR or Boolean XOR
9 | Int or boolean ซาย ไป ขวา Bitwise OR or Boolean OR
10 && Boolean ซาย ไป ขวา Conditional Boolean AND
11 || Boolean ซาย ไป ขวา Conditional Boolean OR

64
ลําดับ
ความสําคัญ
ตัวดําเนินการ ชนิดตัวดําเนินการ การกระทํา การดําเนินการ
12 ? : Boolean,any ขวา ไป ซาย Condition operator(ternary)
13 = Variable,any ขวา ไป ซาย Assignment
*= , /= , %= ,
+= , -= , <<=,
>>= , -= , <<=
Variable,any ขวา ไป ซาย Assignment after operation
แบบฝกหัด
1. ชื่อตอไปนี้เขียนถูกตองตามกฎการตั้งชื่อหรือไม เพราะอะไร
1.1 2variable 1.2 variable2 1.3 _whatavariable
1.4 _3_ 1.5 $anothervar 1.6 #myvar
1.7 a-class 1.8 _object$ 1.9 default
2. ใหนิสิตเขียนโปรแกรม คอมไพล และรันโปรแกรมตอไปนี้ และหาสาเหตุของการเกิด
ขอผิดพลาดพรอมวิธีแกไข
class Practice3{
public static main(char[] args){
int num = 20;
int x = 0;
System.out.println(num/x);
}
}

65
3. ใหนิสิตทําการเติมคาลงในตารางตอไปนี้ใหสมบูรณ
การประกาศและกําหนดคาเริ่มตน
int a = 1, b= 2, c = 3 ;
double x = 1.0 ;
นิพจน นิพจนเทียบเทา คา
a > b && c < b
a + b < ! c + c
a - x || b * c && b / a
a< b | a < c
c > b & x >= a
a < b & a++ < 2 a=
b=
b>c | ++c > 3 b=
c=
4. จงหาผลลัพธจากนิพจนตอไปนี้
1) var = 3 ;
var &= 5 var มีคาเทาไหร
2) ถา var = 0 ;
แลว var |= 4 ; var มีคาเทาไหร
3) ถา var = 0 ;
var ^= 7 ;
var ^= 127 ; แลว var มีคาเทาไหร
4) ถา var มีคา 0000000000000111
~var มีคาเทาไหร
5) ถา var = 1 ;
แลว var <<= 3 ; var มีคาเทาไหร
var << 1 ; var มีคาเทาไหร
var >>= 2 ; var มีคาเทาไหร
var >>>= 3 ; var มีคาเทาไหร

บทที่ 2 ชนิดของตัว

More Related Content

What's hot

Viewers also liked

Similar to บทที่ 2 ชนิดของตัว

More from Theeravaj Tum

บทที่ 2 ชนิดของตัว