ตัวอย่างการใช้งาน break กับ continue ใน java

public class ExBreakAndcontinue {
    /**
     * @param args
     */
    public static void main(String[] args) {
System.out.println("###################  FOR ######################");
for (int i = 0; i < 10; i++) {

   if (i == 9) {
System.out.println("i=9 then must be break.");
break;
   }
   if ((i == 2)||(i == 4)||(i == 8)) {
continue;
   }
   System.out.println("Order [" + i + "] ");

}
System.out.println("###################  WHILE ######################");
int b=0;
while(true){
   if (b == 9) {
System.out.println("i=9 then must be break.");
b++;
break;
   }
   if ((b == 2)||(b == 4)||(b == 8)) {
b++;
continue;
   }
   System.out.println("Order [" + b + "] ");
   b++;
}
    }

}

Java Interview Questions

Java Interview Questions

วิธีการ try catch exception

JAVA
Just application!

Exception

วันนี้ เราจะมาศึกษากันในเรื่องของการเขียนโปรแกรมจัดการไฟล์กัน การจัดการไฟล์นับเป็นบทหนึ่งที่เราจะต้องศึกษาในการเขียนโปรแกรมทุก ๆ โปรแกรม อย่างน้อยล่ะก็จะต้องมี 1 บทแน่นอน เพราะการเขียนไฟล์ก็เป็นหัวใจของแอปพลิเคชั่นเหมือนกัน โปรแกรมจะส่งผลลัพธ์แก่ผู้ใช้ได้นอกจากแสดงออกทางจอภาพแล้วก็คือแสดงผลลัพธ์ออกมาเป็นไฟล์ที่จะสามารถนําไปใช้ได้นั่นเอง 

ถึงภาษาจาวาจะเป็นภาษาที่มีแนวคิดแบบใหม่ที่นิยมสร้างเป็นแอพเพล็ต แต่การเขียนจาวาเป็นแอปพลิเคชั่นก็จะต้องมีการเกี่ยวข้องกับไฟล์เช่นเดียวกัน 



การ Exception ในภาษาจาวา

ก่อนที่เราจะมาพูดถึงเรื่องของการเขียนไฟล์ เราจะมาพูดถึงเรื่องของการ Exception กันก่อน กระบวนการ Exception พูดง่าย ๆ ตามลักษณะการทํางานของมันก็คือ กระบวนการตรวจจับข้อผิดพลาดของโปรแกรมและการทํางานในโปรแกรมนั่นเอง ภาษาจาวาจะสามารถตรวจสอบข้อผิดพลาดที่เกิดขึ้นจากกระบวนการต่าง ๆ ผ่านทาง Exception

เมื่อเราศึกษาเรื่องของ Exception ในภาษาจาวา เราจะต้องรู้จักกับคีย์เวิร์ด (Keyword) 4 ตัวด้วยกันคือ try , catch , throw และ finally 

การทํางานของคีย์เวิร์ด try และ catch จะมีลักษณะการทํางานเหมือนกับ "การพยายาม (try) และการดักจับ (catch)" โดยรูปแบบนั้นจะเหมือนกับการใช้ switch และ case คือ เป็นการบอกถึงรายละเอียดหรือส่วนที่ต้องการจะนํามาทดสอบโดยใช้ try และมี catch ทําหน้าที่เหมือน case ในการตรวจจับเงื่อนไขที่ตรงกับมัน ดังโครงสร้างต่อไปนี้

[src]
try{

process A

} catch(ตรวจจับข้อผิดพลาดจากกระบวนการ A) {

process B

}
[/src]

สมมติว่า เราต้องการเปิดไฟล์ ๆ หนึ่ง จาวาจะมีคลาสที่ใช้ในกระบวนการ Exception อยู่คลาสหนึ่งที่ชื่อ FileNotFoundException เป็นคลาสที่ใช้สําหรับตรวจจับการเปิดไฟล์ที่ผิดพลาด เราจะเขียนโค๊ดโปรแกรมดังนี้

[src]
try{

.... พยายามเปิดไฟล์ A.TXT 

} catch( FileNotFoundException e ) { 

... แสดงข้อความ "ไม่พบไฟล์ A.TXT" 

}
[/src]

จากโค๊ดโปรแกรมในข้างต้น เราสามารถอธิบายลําดับการทํางานง่าย ๆ ได้ดังนี้

ในส่วนของ try ภายในเครื่องหมายปีกกา โค๊ดโปรแกรมภายในบล๊อคนี้จะพยายามเปิดไฟล์ A.TXT 
ในส่วนของ catch จะตรวจจับการผิดพลาดจากการเปิดไฟล์ โดยใช้คลาส FileNotFoundException ซึ่งใช้ตรวจจับข้อผิดพลาดจากการหาไฟล์ที่ต้องการเปิดไม่ได้ 
ในบล๊อคของ catch เป็นข้อความที่หรือสิ่งที่ต้องการให้กระทําเมื่อหาไฟล์ที่จะเปิดไม่ได้ 
การตรวจจับข้อผิดพลาดจากการเปิดไฟล์โดยใช้ Exception เราจะใช้คลาสแต่ละคลาสซึ่งจะมีหน้าที่การในการตรวจจับข้อผิดพลาดต่างกัน ในข้างต้น คลาส FileNotFoundException จะตรวจจับการเปิดไฟล์ไม่พบอย่างเดียว แต่ถ้าเราต้องการตรวจจับอย่างอื่นด้วย เราก็ใส่ catch ซ้อน ๆ กันลงไป ดังนี้

[src]
try{ 

try to do anything 

}catch(ตรวจจับ Error 1){ 

show message if found error 1

}catch(ตรวจจับ Error 2){ 

show message if found error 2

}
[/src]
หากเราลองเปรียบเทียบโค๊ดโปรแกรมภาษาซี เราจะพบว่าผลและลักษณะการทํางานก็เป็นเช่นเดียวกัน ดังนี้
[src]
FILE fp; 

if (fp=fopen("config.sys","r+t")==NULL){ 

printf("File not foundn"); 
exit(0); 

} 
[/src]
จากโปรแกรมภาษา C ในข้างต้นจะเห็นได้ว่า เป็นการตรวจจับการเปิดไฟล์เช่นเดียวกันนั่นเอง ลองเปรียบเทียบผลและแนวคิดของการใช้ Exception ดูสิครับ เราจะรู้จักการ Exception มากยิ่งขึ้น

นอกจากคีย์เวิร์ด try และ catch แล้ว ยังมี throw ที่จะใช้สําหรับเลิกการ Exception ตัวนั้น ซึ่งจะเป็นการป้องกันการเกิดข้อผิดพลาด ส่วีอีกคีย์เวิร์ดนึงก็คือ finally ซึ่งมีลักษณะเช่นเดียวกับคีย์เวิร์ด default ใน swtich..case นั่นเอง ประมาณว่าเป็นการอ้างถึงการตรวจจับข้อผิดพลาดที่เกิดขึ้นอื่น ๆ ทั้งหมด นอกเหนือจากที่กําหนดไว้ใน catch คีย์เวิร์ด finally จะดักจับทุกอย่างที่ผิดปกติ โดยไม่สนใจว่าจะเป็นอะไรทั้งนั้น 

การใช้ Exception ตรวจจับข้อผิดพลาด เราจะพบได้บ่อยมาก ไม่ว่าจะเป็นการเขียนไฟล์ และการเขียนโปรแกรมเพื่อการเชื่อมต่อกับอะไรบางอย่าง ซึ่งเราจะศึกษากันต่อไป

การอ่านและเขียนไฟล์ในภาษาจาวา

การติดต่อกับ I/O หรือคอนโซลในภาษาจาวา เราจะใช้แพ็คเก็ตที่ชื่อ java.io และใช้คําสั่ง println จากคลาส System ดังบรรทัดต่อไปนี้

[src]System.out.println("Easy Java");[/src]

เราคงจํากันได้สําหรับโค๊ดโปรแกรมในบรรทัดนี้ เพราะจะเป็นคําสั่งแรกที่เราจะต้องพบเมื่อเราเขียนโปรแกรมภาษาจาวา ในหนังสือเกือบทุกเล่มจะต้องขึ้นด้วย Hello World!

คําสั่ง println ในข้างต้นเป็นการเขียนข้อความออกทาง Standard I/O เช่นเดียวกับในภาษาอื่น แต่ในภาษาจาวา ถ้าเราจะศึกษาหรือจัดการเกี่ยวกับเรื่องของไฟล์และสตรีม เราจะต้องรู้จักกับคลาส 2 คลาสด้วยกัน คือ

1. คลาส InputStream 
2. คลาส OutputStream

คลาสทั้ง 2 นี้เป็นคลาสที่อยู่ในแพ็คเก็ต java.io โดย InputStream เป็นคลาสที่ใช้สําหรับจัดการกับอินพุต เช่น การอ่านไฟล์ , อ่านข้อมูลเข้าจากสตรีม ส่วนคลาส OutputStream ก็เป็นคลาสที่ใช้สําหรับจัดการกับเอาท์พุตสตรีม เช่น การเขียนข้อมูลลงไฟล์ เราจะมาทําความรู้จักกับคลาสทั้งสองให้ลึกลงไปกว่านี้กัน

เราจะมาศึกษาและทําความเข้าใจกันแบบง่าย ๆ และเบสิกที่สุด โดยจะไม่พูดถึงศัพท์เทคนิคหรือทฤษฎีมากมายนัก เราจะมาทําความเข้าใจกันสักเล็กน้อยกันก่อน ดังนี้ 

"การอ่านไฟล์" ก็คือ การอ่านข้อมูลจากไฟล์ต่าง ๆ เข้ามาเก็บไว้ที่บัฟเฟอร์ ซึ่งจะเป็นตัวแปรตัวหนึ่ง และเราก็สามารถนําเอาตัวแปรที่เก็บข้อมูลในไฟล์นี้ไปใช้งานต่าง ๆ ในโปรแกรมเราได้ เช่น เอามันมาแสดงในเท็กบ๊อก เป็นต้น

"การเขียนไฟล์" คือ การเขียนข้อมูลอักขระต่าง ๆ ลงในไฟล์ โดยลักษณะการเขียนไฟล์จะมีอยู่ด้วยกัน 2 ลักษณะคือ เขียนไฟล์ใหม่ และการเขียนเพิ่มเข้าไปที่ท้ายไฟล์ ในที่นี้เราจะพูดถึงการเขียนแบบเท็กซ์ไฟล์เท่านั้น 



การอ่านไฟล์ 

การอ่านข้อมูลจากไฟล์ในภาษาจาวา เราจะใช้คลาส InputStream ซึ่งภายในคลาส InputStream นี้จะมีคลาสลูกอีก 6 คลาส คือ

1. FilterInputStream
2. ByteArrayInputStream 
3. FileInputStream 
4. PipedInputStream 
5. SequenceInputStream 
6. StringBufferInputStream

คลาสทั้ง 6 ในข้างต้นเป็นคลาสที่สืบทอดมาจากคลาสแม่ InputStream ใช้สําหรับจัดการไฟล์แบบต่าง ๆ แต่ที่จะให้ศึกษากันในตอนนี้เลยก็คือคลาส FileInputStream ครับ 

คลาส FileInputStream เป็นคลาสที่จะใช้สําหรับอ่านข้อมูลจากไฟล์อินพุต ซึ่งจะมีฟังก์ชั่น read() ที่จะอ่านข้อมูลจากอินพุตคืนกลับมาให้บัฟเฟอร์ โดยเราจะมาทดลองเขียนโค๊ดและทําความเข้าใจกับโค๊ดโปรแกรมไปพร้อม ๆ กัน เป็นขั้น ๆ ดังต่อไปนี้

ขั้นที่ 1 เขียนโค๊ดโปรแกรมเพื่อเปิดไฟล์

อันดับแรกในการใช้งานไฟล์ เราจะต้องเขียนโค๊ดโปรแกรมเพื่ออ่านไฟล์ขึ้นมาก่อน โดยเราจะสร้างอ๊อปเจ้กต์ของคลาส FileInputStream ขึ้นมา ซึ่งจะต้องใช้ร่วมกับการ Exception ดังที่ได้อธิบายไปในเรื่องของการ Exception ไงครับ

[src]
FileInputStream f;

try{

f = new FileInputStream("c:config.sys");

} catch(FileNotFoundException e) {

System.out.println("File not found"); 
S ystem.exit(2); 

}
[/src]
จากโค๊ดโปรแกรมในข้างต้น จะเห็นได้ว่าในบล๊อกของ try ได้มีการสร้างอ๊อปเจ็กต์ของ FileInputStream เพื่อเปิดไฟล์ config.sys ในไดรฟ์ C: (เช่นเดียวกับภาษาซี เครื่องหมาย 2 อันแทนเครื่องหมาย หนึ่งอันในภาษาจาวา) และได้มีการตรวจจับ FileNotFoundException ถ้าหากไม่พบไฟล์นี้ กระบวนการภายในบล๊อกของ catch ก็จะถูกกระทํา ทําให้ข้อความ File not found ปรากฏบนจอและจบการทํางานของการเปิดไฟล์ 

ขั้นที่ 2 พยายามอ่านข้อมูลจากไฟล์

คราวนี้ สืบเนื่องจากขั้นตอนที่ 1 ถ้าพบไฟล์ config.sys ที่ไดรฟ์ C: ที่ต้องการเปิดแล้ว เราจะมาเขียนโค๊ดโปรแกรมเพื่ออ่านข้อมูลจากมัน ซึ่งเราจะต้องเขียนซ้อนลงไปในบล๊อกของ try ดังนี้ 

[src]
FileInputStream f;

try{

f = new FileInputStream("c:config.sys");
int ch=0;
while( ch != -1) {

try { 

ch=f.read(); 
System.out.println((char)ch); 

} catch(IOException e) { 

System.out.println("Error"); 
System.exit(2); 

}

}

}catch(FileNotFoundException e){ 

System.out.println("File not found");
System.exit(2); 

}
[/src]
จากโค๊ดโปรแกรม เรากําหนดให้ ch เป็น 0 ซึ่งจะเป็นตัวแปรที่จะคอยเก็บข้อมูลที่อ่านมาจาก config.sys ซึ่งเมื่อเข้าสู่ลูป while มันจะตรวจสอบดูว่า ch เป็น -1 หรือไม่ จากนั้นจะ try เพื่ออ่านข้อมูลมาเก็บไว้ที่ ch ถ้า ch เท่ากับ -1 แสดงว่าการอ่านไฟล์สิ้นสุดแล้ว (เพราะ read() จะคืน -1 มาให้ถ้าไม่มีข้อมูลให้อ่าน) จากนั้นบรรทัดต่อไปให้ทําการ println ข้อมูลที่อยู่ในตัวแปร ch ออกมา

ให้สังเกตดูที่กระบวนการ catch ของการอ่านข้อมูลจากไฟล์ จะเห็นได้ว่าในการ catch นั้น เราได้ catch โดยใช้คลาส IOException นั้นเป็นเพราะว่าเราได้ตรวจจับการผิดพลาดที่เกิดจาก input และ output ของสตรีม เราจึงใช้คลาส IOExeception นี้ ถ้าการอ่านข้อมูลจากสตรีมผิดพลาด มันจะแสดงข้อความ Error และสิ้นสุดการทํางานของการอ่านไฟล์

โปรแกรมทั้งหมดที่ทดสอบการอ่านไฟล์ มีดังนี้

file.txt

การเขียนข้อมูลลงไฟล์

เมื่อเรารู้จักการอ่านข้อมูลจากไฟล์แล้ว รู้จักการนํากระบวนการ Exception ไปใช้ในการอ่านข้อมูลแล้ว ในการเขียนข้อมูลลงไฟล์นั้นก็ไม่ยากอะไร เราจะมาดูที่ตัวฟังก์ชั่นและตัวคลาสกันเลยดีกว่า 

คลาสที่ใช้ในการเขียนข้อมูลลงไฟล์ คือ FileOutputStream ภายในคลาสนี้จะมีฟังก์ชั่นที่ชื่อ Write() ที่จะใช้ในการเขียนข้อมูลลงสตรีมของไฟล์ สิ่งที่เราจะมาวิเคราะห์กันนั้นอยู่ที่กระบวนการ Exception ดังโค๊ดโปรแกรม File.java ต่อไปนี้

file2.txt

จากโค๊ดโปรแกรมในข้างต้น สังเกตการ Exception ให้ดี จะเห็นว่าในการเปิดไฟล์เพื่อเขียน เราจะไม่ใช้คลาส FileNotFoundException ในการตรวจจับการเปิดไฟล์แล้ว (ให้ดูที่บล๊อก try และ catch อันแรก) เราจะใช้คลาส IOException ในการเปิดแทน เพราะเป็นการติดต่อกับสตรีม I/O ไงครับ ถ้าการเปิดไฟล์เพื่อเขียนไม่สําเร็จมันจะแสดงข้อความว่า Error to open file for write ขึ้นมา แต่ถ้าเปิดไฟล์แล้ว ไม่สามารถเขียนข้อมูลภายในไฟล์ได้ มันก็จะฟ้องว่า Error in write data (ในบล๊อก try ข้างใน) 

เพราะฉะนั้น การเกิด Exception ในโปรแกรม File.java นั้น จะเกิดได้ 2 ทางคือ

1. ในบล๊อก try อันแรกจะเกิดจากการผิดพลาดในการเปิดไฟล์ เช่น ถ้าเราเลือกพาธไปที่ไดรฟ์ A: ซึ่งได้ทําการ Write Protect เอาไว้หรือไม่มีดิสก์อยู่ข้างใน ในกรณีนี้ก็คือการผิดพลาดจากการเปิดไฟล์เพื่อเขียนไม่ได้ เพราะฉะนั้น catch ของ try ในบล๊อกแรกจึงตรวจพบและรายงานว่า Error to open file for write 

2. ในบล๊อก try ข้างใน จะถูกกระทําถ้าหากการเปิดไฟล์ new.txt เพื่อเขียนได้สําเร็จ และสามารถเกิดข้อผิดพลาดได้หากไม่สามารถเขียนข้อมูลลงไฟล์ได้ เช่น เนื้อที่ในดิสก์เต็มแล้ว หรือไม่มีเอาแผ่นดิสก์ออกจากเครื่องอ่าน เป็นต้น ในกรณีนี้ จะเกิดขึ้นเมื่อการเปิดไฟล์สําเร็จ แต่เขียนไม่ได้ catch จึงตรวจจับข้อผิดพลาดจากสตรีมเช่นกัน จะเห็นได้ว่าได้ใช้คลาส IOException เหมือนกัน

credit : hxxp://citecclub.org