คอนสตรัคเตอร์ คือ สิ่งที่มีไว้สำหรับกำหนดค่าเริ่มต้นให้กับตัวแปรคลาสของอ็อปเจ็ค คอนสตรัคเตอร์จะทำงานอัตโนมัติเมื่อมีการ new อ็อปเจ็คขึ้นมา ระบบจะทำการจองพื้นที่ในหน่วยความจำสำหรัวแปรอ็อปเจ็คแล้วตามด้วยคอนสตรัคเตอร์

การเขียน คอนสตรัคเตอร์

–          หัวของคอนสตรัคเตอร์ต้องชื่อเหมือนคลาสนั้นๆ วิธีการเรียกใช้ก็คือ new Student(…)เช่น

public class Student

{

            public double weight;

                        public Student()

{

                                    Weight = 55.75;

}

}

–          คอนสตรัคเตอร์ต้องไม่มีประเภทของผลลัพธ์ที่จะคืนค่าออกไป และก็ไม่ต้องมีคำว่า void ด้วย เพราะมันจะทำให้กลายเป็นเมท็อด

–          ไม่มีคำว่า static

รูป9-1

            สร้างคลาส Box ขึ้นมา และสร้างคอนสตรัคเตอร์ public Box() ในบรรทัดที่ 8 ภายในคอนสตรัคเตอร์ก็สามารถตั้งค่าให้กับตัวแปรได้เลย

รูป 9-2

บรรทัดที่ 6-7 : สร้างอ็อปเจ็คขึ้นมา ตรงBox() จะถือว่าเป็นการเรียกเรียกคอนสตรัคเตอร์ของ Box ค่าต่างๆใน

คอนสตรัคเตอร์ก็จะมาอยู่ที่ตัวอ็อปเจ็คเลย

บรรทัดที่ 9-10 : ให้แสดงค่าออกทางหน้าจอโดยจะเห็นว่าตรง +box1.volume() ไม่ต้องให้ค่าอะไรลงไปอีก

เพราะ .volume จะเอาค่าของ box1 มาใช้ และ box1 ก็ได้ค่ามาจากคอนสตรัคเตอร์อีกที

ผลลัพธ์

            box1 และ box2 เรียกคอนสตรัคเตอร์ Box() เหมือนกัน ดังนั้นผลลัพธ์ที่ได้จากการคำนวณย่อมต้องเหมือนกัน

รูป 9-3

คอนสตรัคเตอร์ที่รับพารามิเตอร์(Parameterized constructors)

            จากตัวอย่างข้างบนจะเห็นว่าหากมีการ new Box() ขึ้นมาค่าต่างๆจะเหมือนกันทำให้การใช้งานยังไม่ดีเท่าที่ควร constructor ควรจะกำหนดค่าได้ดังนั้นก็ใช้วิธีแบบเมท็อดมาช่วยคือให้คอนสตรัคเตอร์รับพารามิเตอร์ โดยการรับพารามิเตอร์จะเป็นเกณฑ์แบบเดียวกันกับฟังก์ชัน[1] เรียกว่า overloaded constructor

ตัวอย่างของ overloaded constructor คือมีคอนสตรัคเตอร์ที่ต้องชื่อเหมือนกันแต่รับพารามิเตอร์ต่างๆกันเวลาที่จะเรียกใช้เมื่อ new ขึ้นมา ใน() ก็ให้ใส่ค่าลงไปตามที่พารามิเตอร์ต้องการ

                public class Student

{

                        public Student( ) {}

public Student(int id) {}

public Student(double weight, double height) {}

public Student(int id, double weight, double height ) {}

}

รูป9-4

ในคลาส Box เหมือนเดิม แต่เปลี่ยนคอนสตรัคเตอร์ใหม่ให้คอนสตรัคเตอร์รับพารามิเตอร์เป็น double 3 ตัวจากนั้นเอาค่าจากพารามิเตอร์ที่รับเข้ามาไปเก็บไว้ในตัวแปรคลาส

รูป9-5

            จะเห็นได้ว่า หากให้คอนสตรัคเตอร์รับพารามิเตอร์ แต่เมื่อ new ขึ้นมาแล้วไม่ใส่พารามิเตอร์ลงไปจะเกิด error แบบบรรทัดที่ 6-7 วิธีแก้ error ก็ใส่พารามิเตอร์ให้ถูกต้อง

รูป9-6

            หลังจากใส่พารามิเตอร์ลงไปแล้ว error ก็จะหายไป พารามิเตอร์ที่ใส่ไปตรงนี้จะถูกนำไปเป็นค่าตั้งต้นในคอนสตรัคเตอร์

ผลลัพธ์

            จะเห็นได้ว่าหากใช้คอนสตรัคเตอร์ที่รับพารามิเตอร์ เมื่อเรา new และใส่พารามิเตอร์ลงไป ค่าในคอนสตรัคเตอร์ของอ็อปเจ็คที่ไป new มาก็มีค่าต่างกัน ผลลัพธ์ที่ได้ก็จะมีค่าต่างกันไปด้วย

รูป9-7

Default constructor

            คือสิ่งคอมไพล์เลอร์สร้างขึ้นอัตโนมัติเพื่อกำหนดค่าให้กับตัวแปรเป็น 0 สำหรับ int และ 0.0 สำหรับ double รวมถึง false สำหรับ Boolean ใช่ในกรณีที่เราไม่ได้กำหนดค่าเริ่มต้นให้กับตัวแปร

            ภายใน default constructor จะไม่มีคำสั่งใดๆ

            class Student( ) { }

อธิบายเพิ่มเติม

            ก่อนหน้านี้สิ่งที่เขียนบ่อยก็คือ คลาส Scanner ที่ใช้สำหรับรับข้อมูลเข้ามาจากแป้นพิมพ์ เวลาที่เราใช้คำสั่ง new Scanner(…) เช่น new Scanner(System.in) ก็จะเป็นการส่งค่าพาราเตอร์ที่รับเข้าจากแป้นพิมพ์(System.in) ไปให้คอนสตรัคเตอร์ของ Scanner

            new Scanner(new File(“c:/file.txt”)) แบบนี้ก็จะเป็นการสร้างอ็อปเจ็ค 2 ตัวคือ จากการ new File ทำหน้าไปเอาสตริงจาก file มาเก็บเป็นอ็อปเจ็ค แล้วส่งอ็อปเจ็คตัวนี้ไปเป็นพารามิเตอร์ของอ็อปเจ็ค Scannerอีกที ก็จะทำให้ Scanner อ่านไฟล์ได้

คีย์เวิร์ด this กับ super

            คีย์เวิร์ด this ทำหน้าที่อยู่ 2 อย่าง

1.คือเวลาที่เราตั้งชื่อตัวแปรในพารามิเตอร์เป็นตัวเดียวกับตัวแปรคลาส ซึ่งปกติการตั้งชื่อตัวแปรซ้ำกันจะทำไม่ได้ แต่ในกรณีนี้ได้โดยการใช้คีย์เวิร์ด thisเข้ามาช่วย

รูป9-8

            2.ใช้เวลาที่จะเรียกใช้คอนสตรัคเตอร์ที่อยู่ในคลาสเดียวกัน

            คีย์เวิร์ด super ใช้เมื่อต้องการเรียกให้คอนสตรัคเตอร์ของคลาสแม่ทำงาน

รูป9-9

            สร้างคลาสชื่อ Calculator

บรรทัดที่ 14 : ให้คอนสตรัคเตอร์ของคลาส Calculator รับพารามิเตอร์เป็น int 2ตัว แต่ตัวแปรในพารามิเตอร์

กับตัวแปรคลาสเหมือนกัน ดังนั้นในคอนสตรัคเตอร์ก็เขียน this ลงไปด้วย(จริงๆคือถ้าไม่อย่างเขียน this ก็ตั้งตัวแปรตรงพารามิเตอร์เป็นชื่อคล้ายๆกันก็ได้ เช่น ตัวแปรคลาสชื่อ x กลัวลืมว่าจะต้องเอาค่าไปใส่ตัวแปรชื่อ xในพารามิเตอร์ก็ตั้งเป็น xx พอชื่อไม่เหมือนกันก็ไม่ต้องใส่ this)

บรรทัดที่ 6 : ต้องการตั้งค่าให้ x,y ก็สามารถเรียกใช้คอนสตรัคเตอร์ที่มีอยู่ปล้วในคลาสเดียวกันได้ด้วยคีย์เวิร์ด

this(..);

รูป9-10

            สร้างอีกคลาสโดยให้คลาสนี้รับคุณสมบัติมาจากคลาสCalculator โดยใช้คีย์เวิร์ด extends ในคอนสตรัคเตอร์ของ Calculator2 ให้เรียกคอนสตรัคเตอร์ของ Calculator ได้โดยใช้ super();

รูป9-11

เมื่อมาถึงเมท็อด main ให้เรียกแค่อ็อปเจ็คCalculator2 ก็จะได้ของจากทั้ง Calculator และ Calculator2

            เมื่ออ่านเรื่องคลาสและอ็อปเจ็คแล้ว สิ่งที่จะพิจารณาต่อไปคือเรื่องของการเขียนโปรแกรมเชิงวัตถุซึ่งเป็นจุดเด่นของการเขียนโปรแกรมในภาษาจาวา ประกอบไปด้วย Encapsulation, Inheritance และPolymorphism

Encapsulation การห่อหุ้มข้อมูล

 คือการปกปิดข้อมูลหรือเมท็อดบางอย่างไม่ให้ภายนอกมองเห็นและเปลี่ยนแปลงได้(อ่านเพิ่มเติมจากเรื่อง อ็อปเจ็ค)

Inheritance การสืบทอดคุณสมบัติ

ช่วยในการประหยัดเวลาสำหรับการเขียนโปรแกรม คือสามารถที่จะสร้างคลาสใหม่โดยสืบทอดคุณสมบัติจากคลาสเก่าได้โดยไม่ต้องเขียนอะไรให้ยุ่งยากใหม่ทั้งหมด นอกจากนี้ยังสามารถปรับเปลี่ยนลักษณะบางประการของจากคลาสที่ไปสืบทอดคุณสมบัติมาได้ด้วยเรียกว่า overriding

ปกติถ้าไม่ใช้การสืบทอดคุณสมบัติเวลาเขียนคลาสใหม่ก็จะต้องไปก็อปปี้คลาสเดิมแล้วมาสร้างคลาสใหม่เวลาเกิด error ก็ต้องนั่งแก้ทุกจุดทำให้ลำบาก แบบเขียนยาวแล้วแก้ยาก แต่ถ้าสืบทอดคุณสมบัติมาก็แก้แค่จุดเดียวเป็นต้น

คลาสแม่และคลาสลูก(superclass and subclass)

คลาสลูกคือคลาสที่ไปสืบทอดคุณสมบัติมาจากคลาสอื่น ส่วนคลาสที่ถูกเขาสืบทอดคุณสมบัติไปเรียกว่าคลาสแม่ เช่น คลาส B สืบทอดคุณสมบัติจากคลาส A คลาสจะเป็นคลาสแม่ ส่วนคลาส B จะเป็นคลาสลูก วิธีการสืบทอดคุณสมบัติจะใช้คีย์เวิร์ด extends

Modifier cass ชื่อคลาสลูก extends ชื่อคลาสแม่{ }

            เมื่อมีการสืบทอดคุณสมบัติแล้วมีการเปลี่ยนแปลงเกิดขึ้นกับคลาสแม่ ผลของการเปลี่ยนแปลงจะส่งมาที่คลาสลูกอัตโนมัติ สิ่งที่คลาสแม่สามารถสืบทอดคุณสมบัติไปให้คลาสลูกได้ ได้แก่ ตัวแปรคลาสแม่และเมท็อดภายใน คือเมื่อคลาสลูกสืบทอดคุณสมบัติไปแล้วจะสามารถเรียกใช้ตัวแปรและเมท็อดจากคลาสแม่ได้เหมือนกับคลาสลูกสร้างมันขึ้นมาเอง แต่อย่างไรก็ตามถ้าคลาสแม่มีสิ่งที่ถูกประกาศเป็น private ในคลาสแม่ สิ่งนั้นจะไม่สามารถถ่ายทอดมายังลูกได้ และอีกประการคือคอนสตรัคเตอร์ก็จะไม่ถ่ายทอดมายังลูก เปรียบเหมือนแม่มีคุณสมบัติสูง 170 แต่คุณสมบัติไม่จำเป็นต้องเป็นของลูก ลูกอาจสูง 180 ก็ได้

การสืบทอดคุณสมบัติบางครั้งก็ต้องมีการเปลี่ยนแปลงแก้ไข เช่น การเพิ่มตัวแปรและเมท็อดอื่นๆในคลาสลูกเพิ่มเติม

รูป10-1

            กลับมีที่คลาส Box อีกครั้ง ในคลาสนี้ปรกาศตัวแปร width, height, depth และสร้างคอนสตรัคเตอร์ 2 คอนสตรัคเตอร์ คือ default constructor กับคอนสตรัคเตอร์แบบรับพารามิเตอร์ จากนั้นก็สร้างเมท็อดสำหรับคำนวณ

รูป10-2

            สร้างคลาส BoxWeight โดยให้คลาส BoxWeight สืบทอดคุณสมบัติมาจากคลาส Box ด้วยคีย์เวิร์ด extends ในบรรทัดที่ 2

บรรทัดที่ 4 : ประกาศตัวแปร weight เพื่อเก็บค่าน้ำหนักของกล่อง

บรรทัดที่ 6 : สร้างคอนสตรัคเตอร์ของคลาส BoxWeight จะเห็นว่าในคอนสตรัคเตอร์ของ BoxWeight( ) มีตัว

แปร width, height, depth แบบเดียวกับคลาส Box โดยที่ไม่ต้องประกาศตัวแปร เพราะ BoxWeight( ) ได้ทำการสืบทอดคุณสมบัติมาจาก Box ดังนั้น ตัวแปรคลาสและเมท็อด volume ของ Box นั้น BoxWeight( )ก็จะสามารถใช้งานได้

บรรทัดที่ 8 : ถ้าไม่สร้าง default constructor ในบรรทัดที่ 7 ของคลาส Box จะต้องใส่พารามิเตอร์ในคีย์เวิร์ด

super ตรงนี้แทน ไม่อย่างนั้นจะ error

รูป10-3

บรรทัดที่ 6-7 : new อ็อปเจ็คจากคลาส BoxWeight

บรรทัดที่ 10 : เรียกเมท็อด volume ที่เรียกได้ก็เพราะ BoxWeight สืบทอดเมท็อดนี้มาแล้ว

บรรทัดที่ 12 : เรียกตัวแปร weight ของ BoxWeight มาแสดงผล

ผลลัพธ์

รูป10-4

Overriding

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

รูป10-5

สร้างคลาสชื่อ Overriding ประกาศตัวแปร a กับ b จากนั้นสร้างคอนสตรัคเตอร์รับพารามิเตอร์ 2 ตัวจากนั้นเก็บค่าไว้ในตัวแปร a b

สร้างเมท็อดชื่อ print สำหรับแสดงค่าออกทางหน้าจอ

รูป10-6

สร้างคลาสชื่อ Overriding2 ให้สืบคุณสมบัติมาจาก คลาส Overriding ด้วยคีย์เวิร์ด extends จากนั้นสร้างตัวแปรของคลาส Overriding2 ให้ชื่อ c

ในคอนสตรัคเตอร์ของ Overriding2 เพิ่ม c ลงไป

บรรทัดที่ 10 : นี่คือการ Override คือให้เมท็อดชื่อเหมือนเดิมแต่เปลี่ยนคำสั่งข้างใน จากคลาส Overriding ให้

แสดงค่า a และ b ออกทางหน้าจอ แต่เมท็อดที่สืบทอดคุณสมบัติมาในคลาส Overriding2 ให้แสดงค่า c

รูป10-7

บรรทัดที่ 8 : เรียกเมท็อด print( ) จากคลาส Overriding2 โปรแกรมจะแสดง ผลลัพธ์ว่า c : 15 เพราะในคลาส

Overriding2เป็นเมท็อดที่ได้รับการ override แล้ว

Polymorphism การพ้องรูป

สำหรับการพ้องรูปเป้นเรื่องที่มีความเกี่ยวเนื่องกันกับการสืบทอดคุณสมบัติอย่างแยกไม่ออก แปลตามตัวอักษร poly หลาย morph รูปร่าง คือการที่หนึ่งอ็อปเจ็คสามารถมีหน้าที่ได้หลายบทบาท เวลาที่สร้างคลาสแม่ลูกขึ้นมา คลาสแม่จะถือว่าเป็นอะไรที่ใหญ่กว่าคลาสลูก คลาสแม่จะเป็นกรณีทั่วไปแต่คลาสลูกจะเป็นกรณีพิเศษ เช่น คลาสแม่เป็นดอกไม้ มีคุณสมสมบัติคือมีกลีบดอก มีสี คลาสลูกเป็นคลาสดอกมะลิก็จะมีกลีบ มีสีที่เฉพาะเจาะจงกว่าพูดว่าดอกไม้ ดังนั้นสามารถใช้ตัวแปรอ้างอิงของแม่ไปอ้างอิงลูกได้ เช่น Flower f = new Jasmine(); เหมือนบอกว่า ให้คลาส Flower เก็บดอกไม้ สามารถเก็บดอกมะลิได้ แต่ Jasmine j = new Flower(); ไม่ได้ เพราะบอกให้เก็บดอกมะลิ ไม่ใช่ว่าจะไปเก็บดอกไม้อะไรมาให้ก็ได้

รูป 10-8

รูป10-9

            จากตัวอย่างรูป 10-9 นี้จะเห็นว่าคลาส Rect สืบทอดคุณสมบัติมาจาก Ball แต่ในรูป 10-8 ประกาศอ็อปเจ็ค balls ของ Ball ขึ้นมาเพียงอันเดียว พอจะ new อ็อปเจ็คของคลาส Rect ขึ้นมา ก็สามารถใช้ตัวอ้างอิง ball ไป new ได้เลยเพราะ Rect  เป็นลูกของ Ball

ตัวแปรและเมท็อดที่เป็น static

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

สำหรับตัวแปรที่เป็น static นั้น จะทำให้ตัวแปรนั้นเป็นตัวแปรของคลาสไม่ได้เป็นของอ็อปเจ็คใดอ็อปเจ็คหนึ่ง ถ้ามีการเปลี่ยนแปลงขึ้นกับตัวแปร static อ็อปเจ็คอื่นๆทั้งหมดจะมองเห็นการเปลี่ยนแปลง

วิธีประกาศ

สำหรับตัวแปร    modifier static ชนิดตัวแปร ชื่อตัวแปร;

สำหรับเมท็อด    modifier static ประเภทผลลัพธ์ ชื่อเมท็อด( ) { }

                        วิธีการเรียกใช้งานเมท็อดที่เป็น static ถ้าอยู่ในคลาสเดียวกันก็ ชื่อเมท็อด(); แบบนี้ได้เลย แต่ถ้าอยู่คนละคลาสก็ ใช่ ชื่อคลาส.ชื่อเมท็อด static

            เมท็อดที่เป็น static ที่ได้ใช้มาแล้วก็คือ เมท็อด main ใน public static void main(String [] args) เพราะว่า main เป็นเมท็อดสำหรับเริ่มทำงาน ดังนั้นต้องสามารถทำงานได้เลยโดยไม่ต้องมีอ็อปเจ็คมาเรียกใช้งาน

รูป 10-2-1

            เมท็อดชื่อ f ในบรรทัดที่ 17 ประกาศเป็น เมท็อด static ดังนั้นในบรรทัดที่ 12 สามารถเรียกใช้เมท็อด f ได้เลย แต่บรรทัดที่ 13 มีการเรียกใช้เมท็อด println ซึ่งอยู่ในคลาส System ก็ต้องใช้งานแบบ ชื่อคลาส.เมท็อด

รูป 10-2-2

            สังเกตว่าเมื่อเอาคำว่า static ออกในบรรทัดที่ 17 จะเกิด error ขึ้นทันทีที่บรรทัดที่ 12 ที่เรียกเมท็อด

ตัวแปร เมท็อดและคลาสที่เป็น final

            คล้ายกับ static คีย์เวิร์ด final ใช้ประกาศหน้าตัวแปร เมท็อดและยังประกาศหน้าคลาสได้ด้วย

–          ถ้า final ไปประกาศหน้าตัวแปร ตัวแปรนั้นจะมีค่านั้นตลอดเปลี่ยนแปลงไม่ได้ เรียกว่าเป็นค่าคงที่

–          ถ้าอยู่หน้าเมท็อดแล้วคลาสนี้ถูกสืบคุณสมบัติไป เมท็อดนี้จะไม่สามารถเขียนทับแก้ไขได้หรือก็คือไม่สามารถ Overriding ได้

–          แต่ถ้าอยู่คลาส คลาสนั้นๆจะไม่สามารถเป็นคลาสแม่ได้เลย คือบางทีไม่ต้องการให้คนเอาอะไรเปลี่ยนทั้งนั้นก็ประกาศคลาสเป็น final เพราะบางทีประกาศเมท็อดเป็น final คลาสลูกก็เขียนเมท็อดใหม่ขึ้นมาได้ เช่น เราไม่ต้องการเขาเปลี่ยนชื่อ เขาก็เขียนเมท็อดสำหรับเปลี่ยนชื่อใหม่ได้

วิธีประกาศ

สำหรับตัวแปร    final ชนิดตัวแปร ชื่อตัวแปร = ค่าคงที่ ;

สำหรับเมท็อด    modifier final ประเภทผลลัพธ์ ชื่อเมท็อด( ) { }

สำหรับคลาส      modifier final class ชื่อคลาส{ }

เมท็อดและคลาส abstract

            เป็นอีกหนึ่งคีย์เวิร์ดในจาวาที่ใช้สำหรับการประกาศหน้าคลาสหรือเมท็อดใดๆให้มีคุณสมบัติเป็น abstract(นามธรรม) ซึ่งหมายถึงคลาสที่ไม่สามารถมีอ็อปเจ็คได้ หรือถ้าประกาศหน้าเมท็อดก็จะเป็นเมท็อดที่ไม่ได้กำหนดการทำงานเอาไว้ ให้คลาสลูกที่มาสืบทอดคุณสมบัติไปไปกำหนดการทำงานเอาเอง

            ทำไมต้อง abstract – ก็เพราะว่าบางครั้งมีการสืบทอดคลาสแม่ลูก สมมติว่าคลาส A เป็นคลาสแม่ มีคลาสลูก B, C, D, E มาสืบคุณสมบัติไป ปรากฏว่าคลาส B, D และ E ต้องใช้เมท็อดชื่อ show() เหมือนกัน แต่ในคลาสแม่ A ไม่มีเมท็อดนี้อยู่ ก็ให้คลาสแม่ประกาศเมท็อดเปล่าเอาไว้ คลาสลูกจะได้ใช้งาน ซึ่งคลาสลูกก็สามารถเปลี่ยนแปลงการทำงานในเมท็อด abstract ได้

            เขียนเมท็อดชื่อ show() ใหม่ไม่ได้หรอ – ได้ ก็เขียนใหม่ในคลาส B, D ,E ได้ แต่มันไม่เป็นไปตามเรื่องการสืบทอดคุณสมบัติ(inheritance)และการพ้องรูป(polymorphism) ของการเขียนจาวาแบบ OOP ก็แบบว่า ตัวแปรอ็อปเจ็คของแม่สามารถอ้างอิงอ็อปเจ็คของลูกได้ แต่ถ้าในคลาสแม่ไม่มีเมท็อด show() แม่ก็จะเรียกใช้ก็งานเมท็อดนี้ไม่ได้ ซึ่งก็ทำให้ทำงานไม่ดี

            วิธีประกาศ

สำหรับคลาส      modifier abstract class ชื่อคลาส { }

สำหรับเมท็อด    modifier abstract ประเภทผลลัพธ์ ชื่อเมท็อด(พารามิเตอร์)

ตัวอย่างเช่น

public abstract class Name

{

public abstract void setName(String name);

}

แต่ว่า

1.      ภายในคลาสที่เป็น abstract จะใช้คำสั่ง new สร้างอ็อปเจ็คของคลาสนั้นไม่ได้ เช่น new Name(); ไม่ได้

2.      ภายในเมท็อดที่เป็น abstract จะมีคำสั่งไม่ได้

3.      ใน abstract คลาส จะมีเมท็อดที่เป็นหรือไม่เป็น abstract อยู่ก็ได้

4.      แต่ abstract เมท็อดต้องอยู่ใน abstractคลาส เท่านั้น

รูป 10-2-3

ถ้าเอาคำว่า abstract ในบรรทัดที่ 2 ออกจะ error เพราะ บรรทัดที่ 4 กับ 7 เป็น abstract เมท็อด

5.      Abstract คลาสสามารถสืบทอดคุณสมบัติกันได้เหมือนคลาสปกติ แต่คลาสที่สืบทอดไป(คลาสลูก)จะต้องอิมพลีเมนท์(implement)[1] ทุกเมท็อดแม้จะไม่ได้ใช้งานก็ตาม

6.      คลาสธรรมดาสืบทอดคุณสมบัติจากคลาส abstract ได้

7.      มีคอนสตรัคเตอร์

Interfaces

                เป็นเรื่องต่อมาจาก abstract เพราะ interface เป็นเหมือคลาสๆหนึ่งที่ เมท็อดทุกเมท็อดเป็น abstract และตัวแปรทุกตัวก็เป็นตัวแปรแบบ public static final ด้วย

            การประกาศ

การเขียนคลาสปกติ         public class Worker { }

เขียน interface              public interface Worker { } ก็เอาคำว่า interface ไปแทน class

            ใน eclipse เวลาจะสร้างคลาส ตรงใต้ class จะมีคำว่า interface ก็กดตรงนั้นเลย

รูป10-2-4

            การประการตัวแปรและเมท็อดของ interface ต้องเป็น ตัวแปร public static final และ เมท็อด abstract  อยู่แล้วก็ไม่ต้องเขียนแบบรูป 10-2-4 ก็ได้ เขียนแบบข้างล่างแทน

รูป 10-2-5

วิธีใช้

1.      ใช้คำว่า implements ตามด้วย ชื่อinterface เช่น public class A implements interface B { } แต่อิมพลีเมนต์ interface แล้วต้องทำการ interface ทุกเมท็อดของ interface นั้นด้วย ง่ายๆคือเวลาอิมพลีเมนต์มันขึ้นขีดเส้นสีแดง error ที่ชื่อคลาส A พอกดมันก็จะอิมพลีมเนต์ให้เลยแบบนี้

รูป 10-2-6

2.      ค่าคงที่ เป็น public static final หมายถึงเปลี่ยนแปลงไม่ได้

3.      อิมพลีเมนต์ได้มากกว่า 1 interface  เช่น class A implements Interface1, Interface2, Interface3 { }

4.      ใช้ extends ก่อนอิมพลีเมนต์ก็ได้  เช่น class A extends B implements Interface1, Interface2, Interface3 { }

Abstract กับ Interface

–          เมท็อดของ abstract เป็น abstract ก็ได้ไม่เป็นก็ได้ แต่ถ้า interface นี่ไม่ได้เลยต้อง abstract เท่านั้น

–          ตัวแปรของ interface ล็อกค่า ของ abstract ไม่ล็อกเปลี่ยนแปลงได้

–          เวลามีคลาสไหนจะใช้งานเมท็อดของ abstract ต้องสืบทอดคุณสมบัติเป็นแม่ลูกกัน แต่ interface ไม่ต้องอยากใช้งานก็เอาไปใช้

–          Interface ไม่มีคอนสตรัคเตอร์ abstract มี

ทำไมต้อง interface

            เนื่องจาก interface ไม่ต้องมีความสัมพันธ์แม่ลูกกันแวลาใช้งาน ขอเปรียบเทียบว่า สมมติมีคลาสหมู กับคลาสลูกหมู แน่นอนว่าแบบนี้ต้องเป็นคลาสแม่ลูกกันเพราะนอกจากต้องจะสืบทอดคุณสมบัติทั้งรูปร่าง สีผิวแล้ว พฤติกรรมหรือนิสัยยังต้องทำอะไรคล้ายๆกันด้วย แบบนี้ก็ใช้ abstract ได้ เพราะลูกหมูหลายตัวอาจจะมีพฤติกรรมบางอย่างที่ทำเฉพาะตัวไม่เหมือนกัน ในคลาสลูกหมูก็ไปแก้เมท็อดนั้นเอา เรื่องมีอยู่ว่าแม่หมูทำงานอย่างหนึ่งคือดมกลิ่นหาเห็ดในป่ากับเก็บเห็ด วันนึงแม่หมูไม่สบายเลยจะเอาคนมาทำงานแทน แน่นอนว่าลูกหมูก็ต้องทำได้อยู่แล้วเพราะ extends สกิลดมกลิ่นเห็ดมาจากแม่ แต่เนื่องจากลูกหมูเด็กไป แม่หมูเลยให้หมีป่ามาทำงานแทน แต่หมีป่าไม่ได้เป็นลูก เป็นญาติอะไรกับหมูเลยก็จะมีสกิลไม่เหมือนกัน แต่อยากให้หมีป่าหาเห็ดเก็บเห็ดได้ ก็ไปเขียน interface มาแล้วให้หมีอิมพลีเมนต์สกิลนี้ไป หมีป่าก็จะทำงานแทนแม่หมูได้

            ในบทก่อนๆจะเห็นว่าเวลาเขียนโปรแกรมแล้วรันไม่ผ่านตรง console จะขึ้นข้อความสีแดง หรือไม่อย่างนั้นก็อาจจะรันผ่านแต่กลับไม่มีอะไรแสดงออกมา เรื่องพวกนี้เป็นเรื่องที่เกิดจากความผิดปกติหรือ exception ที่ทำให้โปรแกรมไม่สามารถทำงานจบได้ตามที่เราต้องการ

Error กับ Exception

            Throwable (เปิด java doc ดูประกอบ) เป็นคลาสๆหนึ่งที่มีลูกอยู่ 2 คลาสคือ error กับ exception

            สำหรับ error

เป็นความผิดปกตินอกโปรแกรม หมายความว่าเขียนถูกแล้วแต่อาจจะเกิดปัญหาจากความผิดพลาดจากการรับส่งข้อมูลจากไฟล์ แบบอ่านไฟล์ไม่ได้ เป็นต้น

–          IOError อุปกรณ์รับส่งข้อมูลทำงานไม่ได้

–          NoClassDefFoundError คือเรียกคลาสแต่จริงๆไม่มีคลาสนั้น

–          StackOverflowError คือ หน่วยความจำระหว่างเรียกเมท็อดไม่พอ นี่เป็คนความผิดพลาดจากการเขียนโปรแกรมของเราเอง เกิดจากการเรียก recursive ฟังก์ชันมากไป

สำหรับ exception

เป็นความผิดปกติที่มีสาเหตุอาจจะมาจากการเขียนโค๊ดผิด ความผิดปกติจะเกิดขึ้นตอนประมวลผล

โปรแกรมซึ่งการป้องกันความผิดปกติจะทำที่ตรงนี้ โปรแกรมจะได้ไม่ต้องหยุดทำงานทั้งๆที่ยังทำไม่จบ

–          AritmaticException การหารจำนวนเต็มด้วยศูนย์(ไม่นิยามในทางคณิตศาสตร์)

–          IndexOutOfBoundException เรียกใช้อาร์เรย์ช่องที่ไม่มี

–          NullPointerException การใช้ตัวแปรหรือเมท็อดที่เป็น null

–          FileNotFoundException  หาไฟล์ไม่เจอ

จะเห็นว่าสำหรับ exception เป็นอะไรที่แก้ไขได้ทันที เช่น หารเลขด้วยศูนย์พอมันผิดก็ไปแก้ให้เรียบร้อย โปรแกรมก็ทำงานต่อได้จนจบแล้ว

รูป 11-1

เขียนโปรแกรมขึ้นมา ให้ b เก็บค่าของ 5/a โดยที่ a มีค่าเป็น 0 โปรแกรมจะแสดงผลตามข้างล่าง

รูป 11-2

นี่เป็นตัวอย่างง่ายๆแต่ถ้านึกถึงโปรแกรมขนาดใหญ่ๆยาวแล้วเกิดข้อผิดพลาดขึ้นมาการแก้ปัญหาก็ลำบากอยู่เหมือนกัน และก็จริงที่ว่าโปรแกรมมันก็แจ้งให้เราทราบว่าเกิด exception อะไรขึ้นมาก็จริงแต่การทำแบบนี้โปรแกรมก็จะหยุดการทำงานไปด้วย ดังนั้นเราจึงควรที่จะใช้การจัดการกับ exception เพื่อเป็นการเตือนผู้ใช้ว่าต้องทำอย่างไร เพราะต้องนึกว่าหากเป็นผู้ใช้โปรแกรมกำลังใช้งานโปรแกรมอยู่แล้วมัน error ดับปิดโปรแกรมไปก็คงจะงง ก็ควรจะไม่ทำให้เกิดเหตุการณ์อย่างนั้นพร้อมกับการแก้ไข เช่น ให้ใส่ตัวเลขแต่ใส่ตัวหนังสือมาก็ให้แจ้งไม่ถูกต้องใส่ตัวเลข ไม่ใช่ว่าไม่แจ้งอะไรแล้วก็ดับไปเลย

จับ exception ด้วย try-catch

วิธีการหนึ่งสำหรับการจัดการกับ exception ทำด้วยสิ่งที่เรียกว่า surround with try/catch โดย try/catch นั้นจะประกอบไปด้วยคำสั่ง 2 คำสั่งคือกลุ่ม try(ลอง) กับ กลุ่ม catch(จับ) ง่ายๆก็คือให้ลองทำสิ่งที่อยู่ใน try ดูก่อน หากไม่สามารถทำได้เพราะมี exception ให้จับexception ด้วยการจับไว้ด้วย catch

รูป11-3

โปรแกรมนี้ก็คือต้องการให้ใส่ตัวเลขจำนวนเต็มเพื่อนำมาแสดงผล แต่ก็มีที่ผู้ใช้อาจจะใส่สิ่งที่ไม่ใช่ตัวเลขอย่างตัวอักษรหรือข้อความเข้ามาได้ ซึ่งถ้าเกิดเหตุการณ์นี้โปรแกรมจะ error เลยเพราะต้องบรรทัดที่ 12 คำสั่งบอกให้รับ int เข้ามา

สิ่งที่โปรแกรมฟ้อง หากใส่ข้อมูลผิดประเภท

รูป 11-4

สิ่งที่โปรแกรมฟ้องก็คือ InputMismatchException เพื่อแก้ปัญหานี้เราก็จับ InputMismatchExceptionใส่ไว้ใน catch ซะให้เรียบร้อย

รูป11-5

นี่คือรูปแบบการทำงานของ try/catch กลุ่มคำสั่งที่อยู่ใน try คือคำสั่งเมื่อกี้ แต่รอบนี้เราป้องกันไม่ให้โปรแกรมจบการทำงานไปเองด้วย catch ซึ่งใน catch ก็ใส่ชื่อของ exception ไป พร้อมกับคำสั่งเพื่อให้รู้ว่าความผิดพลาดเกิดตรงนี้และแก้ไขด้วยอะไร

รูป 11-6

เพียงเท่านี้ปัญหาก็จะหมดไปโปรแกรมสามารถทำงานได้ปกติจบครบจบกระบวนความ

การโยนความผิดปกติด้วย throw – throws

ปกติถ้า main ไปเรียก เมท็อด A แล้ว A ก็ไปเรียกเมท็อด B แต่เมท็อด B ดันมี exception หาก B ไม่ได้ดักจับ exception เอาไว้ความผิดปกติก็จะไปหา A ถ้า A ยังไม่จับสุดท้ายก็จะไปที่ main และถ้า main ยังไม่ทำอะไรโปรแกรมก็จะไม่ทำงานในที่สุด การโยนความผิดปกติก็เพื่อให้เมท็อดนั้นทำงานได้ปกติโดยให้เมท็อดอื่นเป็นผู้จับความผิดปกตินี้เอง

วิธีที่ง่ายที่สุดก็คือไปประกาศที่หัวเมท็อดให้หมดเรื่องหมดราวไป ด้วยคีย์เวิร์ด throws  ตามด้วยชื่อของคลาสที่เกิด exception

รูป 11-7

บรรทัดที่ 19 : โยน exception ออกจากเมท็อด เพื่อให้ main ทำการจับความปิดปกตินี้

จะรู้ได้ยังไงว่าต้องใช้ exception อะไร

ก็เป็นธรรมดาที่ตอนแรกจะไม่รู้ว่าจะต้องใช้ exception อะไร แต่พอเห็น error สักพักก็จะพอเดาได้ว่าใช้ exception อะไรเพราะชื่อมันเหมือนๆกันกับที่เวลาเวลา error แสดงออกทาง console แต่ถ้ายังไม่รู้จะใช้อะไรจริงๆ ก็ใช้ Exception ไปก่อน เพราะทุกคลาสของ exception จะเป็นลูกมากจากคลาส Exception

รูป 11-8

แก้ไขโค๊ดจากข้างบน 11-1โดยให้มีการดักจับ(try-catch) ความผิดปกติโดย Exception ก็จะแก้ไขได้ทุกความผิดปกติ แต่มันก็เป็นข้อเสียด้วยเหมือนกันคือพอผิดปกติมาทีเราก็จะไม่รู้ว่ามันผิดปกติเพราะอะไร

รูป 11-9

การใช้งานอ็อปเจ็คของสิ่งผิดปกติ

            คงจะเห็นว่าใน catch นั้นจะมี ตัว e ตามท้ายชื่อคลาสที่เป็น exception ซึ่งนี่ก็คือตัวแปรสำหรับอ้างอิงอ็อปเจ็คของ exception ซึ่ง e สามารถใช้ประโยชน์ได้จากการเรียกใช้เมท็อดของคลาส Throwable

–          e.getMessage () ใช้แสดงความผิดปกติ เป็นสตริง

–          e.printStackTrace() ใช้บอกว่าผิดตริงไหน

–          e.toString() คืนค่าสตริงบรรยายสิ่งที่ปิด

            I/O คือเรื่องเกี่ยวกับการอ่านและเขียนข้อมูล รวมถึงการอ่านและเขียนข้อมูลลงบนไฟล์ ในหัวนี้จะอธิบายถึงการเขียนแบบตัวอักษรและสตริงเท่านั้น ไม่ได้รวมถึงการเขียนแบบไบต์ อย่างไรก็ตามจะเห็นได้ว่าการอ่านเขียนข้อมูลพวกนี้แทบจะไม่ได้เห็นในการเขียนโปรแกรมด้วยจาวาช่วงแรกๆเพราะจริงคือจาวาโดดเด่นเรื่องการเป็นโปรแกรมกราฟฟิค (graphically oriented programs) ไม่ใช่โปรแกรมตัวหนังสือ (text-based programs)

สตรีม

            ท่อต่อสำหรับส่งและรับข้อมูล เหมือนจะส่งน้ำก็ต้องต่อท่อที่ส่งกับที่รับน้ำ(น้ำเป็นข้อมูล) สตรีมสามารถเอาไปต่อกับอะไรก็ได้ เช่น ขาเข้า(เข้ามาหาเรา)ก็เอาไปต่อกับ ดิสก์ ไฟล์ คีย์บอร์ดและซ็อกเก็ต(network socket) ก็ได้ เพื่อดูดข้อมูลจากแหล่งที่ไปต่อมาใช้งาน ส่วนขาออก(ออกไปที่ๆอยากจะส่งไป) ก็ไปต่อกับ console ดิสก์ ไฟล์ ซ็อกเก็ต ก็ได้

รูป 12-1

            ท่อข้างบนเป็นท่อขาเข้าใช้สำหรับอ่านข้อมูล ส่วนท่อข้างล่างเป้นท่อขาออกสำหรับการเขียนข้อมูลออกไปข้างนอก

เรื่องทั่วไปของ System

            System เป็นคลาสหนึ่งของจาวาที่ใช้กันบ่อยๆก่อนหน้านี้สำหรับการรับข้อมูลเข้าทางแป้นพิมพ์จาก System.in และการให้โปรแกรมแสดงผลลัพธ์ออกทาง console ด้วย System.out.println ใน System มีตัวแปร in, out ที่ประกาศเป็น public static ดังนั้นจึงสามารถใช้งานได้เลย

            System.in เป็นอินพุตแบบมาตรฐาน โดยที่ System.in เป็นอ็อปเจ็คของ InputStream ส่วน System.out ก็เป็นเอาท์พุตแบบมาตรฐาน  เป็นอ็อปเจ็คชนิด PrintStream

การอ่านข้อมูล

            การอ่านข้อมูลสามารถทำได้ด้วยบัฟเฟอร์ดสตรีม (Buffered Stream) การอ่านเขียนข้อมูลแบบมีบัฟเฟอร์ดก็จะทำให้ประสิทธิภาพการรับส่งข้อมูลดีขึ้นกว่าไม่มี(แบบไม่มีคือใช้ Scanner แทนได้)

            BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

นี่คือการเขียนบัฟเฟอร์ดเพื่อรับข้อมูลเข้าจากแป้นพิมพ์ เนื่องจากReader เป็น abstract ส่วน InputStream ไม่ได้เป็น abstract ก็เลยต้องเอา InputStream ที่เป็นคลาสลูกมาช่วยดูดข้อมูล และ System.in ก็เป็นอ็อปเจ็คของ InputStream สตรีมอีก ก็ให้เอาอ็อปเจ็บที่รับมาจากแป้นพิมพ์มาให้ InputStream หลังจากนั้นก็เก็บไว้ในตัวแปร br ของ BufferedReader

อ่าน character

Charactor คือตัวอักษรตัวเดียว ให้ใช้เมท็อด read() มาช่วยในการเก็บตัวอักษร โดย read() โยน IOException เพื่อป้องกันความผิดพลาด

int read()throws IOException

รูป12-2

บรรทัดที่ 3 : อิมพอร์ท java.io.*; แทนได้

บรรทัดที่ 9 : อย่าลืม throws IOException

บรรทัดที่ 12 : รับข้อมูลจากแป้นพิมพืมาใส่บัฟเฟอร์ด

บรรทัดที่ 17: ภายในลูป while ให้รับข้อมูลจนกระทั่งถ้าเป็น e ให้หยุดรับข้อมูลโดยรับข้อมูลโดย read()

รูป12-3

อ่านสตริง

คล้ายกับการรับข้อมูลตัวอักษรแต่เปลี่ยนเมท็อดที่ใช้เป็น readLine();

String readLine() throws IOException

รูป12-4

การเขียนข้อมูล

การเขียนข้อมูลหรือการส่งข้อมูลออกสามารถทำได้โดยใช้เมท็อด void write() สำหรับการเขียนข้อมูลตัวอักษรและ byte

นอกจากนี้ยังมีคลาส PrinWriter  ซึ่งก็ทำงานเหมือนๆกับ print กับ println  เขียนได้แบบนี้

PrinWriter pw = new PrinWriter(ตัวแปร.getOutputStream)

การอ่านและเขียนไฟล์

            หัวข้อนี้เป็นเรื่องการเขียนและอ่านแฟ้มโดยเป็นแฟ้มแบบสตริงที่เปิดอ่านด้วยNotepad ได้ ซึ่งการเขียนและอ่านไฟล์สามารถใช้ Scanner และ PrintStream ร่วมกันก็ได้หรือจะใช้

FileInputStream(String fileName) throws FileNotFoundException

FileOutputStream(String fileName) throws FileNotFoundException

และเมท็อดที่ใช้ได้ดังนี้

void close() throws IOException

int read()throws IOException

void write()throws IOException

ตัวอย่างเช่น

รูป 12-5

            โปรแกรมตัดเกรดจากไฟล์แล้วเซฟลงอีกไฟล์

บรรทัดที่ 10 : โปรแกรมนี้ใช้ Scanner ในการรับข้อมูล โดยมีการ new อ็อปเจ็คของไฟล์ขึ้นมาให้อ็อปเจ็คนี้ไป

เก็บข้อมูลจากพาธ(path) ตามในรูปก็คือ มีไฟล์ชื่อ score.txt ใน local disk e

รูป12-6

บรรทัดที่ 11 : ใช้คำสั่ง PrintStream สำหรับการเขียนข้อมูลออกไปเก็บโดยสร้างไฟล์ใหม่ขึ้นมาชื่อ grade.txt

สำหรับเก็บผลของการตัดเกรด

บรรทัดที่ 13 : ใช้เงื่อนไข while(sc.hasnext()) สำหรับการตรวจสอบว่ายังมีข้อมูลอยู่ในไฟล์หรือไม่ ถ้ามีจะคืน

ค่าจริงและทำงานต่อจนกว่าจะไม่มีข้อมูลในไฟล์ก็จะคืนค่าเท็จและออกจากลูป

บรรทัดที่ 15 : ให้เก็บข้อมูลจากอ็อปเจ็ค sc ด้วย nextLine() เพื่อเก็บข้อมูลแต่ละบรรทัดลงใน ตัวแปร person

คือเก็บข้อมูลของแต่ละคนไว้ หลังจากนั้น บรรทัดที่ 16 : ให้ใช้ trim() เพื่อตัดช่องว่างหน้าหลังออก

บรรทัดที่ 17 : ใช้ indexOf เพื่อหาช่องว่างจากตำแหน่งที่ 0 นี่เป็นเหตุผลว่าทำไมต้องใช้ trim() ก่อนเพราะ

ช่องว่างที่เราต้องการอยู่ตรงกลางเท่านั้น ต้องมั่นใจว่าจะไม่มีช่องว่างที่อื่นก่อนหน้าช่องวางตรงกลาง ดูจากรูป 12-6

บรรทัดที่ 20 : ตัด substring ก่อนช่องว่างเก็บเป็น id

บรรทัดที่ 21 : ตัด substring ครึ่งหลังเก็บเป็น คะแนน

บรรทัดที่ 22 : เอาสตริงคะแนนมาเปลี่ยนเป็น double

บรรทัดที่ 30 : ให้อ็อปเจ็คเรียก println เพื่อเก้บข้อมูลสำหรับส่งออก

บรรทัดที่ 33 : close(); ไฟล์เพื่อเซฟข้อมูลให้เรียบร้อย

ผลลัพธ์ที่ได้

ได้ไฟล์ใหม่ที่ตัดเกรดเรียบร้อยแล้ว

รูป 12-7

            เธรดคือระบบของจาวาสำหรับการสนับสนุนการทำงานแบบ multi-tasking แบบที่ในระบบปฏิบัติการก็จะให้โปรแกรมสามารถทำงานพร้อมกันได้ เช่น ฟังเพลงไปด้วยพิมพ์งานไปด้วยก็ได้ นอกจากนี้เธรดยังสามารถทำงานพร้อมกันได้ด้วยเรียกว่า multi-thread

เธรด

            เธรดเป็นการทำงานหลายงานพร้อมกันก็จริงแต่สำหรับเธรดนั้นจะไม่ได้ใช้พื้นที่เยอะเหมือนโปรเซส(processes)เนื่องมาจากว่าเธรด มี stack, program counter และ local variable ที่เป็นของตัวเอง แต่ใช้ทรัพยากรอื่นร่วมกันกับเธรดตัวอื่นที่มีอยู่ในโปรเซสเดียวกัน เช่น memory, file handlers และ pre‐process state อื่น ๆ ก็เลยเรียกโปรเซสว่า “heavyweight process” และเรียกเธรดว่าเป็น “lightweight process” เธรดเป็นเพียงหน่วยการทำงานของโปรแกรม

สาเหตุหลักที่ต้องมีเธรด ในโปรแกรมก็เพราะต้องการให้การแสดงผลเป็นไปได้อย่างรวดเร็ว เช่นถ้ามีโปรแกรมที่ใช้เวลาในการประมวลผลใน CPU มาก ๆ ก็จะทำให้การสนองตอบจะช้าลง การนำเอาเธรดเข้ามาช่วยจะเหมือนกับว่าสามารถทำงานสองอย่างในเวลาเดียวกัน แต่ที่จริงแล้ว ระบบทำการสลับการใช้ CPU ระหว่างโปรแกรมต่าง ๆ เมื่อสิ้นสุดก็กลับมาทำงานเดิมต่อ

ชีวิตของเธรด

รูป13-1

1.      เริ่มต้นชีวิตด้วยคีย์เวิร์ด new

2.      ใช้คำสั่ง start ให้เธรดเริ่มทำงาน โดยเธรดจะทำตามสิ่งที่อยู่ในเมท็อด run ต้อง override เมท็อดนี้

3.      Time waiting คือบางครั้งทำงานอยู่ก็สามารถให้เธรดหยุดการทำงานชั่วคราวได้ โดยใช้เมท็อด sleep หรือ เมท็อด wait

4.      เธรดกลับมาทำงานเหมือนเดิมจากการตื่นจาก sleep หรือ ไม่ก็ถูกปลุกด้วย notify

5.      Terminated คือการหยุดทำงานเมื่อจบคำสั่งจาก run

ประเภทของเธรด

            ประเภทของเธรดมี 2 แบบ

1.แบบ extends Thread

            public void run( ){ }

2. แบบ implements Runnable

            public void run( ){ }

            ไม่ว่าจะ extends หรือ implements มาก็ต้องทำการ override เมท็อด run แล้วจะรู้ได้ยังไงว่าจะต้อง extends หรือ implements – ก็แล้วแต่ว่าคลาสนั้นไป extends อะไรมาก่อนหรือเปล่า เพราะจาวาไม่ให้ extends คลาสหลายๆคลาสพร้อมกันได้(multi-inheritance) ถ้าไป extends อะไรมาแล้วก็ implements เอา

            ตัวอย่างเธรด

รูป13-2

บรรทัดที่ 3 : สร้างคลาส TestThread โดยให้ extends Thread มา ถ้าจะใช้อินเทอร์เฟซก็เปลี่ยนเป็น

            implements มาแทน

บรรทัดที่ 5 : override เมท็อด run ข้างหน้าเลข 5 จะมีรูปสามเหลี่ยมสีเขียวบอกว่าทำการ override เมท็อด

            run จากคลาส Thread

บรรทัดที่ 14 : สร้างอ็อปเจ็คของ TestThread ขึ้นมาและให้ตัวแปรนี้เรียก start();

บรรทัดที่ 15 : เรียก start();

ผลลัพธ์ที่ได้

รูป13-3

Multi-thread

            เป็นการทำงานของเธรดหลายตัวพร้อมกันโดยการทำงานของเธรดจะเป็นอิสระต่อกัน สามารถใช้multi-thread ด้วยสิ่งที่เรียกว่า anonymous inner class ก็คือคลาสย่อยในคลาสอีกคลาสหนึ่ง

รูป 13-4

บรรทัดที่ 5 : new Thread ขึ้นมาแต่จะสังเกตว่ามีการ new Runable ขึ้นมาเป็น anonymous inner class ด้วย

ภายใน Runable ก็ทำการ implements เมท็อด run

บรรทัดที่ 8 : หน้าเลข 8 จะมีสามเหลี่ยมสีขาวเพื่อแสดงการ implements เมท็อดจากคลาส Runable

บรรทัดที่ 11 : ระบุเวลาสำหรับหยุดการทำงานของเธรด หน่วยเป็น millisecond

บรรทัดที่ 13 : แสดงตัวอักษร x ออกจากหน้าจอ

บรรทัดที่ 18 : ให้เธรดแรกเริ่มการทำงาน

บรรทัดที่ 20 : new Thread ขึ้นมาและ new Runable ขึ้นมาเป็น anonymous inner class

บรรทัดที่ 24 : เปลี่ยนเวลาสำหรับหยุดการทำงานเหลือแค่ 50 millisecond

บรรทัดที่ 26 : แสดงตัวอักษร y

ผลลัพธ์

รูป13-5

            จะเห็นว่า y จะแสดงออกทางหน้าจอมากกว่า x เพราะเวลาสำหรับหยุดการทำงานของ y นั้นน้อยกว่า x และทุกๆ 2 บรรทัด x และ y จะแสดงออกทางหน้าจอพร้อมกันอยู่บรรทัดเดียวกันก็เพราะว่าเธรดทำงานเป้นอิสระต่อกันจึงสามารถแสดงผลออกมาพร้อมกันได้

เมท็อดในเธรด

            เมท็อด sleep

static void sleep(long millis)

            เมท็อดนี้เธรดจะหยุดทำงานจนครบกำหนดเวลาก็จะคืนค่าออกมาเหมือนเดิม

            เมท็อด join

void join (long millis)

                        ถ้าใช้ join กับเธรดตัวไหน เธรดตัวนั้นจะทำงานครบตาม run ก่อนเธรดอื่นถึงจะทำงาน

            เมท็อด wait

void wait()

                        เธรดจะหยุดการทำงานจนกว่า จะมีการเรียกเมท็อด void notify()

            ปกติเวลาที่เขียนคลาสขึ้นมาคลาสหนึ่งจะต้องกำหนดไปเลยว่าคลาสนั้นจะให้มีอินพุตชนิดของข้อมูลเป็นประเภทไหน แล้วทำงานอะไรบ้าง เช่นคลาส A กำหนดว่าจะให้มีอินพุตเป็นจำนวนเต็ม เอาไปทำงาน พอมีคลาสอื่นมาประกาศอ็อปเจ็คประเภทคลาส A ก็จะต้องใส่อินพุตเป็นจำนวนเต็มเท่านั้น ไม่อย่างนั้นจะ error แต่บางครั้งการทำงานของคลาส A มีประโยชน์กับคลาสอื่นที่ไม่ได้ใช้อินพุตแบบจำนวนเต็มก็ทำให้ต้องสร้างคลาสใหม่แล้วก็ไปก็อบข้อมูลของคลาส A มาเปลี่ยนชนิดข้อมูลจาก Integer ไปเป็นอย่างอื่น

รูป 14-1

            สร้างคลาสแบบปกติโดยมีตัวแปร a กับ b และมีเมท็อดสำหรับคืนค่าของตัวแปรออกไป โดยคลาสนี้กำหนดให้ภายในคลาสมีข้อมูลประเภท int ซึ่งคลาสใดๆที่เรียกใช้อ็อปเจ็คของคลาสนี้จะต้องใช้ข้อมูลแบบ int เหมือนกัน

รูป14-2

            นี่คือตัวอย่างของคลาสปกติที่ได้เขียนๆกันอยู่แล้วคือคลาส NormalClass ให้ชนิดของข้อมูลเป็น int ดังนั้นเวลาที่คลาส CallNormal เรียกอ็อปเจ็คของคลาส NormalClass มาใช้ตอนเรียกคอนสตรัคเตอร์ก็ต้องใส่ข้อมูลเป็น int ถ้าใส่ double เช่น 5.5 ก็จะ error

การใช้งานเจอเนริค

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

class ชื่อคลาส< ประเภทข้อมูล>

            ส่วนการใช้งานเขียนแบบนี้

ชื่อคลาส<ประเภทข้อมูล> ชื่อตัวแปร = new ชื่อคลาส<ประเภทข้อมูล>(พารามิเตอร์);

รูป 14-3

            เอาคลาส NormalClass มาเขียนใหม่ในรูปแบบของเจอเนริค

บรรทัดที่ 3 : สร้างคลาสชื่อ Generic ตามด้วยเครื่องหมาย <> โดยให้ข้างในเป็นประเภทของข้อมูล ในที่นี้ให้

เป็นประเภท T

บรรทัดที่ 4 : ประกาศตัวแปร a ของคลาส เป็นประเภท T ที่ให้เป็นประเภท T เพราะว่าเวลาที่มีการเรียกใช้อ็อป

เจ็คของเจอเนริคแล้วมีการกำหนดว่า T เป็นอะไร ตัวแปรจะได้เป็นข้อมูลประเภทนั้นไปด้วย

บรรทัดที่ 7 : สร้างคอนสตรัคเตอร์(เมท็อดที่ชื่อเหมือนคลาส) รับพารามิเตอร์สองตัวเป็นประเภท T เหมือนเดิม

แล้วตั้งค่าให้ตัวแปร x กับ y

บรรทัดที่ 12 : สร้างเมท็อดสำหรับดูค่าของตัวแปร a ประเภทของตัวแปรที่จะคืนค่าออกก็ต้องเป็น T ด้วย

รูป14-4

บรรทัดที่ 8 : เรียกใช้อ็อปเจ็คของ Generic โดยกำหนดประเภทของข้อมูลเป็นจำนวนเต็ม Integer (กำหนดใน

<>) เมื่อให้อ็อปเจ็คนี้รับข้อมูลประเภอจำนวนเต็มในพารามิเตอร์จึงสามารถใส่เลขจำนวนเต็ม 5 กับ 7 ได้

บรรทัดที่ 9-10 : ให้ตัวแปร x และ y ซึ่งเป็นตัวแปรประเภท int เก็บค่าของอ็อปเจ็ค g ที่เรียกมาจากเมท็อดของ

คลาส Generic

บรรทัดที่ 11-12 : แสดงค่าของ x y ออกมาดู

บรรทัดที่ 15 : ประกาศตัวแปร w กับ z เป็น double

บรรทัดที่ 16 : เรียกใช้อ็อปเจ็คประเภทGeneric อีd ให้ชื่อว่า g2 กำหนดเป็นประเภท double เพราะฉะนั้นอ็อป

เจ็คนี้จะเก็บ double

ผลลัพธ์ที่ได้

รูป 14-5

            จะเห็นว่าด้วยการใช้เจอเนริคจะทำให้เวลาต้องการเอาคลาสไปใช้งานซ้ำๆสามารถทำได้อย่างง่ายดายไม่ต้องคอยเปลี่ยนประเภทของข้อมูล แต่อย่างไรก็ตามหากใส่ประเภทข้อมูลประเภทไหนในเจอเนริคแล้วก็ต้องใช้ข้อมูลแบบนั้นตลอด

เจอเนริคกับอ็อปเจ็ค

            ภายในเครื่องหมาย<> จะต้องใส่คลาสลงไปเท่านั้น ไม่สามารถใส่พวกประเภทข้อมูลแบบ primitive ได้เช่น int, float, long, double เพราะจะทำให้ error

เช่น       Gen<int> Obj = new Gen<int>(53);

แบบนี้ไม่ได้เพราะ int เป็น ประเภทข้อมูลแบบ primitive ส่วน Integer เป็นคลาสของข้อมูลประเภท int ดังนั้นหากต้องให้เจอเนริคเป็น int ต้องใส่คลาส Integer ลงในเครื่องหมาย <>

ไม่ใช้เจอเนริคได้ไหม แบบจะ cast ข้อมูลเอาได้ไหม – ได้ แต่มันก็จะยุ่งยากอีกเรื่องต้อง cast เพราะถ้าลืมมันจะคอมไพล์ไม่ผ่านซึ่งถ้าใช้เจอเนริคแต่แรกก็จบปัญหานี้แล้ว

เจอเนริคแบบรับพารามิเตอร์มากกว่าหนึ่ง

            เจอเนริคไม่จำเป็นต้องมีพารามิเตอร์แค่ตัวเดียวก็ได้ มีสองหรือมากกว่าก็ได้ โดยเขียนแบบนี้

class ชื่อคลาส< ประเภทข้อมูล1, ประเภทข้อมูล2 >

            ส่วนการใช้งานเขียนแบบนี้

ชื่อคลาส<ประเภทข้อมูล1, ประเภทข้อมูล2 > ชื่อตัวแปร

= new ชื่อคลาส<ประเภทข้อมูล1, ประเภทข้อมูล2 > (พารามิเตอร์1, พารามิเตอร์2);

รูป 14-6

            แก้ไขจากคลาสเจอเนริคเดิม แต่คราวนี้ให้เจอเนริคไม่จำเป็นต้องเป็นข้อมูลประเภทเดียวแต่เป็นสองประเภทคือ T กับ V หลังจากนั้นให้ a กับ b เป็นตัวแปรประเภท T และ V ตามลำดับ หลังจากนั้นก็เขียนคอนสตรัคเตอร์และเมท็อด

รูป14-7

            เมื่อทำการ new อ็อปเจ็คของคลาส Generic ขึ้นมาคราวนี้จะต้องใส่ พารามิเตอร์สำหรับประเภทข้อมูลให้ครบทั้งสอง โดยบรรทัดที่ 8 ทำการใช้อ็อปเจ็คของ Generic และให้ประเภทของข้อมูลหรือไทป์พารามิเตอร์(type parameter)เป็น double และ String ตามลำดับ ดังนั้นตรงพารามิเตอร์ของคอนสตรัคเตอร์ก็ต้องใส่ข้อมูลเป็น double และ String ตามลำดับด้วย

ผลลัพธ์ดังภาพ

รูป14-8

คอนสตรัคเตอร์ของคลาสเจอเนริค

            จากตัวอย่างจะเห็นว่าการประกาศใช้งานคอนสตรัคเตอร์คลาสที่เป็นคลาสเจอเนริคไม่ต้องมีไทป์พารามิเตอร์ต่อท้ายแบบว่า            public Generic<T>( ) { } แต่สามารถเขียนว่า public Generic( ) { } ได้เลย หรือจะมีพารามิเตอร์ public Generic(T x ) { } ก็ได้

ArrayList<E>

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

การสร้างอาร์เรย์ลิสต์

ArrayList<ประเภทข้อมูลที่จะเก็บในอาร์เรย์ลิสต์> ชื่อตัวแปร

= new ArrayList<ประเภทข้อมูลที่จะเก็บในอาร์เรย์ลิสต์>(ขนาดของอาร์เรย์ลิสต์);

            การใช้งานอาร์เรย์ลิสต์ต้อง import java.util.ArrayList;

ตัวอย่างการสร้างอาร์เรย์ลิสต์

ArrayList<String> list = new ArrayList<String>(10);

            นี่คือการสร้างอาร์เรย์ลิสต์ชื่อลิสต์สำหรับเก็บสตริง10ช่อง อย่าลืมว่าภายใน<> เก้บข้อมูลแบบ primitive ไม่ได้

เมท็อดของอาร์เรย์ลิสต์

            เพิ่มข้อมูล add เช่น list.add(“cat”); เพิ่มคำว่า cat

เรียกข้อมูล get เช่น list.get(list.size()-1); ดูข้อมูลตัวสุดท้าย

ลบข้อมูล remove เช่น list.remove(0); ลบข้อมูลช่องแรกของอาร์เรย์ลิสต์

ดูขนาดของอาร์เรย์ลิสต์ size เช่น list.size();

รูป14-9

ตัวอย่างการใช้ ArrayList โดยใช้ลูป for เป็นข้อมูลในลิสต์11ตัว

บรรทัดที่ 17 : เพิ่มข้อมูลลงใน list ข้อมูลจะไปปรากฏที่ท้ายสุดของอาร์เรย์ ปริ้นมาดูว่าจริงไหม

บรรทัดที่ 20 : ขอดูข้อมูลตำแหน่งสุดท้ายต้อง size-1 เพราะอาร์เรย์เริ่มต้นที่ 0

บรรทัดที่ 22 : ลบข้อมูลตำแหน่งที่ size-5 ก็นับมาจากตัวสุดท้าย 5 ตัวคือต้องลบ 7 ออก ก็ปริ้นออกมาดูอีก

รูป14-10

บรรทัดแรกวนลูปใส่ list จากตอนแรก list มี 0 ช่อง ก็กลายเป็น 11 ช่อง

บรรทัดที่สองเพิ่มข้อมูล 66 ต้องไปอยู่ท้ายสุด

บรรทัดที่สามดูข้อมูลตัวสุดท้ายเท่ากับ 66

บรรทัดที่สี่ลบเลข7

            GUI คือส่วนที่เป็นกราฟฟิคของโปรแกรมเอาไว้ใช้ติดต่อกับผู้ใช้งานจริงๆ ในตอนแรกๆที่เขียนโปรแกรมจะเป็นทำงานและทดสอบผ่าน console แต่การสร้าง GUI จะทำให้โปรแกรมสมบูรณ์และพร้อมสำหรับการใช้งานจริงๆ สำหรับการสร้าง GUI ในจาวามีสิ่งที่เรียกว่า Abstract Window Toolkit (AWT) และ Swing มาช่วยในการทำงาน

ส่วนประกองของ GUI

            ประกอบด้วย 3 ส่วนหลักๆที่จำเป็นสำหรับโปรแกรม

– Layout Managers : คือส่วนของการจัดวาง Layout ต่าง โดย Layout ก็คือรูปแบบการวางสิ่งต่างๆหน้าต่างของโปรแกรม

– Containers : คือพวก Component ที่สามารถนำมาสร้างเป็น Window Form หลักได้ เช่น Frame หรือวินโดว์, Dialog กล่องสำหรับแสดงข้อความ และPanel เป็นเหมือนกระดาษที่แปะอยู่บนวินโดว์

– Graphical Components : คือพวกของต่าง ๆ ที่เราจะนำมาใส่ใน Windows Form เพื่อให้โปรแกรมใช้งานได้ จำนวนปุ่มต่างๆ เช่น พวก Label, Textbox , Button , Menu, MenuBar และอื่น ๆ

การใช้งานของข้างบนนี้จะทำผ่านคลาส ที่อยู่ในกลุ่มของ Swing (javax.swing) และ AWT (java.awt) คือต้องทำงานการอิมพอร์ตเข้ามาจาก java.awt.*; หรือ javax.swing.*; โดยทั้ง Swing และ AWT ล้วนทำงานได้เหมือนกันคือสร้าง  window form กับพวกปุ่มต่างๆและการจัดวางหน้า โดยที่ AWT นั้นสืบคุณสมบัติมาจากComponent ส่วน Swing สืบคุณสมบัติมาจาก JComponent ชื่อต่างๆก็จะขึ้นต้นด้วย J เช่น JLabel, JTextbox , JButton

แล้วจะใช้อันไหน – Swing จะได้ใช้มากกว่าเพราะเอาไปรันในระบบปฏิบัติการที่ต่างกันก็ไม่เพี้ยน ทำงานได้เร็วกว่าและมีลูกเล่นต่างๆมากว่าด้วย ดังนั้นต่อไปก็จะพูดถึงและใช้ Swing

รูป15-1

การสร้าง GUI ก็เพียงแค่สร้างคลาสขึ้นมาคลาสหนึ่งจากนั้นก็ทำการ extends JFrame(บรรทัดที่ 6)

บรรทัดที่ 1-3 :  สามารถเขียนได้แบบ import javax.swing.*; จะเห็นว่าคอมโพเนนท์ต่างๆที่อิมพอร์ทมาจะมีตัว

J อยู่ข้างหน้า

บรรทัดที่ 14 : สร้างคอนสตรัคเตอร์ขึ้นมา ด้วยคำสั่งต่างๆดังนี้

บรรทัดที่ 16 : setSize(x,y); ตั้งขนาดของกรอบวินโดว์

บรรทัดที่ 17 : setLocation(x,y); เวลาที่เปิดโปรแกรมจะให้มันรันอยู่ส่วนไหนของหน้าจอ ในบรรทัดนี้เซ็ทเป็น

(500,280) ก็จะรันอยู่ตรงกลางหน้าจอ

บรรทัดที่ 18 : setDefaultCloseOperation ตรงนี้ให้เป็น EXIT_ON_CLOSE คือเวลากดกากบาทสีแดง

โปรแกรมก็จะปิดการทำงาน

บรรทัดที่ 19 : setVisible(true); คือทำให้หน้าจอวินโดว์มันมองเห็นใช้ได้

บรรทัดที่ 21-22 : สร้างLabel สำหรับแปะตัวหนังสือ

บรรทัดที่ 24-27 : สร้าง Panel เอาตัวหนังสือไปแปะ

            จากนั้นในเมท็อด main ให้เรียกตัวเองขึ้นมาทำงาน

ผลลัพธ์

รูป15-2

แต่เนื่องจากคำสั่งสำหรับปุ่ม textfield textarea อะต่างๆมากมายนั้นมีเยอะมาก ถ้าจะเขียนเองก็จะยาวและเยอะมากๆเพราะต้องนึกถึงความจริงทำโปรแกรมคงไม่ได้มีแค่ปุ่มเดียวจบแต่มันจะหลายปุ่มหลายช่องสำหรับกรอกข้อมูล eclipse จึงมีสิ่งที่เรียกว่า WindowBuilder Designer มาช่วยในการสร้าง GUI ซึ่งทำให้การสร้าง GUI ง่ายมากๆแค่ลากวาง ลากวาง แต่ทั้งนี้ทั้งนั้นก็ต้องโหลด WindowBuilder มาก่อน(อ่านได้จาก การดาวน์โหลดและใช้งานWindowBuilder)

ทีนี้มาลองสร้าง JFrame อีกวิธีหนึ่งกัน

รูป15-3

            ขั้นแรกคลิกขวาเลือกที่ New เหมือนเวลาจะสร้างคลาส แต่เลือกตรง other…

รูป15-4

ได้หน้าต่างนี้ขึ้นมาเลือกตรงคำว่า WindowBuilder จะปรากฏ Swing Designer จากนั้นเลือกJFrame กด Next เพื่อสร้าง JFrame

รูป15-5

จากนั้นก็ใส่ชื่อและกด finish

รูป15-6

ได้ JFrame มา 2 ส่วนโดยไม่ต้องพิมพ์ โดยส่วนแรกคือเมท็อด main สำหรับเรียงตัวเองพร้อมดักจับ exception ให้ด้วย และส่วนที่สองคือคอนสตรัคเตอร์สำหรับกำหนดรูปร่างหน้าและการทำงานของวินโดว์ โดยในคอนสตรัคเตอร์จะกำหนดค่าพื้นฐานให้กับวินโดว์ด้วย นอกจากนี้ยังทำการอิมพอร์ทให้ทั้ง java.awt และ javax.Swing

รูป15-7

การใช้เครื่องมือต่างๆของ WindowBuilder

            ก็อย่างที่บอกไปแล้วว่า WindowBuilder ช่วยให้การสร้าง from ต่างๆง่ายมากเพราะเราไม่จำเป็นต้องเขียนโค๊ดเอง eclipse จะเขียนให้อัตโนมัติจากการลากวางๆใน WindowBuilder ดังนั้นเราต้องรู้ว่ามีเครื่องมืออะไรให้ใช้บ้าง

            ก่อนอื่นให้กดปุ่ม Design ซึ่งจะอยู่บริเวณเหนือ console

รูป15-8

จะปรากฏหน้าต่างดังข้างล่าง

รูป 15-9

มาดูว่าในหน้าต่างนี้ประกอบไปด้วยอะไรบ้าง

รูป 15-10

หมายเลข 1 : จะบอกว่าเราใช้คอมโพเนนท์อะไรและชื่ออะไรบ้าง

หมายเลข 2 : ถ้าไปคลิกที่คอมโพเนนท์ใดๆจะปรากฏรายละเอียดของคอมโพเนนท์นั้นๆ เช่น ชื่อ ตัวหนังสือที่ใช้ สีตัวหนังสือ ชื่อตัวแปร และอื่นๆ

หมายเลข 3 : ที่สำหรับกดคอมโพเนนท์ต่างๆลากไปใส่หมายเลข 4 ที่เป็นวินโดว์

หมายเลข 4 : วินโดว์สำหรับลากคอมโพเนนท์ต่างๆมาใส่

หมายเลข 5 : ตัวอย่างของปุ่มที่ถูกลากเอามาใส่แล้ว

            ในรูปเอา JBotton ใกล้ๆเลข3 ลากขึ้นไปแปะในJframe โค๊ดก็จะไปปรากฏเมื่อเราคลิกที่ source ปุ่มติดกับ design

รูป15-11

            บรรทัดที่ 42 ปรากฏโค๊ดของปุ่มโดย new ขึ้นมา JBotton ซึ่งง่ายดายไปไม่ต้องเขียนเอง

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

รายละเอียดเครื่องมือบนWindowBuilder

            ประกอบไปด้วย Containers, Layouts

รูป15-2-1

Components, Swing Actions, Menu

รูป15-2-2

Containers

คอนเทนเนอร์ก็คือของต่างๆที่เราสามารถใส่คอมโพเนนท์ลงไปได้ ซึ่งจะขอแนะนำ 3 อย่างได้แก่ JPanel, JScrollPane

JPanel

เป็นพื้นที่กรอบสี่เหลี่ยมที่สามารถใส่คอมโพเนนท์ลงไปได้ วิธีการใช้ก็เลือกตรง JPanel หลังจากนั้นก็ลากไปวางในเฟรม

รูป15-2-3

เมื่อลากมาจากจะปรากฏ JPanel บนเฟรม ตรงช่องซ้ายบนที่ชื่อ Components จะปรากฏชื่อ panel ขึ้นมา และในช่อง Properties กำหนดเป็นสีชมพูจะมองเห็น panel ของเราเป็นสีชมพู(อันนี้ใส่สีให้เห็นตัว panel เฉยๆ ไม่ต้องใส่สีตามก็ได้)

รูป15-2-4

            เมื่อมาดูที่ source จะมีการสร้างโค๊ดให้ดังนี้ ให้ตัวแปร panel เป็นอ็อปเจ็คของ JPanel หลังจากนั้นให้ contenPane (ที่เป็น panel เริ่มต้นตอนสร้างเฟรมซึ่งสร้างอัตโนมัติ)เรียกเมท็อด add ลงบนเฟรม panel ที่เราสร้างเองก็จะปรากฏบนเฟรม

รูป12-4-5

JScrollPane

JScrollPane เป็นคล้ายๆกับ JPanel แต่เป็น panel ที่เลื่อนไปมาขึ้นลงได้ คือลองนึกถึงโปรแกรมที่มีภาพแต่ว่าที่แสดงภาพมันเล็กกว่าภาพดังนั้นก็ต้องทำให้ที่แสดงภาพมันเลื่อนไปหาบนล่าซ้ายขวาได้ ถึงจะสามารถเห็นภาพได้ทั้งภาพ JScrollPane นี่ก็จะอยู่ข้างๆกับ JPanel ก็ลากมาวาง

รูป15-2-6

เมื่อลากมาวางก็จะเห็น JScrollPane

รูป15-2-7

            อีกวิธีการสร้าง JScrollPane อย่างง่ายๆก็คือให้มัน surround ให้เลยดังนี้ ขั้นแรกให้ลาก JTextArea มาวางแล้วพิมพ์คำว่าอะไรลงไปก็ได้ ขยายขนาดตัวหนังสือให้มันใหญ่ๆ

รูป 15-2-8

            คลิกขวาที่ JTextArea เลือก surround with เลือก javax.swing.JScrollPane

รูป15-2-9

            ขั้นตอนการทำงานคือจะใช้ JScrollPane ก็สร้าง Container มาตัวนึง เช่น JPanel แล้วก็เอา Component ที่จะใช้ใส่เข้าไป แล้วก็สร้าง JScrollPane มาครอบ JPanel ข้างบน แล้วค่อยเอา JScrollPane ไปใส่ใน JFrame อีกที ก็จะgenerate โค๊ดให้อัตโนมัติ ได้ตามที่บอก คือเอา text ไปใส่ JScrollPane แล้ว JScrollPaneไปแปะบน contentPane ลองไล่โค๊ดดู

รูป 15-2-10

ผลลัพธ์ก็จะมีที่เลื่อนๆให้ใช้งานได้แล้วทีนี้

รูป 15-2-11

Layout Manager

คือรูปแบบการจัดวางของสิ่งต่างๆในเฟรมของโปรแกรมจะแนะนำวิธีจัดการกับเฟรมทั้งหมด 4 แบบ ได้แก่ FlowLayout, BorderLayout, GridLayout และ Absolute layout

FlowLayout

ตัวนี้เป็น default layout manager คือถ้าไม่ได้กำหนดว่าจะให้ layout เป็นแบบไหน มันจะเป็น FlowLayout โดยอัตโนมัติ ซึ่ง FlowLayout จะแบ่งช่องออกเป็นแถว เป็นช่องๆ จะะทำการจัดเรียงคอมโพเนนท์พวกปุ่มๆต่างๆจากซ้ายไปขวาจนเต็ม

รูป15-2-12

ลาก FlowLayout จากช่อง Layout ไปวางในเฟรมของเรา

รูป15-2-13

ลองลากปุ่มไปวาง สังเกตว่าปุ่มจะมีขนาดเท่ากันและเรียงไปทางเดียวกันหมด ดูโค๊ดตรง setLayout ก็จะบอกว่าเราใช้ FlowLayout อยู่ ถ้าใช้อย่างอื่นก็จะ new อย่างอื่นขึ้นมา

รูป15-2-14

BorderLayout

            จะจัดเรียงหน้าจอเป็นบน ล่าง ซ้าย ขวา และตรงกลางโดยแต่ละช่องวางได้แค่ 1 คอมโพเนนท์ ถ้าอยากวางมากกว่า 1 ต้องเอาคอมโพเนนท์นั้นใส่ใน panel แล้วเอามาแปะที่ layout ทีหลัง

ก่อนอื่นก็เลือก BorderLayout ไปแปะก่อน

รูป15-2-15

            ลองเอาคอมโพเนนท์ไปวางจะพบว่าLayout กลายเป็นบน ล่าง ซ้าย ขวา แล้วแล้วเวลาเอาไปวางตรงไหนก็จะบอกด้วยว่าเรากำลังจะวางตรงไหน

6

            เมื่อเอาปุ่มไปวางปุ่มก็จะมีขนาดเท่ากับLayout ที่กำหนดมาให้

รูป15-2-17

GridLayout

แบบ layout เป็นตารางต้องกำหนดเช่นให้มีแถวละสองช่องก็จะมีสองช่องทุกคอมโพเนนท์ที่ใส่ลงไปจะเท่ากันหมด อาจเอาไปใช่กับการกรอกข้อมูลน้อยๆได้เช่นต้องการแค่ชื่อกับเบอร์โทรก็แบ่งฝั่งซ้ายพิมพ์เท็ซ์ฝั่งขวาเป็นปุ่ม

เอา GridLayout ไปวางเหมือนเดิม

รูป15-2-18

ผลลัพธ์

รูป15-2-19

Absolute layout

เป็นตัวที่เหมาะสำหรับการจัดหน้าตาโปรแกรมตามใจชอบ คือเมื่อเอา absolute layout ไปวางจะสามารถเอาปุ่ม เอาที่กรอกตัวหนังสือไปวางตรงไหนขนาดเท่าไหร่ก็ได้ กำหนดเองได้หมด

รูป15-2-20

ผลลัพธ์เราสามารถจัดเรียงปุ่มได้ตามความต้องการของเรา

รูป15-2-21

หลังจากเข้าใจเรื่อง GUI และการใช้งานเบื้องต้นและการจัดหน้าเฟรมแล้ว ก็จะต่อที่การใช้คอมโพเนนท์ต่างๆซึ่งก็จะไม่ได้พูดถึงทุกตัวแต่จะพูดตัวหลักๆเท่าที่จำเป็นก่อนซึ่งตัวอื่นๆก็สามารถศึกษาเพิ่มเติมได้ภายหลัง การดูโค๊ดจะเป็นไปตามหัวข้อ Graphic User Interface (GUI) 2 ดังนั้นบทนี้จะไม่ได้แสดงโค๊ดของหน้า source ให้ดูแล้ว(สามารถคลิ๊กไปดูได้เอง)

Components

            คือส่วนคอมโพเนนท์ต่างๆสำหรับการใช้งาน เช่น ปุ่ม ช่องกรอกตัวหนังสือ การทำตัวเลือกและอื่นๆซึ่งจะแนะนำตามหัวข้อข้างล่าง 10 รายการ

JLabel

Label แปลว่าฉลาก ก็คือฉลากที่ปิดไว้เพื่อบอกว่าสิ่งนี้คืออะไรหรือก็คือที่เอาไว้สำหรับเขียนชื่อนั้นเอง ซึ่ง JLabel จะอยูในช่องของ Coponents

15-3-1

เมื่อลาก JLabel มาวางก็จะได้Label มาและสามารถเปลี่ยนชื่อได้ตามความต้องการ

15-3-2

15-3-3

การปรับเปลี่ยนคอมโพเนนท์ในช่อง Properties ที่สำคัญ

เริ่มจากวงกลมข้างบนคือการเปลี่ยนให้ตัวแปรไปประเป็นตัวแปรของคลาส(จะได้ใช้งานง่ายๆ)

1.      Variable คือตัวแปรของคอมโพเนนท์ ชื่ออ็อปเจ็คที่จะทำการ new Label ขึ้นมา ควรตั้งชื่อให้มีความหมายจะได้จำได้ง่ายๆ เช่น สมมติเป็น Label สำหรับกรอกชื่อ Label ตัวนี้ก็น่าจะมีตัวแปรชื่อ lblName เป็นต้น เพราะถ้าเป็น lblNewLabel1, lblNewLabel2, lblNewLabel3 ไปเรื่อยๆก็จะงงได้ ใช้หลักการนี้กับทุกคอมโพเนนท์

2.      เป็นสีของพื้นหลังส่วน foreground เป็นสีของตัวหนังสือ

3.      ทำให้มองเห็นได้

4.      คือชื่อของ Jlabel ตัวนี้ที่จะให้ทำคนอื่นมองเห็น หลักการตั้งชื่อควรมีความหมาย เช่นเดียวกับข้อ1

JTextField

คือที่สำหรับการกรอกข้อมูลตัวหนังสือ เช่นต้องการให้ผู้ใช้หรอกข้อมูลชื่อ เบอร์โทร ที่อยู่เป็นต้น

รูป15-3-4

รูป15-3-5

JBotton

เป็นปุ่มสำหรับกดเพื่อให้กระทำบางอย่างเช่น บันทึกข้อมูลเป็นต้น

รูป 15-3-6

รูป15-3-7

JComboBox

ไว้หรับเป็นช่องสำหรับให้ผู้ใช้เลือกตัวเลือก เช่น เพศ ระดับการศึกษาที่จบเป็นต้น

รูป15-3-8

ได้ ComboBox ถ้ากดตรงสามเหลี่ยมหัวทิ่มลงก็จะขึ้นตัวเลือกมาแต่นี่ยังเลือกไม่ได้ต้องอ่านเรื่องการจัดการอีเวนท์ก่อน

รูป15-3-9

JRadioButton

ก็เป็นช่องสำหรับเลือกแบบเดียวกับ ComboBox จะพบเห็นตามตัวเลือกเช่น จะยอมรับข้อตกลงการดาวน์โหลดหรือไม่ เป็นต้น

รูป15-3-10

ตัวอย่าง

รูป15-3-11

JTextArea

เป็นที่สำหรับแสดงข้อความออกมาเช่นในข้อความของโปรแกรมแชทเป็นต้น

รูป15-3-12

รูป15-3-13

JPasswordFiled

เป็นช่องสำหรับพิมพ์ข้อความคล้ายกับ JTextField แต่ข้อความที่หรอกใน JPasswordFiled จะไม่ปรากฏให้เห็น พูดง่ายๆก็คือเป็นช่องสำหรับกรอกพาสเวิร์ดโดยเฉพาะ

รูป15-3-14

รูปร่างคล้าย JTextField

รูป15-3-15

JTable

ไว้สำหรับการแสดงผลเป็นตางราง น่าจะใช้คู้กับ JScrollPane หากตารางมีขนาดใหญ่

รูป15-3-16

ใช้ร่วมกับ JScrollPane  จะปรากฏในหน้า Structure

รูป15-3-17

JDialog

คือกล่องข้อความ สำหรับบอกข้อความบางอย่างแก่ผู้ใช้ JDialog สามารถใช้งานได้จากคลาส OptionPane (javax.swing.JOptionPane) มาดูว่ามีไดอะล็อกแบบใดบ้าง(ให้พิมพ์ตามนี้)

ข้อความเตือน

รูป15-3-18

รูป 15-3-19

ข้อความเตือนพร้อมรูป1

ให้ JOptionPane เรียก WARNING_MESSAGE

รูป 15-3-20

รูป15-3-21

ข้อความเตือนพร้อมรูป2

รูป 15-3-22

รูป 15-3-23

ข้อความให้เลือก

รูป 15-3-24

รูป 15-3-25

ตัวอย่างของ GUI

รูป 15-3-26