ภาษาโปรแกรมคอมพิวเตอร์ที่ใช้เขียนโปรแกรมเพื่อแก้ปัญหาต่างๆ มีมากมายหลายภาษา ซึ่งแต่ละภาษาโปรแกรมมีข้อดีและเหมาะกับใช้งานต่างๆ กัน ในการเลือกใช้ภาษาโปรแกรมคอมพิวเตอร์มาใช้งาน ควรพิจารณาสิ่งต่างๆ ดังนี้คือ
1. เลือกภาษาโปรแกรมคอมพิวเตอร์ที่เหมาะกับความชำนาญของบุคลากร หรือนักเขียนโปรแกรม
2. คำนึงถึงเวลาและค่าใช้จ่ายในการพัฒนาและเขียนโปรแกรม
3. เลือกภาษาโปรแกรมคอมพิวเตอร์ที่นักเขียนโปรแกรมเข้าใจง่าย มีการประยุกต์ใช้งานได้อย่างแพร่หลาย และสามารถพัฒนาต่อไปในอนาคตได้
4. เลือกภาษาโปรแกรมคอมพิวเตอร์ให้เหมาะกับฮาร์ดแวร์ และสามารถทำงานร่วมกันได้ระหว่างอุปกรณ์คอมพิวเตอร์
ตัวอย่างภาษาโปรแกรมคอมพิวเตอร์ที่นำมาใช้ในงานด้านต่างๆ สามารถสรุปได้ดังตาราง ต่อไปนี้
ภาษาคอมพิวเตอร์
|
การใช้งานหลัก
|
• FORTRAN (FORmula TRANslator)
|
ใช้ในงานคำทางด้านวิทยาศาสตร์ วิศวกรรมศาสตร์ หรืองานวิจัย การแก้ปัญหาทางคณิตศาสตร์ หรือการวิเคราะห์ทางเศรษฐศาสตร์ได้
|
• ALGOL (ALGOrithmic Language)
|
เริ่มต้นได้รับการออกแบบให้เป็นภาษาสำหรับงานวิทยาศาสตร์ และต่อมามีการพัฒนาต่อเป็นภาษา PL/I และ Pascal
|
• COBOL
(Common Business Oriented Language)
|
ใช้ในการประมวลผลแฟ้มข้อมูลขนาดใหญ่ การคำนวณทางด้านธุรกิจบนเครื่องขนาดใหญ่
|
PL/I (Programming Language One)
|
ถูกออกแบบมาใช้กับงานทั้งทางด้านวิทยาศาสตร์ และธุรกิจ
|
• BASIC (Beginner's All-purpose Symbolic Instruction Code)
|
สำหรับผู้เริ่มศึกษาการเขียนโปรแกรมคอมพิวเตอร์ ประยุกต์ใช้งานทางด้านวิทยาศาสตร์ และธุรกิจ
|
• Pascal ( ชื่อของ Blaise Pascal)
|
นิยมใช้กันอย่างแพร่หลายทุกด้าน
|
• C และ C ++
|
สำหรับนักเขียนโปรแกรม ผู้ผลิตซอฟต์แวร์ และโปรแกรมประยุกต์ต่างๆ
|
• LISP (LISt Processing)
|
ออกแบบโดยบริษัท IBM ในปี ค . ศ . 1968 เป็นภาษาที่โต้ตอบ กับผู้ใช้ทันทีเหมาะสำหรับจัดการกับกลุ่มของข้อมูลที่สัมพันธ์กันในรูปแบบตาราง
|
• LOGO
|
นิยมใช้ในโรงเรียน เพื่อสอนทักษะการแก้ปัญหาให้กับนักเรียน
|
• PROLOG (PROgramming LOGic)
|
นิยมใช้มากในงานด้าน ปัญญาประดิษฐ์จัดเป็นภาษาธรรมชาติ ภาษาหนึ่ง
|
• RPG (Report Program Generator)
|
ถูกออกแบบให้ใช้กับงานทางธุรกิจ จะมีคุณสมบัติในการสร้างโปรแกรมสำหรับพิมพ์รายงานที่ยืดหยุ่นมาก
|
ตัวอย่างภาษาโปรแกรมคอมพิวเตอร์ ปัจจุบันนี้มีภาษาคอมพิวเตอร์ให้เลือกใช้มากมายหลายภาษา แต่ละภาษาก็ถูกออกแบบ มาให้ใช้กับงานด้านต่าง ๆ กัน ตัวอย่าง เช่น บางภาษาก็ออกแบบมาเพื่อแก้ปัญหาทางธุรกิจ บางภาษาใช้ในการคำนวณที่ซับซ้อน ซึ่งจะกล่าวโดยสรุปถึงการใช้งานของแต่ละภาษาดังนี้
1. ภาษาฟอร์แทรน ( FORTRAN : FORmula TRANslator)
ภาษาฟอร์แทรน เป็นภาษาระดับสูงที่ได้รับการพัฒนาโดยบริษัท IBM มาตั้งแต่ปี ค.ศ. 1957 ย่อมาจากคำว่า FORmula TRANslator ซึ่งถือว่าเป็นการกำเนิดของภาษาระดับสูงภาษาแรก นิยมใช้สำหรับงานที่มีการคำนวณมาก ๆ เช่น งานทางด้านคณิตศาสตร์ วิทยาศาสตร์ และวิศวกรรมศาสตร์ ภาษา FORTRAN สามารถใช้ในการแก้ปัญหาสมการทางคณิตสาสตร์ที่ซับซ้อนได้ดี หรือการวิเคราะห์ทางเศรษฐศาสตร์
ตัวอย่างการเขียนโปรแกรมด้วยภาษา FORTRAN
FORTRAN PROGRAM
SUM = 0
COUNTER = 0
WRITE ( 6 , 60 )
READ ( 5 , 40 ) NUMBER
1 IF ( NUMBER) .EQ. 999 ) GOTO 2
SUM = SUM + NUMBER
COUNTER = COUNTER + 1
WRITE ( 6 , 70 )
READ ( 5 , 70 ) NUMBER
GOTO 1
2 AVERAGE = SUM / COUNTER
WRITE ( 6 , 80 ) AVERAGE
STOP
END
2. ภาษา ALGOL
ภาษา ALGOL หรือ Algorithmic Language คิดค้นโดยกลุ่มนักคอมพิวเตอร์ ที่มาประชุมวิชาการ ที่ซูริค ในปี 1958 และออกเผยแพร่ปี 1960 มีคำสั่งกำหนดโครงสร้าง และชนิดข้อมูลอย่างสมบูรณ์ และมีการนำไปเป็นพื้นฐานในการออกแบบภาษารุ่นที่ 3 ที่นิยมกันอย่างมากในปัจจุบัน เช่น Pascal โดยภาษา ALGOL ที่เป็นมาตรฐาน ได้แก่ ALGOL- 60 และ ALGOL- 68
3. ภาษาโคบอล (COBOL)
ภาษาโคบอล เป็นภาษาระดับสูงที่ออกแบบมาตั้งแต่ปี ค.ศ. 1960 โดยสถาบันมาตรฐานแห่งสหรัฐอเมริกากับบริษัทผู้ผลิตคอมพิวเตอร์หลายแห่ง และได?มีการพัฒนาอย่างต่อเนื่องจากมาตรฐานของภาษาโคบอลในปี 1968 กำหนดโดย The American National Standard Institute และในปี 1974 ได?ออกมาตรฐานที่เรียกว่า ANSI - COBOL ต่อมาเป็น COBOL 85 ภาษาโคบอลเป็นภาษาที่ออกแบบให้ใช้?กับงานทางธุรกิจได?เป็นอย่างดี สำหรับการประมวลผลแฟ้มข้อมูลขนาดใหญ่? การคำนวณทางธุรกิจเช่นการจัดเก็บ เรียกใช้? และประมวลผลทางด้านบัญชี ตลอดจนทำงานด้านการควบคุมสินค้าคงคลัง การรับและจ่ายเงิน เป็นต้น
คำสั่งของภาษา COBOL จะคล้ายกับภาษาอังกฤษทำให้สามารถอ่านและเขียนโปรแกรม ได?ไม?ยากนัก ในยุคแรก ๆ ภาษา COBOL จะได?รับความนิยมบนเครื่องระดับเมนเฟรม แต่ปัจจุบันนี้จะ มีตัวแปลภาษา COBOL ที่ใช้บนเครื่องไมโครคอมพิวเตอร์ด้วย รวมทั้งมีภาษา COBOL ที่ได?รับการ ออกแบบตามแนวทางเชิงวัตถุ ( Object Oriented) เรียกว่า Visual COBOL ซึ่งจะช่วยให้การโปรแกรมสามารถทำได?ง่ายขึ้น และสามารถนำโปรแกรมที่เขียนไว้มาใช้ในการพัฒนางานอื่น ๆ อีก
ตัวอย่างการเขียนโปรแกรมด้วยภาษา COBOL
IF SALES-AMOUNT IS GREATER THAN SALES-QUOTA
COMPUTE COMMISSION = MAX-RATE * SALES - AMOUNT
ELSE
COMPUTE COMMISSION = MIN-RATE * SALES - AMOUNT
4. ภาษาเบสิก (BASIC)
ภาษาเบสิก ( Basic ย่อมาจาก Beginners All - purpose Symbolic Instruction Code)เป็นภาษาที่ง่ายต่อการเรียนรู้พัฒนาโดย Dartmouth Collage แนะนำโดย John Kemeny และ Thomas Krutz ในปี 1965 เป็นภาษาที่ใช้ง่าย และติดตั้งอยู่บนเครื่องไมโครคอมพิวเตอร์ส่วนมาก ใช้สำหรับ ผู้เริ่มต้นศึกษาการเขียนโปรแกรม และได้มีการพัฒนาอย่างต่อเนื่องจากภาษา BASIC, QBASIC ปัจจุบันเป็น Visual BASIC เป็นที่นิยมใช้กันอย่างแพร?หลาย สามารถประยุกต์ใช้งานได?ทั้งทางวิทยาศาสตร์และทางธุรกิจ
ตัวอย่างการเขียนโปรแกรมด้วยภาษา BASIC
CLS
PRINT “PLEASE ENTER A NUMBER”
INPUT NUMBER
DO WHILE NUMBER <> 999
SUM = SUM + NUMBER
vCOUNTER = COUNTER + 1
PRINT “PLEASE ENTER THE NEXT NUMBER”
INPUT NUMBER
LOOP
AVERAGE = SUM/COUNTER
PRINT “THE AVERAGE OF THE NUMBER IS”; AVERAGE
END
5. ภาษา PL/ 1
ภาษา PL/I เป็นภาษาที่พัฒนาขึ้นโดยทีมงานของบริษัทไอบีเอ็ม ที่ตั้งใจจะรวมความสามารถของภาษา FORTRAN, ALGOL, COBOL เข้าด้วยกัน ดังนั้นจึงอาจกล่าวได้ว่า ภาษานี้เป็นภาษาแรกที่ทำงานได้กว้างขวางจริงๆ ทั้งทางด้านวิทยาศาสตร์ วิศวกรรม และธุรกิจ แต่ขณะเดียวกัน ก็ทำให้ตัวแปลภาษาใหญ่มาก จนไม่สามารถนำไปใช้กับเครื่องขนาดเล็กได้ ภาษานี้กำหนดรูปแบบ/ประเภทข้อมูลได้หลายแบบ ทำงานหลายงานพร้อมกันได้ ( Multitasking) ทำงานกับอุปกรณ์รับส่งข้อมูล ที่ซับซ้อนได้ และประมวลรายการได้ ( List Processing) แต่ภาษานี้ไม่เป็นที่ยอมรับมากนัก
6. ภาษาปาสคาล (Pascal)
ภาษาปาสคาล เป็นภาษาที่ได้รับการพัฒนาโดยนิคลอส เวิร์ธ (Niklaus Wirth) แห่งสถาบันเทคโนโลยีของรัฐในเมือง ซูริค (Zurick) ประเทศสวิสเซอร์แลนด์ เมื่อปี ค.ศ. 1968 ชื่อของภาษานี้ตั้งชื่อเพื่อเป็นเกียรติแก่นักคณิตศาสตร์ชาวฝรั่งเศสคนสำคัญที่ชื่อว่า Blaise Pascal ภาษานี้ออกแบบมาเพื่อให้ง่ายต่อการเขียนโปรแกรม ง่ายต่อการเรียนรู้ แตกต่างกับภาษาเบสิกก็คือ ภาษาปาสคาลเป็นภาษาโครงสร้าง ( Structure Programming) นิยมใช้เป็นภาษาสำหรับการเรียนการสอน และการเขียนโปรแกรมประยุกต์ต่าง ๆ ภาษาปาสคาลมีตัวแปลภาษาทั้งที่เป็นแบบ Interpreter และ Compiler โดยจะมีโปรแกรม เทอร์โบปาสคาล ( Turbo Pascal) ที่ได้รับความนิยมอย่างสูงทั้งในวงการศึกษา และธุรกิจ เนื่องจากได้รับ การปรับปรุงให้ตัดข้อเสียของภาษาปาสคลารุ่นแรก ๆ ออกไป
ตัวอย่างการเขียนโปรแกรมด้วยภาษา Pascal
PROGRAM AVERAGE OF NUMBER:
VAR
COUNTER , NUMBER , SUM : INTEGER ;
AVERAGE : REAL ;
BEGIN
SUM := 0 ;
COUNTER := 0;
WRITELN (‘PLEASE ENTER A NUMBER');
READLN ( NUMBER);
WHILE NUMBER <> 999 DO
BEGIN (* WHILE LOOP *)
SUM := SUM + COUNTER;
WRITELN (‘PLEASE ENTER THE NEXT NUMBER');
READ ( NUMBER);
END ; (* WHILE LOOP *)
AVERAGE := SUM / COUNTER;
WRITELN (‘THE AVERAGE OF THE NUMBERS IS' , AVERAGE : 2 );
END.
7. ภาษา Modula- 2
ภาษา Modula- 2 เป็นภาษาที่นิคลอส เวิร์ธ ปรับปรุงจากภาษาปาสกาล โดยพยายามให้มีลักษณะที่ดีของภาษา สำหรับเขียนโปรแกรมมากขึ้น เช่น การทำให้มีการซ่อนสารสนเทศ ( Information Hiding) หลักการนามธรรม ( Abstraction) การกำหนดชนิดข้อมูล ซึ่งสามารถนำไปใช้กับการดำเนินงานแบบ Recursion และ Concurrency ได้ด้วย ปัจจุบันภาษานี้ไม่ได้รับความนิยมเท่าที่ควร
8. ภาษา C และ C++
ภาษา C ถูกพัฒนาขึ้นโดย Dennis Ritchie ในปี ค.ศ. 1972 ที่ห้องปฏิบัติการเบลล์ ของบริษัท AT&T เป็นภาษาที่ใช้เขียนระบบปฏิบัติการ UNIX ซึ่งเป็นระบบปฏิบัติการที่ได้รับ ความนิยมคู่กับภาษาซี และมีการใช้งานอยู่ในเครื่องทุกระดับ
ภาษา C เป็นภาษาระดับสูงที่ได้รับความนิยมในหมู่นักเขียนโปรแกรมเป็นอย่างมาก เนื่องจากภาษา C เป็นภาษาที่รวมเอาข้อดีของภาษาระดับสูงในเรื่องของความยืดหยุ่น และไวยากรณ์ ที่ง่ายต่อการเข้าใจกับข้อดีของภาษาแอสเซมบลีในเรื่องของประสิทธิภาพและความเร็วในการทำงาน ทำให้โปรแกรมที่พัฒนาด้วย ภาษาซีทำงานได้เร็วกว่าโปรแกรมที่เขียนด้วยภาษาระดับสูงอื่น ๆ ในขณะที่การพัฒนา และแก้ไขโปรแกรมสามารถทำได้ง่ายเช่นเดียวกับภาษาระดับสูงทั่ว ๆ ไป นอกจากนี้ภาษา C ยังได้มีการพัฒนาก้าวหน้าขึ้นไปอีก โดยทำการประยุกต์แนวความคิดของการ โปรแกรมเชิงวัตถุเข้ามาใช้ในภาษา ทำให้เกิดเป็นภาษาใหม่คือ C++ (++ ในความหมายของภาษาซีคือ การเพิ่มขึ้นอีกหนึ่งนั่นเอง) ซึ่งเป็นภาษาที่ได้รับความนิยมใช้ในงานพัฒนาโปรแกรมอย่างมาก
ตัวอย่างการเขียนโปรแกรมด้วยภาษา C และ C++
/* http://www.thaiall.com/tc */
#include <stdio.h>
#include <conio.h>
void main(){
int i, j;
printf("Put integer :");
scanf ("%d", &i);
printf("n========n");
j = 0;
while (i > j){
printf("%d\n", ++j);
}
getch();
}
9. ภาษา Ada
ภาษา Ada พัฒนาขึ้นตามสัญญาว่าจ้างของกระทรวงกลาโหม สหรัฐอเมริกา ที่ต้องการได้ภาษาคอมพิวเตอร์ ที่สามารถใช้แทนภาษาอื่นๆ ที่หน่วยงานต่างๆ ภายในกระทรวงกำลังใช้อยู่ในขณะนั้นได้ ภาษานี้มีโครงสร้างคล้ายภาษาปาสกาล แต่ทำงานได้มากกว่า เช่น ทำงานหลายงานได้พร้อมกัน ( Mustitasking) จัดการกับการขัดจังหวะได้ ( Interrupt handling) จัดจังหวะการทำงานให้เข้ากัน ( Intertask Synchronization) เป็นต้น ซึ่งนับว่าเป็นภาษาที่มากด้วย โครงสร้างแบบต่างๆ จึงมีขนาดใหญ่ด้วย
10. ภาษา Lisp
ภาษา Lisp (LISt Processing) เป็นภาษาที่นับได้ว่าเก่าแก่พอๆ กับภาษาฟอร์แทรน พัฒนาในปี 1950 โดย จอห์น แมคคาร์ธี ( John McCarthy) สถาบันเทคโนโลยีแห่งแมสสาชูเสตต์ เหมาะสมกับงานประมวลสัญลักษณ์ หรือรายการต่างๆ ในปัญหาประเภท Combinatorial ซึ่งใช้ในงานปัญญาประดิษฐ์ เช่น การพิสูจน์ทฤษฏี การค้นหาข้อมูล ที่จัดโครงสร้างแบบต้นไม้ เป็นต้น ภาษานี้มีโปรแกรมย่อย ในรูปของฟังก์ชัน ที่มีลักษณะเป็นเอกเทศ สามารถนำมาทำเป็นคลังฟังก์ชันขนาดใหญ่ได้ และเป็นการเน้นหลักการ ด้านการนำกลับมาใช้ใหม่ได้เป็นอย่างดี ปัจจุบันมีการนำมาใช้ในการสร้าง ระบบผู้เชี่ยวชาญกันมาก เพราะลักษณะของภาษา เอื้ออำนวยต่อการใช้ระบุความจริง กฎเกณฑ์ และการอนุมานต่างๆ อันจำเป็นต่องานระบบอิงฐานความรู้
11. ภาษา Prolog
ภาษา Prolog (PROgramming in LOGic) เป็นอีกภาษาที่นิยมใช้ในการสร้างระบบผู้เชี่ยวชาญ ( Artificial Intelligence) เพราะเหมาะสำหรับใช้แสดงความรู้ ( Knowledge Representation) โดยนำความรู้มาเขียนในรูปของ อนุประโยค ( Clause) ซึ่งเป็นภาษาคู่แข่งกับภาษา Lisp พัฒนาโดย Colmerauer แห่ง University of Marseilles ในปี 1970 จากนั้น Clocksin กับ Mellish จาก University of Edinburgh ได้นำมาพัฒนาเพื่อใช้งานต่อ
12. ภาษา APL
ภาษา APL (A Programming Language) เป็นภาษาระดับสูงที่คิดสร้างโดย เค. อี. ไอเออร์สัน ( Ken Iverson) แห่งบริษัทไอบีเอ็ม เมื่อปี 1960 มีลักษณะแตกต่างจาก ภาษาคอมพิวเตอร์ภาษาอื่นอยู่มาก เช่น ใช้สัญลักษณ์แทนการทำงาน หรือการดำเนินการทางเลขคณิต และอักขระ ทำให้โปรแกรมมีขนาดกระทัดรัด จึงเป็นภาษาที่นิยมใช้แก้ปัญหาคณิตศาสตร์
13. ภาษาโปรแกรมเชิงวัตถุ ( Object-Oriented Programming Language)
ภาษาโปรแกรมเชิงวัตถุ ( Object-Oriented Programming) หรือ OOP เหมาะกับการเขียนโปรแกรมประยุกต์ขนาดใหญ่ทำให้งานเขียนโปรแกรมเป็นสิ่งที่ง่ายและสามารถเขียนได้อย่างรวดเร็ว เพราะจะสิ่งต้องการเขียนโปรแกรมเป็นคลาสของวัตถุ ( Class) ซึ่งประกอบด้วย คุณสมบัติ (Property) และวิธีการทำงาน (Method) สามารถทำการแก้ไข หรือเพิ่มเติมคำสั่งใน Method ได้โดยไม่กระทบโปรแกรมส่วนอื่นๆ ทั้งยังสามารถสืบทอดคุณสมบัติของ Class ได้อีกด้วย มีหน้าจอของการโต้ตอบ ( dialog box) หรือไอคอน บนจอภาพ เป็นต้น ตัวอย่างของภาษา OOP เช่น
- Smalltalk เป็นภาษา OOP ภาษาแรก ได้สร้างขึ้นในปี 1970 โดยนักคอมพิวเตอร์ชื่อ Alan kay ภาษานี้ใช้แป้นพิมพ์ในการป้อนข้อมูลแต่การทำงานทั้งหมดใช้เมาส์
- C++ เป็นการพัฒนาจากภาษา C เพื่อให้เป็นภาษา OOP ได้สร้างขึ้นโดย Bjarne Strousup การเขียนภาษานี้ใช้รหัสมาตรฐานของภาษา C ภาษา C++ สามารถเขียนแบบธรรมดาและแบบ OOP
ภาษาคอมพิวเตอร์ที่อยู่ในตระกูล Visual เป็นภาษาที่พัฒนาต่อจาก OOP เป้าหมายของ Visual Programming ทำให้โปรแกรมเมอร์เขียนโปรแกรมได้ง่าย การทำงานจะเป็นกราฟฟิกส์ ทำให้ผู้?ใช้คิดเกี่ยวกับการแก้ปัญหาได้ง่าย การสร้างโปรแกรมใช้ Icon แทนการเขียนโปรแกรมประจำโปรแกรมเมอร์จะเชื่อมต่อระหว่าง Object โดยการวาดรูป การชี้ การคลิกบนไดอะแกรม การเขียนโปรแกรมแบบ Visual จะต้องเป็นระบบ GUI ตัวอย่างของภาษาในกลุ่มนี้ที่นิยมคือ Visual Basic พัฒนาโดยไมโครซอฟต์ ในปี 1990 จัดเป็นภาษาในยุคที่ 4 ในกลุ่มของ OOP
14. ภาษา Visual Basic
ภาษา Visual Basic เป็นภาษาระดับสูงในยุคที่ 4 พัฒนาโดยบริษัท Microsoft ในปี ค.ศ. 1987 แต่เริ่มได้รับความนิยมในปี ค.ศ.1991 นับว่าเป็นภาษาคอมพิวเตอร์ภาษาแรกที่มีเครื่องมือ เป็นภาพกราฟฟิกคอยอำนวยสะดวกในการเขียนโปรแกรม และได้รับความนิยมในการพัฒนาโปรแกรมบน Windows เพราะมีหลักการเขียนโปรแกรมแบบ Event – Driven ซึ่งเป็นการเขียนโปรแกรมเพื่อกำหนดการทำงานให้กับ Control ต่างๆที่สร้างขึ้นตามเหตุการณ์ (Event) ที่เกิดขึ้น เช่น การคลิกเมาส์ของผู้ใช้ หรือการรับข้อมูลจากคีย์บอร์ด เป็นต้น
Private Sub Form_Load()
Dim i As Integer
For i = -5 To 5
If i < 0 Then
MsgBox i &" เป็นตัวเลขจำนวนเต็มลบ ", vbOKOnly + vbInformation, "Show"
Else
MsgBox i &" เป็นตัวเลขจำนวนเต็มบวก ", vbOKOnly + vbInformation, "Show"
End If
Next
End Sub
16. ภาษา Java
ภาษา Java เป็นภาษาระดับสูงในยุคที่ 4 ที่สนับสนุนการเขียนโปรแกรมเชิงวัตถุ ซึ่งเป็นเทคนิคที่ใช้วัตถุ (Object) เป็นหลักในการพิจารณาสิ่งต่างๆที่สนใจ ดังนั้นโปรแกรมที่เขียนด้วยภาษา Java ซึ่งประกอบด้วยกลุ่มของ Object ถูกจัดกลุ่มในรูปของ Class โดยที่แต่ละคลาสมีคุณสมบัติการถ่ายทอดลักษณะ (Inheritance) ภาษา Java ได้รับความนิยมอย่างสูง เนื่องจากโปรแกรมที่เขียนด้วยภาษา Java สามารถทำงานบนเครื่องคอมพิวเตอร์ที่มีสภาวะแวดล้อมต่างกันได้โดยไม่ขึ้นกับแพตฟอร์มใดๆ (Platform Independent) เป็นภาษาที่มีไวยากรณ์เข้าใจง่าย ดังตัวอย่างต่อไปนี้
class TestJava
{
public static void main(String[] args)
{
System.out.println("Hello World!");
}
}
| ตัวแปลภาษาโปรแกรมคอมพิวเตอร์ |
| |
ตัวแปลภาษาโปรแกรมคอมพิวเตอร์ เป็นโปรแกรมที่ใช้ในการแปลความหมายของคำสั่งในภาษาคอมพิวเตอร์ชนิดต่างๆไปเป็นภาษาเครื่อง ซึ่งเป็นภาษาที่คอมพิวเตอร์เข้าใจ และทำงานตามคำสั่งได้ โดยโปรแกรมที่เขียนเป็นโปรแกรมต้นฉบับ หรือ ซอร์สโค้ด ( Source code) ซึ่งโปรแกรมเมอร์เขียนคำสั่งตามหลักการออกแบบโปรแกรม และจำเป็นต้องใช้ตัวแปลภาษาคอมพิวเตอร์เพื่อตรวจสอบไวยากรณ์ของภาษาว่าเขียนถูกต้อง หรือไม่ และทดสอบผลลัพธ์ว่าเป็นอย่างไร ซึ่งภาษาคอมพิวเตอร์ชนิดต่างๆจะมีตัวแปลภาษาของตนเองโดยเฉพาะ โปรแกรมที่แปลจากโปรแกรมต้นฉบับแล้วจะเรียกว่า ออบเจ็คโค้ด ( Object code) ซึ่งเป็นภาษาเครื่องที่ประกอบด้วย รหัสคำสั่งที่คอมพิวเตอร์สามารถเข้าใจและนำไปปฏิบัติได้ต่อไป
ตัวแปลภาษาคอมพิวเตอร์มีการใช้งานสำหรับการแปลภาษาคอมพิวเตอร์ชนิดต่างๆแบ่งออกเป็น 3 ประเภท
1. แอสเซมเบลอร์ ( Assembler) เป็นตัวแปลภาษาแอสเซมบลีซึ่งเป็นภาษาระดับต่ำ ให้เป็นภาษาเครื่อง
2. อินเทอร์พรีเตอร์ ( Interpreter) เป็นตัวแปลภาษาคอมพิวเตอร์ระดับสูงไปเป็นภาษาเครื่อง โดยใช้หลักการแปลคำสั่งครั้งละ 1 คำสั่งให้เป็นภาษาเครื่อง แล้วนำคำสั่งที่เป็นภาษาเครื่องนั้นไปทำการประมวลผล และแสดงผลลัพธ์ทันทีหากไม่พบข้อผิดพลาด หลังจากนั้นจะแปลคำสั่งถัดไปเรื่อยๆจนกว่าจะจบโปรแกรม ในระหว่างการแปลคำสั่ง ถ้าหากพบข้อผิดพลาดทางไวยากรณ์ของภาษา โปรแกรมอินเทอร์พรีเตอร์ก็จะหยุดการทำงานพร้อมแจ้งข้อผิดพลาดให้ทำการแก้ไขซึ่งทำได้ง่ายและรวดเร็ว แต่ออบเจ็คโค้ดที่ได้จากการแปลคำสั่งโดยใช้อินเทอพรีเตอร์นั้นไม่สามารถเก็บไว้ใช้ใหม่ได้ จะต้องแปลโปรแกรมใหม่ทุกครั้งที่ต้องการใช้งาน ทำให้โปรแกรม ทำงานได้ค่อนข้างช้า
3. คอมไพเลอร์ ( Compiler) เป็นตัวแปลภาษาคอมพิวเตอร์ระดับสูงไปเป็นภาษาเครื่อง โดยทำการตรวจสอบความถูกต้องของการเขียนคำสั่งทั้งหมดทั้งโปรแกรมให้เป็นออบเจ็คโค้ด แล้วจึงทำการแปลคำสั่งไปเป็นภาษาเครื่อง จากนั้นจึงทำทำการประมวลผลและแสดงผลลัพธ์ หากพบข้อผิดพลาดของการเขียนโปรแกรม หรือมีคำสั่งที่ผิดหลักไวยากรณ์ของภาษาคอมพิวเตอร์ โปรแกรมคอมไพเลอร์จะแจ้งให้โปรแกรมเมอร์ทำการแก้ไขให้ถูกต้องทั้งหมดก่อนแล้วจึงคอมไพล์ใหม่อีกครั้ง จนกว่าไม่พบข้อผิดพลาดถึงจะนำโปรแกรมไปใช้งานได้
ข้อดีของคอมไพเลอร์ คือโปรแกรมออปเจ็คโค้ดที่ได้จะรวบรวมคำสั่งที่สำคัญในการรันโปรแกรม และได้โปรแกรมที่ทำงานเองได้ หรือ Execute Program ซึ่งสามารถทำงานได้ไม่จำกัด ไม่ต้องเสียเวลาในการแปลใหม่ทุกครั้ง ทำให้การทำงานของโปรแกรมเป็นไปอย่างรวดเร็ว จึงเป็นรูปแบบการแปลที่ได้รับความนิยมอย่างมาก
ในปัจจุบัน มีหลักการแปลภาษาคอมพิวเตอร์แบบใหม่เกิดขึ้น คือ แปลจากซอร์สโค้ด ไปเป็นรหัสชั่วคราว หรืออินเทอมีเดียตโค้ด ( Intermediate Code) ซึ่งสามารถนำไปทำงานได้ด้วย การใช้โปรแกรมในการอ่าน และทำงานตามรหัสชั่วคราวนั้น โดยโปรแกรมนี้จะมีหลักการทำงาน คล้ายกับอินเทอพรีเตอร์ แต่จะทำงานได้เร็วกว่าเนื่องจากรหัสชั่วคราวจะใกล้เคียงกับภาษาเครื่องมาก มีข้อดีคือสามารถนำรหัสชั่วคราวนั้นไปใช้ได้กับทุก ๆ เครื่องมี่มีโปรแกรมตีความได้ทันที
| |
 หน่วยที่ 2 หลักการเขียนโปรแกรมคอมพิวเตอร์เบื้องต้น |
|
|
|
|
| ขั้นตอนการพัฒนาโปรแกรม |
| |
ในการเขียนโปรแกรมเพื่อแก้ปัญหาต่างๆจำเป็นต้องมีการวางแผน และออกแบบโปรแกรมไว้ล่วงหน้า โดยกำหนดขั้นตอนวิธีการทำงานให้ชัดเจน ซึ่งกระบวนการวิเคราะห์ และออกแบบโปรแกรมเรียกว่า วัฏจักรการพัฒนาระบบงาน System Development Lift Cycle ( SDLC) ซึ่งมีกระบวนการทำงานเริ่มต้นจากการวิเคราะห์ปัญหาไปจนถึงการนำโปรแกรมไปใช้งาน และปรับปรุงพัฒนาระบบให้ดีขึ้น มีขั้นตอนของ วัฏจักรการพัฒนาระบบงาน ดังต่อไปนี้
ขั้นตอนที่ 1 การวิเคราะห์ปัญหา (Problem Analysis)
ขั้นตอนที่ 2 การออกแบบโปรแกรม (Program Design)
ขั้นตอนที่ 3 การเขียนโปรแกรม (Program Coding)
ขั้นตอนที่ 4 การทดสอบและแก้ไขโปรแกรม ( Program Testing & Verification)
ขั้นตอนที่ 5 การจัดทำเอกสารและคู่มือการใช้งาน (Program Documentation)
ขั้นตอนที่ 6 การใช้งานจริง (Program Implement)
ขั้นตอนที่ 7 การปรับปรุงและพัฒนาโปรแกรม (Program Maintenance)
การวิเคราะห์ปัญหา (Problem Analysis) ขั้นตอนการวิเคราะห์ปัญหาสามารถจำแนกได้ดังนี้
1. กำหนดขอบเขตของปัญหา เพื่อให้ทราบขั้นตอนการทำงานต่างๆ ดังนี้
• กำหนดจุดประสงค์การทำงาน เพื่อให้ทราบว่าเขียนโปรแกรมเพื่อต้องการแก้ปัญหาอะไร เช่น ปัญหาเกี่ยวกับการคำนวณพื้นที่ของสามเหลี่ยม เป็นต้น
• กำหนดเป้าหมายให้ชัดเจน เพื่อให้ได้ผลลัพธ์ที่ต้องการ เช่น โปรแกรมคำนวณพื้นที่ของสามเหลี่ยม ต้องการคำนวณพื้นที่รูปสามเหลี่ยมได้หลายขนาดและแสดงผลเป็นตัวเลข
• ศึกษาวิธีการแก้ปัญหา เพื่อออกแบบขั้นตอนการทำงานได้อย่างเหมาะสม เช่น การใช้สูตรคำนวณทางคณิตศาสตร์ต่างๆ
• กำหนดข้อจำกัดและศึกษาความเป็นไปได้เพื่อใช้ในการแก้ปัญหาตามวัตถุประสงค์ เช่น โปรแกรมคำนวณพื้นที่ของสามเหลี่ยม ต้องการคำนวณพื้นที่ได้เฉพาะรูปสามเหลี่ยม
2. กำหนดข้อมูลนำเข้า ซึ่งประกอบหัวข้อพิจารณาดังนี้
• กำหนดลักษณะการรับข้อมูล เช่น รับข้อมูลจากแป้นพิมพ์ หรือ อ่านข้อมูลจากไฟล์
• รูปแบบข้อมูลที่รับเข้ามาเป็นอย่างไร เช่น ข้อมูลชื่อนิสิตเก็บเป็นตัวอักษรหรือสตริง ข้อมูลเงินเดือนพนักงานเก็บเป็นจำนวนทศนิยม เป็นต้น
• ขอบเขตของข้อมูลมีช่วงค่าของข้อมูลได้เท่าไหร่ เช่น รับข้อมูลเงินเดือนมีค่าอยู่ระหว่าง 0.00 ถึง 100,000.00 บาท เก็บข้อมูลเป็นจำนวนทศนิยม เป็นต้น
• ข้อจำกัดในการรับข้อมูลอย่างไรบ้าง เช่น รับข้อมูลได้เฉพาะค่าตัวเลขที่มากกว่า 0 เป็นต้น
3. วิธีการประมวลผล เป็นขั้นตอนที่สำคัญในการแก้ปัญหา ประกอบด้วยข้อกำหนดดังนี้
• กำหนดวิธีการ หรือเทคนิคที่ใช้แก้ปัญหา ปัญหาต่างๆ จะมีวิธีการปัญหาแตกต่างกันไปขึ้นอยู่กับสภาพของปัญหา และผู้แก้ปัญหา และปัญหาหนึ่งๆสามารถแก้ปัญหาได้ด้วยหลายๆ วิธีการ ดังนั้นให้เลือกวิธีการแก้ปัญหาที่เหมาะสมกับปัญหานั้นๆ
• กำหนดขั้นตอนทำงานให้ชัดเจน เพื่อแก้ปัญหาตามลำดับการทำงานของวิธีการที่ได้เลือกใช้ และประมวลผลให้ได้ผลลัพธ์ที่ต้องการ
4. กำหนดผลลัพธ์
• กำหนดรูปแบบการแสดงผล เช่น แสดงผลลัพธ์เป็นภาพกราฟฟิกส์ทางจอภาพ หรือพิมพ์ข้อมูลออกทางเครื่องพิมพ์ เป็นต้น
• ตรวจสอบข้อผิดพลาดและความถูกต้องของผลลัพธ์ เช่น ตรวจสอบข้อผิดพลาดจากการคำนวณ ตรวจสอบผลลัพธ์ว่าถูกต้องตรงตามที่ต้องการหรือไม่
5. กำหนดโครงสร้างข้อมูลที่ใช้ ประกอบด้วย
• ภาษาที่ใช้ในการเขียนโปรแกรม ซึ่งขึ้นอยู่กับความถนัด ประเภทของงานและคุณสมบัติเฉพาะของเครื่องคอมพิวเตอร์
• วิธีการเก็บข้อมูลและเรียกใช้ตัวแปร เช่นการประกาศตัวแปรอาเรย์ให้สามารถเก็บข้อมูลได้หลายตัว หรือเก็บข้อมูลเป็นคลาส หรือตามโครงสร้างข้อมูลแบบต่างๆ เป็นต้น
การออกแบบโปรแกรม (Program Design) ประกอบด้วยวิธีการดังนี้ คือ
1. การออกแบบโปรแกรมโดยใช้ อัลกอริธึม (Algorithm) เป็นการอธิบายถึงลำดับขั้นตอนการทำงานของการแก้ปัญหาโดยใช้ประโยคข้อความที่ชัดเจนไม่คลุมเครือ สามารถบอกลำดับการทำงานได้ ซึ่งมีประโยชน์ดังนี้
• ทำให้เห็นลำดับของการทำงานและวิธีการทำงานแต่ละขั้นตอนได้อย่างละเอียด
• ทำให้เห็นภาพรวมของการทำงานของขั้นตอนทั้งหมด
• เป็นการวางแผนการทำงานไว้ล่วงหน้า ทำให้สามารถนำไปเขียนเป็นโปรแกรมได้อย่างถูกต้องและรวดเร็ว
2. การออกแบบโปรแกรมโดยใช้ รหัสจำลอง (Pseudo Code) เป็นการออกแบบขั้นตอนการทำงานของโปรแกรมโดยการใช้ข้อความภาษาอังกฤษที่ใกล้เคียงกับภาษาคอมพิวเตอร์ ซึ่งมีหลักการทำงานและประโยชน์เหมือนกับการใช้อัลกอริธึ่ม แต่มีข้อดี ดังนี้คือ
• สามารถนำรหัสจำลองไปใช้เขียนโปรแกรมได้ง่ายกว่าการใช้อัลกอริธึ่ม เพราะมีความใกล้เคียงกับคำสั่งคอมพิวเตอร์
• ผู้ออกแบบโปรแกรมต้องมีความรู้ทางด้านภาษาคอมพิวเตอร์บ้าง เพื่อให้สามารถนำไปประยุกต์ใช้และเขียนโปรแกรมเป็นภาษาอื่นๆได้หลายภาษา
3. การออกแบบโปรแกรมโดยใช้ ผังงาน (Flowchart) คือ การใช้สัญลักษณ์รูปภาพ หรือกล่องข้อความบรรยายรายละเอียดการทำงาน และใช้ลูกศรบอกทิศทางลำดับ ของการทำงาน ซึ่งมีข้อดีดังนี้ คือ
• สามารถอ่านและเข้าใจการทำงานได้ง่าย เพราะมองเห็นภาพรวมขั้นตอนการทำงานทั้งหมดได้ชัดเจน
• สามารถออกแบบโครงสร้างการทำงานได้หลากหลายโดยใช้ลูกศรแสดงทิศทางการทำงาน ทำให้แก้ปัญหาที่มีหลายเลือกและซับซ้อนได้
• คำสั่งหรือคำบรรยายรายละเอียดในกล่องข้อความสามารถนำไปเขียนเป็นคำสั่งของโปรแกรมได้
การเขียนโปรแกรม (Program Coding)
เป็นขั้นตอนสำคัญหลังจากได้ผ่านการออกแบบโปรแกรมแล้ว โดยการนำแนวคิดจากอัลกอริธึ่ม หรือผังงานมาแปลงให้อยู่ในรูปคำสั่งคอมพิวเตอร์ โดยอาศัยความรู้และทักษะการเขียนโปรแกรมและใช้ภาษาคอมพิวเตอร์รวมทั้งเครื่องมือช่วยในการเขียนโปรแกรมต่างๆ เพื่อให้เกิดผลลัพธ์ถุกต้อง และทำงานตามที่เราต้องการ สรุปการเขียนโปรแกรม ต้องพิจารณาองค์ประกอบดังนี้
• เลือกภาษาที่เหมาะสม
• ลงมือเขียนโปรแกรม โดยการแปลงขั้นตอนการทำงาน (ประมวลผล) ที่ได้จากการออกแบบ ให้อยู่ในรูปของคำสั่งที่ถูกต้อง ตรงตามรูปแบบของภาษาที่เลือกนั้น
การทดสอบและแก้ไขโปรแกรม ( Program Testing & Verification)
การทดสอบและแก้ไขโปรแกรม เป็นขั้นตอนการตรวจสอบโปรแกรมที่เขียนได้ ว่าทำงานถูกต้องตรงตามความต้องการของผู้ใช้ หรือตรงตามลักษณะงานของโปรแกรมนั้นหรอไม่ ความผิดพลาด ( Errors) ที่สามารถเกิดขึ้นได้จากการเขียนโปรแกรม มีดังนี้
• Syntax Error ความผิดพลาดที่เกิดจากการใช้คำสั่งผิดรูปแบบที่ภาษานั้นกำหนด เช่น การลืมประกาศตัวแปร การเขียนคำสั่งผิอด เช่น คำสั่ง while( ) เป็น WHILE( )
• Logic Error ความผิดพลาดที่เกิดจากการที่โปรแกรมทำงานผิดไปจากขั้นตอนที่ควรจะเป็น เช่น การตรวจสอบเงื่อนไขผิดไม่ตรงตามวัตถุประสงค์ คำนวณค่าได้คำตอบไม่ถูกต้อง หรือ ทำงานผิดลำดับขั้นตอน เป็นต้น
• System Design Error ความผิดพลาดที่เกิดจากการที่โปรแกรมทำงานได้ไม่ตรงตามความต้องการของลูกค้า
ขั้นตอนการทดสอบและแก้ไขโปรแกรม
• Desk-Checking ผู้เขียนโปรแกรมตรวจสอบโปรแกรมด้วยตนเอง ถ้าให้ผู้อื่นช่วยดูจะเรียกว่า Structured-Walkthrough
• Translating ตรวจสอบรูปแบบคำสั่งต่างๆที่ใช้ในโปรแกรมโดยตัวแปลภาษา ( Translator) เป็นผู้ตรวจ
• Debugging เป็นการทดลองใช้โปรแกรมจริง เพื่อค้นหาข้อบกพร่อง เช่น ผลลัพธ์ที่ไม่ตรงตามความต้องการ ซึ่งอาจมีสาเหตุจาก Logic Errors และถ้าได้ทดสอบกับผู้ใช้จริงก็จะสามารถตรวจสอบ System Design Errors ได้
การจัดทำเอกสารและคู่มือการใช้งาน (Program Documentation)
การจัดทำเอกสารและคู่มือการใช้งานจัดทำเอกสารต่างๆ ที่เกี่ยวข้องกับระบบหรือการเขียนโปรแกรม ได้แก่
• คู่มือสำหรับผู้ใช้โปรแกรม (User's Manual or User's Guide) คือเอกสารที่อธิบายวิธีการใช้ระบบหรือโปรแกรม เรียกว่า User Manual ใช้สำหรับผู้ใช้งานโปรแกรม แนะนำวิธีการใช้งานโปรแกรม แนะนำคุณสมบัติ และองค์ประกอบของโปรแกรมต่างๆ วิธีการติดตั้งโปรแกรม สามารถทำควบคู่ไปกับการเขียนโปรแกรม อาจทำเป็นคู่มือเอกสารที่อยู่ในรูปแบบโปรแกรมออนไลน์ก็ได้ (Online Manual)
• คู่มือสำหรับผู้เขียนโปรแกรม (Programmer's Manual or Programmer's Guide) เป็นคู่มือที่จัดทำขึ้น เพื่อให้ผู้พัฒนาโปรแกรม รวมทั้งเทคนิคพิเศษต่างๆ ของโปรแกรม เพื่อให้สะดวกต่อการปรับปรุงแก้ไขโปรแกรมที่มีอยู่เดิม โดยทั่วไปจะเป็นเอกสารแสดงการวิเคราะห์ และออกแบบระบบ เรียกว่า System Manual ใช้สำหรับผู้พัฒนาระบบหรือโปรแกรม เท่านั้น
การใช้งานจริง (Program Implement)
การใช้งานจริง เป็นขั้นตอนสำคัญหลังจากทำการทดสอบและแก้ไขโปรแกรมให้มีความถูกต้องเรียบร้อยแล้ว โดยการนำโปรแกรมไปใช้งานจริงด้วยการป้อนข้อมูลต่างๆ สภาวะแวดล้อม และสถานการณ์ต่างๆโดยผู้ใช้งานโปรแกรมสามารถทำงานตามฟังก์ชั่น และทำตามจุดประสงค์ของโปรแกรมที่เขียนไว้ ขั้นตอนการใช้งานจริงของโปรแกรมหากพบข้อผิดพลาด ก็สามารถปรับปรุง แก้ไข โปรแกรมให้ถูกต้องได้
การปรับปรุงและพัฒนาโปรแกรม (Program Maintenance)
การเขียนโปรแกรมที่ดีต้องมีขั้นตอนการปรับปรุงและพัฒนาโปรแกรมให้มีความถูกต้อง ทันสมัย และตรงกับความต้องการของผู้ใช้มากที่สุด โดยทั่วไปโปรแกรมที่ใช้งานจะประกอบด้วยหลายๆรุ่น เช่นรุ่นทดสอบ (Beta Version) และ รุ่นที่ใช้งานจริง (Release Version) และต้องมีการปรับเปลี่ยนโปรแกรมให้ดีขึ้น ดังตัวอย่างเช่นโปรแกรมเวอร์ชัน 1 มีการเพิ่มเติม ปรับปรุง แก้ไขโปรแกรมเป็นเวอร์ชัน 1.2 เป็นต้นการพัฒนาโปรแกรมให้ดีขึ้นมีประโยชน์ต่อผู้ใช้งาน และผู้เขียนโปรแกรมต้องอาศัยคู่มือการใช้งาน และเอกสารประกอบของโปรแกรม เพื่อเป็นแนวทางในการแก้ไข และให้ผู้อื่นๆสามารถพัฒนาต่อได้
|
| |
| การออกแบบการเขียนโปรแกรม |
| |
การออกแบบโปรแกรม เป็นการแสดงลำดับของการทำงานของโปรแกรม เพื่อให้เห็นภาพรวมของการทำงานของขั้นตอนทั้งหมด และเป็นการวางแผนการทำงานไว้ล่วงหน้า สามารถใช้วิธีการต่างๆได้ดังนี้
• การออกแบบโปรแกรมโดยใช้ อัลกอริธึม (Algorithm)
• การออกแบบโปรแกรมโดยใช้ รหัสจำลอง (Pseudo Code)
• การออกแบบโปรแกรมโดยใช้ ผังงาน (Flowchart)
โดยทั่วไปผู้เขียนโปรแกรมจะแสดงการทำงานของโปรแกรมโดยการใช้ผังงาน (Flowchart) ซึ่งสามารถอ่านและเข้าใจการทำงานได้ง่าย ช่วยให้เขียนโปรแกรม การตรวจสอบ และแก้ไขโปรแกรมสะดวกรวดเร็วขึ้น
ผังงาน ( Flowchart) คือ รูปภาพหรือสัญลักษณ์ ที่ใช้เขียนแทนคำอธิบาย ข้อความ หรือคำพูดที่ใช้ในอัลกอริทึม เพราะการที่จะเข้าใจขั้นตอนได้ง่ายและตรงกันนั้น การใช้คำพูดหรือข้อความอาจทำได้ยากกว่าการใช้รูปภาพหรือสัญลักษณ์ ผังงานสามารถแบ่งได้เป็น 2 ประเภทใหญ่ ๆ คือ
1. ผังงานระบบ ( System Flowchart) เป็นผังงานที่แสดงขั้นตอนการทำงานในระบบงานหนึ่ง ๆ ในลักษณะของภาพกว้าง ๆ แต่จะไม่เจาะลึกลงไปว่าในระบบงานย่อย ๆ นั้นจะมีการทำงานหรือวิธีการทำงานอย่างไร ผังงานจะแสดงทิศทางการทำงานในระบบ ตั้งแต่เริ่มต้นว่าข้อมูลเกิดขึ้นครั้งแรกที่ใด เก็บอยู่ในรูปแบบใด และผ่านขึ้นตอนการประมวลผลอย่างไร อะไรบ้าง (แต่จะไม่เน้นถึงวิธีการประมวลผล) จนสุดท้ายผลลัพธ์ที่ได้เก็บอยู่ในรูปแบบใด
ตัวอย่างเช่น ผังงานระบบบริหารโรงเรียนแห่งหนึ่ง ข้อมูลทะเบียนประวัติของนักเรียนจะเริ่มขึ้นครั้งแรกเมื่อมีการับสมัครนักศึกษาใหม่ จากแผนกรับสมัคร และถือว่าเป็นข้อมูลพื้นฐานไปยังแผนกต่าง ๆ ในโรงเรียน เช่น แผนกปกครอง แผนกวัดผล หรือแผนกทะเบียน ซึ่งในส่วนของแผนกทะเบียนอาจจะมีการแก้ไขข้อมูลบางอย่าง เช่น มีการแก้ไขชื่อ ที่อยู่ของนักศึกษา ก็ได้
2. ผังงานโปรแกรม ( Program Flowchart) เป็นผังงานที่แสดงถึงขั้นตอนในการทำงานของโปรแกรม ซึ่งจะแสดงการทำงานตั้งแต่เริ่มต้น ในส่วนของการรับข้อมูล การคำนวณหรือการประมวลผล จนถึงการแสดงผลลัพธ์ ผังงานนี้อาจสร้างจากผังงานระบบ โดยผู้เขียนผังงานอาจดึงเอาแต่ละจุดที่เกี่ยวข้องกับการทำงานของคอมพิวเตอร์เพื่อนำมาวิเคราะห์ว่า ถ้าใช้คอมพิวเตอร์ทำงานตรงจุดนั้นเพื่อให้ได้ผลลัพธ์ตามต้องการ ควรจะมีขั้นตอนในการเขียนผังงานอย่างไร เพื่อให้คอมพิวเตอร์ทำงาน ซึ่งการเขียนผังงานนี้จะช่วยเพิ่มความสะดวกในการเขียนโปรแกรมของผู้เขียนโปรแกรมได้มาก เพราะสามารถดูได้ง่ายว่าในแต่ละขั้นตอนการทำงานควรใช้คำสั่งอย่างไร
ประโยชน์ของผังงานโปรแกรม
• ทำให้เข้าใจและแยกแยะปัญหาต่าง ๆ ได้ง่ายขึ้น
• ผู้เขียนโปรแกรมมองเห็นลำดับการทำงาน รู้ว่าสิ่งใดควรทำก่อน สิ่งใดควรทำหลัง
• สามารถหาข้อผิดพลาดของโปรแกรมได้ง่าย
• ทำให้ผู้อื่นเข้าใจการทำงานได้ง่ายกว่าการดูจาก source code
• ไม่ขึ้นกับภาษาคอมพิวเตอร์ภาษาใดภาษาหนึ่ง ผู้อื่นสามารถเรียนรู้และเข้าใจได้ง่าย
ข้อจำกัดของผังงาน ผู้เขียนโปรแกรมบางคนไม่นิยมเขียนผังงานก่อนการเขียนโปรแกรม เพราะเห็นว่าเสียเวลา นอกจากนี้แล้ว ยังมีข้อจำกัดอื่น ๆ อีก คือ
• ผังงานเป็นการสื่อความหมายระหว่างบุคคลกับบุคคลมากกว่าที่สื่อความหมายระหว่างบุคคลกับเครื่อง เพราะผังงานไม่ขึ้นกับภาษาคอมพิวเตอร์ภาษาใดภาษาหนึ่ง ทำให้เครื่องไม่สามารถรับและเข้าใจได้ว่าในผังงานนั้นต้องการให้ทำอะไร
• ในบางครั้ง เมื่อพิจารณาจากผังงาน จะไม่สามารถทราบได้ว่า ขั้นตอนการทำงานใดสำคัญกว่ากัน เพราะทุก ๆ ขั้นตอนจะใช้รูปภาพหรือสัญลักษณ์ในลักษณะเดียวกัน
การเขียนผังงานเป็นการสิ้นเปลือง เพราะจะต้องใช้กระดาษและอุปกรณ์อื่น ๆ เพื่อประกอบการเขียนภาพ ซึ่งไม่สามารถเขียนด้วยมืออย่างเดียวได้ และในบางครั้ง การเขียนผังงานอาจจะต้องใช้กระดาษมากกว่า 1 แผ่น หรือ 1 หน้า ซึ่งถ้าเป็นข้อความอธิบายอาจะใช้เพียง 2-3 บรรทัดเท่านั้น
| ผังงาน |
| |
เป็นเครื่องมือในการอธิบายลอจิกของวิธีการประมวลผล เป็นเครื่องชนิดหนึ่งที่นิยมสำหรับนักเขียนโปรแกรม การนำผังงานมาแสดงลำดับขั้นตอนการทำงานของชุดคำสั่ง เป็นการแสดงจากระดับสู่ระดับล่าง ขั้นตอนต่างๆจะแสดงด้วยภาพสัญลักษณ์กำหนดสามารถอธิบายขั้นตอนการทำงานได้ดี เพราะว่าการใช้สัญลักษณ์ต่างๆสามารถเข้าใจได้ง่ายมีการอธิบายการทำงานตามทิศทางของลูกศร ทำให้เข้าใจการไหลเวียนของข้อมูล เช่น การทำงานอย่างต่อเนื่องหรือการกระโดดข้าม เป็นต้นนอกจากนี้เครื่องมือชนิดนี้ยังใช้ใน การออกแบบโครงสร้างมีคุณสมบัติที่มีการเข้าทางเดียวออกทางเดียว สัญลักษณ์ที่ในการเขียนผังงานมีดังต่อไปนี้
สัญลักษณ์ที่ใช้ในการเขียนผังงานโปรแกรม
ผังงานโปรแกรมประกอบด้วยสัญลักษณ์ที่ใช้แทนขั้นตอนการทำงานของโปรแกรม ซึ่งสัญลักษณ์ต่างๆมีความหมายเฉพาะและเป็นมาตรฐาน นอกจากนั้นผังงานยังมีองค์ประกอบของเส้นสายและลูกศร เพื่อแสดงการเชื่อมโยงการทำงาน ลำดับ และทิศทางการเชื่อมโยงระหว่างข้อมูลต่างๆ แบ่งกลุ่งสัญลักษณ์ของผังงานโปรแกรมออกเป็น 4 กลุ่ม ดังนี้
กลุ่มสัญลักษณ์ในการรับส่งและเก็บข้อมูล
สัญลักษณ์
|
ความหมาย
|
Terminal
| - การเริ่มต้นโปรแกรม
- การหยุดชั่วขณะ
- การสิ้นสุดโปรแกรม |
Input / Output
| การรับส่งข้อมูลโดยไม่เจาะจงตัวกลางที่ใช้ |
Manual Input
| การรับส่งข้อมูลโดยใช้แป้นพิมพ์ (Keyboard) |
Punched Card  | การรับส่งข้อมูลโดยใช้บัตรเจาะรู (Punch Card) |
Punched Tape  | การรับส่งข้อมูลทางเทปกระดาษ (Punch Tape) |
Magnetic Tape  | การรับส่งข้อมูลโดยใช้เทปแม่เหล็ก (Magnetic Tape) |
Magnetic Disk  | การรับส่งข้อมูลโดยใช้แผ่นจานแม่เหล็ก (Magnetic Disk) |
Store Data  | แสดงการเก็บข้อมูล |
Delay
| แสดงการหน่วงเวลาการประมวลผล (Delay) |
กลุ่มสัญลักษณ์ในการเชื่อมต่อข้อมูล
สัญลักษณ์
|
ความหมาย
|
Off-page Connector  | การแสดงจุดต่อเนื่องที่อยู่คนละหน้ากระดาษ (Off-page Connector) ใช้เชื่อมต่อส่วนของผังงานจากกระดาษแผ่นหนึ่งไปสู่อีกแผ่นหนึ่ง |
Connector
| การแสดงจุดต่อเนื่อง (Connector) ใช้เชื่อมต่อส่วนประกอบต่างๆของผังงานที่อยู่หน้ากระดาษเดียวกัน |
Arrow  | ลุกศรแสดงทิศทางของข้อมูลและการประมวลผล (Arrow or Flowline) |
Summing Junction  | การแสดงจุดต่อร่วมแสดงการรวมข้อมูล (Summing) |
กลุ่มสัญลักษณ์ในการประมวลผลข้อมูล
สัญลักษณ์
|
ความหมาย
|
Process  | - การประมวลผลข้อมูลอัตโนมัติ
- การกำหนดค่าข้อมูล |
Alternate Process  | การประมวลผลข้อมูล |
Manual Operation
| การประมวลผลข้อมูลด้วยมือ (manual Operation) |
External Subroutine  | การประมวลผลข้อมูลด้วยโปรแกรมย่อยที่อยู่ภายนอกโปรแกรมหลัก (External Subroutine) |
Internal Subroutine  | การประมวลผลข้อมูลด้วยโปรแกรมย่อยที่อยู่ภายในโปรแกรมหลัก (Internal Subroutine) |
Preparation
| การเตรียมข้อมูล (Preparation) ใช้กำหนดชื่อและรูปแบบของข้อมูล |
Decision
| การตัดสินใจ (Internal Subroutine) |
กลุ่มสัญลักษณ์ในการแสดงผลข้อมูล
สัญลักษณ์
|
ความหมาย
|
Display
| การนำข้อมูลออกทางจอภาพ (Monitor) |
Document  | การนำข้อมูลแกทางกระดาษในรูปของเอกสาร (Document) |
ประเภทของผังงานโปรแกรม
การเขียนผังงาน หมายถึงการเขียนภาพแสดงลำดับขั้นตอนการทำงาน แบ่งออก เป็น 2 ประเภทใหญ่ คือ ผังงานระบบ ( System Flowchart) และผังงานโปรแกรม ( Program Flowchart) ผังระบบงาน คือ ผังแสดงการทำงานของระบบในภาพรวม มีความหมายถึงแสดงการ ทำงานของระบบทั้งหมด ตั้งแต่จุดเริ่มต้นของระบบงาน กิจกรรมระหว่างการทำงาน การส่งผ่านของข้อมูลในกิจกรรมต่างๆ เพื่อจะเป็นแนวทางในการนำไปเขียนผังโปรแกรมผังโปรแกรม หมายถึง ภาพแสดงรายละเอียดการทำงานของโปรแกรม ตั้งแต่จุดเริ่มต้นในการรับข้อมูล การประมวลผลข้อมูล การแสดงผลลัพธ์ของข้อมูล เพื่อเป็นแนวทางให้นักเขียนโปรแกรมนำไปลงรหัสคำสั่งให้คอมพิวเตอร์ทำงานตามความต้องการของผังงาน ( Flowchart) ใช้มาตรฐานที่พัฒนาโดย ANSI (American National Standard Institute) การออกแบบโปรแกรมโครงสร้าง จะมีโครงสร้างการควบคุม 3 แบบที่ใช้ในโปรแกรมลอจิก เช่น การเรียงลำดับ ( Sequential ) การเลือก ( Selection ) และการทำงานซ้ำ ( Iteration) โครงสร้างทั้ง 3 แบบเป็นการควบคุมลอจิกของโปรแกรมคอมพิวเตอร์
โครงสร้างการควบคุมแบบเรียงลำดับ ( Sequence Control Structure)
โครงสร้างการควบคุมแบบนี้เป็นการเรียงลำดับของการประมวลผลที่แต่ละบล็อค ที่เรียงลำดับนั้นเป็นการประมวลผลของคอมพิวเตอร์
โครงสร้างการควบคุมแบบเลือก ( Selection Control Structure)
เป็นโครงสร้างที่มีการกำหนดทิศทางการเลือกทางเดินของการทำงานตามเงื่อนไขที่ต้องการว่าเป็นค่าจริงหรือค่าเท็จ การทำงานใน แต่ละทางจะแตกต่างกัน เป็นโครงสร้างแบบ If - Else หรือ ถ้ามีทางเลือกจำนวนมากจะเป็นโครงสร้างแบบ Switch - Case
โครงสร้างแบบซ้ำ ( Iteration Control Structure)
เป็นโครงสร้างที่แสดงการทำงานตามเงื่อนไขแบบ While หรือ Do - While โครงสร้างแบบ While ถ้าเงื่อนไขเป็นจริงมันจะทำงานซ้ำอีกโดยย้อนกลับไปตรวจสอบเงื่อนไขใหม่ ถ้าเงื่อนไขเป็นจริงมันก็จะทำงานใหม่อีก แต่ถ้าเป็นเท็จจะสิ้นสุดการทำงาน กรณีของโครงสร้างแบบ Do - While การทำงานจะทำอย่างน้อย 1 ครั้ง ตามเงื่อนไขที่กำหนดว่าเป็นจริงจะย้อนกลับไปทำงานใหม่ความสำคัญของการกำหนดโครงสร้างจะเห็นว่ามีทางเข้าทางเดียว และมีทางออกทางเดียวหมายความว่าโครงสร้างทั้ง 3 ชนิด จะมีทางเข้าทางเดียวและทางออกทางเดียว
| ตัวอย่างของการเขียนผังงาน |
| |
โจทย์ : จงเขียนโปรแกรมคำนวณคะแนนของนิสิต โดยกำหนดให้มีการรับชื่อนิสิต คะแนนกลางภาค (Midterm) คะแนนปลายภาค (Final) และคะแนนสอบย่อย (Test) โดยรับข้อมูลทางแป้นพิมพ์
ข้อกำหนดของโปรแกรม
เกณฑ์การตัดเกรด คะแนนมากกว่า 80 ได้เกรด A
คะแนนอยู่ระหว่าง 70 - 80 ได้เกรด B
คะแนนอยู่ระหว่าง 60 - 69 ได้เกรด C
คะแนนอยู่ระหว่าง 50 - 59 ได้เกรด D
คะแนนน้อยกว่า 50 ได้เกรด F
ขั้นตอนการทำงาน
1. สิ่งที่ต้องการจากระบบ คือ คำนวณเกรดโดยหาได้จาก ผลรวม ของ สอบกลางภาค+ปลายภาค+สอบย่อย แล้วตัดเกรดตามเงื่อนไขที่กำหนด
2. รูปแบบผลลัพธ์ที่ต้องการ คือ Name your grade is X
3. ข้อมูลเข้า ชื่อ , สอบกลางภาค , ปลายภาค , สอบย่อย
4. ตัวแปรที่ใช้
Name = ชื่อ Grade = เกรด ,
Total = ผลรวม Mid = สอบกลางภาค ,Final = ปลายภาค Test= สอบย่อย ,
5. วิธีการประมวลผล
5.1) รับข้อมูล Name, Mid, Final, Test
5.2) ประมวลผล Total = Mid+ Final+ Test
5.3) ถ้า Total > 80 และ Total <= 100, Grade = “A”
ถ้า Total > 70 และ Total <=80, Grade = “B”
ถ้า Total > 60 และ Total <= 70, Grade = “C”
ถ้า Total > 50 และ Total <= 60, Grade = “D”
ถ้า Total > 0 และ Total <= 50 , Grade = “F”
5.4) พิมพ์ Name, “your grade is “, Grade
5.5) จบการทำงาน
ผังงานโปรแกรม
| หน่วยที่ 3 แนะนำการเขียนโปรแกรมของภาษา java |
|
|
|
|
| ภาษา Java |
| |
Java เป็นภาษาโปรแกรมที่ใช้ในการเขียนคำสั่งสั่งงานคอมพิวเตอร์ ซึ่งพัฒนาขึ้นโดยบริษัท ซันไมโครซิสเต็มส์ จำกัด (Sun Microsystems Inc.) ในปี ค.ศ. 1991
เป็นส่วนหนึ่งของโครงการวิจัยเพื่อพัฒนาซอฟต์แวร์ สำหรับอุปกรณ์อิเล็กทรอนิคส์ต่างๆ เช่น โทรทัศน์ โทรศัพท์มือถือ โดยมีเป้าหมายการทำงานเชื่อมต่อกับอุปกรณ์ฮาร์ดแวร์ต่างๆได้อย่างกว้างขวาง และมีประสิทธิภาพ ใช้เวลาน้อย รวดเร็วในการพัฒนาโปรแกรม และสามารถเชื่อมต่อไปยังแพล็ตฟอร์ม (Platform) อื่นๆได้ง่าย Java เป็นภาษาสำหรับเขียนโปรแกรมภาษาหนึ่งที่มีลักษณะสนับสนุนการเขียนโปรแกรมเชิงวัตถุ (OOP : Object-Oriented Programming) ที่ชัดเจน โปรแกรมต่าง ๆ ถูกสร้างภายในคลาส (Class) โปรแกรมเหล่านั้นเรียกว่า Method หรือ Behavior โดยปกติจะเรียกแต่ละ Class ว่า Object โดยแต่ละ Object มีพฤติกรรมมากมาย โปรแกรมที่สมบูรณ์จะเกิดจากหลาย object หรือหลาย Class มารวมกัน โดยแต่ละ Class จะมี Method หรือ Behavior แตกต่างกันไป
| ข้อดีของภาษา Java |
| |
1. ภาษา Java เป็นภาษาโปรแกรมที่ง่ายในการเรียนรู้ ภาษา Java มีคุณลักษณะต่างๆ ดังนี้ เช่น เชื่อมต่อข้ามแพล็ตฟอร์ม (Platforms) ต่างๆ ได้ สามารถเขียนโปรแกรมแบบ OOP (Object-Oriented Programming) ได้งายมาก โปรแกรมมีขนาดเล็ก และมีวิธีการเขียนไม่ยุงยากซับซ้อน ดังนั้นโปรแกรมที่เขียนด้วยภาษา Java จึงคอมไพล์ได้ง่ายตลอดจนตรวจสอบหาข้อผิดพลาดโปรแกรมได้ง่ายด้วย ภาษา java เป็นภาษาที่ทำความเข้าใจได้ง่ายมาก มีขนาดเล็กและยากที่จะเกิดข้อผิดพลาด เขียนคำสั่งได้ง่าย มีประสิทธิภาพในการทำงานและมีความยืดหยุ่นสูง
2. ภาษา Java เป็นการเขียนโปรแกรมเชิงวัตถุ OOP (Object-Oriented Programming) การเขียนโปรแกรมเชิงวัตถุ เป็นเทคนิคการเขียนโปรแกรมให้มีลักษณะเป็นโมดูล (Module) แบ่งโปรแกรมเป็นส่วนๆ ตามสภาวะแวดล้อมการทำงานของโปรแกรมซึ่งเรียกว่า Method โดยทุก Method ก็คือ ระเบียบวิธี หรือการทำงานอย่างใดอย่างหนึ่ง โดยจะถูกรวบรวมอยู่ในคลาส ซึ่งหลักการเขียนโปรแกรมเชิงวัตถุจะมององค์ประกอบของโปรแกรมต่างๆเป็นคลาสหรือวัตถุ เรียกว่า Object ตัวอย่าง เช่น วัตถุที่มองเห็นได้ เช่น รถ สินค้า หรือ วัตถุที่ไม่สามารถมองเห็นได้ เช่น เหตุการณ์ต่างๆ ข้อมูลต่างๆของ Object จะถูกซ่อนไว้คลาสเรียกว่า Data Encapsulation ซึ่งมีประโยชน์ในการแก้ไขข้อมูลหรือ Method ใดๆ ที่อยู่ในคลาส โดยไม่ส่งผลกระทบต่อการทำงานหรือเรียกใช้งานของ Object นั้น
นอกจากนั้น Java ยังมีคุณสมบัติการสืบทอด (Inheritance) เพื่อส่งผ่านและถ่ายทอดลักษณะต่างๆ ของคลาสแม่ไปยังคลาสลูก ทำให้เขียนโปรแกรมได้ง่ายขึ้น และมีโครงสร้างการทำงานที่เข้าใจง่ายและมีความสัมพันธ์กัน
3. ภาษา Java เป็นอิสระต่อแพล็ตฟอร์ม (Java is Platform-Independent)Java เป็นอิสระต่อแพล็ตฟอร์ม ทั้งระดับซอร์ซโค้ด (Source Code) และไบนารีโค้ด (Binary Code) ช่วยให้สามารถเคลื่อนย้ายโปรแกรมจากระบบคอมพิวเตอร์หนึ่งไปยังระบบคอมพิวเตอร์อื่นได้อย่างง่ายดาย เพราะว่าโปรแกรมที่เขียนด้วยภาษา Java ได้รวบรวมคำสั่งต่างๆไว้ในไลบรารีคลาสพื้นฐานต่างๆ เป็น Java Packages ช่วยอำนวยความสะดวกในการเขียนคำสั่ง เมื่อย้ายโปรแกรมไปยังแพล็ตฟอร์มอื่น โดยไม่ต้องเขียนซอร์ซโค้ด (Source Code) ขึ้นใหม่ทำให้ประหยัดเวลามาก เมื่อคอมไพล์ซอร์ซโค้ด จะได้ไฟล์ไบนารีโค้ด ที่เรียกว่า Bytecode การรันโปรแกรมของ Java จะทำงานในลักษณะอินเทอร์พรีเตอร์ (Interpreter) ของไฟล์ Bytecode ซึ่งสามารถรันบนแพล็ตฟอร์มใดๆ ก็ได้ รวมทั้งระบบปฏิบัติการต่างๆ เช่น ระบบ Windows, Solaris, Linux หรือ MacOS โดยการแปลคำสั่งทีละคำสั่ง แพล็ตฟอร์มที่ Java ทำงานได้จะต้องประกอบด้วย 2 ส่วน คือ Java Virtual Machine (JVM) และ Java Application Programming Interface (Java API) โดย Java Virtual Machine คือเครื่องมือที่รวบรวมคำสั่งคอมไฟล์และรันโปรแกรม Java ส่วน Java API เป็นกลุ่มของคลาส และอินเตอร์เฟส (Interface) ที่รวมอยู่ในไลบรารีที่เรียกว่า Java Package เช่น java.awt, java.util หรือ java.io เป็นต้น ลักษณะการทำงานของ Java ที่เป็นอิสระต่อแพล็ตฟอร์มโดยการเขียนโปรแกรมเพียงครั้งเดียวแต่สามารถนำไปใช้ทำงานยังเครื่องอื่นๆ ได้ นั้นเรียกว่า Write once, Run anywhere นั้นเอง
4. ภาษา Java มีระบบการทำงานและมีระบบความปลอดภัยที่ดี Java จะคำสั่งต่างๆที่เป็นส่วนประกอบของ Java API โดยมีการรวบรวมเป็นคลาสต่างๆไว้มากมาย ช่วยอำนวยความสะดวกในการเขียนโปรแกรม นอกจากนั้นยังมี Garbage Collector โดยมีระบบจัดการหน่วยความจำเพื่อเก็บขยะของโปรแกรมและคืนหน่วยความจำให้กับระบบ โปรแกรมที่เขียนด้วยภาษา Java มีระบบจัดการข้อผิดพลาดที่เกิดจากการทำงานของโปรแกรมที่เรียกว่า Exception Handling ด้วยทำให้สามารถตรวจสอบโปรแกรม (Debug) โปรแกรมได้ง่ายขึ้น Java มีระบบความปลอดภัยที่ดี เช่น โปรแกรม Java ที่ทำงานบนเว็บบราวเซอร์ (Web Browser) ที่เรียกว่า Java Applet นั้นจะทำงานเฉพาะบนเครื่องแม่ข่าย (Server) โดยไม่สามารถเข้าถึงเครื่องลูกข่าย (Client) ไปทำลายไฟล์ หรือไฟล์ระบบ (System file) ได้ ทำให้มีระบบความปลอดภัยที่ดี ป้องกันข้อมูลจากไวรัส และโปรแกรมที่เขียนด้วย Java ไม่มีพฤติกรรมเป็นไวรัส ได้
| เครื่องมือที่ใช้ในการพัฒนาโปรแกรม |
| |
เครื่องคอมพิวเตอร์ที่ใช้ในการเขียนโปรแกรมด้วยภาษา Java จะต้องมีโปรแกรมที่รวมคำสั่งต่างๆ ให้สามารถคอมไฟล์ และรันโปรแกรมได้ที่เรียกว่า Java Virtual Machine ซึ่งเป็นเครื่องมือที่ช่วยในการเขียน และพัฒนาโปรแกรม Java Virtual Machine จะอยู่ในโปรแกรมชุดพัฒนาจาวาที่เรียกว่า JDK (Java Development Kit) เป็นลิขสิทธิ์ของบริษัท Sun Microsystems ที่ใช้บริการฟรีบนอินเตอร์เน็ต ซึ่งประกอบด้วยคำสั่งต่างๆ และเครื่องมือที่ใช้ในการคอมไพล์ และรันโปรแกรมที่เขียนด้วยภาษา Java โดยการดาวน์โหลด (Download) โปรแกรมชุดพัฒนาจาวา JDK ได้ที่เว็บไซต์ www.java.sun.com ซึ่งจะมีโปรแกรม JDK เวอร์ชันใหม่ตลอดเวลา และเลือกระบบปฏิบัติการที่ต้องการใช้ หลังจากนั้นได้ทำการติดตั้ง และลงโปรแกรมให้เรียบร้อย เครื่องมือ และคำสั่งที่ใช้ในการสร้างโปรแกรม Java จะถูกเก็บไว้ในโฟลเดอร์ของ Java ที่ชื่อ bin เช่น C:\java\bin เป็นต้น ประกอบด้วยคำสั่งที่สำคัญดังนี้
ไฟล์
|
คำอธิบาย
|
| javac.exe | คอมไพล์เลอร์ (Compiler) ของ Java เป็นคำสั่งที่ใช้คอมไฟล์ ตรวจสอบไวยากรณ์ของโปรแกรมโดยการแปลงไฟล์ซอร์สโค้ด ให้เป็นไฟล์ไบต์โค้ดที่เป็นคลาสของโปรแกรม |
| java.exe | อินเตอร์พรีเตอร์ (Interpreter) ของ Java เป็นคำสั่งที่ใช้ในการรันไฟล์ไบต์โค้ดที่คอมไพล์ แล้วให้ทำงานตามคำสั่งของโปรแกรม |
| appletviewer.exe | Applet Viewer เป็นคำสั่งที่ใช้ทดสอบและรันโปรแกรมแอปเพล็ต |
| javadoc.exe | ผลิตเอกสารของคำสั่ง API ใช้สร้างเอกสารของ Java API ในรูปแบบของ HTML จาก
ซอร์สโค้ดของ Java |
| javap.exe | การแยกและถอดไฟล์ของ Java และพิมพ์ออกมาเป็นตัวแทนของไบต์โค้ด (Bytecode) |
| jdb.exe | ดีบักเกอร์(Debugger) ของ Java ใช้ในการตรวจสอบข้อผิดพลาดในโปรแกรมพร้อมรายงานข้อผิดพลาดที่เกิดขึ้น
| ขั้นตอนการเขียนโปรแกรม ด้วย Java |
| |
การเขียนโปรแกรมด้วยภาษา Java ประกอบด้วยขั้นตอนการทำงานทั้งหมด 3 ขั้นตอน ดังนี้
ขั้นตอนที่ 1 สร้างโปรแกรมซอร์สโค้ด โดยการพิมพ์คำสั่งต่างๆ ตามหลักการเขียนโปรแกรมด้วยภาษา Java โดยใช้เอดิเตอร์ (Editor) หรือโปรแกรมที่สามารถพิมพ์ข้อความ (Text Editor) และสามารถบันทึกไฟล์เป็นรหัสแอสกี (ASCII) ได้ เช่น โปรแกรม Notepad หรือ โปรแกรม Editplus เป็นต้น หลังจากเขียนโปรแกรมเสร็จเรียบร้อยแล้ว ต้องทำการบันทึกข้อมูลเป็นไฟล์ที่มีชื่อเดียวกันกับชื่อคลาสของ Java และใช้นามสกุลไฟล์เป็น java ตัวอย่างเช่น TestJava.java
ขั้นตอนที่ 2 คอมไพล์โปรแกรมซอร์สโค้ด โดยการใช้คำสั่ง javac.exe ที่มากับการติดตั้ง JDK แล้ว มีรูปแบบคำสั่ง คือ javac FileName.java เมื่อ FileName.java คือ ชื่อไฟล์ใดๆ ที่มีนามสกุล java ถ้าไม่มีข้อผิดพลาดใดๆ ผลลัพธ์ที่ได้จากการคอมไพล์ จะได้ไฟล์ไบต์โค้ดที่ชื่อเดียวกับชื่อคลาส ตัวอย่างเช่น javac TestJava.java หลังจากการคอมไพล์จะได้ไฟล์ TestJava.class ข้อสำคัญในการคอมไพล์ไฟล์ซอร์สโค้ด คือต้องพิมพ์ชื่อไฟล์พร้อมนามสกุลเป็น java เสมอ และต้องพิมพ์ชื่อไฟล์ด้วยตัวอักษรตัวใหญ่หรืตัวเล็กให้ถูกต้องตามการตั้งชื่อคลาส
ขั้นตอนที่ 3 ทำการรันโปรแกรม เพื่อดูผลลัพธ์ทางจอภาพโดยการรันไฟล์ไบต์โค้ด โดยการใช้คำสั่ง javac.exe ที่มากับการติดตั้ง JDK แล้วซึ่งมีรูปแบบคำสั่งคือ java FileName เมื่อ FileName คือ ชื่อไฟล์ใดๆ ไม่ต้องมีนามสกุล
ดังนั้นการรันโปรแกรมเพียงแค่พิมพ์ชื่อไฟล์ไม่ต้องพิมพ์นามสกุลของไฟล์ และต้องพิมพ์ชื่อไฟล์ด้วยตัวอักษรตัวใหญ่หรืตัวเล็กให้ถูกต้องตามชื่อคลาส ตัวอย่างเช่น java TestJava เมื่อ TestJava คือชื่อไฟล์ TeatJava.class
ดังนั้นสิ่งที่ต้องคำนึงก่อนเขียนโปรแกรมด้วยภาษา Java จะต้องทำขั้นตอนดังนี้
1. ต้องตรวจสอบว่าในเครื่องคอมพิวเตอร์มี JDK (Java Development Kit) และโปรแกรมที่ใช้เขียนซอร์สโค้ด (SourceCode) เช่น โปรแกรม Notepad, โปรแกรม Editplus หรือไม่ ถ้าไม่มีโปรแกรมข้างต้น ต้องทำการติดตั้ง และลงโปรแกรมดังกล่าวให้เรียบร้อยก่อน
2. ตรวจสอบโฟลเดอร์และไฟล์ของ JDK ที่ใช้ในการคอมไพล์ (compile) คือ javac.exe และรันโปรแกรม (run) คือ java.exe ตัวอย่าง โฟลเดอร์ของไฟล์ java เช่น C:\j2sdk1.4.1_03\bin
3. ทำการติดตั้งและแก้ไขโปรแกรม (Config) เครื่องมือในการเขียนโปรแกรม ด้วยโปรแกรม Editplus ได้ดังนี้
1. ไปทีเมนู Tools เลือก Preferences หรือไปทีเมนู Tools เลือก Configure User Tools…
2. ไปที่เมนู Tools เลือก User Tool Groups ไปที่ View เลือก Toolbars/Views เลือก User Toolbar
|
| 3. สร้างโฟลเดอร์ เพื่อบันทึกไฟล์ซอร์สโค้ด เช่น D:\work
4. เลือก Directory ในโปรแกรม Editplus ให้ถูกต้องเพื่อใช้อ้างอิงในการรันโปรแกรม
5. ทดสอบโปรแกรม Java โดย ไปที่เมนู File -> New -> Java
5.1 ตั้งชื่อ Class เช่น TestJava
5.2 บันทึกไฟล์ชื่อเดียวกับชื่อ Class เช่น TestJava.java
5.3 เลือก Tools->Compile
5.4 เลือก Tools->Run
| ตัวอย่างการเขียนโปรแกรมด้วย Java |
| |
ตัวอย่างแรกของการเขียนโปรแกรมด้วย Java จะเป็นตัวอย่างที่เขียนด้วยคำสั่งง่ายๆ คือ โปรแกรมที่แสดงข้อความ “Hello World!” ออกทางจอภาพ ดังตัวอย่างไฟล์ TestJava.java
class TestJava
{
public static void main(String[] args)
{
System.out.println("Hello World!");
}
}
ไฟล์ TestJava.java มีหลักการเขียนโปรแกรม ดังคำอธิบายต่อไปนี้
1. โปรแกรมทั้งหมดจะเขียนอยู่ภายในคลาส (Class) ที่ชื่อ TestJava เพียงคลาสเดียว
2. ภายในคลาสจะประกอบด้วยฟังก์ชัน(Method) ที่ชื่อ main ซึ่งทำหน้าที่เป็นฟังก์ชันหลักในการสั่งในโปรแกรมทำงาน
3. ภายในฟังก์ชัน main จะประกอบด้วยคำสั่งต่างๆ ที่ต้องการเขียนโปรแกรมด้วย Java เช่น System.out.println("Hello World!");
|
|
|
| การแสดงผลทางจอภาพ |
| |
คำสั่งที่ใช้ในการแสดงผลข้อมูลออกทางจอภาพ ได้แก่
1. คำสั่ง System.out.print() คือคำสั่งในการแสดงข้อความทางจอภาพในบรรทัดที่เคอ
เซอร์อยู่โดยไม่มีการขึ้นบรรทัดใหม่ มีรูปแบบการใช้งาน ดังนี้
รูปแบบคำสั่ง
System.out.print(String text);
System.out.print(int x);
System.out.print(char ch);
เมื่อ
text คือข้อความที่ต้องการแสดงผลทางจอภาพอยู่ในเครื่องหมายคำพูด (“ … ”)
x คือตัวเลขที่ต้องการแสดงผลทางจอภาพอยู่ในเครื่องหมายคำพูด (“ … ”)
ch คือตัวอักขระที่ต้องการแสดงผลทางจอภาพอยู่ในเครื่องหมาย ‘ และ ’
ตัวอย่างเช่น
System.out.print("Hello World!");
System.out.print(2500);
System.out.print(‘A’);
ผลลัพธ์ทางจอภาพ
Hello World!2500A
2. คำสั่ง System.out.println() คือคำสั่งในการแสดงข้อความทางจอภาพแล้วขึ้น
บรรทัดใหม่ มีรูปแบบการใช้งาน ดังนี้
รูปแบบคำสั่ง
System.out.println();
System.out.println(String text);
System.out.println(int x);
System.out.println(char ch);
เมื่อ
text คือข้อความที่ต้องการแสดงผลทางจอภาพอยู่ในเครื่องหมายคำพูด (“ … ”)
x คือตัวเลขที่ต้องการแสดงผลทางจอภาพอยู่ในเครื่องหมายคำพูด (“ … ”)
ch คือตัวอักขระที่ต้องการแสดงผลทางจอภาพอยู่ในเครื่องหมาย ‘ และ ’
ตัวอย่างเช่น
System.out.println("Hello World!");
System.out.println();
System.out.println(2500);
System.out.println(‘A’);
ผลลัพธ์ทางจอภาพ
Hello World!
2500
A
กรณีต้องการแสดงข้อความพร้อมกันในคำสั่ง System.out.println() ในครั้งเดียว ให้ใช้เครื่องหมาย + ในการเชื่อมข้อมูล
ตัวอย่างเช่น
System.out.println("Hello World!"+2500+ ‘A’);
System.out.println("Hello World!\n"+2500+ ‘A’);
ผลลัพธ์ทางจอภาพ
Hello World!2500A
Hello World!
2500A
| การรับค่าจากแป้นพิมพ์ |
| |
7.1 การรับค่าจากแป้นพิมพ์เป็นจำนวนเต็ม
บรรทัดที่
|
|
คำอธิบาย
|
1
2
3
4
5
6
7
8
9
10
11
12
|
import java.io.*;
class InputNumber {
public static void main(String[] args) {
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
int num;
try{
System.out.print("Input a Number::");
num = Integer.parseInt(br.readLine());
System.out.println("Show input = "+num);
}catch(IOException e){ System.err.println(e); }
}
} |
|
7.2 การรับค่าจากแป้นพิมพ์เป็นจำนวนทศนิยม
บรรทัดที่
|
|
คำอธิบาย
|
5
6
7
8
9
10
|
float num;
try{
System.out.print("Input a Number::");
num = Float.parseFloat(br.readLine());
System.out.println("Show input = "+num);
}catch(IOException e){ System.err.println(e); } |
|
7.3 การรับค่าจากแป้นพิมพ์เป็นข้อความ String
บรรทัดที่
|
|
คำอธิบาย
|
5
6
7
8
9
10
|
String str;
try{
System.out.print("Input a String::");
str = br.readLine();
System.out.println("Show input = "+str);
}catch(IOException e){ System.err.println(e); } |
|
7.4 การรับค่าจากแป้นพิมพ์เป็นอักขระ 1 ตัว
บรรทัดที่
|
|
คำอธิบาย
|
5
6
7
8
9
10
11
12
|
String str;
char ch;
try{
System.out.print("Input a Character::");
str = br.readLine();
ch = str.charAt(0);
System.out.println("Show input = "+ch);
}catch(IOException e){ System.err.println(e); } |
|
| |
| หน่วยที่ 4 พื้นฐานของภาษา java |
|
| ไวยากรณ์ของภาษา Java |
|
การเขียนโปรแกรมด้วยภาษา Java ต้องประกอบด้วยคำสั่งต่างๆ ตัวอักขระ หรือข้อความ ที่อยู่ในรูปแบบที่ภาษา Java แปลความหมายได้และถูกต้องตามหลักไวยากรณ์ของภาษา Java ซึ่งประกอบด้วยรูปแบบประเภทต่างๆ ดังนี้
1.1 หมายเหตุ (Comment)
หมายเหตุ คือข้อความที่แทรกอยู่ภายในซอร์สโค้ดของโปรแกรม เพื่อใช้อธิบายการทำงาน เตือนความจำ หรือเพื่อให้ผู้เขียนโปรแกรมและผู้พัฒนาโปรแกรมต่อเข้าใจได้ง่ายขึ้น ช่วยให้สามารถแก้ไขและปรับปรุงโปรแกรมได้ง่ายขึ้น ข้อความหมายเหตุนี้จะถูกมองข้ามเมื่อทำการคอมไพล์โปรแกรมและไม่มีผลกระทบต่อการรันโปรแกรม ในการเขียนโปรแกรมด้วยภาษา Java มีรูปแบบของหมายเหตุ 2 แบบ ดังนี้
1. หมายเหตุบรรทัดเดียว(Line Comment) จะใช้เครื่องหมาย // นำหน้าข้อความหมายเหตุ โดยข้อความหมายเหตุอยู่ภายใน 1 บรรทัดที่อยู่หลังเครื่องหมาย // จะไม่มีผลต่อโปรแกรม ตัวอย่างเช่น
int i; // just to define i
2. หมายเหตุหลายบรรทัด(Block Comment) จะใช้เครื่องหมาย /* นำหน้าข้อความหมายเหตุและใช้เครื่องหมาย */ ปิดท้ายข้อความหมายเหตุ ตัวอย่างเช่น
int i;
/* Just to define i
This is a block comment
*/
ตัวอย่างโปรแกรม แสดงการเขียนหมายเหตุ
/* Programmer Name :: abc
Date :: 01/08/06
*/
class TestComment {
public static void main(String[] args) {
int x=0, y=0; // Declare variables
for(int i=0; i < 5; i++){
x = i;
y = 2*i;
System.out.println("X+Y="+(x+y));
} // End of for
}
} |
|
1.2 ตัวระบุ (Identifier)
ตัวระบุ (Identifier) หรือโทเคน (Token) ของภาษา Java เป็นคำที่ใช้ตั้งชื่อในภาษา Java ซึ่งอาจเป็นชื่อฟังก์ชั่นหรือคำศัพท์ที่ภาษา Java เข้าใจ ใช้ในการกำหนดเป็นชื่อ คลาส (Class) เมธอด (Method) คำสงวน (Keyword) ตัวแปร (Variable) และ ค่าคงที่ (Constant) เป็นต้น ซึ่งจะต้องตั้งชื่อให้ถูกต้องตามหลักการตั้งชื่อตัวระบุโดยทั่วไป ดังนี้
1. ขึ้นต้นด้วยตัวอักษรภาษาอังกฤษ (a ถึง z หรือ A ถึง Z) หรือ เครื่องหมายขีดเส้นใต้ (underscore) ( _ ) หรือ dollar sign ($) เท่านั้น
2. ตัวถัดไปประกอบด้วยตัวอักษรภาษาอังกฤษ (a ถึง z หรือ A ถึง Z), ตัวเลขอารบิก (0 ถึง 9), เครื่องหมายขีดเส้นใต้ (underscore) ( _ ) หรือ dollar sign ($) เท่านั้น
3.การตั้งชื่อด้วยตัวอักษรเล็กหรือใหญ่จะเป็นชื่อที่แตกต่างกัน (Case Sensitive) ตัวอย่างเช่น Student กับ student จะเป็นชื่อที่ต่างกัน
4. ตัวระบุที่นิยามขึ้นมาเองห้ามตั้งชื่อซ้ำกับคำสงวน (Keyword)
ตัวอย่างของตัวตัวระบุ (Identifier) ที่ถูกต้อง ดังเช่น
| MyClass | ตัวอักษรตัวแรกเป็นตัวอักษร และตามด้วยตัวอักษรถูกต้องตามกฎข้อ1 และข้อ2 |
| student_Score | เป็นการตั้งชื่อที่ถูกต้องตามกฎข้อ1และ2 ให้เครื่องหมายขีดเส้นใต้แบ่งข้อความให้อ่านง่าย |
| number2 | เป็นการตั้งชื่อที่ถูกต้องตามกฎข้อ1และ2 ใช้ตัวเลขตามหลังตัวอักษรได้ |
| firstStudentRecord_Number | เป็นการตั้งชื่อที่ถูกต้องตามกฎข้อ1และ2 ใช้ตัวอักษรพิมพ์ใหญ่ของแต่ละคำเพื่อให้อ่านง่าย |
ตัวอย่างของตัวระบุ(Identifier) ที่ไม่ถูกต้อง ดังเช่น
| My Class | เป็นการตั้งชื่อที่ไม่ถูกต้องเพราะมีช่องว่าง ซึ่งผิดกฎข้อ2 |
| x+y | เป็นการตั้งชื่อที่ไม่ถูกต้องเพราะเครื่องหมาย + ซึ่งผิดกฎข้อ2 |
| 2x | เป็นการตั้งชื่อที่ไม่ถูกต้องเพราะขึ้นต้นด้วยตัวเลข ซึ่งผิดกฎข้อ1 |
| return | เป็นการตั้งชื่อที่ไม่ถูกต้องเพราะเป็นชื่อซ้ำกับคำสงวน ซึ่งผิดกฎข้อ4 |
คำแนะนำในการตั้งชื่อ Class
1. ตัวอักษรตัวแรกของทุกคำขึ้นต้นด้วยตัวอักษรภาษาอังกฤษตัวพิมพ์ใหญ่ (A ถึง Z)
2. ตัวถัดไปประกอบด้วย ตัวอักษรภาษาอังกฤษพิมพ์เล็ก (a ถึง z), ตัวเลขอารบิก (0 ถึง 9)
3. ใช้ตัวอักษรตัวแรกของทุกคำเป็นตัวพิมพ์ใหญ่ หรือ underscore เพื่อให้อ่านง่าย
4. ควรตั้งชื่อเป็นคำนามและสื่อความหมายของคลาสนั้นๆ
ตัวอย่างชื่อ Class เช่น BufferedReader, MyClass
คำแนะนำในการตั้งชื่อตัวแปร (Variable)
1. ขึ้นต้นชื่อด้วยตัวอักษรภาษาอังกฤษตัวพิมพ์เล็ก (a ถึง z)
2. ตัวถัดไปประกอบด้วย ตัวอักษรภาษาอังกฤษ, ตัวเลขอารบิก (0 ถึง 9)
3. ใช้ตัวอักษรตัวแรกของคำต่อไปเป็นตัวพิมพ์ใหญ่ หรือ underscore เพื่อให้อ่านง่าย
4. ควรตั้งชื่อเป็นคำนามและสื่อความหมาย หรือเป็นคำสั้นๆ จำได้ง่าย
ตัวอย่างชื่อตัวแปร เช่น name, studentRecord
คำแนะนำในการตั้งชื่อ Method
1. ขึ้นต้นชื่อด้วยตัวอักษรภาษาอังกฤษตัวพิมพ์เล็ก (a ถึง z)
2. ตัวถัดไปประกอบด้วย ตัวอักษรภาษาอังกฤษ, ตัวเลขอารบิก (0 ถึง 9)
3. ใช้ตัวอักษรตัวแรกของคำต่อไปเป็นตัวพิมพ์ใหญ่ หรือ underscore เพื่อให้อ่านง่าย
4. ควรตั้งชื่อเป็นคำกริยาและสื่อความหมาย
ตัวอย่างชื่อ Method เช่น getName(), isLetter()
คำแนะนำในการตั้งชื่อ ค่าคงที่ (Constant)
1. ตั้งชื่อด้วยตัวอักษรภาษาอังกฤษตัวพิมพ์ใหญ่ (A ถึง Z) ทั้งหมด
2. ใช้ underscore ใช้ในการแบ่งคำแต่ละคำ
ตัวอย่างชื่อค่าคงที่ เช่น MAX_VALUE, MIN_VALUE
1.3 คำสงวน (Keyword)
คำสงวนในภาษา Java คือคำศัพท์ที่คอมไพเลอร์ของภาษา Java เข้าใจได้ เป็นคำสั่งสำคัญที่ใช้แทนความหมายของการทำงานต่างๆและใช้ได้เฉพาะคำสั่งของ Java เท่านั้น ผู้เขียนโปรแกรมไม่สามารถนำมาตั้งชื่อเป็นตัวระบุต่างๆ เช่น ชื่อตัวแปร ชื่อคลาส ชื่อเมธอด ได้ คำสงวนในภาษา Java ประกอบด้วยคำศัพท์ ดังนี้
คำสงวนในภาษา Java
|
| abstract | default | if | package | throw |
| boolean | do | implements | private | thows |
| break | double | import | protected | transient |
| byte | else | inner | public | try |
| byvalue | extends | instanceof | rest | var |
| case | final | int | return | void |
| cast | finally | interface | short | volatile |
| catch | float | long | static | while |
| char | for | native | super | |
| class | future | new | switch | |
| const | generic | operator | synchronized | |
| continue | goto | outer | this | |
คำสงวนทุกตัวต้องเขียนด้วยตัวอักษรพิมพ์เล็กเท่านั้นและห้ามนำมาตั้งเป็นชื่อตัวแปร ส่วนคำว่า true และ false ไม่ใช่คำสงวนเพราะเป็นข้อมูลของค่าคงที่ตรรกะ และ null เป็นค่าคงที่ของตัวแปรสตริง (String)
1.4 สัญลักษณ์แยกคำ(Separator)
ในการเขียนโปรแกรมด้วยภาษา Java มีสัญลักษณ์ที่ใช้ในการแยกคำ ดังนี้
สัญลักษณ์แยกคำ
|
หน้าที่
|
;
| เพื่อการสิ้นสุดประโยคคำสั่งของภาษา Java |
( )
| ใช้สำหรับต่อท้ายเมธอดหรือคำสั่ง ตัวอย่างเช่น if(), functionTest() เป็นต้น |
,
| สำหรับแยกตัวแปร หรือคำสั่ง ตัวอย่างเช่น int x,y,z; |
.
| ใช้ในการระบุคุณลักษณะ หรือเมธอดของคลาส ตัวอย่างเช่น System.out.println();
ใช้ในการระบุแพ็คเกจของภาษ Java เช่น java.io.*; |
{ }
| เพื่อระบุขอบเขตของคำสั่งของภาษา Java โดยคำสั่งต่างๆจะอยู่ภายในบล็อก เช่น คำสั่งที่อยู่ภายในคลาส เมธอด หรืออยู่ภายในคำสั่งควบคุมต่างๆ เช่น if, while, do..while หรือ for เป็นต้น |
ช่องว่าง
(Whitespace)
| ใช้ช่องว่างเพื่อแยกคำสั่ง ข้อความต่างๆโดยคอมไพเลอร์ของภาษา Java จะไม่สนใจและไม่มีผลต่อโปรแกรม ช่องว่างทำให้อ่านซอร์สโค้ดได้ง่ายขึ้น รูปแบบของช่องว่าง ได้แก่ การกดคีย์แทบ (Tab), ช่องว่าง (Space bar) และขึ้นบรรทัดใหม่ (Enter) บนแป้นพิมพ์ |
1.5 ข้อมูลค่าคงที่
ข้อมูลค่าคงที่คือคำที่ใช้ในการแสดงข้อมูลที่เป็นตัวเลข ตัวอักขระ ข้อความ หรือค่าทางตรรกะ ซึ่งในภาษา Java ได้กำหนดข้อมูลค่าคงที่ไว้ 5 ประเภท ดังนี้
1. ตรรกะ (Boolean)
2. ตัวอักขระ (Character)
3. ตัวเลขจำนวนเต็ม (Integer)
ค่าคงที่ตัวเลขจำนวนเต็ม ประกอบด้วยลำดับของตัวเลข ซึ่งสามารถเขียนได้โดยใช้
ระบบจำนวน(Number System) อาทิเช่น ระบบเลขฐานสิบ ฐานแปด และฐานสิบหกค่าคงที่ตัวเลขจำนวนเต็มฐานสิบแต่ละหลักต้องประกอบด้วยตัวเลข 0 ถึง 9 โดยตัวเลขหลักแรกต้องไม่เป็น 0 และไม่มีเครื่องหมายอื่นๆ เช่น จุลภาค(,) จุดทศนิยม(.) หรือ ช่องว่าง เป็นต้น
ตัวอย่างของค่าคงที่ตัวเลขจำนวนเต็มฐานสิบที่ถูกต้อง ได้แก่
0 1 123 5482 364820 9994750
ตัวอย่างของค่าคงที่ตัวเลขจำนวนเต็มฐานสิบที่ไม่ถูกต้อง ได้แก่
| 12,510 | เป็นค่าคงที่ตัวเลขจำนวนเต็มที่ผิดเพราะมีเครื่องหมายจุลภาค |
| 360.52 | เป็นค่าคงที่ตัวเลขจำนวนเต็มที่ผิดเพราะมีเครื่องหมายจุดทศนิยม |
| 15 822 | เป็นค่าคงที่ตัวเลขจำนวนเต็มที่ผิดเพราะมีช่องว่าง |
| 123-456-789 | เป็นค่าคงที่ตัวเลขจำนวนเต็มที่ผิดเพราะมีเครื่องหมายลบ |
| 09001 | เป็นค่าคงที่ตัวเลขจำนวนเต็มที่ผิดเพราะมีเลข 0 นำหน้า |
ค่าคงที่ตัวเลขจำนวนเต็มฐานแปดแต่ละหลักต้องประกอบด้วยตัวเลข 0 ถึง 7 โดย
ตัวเลขหลักแรกต้องเป็น 0 และไม่มีเครื่องหมายอื่นๆ เช่น จุลภาค(,) จุดทศนิยม(.) หรือ ช่องว่าง เป็นต้น
ตัวอย่างของค่าคงที่ตัวเลขจำนวนเต็มฐานแปดที่ถูกต้อง ได้แก่
0 01 0123 05472
ตัวอย่างของค่าคงที่ตัวเลขจำนวนเต็มฐานแปดที่ไม่ถูกต้อง ได้แก่
| 752 | เป็นค่าคงที่ตัวเลขจำนวนเต็มที่ผิดเพราะไม่มี 0 นำหน้า |
| 05281 | เป็นค่าคงที่ตัวเลขจำนวนเต็มที่ผิดเพราะมีตัวเลข 8 |
| 0475.510 | เป็นค่าคงที่ตัวเลขจำนวนเต็มที่ผิดเพราะมีเครื่องหมายจุดทศนิยม (.) |
ค่าคงที่ตัวเลขจำนวนเต็มฐานสิบหกแต่ละหลักต้องประกอบด้วยตัวเลข 0 ถึง 9 และ
ตัวอักษร a ถึง f (ทั้งตัวเล็กตัวใหญ่) โดยต้องขึ้นต้นด้วย 0x หรือ 0X และไม่มีเครื่องหมายอื่นๆ เช่น จุลภาค(,) จุดทศนิยม(.) หรือ ช่องว่าง เป็นต้น
ตัวอย่างของค่าคงที่ตัวเลขจำนวนเต็มฐานสิบหกที่ถูกต้อง ได้แก่
0X 0X1 0x789FF 0xabcd
ตัวอย่างของค่าคงที่ตัวเลขจำนวนเต็มฐานสิบหกที่ไม่ถูกต้อง ได้แก่
| 0xDEFG | เป็นค่าคงที่ตัวเลขจำนวนเต็มที่ผิดเพราะมีตัวอักษร G |
| 05281 | เป็นค่าคงที่ตัวเลขจำนวนเต็มที่ผิดเพราะไม่ขึ้นต้นด้วย 0x หรือ 0X |
| 0X475.10 | เป็นค่าคงที่ตัวเลขจำนวนเต็มที่ผิดเพราะมีเครื่องหมายจุดทศนิยม (.) |
ค่าคงที่ตัวเลขทศนิยม คือตัวเลขทศนิยมฐานสิบ ซึ่งประกอบด้วยตัวเลข 0 ถึง 9 และจุดทศนิยม หรือเลขชี้กำลังที่เขียนอยู่ในรูปแบบของเลขยกกำลัง (Exponential)
ตัวอย่างของค่าคงที่ตัวเลขทศนิยมที่ถูกต้อง ได้แก่
0. 1. 0.2 700225.542
50000. 0.000458 12.578 30.E4
25E-8 0.006e-3 1.678E+8 .12345e12
ตัวอย่างของค่าคงที่ตัวเลขทศนิยมที่ไม่ถูกต้อง ได้แก่
| 1 | เป็นค่าคงที่ตัวเลขทศนิยมที่ผิดเพราะไม่มีจุดทศนิยมหรือเลขชี้กำลัง |
| 2E+10.2 | เป็นค่าคงที่ตัวเลขทศนิยมที่ผิดเพราะเลขชี้กำลังต้องเป็นเลขจำนวนเต็มเท่านั้น |
| 12,000.158 | เป็นค่าคงที่ตัวเลขทศนิยมที่ผิดเพราะมีเครื่องหมายจุลภาค
|
| ชนิดข้อมูล (Data Types) |
|
ในการเขียนโปรแกรมด้วยภาษา Java เช่นการประกาศตัวแปร หรือกำหนดค่าข้อมูลต่างๆ ต้องระบุชนิดข้อมูลอย่างชัดเจน โดยชนิดข้อมูลในภาษา Java มี 2 ประเภท คือ
1. ชนิดข้อมูลพื้นฐาน (Primitive Data Type) คือชนิดข้อมูลที่ใช้ในการเขียนโปรแกรมสำหรับเก็บข้อมูลชนิดต่างๆ ได้แก่ จำนวนเต็ม(Integer) จำนวนทศนิยม(Floating Point) ข้อมูลอักขระ(Character) และข้อมูลตรรกะ (Logical Data)
2. ชนิดข้อมูลแบบอ้างอิง (Reference Data Type) คือชนิดข้อมูลที่มีการอ้างอิงตำแหน่งในหน่วยความจำ ได้แก่ข้อมูลของคลาส เช่น String และข้อมูลแบบอาเรย์
ชนิดข้อมูลพื้นฐานในภาษา Java มีทั้งหมด 8 ชนิดข้อมูลโดยแบ่งออกเป็น 4 ประเภท ประกอบด้วย
1. ชนิดข้อมูลจำนวนเต็ม(Integer) ได้แก่ long, int, short และ byte
2. ชนิดข้อมูลจำนวนทศนิยม(Floating Point) ได้แก่ double และ float
3. ชนิดข้อมูลอักขระ(Character) ได้แก่ char
4. ชนิดข้อมูลตรรกะ (Logical Data) ได้แก่ boolean
ชนิดข้อมูลแต่ละประเภทจะมีขนาดและช่วงค่าของข้อมูลแตกต่างกัน และสามารถสรุปประเภทชนิดข้อมูล ขนาดและช่วงค่าของข้อมูล และค่าเริ่มต้น ได้ดังนี้
ประเภท
|
ชนิดข้อมูล
|
ขนาด
Size(bit)
|
ช่วงค่าข้อมูล
|
ค่าเริ่มต้น(Default)
|
จำนวนเต็ม
|
long
|
64
|
signed (two's complement) มีค่าอยู่ระหว่าง
-9,223,372,036,854,775,808 ถึง 9,223,372,036,854,775,807
|
0L
|
|
int
|
32
|
signed (two's complement) มีค่าอยู่ระหว่าง
-2,147,483,648 ถึง 2,147,483,647
|
0
|
|
short
|
16
|
signed (two's complement) มีค่าอยู่ระหว่าง
-32,768 ถึง 32,767
|
0
|
|
byte
|
8
|
signed (two's complement) มีค่าอยู่ระหว่าง
มีค่าอยู่ระหว่าง -128 ถึง 127
|
0
|
จำนวนทศนิยม
|
double
|
64
|
IEEE 754 มีค่าอยู่ระหว่าง
4.94065645841246544e-324 ถึง1.79769313486231570e+308
|
0.0
|
|
float
|
32
|
IEEE 754 มีค่าอยู่ระหว่าง
1.40129846432481707e-45 ถึง 3.40282346638528860e+38
|
0.0F
|
อักขระ
|
char
|
16
|
Unicode มีค่าอยู่ระหว่าง 0 ถึง 65,535
|
\u0000
|
ตรรกะ
|
boolean
|
1
|
มีค่าเท่ากับ true หรือ false
|
false
|
ชนิดข้อมูลแบบอื่นๆ
|
String
|
|
|
null
|
2.1 ชนิดข้อมูลจำนวนเต็ม(Integer)
ชนิดข้อมูลจำนวนเต็มประกอบด้วย 4 ชนิดได้แก่ long, int, short และ byte เป็นชนิดข้อมูลที่ใช้เก็บข้อมูลตัวเลขจำนวนเต็มในทางคณิตศาสตร์ ช่วงของข้อมูลขึ้นอยู่ขนาดของตัวแปรที่ประกาศ ตัวอย่างเช่น ตัวแปร int จะมีขนาด 32 บิต เก็บข้อมูลได้ -2,147,483,648 ถึง 2,147,483,647 การกำหนดค่าข้อมูลให้กับตัวแปรชนิดข้อมูลจำนวนเต็ม มีดังนี้
1. เลขฐานสิบคือการเขียนค่าของข้อมูลจำนวนเต็มทั่วไป เช่น 1200 150 -250 เป็นต้น โดยการเขียนจะไม่มีเครื่องหมาย , (Comma) เช่น 25,000 จะต้องเขียนเป็น 25000
2. เลขฐานแปดคือการเขียนค่าของข้อมูลจำนวนเต็มโดยใช้เลขฐานแปด โดยการขึ้นต้นข้อมูลด้วยเลข 0 แล้วตามด้วยเลข 0 ถึง 7 ตัวอย่างเช่น 036 เป็นเลขฐานแปด มีค่าเท่ากับ 30 ในเลขฐานสิบ
3. เลขฐานสิบหกคือการเขียนค่าของข้อมูลจำนวนเต็มโดยใช้เลขฐานสิบหก โดยการขึ้นต้นข้อมูลด้วยเลข 0x หรือ 0X แล้วตามด้วยเลข 0 ถึง 9 และ ตัวอักษร A ถึง F ตัวอย่างเช่น 0XB2 เป็นเลขฐานแปด มีค่าเท่ากับ 178 ในเลขฐานสิบ
การประกาศตัวแปรใดๆ ให้เป็นข้อมูลจำนวนเต็มต้องคำนึงถึงขอบเขตของช่วงข้อมูลที่เก็บได้ และต้องกำหนดค่าชนิดข้อมูลในเหมาะสมตรงกับชนิดข้อมูลที่ประกาศตัวแปร
ตัวอย่างการประกาศตัวแปรและกำหนดค่าข้อมูลของตัวแปร ดังนี้
long x1 = 100000000000L;
เป็นการประกาศตัวแปรชนิด long ชื่อ x1 มีค่าข้อมูลเท่ากับแสนล้าน (100,000,000,000) การประกาศตัวแปร long ต้องต่อท้ายข้อมูลด้วยตัวอักษร L หรือ l เสมอ
int x2 = 1000000000;
เป็นการประกาศตัวแปรชนิด long ชื่อ x1 มีค่าข้อมูลเท่ากับพันล้าน (1000,000,000)
short x31 = 32767;
เป็นการประกาศตัวแปรชนิด short ชื่อ x31 เก็บข้อมูลเป็นตัวเลขฐานสิบมีค่าข้อมูลเท่ากับ 32,767
short x32 = 0X7FFF;
เป็นการประกาศตัวแปรชนิด short ชื่อ x32 เก็บข้อมูลเป็นตัวเลขฐานสิบหกมีค่าข้อมูลเท่ากับ 32,767
byte x41 = 127;
เป็นการประกาศตัวแปรชนิด byte ชื่อ x41 เก็บข้อมูลเป็นตัวเลขฐานสิบมีค่าข้อมูลเท่ากับ 127
byte x42 = 0177;
เป็นการประกาศตัวแปรชนิด byte ชื่อ x42 เก็บข้อมูลเป็นตัวเลขฐานสิบแปดมีค่าข้อมูลเท่ากับ 127
2.2 ชนิดข้อมูลจำนวนทศนิยม(Floating Point)
ชนิดข้อมูลจำนวนทศนิยม ประกอบด้วยข้อมูลที่เป็นตัวเลขทศนิยม เช่น 1200.578 การเขียนโปรแกรมด้วยภาษา Java จะประกาศตัวแปรด้วยคำว่า float และ double โดยชนิดข้อมูล float จะเก็บข้อมูล 32 บิตตามมาตรฐาน single precision คือมีส่วนละเอียดของตัวเลขจำนวน 24 บิต และส่วนเลขยกกำลัง 8 บิต และชนิดข้อมูล double จะเก็บข้อมูล 64 บิตตามมาตรฐาน double precision คือมีส่วนละเอียดของตัวเลขจำนวน 53 บิต และส่วนเลขยกกำลัง 11 บิต รูปแบบการตัวเลขทศนิยมมี 2 แบบ ดังนี้
1. ตัวเลขทศนิยม เป็นการเขียนตัวเลขทศนิมที่มีเครื่องหมายจุดทศนิยม ตัวอย่างเช่น 3.14 เป็นต้น
2. ตัวเลขยกกำลังสิบ เป็นการเขียนตัวเลขทศนิยมอยู่ในรูปเลขยกกำลังสิบ (Exponential Form) โดยใช้ตัวอักษร E หรือ e ระบุจำนวนที่เป็นเลขยกกำลัง เช่น 6.12E12 หรือ 125.03E-5 เป็นต้น
ตัวอย่างการประกาศชนิดข้อมูลจำนวนทศนิยม เช่น
float f1 = 1234.157f;
เป็นการประกาศตัวแปรชนิด float ชื่อ f1 เก็บข้อมูลตัวเลขทศนิมขนาด 32 บิตและต้องใส่ตัวอักษร F หรือ f ต่อท้ายเพื่อระบุว่าเป็นชนิดข้อมูลแบบ float
double f2 = 2.18E6;
double f3 = 1234.157D;
เป็นการประกาศตัวแปรชนิด double ชื่อ f2, f3 เก็บข้อมูลเป้นเลขทศนิยมแบบ 64 บิต โดยใส่ตัวอักษร D หรือ d ต่อท้าย แต่โดยทั่วไปจะไม่นิยมใส่ตัวอักษรต่อท้ายเพราะการเขียนตัวเลขทศนิยมทั่วไปเป็นชนิดข้อมูลแบบ double อยู่แล้ว
ตัวอย่างข้อมูลจำนวนทศนิยมที่ถูกต้อง ได้แก่
123. 456E3 12.5e2 617.0e2F -3.14F 512.0E-12
ตัวอย่างข้อมูลจำนวนทศนิยมที่ไม่ถูกต้อง ได้แก่
1,234.567 ไม่ถูกต้องเพราะมีเครื่องหมาย ,
1.2E50F ไม่ถูกต้องเพราะ ค่าข้อมูลเกินขอบเขตของชนิดข้อมูลแบบ float
2.3 ชนิดข้อมูลอักขระ(Character)
ชนิดข้อมูลอักขระจะต้องประกาศตัวแปรด้วยคำว่า char คือการเก็บข้อมูลเป็นตัวอักษร หรืออักขระบนแป้นพิมพ์ได้เพียง 1 ตัวอักขระ ซึ่งในภาษา Java จะเก็บข้อมูลอักขระอยู่ในรูปแบบของรหัสแอสกี (ASCII Code) หรือรูปแบบมาตรฐาน Unicode ขนาด 16 บิต การกำหนดค่าข้อมูลอักขระจะอยู่ในเครื่องหมาย ‘ ’ โดยจะขึ้นต้นด้วยสัญลักษณ์ \u และตามด้วยเลขฐานสิบหก (Hexadecimal Number) โดยมีค่าตั้งแต่ ‘\u0000’ ถึง ‘\uFFFF’ หรือกำหนดค่าข้อมูลอักขระด้วยตัวอักขระบนแป้นพิมพ์ ตัวอย่างเช่น ‘A’, ‘x’, ‘$’ หรือ ‘1’ เป็นต้น
ตัวอย่างการประกาศชนิดข้อมูลอักขระ เช่น
char grade= ‘A’;
char grade= ‘\u0041’;
เป็นการประกาศตัวแปรที่มีชื่อว่า grade เป็นชนิดข้อมูลอักขระ มีการกำหนดค่าเริ่มต้นเป็นตัวอักษร A ซึ่งมีค่าเป็นเลขฐานสิบหก คือ 0041
ตัวอักขระพิเศษ หรือ Escape Sequence เป็นการแสดงข้อมูลอักขระบนแป้นพิมพ์ที่ใช้แทนการขึ้นบรรทัดใหม่ หรือ ตัวอักขระพิเศษในการเขียนโปรแกรม
ตัวอักขระพิเศษ
|
รหัส Unicode
|
ความหมาย
|
\b
|
\u000B
| Backspace ลบอักขระตำแหน่งเคอร์เซอร์ |
\t
|
\u0009
| Tab การเว้นช่องว่างตามระยะ |
\n
|
\u000A
| New Line การขึ้นบรรทัดใหม่ |
\r
|
\u000D
| Return การขึ้นบรรทัดใหม่ |
\\
|
\u005C
| Backslash แสดงตัวอักขระ \ |
\‘
|
\u0027
| Single Quote แสดงตัวอักขระ ‘ |
\“
|
\u0022
| Double Quote แสดงตัวอักขระ “ |
2.4 ชนิดข้อมูลตรรกะ (Logical Data)
ชนิดข้อมูลตรรกะจะต้องประกาศตัวแปรด้วยคำว่า boolean ซึ่งเป็นข้อมูลที่มีความจริงเป็นจริง (true) หรือเท็จ (false) ได้เพียง 1 ค่าเท่านั้น ใช้ในการตัดสินใจในเงื่อนไขของคำสั่งควบคุม หรือคำสั่งเกี่ยวกับตรรกะของโปรแกรม ตัวอย่างการประกาศชนิดข้อมูลตรรกะ เช่น
boolean flag = false;
เป็นการประกาศตัวแปรที่มีชื่อว่า flag เป็นชนิดข้อมูลตรรกะ มีการกำหนดค่าเริ่มต้นเป็น false
| การประกาศตัวแปร (Declaration Variable) |
| |
ข้อมูลที่ในการเก็บค่าต่างๆในการเขียนโปรแกรม Java ต้องได้รับการประกาศตัวแปรขึ้นมาก่อนเพื่อจองพื้นที่ในหน่วยความจำสหรับเก็บข้อมูล ซึ่งตัวแปรสามารถเปลี่ยนแปลงข้อมูลและกำหนดค่าได้ตลอดเวลาเมื่อต้องการ โดยต้องระบุชื่อของตัวแปรและชนิดข้อมูล มีรูปแบบคำสั่งประกาศตัวแปร ดังนี้
รูปแบบคำสั่งประกาศตัวแปร
[<Modifier>] <Data_type> <Variable_name> [=<Value>];
โดยที่
Modifier คือคำสัพท์ที่ใช้ระบุคุณลักษณะการเข้าถึงและใช้งานตัวแปรนั้นๆ เช่น static , public, protected, private เป็นต้น
Data_type คือ ชนิดข้อมูลแบบต่างๆ เช่น long, int, short, byte, double, float, char, boolean หรือตัวแปรชนิดของคลาสต่างๆเช่น String เป็นต้น
Variable_name คือชื่อของตัวแปรตามกฎการตั้งชื่อตัวแปร
Value คือ ค่าของข้อมูล มีค่าตามขอบเขตชนิดข้อมูลที่ประกาศ
ตัวอย่างเช่น การประกาศตัวแปรชนิดต่างๆพร้อมกับค่าเริ่มต้นให้กับตัวแปร
int x = 0;
float sum =0.0f;
char garde =‘F’;
การประกาศตัวแปรพร้อมกันหลายๆตัว และมีการกำหนดค่าเริ่มต้นให้กับตัวแปร
int x, y, z = 10;
float a = 1.5f, b ,c = 10f;
การประกาศตัวแปรโดยใช้ คำ Modifier
static int min = 0;
private float salary = 0.0f;
การประกาศตัวแปรค่าคงที่
การประกาศตัวแปรค่าคงที่ คือการประกาศตัวแปรชนิดข้อมูลต่างๆให้มีค่าคงที่ตลอดการทำงานจนจบcโปรแกรม โดยตัวแปรค่าคงที่จะกำหนดค่าข้อมูลได้เพียงครั้งเดียว ซึ่งเมื่อกำหนดแล้วจะไม่สามารถแก้ไขหรือเปลี่ยนแปลงค่าได้ มีรูปแบบคำสั่งการประกาศตัวแปร ดังนี้
รูปแบบคำสั่งประกาศตัวแปรค่าคงที่
[<Modifier>] final <Data_type> <Variable_name> =<Value>;
ตัวอย่างเช่น
final int MAX = 999;
final int MIN = 1+2+3; เป็นการประกาศตัวแปรค่าคงที่ ชื่อ MIN มีค่าเท่ากับ 1+2+3 คือเท่ากับ 6 นั่นเอง
final float MAX_SALARY = 999999;
คำสั่งการกำหนดค่า(Assignment Statement)
ตัวแปรทั่วไปสามารถเปลี่ยนแปลงหรือกำหนดค่าได้ตามต้องการโดยการใช้คำสั่งกำหนดค่า ดังนี้
รูปแบบคำสั่งกำหนดค่า
<Variable_name> = <Value>;
โดยที่
Variable_name คือชื่อของตัวแปรตามกฎการตั้งชื่อตัวแปร
Value คือ ค่าของข้อมูล หรืออาจเป็นนิพจน์ที่ให้ผลลัพธ์ที่มีค่าตามขอบเขตชนิดข้อมูลที่ประกาศไว้
ตัวอย่างเช่น ถ้ามีการประกาศตัวแปรดังนี้
int x;
char grade;
float y;
สามารถกำหนดค่าของตัวแปรต่างๆได้ดังนี้ เช่น
x = x + 2 ;
Garde = ‘A’
y = x + 4 + 0.5;
ตัวอย่างโปรแกรมการประกาศและกำหนดค่าของตัวแปรต่างๆ
class Test3 {
public static void main(String[] args) {
final double PI =3.1419265;
int a =0, b=0;
float x =0, y=0;
char grade='F';
// Assignment variable
a = b+2*3;
y = 25.5f;
x = y / a;
grade='B';
// Display variable
System.out.println("a ="+a);
System.out.println("x="+x);
System.out.println("grade="+grade);
}
} |
|
|
| |
| หน่วยที่ 5 นิพจน์และตัวดำเนินการ |
|
| นิพจน์ (Expression) |
| |
นิพจน์ในภาษา Java คือรูปแบบการเขียนคำสั่งระหว่างตัวดำเนินการ (Operator) และตัวถูกกระทำ (Operand) เช่น การกำหนดค่าให้กับตัวแปร สามารถเขียนนิพจน์ได้ดังนี้ int x = 2+3 ; เป็นการเขียนนิพจน์ 2+3 ซึ่งมีเครื่องหมาย + เป็นตัวดำเนินการและตัวถูกกระทำคือตัวเลข 2 และ 3 จากผลการคำนวณได้ผลลัพธ์เท่ากับ 5 ซึ่งถูกกำหนดค่าให้กับตัวแปร x
ดังนั้นนิพจน์จะต้องใช้ตัวดำเนินการต่างๆเพื่อคำนวณหาผลลัพธ์ และสร้างเงื่อนไขต่างๆ ในการเขียนโปรแกรม
| ตัวดำเนินการ (Operators) |
| |
ในภาษา Java ตัวดำเนินการแบ่งออกเป็น 6 ประเภท คือ
1. ตัวดำเนินการกำหนดค่า(Assignation Operator)
2. ตัวดำเนินการทางคณิตศาสตร์(Arithmetic Operator)
3. ตัวดำเนินการเปรียบเทียบความสัมพันธ์(Relational Operator)
4. ตัวดำเนินการเงื่อนไข(Conditional Operator)
5. ตัวดำเนินการทางตรรกะ(Logical Operator)
6. ตัวดำเนินการแบบบิต(Bitwise Operator)
หมายเหตุ นิพจน์ที่ใช้ตัวดำเนินการเปรียบเทียบความสัมพันธ์และตัวดำเนินการทางตรรกะ จะให้ผลลัพธ์เป็นชนิดข้อมูลตรรกะ ส่วนนิพจน์ที่ใช้ตัวดำเนินการทางคณิตศาสตร์และตัวดำเนินการแบบบิต จะให้ผลลัพธ์เป็นชนิดข้อมูลจำนวนเต็มหรือจำนวนทศนิยม
1. ตัวดำเนินการกำหนดค่า(Assignation Operator)
ตัวดำเนินการกำหนดค่าคือเครื่องหมายที่ใช้ในการกำหนดค่าข้อมูลในกับตัวแปรต่างๆโดยการใช้เครื่องหมายเท่ากับ ( = ) ดังตัวอย่างเช่น
int x = 20; เป็นการกำหนดค่าให้กับตัวแปร x เก็บข้อมูลจำนวนเต็มมีค่าเท่ากับ 20
x = 2 + 3 + 4; เป็นการกำหนดค่าให้กับตัวแปร x เก็บข้อมูลจำนวนเต็มมีค่าเท่ากับ 9
2. ตัวดำเนินการทางคณิตศาสตร์(Arithmetic Operator)
ใช้สำหรับการคำนวณทางคณิตศาสตร์ประกอบด้วยเครื่องหมายทางคณิตศาตร์ ได้แก่เครื่องหมาย +, -, *, / และ % มีตัวอย่างการใช้งานดังนี้
เครื่องหมายดำเนินการ
|
ความหมาย
|
ตัวอย่างนิพจน์
|
+
|
การบวก หรือแทนค่าตัวเลขบวก
|
a + b หรือ +a เช่น 1 + 2 + 3, x + y, 25.5 + 81.2 , +52
|
-
|
การลบ หรือแทนค่าตัวเลขลบ
|
a - b หรือ -a เช่น 50 – 15 - 4, x – 169.45, -34, -6.25E2
|
*
|
การคูณ
|
a * b เช่น x * y, 2 * 3
|
/
|
การหาร
|
a / b เช่น x / y, 2 / 3, 42 / 2.5
|
%
|
เศษจากการหาร
|
a % b เช่น x % y, 20 % 3
|
ตัวดำเนินการทางคณิตศาสตร์ จะใช้ได้เฉพาะตัวแปรที่มีชนิดข้อมูลแบบจำนวนเต็มและจำนวนทศนิยมเท่านั้น ดังตัวอย่างเช่น
ตัวดำเนินการเครื่องหมาย / จะให้ผลลัพธ์เป็นชนิดข้อมูลจำนวนทศนิยม ก็ต่อเมื่อตัวถูกกระทำตัวใดตัวหนึ่งเป็นชนิดข้อมูลจำนวนทศนิยม ดังตัวอย่างเช่น 20 / 3.0 จะมีค่าเท่ากับ 6.66667 ถ้าตัวถูกกระทำเป็นจำนวนเต็มทั้งหมดจะให้ผลลัพธ์เป็นจำนวนเต็ม ดังตัวอย่างเช่น 20 / 3 ซึ่งผลลัพธ์มีค่าเท่ากับ 6
ตัวดำเนินการเครื่องหมาย % จะให้ผลลัพธ์เป็นตัวเลขเศษซึ่งเกิดจากการหารของตัวเลข 2 จำนวน ดังตัวอย่างเช่น
20 % 3 จะได้เศษของการหารเท่ากับ 2
51.5 % 2 จะได้เศษของการหารเท่ากับ 1.5
2.1 ตัวดำเนินการแบบย่อ (Shortcut Operator)
ตัวดำเนินการแบบย่อ คือการเขียนนิพจน์ทางคณิตศาสตร์ให้อยู่ในรูปแบบใหม่ ทำให้เขียนง่ายและโปรแกรมทำงานได้เร็วขึ้น ซึ่งสามารถเขียนตัวดำเนินการแบบย่อได้นั้นต้องอยู่ในรูปแบบของนิพจน์ดังนี้ เช่น
x = x + 2; เขียนเป็นตัวดำเนินการแบบย่อได้เป็น x += 2;
ตัวดำเนินการแบบย่อในภาษา Java ได้แก่ เครื่องหมายทางคณิตศาสตร์ เช่น +=, -=, *=, /= และ %= เครื่องหมายแบบบิต เช่น <<=, >>=, &= และ |= เป็นต้น
เครื่องหมายดำเนินการ
|
ตัวอย่างตัวดำเนินการแบบย่อ
|
ความหมาย
|
+=
|
x += 2;
|
x = x + 2;
|
-=
|
x -= 2;
|
x = x - 2;
|
*=
|
x *= 2;
|
x = x * 2;
|
/=
|
x /= 2;
|
x = x / 2;
|
%=
|
x %= 2;
|
x = x % 2;
|
<<=
|
|
|
>>=
|
|
|
&=
|
|
|
|=
|
|
|
2.2 ตัวดำเนินการเพิ่มค่า (Increment Operator) และลดค่า (Decrement Operator)
ตัวดำเนินการเพิ่มค่า คือการเพิ่มค่าชนิดข้อมูลจำนวนเต็มและจำนวนทศนิยม เพิ่มค่าขึ้นครั้งละ 1 โดยการใช้เครื่องหมาย ++ วางไว้ข้างหน้า หรือข้างหลังตัวแปรดังตัวอย่าง เช่น x++, ++x เป็นต้น
ตัวดำเนินการลดค่า คือการลดค่าชนิดข้อมูลจำนวนเต็มและจำนวนทศนิยม ลดค่าลงครั้งละ 1 โดยการใช้เครื่องหมาย -- วางไว้ข้างหน้า หรือข้างหลังตัวแปรดังตัวอย่าง เช่น x--, --x เป็นต้น
ตัวอย่างการใช้ตัวดำเนินการเพิ่มค่าและลดค่า
x++ มีความหมายเดียวกันกับ x = x + 1 หรือ x += 1
++x มีความหมายเดียวกันกับ x = x + 1 หรือ x += 1
x-- มีความหมายเดียวกันกับ x = x - 1 หรือ x -= 1
--x มีความหมายเดียวกันกับ x = x - 1 หรือ x -= 1
การวางเครื่องหมายเพิ่มค่าและลดค่าจะได้ผลลัพธ์แตกต่างกันดังตัวอย่าง เช่น
ถ้า x = 10; แล้วเมื่อกำหนดให้ y = x++; จะได้ค่าข้อมูลของ y เท่ากับ 10 และค่าข้อมูลของ x เท่ากับ 11 เนื่องจากว่าเครื่องหมาย ++ อยู่หลังตัวแปร x ซึ่งตัวแปร x จะกำหนดค่าให้กับ y ก่อนแล้วจึงเพิ่มค่าของตัวแปร x ทีหลัง
ถ้า x = 10; แล้วเมื่อกำหนดให้ y = ++x; จะได้ค่าข้อมูลของ y เท่ากับ 11 และค่าข้อมูลของ x เท่ากับ 11 เนื่องจากว่าเครื่องหมาย ++ อยู่ข้างหน้าตัวแปร x ซึ่งตัวแปร x จะเพิ่มค่าก่อนแล้วจึงกำหนดค่าให้กับ y ทีหลัง
3. ตัวดำเนินการเปรียบเทียบความสัมพันธ์(Relational Operator)
ตัวดำเนินการเปรียบเทียบความสัมพันธ์ใช้ในการเปรียบเทียบค่าของชนิดข้อมูลใดๆสองค่า โดยผลลัพธ์ที่ได้จากการเปรียบเทียบความสัมพันธ์จะเป็นชนิดข้อมูลตรรกะ เครื่องหมายของตัวดำเนินการเปรียบเทียบความสัมพันธ์ ได้แก่เครื่องหมาย ==, !=, >, >=, <, <= มีตัวอย่างการใช้งานดังนี้
เครื่องหมาย
ดำเนินการ
|
ความหมาย
|
ตัวอย่าง
|
ผลลัพธ์
|
==
|
เท่ากับ
|
a == b เช่น 2 == 3
|
false
|
!=
|
ไม่เท่ากับ
|
a != b เช่น 2 != 3
|
True
|
>
|
มากกว่า
|
a > b เช่น 2 > 3
|
false
|
>=
|
มากกว่าหรือเท่ากับ
|
a >= b เช่น 2 >= 3
|
false
|
<
|
น้อยกว่า
|
a < b เช่น 2 < 3
|
true
|
<=
|
น้อยกว่าหรือเท่ากับ
|
a <= b เช่น 2 <= 3
|
true
|
การนำข้อมูลมาเปรียบเทียบความสัมพันธ์กันจะต้องเป็นชนิดข้อมูลที่สอดคล้องกัน เช่นการเปรียบเทียบระหว่างข้อมูลที่เป็นตัวเลขกับตัวเลข เป็นต้น ดังตัวอย่างเช่น
2 > 5.5 ได้ผลลัพธ์เป็น false
‘A’ != ‘a’ ได้ผลลัพธ์เป็น true
x < 20 นิพจน์นี้จะถูกต้องเมื่อกำหนดให้ตัวแปร x เป็นชนิดข้อมูลจำนวนเต็มหรือจำนวนทศนิยม และได้ผลลัพธ์เป็น false เมื่อค่าของตัวแปร x > 20 หรือได้ผลลัพธ์เป็น true เมื่อค่าของตัวแปร x < 20
boolean check = true;
check = ( 5 != 3) นิพจน์นี้จะได้ผลลัพธ์เป็น true เนื่องจากนิพจน์ 5 !=3 มีค่าเป็น true ซ่งมีค่าเท่ากับค่าของตัวแปร check
4. ตัวดำเนินการเงื่อนไข(Conditional Operator)
ตัวดำเนินการเงื่อนไข คือการเขียนคำสั่งเงื่อนไขและกำหนดค่าให้กับตัวแปรตามเงื่อนไขที่กำหนด ดยมีรูปแบบคำสั่ง ดังนี้
<Variable_Name> = (<Condition>)? <Expression_1> : <Expression_2> ;
โดยที่
<Variable_Name> หมายถึง ชื่อตัวแปรชนิดข้อมูลใดๆ
<Condition> หมายถึง นิพจน์เงื่อนไข
<Expression_1> และ <Expression_2> หมายถึง นิพจน์ที่1 และ นิพจน์ที่2 ตามลำดับ
ตัวอย่างตัวดำเนินการเงื่อนไข เช่น
y = (a>10)? 200: 300;
หมายความว่า ถ้าตัวแปร a มีค่ามากกว่า10 จริงจะมีผลทำให้ตัวแปร y มีค่าเท่ากับ 200 มิฉะนั้นถ้าตัวแปร a น้อยกว่า 10 จะทำให้ตัวแปร y มีค่าเท่ากับ 300
5. ตัวดำเนินการทางตรรกะ(Logical Operator)
ตัวดำเนินการทางตรรกะ เป็นตัวดำเนินการเกี่ยวข้องกับนิพจน์ที่สามารถบอกค่าความจริงเป็นจริง(true) หรือเท็จ (false)ได้ หรือชนิดข้อมูลตรรกะ เช่น ตัวแปรประเภท boolean ผลลัพธ์ที่ได้จากการกระทำจะได้ค่าคงที่ตรรกะเป็น true หรือ false ตัวดำเนินการทางตรรกะได้แก่เครื่องหมาย !, &&, &, ||, |, ^ มีตัวอย่างการใช้งานดังนี้
เครื่องหมาย
ดำเนินการ
|
ความหมาย
|
ตัวอย่าง
|
ผลลัพธ์
|
!
|
NOT (นิเสธ)
|
!(5 > 3)
| false |
&& หรือ &
|
AND (และ)
|
(x >= 10)&&(x <= 100)
| มีค่าเป็น true เมื่อ
(x >= 10) มีค่าเป็น true
และ (x <= 100) มีค่าเป็น true |
|| หรือ |
|
OR (หรือ)
|
(x < 10) || (x > 100)
| มีค่าเป็น true เมื่อ
(x < 10) มีค่าเป็น true
หรือ (x > 100) มีค่าเป็น true |
^
|
Exclusive OR
|
(x > 20) ^ (y > 20)
| มีค่าเป็น false ได้ 2 กรณี คือ
กรณีที่1
เมื่อ (x >= 10) มีค่าเป็น true และ (x <= 100) มีค่าเป็น true
หรือกรณีที่2
เมื่อ (x >= 10) มีค่าเป็น false และ (x <= 100) มีค่าเป็น false |
ตัวดำเนินการทางตรรกะแบบต่างๆ สามารถแสดงผลลัพธ์ของนิพจน์ตรรกะตามค่าความจริง ของการดำเนินการได้ดังตารางค่าความจริง (Truth Table) ดังนี้
ตารางค่าความจริงของตัวดำเนินการ ! หรือ NOT
ค่าความจริงนิพจน์
|
ตัวอย่าง
|
ผลลัพธ์
|
false
|
!(false)
|
False
|
true
|
!(true)
|
True
|
ตารางค่าความจริงของตัวดำเนินการ && หรือ AND
ค่าความจริงนิพจน์ที่ 1
|
ค่าความจริงนิพจน์ที่ 2
|
ตัวอย่าง
|
ผลลัพธ์
|
false
|
false
|
false && false
|
False
|
false
|
true
|
false && true
|
False
|
true
|
false
|
true && false
|
False
|
True
|
true
|
true && true
|
True
|
ตารางค่าความจริงของตัวดำเนินการ || หรือ OR
ค่าความจริงนิพจน์ที่ 1
|
ค่าความจริงนิพจน์ที่ 2
|
ผลลัพธ์
|
ผลลัพธ์
|
False
|
false
|
false || false
|
False
|
False
|
true
|
false || true
|
True
|
True
|
false
|
true || false
|
True
|
True
|
true
|
true || true
|
True
|
ตารางค่าความจริงของตัวดำเนินการ ^ หรือ XOR
ค่าความจริงนิพจน์ที่ 1
|
ค่าความจริงนิพจน์ที่ 2
|
ผลลัพธ์
|
ผลลัพธ์
|
False
|
false
|
false ^ false
|
False
|
False
|
true
|
false ^ true
|
True
|
True
|
false
|
true ^ false
|
True
|
True
|
true
|
true ^ true
|
false
|
6. ตัวดำเนินการแบบบิต(Bitwise Operator)
ตัวดำเนินการแบบบิตเป็นตัวดำเนินการที่ใช้กับชนิดข้อมูลจำนวนเต็มเท่านั้น ตัวดำเนินการทางตรรกะได้แก่เครื่องหมาย &(AND), | (OR), ^ (XOR), >> (right shift), << (left shift) มีตัวอย่างการใช้งานดังนี้
5 & 3 มีค่าเท่ากับ 1 เนื่องจาก
5 แปลงเป็นเลขฐานสองได้เป็น 0000 0101
3 แปลงเป็นเลขฐานสองได้เป็น 0000 0011
ผลลัพธ์เมื่อ AND กันแต่ละบิต ได้ 0000 0001 มีค่าเท่ากับ 1 (เลขฐานสิบ)
5 | 3 มีค่าเท่ากับ 1 เนื่องจาก
5 แปลงเป็นเลขฐานสองได้เป็น 0000 0101
3 แปลงเป็นเลขฐานสองได้เป็น 0000 0011
ผลลัพธ์เมื่อ AND กันแต่ละบิต ได้ 0000 0111 มีค่าเท่ากับ 7 (เลขฐานสิบ)
การคำนวณค่าของตัวดำเนินการแบบบิต โดยใช้เครื่องหมาย >> หมายถึงการเลื่อนบิตไปทางขวามือ (Right Shift) ซึ่งมีค่าเท่ากับ base* (2^(shift)) เมื่อ
base หมายถึงตัวเลขตัวตั้ง
shift หมายถึงตัวเลขจำนวนที่ต้องเลือนบิตทางขวา
ตัวอย่างเช่น
5>>2 มีค่าเท่ากับ 1 เนื่องจาก
5 แปลงเป็นเลขฐานสองได้เป็น 0000 0101
เลื่อนบิตขวาสุดของตัวตั้งไปเป็นจำนวน 1 บิต ได้เป็น 0000 0001 | 01
ผลลัพธ์ของการเลื่อนบิตทางขวาของ 5>>2 คือ 0000 0001 มีค่าเท่ากับ 1
การคำนวณค่าของตัวดำเนินการแบบบิต โดยใช้เครื่องหมาย << หมายถึงการเลื่อนบิตไปทางซ้ายมือ (Left Shift) ซึ่งมีค่าเท่ากับ base/ (2^(shift)) เมื่อ
base หมายถึงตัวเลขตัวตั้ง
shift หมายถึงตัวเลขจำนวนที่ต้องเลือนบิตทางซ้าย
ตัวอย่างเช่น
5<<2 มีค่าเท่ากับ 20 เนื่องจาก
5 แปลงเป็นเลขฐานสองได้เป็น 0000 0101
เลื่อนบิตซ้ายสุดของตัวตั้งไปเป็นจำนวน 2 บิต ได้เป็น 00 | 0001 0100
ผลลัพธ์ของการเลื่อนบิตทางขวาของ 5<<2 คือ 0001 0100 มีค่าเท่ากับ 20
ตารางสรุปตัวดำเนินการแบบต่างๆ
ตัวดำเนินการ
|
เครื่องหมาย
|
ตัวอย่าง
|
Assignation Operator
| = | int x = 20; |
Arithmetic Operator
| + - * / %
แบบย่อ
+= -= *= /= %=
เพิ่มค่าตัวแปร 1 ค่า
++ -- | x = x + 1;
x += 1;
x++;
++x;
-------------------------------------
x=5;
y = ++x; // y = 6, x = 6
y = x++; // y = 5, x = 6 |
Relational Operator
| > >= < <= == !=
ใช้ในการสร้างประโยคเงื่อนไข ตัวอย่างเช่น (a>=10), (b == 100), (c != 5) |
Conditional Operator
| <Variable> = (<Condition>)? <Expression_2> : <Expression_2> ;
ตัวอย่างเช่น y = (a>10)? 200 : 300;
ถ้า a>10 จริง y มีค่าเท่ากับ 200 มิฉะนั้นถ้า a>10 เท็จ y มีค่าเท่ากับ 300 |
Logical Operator
| && || !
ใช้ในการเชื่อมประโยคเงื่อนไขหลายๆประโยค เช่น (a >=10)&&(a<=100), (a>10)||(b<5)
ใช้ในการปฏิเสธ เช่น !((a >=10)&&(a<=100)) |
Bitwise Operator
| &(AND) | (OR) ^ (XOR)
>> (right shift) << (left shift)
ตัวอย่างเช่น
5&3 มีค่าเท่ากับ 1
0000 0101
0000 0011
0000 0001
Right shift มีค่าเท่ากับ base* (2^(shift))
Left shift มีค่าเท่ากับ base/ (2^(shift)) | 5<<3 มีค่าเท่ากับ 40
5 = 0000 0101
000 | 0010 1000
0010 1000
5>>1 มีค่าเท่ากับ 2
5 = 0000 0101
0000 0010 | 1
0000 0010 |
| ลำดับความสำคัญ |
| |
ลำดับที่
|
เครื่องหมาย
|
ลำดับการทำงาน
|
1
|
( )
|
|
2
|
++ , --
|
ซ้ายไปขวา
|
3
|
* , / , %
|
ซ้ายไปขวา
|
4
|
+ , -
|
ซ้ายไปขวา
|
5
|
< , <= , > , >=
|
ซ้ายไปขวา
|
6
|
== , !=
|
ซ้ายไปขวา
|
7
|
&&
|
ซ้ายไปขวา
|
8
|
||
|
ซ้ายไปขวา
|
9
|
= , += , -= , *= , /= , %=
|
ซ้ายไปขวา
|
| การแปลงค่าชนิดข้อมูล (Type Conversion) |
| |
ชนิดข้อมูลในภาษา Java มีหลายชนิด แต่ชนิดข้อมูลที่สามารถแปลงค่าได้จะเป็นชนิดข้อมูลแบบตัวเลขและตัวอักขระ โดยเรียงลำดับชนิดข้อมูลจากชนิดข้อมูลที่มีขนาดใหญ่ ไปถึงเล็ก ได้ดังนี้
| double |  | float | | long | | int | | char | | short | | byte |
การแปลงชนิดข้อมูลของตัวแปรในภาษา Java มี 2 ลักษณะ คือ
1. Widening Casting คือการแปลงชนิดข้อมูลที่มีขนาดเล็กไปเป็นชนิดข้อมูลขนาดใหญ่ โดยจะเป็นการแปลงแบบอัตโนมัติ เมื่อตัวแปรทางขวามือเครื่องหมายเท่ากับมีขนาดเล็กกว่าค่าทางซ้าย และเมื่อข้อมูลทางขวามีการคำนวณด้วยชนิดข้อมูลตัวเลขแบบต่างๆ ผลลัพธ์จากการทำนวณ จะถูกแปลงให้เป็นชนิดข้อมูลที่มีขนาดใหญ่ที่สุดตามลำดับ ดังนี้ double, float, long, int, char, short, byte
ตัวอย่างเช่น
float f = 250000; เป็นการแปลงค่าจำนวนเต็มไปเป็นชนิดข้อมูลแบบจำนวนทศนิยม
double d = 25.325F; เป็นการแปลงค่า 25.325 เป็นชนิดข้อมูลแบบจำนวนทศนิยม
int x = 12; float y = x / 10; เมื่อ x = 12 จะได้ y เท่ากับ 1.0 เพราะ x หาร 10 ทั้งสองค่าเป็นจำนวนเต็มจึงทำให้ผลลัพธ์เป็นจำนวนเต็ม
float z = 15.0;
int x = 2;
double y = x + 5 + z; เมื่อ x = 2 และ z = 15.0 จะได้ y เท่ากับ 22.0 เพราะผลลัพธ์ของ x + 5 + z จะถูกแปลงโดยอัตโนมัติให้เป็นชนิดข้อมูลแบบทศนิยม (float)
2. Narrowing Casting คือการแปลงชนิดข้อมูลที่มีขนาดใหญ่ไปเป็นชนิดข้อมูลขนาดเล็กกว่า โดยข้อมูลที่ถูกแปลงไปจะมีการสูญเสียข้อมูลไป
ตัวอย่างเช่น
int i = (int)25.325;
float f = (float)20.325;
float f = 20.325f;
char c = (char)97;
|
| |
| หน่วยที่ 6 คำสั่งควบคุม |
|
| ค่าตรรกะและการสร้างนิพจน์เงื่อนไข |
| |
ค่าตรรกะ หรือค่าความจริง (Logical value) คือ ค่าความจริงของนิพจน์ที่ใช้เป็นเงื่อนไข โดยสามารถบอกค่าความจริงได้ว่าเป็นจริง (True) หรือ เท็จ (False) เท่านั้น ตัวอย่างเช่น
boolean check1 = true;
boolean check2 = false;
คำอธิบาย : ตัวแปร check1 มีค่าความจริงเป็นจริง และ check2 มีค่าความจริงเป็นเท็จ
นิพจน์เงื่อนไข (Conditional Expression) คือ นิพจน์ที่ใช้เป็นเงื่อนไขของคำสั่งตัดสินใจและการทำงานแบบวนซ้ำ สามารถเขียนนิพจน์เงื่อนไขด้วยเครื่องหมายดำเนินการเปรียบเทียบ หรือเครื่องหมายดำเนินการตรรก
เครื่องหมายดำเนินการเปรียบเทียบ (Relational Operator) คือเครื่องหมายที่ใช้ในการเปรียบเทียบระหว่างตัวแปรหรือข้อมูล 2 ค่า ข้อมูลทั้งสองค่าที่เปรียบเทียบกันต้องเป็นข้อมูลชนิดเดียวกันและสามารถเปรียบเทียบกันได้ และผลลัพธ์ของการเปรียบเทียบต้องสามารถบอกเป็นค่าความจริงได้ ดังตัวอย่างเช่น
(3 > 2) นิพจน์เงื่อนไขนี้มีค่าความจริงเป็นจริง
(x != 10) นิพจน์เงื่อนไขนี้มีค่าความจริงเป็นจริง ถ้า x ไม่เท่ากับ 10
หรือมีค่าความจริงเป็นเท็จ ถ้า x เท่ากับ 10
เครื่องหมายดำเนินการเปรียบเทียบ ประกอบด้วยเครื่องหมายต่างๆ ดังนี้
เครื่องหมายดำเนินการเปรียบเทียบ
|
ความหมาย
|
>
| เปรียบเทียบข้อมูลด้านซ้าย มากกว่า ด้านขวา |
>=
| เปรียบเทียบข้อมูลด้านซ้าย มากกว่าหรือเท่ากับด้านขวา |
<
| เปรียบเทียบข้อมูลด้านซ้าย น้อยกว่า ด้านขวา |
<=
| เปรียบเทียบข้อมูลด้านซ้าย น้อยกว่าหรือเท่ากับด้านขวา |
==
| เปรียบเทียบข้อมูลด้านซ้าย เท่ากับ ด้านขวา |
!=
| เปรียบเทียบข้อมูลด้านซ้าย ไม่เท่ากับ ด้านขวา |
นิพจน์ที่เขียนด้วยเครื่องหมายดำเนินการเปรียบเทียบ จะนำไปใช้งานเป็นนิพจน์เงื่อนไข ในคำสั่ง if, for หรือ while เป็นต้น ดังตัวอย่างเช่น
นิพจน์เงื่อนไขในคำสั่ง if
|
int x=15;
if(x!=10){
System.out.println(“Hello”);
}
|
นิพจน์เงื่อนไขในคำสั่ง for
|
for(int i=0; i<10; i++){
System.out.println(“Hello”);
}
|
นิพจน์เงื่อนไขในคำสั่ง while
|
int y = 0;
while(y<=10){
System.out.println(“Hello”);
y++;
}
|
เครื่องหมายดำเนินการตรรกะ (Logical Operator) คือเครื่องหมายที่ใช้ในเชื่อมนิพจน์เงื่อนไข 2 นิพจน์ โดยผลลัพธ์ของการเชื่อมนิพจน์เงื่อนไขทั้งสองจะต้องสามารถบอกเป็นค่าความจริงได้ ดังตัวอย่างเช่น
(3 > 2) && (5 > 2) นิพจน์เงื่อนไขนี้มีค่าความจริงเป็นจริง
(x != 10) || (y > 10) นิพจน์เงื่อนไขนี้จะมีค่าความจริงเป็นจริง เมื่อ (x != 10) มีค่าความจริงเป็นจริง
หรือ (y > 10)มีค่าความจริงเป็นจริง
หรือมีค่าความจริงเป็นเท็จ เมื่อ (x != 10) มีค่าความจริงเป็นเท็จและ
(y > 10) มีค่าความจริงเป็นเท็จ
เครื่องหมายดำเนินการตรรกะ ประกอบด้วยเครื่องหมายต่างๆ ดังนี้
เครื่องหมายดำเนินการตรรกะ
|
ความหมาย
|
&&
| การกระทำนิพจน์เงื่อนไขแบบ และ (And) |
||
| การกระทำนิพจน์เงื่อนไขแบบ หรือ (Or) |
!
| การกระทำนิพจน์เงื่อนไขแบบ ปฏิเสธ (Not) |
ตารางค่าความจริงของการกระทำนิพจน์เงื่อนไขแบบ และ (And)
ค่าความจริงนิพจน์ที่ 1
|
ค่าความจริงนิพจน์ที่ 2
|
ค่าความจริงแบบ และ (And)
|
False
|
False
|
False
|
False
|
True
|
False
|
True
|
False
|
False
|
True
|
True
|
True
|
ตารางค่าความจริงของการกระทำนิพจน์เงื่อนไขแบบ หรือ (Or)
ค่าความจริงนิพจน์ที่1
|
ค่าความจริงนิพจน์ที่2
|
ค่าความจริงแบบ และ (And)
|
False
|
False
|
False
|
False
|
True
|
True
|
True
|
False
|
True
|
True
|
True
|
True
|
นิพจน์ที่เขียนด้วยเครื่องหมายดำเนินการตรรกะ จะนำไปใช้งานเป็นนิพจน์เงื่อนไข ในคำสั่ง if, for หรือ while เป็นต้น ดังตัวอย่างเช่น
นิพจน์เงื่อนไขในคำสั่ง if
|
int x=15;
if(x>=10 && x<=30){
System.out.println(“Hello”);
}
|
นิพจน์เงื่อนไขในคำสั่ง for
|
for(int i=0, int j=0; i<10 && j<10; i++,j++){
System.out.println(“Hello”);
}
|
นิพจน์เงื่อนไขในคำสั่ง while
|
int y = 0;
int x = 0;
while(x <10 || y <10){
System.out.println(“Hello”);
y++;
x++;
}
|
| คำสั่งเงื่อนไข |
| |
คำสั่งเงื่อนไข คือคำสั่งที่ในการตัดสินใจ หรือการเลือกทำเหตุการณ์ใดเหตุการณ์หนึ่งโดยอาศัยเงื่อนไขในการตัดสินใจ เช่น ถ้าเงื่อนไขเป็นจริงให้แสดงผลลัพธ์ หรือถ้าเงื่อนไขเป็นเท็จให้แสดงข้อผิดพลาด คำสั่งเงื่อนไขประกอบด้วย คำสั่ง if…else และ switch…case
2.1 คำสั่ง if … else คือ คำสั่งทางเลือกในการตัดสินใจทำงานอย่างใดอย่างหนึ่งประกอบด้วยรูปแบบคำสั่งหลายแบบ โดยมีการเขียนนิพจน์เงื่อนไขในคำสั่ง if และจะทำงานคำสั่งใน if ถ้าเงื่อนไขเป็นจริง ถ้าไม่เช่นนั้นจะทำคำสั่งใน else เมื่อเงื่อนไขเป็นเท็จ
คำสั่ง if … else มีทั้งหมด 4 รูปแบบ ดังนี้
แบบที่1 คำสั่ง if แบบทางเลือกเดียว
รูปแบบคำสั่ง
if( Condition ){
Statement;
}
Condition คือ นิพจน์เงื่อนไข
Statement คือ คำสั่ง
หลักการทำงาน
ทำงานตามคำสั่ง Statement เมื่อนิพจน์เงื่อนไขในคำสั่ง if มีค่าความเป็นจริงเท่านั้น
ตัวอย่างโปรแกรม
|
int x = 13;
if( x%2 == 0){
System.out.println(x+“ is even number”);
}
|
ผลลัพธ์ของโปรแกรม
แบบที่2 คำสั่ง if แบบ 2 ทางเลือก
รูปแบบคำสั่ง
if( Condition ){
Statement1;
}else{
Statement2;
}
Condition คือ นิพจน์เงื่อนไข
Statement1, Statement2 คือ คำสั่งที่1 และคำสั่งที่2
หลักการทำงาน
ทำงานตามคำสั่ง Statement1 เมื่อนิพจน์เงื่อนไขในคำสั่ง if มีค่าความเป็นจริง ถ้าไม่เช่นนั้นจะตามคำสั่ง Statement2 เมื่อนิพจน์เงื่อนไขในคำสั่ง if มีค่าความเป็นเท็จ
ตัวอย่างโปรแกรม
|
int x = 12;
if( x%2 == 0){
System.out.println(x+“ is even number”);
}else{
System.out.println(x+“ is odd number”);
}
|
ผลลัพธ์ของโปรแกรม
12 is odd number แบบที่3 คำสั่ง if แบบหลายทางเลือก
รูปแบบคำสั่ง
if( Condition1 ){
Statement1;
}else if( Condition2 ){
Statement2;
}else if( ConditionN ){
StatementN;
}
Condition1, Condition2, …, ConditionN คือ นิพจน์เงื่อนไขที่1, 2, ..., N
Statement1, Statement2, …, StatementN คือ คำสั่งที่1, 2, ..., N
หลักการทำงาน
ทำงานตามคำสั่ง Statement1 เมื่อนิพจน์เงื่อนไขที่1 ในคำสั่ง if มีค่าความเป็นจริง ถ้าไม่เช่นนั้นจะตามคำสั่ง Statement2 เมื่อนิพจน์เงื่อนไขที่2 ในคำสั่ง else if มีค่าความเป็นจริง ถ้าเงื่อนไขลำดับต้นๆ มีค่าความจริงเป็นเท็จจะตรวจสอบเงื่อนไขในลำดับถัดลงมาไปเรื่อยๆจนกว่าจะเจอเงื่อนไขที่เป็นจริง จึงค่อยทำคำสั่งที่อยู่ในเงื่อนไขนั้น แล้วออกจากสั่ง if … else if โดยจะทำคำสั่งที่มีเงื่อนไขมีค่าความจริงเป็นจริงเพียงกรณีเดียวเท่านั้น
ตัวอย่างโปรแกรม
|
int x = 75;
if( x>= 0 && x<=50){
System.out.println(“You get grade F”);
}else if( x> 50 && x<=60){
System.out.println(“You get grade D”);
} else if( x> 60 && x<=70){
System.out.println(“You get grade C”);
} else if( x> 70 && x<=80){
System.out.println(“You get grade B”);
} else if( x> 80 && x<=100){
System.out.println(“You get grade A”);
}
|
ผลลัพธ์ของโปรแกรม
แบบที่4 คำสั่ง if แบบหลายทางเลือก
รูปแบบคำสั่ง
if( Condition1 ){
Statement1;
}else if( Condition2 ){
Statement2;
}else if( ConditionN ){
StatementN;
}else{
StatementM;
}
Condition1, Condition2, …, ConditionN คือ นิพจน์เงื่อนไขที่1, 2, ..., N
Statement1, Statement2, …, StatementN คือ คำสั่งที่1, 2, ..., N
StatementM คือ คำสั่งที่ M
หลักการทำงาน
มีหลักการทำงานเหมือนคำสั่ง if แบบหลายทางเลือก โดยจะทำคำสั่งในนิพจน์เงื่อนไขของคำสั่ง if ที่มีค่าความจริงเป็นจริง เรียงตามลำดับก่อนหลังและเลือกคำสั่งทำเพียงครั้งเดียวในคำสั่ง if ที่เป็นจริง การทำงานจะให้ความสำคัญในการตรวจสอบเงื่อนไขทุกเงื่อนไขใน if แต่คำสั่ง StatementM เป็นกรณีสุดท้ายที่ไม่มีเงื่อนไขและทำคำสั่ง StatementM เมื่อทุกเงื่อนไขมีค่าความจริงเป็นเท็จทั้งหมด
ตัวอย่างโปรแกรม
|
int x = 200;
if( x>= 0 && x<=50){
System.out.println(“You get grade F”);
}else if( x> 50 && x<=60){
System.out.println(“You get grade D”);
} else if( x> 60 && x<=70){
System.out.println(“You get grade C”);
} else if( x> 70 && x<=80){
System.out.println(“You get grade B”);
} else if( x> 80 && x<=100){
System.out.println(“You get grade A”);
}else{
System.out.println(“Your score is wrong”);
}
|
ผลลัพธ์ของโปรแกรม
เงื่อนไข (Condition) คือนิพจน์เงื่อนไขที่สามารถบอกค่าความจริงได้ว่า จริง หรือ เท็จ การเขียนนิพจน์เงื่อนไขนี้จะใช้เครื่องหมายเปรียบเทียบ ( >, >=, <, <=, ==, != ) และ/หรือเครื่องหมายตรรกะ( &&, ||, ! ) ตัวอย่างเช่น
(a>0) สามารถบอกค่าความจริงได้ว่าจริง หรือ เท็จ เช่น (a>0) && (a<10) ถ้า a มีค่าเท่ากับ 5 จะทำให้ (a>0) มีค่าเป็นจริง
(a<=0) || (a>=10) เครื่องหมายตรรกะ &&, || ใช้ เชื่อม นิพจน์เงื่อนไขหลายๆนิพจน์ เช่น (a>0) && (b>0) || (c>0) && (d>0)
คำสั่ง (Statement) คือ คำสั่งที่อยู่ในภาษา Java เช่น คำสั่งกำหนดค่า, คำสั่งคำนวณ, ฟังก์ชั่น เป็นต้น ตัวอย่างเช่น
result = 2*x + y;
System.out.println(“Show the resut is” + result);
2.2 คำสั่ง switch … case คือ คำสั่งทางเลือกที่คล้ายกับคำสั่ง if แบบที่3 หรือ 4 ( if … else if หรือ if ..else if .. else ) เป็นคำสั่งที่ไม่มีเงื่อนไข และกระโดดไปทำคำสั่งที่อยู่ใน case ต่างๆ โดยดูจากค่าของตัวแปรที่กำหนดไว้ที่ switch
รูปแบบคำสั่ง
switch ( variable ){
case value1 : statement1; break;
case value2 : statement2; break;
:
case valueN : statementN; break;
default : statementM;
}
variable คือ ค่าที่จะนำเป็นเทียบกับ case ต่างๆ โดยต้องเป็นตัวแปร int (long, short, byte) char เท่านั้น (เป็นตัวแปร หรือ ตัวเลข หรือ ตัวอักขระ และต้องสามารถบอกค่าได้เสมอ)
value คือ ค่าของตัวแปร ซึ่งเป็นตัวเลข ตัวอักขระ โดยต้องเป็นค่าที่อาจจะเกิดขึ้น หรือเป็นไปได้ ต้องมีค่าอยู่ในช่วงของตัวแปร (variable)
| คำสั่งวนซ้ำ |
| |
คำสั่งทำซ้ำ คือ คำสั่งที่มีการทำงานเดิมซ้ำหลายๆครั้ง หรือ คำสั่งวนลูป
3.1 คำสั่ง for
รูปแบบคำสั่ง
for( initial_variable ; condition ; update_variable){
statement;
}
initial_value คือ การกำหนดค่าเริ่มต้นให้กับตัวแปรควบคุม เช่น i = 0 หรือ i = 0, j = 0 ต้องทำให้เงื่อนไขเป็นจริง
condition คือ เงื่อนไขที่ต้องประกอบด้วยตัวแปรควบคุม เช่น i <= 10 หรือ ( i < 10 ) && ( j < 20 )
update_variable คือ การเปลี่ยนปลงค่าตัวแปรควบคุมเพื่อให้เงื่อนไขเป็นเท็จ เช่น i-- หรือ i++ , j = j+2
การทำงานของคำสั่ง if คือ เน้นการทำงานที่สามารถบอกจำนวนรอบการทำงานได้
ตัวอย่างเช่น
for( i = 1; i< 10; i++ ){
System.out.print(i+ “ ”);
}
จำนวนครั้งในการวนลูป เท่ากับ 10 – 1 = 9 ครั้ง
ผลลัพธ์ที่ได้คือ 1 2 3 4 5 6 7 8 9
3.2 คำสั่ง while
รูปแบบคำสั่ง
initial_variable ;
while(condition){
statement;
update_variable;
}
การทำงานของคำสั่ง while คือ เน้นการวนลูป หรือทำตามเงื่อนไขที่เป็นจริงไปเรื่อย ๆ จนกระทั่งเงื่อนไขเป็นเท็จจึงออกจากลูป
3.3 คำสั่ง do … while
initial_variable ;
do{
statement;
update_variable;
} while(condition);
การทำงานของคำสั่ง do...while คือ มีคำสั่งที่ต้องทำก่อน จากนั้นค่อยตรวจสอบเงื่อนไข ถ้าเงื่อนไขที่เป็นจริงก็วนลูปไปเรื่อยๆ จนกระทั่งเงื่อนไขเป็นเท็จจึงออกจากลูป เช่น มี เมนูให้เลือก หรือ การรับค่าข้อมูลจนกว่าจะป้อนข้อมูลถูกต้อง
| คำสั่ง Break และ Continue |
| |
คำสั่ง Break คือคำสั่งที่ใช้ในการออกจากวนลูป เช่น คำสั่ง for, while, do .. while หรือคำสั่ง Switch
ตัวอย่างโปรแกรม
|
int i = 0;
while( i < 10){
i++;
if(i == 5)
break;
System.out.println(i);
}
|
ผลลัพธ์ของโปรแกรม
คำธิบายของโปรแกรม
หลักการทำงานของตัวอย่างนี้ต้องการวนลูปเพียง 4 ครั้งโดยกำหนดให้เมื่อค่าของตัวแปร i มีค่าเท่ากับ 5 ให้ออกจากลูป ถึงแม้จะกำหนดจำนวนรอบไว้ที่ 10 ครั้งก็ตาม และคำสั่งแสดงผล System.out.println(i) ที่ต่อจากคำสั่ง break จะไปถูกทำงานเพราะได้ออกจากการวนลูปแล้ว ทำให้แสดงผลลัพธ์ทางจอภาพเป็น 1234
คำสั่ง Continue คือคำสั่งที่กลับไปตรวจสอบเงื่อนไขของลูปอีกครั้ง ถ้าเงื่อนไขเป็นจริงก็ดำเนินการทำคำสั่งในลูปต่อไป
ตัวอย่างโปรแกรม
|
int i = 0;
while( i < 10){
i++;
if(i == 5)
continue;
System.out.println(i);
}
|
ผลลัพธ์ของโปรแกรม
คำธิบายของโปรแกรม
ตัวอย่างนี้เขียนการวนลูปไว้ที่ 10 รอบ แต่ถ้าค่าของตัวแปร i มีค่าเท่ากับ 5 จะมีผลทำให้กลับไปตรวจสอบเงื่อไขอีกครั้งว่า i < 10 หรือไม่ ซึ่งมีผลทำให้ไม่แสดงคำสั่ง System.out.println(i) และดำเนินการต่อไปเมื่อเงื่อนไขเป็นจริงทำให้แสดงผลลัพธ์ทางจอภาพเป็น 1234678910 ซึ่งไม่แสดงเลข 5 ออกจากจอภาพ
| ตัวอย่างประยุกต์ใช้งาน |
| |
โจทย์ : โปรแกรมการคำนวณค่าลงทะเบียน โดยมีการรับข้อมูลจำนวนนิสิต รหัสนิสิต ชื่อนิสิต และจำนวนวิชาที่ลงทะเบียน จากนั้นวนลูปรับข้อมูลของวิชาที่ลงทะเบียน ประกอบด้วย ชื่อรายวิชา รหัสวิชา และ หน่วยกิต จากนั้นคำนวณค่าลงทะเบียนโดยคิด หน่วยกิตละ 400 บาท และแสดงผลการคำนวณทางจอภาพ ว่าค่าลงทะเบียนที่ต้องจ่าย เท่าไหร่และลงทะเบียนกี่หน่วยกิตของนิสิตแต่ละคน
ขั้นตอนการทำงาน
1. รับจำนวนนิสิต
2. วนลูปตาม จำนวนนิสิต
2.1 รับรหัสนิสิต
2.2 รับชื่อ
2.3 รับจำนวนวิชา
2.4 วนลูปตาม จำนวนวิชา
2.4.1 รับชื่อวิชา
2.4.2 รับรหัสวิชา
2.4.3 รับหน่วยกิต
2.4.4 นับจำนวนหน่วยกิต
2.5 คำนวณค่าลงทะเบียน = จำนวนหน่วยกิต*400
2.6 แสดงผลการลงทะเบียนของนิสิตแต่ละคน
ตัวอย่างโปรแกรม
|
import java.io.*;
class TestFor {
public static void main(String[] args) {
BufferedReader br = new BufferedReader( new InputStreamReader( System.in ) );
int num=0,num2=0,credit=0;
String id="",name="",subjectId ,subjectName ="";
int nCredit=0, total=0;
try{
System.out.print("รับจำนวนนิสิต::");
num = Integer.parseInt(br.readLine() );
}catch(IOException e){ System.err.println(e); }
for(int i=0;i<num;i++){
System.out.println("นิสิตคนที่ "+(i+1));
try{
System.out.print("รหัสนิสิต::");
id = br.readLine();
System.out.print("ชื่อ-นามสกุล::");
name = br.readLine();
System.out.print("จำนวนวิชาที่ลงทะเบียน::");
num2 = Integer.parseInt(br.readLine() );
}catch(IOException e){ System.err.println(e); }
for(int j=0;j<num2; j++){
System.out.print("วิชาที่ "+(j+1));
try{
System.out.print("\tรหัสวิชา::");
subjectId = br.readLine();
System.out.print("\tชื่อวิชา::");
subjectName = br.readLine();
System.out.print("\tหน่วยกิต::");
credit = Integer.parseInt(br.readLine() );
}catch(IOException e){ System.err.println(e); }
nCredit = nCredit+credit;
}
total = nCredit*400;
System.out.println("ชื่อนิสิต "+name);
System.out.println("ค่าลงทะเบียนที่ต้องจ่าย "+total +" บาท");
System.out.println("จำนวนหน่วยกิตทั้งหมด "+nCredit+" หน่วยกิต");
System.out.println("\n--------------------------\n ");
}
}
}
|
|
|
| |
| หน่วยที่ 7 การเขียนการใช้งาน Method |
|
| ตัวแปรอาเรย์ ( Array Variable) |
| |
ตัวแปรอาเรย์ หมายถึง ตัวแปรที่ใช้ในการเก็บข้อมูลได้หลายตัว โดยข้อมูลที่เก็บต้องเป็นข้อมูลชนิดเดียวกัน เป็นตัวแปรที่ใช้ในการเก็บชุดข้อมูลที่มีการกำหนดขนาดของการเก็บข้อมูลได้ โดยมีตำแหน่งข้อมูลต่อเนื่องกัน ซึ่งขนาดของอาเรย์จะขึ้นกับจำนวนมิติ (Dimension) และจำนวนสมาชิกที่กำหนด
การสร้างตัวแปรอาเรย์ ประกอบด้วย 3 ส่วน ได้แก่ ชนิดข้อมูลที่ต้องเก็บข้อมูล ชื่อตัวแปรอาเรย์ และขนาดของอาเรย์ โดยสมาชิกแต่ละตัวในอาเรย์ สามารถอ้างอิงตำแหน่งได้ด้วยตัวเลขจำนวนเต็ม โดยสมาชิกตัวแรกของอาเรย์ มีหมายเลขตำแหน่ง คือ 0
ตัวแปรอาเรย์ 1 มิติ
ตัวแปรอาเรย์ 1 มิติ คือตัวแปรอาเรย์ที่กำหนดจำนวนมิติ 1 มิติ ซึ่งมีลักษณะการเก็บข้อมูล 1 แถว (Row) และ N หลัก (Column) เรียงลำดับต่อเนื่องกันไปตามขนาดของอาเรย์
การสร้างตัวแปรอาเรย์ แบบที่ 1
การสร้างตัวแปรอาเรย์ แบบที่ 1 ทำได้โดยการประกาศตัวแปรอาเรย์ก่อน จากนั้นจึงนำชื่อตัวแปรอาเรย์ไปกำหนดขนาดสมาชิกอีกครั้งเมื่อต้องการเรียกใช้งานตัวแปรอาเรย์
การประกาศตัวแปรอาเรย์ มีรูปแบบคำสั่ง ดังนี้
<DataType> [] <ArrayName>;
หรือ
DataType> <ArrayName>[];
การกำหนดขนาดสมาชิกของตัวแปรอาเรย์ มีรูปแบบคำสั่ง ดังนี้
<ArrayName> = new <DataType>[N];
เมื่อกำหนดให้
N หมายถึง ตัวเลขจำนวนเต็ม ที่ใช้บอกจำนวนสมาชิกในตัวแปรอาเรย์
<DataType> หมายถึง ชนิดข้อมูล หรือ คลาส (Class) ที่ใช้เก็บข้อมูลในภาษา Java เช่น int, float, char, String เป็นต้น
<ArrayName> หมายถึง ชื่อตัวแปรอาเรย์
การตั้งชื่อตัวแปรอาเรย์ต้องตั้งชื่อให้ถูกต้องตามหลักการตั้งชื่อตัวแปร ตัวอย่างเช่น student, userName เป็นต้น
เมื่อกำหนดขนาดสมาชิกของตัวแปรอาเรย์ด้วยวิธีนี้จะทำให้ข้อมูลที่อยู่ในอาเรย์มีค่าเริ่มต้น (Default value) ตามชนิดข้อมูลที่กำหนด เช่น ชนิดข้อมูลแบบจำนวนเต็ม มีข้อมูลเริ่มต้นเท่ากับ 0 ชนิดข้อมูลแบบตรรกะ มีข้อมูลเริ่มต้นเท่ากับ false เป็นต้น
ตัวอย่างการสร้างตัวแปรอาเรย์ แบบที่ 1
|
int studentScore[];
…
studentScore = new int[20];
|
คำอธิบาย
ตัวแปรอาเรย์ชื่อ studentScore เป็นชนิดข้อมูลแบบจำนวนเต็ม (Integer) มีขนาดสมาชิกเท่ากับ 20 ตัว หมายถึงตัวแปรอาเรย์ชื่อ studentScore สามารถเก็บข้อมูลที่เป็นตัวเลขจำนวนเต็มซึ่งเป็นคะแนนนิสิตได้ทั้งหมด 20 คะแนน หรือ
|
String []studentName;
…
studentName = new String[25];
|
คำอธิบาย
ตัวแปรอาเรย์ชื่อ studentName เป็นชนิดข้อมูลแบบคลาสสตริง (String Class) มีขนาดสมาชิกเท่ากับ 25 ตัว หมายถึงตัวแปรอาเรย์ชื่อ studentName สามารถเก็บข้อมูลที่เป็นสตริง ซึ่งเป็นชื่อนิสิตได้ทั้งหมด 25 ชื่อ
การสร้างตัวแปรอาเรย์ แบบที่ 2
การสร้างตัวแปรอาเรย์ แบบที่ 2 ทำได้โดยการประกาศตัวแปรอาเรย์และกำหนดขนาดสมาชิกพร้อมกัน
การประกาศตัวแปรอาเรย์และกำหนดขนาดสมาชิกพร้อมกัน มีรูปแบบคำสั่ง ดังนี้
<DataType> []<ArrayName> = new <DataType>[N];
หรือ
DataType> <ArrayName>[]= new <DataType>[N];
เมื่อกำหนดให้
N หมายถึง ตัวเลขจำนวนเต็ม ที่ใช้บอกจำนวนสมาชิกในตัวแปรอาเรย์
<DataType> หมายถึง ชนิดข้อมูล หรือ คลาส (Class) ที่ใช้เก็บข้อมูลในภาษา Java เช่น int, float, char, String เป็นต้น
<ArrayName> หมายถึง ชื่อตัวแปรอาเรย์ การตั้งชื่อตัวแปรอาเรย์ต้องตั้งชื่อให้ถูกต้องตามหลักการตั้งชื่อตัวแปร ตัวอย่างเช่น student, userName เป็นต้น
ตัวอย่างการสร้างตัวแปรอาเรย์ แบบที่ 2
|
float salary[] = new float[50];
…
|
คำอธิบาย
ตัวแปรอาเรย์ชื่อ salary เป็นชนิดข้อมูลแบบจำนวนทศนิยม (Floating Point) มีขนาดสมาชิกเท่ากับ 50 ตัว หมายถึงตัวแปรอาเรย์ชื่อ salary สามารถเก็บข้อมูลที่เป็นตัวเลขทศนิยมซึ่งเป็นเงินเดือนได้ทั้งหมด 50 คน
หรือ
|
char []symbol = new char[10];
…
|
คำอธิบาย
ตัวแปรอาเรย์ชื่อ symbol เป็นชนิดข้อมูลแบบอักขระ (Character) มีขนาดสมาชิกเท่ากับ 10 ตัว หมายถึงตัวแปรอาเรย์ชื่อ symbol สามารถเก็บข้อมูลที่เป็นอักขระ ซึ่งเป็นอักขระสัญลักษณ์ได้ทั้งหมด 10 ตัวอักขระ
| การกำหนดค่าข้อมูลให้กับตัวแปรอาเรย์ |
| |
การกำหนดค่าข้อมูลให้กับตัวแปรอาเรย์ กระทำได้หลายรูปแบบ โดยการระบุตำแหน่งของสมาชิกที่ต้องการเก็บข้อมูลด้วยเลขจำนวนเต็ม โดยมีตำแหน่งสมาชิกตัวแรกเป็นตำแหน่งที่ 0 จนถึงตำแหน่งที่ N-1 เมื่อ N คือ ขนาดของอาเรย์
การระบุตำแหน่งสมาชิกของอาเรย์ ใช้คำสั่ง <ArrayName>[Index]
Index หมายถึง ตัวเลขจำนวนเต็มซึ่งเป็นตำแหน่งสมาชิกที่ต้องอ้างถึง โดยเริ่มตั้งแต่ 0 และไม่เกินขนาดของอาเรย์
การหาขนาดของอาเรย์ จะใช้คำสั่ง <ArrayName>.length ซึ่งเป็นคุณสมบัติหนึ่ง (Property) ของตัวแปรอาเรย์
2.1 การกำหนดค่าข้อมูลให้กับตัวแปรอาเรย์ แบบที่ 1
การกำหนดค่าข้อมูลในอาเรย์โดยการระบุตำแหน่งสมาชิกในอาเรย์ขึ้นอยู่กับชนิดข้อมูลที่ประกาศไว้ ตัวอย่างเช่น
int x[] = new int[2];
x[0] = 10;
float y[] = new float[2];
y[1] = 10.25f;
char grade[] = new char[2];
grade[0] = ‘A’;
boolean check[] = new boolean[2];
check[0] = true;
String name[] = new String[2];
name[1] = “Somsri”;
และตัวอย่างการกำหนดค่าให้กับตัวแปรอาเรย์ดังนี้
int studentScore[] = new int[10];
studentScore[0] = 0;
studentScore[1] = 0;
for(int i = 0; i < studentScore.length; i++){
studentScore[i] = 50 + i;
}
… |
คำอธิบาย
ตัวแปรอาเรย์ที่ชื่อ studentScore ซึ่งเป็นตัวแปรที่เก็บคะแนน ได้ทั้งหมด 10 คะแนน ในขั้นแรกจะกำหนดค่าข้อมูลที่ตำแหน่งที่ 0 และ 1 มีค่าข้อมูลเป็น 0 ก่อน จากนั้นจึงใช้คำสั่ง for วนซ้ำเพื่อกำหนดค่าข้อมูลโดยการระบุตำแหน่งสมาชิกไปที่ละค่าตั้งแต่ตำแหน่งที่ 0 จนถึง ขนาดของอาเรย์โดยใช้คำสั่ง studentScore.length ข้อมูลที่เก็บในตัวแปรอาเรย์ studentScore ประกอบด้วยข้อมูลทั้งหมด 0 ตัว มีตำแหน่งตั้งแต่ 0 ถึง 9 ดังนี้
ตำแหน่งที่
|
0
|
1
|
2
|
3
|
4
|
5
|
6
|
7
|
8
|
9
|
|
50
|
51
|
52
|
53
|
54
|
55
|
56
|
57
|
58
|
59
|
2.2 การกำหนดค่าข้อมูลให้กับตัวแปรอาเรย์ แบบที่ 2
นอกจากการกำหนดค่าข้อมูลในอาเรย์โดยการระบุตำแหน่งสมาชิกในอาเรย์แล้ว ยังสามารถกำหนดค่าข้อมูลให้กับตัวแปรอาเรย์โดยการประกาศตัวแปรอาเรย์และกำหนดค่าข้อมูลพร้อมกัน ดังตัวอย่างเช่น
int x[] = {10, 20, 30, 40, 50};
float y[] ={10.25f, 10.5f, 10.75f, 11};
char grade[] = {‘H’, ’E’, ’L’, ’L’, ’O’};
boolean check[] = {true, false};
String name[] = {“Somsri”, “Somchai”, “Somsuk”};
และตัวอย่างการกำหนดค่าให้กับตัวแปรอาเรย์ดังนี้
int studentScore[] = {50, 51, 52, 53, 53, 55, 56, 57, 58, 59};
for(int i = 0; i < studentScore.length; i++){
System.out.print(“\t” + studentScore[i]);
}
… |
คำอธิบาย
ตัวแปรอาเรย์ที่ชื่อ studentScore มีการกำหนดค่าข้อมูลให้ตอนประกาศตัวแปร ทำให้ตัวแปรอาเรย์นี้มีขนาดเท่ากับ 10 ตามข้อมูลที่กำหนดให้ และใช้คำสั่ง for วนซ้ำเพื่อแสดงผลค่าข้อมูลในอาเรย์ โดยแสดงค่าข้อมูลในอาเรย์ตั้งแต่ตำแหน่ง 0 ถึง 9 ดังนี้ ได้ดังนี้
50 51 52 53 54 55 56 57 58 59
ข้อมูลในตำแหน่งต่างๆของตัวแปรอาเรย์ studentScore มีค่าข้อมูลดังนี้
studentScore[0] มีค่าข้อมูลเท่ากับ 50
studentScore[1] มีค่าข้อมูลเท่ากับ 51
studentScore[2] มีค่าข้อมูลเท่ากับ 52
studentScore[3] มีค่าข้อมูลเท่ากับ 53
studentScore[4] มีค่าข้อมูลเท่ากับ 54 | studentScore[5] มีค่าข้อมูลเท่ากับ 55
studentScore[6] มีค่าข้อมูลเท่ากับ 56
studentScore[7] มีค่าข้อมูลเท่ากับ 57
studentScore[8] มีค่าข้อมูลเท่ากับ 58
studentScore[9] มีค่าข้อมูลเท่ากับ 59 |
ตัวอย่างโปรแกรมการใช้งานตัวแปรอาเรย์ 1 มิติ
|
// File : TestArray01.java
class TestArray{
public static void main(String args[]){
int score[] = {50, 60, 70, 80, 90};
String grade = “”;
for(int i = 0; i < score.length; i++){
if(score[i] > 80 && score[i] <= 100){
grade = “A”;
}else if(score[i] > 70 && score[i] <= 80){
grade = “B”;
} else if(score[i] > 60 && score[i] <= 70){
grade = “C”;
} else if(score[i] > 50 && score[i] <= 60){
grade = “D”;
} else if(score[i] >= 0 && score[i] <= 50){
grade = “F”;
}
System.out.print(“Student No” + (i+1) );
System.out.print(“ get Score :: ” + score[i]);
System.out.println(“ and Grade is ” + grade);
}
}
}
|
ผลลัพธ์ทางหน้าจอ
|
Student No1 get Score :: 50 and Grade is F
Student No2 get Score :: 60 and Grade is D
Student No3 get Score :: 70 and Grade is C
Student No4 get Score :: 80 and Grade is B
Student No5 get Score :: 90 and Grade is A
|
| ตัวแปร Array แบบหลายมิติ |
| |
โจทย์ : โปรแกรมลงทะเบียนของนิสิต โดยมีการรับข้อมูลจำนวนนิสิต รหัสนิสิต ชื่อนิสิต และจำนวนวิชาที่ลงทะเบียน จากนั้นวนลูปรับข้อมูลของวิชาที่ลงทะเบียน ประกอบด้วย ชื่อรายวิชา รหัสวิชา และ หน่วยกิต แสดงผลทางจอภาพ เป็นรายละเอียดของการลงทะเบียนของนิสิตแต่ละคน
ข้อกำหนดของโปรแกรม: ให้ประกาศตัวแปรแบบอาเรย์ในการเก็บข้อมูลนิสิตและข้อมูลการลงทะเบียน และใช้ตัวแปรอื่นได้ตามความเหมาะสมของโปรแกรม
ขั้นตอนการทำงาน
1. รับจำนวนนิสิต
2. วนลูปตาม จำนวนนิสิต
2.1 รับรหัสนิสิต
2.2 รับชื่อ
2.3 รับจำนวนวิชา
2.4 วนลูปตาม จำนวนวิชา
2.4.1 รับชื่อวิชา
2.4.2 รับรหัสวิชา
2.4.3 รับหน่วยกิต
2.4.4 นับจำนวนหน่วยกิต
2.5 แสดงผลการลงทะเบียนของนิสิตแต่ละคน
ตัวอย่างโปรแกรม
|
import java.io.*;
class RegistrationSystem
{
public static void main(String[] args)
{
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
String stdName[]={""},stdID[]={""};
int nSubj[]={0};
String subjName[][]={{""}},subjID[][]={{""}};
int credit[][]={{0}},nCredit[]={0};
int nStd=0;
try{
System.out.print("Enter a Number of Student ::");
nStd=Integer.parseInt(br.readLine());
stdID=new String[nStd];
stdName=new String[nStd];
subjName=new String[nStd][10];
subjID=new String[nStd][10];
nSubj= new int[nStd];
credit= new int[nStd][10];
}catch(IOException e){}
for(int i=0; i<nStd; i++){
try{
System.out.print("Student No::"+(i+1));
System.out.print("Enter Student ID:");
stdID[i]=br.readLine();
System.out.print("Enter Student Name:");
stdName[i]=br.readLine();
System.out.print("Enter number of Subject:");
nSubj[i] = Integer.parseInt(br.readLine());
for(int j=0; j<nSubj[i]; j++){
System.out.print("\tSubject Name:");
subjName[i][j]=br.readLine();
System.out.print("\tEnter Subject ID:");
subjID[i][j]=br.readLine();
System.out.print("\tEnter Credit:");
credit[i][j]= Integer.parseInt(br.readLine());
nCredit[i] +=credit[i][j];
} System.out.println("************************************");
}catch(IOException e){}
}
System.out.println("************************************");
System.out.println("ID\tName\tNumberofSubject\tCredit");
for(int i=0; i< stdID.length ; i++){ System.out.println(stdID[i]+"\t"+stdName[i]+"\t"+nSubj[i]+"\t"+nCredit[i]);
System.out.println("\tSubjectID\tSubjectName\tCredit");
for(int j=0; j< nSubj[i]; j++){
System.out.print("\t"+subjID[i][j]);
System.out.print("\t"+subjName[i][j]);
System.out.println("\t"+credit[i][j]);
}
System.out.println("---------------------------------");
}
}
}
| การเรียงลำดับข้อมูล |
| |
การเรียงลำดับข้อมูลในอาเรย์ มีหลายวิธี โดยแต่ละวิธีจะมีหลักการทำงานและข้อจำกัดที่แตกต่างกัน และขึ้นกับการเลือกใช้งาน ซึ่งจะกล่าวถึงการจัดเรียงข้อมูล 2 แบบดังนี้
การจัดเรียงข้อมูลแบบ Selection Sort
หลักการทำงาน
1. ค้นหาข้อมูลที่มีค่าสูงสุดในอาเรย์ ตั้งแต่ตำแหน่งข้อมูลที่ 0 ถึงตำแหน่ง N-1
2. สลับข้อมูลที่มีค่ามากที่สุดกับค่าข้อมูลตำแหน่งที่ N-1 (ช่วงข้อมูลท้ายสุดในอาเรย์)
3. ลดค่า N ลง 1 ค่าเพื่อเปลี่ยนขอบเขตในการค้นหาข้อมูลใหม่
4. ทำขั้นตอนในข้อ 1, 2 และ 3 จนกว่าขอบเขตข้อมูลเป็น 0
เมื่อกำหนดให้ N หมายถึงขนาดของอาเรย์
ผลลัพธ์จากการเรียงข้อมูลแบบ Selection Sort ข้างต้นจะได้ข้อมูลที่เรียงลำดับจากค่าน้อยไปมาก ถ้าต้องการเรียงลำดับข้อมูลจากมากไปน้อย ก็ให้เปลี่ยนการสลับข้อมูลที่มีค่าน้อยที่สุดกับข้อมูลตำแหน่งที่ N-1 เพราะค่าที่ต้องการจัดเรียงจะอยู่ด้านขวาสุดของอาเรย์นั้นเอง ดังตัวอย่างโปรแกรม
|
int studentScore[] = {15, 11, 2, 8, 23, 9, 20, 6};
int max = 0, maxIndex = 0;
//จัดเรียงข้อมูลแบบ Selection Sort จากน้อยไปมาก
for(int i = studentScore.length-1; i >= 0; i--){
max = studentScore[i];
maxIndex = i;
for(int j = 0; j < i-1; j++){
if(studentScore[j] > max)
maxIndex = j;
}
temp = studentScore[maxIndex];
studentScore[maxIndex] = studentScore[i];
studentScore[i] = temp;
}
// แสดงผลลัพธ์การจัดเรียง
for(int i = 0; i < studentScore.length; i++){
System.out.print(“\t” + studentScore[i]);
}
…
|
ผลลัพธ์ทางหน้าจอ
|
|
| การค้นหาข้อมูล |
| |
ตัวอย่างโปรแกรม
|
import java.io.*;
class Search{
public static void main(String[] args){
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
int col=8;
int data[]= {5, 10,20,25,30,60,70,80};
int i, j, key=0, element=0, low=0, high=0, middle=0;
int found=0, check=0;
try{
System.out.print("\nEnter the item you are searching for: ");
key=Integer.parseInt(br.readLine());
}catch(IOException e){}
found=0; low = 0; high = col - 1;
while (low <= high){
middle = (low + high) / 2;
if (key == data[middle]){
found=1; break;
}else if (key < data[middle])
high = middle - 1; // search low end of array
else
low = middle + 1; // search high end of array
}
if (found==1){
check=1; element = middle;
System.out.println("Found value in col: "+element );
}
if(check==0)
System.out.println("Value not found");
System.out.println("\nElement="+element);
System.out.println("\nLow="+low+" Middle="+middle+" High="+high);
}
}
|
ผลลัพธ์ทางหน้าจอ
|
Enter the item you are searching for: 20
Found value in col : 2
Element = 2
Low=2 Middle=2 High = 2
|
| |
| หน่วยที่ 8 การใช้งาน Method |
|
| โครงสร้างของ Class (Class Structure) |
| |
//การเรียกใช้ Class Libraries
import java.io.*;
//การประกาศ Class
public class TestStructure{
ภายใน Class ประกอบด้วย 2 ส่วนคือ
1. ตัวแปร(Variable), Attribute, Property, Object
//การประกาศตัวแปร
//การสร้าง Object
2. ฟังก์ชั่น (Function), Method, Action
//การประกาศฟังก์ชั่น หรือ Method
}
| การเรียกใช้ Class Libraries |
| |
Class Library คือแหล่งรวบรวมฟังก์ชั่นหรือโปรแกรมต่างๆของ Java ที่เขียนไว้แล้วและสามารถเรียกใช้ได้ทันที เรียกอีกอย่างว่า Java Package โดยต้องใช้คำสั่ง import ตามด้วยชื่อ Package และ Class ตัวอย่างเช่น
import java.io.*; เป็นการเรียกใช้คำสั่งที่อยู่ใน Java Package ที่ชื่อว่า java.io และ * คือนำเข้าคำสั่งมาใช้ได้ทุกๆ Class ที่อยู่ใน java.io
Java Package ได้แก่
java.applet เป็น Package ที่รวบรวม Class ที่จำเป็นในการสร้าง Applet และคำสั่งที่นำไปเรียกใช้งานเพื่อดูข้อมูลที่อยู่ใน Applet (Applet Context)
java.awt เป็น Package ที่รวบรวม Class ที่ใช้ในการสร้าง User Interface (Button, BorderLayout, Menu, Font ,…) การวาดภาพ Graphic และคำสั่งเกี่ยวกับรูปภาพ
java.io เป็น Package ที่รวบรวม Class ที่ใช้ในการรับข้อมูลนำเข้าและส่งออก (Input/Output) การจัดการเกี่ยวกับ File
java.lang เป็น Package พื้นฐานของ Java รวบรวม Class ที่สำคัญและเรียกใช้ได้ทันที่โดยไม่ต้อง import เพราะ java จะรวบรวม class ที่อยู่ใน java.lang ให้เองอัตโนมัติ
java.math เป็น Package ของ Java ที่รวบรวมคำสั่งที่ใช้ในการคำนวณทางคณิตศาสตร์
java.util เป็น Package ของ Java ที่รวบรวมคำสั่งเกี่ยวกับเวลา และอรรถประโยชน์อื่นๆ เพื่อเพิ่มความสะดวกในงานบางอย่าง
javax.swing เป็น Package ของ Java ที่รวบรวมคำสั่งที่ใช้ในการสร้าง User Interface
| การประกาศตัวแปร |
| |
<data_type> <variable_name> [=<value>];
เมื่อ
data_type คือ ชนิดข้อมูล
variable_name คือชื่อของตัวแปร
value คือค่าของข้อมูลตามชนิดข้อมูล
ตัวอย่างเช่น
int x = 0, y, z = 10;
float a, b, c = 10f;
| การสร้าง Object |
| |
<Class_name> <Object_name> = new <Class_name>(<Class_argument>);
เมื่อ
Class_name คือ ชื่อของ Class
Object_name คือชื่อของตัวแปร Object
Class_argument คือตัวแปรในการรับเข้ามาในการสร้าง Class ขึ้นอยู่กับ Constructor ของ Class นั้นๆ
ตัวอย่างเช่น
BufferedReader input = new BufferedReader(new InputStreamReader(System.in));
ตัวอย่างการเขียนโปรแกรมเชิงวัตถุ
class TestObject1 {
public static void main(String[] args) {
System.out.println("Show in Class TestObject1 is"+"Hello World!");
TestObject2 obj = new TestObject2();
obj.show("My name is Somsri");
}
}
class TestObject2 {
public void show(String text) {
System.out.println("Show in Class TestObject2 is "+text);
}
}
| โครงสร้างของ Method (Method Structure) |
| |
การประกาศฟังก์ชั่นหรือ Method รูปแบบทั่วไปของ Method จะเป็นดังนี้
accessibility return_data_type methodName(parameter_list){
//รายละเอียด
}
เมื่อ
accessibility คือ การกำหนดชนิดการเรียกใช้ และการเข้าถึง Method
ตัวอย่างของ accessibility เช่น public, protected, private, static เป็นต้น
return_data_type คือ ค่าที่ส่งกลับมาจาก Method ถ้าไม่มีใช้คำว่า void ตัวอย่างของ return_data_type เช่น int, char, String, float, int[], String[] เป็นต้น
methodName คือชื่อของ Method เช่น maxFunction
parameter_list คือตัวแปรที่รับเข้ามาใน Method ตัวอย่างของ parameter_list เช่น int x1, float x2, char x3 เป็นต้น
ตัวอย่างการประกาศ Method
int maxFunction(int x1, int x2){
int max = 0;
if(x1 > x2)
max = x1;
else
max = x2;
return(max);
}
คำอธิบาย
ชื่อ Method คือ maxFunction รับข้อมูลเข้ามาเป็นจำนวนเต็ม 2 ตัว คือ int x1 และ int x2 และส่งค่ากลับเป็น int
หน้าที่ของ Method นี้ คือทำการตรวจค่าของ x1 และ x2 ว่าตัวใดมีค่ามากที่สุด จากนั้นกำหนดค่าให้ตัวแปร max เพื่อส่งค่ากลับaccessibility ของ Method
accessibility เป็นการกำหนดชนิดของการเรียกใช้ ใช้กำหนดขอบเขตการใช้งานของตัวแปร, Method หรือ Class แบ่งออกเป็น
1. static ใช้นิยามตัวแปรและ Method ที่ต้องการให้มีค่าคงที่ สามารถนำไปใช้ได้กับทุกๆส่วนของ Class โดยค่านั้นไม่มีการเปลี่ยนแปลงไม่ว่ากรณีใดๆ
ตัวอย่างเช่น
การประกาศตัวแปรที่เป็นค่าคงที่
ใช้คำว่า static นำหน้าการประกาศตัวแปร (สามารถเปลี่ยนแปลงค่าได้)
ใช้คำว่า static final นำหน้าการประกาศตัวแปรโดยที่ไม่สามารถแก้ไขค่าได้
ต้องประกาศไว้ภายนอก Method เท่านั้น
static float PI_VALUE = 3.14159;
static final float PI_VALUE = 3.14159;
การประกาศ Method แบบ static
การประกาศ Method แบบ static สามารถเรียกใช้ใน Class หรือ เรียกผ่าน Class โดยไม่ต้องประกาศตัวแปร Object ก็ได้เพราะมีการจองตำแหน่งหน่วยความจำของ Method ไว้แน่นอนหรือคงที่ สามารถเรียกใช้งานได้ทันที
static double random(){// }
static double pow(double a, double b){// }
public static void main(String[] arg){// }
2. public ใช้นิยามตัวแปร, Method และ Class เพื่อใช้สามารถนำไปใช้กับ Class หรือโปรแกรมอื่นได้
ตัวอย่างเช่น
การประกาศตัวแปรแบบ public (ตัวแปรสาธารณะ)
ใช้คำว่า public นำหน้าการประกาศตัวแปร
เป็นการเรียกใช้งานตัวแปรตามปกติ โดยสามารถเข้าถึงได้ทุกส่วนของโปรแกรมและเรียกใช้ผ่าน object ของ Class ได้
public float score = 0.0;
การประกาศ Method แบบ public
การประกาศ Method แบบ public สามารถเรียกใช้งานได้ทั้งใน Class และโปรแกรมที่อยู่นอก Class โดยเรียกใช้ผ่าน object ของ Class นั้นๆ
public void function_1(int x){// }
การประกาศ Class แบบ public สามารถเข้าถึงหรือประกาศ object ของ Class ได้จากโปรแกรมหรือ Class อื่นได้
public class Test1{
}
3. private ใช้นิยามตัวแปรและ Method เพื่อให้เรียกใช้ได้เฉพาะภายใน Class ที่สร้างตัวแปรหรือ Method นั้นๆเท่านั้น
ตัวอย่างเช่น
การประกาศตัวแปรแบบ private (ตัวแปรเฉพาะ)
ใช้คำว่า private นำหน้าการประกาศตัวแปร
เป็นการเรียกใช้งานตัวแปรโดยสามารถเข้าถึงได้เฉพาะส่วนที่ประกาศตัวแปรนั้น เช่น ใน Method หรือภายใน Class ได้เท่านั้น
private float score = 0.0;
การประกาศ Method แบบ private
การประกาศ Method แบบ private สามารถเรียกใช้งานได้เฉพาะใน Class ที่ประกาศ Method นั้นเท่านั้น
private void function_1(int x){// }
4. protected ใช้นิยามตัวแปรและ Method ที่ใช้ได้เฉพาะ Class ที่สร้างขึ้นมาด้วยวิธีการสืบทอด (Inheritance) เท่านั้น โดยปกติจะใช้ protected กับ Class ที่เป็น Class ต้นฉบับ (Base Class)
ตัวอย่างเช่น
การประกาศตัวแปรแบบ protected
ใช้คำว่า protected นำหน้าการประกาศตัวแปร
เป็นการเรียกใช้งานตัวแปรโดยสามารถเข้าถึงได้ภายใน Method หรือ Class ได้เท่านั้น เรียกใช้ภายนอก Class ไม่ได้
protected float score = 0.0;
การประกาศ Method แบบ protected
การประกาศ Method แบบ protected สามารถเรียกใช้งานได้เฉพาะใน Class ที่ประกาศ Method นั้น หรือ Class ที่ได้มาจากการสืบทอดเท่านั้น
protected void function_1(int x){// }
5. void ใช้นิยาม Method โดยไม่มีการส่งค่าใดๆกลับมาจาก Method นั้น (ไม่ต้องมีคำสั่ง return)
ถ้าไม่มีการระบุค่า Accessibility จะหมายถึง
ตัวแปร ใช้ได้เฉพาะใน Method ที่นิยามตัวแปรนั้นเท่านั้น
Method ใช้ได้เฉพาะภายใน Class นั้นเท่านั้น Class อื่นจะมาเรียกใช้ไม่ได้
Class ใช้ได้เฉพาะภายในไฟล์ได้เท่านั้น โปรแกรมอื่นหรือไฟล์อื่นจะมาเรียกใช้ Method หรือ ตัวแปรต่างๆใน class นี่ไม่ได้
ตัวอย่างการเขียนโปรแกรมโดยมีการเรียกใช้ Method
import java.io.*;
class TestMethod{
static int score = 0;
public static void input(){
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
try{
System.out.print("Input Score:");
score = Integer.parseInt(br.readLine());
}catch(IOException e){}
}
public static char process(int score){
char grade='F';
if(score >80 && score<=100){
grade='A';
}else if(score >70 && score<=80){
grade='B';
}else if(score >60 && score<=70){
grade='C';
}else if(score >50 && score<=60){
grade='D';
}else {
grade='F';
}
return(grade);
}
public static void output(int score, char grade){
System.out.println("******* Show Output ********");
System.out.println("Your Score = "+score);
System.out.println("Your Grade = "+grade);
}
public static void main(String[] args) {
TestMethod obj = new TestMethod();
char grade='F';
System.out.println("** Method Main ***");
obj.input();
grade=process(score);
output(score,grade);
}
}
| การเรียกใช้ Method |
| |
การเรียกใช้งาน Method ดังในโปรแกรมตัวอย่าง มีขั้นตอนการทำงานดังนี้
1. สร้าง Object ของ Class ที่ต้องการเรียกใช้ Method นั้น โดยการใช้คำสั่ง
<Class_name> <Object_name> = new <Class_name>(<Class_argument>);
ตัวอย่างเช่น
TestMethod obj = new TestMethod();
ในกรณีที่ Method มีการมีนิยามการใช้งานแบบ Static แสดงว่า Method นั้นสามารถเรียกใช้งานได้เลยโดยไม่ต้องสร้าง Object
2. เรียก Method ที่มีอยู่ใน Class นั้นผ่านตัวแปร Object โดยใช้เครื่องหมายจุด(.) ในการเข้าถึง Method นั้นๆ
ตัวอย่างเช่น
obj.input(); เรียก Method ที่ชื่อ input ผ่าน Object ที่ชื่อ obj
output(score,grade); เรียก Method ที่ชื่อ output โดยไม่ต้องสร้าง Object เพราะMethod นี้เป็นแบบ static
3. ส่งข้อมูลนำเข้าให้กับ Method นั้น ดังตัวอย่างเช่น
grade=process(score); ใน Method ที่ชื่อ process มีการรับจำนวนเต็มเข้ามา
ถ้าไม่มีข้อมูลนำเข้า เช่น obj.input(); ต้องเขียนชื่อ Method ตามด้วยวงเล็บ
4. รับข้อมูลที่ส่งกลับมาจาก Method นั้น ดังตัวอย่างเช่น
grade=process(score); ใน Method ที่ชื่อ process มีการส่งค่ากลับเป็นตัวอักษร ดังนั้นต้องตัวแปรที่ชื่อ grade มารับข้อมูลที่เป็นตัวอักษร ถ้าไม่มีข้อมูลส่งกลับมา หรือ void ใน Method เช่น output(score,grade); ไม่มีการส่งค่ากลับก็ไม่ต้องมีตัวแปรมารับค่าแต่อย่างใด
|
|
|
| การส่งผ่าน Argument |
| |
การส่งผ่านค่าให้กับ Method มี 2 แบบ คือ
1. การส่งผ่าน Argument แบบค่า (Pass by value) เป็นการรับข้อมูลนำเข้ามาใน Method โดยไม่ส่งผลกระทบ หรือเปลี่ยนแปลงค่าของตัวแปรที่รับมา ซึ่งตัวแปรใน Parameter ของ Method จะรับมาเฉพาะค่าของข้อมูลเท่านั้น ดังตัวอย่างเช่น
static void swapFunction(int x1, int x2){
int temp = 0;
temp = x1;
x1 = x2;
x2 =temp;
}
public static void main(String[] args) {
int x=45, y = 50;
System.out.println(“Before: ”+“X= ”+x+ “ Y= ”+y);
swapFunction(x, y);
System.out.println(“After: ”+ “X= ”+x+ “ Y= ”+y);
}
ผลลัพธ์ทางจอภาพ
Before: X= 45 Y = 50
After: X= 45 Y = 50
คำอธิบาย
ตัวอย่างโปรแกรมข้างบนใน Method maxFunction มี ตัวแปร x1 และ x2 เป็น parameter และใน Method main มีการส่งข้อมูลให้กับ Method maxFunction ซึ่งรับข้อมูลผ่าน Argument ที่ชื่อ x, y มีค่าเท่ากับ 45 และ 50 ตามลำดับ เมื่อมีการเรียกใช้งาน Method จะทำให้ตัวแปร x1 และ x2 คัดลอกค่าของ x และ y เก็บไว้ตามลำดับ แล้วนำไปประมวลผล โดยไม่ส่งผลกระทบหรือสามารถเปลี่ยนค่าของ x และ y ใน Method main ได้
2. การส่งผ่าน Argument แบบอ้างอิง (Pass by reference) เป็นการรับข้อมูลเข้ามาใน Method โดยการส่งตำแหน่งอ้างอิงของตัวแปรนั้นๆมาด้วย ซึ่งมีผลทำให้ตัวแปรใน Parameter ที่มีการรับแบบอ้างอิง ถ้ามีการเปลี่ยนแปลงค่าก็จะทำให้ค่าของตัวแปรที่ส่งมาถูกเปลี่ยนแปลงค่าตามไปด้วย ส่วนใหญ่แล้วจะเป็นการรับค่าของตัวแปรแบบ อาเรย์ ดังตัวอย่างเช่น
static void swapFunction(int[] x){
int temp = 0;
temp = x[0];
x[0] = x[1];
x[1] =temp;
}
vpublic static void main(String[] args) {
int[] x ={45, 50};
System.out.println(“Before : ”+ “X[0] = ”+x[0]+ “ , X[1] = ”+x[1]);
swapFunction(x);
System.out.println(“After : ”+ “X[0] = ”+x[0]+ “ X[1] = ”+x[1]);
}
ผลลัพธ์ทางจอภาพ
Before : X[0] = 45 , X[1] = 50
After : X[0] = 50 , X[1] = 45
| |
| หน่วยที่ 9 การใช้งาน String Class |
|
| การสร้าง String |
| |
คำสั่งที่ใช้ในการสร้าง String มีทั้งหมด 6 รูปแบบดังนี้
รูปแบบคำสั่งที่ 1
String stringName = new String( text );
stringName คือ ชื่อตัวแปร Object
text คือ ข้อความที่ต้องการเก็บไว้ในตัวแปร Object เช่น “Hello”
ตัวอย่างคำสั่งเช่น
String studentName = new String(“Somsri”);
คำอธิบาย
เป็นการกำหนดตัวแปร Object ชื่อ studentName เก็บข้อมูลแบบ String มีค่าเท่ากับ Somsri
รูปแบบคำสั่งที่ 2
String stringName = text;
stringName คือ ชื่อตัวแปร Object
text คือ ข้อความที่ต้องการเก็บไว้ในตัวแปร Object เช่น “Hello”
ตัวอย่างคำสั่งเช่น
String studentWord = “Welcome”;
คำอธิบาย
เป็นการกำหนดตัวแปร Object ชื่อ studentWord เก็บข้อมูลแบบ String มีค่าเท่ากับ Welcome
รูปแบบคำสั่งที่ 3
String stringName = = new String(char charName[]);
charName คือ ชื่อตัวแปรอาเรย์ ที่มีชนิดข้อมูลตัวอักขระ (char)
ตัวอย่างคำสั่งเช่น
char text[] = { ‘H’, ‘E’, ‘L’, ‘L’, ‘O’};
String studentWord = new String(text);
คำอธิบาย
ในขั้นแรกต้องสร้างตัวแปรอาเรย์ที่ชื่อ text เก็บค่าข้อมูลก่อนจากนั้นจึงกำหนดตัวแปร Object ชื่อ studentWord เก็บข้อมูลแบบ String โดยรับค่ามาจากตัวแปรอาเรย์ที่ชื่อ text ซึ่งทำให้ตัวแปร studentWord มีค่าเท่ากับ HELLO
รูปแบบคำสั่งที่ 4
String stringName = = new String(char charName[], int startIndex, int numChars);
charName คือ ชื่อตัวแปรอาเรย์ ที่มีชนิดข้อมูลตัวอักขระ (char)
startIndex คือตัวแปรจำนวนเต็ม (int) เป็นตำแหน่งข้อมูลในอาเรย์ที่ชื่อ charName
numChars คือตัวแปรจำนวนเต็ม (int) บอกจำนวนตัวอักขระที่ต้องการ
ตัวอย่างคำสั่งเช่น
char text[] = { ‘H’, ‘E’, ‘L’, ‘L’, ‘O’};
String studentWord = new String(text, 2, 3);
คำอธิบาย
ตัวแปรอาเรย์ที่ชื่อ text เก็บค่าข้อมูลที่ประกอบด้วยตัวอักษร H, E, L, L, O ตามลำดับจากนั้นจึงกำหนดตัวแปร Object ชื่อ studentWord เก็บข้อมูลแบบ String โดยรับค่ามาจากตัวแปรอาเรย์ที่ชื่อ text ตำแหน่งตัวอักษรที่ 2 มาจำนวน 3 ตัวอักษร ซึ่งทำให้ตัวแปร studentWord มีค่าเท่ากับ LLO
รูปแบบคำสั่งที่ 5
String stringName = = new String(byte byteName[]);
byteName คือ ชื่อตัวแปรอาเรย์ ที่มีชนิดข้อมูลจำนวนเต็ม (byte) หรือรหัส Ascii ของตัวอักขระ
ตัวอย่างคำสั่งเช่น
char ascii[] = { 65, 66, 67, 68, 69, 70, 71};
String studentWord = new String(ascii);
คำอธิบาย
ตัวแปรอาเรย์ที่ชื่อ ascii เก็บค่าข้อมูลเป็นรหัส Ascii ของตัวอักขระ A, B, C, D, E, F ตามลำดับ ก่อนจากนั้นจึงกำหนดตัวแปร Object ชื่อ studentWord เก็บข้อมูลแบบ String โดยรับค่ามาจากตัวแปรอาเรย์ที่ชื่อ ascii ซึ่งทำให้ตัวแปร studentWord มีค่าเท่ากับ ABCDEF
รูปแบบคำสั่งที่6
String stringName = = new String(byte byteName[], int startIndex, int numByte);
byteName คือ ชื่อตัวแปรอาเรย์ ที่มีชนิดข้อมูลจำนวนเต็ม (byte) หรือรหัส Ascii ของตัวอักขระ
startIndex คือตัวแปรจำนวนเต็ม (int) เป็นตำแหน่งข้อมูลในอาเรย์ที่ชื่อ byteName
numByte คือตัวแปรจำนวนเต็ม (int) บอกจำนวนตัวอักขระที่ต้องการ
ตัวอย่างคำสั่งเช่น
char ascii[] = { 65, 66, 67, 68, 69, 70, 71};
String studentWord = new String(ascii, 2, 3);
คำอธิบาย
ตัวแปรอาเรย์ที่ชื่อ ascii เก็บค่าข้อมูลเป็นรหัส Ascii ของตัวอักขระ A, B, C, D, E, F ตามลำดับ ก่อนจากนั้นจึงกำหนดตัวแปร Object ชื่อ studentWord เก็บข้อมูลแบบ String โดยรับค่ามาจากตัวแปรอาเรย์ที่ชื่อ ascii ตำแหน่งที่ 2 มาจำนวน 3 ตัวอักษร ซึ่งทำให้ตัวแปร studentWord มีค่าเท่ากับ CDE
| การเปรียบเทียบ String |
| |
การเปรียบเทียบ String คือการตรวจสอบว่าString ทั้งสองตัวเป็น Object ที่เก็บค่าข้อมูลเดียวกันหรือไม่ มีการใช้คำสั่งในการเปรียบเทียบ ดังนี้
2.1 รูปแบบคำสั่งที่1 การใช้เครื่องหมายเท่ากับ (==)
string1 == string2
เมื่อ string1 และ string2 คือ ชื่อตัวแปร Object แบบ String
ตัวอย่างคำสั่งเช่น
String studentWord1 = “HELLO”;
String studentWord2 = “Hello”;
if(studentWord1 == studentWord2)
System.out.println(“String ทั้งสองมีค่าเท่ากัน”);
else
System.out.println(“String ทั้งสองมีค่าไม่เท่ากัน”);
คำอธิบาย
ผลลัพธ์จากตัวอย่างข้างบน จะทำการแสดงข้อความว่า “String ทั้งสองมีค่าไม่เท่ากัน” ออกทางจอภาพ เพราะว่าตัวแปร String ทั้งสองเก็บค่าข้อมูลไม่เหมือนกัน
2.2 รูปแบบคำสั่งที่2 การใช้คำสั่ง equals
string1.equals(string2)
ตัวอย่างคำสั่งเช่น
String studentWord1 = “HELLO”;
String studentWord2 = “HELLO”;
if(studentWord1.equals( studentWord2))
System.out.println(“String ทั้งสองมีค่าเท่ากัน”);
else
System.out.println(“String ทั้งสองมีค่าไม่เท่ากัน”);
คำอธิบาย
ผลลัพธ์จากตัวอย่างข้างบน จะทำการแสดงข้อความว่า “String ทั้งสองมีค่าเท่ากัน” ออกทางจอภาพ เพราะว่าตัวแปร String ทั้งสองเก็บค่าข้อมูลเหมือนกัน
2.3 รูปแบบคำสั่งที่3 การใช้คำสั่ง compareTo
string1.compareTo(string2)
การใช้คำสั่งนี้จะทำการเปรียบเทียบตัวอักขระใน sting1 เทียบกับ sring2 ทีละตัวในตำแหน่งเดียวกันไปเรื่อยๆ ซึ่งถ้ามีข้อมูลเดียวกันจำนวนเท่ากันก็จะ return ค่าเป็น 0 แต่ถ้ามีตัวใดตัวหนึ่ง หรือมีขนาดข้อมูลต่างกันก็จะ return เป็นผลต่างของรหัส Ascii ของข้อมูลใน String ทั้งสอง ซึ่งมีผลลัพธ์ ดังนี้
เป็นลบ (-) ถ้า String1 มีค่าน้อยกว่า String2
เป็นบวก (+) ถ้า String1 มีค่ามากกว่า String2
เป็นศูนย์ (0) ถ้า String1 มีค่าเท่ากับ String2
ตัวอย่างคำสั่งเช่น
String studentWord1 = “HELLO”;
String studentWord2 = “Hello”;
int check = studentWord1. compareTo( studentWord2);
if(check == 0)
System.out.println(“String ทั้งสองมีค่าเท่ากัน”);
else
System.out.println(“String ทั้งสองมีค่าไม่เท่ากัน”);
คำอธิบาย
ผลลัพธ์จากตัวอย่างข้างบน จะทำการแสดงข้อความว่า “String ทั้งสองมีไม่ค่าเท่ากัน” ออกทางจอภาพ เพราะคำสั่ง compareTo จะเปรียบเทียบว่าตัวแปร String ทั้งสองเก็บค่าข้อมูลเหมือนกันหรือไม่ ซึ่งมีค่าตัวอักษรต่างกันโดย studentWord1 เก็บตัวอักษรพิมพ์ใหญ่ (มีรหัส Ascii น้อยกว่า studentWord2) ทำให้ได้ผลลัพธ์เป็นค่าลบ (ตัวแปร check มีค่าเท่ากับ -32 )
| การเชื่อม String (Concatenation) |
| |
3.1 การเชื่อม String โดยใช้เครื่องหมายบวก (+)
การเชื่อม String ตั้งแต่ 2 ตัวขึ้นไปจะให้เครื่องหมายบวก (+) เพื่อสร้างรูปประโยคข้อความให้ยาวขึ้น หรือเชื่อมประโยคข้อความกับตัวเลข
ตัวอย่างคำสั่งเช่น
String myString = “ X = ” + 2 + 3;
System.out.println(myString);
ผลลัพธ์ทางจอภาพ
X = 23
ตัวอย่างคำสั่งเช่น
String myString = “ X = ” + ‘2’ + ‘3’;
System.out.println(myString);
ผลลัพธ์ทางจอภาพ
X = 23
ตัวอย่างคำสั่งเช่น
String myString = “ X = ” + (2 + 3);
System.out.println(myString);
ผลลัพธ์ทางจอภาพ
X = 5
3.2 การเชื่อม String โดยใช้คำสั่ง concat
รูปแบบคำสั่ง
String string3 = string1.concat (string2);
ตัวอย่างคำสั่งเช่น
String studentWord1 = “Hello”;
String studentWord2 = “ World”;
String myString = studentWord1.concat(studentWord2);
System.out.println(“My string is ” + myString);
ผลลัพธ์ทางจอภาพ
My string is Hello World
| การดึงข้อความบางส่วนจาก String |
| |
เป็นการดึงข้อความ หรือตัดคำใน String โดยการบอกตำแหน่งเริ่มต้นและสุดท้ายของความที่ต้องการตัด
รูปแบบคำสั่ง
String string2 = string1.substring(n, m);
n คือตัวเลขที่บอกตำแหน่งเริ่มต้นใน string1 ของข้อความที่ต้องการ
m คือตัวเลขที่บอกตำแหน่งสุดท้ายใน string1 ของข้อความที่ต้องการ
ตัวอย่างคำสั่งเช่น
String studentWord1 = “WELCOME to Java”;
String myString = studentWord1. substring(0,7);
System.out.println(“My string is ” + myString);
ผลลัพธ์ทางจอภาพ
My string is WELCOME
การดึงตัวอักขระใน String
เป็นการใช้คำสั่ง charAt() เพื่อดึงเอาตัวอักขระที่อยู่ใน String โดยการระบุตำแหน่งที่ต้องการ ผลลัพธ์ที่ได้จะ return ค่าเป็นตัวอักขระในตำแหน่งนั้นใน String
รูปแบบคำสั่ง
char charName = string1.charAt( n );
n คือ เลขจำนวนเต็ม บอกตำแหน่งของอักขระใน string1
ตัวอย่างคำสั่งเช่น
String studentWord1 = “WELCOME”;
char letter = studentWord1.charAt(3);
System.out.println(“Character in studentWord1 is ” + letter);
ผลลัพธ์ทางจอภาพ
Character in studentWord1 is C
| การแทนที่ตัวอักขระใน String |
| |
ใช้คำสั่ง replace() เป็นการแทนที่ตัวอักขระใน String ด้วยตัวอักขระอื่นโดยแทนตัวอักขระเดิมที่มีอยู่ใน String ด้วยตัวอักขระใหม่
รูปแบบคำสั่ง
String string2 = string1.replace(oldChar, newChar);
oldChar คือตัวอักขระที่มีอยู่ใน string1
newChar คือตัวอักขระใหม่ที่ต้องการแทนที่
ตัวอย่างคำสั่งเช่น
String studentWord1 = “WELCOME to Java”;
String myString = studentWord1.replace(‘a’, ‘o’);
System.out.println(“My string is ” + myString);
ผลลัพธ์ทางจอภาพ
My string is HELLO to Jovo
| การตัดช่องว่างใน String |
| |
ใช้คำสั่ง trim() เป็นตัดช่องว่างหน้าและหลังของข้อความที่อยู่ใน String
รูปแบบคำสั่ง
String string2 = string1.trim();
ตัวอย่างคำสั่งเช่น
String studentWord1 = “ My name is Somsri ”;
String myString = studentWord1.trim();
System.out.println(“My string is ” + myString);
ผลลัพธ์ทางจอภาพ
My string is My name is Somsri
| ความยาวของ String |
| |
เป็นการใช้คำสั่ง length() เพื่อตรวจสอบความยาวของ String โดยการ return
ค่าเป็นจำนวนเต็มเท่ากับจำนวนตัวอักขระทั้งหมดที่อยู่ใน String
รูปแบบคำสั่ง
int lenString = string1.length();
ตัวอย่างคำสั่งเช่น
String studentWord1 = “WELCOME”;
int len = studentWord1.length();
System.out.println(“Length of studentWord1 is ” + len);
ผลลัพธ์ทางจอภาพ
Length of studentWord1 is 7
| การค้นหาใน String |
| |
ในการค้นหาข้อความใน String จะใช้ Method 2 Method ดังนี้
indexOf() ใช้ในการค้นหาข้อความที่พบเป็นชุดแรก
lastIndexOf() ใช้ในการค้นหาข้อความที่พบเป็นชุดสุดท้าย
รูปแบบคำสั่ง
int pos = string1.indexOf( text ); หรือ
int pos = string1.indexOf( text , n);
int pos = string1.lastIndexOf( text ); หรือ
int pos = string1.lastIndexOf( text , n );
pos คือ เลขจำนวนเต็มแสดงตำแหน่งที่ค้นพบ
n คือ เลขจำนวนเต็ม บอกตำแหน่งเริ่มต้นใน string1 ที่ต้องการค้นหา
text คือ ข้อความที่ต้องการค้นหาใน string1
ผลลัพธ์ที่ได้ คือ ตัวเลขแสดงตำแหน่งที่ค้นพบ
ตัวอย่างคำสั่งเช่น
String studentWord1 = "Welcome to Java, Hello everybody, My name is Somsri, Hello!!!";
int pos1 = studentWord1.indexOf("Hello");
int pos2 = studentWord1.indexOf("Hello", 25);
int pos3 = studentWord1.lastIndexOf("Hello");
int pos4 = studentWord1.lastIndexOf("Hello", 25);
System.out.println("pos1 = " + pos1);
System.out.println("pos2 = " + pos2);
System.out.println("pos3 = " + pos3);
System.out.println("pos4 = " + pos4);
ผลลัพธ์ทางจอภาพ
pos1 = 17
pos1 = 53
pos1 = 53
pos1 = 17
อธิบายโปรแกรม
จากตัวอย่างโปรแกรมข้างต้น ข้อความใน String ที่ชื่อ studentWord1 มีค่าเท่ากับ Welcome to Java, Hello everybody, My name is Somsri, Hello!!! และในโปรแกรมต้องการค้นหาข้อความ Hello ซึ่งปรากฏอยู่ใน studentWord1 ตำแหน่งที่ 17 และ 53 ดังนั้นเมื่อใช้คำสั่ง studentWord1.indexOf("Hello") จะได้ผลลัพธ์เท่ากับ 17 เพราะเป็นตำแหน่งแรกที่ค้นพบ และคำสั่ง studentWord1.lastIndexOf("Hello") จะได้ผลลัพธ์เท่ากับ 53 เพราะเป็นตำแน่งสุดท้ายที่ค้นพบ
| การแปลงตัวอักษรใน String |
| |
การแปลงตัวอักษรใน String มี 2 วิธี ดังนี้
1. การแปลงตัวอักษรจากตัวอักษรพิมพ์ใหญ่ไปเป็นตัวอักษรพิมพ์เล็กทั้งหมดใน String โดยใช้คำสั่ง toLowerCase() มีรูปแบบคำสั่งดังนี้
รูปแบบคำสั่ง
String stringName = string1.toLowerCase();
2. การแปลงตัวอักษรจากตัวอักษรพิมพ์เล็กไปเป็นตัวอักษรพิมพ์ใหญ่ทั้งหมดใน String โดยใช้คำสั่ง toUpperCase() มีรูปแบบคำสั่งดังนี้
รูปแบบคำสั่ง
String stringName = string1.toUpperCase();
ตัวอย่างคำสั่งเช่น
String studentWord1 = "My name is Somsri";
String text1 = studentWord1.toLowerCase();
String text2 = studentWord1.toUpperCase();
System.out.println("Text1 = " + text1);
System.out.println("Text2 = " + text2);
ผลลัพธ์ทางจอภาพ
Text1 = my name is somsri
Text2 = MY NAME IS SOMSRI
| StringTokenizer |
| |
StringTokenizer เป็น Class ที่อยู่ใน package ที่ชื่อ java.util โดยทำหน้าที่ในการแบ่งข้อความออกเป็นส่วนๆตามสัญลักษณ์ที่กำหนด หรือสัญลักษณ์มาตรฐาน เช่น ช่องว่าง(Space) แท็บ (Tab) และขึ้นบรรทัดใหม่ (Newline) สัญลักษณ์ที่ใช้แบ่งข้อความเหล่านี้ เรียกว่า delimiter ส่วนข้อความที่แบ่งออกมาได้เรียกว่า token
รูปแบบคำสั่ง
StringTokenizer(String s, String delim, boolen returnTokens)
StringTokenizer(String s, String delim) ใช้ในการแบ่ง String ที่ชื่อ s ออกเป็น Token หรือเป็นคำๆด้วยสัญลักษณ์ที่ส่งมากับตัวแปร String ที่ชื่อ delim
StringTokenizer(String s) ใช้ในการแบ่ง String ที่ชื่อ s ออกเป็น Token หรือเป็นคำๆด้วยสัญลักษณ์มาตรฐาน
boolean hasMoreTokens() เป็นคำสั่งในการตรวจสอบว่ามี Token หลงเหลืออยู่ใน StringTokenizer อีกหรือไม่ ซึ่งจะ return ค่ากลับเป็นจริงถ้ามี Token เหลืออยู่ มิเช่นนั้นจะเป็นเท็จ
String nextToken() เป็นคำสั่งอ่านค่า Token ถัดไปใน StringTokenizer
String nextToken(String delim) เป็นคำสั่งอ่านค่า Token ถัดไปใน StringTokenizer โดยมีการแบ่งคำตามสัญลักษณ์ใน String ที่ชื่อ delim
String countTokens() เป็นคำสั่งที่ใช้นับจำนวน Token ทั้งหมดที่ถูกแบ่งได้ทั้งหมดใน StringTokenizer
ตัวอย่างโปรแกรม
import java.util.StringTokenizer;
class TestToken {
public static void main(String[] args)
{
String input = "My name is Somsri";
StringTokenizer st= new StringTokenizer(input);
System.out.println("Count of Tokens = " + st.countTokens());
int i=0;
while(st.hasMoreTokens()){
i++;
System.out.println("Token"+(i) +" = " + st.nextToken());
}
}
}
ผลลัพธ์ทางจอภาพ
Token1 = My
Token2 = name
Token3 = is
Token4 = Somsri
คำอธิบาย
ผลลัพธ์ของโปรแกรมข้างต้นจะแยก String ที่ชื่อ input ได้ทั้งหมด 4 คำซึ่งถูกแบ่งด้วยสัญลักษณ์มาตรฐาน (ช่องว่าง) ด้วยคำสั่ง StringTokenizer st= new StringTokenizer(input) เก็บไว้ในตัวแปร Object ของ Class StringTokenizer ที่ชื่อ st จากนั้นวนลูปตรวจสอบว่ามี Token ใน st ยังเหลืออยู่หรือไม่ แล้วแสดงผล Token แต่ละตัวด้วยคำสั่ง st.nextToken() จนกว่าจะหมด Token ใน st ซึ่งได้ Token ทั้งหมด 4 คำดังผลลัพธ์ที่แสดงทางจอภาพ
| StringBuffer |
| |
เป็น Class หนึ่งที่ใช้ในการสร้างตัวแปร String ที่มีประสิทธิภาพดีกว่าการใช้คำสั่งประกาศ String ทั่วๆไปของ String Class เพราะมีความยืดหยุ่น ทำงานได้หลากหลายและประหยัดหน่วยความจำ มีรูปแบบคำสั่งที่ใช้สร้าง Object ของ Class StringBuffer (หรือ StringBuffer Class Constructor) 3 คำสั่งดังนี้
StringBuffer() ใช้ในการสร้างตัวแปร Object ของ Class StringBuffer ที่ความยาวสูงสุด 16 ตัวอักษรและมีค่าเริ่มต้นเป็น Null
StringBuffer(int length) ใช้ในการสร้างตัวแปร Object ของ Class StringBuffer ที่ความยาวของตัวอักษรตามค่าตัวแปร length และมีค่าเริ่มต้นเป็น Null
StringBuffer(String str) ใช้ในการสร้างตัวแปร Object ของ Class StringBuffer ที่มีค่าเริ่มต้นและความยาวตามตัวแปร String str
คำสั่ง Method อื่นๆที่อยู่ใน StringBuffer Class มีดังนี้
คำสั่ง append
เป็นคำสั่งที่ใช้ในการเพิ่มข้อความใหม่เข้าไปต่อท้าย String ที่มีอยู่เดิม
รูปแบบคำสั่ง
StrBuf.append(String text );
เมื่อ
trBuf คือตัวแปร Object ของ StringBufer
text คือตัวแปร String ที่เป็นข้อความที่ต้องการนำมาต่อท้าย
ตัวอย่างคำสั่งเช่น
StringBuffer strBuf = new StringBuffer("My name is ");
strBuf.append("Somsri");
System.out.println("Text = " + strBuf);
ผลลัพธ์ทางจอภาพ
Text = My name is Somsri
คำสั่ง insert
เป็นการแทรกข้อความใหม่เข้าไปใน String ที่มีอยู่เดิม โดยไม่ทับข้อความเดิมแต่เป็นการแทรกระหว่างข้อมูลที่มีอยู่เดิม
รูปแบบคำสั่ง
StrBuf.insert( int pos, String text );
เมื่อ
StrBuf คือตัวแปร Object ของ StringBufer
pos คือตัวแปรจำนวนเต็มที่บอกตำแหน่งที่ต้องการแทรก
text คือตัวแปร String ที่เป็นข้อความที่ต้องการนำมาแทรก
ตัวอย่างคำสั่งเช่น
StringBuffer strBuf = new StringBuffer("My name Somsri");
strBuf.insert(8, "is");
System.out.println("Text = " + strBuf);
ผลลัพธ์ทางจอภาพ
Text = My name is Somsri
คำสั่ง length
เป็นคำสั่งที่บอกจำนวนตัวอักขระที่อยู่ใน String หรือความยาวของ String นั่นเอง
รูปแบบคำสั่ง
StrBuf.length( );
คำสั่ง capacity
เป็นคำสั่งที่บอกขนาดความจุของ String หรือความยาวสูงสุดของ String ที่สามารถเก็บข้อมูลได้
รูปแบบคำสั่ง
StrBuf.capacity( );
ตัวอย่างคำสั่งเช่น
StringBuffer strBuf = new StringBuffer("My name is Somsri");
System.out.println("Length = " + strBuf.length());
System.out.println("Capacity = " + strBuf.capacity());
ผลลัพธ์ทางจอภาพ
Length = 17
Capacity = 33
คำสั่ง setLength
เป็นคำสั่งที่ใช้ในการกำหนดขนาดความยาวอักขระให้กับ String
รูปแบบคำสั่ง
StrBuf.setLength( int n );
เมื่อ
n คือ ตัวเลขที่บอกขนาดความยาว
คำสั่ง charAt
เป็นคำสั่งแสดงตัวอักขระที่ตำแหน่งใดๆ ส่งค่ากลับเป็นตัวอักขระ 1 ตัว
รูปแบบคำสั่ง
StrBuf.charAt( int n );
เมื่อ
n คือ ตัวเลขที่บอกตำแหน่งใดๆ
คำสั่ง setCharAt
เป็นคำสั่งแทนที่ตัวอักขระใหม่ลงในตำแหน่งที่ต้องการ
รูปแบบคำสั่ง
StrBuf.setCharAt( int n, char new );
เมื่อ
n คือ ตัวเลขที่บอกตำแหน่งใดๆ
new คือ ตัวอักขระใหม่ที่ต้องการแทนที่
คำสั่ง reverse
เป็นคำสั่งเรียงลำดับตัวอักขระใน String ใหม่จากด้านหลังไปทางด้านหน้า
รูปแบบคำสั่ง
StrBuf.reverse( );
ตัวอย่างคำสั่งเช่น
StringBuffer strBuf = new StringBuffer("abcdef");
System.out.println("Text before = " + strBuf);
System.out.println("Text after = " + strBuf.reverse());
ผลลัพธ์ทางจอภาพ
Text before = abcdef
Text after = fedcba
http://www.elearning.msu.ac.th/opencourse/1201104/Unit_1/Unit_1_01.htm |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
เริ่มต้นการเขียนโปรแกรมด้วย Java
ภาษาโปรแกรมคอมพิวเตอร์
ไม่มีความคิดเห็น:
แสดงความคิดเห็น