บทที่ 3 Class and Object 2 บทที่ 3 Class and Object กฏในการเข้าถึงสมาชิกในคลาส จากตัวอย่าง Easy.cpp ในข้างต้น จะเห็นได้ว่า สมาชิกในคลาส จู่ ๆ เราจะเข้าถึงทันทีเลยไม่ได้ อ็อบเจ็ตก์จะเรียกใช้ฟังก์ชั่นหรือตัวแปรในคลาสได้จะต้องกำหนดให้เป็นแบบ public เสียก่อน ซึ่งตรงจุดนี้เป็นความสามารถของ OOP ที่จะช่วยให้เกิดความปลอดภัยของข้อมูลในคลาสมากขึ้น ระดับในการเข้าถึงข้อมูลในคลาสจะมีอยู่ด้วยกัน 3 ระดับ คือ 1. ส่วนตัว หรือ Private 2. สาธารณะ หรือ Public 3. ปกป้อง หรือ Protect ถ้าเราสร้างคลาสขึ้นมา โดยไม่ได้ระบุว่าเป็น private, public หรือ protect ใด ๆ สมาชิกภายในคลาสก็จะเป็นแบบ private ทั้งหมด เรามาดูกันต่อไปว่าความแตกต่างของ private กับ public นั้นต่างกันอย่างไร สำหรับแบบ protect นั้น เราจะพักเอาไว้ก่อน เราจะไปพูดถึงกันอีกทีหนึ่งในตอนที่เราเข้าสู่เรื่องของการสืบทอดคลาสแล้ว (เมื่อท่านเข้าใจเรื่อง public และ private ที่จะได้อธิบายต่อไปนี้ เมื่อท่านศึกษาเรื่องของ protect ก็จะเข้าใจได้ง่ายขึ้นครับ) ลองพิจารณาคลาสต่อไปนี้ class Person { int age; void setage( int a ) { age=a; } void showage( ) { printf( "age = %d\\n",age ); } }; คลาสนี้ ดูแล้วรู้ได้ทันทีว่า สมาชิกทุกตัวในคลาสเป็นแบบ private หมด สมาชิกแบบ private นั้น จะอนุญาตให้กระบวนการที่ดําเนินการอยู่ภายในคลาสเดียวกันเรียกใช้งานกันได้ ในคลาส Person จะเห็นว่ามีฟังก์ชั่น setage และ showage ซึ่งต่างก็เรียกใช้ตัวแปร age ได้ พูดง่าย ๆ ก็คือ ตัวแปรและฟังก์ชั่นนั้นสามารถเรียกใช้กันไป ๆ มา ๆ ภายในคลาสได้อย่างเป็นปกติสุขทุกอย่าง แต่ถ้าเกิดเราสร้างอ็อบเจ็กต์ของคลาสขึ้นมา และเรียกใช้ตัวแปรที่อยู่ในคลาส.. แบบนี้... Person p; p.age=10; เราจะเรียกใช้แบบนี้ไม่ได้เลย ทั้งนี้เป็นเพราะว่าอ็อบเจ็กต์ p เป็นตัวแปรที่ถูกสร้างขึ้นมาใหม่อยู่ภายนอกคลาสนั้นเอง สำหรับการประกาศให้เป็น public นั้น เราจะต้องเขียนคำว่า public: ไว้ที่บรรทัดก่อนที่จะทำการประกาศตัวแปรหรือฟังก์ชั่นนั้น เช่น class Person { public: int age; void setage( int a ) { age=a; } void showage( ) { printf( "age = %d\\n",age ); } }; ในตอนนี้ ทุกสมาชิกของคลาสเป็น public หมด ลองดูอีกตัวอย่างหนึ่ง 1 class Person 2 { 3 public: 4 int age; 5 void setage( int a ) 6 { 7 age=a; 8 } 9 private: 10 void showage( ) 11 { 12 printf( "age = %d\\n",age ); 13 } 14 }; จากข้างต้น จะเห็นได้ว่าเราได้แทรก private ไว้ก่อนฟังก์ชั่น showage ผลก็คือ ตัวแปร age และฟังก์ชั่น setage จะเป็นแบบ public แต่ฟังก์ชั่น showage นั้นจะกลายเป็นแบบ private ไปเลย เพราะหลังจากที่ได้ประกาศ public ตรงบรรทัดที่ 3 แล้ว ความเป็น public นั้นก็จะลามไปเรื่อย ๆ ไปตามบรรทัดที่ 4,5,6 .. จนถึงบรรทัดที่ 8 พอมาบรรทัดที่ 9 ก็มี private ดักเอาไว้ก่อน และจาก private นี้ ตัวแปรหรือฟังก์ชั่นใดที่ประกาศเอาไว้ตั้งแต่บรรทัดที่ 10 ไปจนจบคลาสก็จะกลายเป็น private ทั้งหมดทันที คราวนี้ก็มาถึงคำถามที่มีการถามกันมากมายว่า "ทำไมการใช้งานคลาสไม่เหมือนกับ struct ทำไมจะต้องมี private หรือ public ด้วย ? " คำตอบก็คือ ตัวแปรแบบโครงสร้าง (struct) นั้นต่างจากคลาส (class) ก็ตรงที่ ภายในโครงสร้างจะมีเฉพาะตัวแปรเท่านั้น แต่ในการสร้างคลาส มีได้ทั้งตัวแปรและทั้งฟังก์ชั่น ดังนั้น คลาสจึงมีประสิทธิภาพมากกว่าฟังก์ชั่น การเข้าถึงข้อมูลสมาชิกในคลาส ถ้าไม่มีการควบคุมโดยกำหนดขอบเขตให้เป็น public หรือ private ล่ะก็ เมื่อนำคลาสไปใช้งานก็จะทำให้เกิดความซับซ้อนมากขึ้น ลองพิจารณาดูนะครับว่า ถ้าเราออกแบบคลาส ให้ทุก ๆ สมาชิกในคลาสเป็น public ทั้งหมด จะเกิดอะไรขึ้น ดังนี้ class Circle { public: double pi; double r; void setr(double temp) { pi=3.14; r=temp ; } double getarea() { return pi*r*r; } }; จากตัวอย่าง คลาสนี้เป็นคลาสวงกลม ซึ่งใช้ในการเก็บค่ารัศมีของวัตถุวงกลม เราจะเรียกฟังก์ชั่น setr เพื่อกำหนดค่ารัศมี และฟังก์ชั่น getarea ก็ใช้ในการหาค่าพื้นที่ของวงกลม ในการเรียกใช้งานคลาส ให้สร้างอ็อบเจ็กต์ของคลาส Circle ชื่อ c1 ก่อนดังนี้ Circle c1; c1.setr(20.0); printf("area = %f ",c1.getarea() ); จากนั้นใช้ c1 เรียกฟังก์ชั่น setr เพื่อส่งค่า 20 ไปให้เป็นค่ารัศมี โดยให้เก็บลงตัวแปร r ที่อยู่ในคลาส และค่า pi ก็จะถูกกำหนดให้เป็น 3.14 ในตอนนี้ หลังจากนั้นก็เรียก getarea เพื่อคืนค่าพื้นที่โดยได้มาจากการคำนวณโดยใช้ 3.14 คูณค่ารัศมียกกำลังสอง ซึ่งก็คือพื้นที่ของวงกลมนั่นเอง คราวนี้ลองพิจารณาต่อไปนะครับ จะเห็นว่าในคลาสนี้ สมาชิกทุก ๆ ตัวเป็น public ทั้งหมด ซึ่งก็ไม่ผิดอะไร แต่ถ้าเกิดมีการเข้าไปแก้ไขตัวแปรที่อยู่ภายในคลาสโดยตรงล่ะ ดังนี้ Circle c1; c1.setr(20.0); c1.pi = 2.14; printf("area = %f ",c1.getarea() ); จะเห็นได้ว่า ตัวแปร pi เป็นตัวแปรที่เก็บค่า 3.14 ตามสูตรของการหาพื้นที่วงกลม แต่ตอนนี้ถูกแก้ไขให้เป็นค่าอื่นโดยกระบวนการภายนอกคลาส ซึ่งจริง ๆ แล้ว ในการออกแบบคลาส น่าจะมีการปกป้องตัวแปรตัวนี้เอาไว้ ไม่ให้เข้ามาแก้ไขได้ เพราะค่าในตัวแปร pi นี้เป็นค่าที่ใช้งานอยู่ภายในคลาส เพื่อให้ค่าคำนวณหาค่าพื่นที่ได้ถูกต้องตามสูตร แต่กลับถูกแก้ไขได้ ถ้าเราออกแบบคลาสใหญ่ ๆ ที่มีการทำงานที่ซับซ้อนมาก ๆ ตัวแปรและฟังก์ชั่นภายในคลาสย่อมมีมากขึ้น และบางตัวเรียกใช้แค่ภายในคลาสเท่านั้น ดังนั้น จึงมีการกำหนดระดับในการเข้าถึงข้อมูลภายในคลาสขึ้นให้เป็นแบบ public และ private โดยตัวแปรหรือฟังก์ชั่นใด ที่ไม่ต้องการให้ถูกเรียกใช้จากอ็อบเจ็กต์ ก็ให้เป็นแบบ private ซะ ตัวแปรและฟังก์ชั่นใดที่จะเป็นช่องทางในการเรียกใช้งานคลาส ก็ให้เป็นแบบ public นั่นเอง ลองดูนะครับว่า คลาส Circle นั้น ถ้าเราปรับแต่งแก้ไขโดยใส่ private และ public ลงไปจะได้ดังนี้ class Circle { double pi; double r; public: void setr(double temp) { pi=3.14; r=temp ; } double getarea() { return pi*r*r; } }; คลาส Circle จะสมบูรณ์และพร้อมใช้งานมากขึ้น โดยจะมีฟังก์ชั่นให้เรียกใช้งานโดยตรง คือ setr และ getarea สองฟังก์ชั่นนี้ อ็อบเจ็กต์ของคลาสจะเรียกใช้ได้โดยตรง โดยไม่ต้องไปยุ่งกับตัวแปร pi และ r เลย ตัวแปรนี้ก็จะปลอดภัย ปลอดจากการถูกเรียกใช้จากกระบวนการภายนอกคลาสนั่นเอง ดังนั้น ในการออกแบบคลาส เราจะต้องคำนึงถึงตรงนี้ด้วยว่าจะให้สมาชิกตัวใดเป็นแบบ private หรือแบบ public โดยมากแล้วเราจะให้ตัวแปรเป็นแบบ private และให้ฟังก์ชั่นเป็นแบบ public เพื่อออกมาเป็นช่องทางที่คอยให้บริการนั่นเอง และนี่ก็คือคำตอบของคำถามที่ว่า "ทำไมคลาสจะต้องมี public และ private"   Create Date : 28 ธันวาคม 2549     Last Update : 28 ธันวาคม 2549 18:29:14 น.     Counter : 1507 Pageviews.   Share to Facebook Tweet

บทที่ 3 Class and Object บทที่ 3 Class and Object หลังจากที่เราได้ศึกษาแนวคิดของ OOP และความรู้เบื้องต้นกันไปแล้ว บทนี้เราจะมาศึกษากันถึงวิธีการเขียนโปรแกรมด้วยภาษา C++ กันว่ามีวิธีการเขียนและกฏเกณฑ์อย่างไร และเมื่อเราศึกษาถึงกฏเกณฑ์และวิธีการแล้ว เราก็จะมาศึกษาถึงวิธีการออกแบบคลาสกัน ซึ่งจำเป็นมาก เพราะถ้าเรารู้จักวิธีการเขียนคลาส แต่เราไม่รู้จักวิธีการที่จะนำคลาสเข้ามาใช้แก้ไขปัญหา ก็คงจะเสียเวลาในการศึกษาไปเปล่า เพราะฉะนั้น บทที่ 3 นี้จึงเป็นพื้นฐานสำคัญที่ท่านควรทำความเข้าใจในเทคนิคและวิธีการสร้างคลาส และการสร้างอ็อบเจ็กต์ของคลาส การสร้างคลาสใน C++ การสร้างคลาสใน C++ เราจะเขียนคล้าย ๆ กับการประกาศตัวแปรแบบโครงสร้าง ดังที่ได้ศึกษามาบ้างแล้วในบทที่ผ่านมา คลาสจะเป็นโครงสร้างที่รวมการทำงานทั้งหมดเข้าด้วยกัน ให้เป็นวัตถุก้อนเดียวกัน ดูตัวอย่างโปรแกรม EASY.CPP ต่อไปนี้ EASY.CPP #include class Person { int age; void setage( int a ) { age=a; } void showage( ) { printf( "age = %d\\n",age ); } }; void main( ) { Person p; } โปรแกรม EASY.CPP ในข้างต้น มีการประกาศคลาส Person เอาไว้ ภายในคลาสมีสมาชิกดังนี้ 1. ตัวแปร age 2. ฟังก์ชั่น setage( int a ) 3. ฟังก์ชั่น showage( ) คลาส Person ที่ยกตัวอย่างมานี้ แสดงให้เห็นถึงการจัดเก็บข้อมูล ก็คือ อายุ และมีฟังก์ชั่น setage ที่ใช้ในการกำหนดค่าอายุโดยรับพารามิเตอร์จากภายนอก และมีฟังก์ชั่น showage ที่ใช้ในการแสดงค่าอายุออกมาทางจอภาพโดยฟังก์ชั่น printf และในฟังก์ชั่น main( ) ก็ได้มีการประกาศอ็อบเจ็กต์ของคลาส Person นี้ชื่อว่า p เอาไว้ จากนั้นก็จบโปรแกรม โปรแกรมนี้เป็นตัวอย่างที่แสดงให้เห็นถึงการประกาศคลาส ซึ่งมีรูปแบบดังนี้ class ชื่อคลาส { ประกาศตัวแปร ประกาศฟังก์ชั่น } ในคลาส ๆ หนึ่งจะมีแค่การสร้างตัวแปรหรือฟังก์ชั่นเพียงอย่างเดียวก็ได้ หรือเขียนแค่คลาสเฉย ๆ มีแค่ { .} ไม่ต้องมีตัวแปรหรือฟังก์ชั่นไว้เลยก็ได้ ดังตัวอย่างต่อไปนี้ class Person { }; จากตัวอย่าง คลาสที่ชื่อว่า Person จะถูกสร้างขึ้น และเราสามารถสร้างอ็อบเจ็กต์ของคลาสนี้ได้ตามปกติ แต่จะไม่สามารถนําไปใช้งานอะไรได้เลยเพราะว่าไม่มีตัวแปรหรือฟังก์ชั่นใด ๆ ในคลาสให้เรียกใช้นั่นเอง... เอาล่ะครับ จากโปรแกรม Easy.cpp ในข้างต้นนั้น เราจะมาทำความเข้าใจกันดังนี้ class Person { int age; void setage( int a ) { age=a; } void showage( ) { printf( "age = %d\\n",age ); } }; ในคลาส Person มีตัวแปร age ตัวหนึ่ง และมีฟังก์ชั่น setage ฟังก์ชั่นนี้รับค่าพารามิเตอร์ 1 ตัว คือ int a และเมื่อรับเข้ามาแล้ว ก็จะทำการกำหนดให้กับตัวแปร age ที่อยู่ภายในคลาส และอีกฟังก์ชั่นหนึ่งก็คือ ฟังก์ชั่น showage ซึ่งเป็นฟังก์ชั่นที่ใช้ในการแสดงค่า age ออกทางจอภาพ จะเห็นได้ว่าการทำงานจะอยู่ภายในคลาสเท่านั้น จบแค่ภายในคลาส เมื่อเราประกาศอ็อบเจ็กต์ของคลาสดังนี้ Person p; ก็เท่ากับว่า ตอนนี้คลาส Person มีทายาทแล้ว นั่นก็คือ อ็อบเจ็กต์ p นั่นเอง และ p นี้ก็มีคุณลักษณะทุกอย่างเช่นเดียวกับคลาส Person นี้เลย นั่นก็คือ p สามารถเรียกใช้ตัวแปร a , ฟังก์ชั่น setage และ showage ได้ คราวนี้ ให้เราแก้ไขโปรแกรม Easy.cpp ให้เป็นดังนี้ void main( ) { Person p; p.setage( 25 ); p.showage( ); } จากข้างต้น เป็นการสั่งให้ p เรียกฟังก์ชั่น setage โดยใส่พารามิเตอร์ 25 ให้กับฟังก์ชั่น เป็นการเรียกฟังก์ชั่นที่อยู่ในคลาส Person เอง จากนั้นก็เรียกฟังก์ชั่น showage ตามลำดับ เพื่อแสดงค่าอายุในตัวแปร age ออกมา ปัญหานั้นก็คือ เมื่อเราแปลโปรแกรมนี้โดยใช้ตัวแปรภาษา C++ ใด ๆ ท่านจะพบกับข้อความผิดพลาดลักษณะนี้ (การทดสอบของตัวอย่างในหนังสือเล่มนี้จะใช้ Visual C++ ในการทดสอบ) \'setage\' : cannot access private member declared in class \'Person\' \'showage\' : cannot access private member declared in class \'Person\' จากข้อความที่ปรากฏในข้างต้น แปลแล้วได้ความว่า ฟังก์ชั่น setage และฟังก์ชั่น showage ไม่สามารถเรียกใช้ได้ ข้อความผิดพลาดจะฟ้องออกมาในบรรทัดนี้ p.setage( 25 ); p.showage( ); ที่เป็นเช่นนี้ก็เพราะว่ากฏของ OOP ข้อหนึ่งก็คือ คลาสจะมีการปกป้องข้อมูลไม่ให้กระบวนการภายนอกคลาสใด ๆ เข้าถึงสมาชิกในคลาสได้เลย เมื่อเราประกาศอ็อบเจ็กต์ p ซึ่งอ็อบเจ็กต์นี้เป็นตัวแปรที่อยู่ภายนอกคลาส ดังนั้น p จึงไม่สามารถเข้าถึงตัวแปร age และฟังก์ชั่น setage กับ showage ได้ อันนี้เป็นคุณสมบัติของ OOP ที่ช่วยให้สมาชิกภายในคลาสไม่ถูกก่อกวน ทำให้คลาสมีคุณสมบัติปกป้องข้อมูลหรือ Encapsulation ได้นั่นเอง เห็นมั้ยครับ นี่ก็คือ สิ่งที่แตกต่างออกไปจากตัวแปรแบบโครงสร้างที่เห็นได้ชัด ๆ อย่างแรก ถ้าเราจะทำให้อ็อบเจ็กต์ p สามารถเรียกใช้สมาชิกในคลาสได้ ผู้เขียนโปรแกรมจะต้องอนุญาติให้สมาชิกในคลาสตัวที่ต้องการ มีคุณสมบัติเป็น "สาธารณะ" หรือ public เสียก่อน แบบนี้ class Person { int age; public: void setage( int a ) { age=a; } void showage( ) { printf( "age = %d\\n",age ); } }; void main( ) { Person p; p.setage( 25 ); p.showage( ); } จากข้างต้น ในตอนนี้ฟังก์ชั่นทั้งสองในคลาสได้กลายเป็น public แล้ว ดังนั้น จึงสามารถเรียกใช้ p.setage และ p.showage ได้อย่างสมบูรณ์   Create Date : 28 ธันวาคม 2549     Last Update : 28 ธันวาคม 2549 18:28:16 น.     Counter : 889 Pageviews.   Share to Facebook Tweet

บทที่ 2 ธรรมชาติของวัตถุ และทฤษฎีของ OOP 4 บทที่ 2 ธรรมชาติของวัตถุ และทฤษฎีของ OOP OOP กับการออกแบบโปรแกรม ในการเขียนโปรแกรมคอมพิวเตอร์ก็เช่นกัน เราจะต้องมองสิ่งที่อยู่ในโปรแกรมของเราให้เป็นเชิงวัตถุเพื่อที่จะได้ออกแบบวิธีการเก็บและจัดการข้อมูลที่เป็นอิสระต่อกันได้ เราอาจจะต้องใช้เวลาสักระยะหนึ่งในการฝึกฝนและเก็บเกี่ยวประสบการณ์ในการเขียนโปรแกรมแบบ OOP ด้วยภาษา C++ จนกระทั่งเข้าใจในระดับวิเคราะห์ปัญหาและนำเอา OOP ไปใช้แก้ไขปัญหาได้ แต่ก่อนที่จะเข้าสู่การเขียนโปรแกรมแบบ OOP ในภาษา C++ นั้น ผู้อ่านที่เคยศึกษาภาษา C มาแล้วล้วนแล้วแต่เคยศึกษาในเรื่องของตัวแปรแบบโครงสร้าง (Structure) ด้วยกันทั้งนั้น การประกาศตัวแปรแบบโครงสร้างนี้ เป็นแนวคิดพื้นฐานที่สามารถต่อยอดมาศึกษาในเรื่องของ OOP ใน C++ ได้เป็นอย่างดี ลักษณะการทำงานของตัวแปรแบบโครงสร้างจะช่วยแก้ไขปัญหาในเรื่องของความซับซ้อนของตัวแปรได้ เพราะเป็นการเปลี่ยนวิธีการเขียนโปรแกรมโดยอาศัยชุดของข้อมูลเป็นหลัก เราจะมาทบทวนเรื่องของตัวแปรโครงสร้างกันสักเล็กน้อย เพื่อให้เข้าใจไปในทางเดียวกัน ถ้าท่านยังไม่เคยศึกษาเรื่องของตัวแปรแบบโครงสร้างมาก่อน ผู้เขียนขอแนะนำให้ท่านศึกษาจากคู่มือการเขียนโปรแกรมภาษา C หรือศึกษาไปพร้อมกับการทบทวนในบทนี้ก็ได้ เพราะจุดประสงค์ของการทบทวนก็เพื่อให้มองเห็นถึงแนวคิดและเหตุผลของการนำเอาตัวแปรแบบโครงสร้างมาใช้ในการแก้ไขปัญหาการเขียนโปรแกรมที่มีข้อมูลปริมาณมาก ๆ ถ้าท่านเข้าใจในจุดนี้แล้ว เราก็จะลุยศึกษาภาษา C++ ไปพร้อมกันได้อย่างคล่องตัวเลยทีเดียว เราจะยกตัวอย่างปัญหาในการเก็บข้อมูลของคน 5 คน ดังรูป จากรูป สมมติว่าเราจะต้องเขียนโปรแกรมให้เก็บข้อมูลของพวกเขาเหล่านั้นเอาไว้ ถ้าเราใช้การเขียนโปรแกรมภาษา C ธรรมดา ๆ เราจะเขียนได้อย่างไร.?? คำตอบก็คือ ใช้อะเรย์แบบ 1 มิติใช่มั้ยครับ โดยการประกาศตัวแปรตามสิ่งที่เราต้องการจะเก็บ คือ อายุ, ส่วนสูง, น้ำหนัก จำนวน 5 คนดังนี้ int age[5]; int height[5]; int weight[5]; ถ้าเราจะนำเอาข้อมูลมาใส่ลงในตัวแปร age , height และ weight นั้น เราก็จะอาศัยลำดับในอะเรย์เข้ามาช่วย นั่นคือ คนที่ 1 ก็จะเก็บลงไปในอะเรย์ช่องที่ 0 ในทุกตัวแปร ดังนี้ age[0] = 25; height[0] = 170; weight[0] = 68; สำหรับคนที่ 2 ก็จะเก็บลงไปในอะเรย์ช่องที่ 1 ของทุกตัวแปร เช่นกัน ดังนี้ age[1] = 30; height[1] = 165; weight[1] = 70; สำหรับคนที่ 3 , 4 และ 5 ก็จะเก็บลงไปในอะเรย์ช่องที่ 2,3 และ 4 ของทุก ๆ ตัวแปรตามลำดับเช่นกัน จากตัวอย่างนี้ เราจะสรุปได้ว่า การใช้อะเรย์ในการเก็บข้อมูลที่มีจำนวนมาก ๆ และมีตัวแปรหลาย ๆ ตัวค่อนข้างจะยุ่งยากพอสมควร เพราะเราใช้ลำดับของอะเรย์เป็นตัวกำหนดลำดับการเก็บข้อมูล ถ้าเราต้องการเรียกดูข้อมูลของคนที่ 1 เราก็จะต้องแสดงข้อมูลที่อยู่ในช่องที่ 0 ของอะเรย์ทุกตัวออกมา รูปแบบของการเก็บข้อมูลในลักษณะนี้ เป็นดังรูป จะเห็นว่า อะเรย์ 1 ตัวที่เก็บอายุ ก็จะเก็บอายุทุก ๆ ช่อง ตัวแปรที่เก็บส่วนสูง ก็จะเก็บแต่ส่วนสูงทั้งหมด วิธีการลักษณะนี้เสี่ยงต่อการผิดพลาดอย่างมากในเรื่องของลำดับ เพราะตัวแปรแต่ละตัวมีความอิสระต่อกัน การอ้างลำดับผิดในกรณีที่มีปริมาณข้อมูลมาก ๆ เช่น เก็บข้อมูลเป็นร้อย ๆ ข้อมูลขึ้นไป การไล่ลำดับจะต้องไล่ให้ตรงกัน ซึ่งจากปัญหาที่ได้กล่าวไปนี้ เราจะต้องใช้ตัวแปรแบบโครงสร้างมาช่วยแก้ไขปัญหา การใช้งานตัวแปรโครงสร้างนี้ จะคล้าย ๆ กับการที่เราสร้างตัวแปรชนิดใหม่ขึ้นมาเป็นของเราเอง โดยพิจารณาจากข้อมูลที่เราต้องการจัดเก็บ รูปแบบของการเก็บข้อมูลแสดงได้ดังรูป การประกาศตัวแปรโครงสร้าง เราจะใช้คำสั่ง typedef struct ดังนี้ typedef struct _person { int age; int height; int weight; }person; จากข้างต้น เป็นการสร้างตัวแปรแบบโครงสร้างชนิดใหม่ขึ้นมา ชื่อว่า person เราจะถือว่าเป็นการสร้างตัวแปรแบบใหม่ และตัวแปรนี้สามารถเก็บค่าได้ 3 ค่า คือ อายุ (age) , น้ำหนัก (Weight) และส่วนสูง (Height) เมื่อเราประกาศตัวแปรแบบใหม่นี้เอาไว้ในโปรแกรมของเราแล้ว เราก็สามารถสร้างตัวแปรแบบ person นี้ได้ทันที โดยเขียนโค้ดดังนี้ person p1,p2,p3,p4; ตอนนี้ เราได้ตัวแปร p1,p2,p3 และ p4 เป็นตัวแปรแบบ person แล้ว ก่อนที่จะศึกษาในส่วนต่อไป ขอให้หยุดพิจารณานิดหนึ่ง ถ้าท่านยังไม่เข้าใจในเรื่องของตัวแปรโครงสร้าง จุดที่น่าสังเกตของการประกาศตัวแปรแบบโครงสร้าง ที่ท่านควรทำตวามเข้าใจให้ดีก็คือ มันเหมือนกับการสร้างตัวแปรชนิดใหม่ขึ้นมาในโปรแกรมของเราเอง โดยปกติแล้ว เวลาเราประกาศตัวแปร เราก็จะต้องประกาศโดยระบุว่าตัวแปรนั้นเป็นตัวแปรชนิดไหน เช่น int a, int b เป็นต้น ซึ่งประเภทของตัวแปรเหล่านี้ ไม่ว่าจะเป็น int , float ,char ฯลฯ นั้น ภาษา C ได้มีการกำหนดเอาไว้เป็นมาตรฐานอยู่แล้ว สำหรับตัวอย่างนี้ก็เช่นกัน คือ เมื่อเราได้สร้างตัวแปรโครงสร้างชนิดใหม่ขึ้นมาแล้ว โดยชื่อว่า person เราก็สามารถที่จะสร้างตัวแปรแบบ person ขึ้นมาได้ และตัวแปรที่ถูกสร้างขึ้นมานี้ จะมีคุณลักษณะความเป็นตัวแปรแบบ person ทุกอย่าง คือ ภายในตัวมันเอง สามารถเก็บค่าย่อย ๆ ได้อีก 3 ค่า ดังรูป ลักษณะของตัวแปรแบบโครงสร้างนี้ จะจัดเก็บข้อมูลเป็นหมวดหมู่ และแบ่งแยกชัดเจนมากขึ้นอย่างเห็นได้ชัดว่า age , height และ weight ก็เป็นของคน ๆ นั้นเลย เพราะฉะนั้นมันจะไม่ปะปนกันคือ age ของ p1 จะเป็นของ p1 โดยเฉพาะ อาจจะไม่เท่ากับ age ของ p2 ก็ได้ เพราะฉะนั้นด้วยหลักการของโครงสร้างนี้ เมื่อเรานำมาใช้ในการเก็บข้อมูลอายุ, น้ำหนัก และส่วนสูงของคน 5 ตนดังที่ได้ยกตัวอย่างไว้ในข้างต้น ถ้าเขียนด้วยโค้ดภาษาซี ก็จะเขียนลักษณะนี้ typedef struct _person { int age; int height; int weight; }person; person p[5]; p[0].age=25; p[0].height=170; p[0].weight=68; p[1].age=30; p[1].height=165; p[1].weight=70; p[2].age=36; p[2].height=175; p[2].weight=65; p[3].age=40; p[3].height=168; p[3].weight=70; p[4].age=27; p[4].height=172; p[4].weight=69; จากตัวอย่าง จะเหมือนกับว่าเรามีตัวแปรทั้งหมด 15 ตัว และแต่ละตัวก็ถูกจัดหมวดหมู่แบ่งออกเป็นคน ๆ เป็นข้อมูลเฉพาะส่วน ๆ ไป เราสามารถเข้าถึงข้อมูลที่เป็นอายุของคนที่ต้องการได้โดยอ้างอิงลำดับของคน ๆ นั้นและตามด้วยชื่อตัวแปรที่เราต้องการ เช่น ต้องการอายุของนายมงคล ซึ่งอยู่ลำดับที่สอง ก็คือ p[1].age เป็นต้น จะเห็นได้ว่า วิธีการนี้ เป็นการเปลี่ยนแนวคิดและมุมมองจากอะเรย์ ให้มาเป็นแนวคิดที่คล้าย ๆ กับเชิงวัตถุเลย คือ เรามองแต่ละคน ๆ เป็นวัตถุมากขึ้น 1 คน ก็จะมีอายุ , น้ำหนัก และส่วนสูง หรือมีข้อมูลมากกว่านี้ใน 1 โครงสร้าง ทำให้การจัดการข้อมูลทำได้ง่ายกว่าการใช้อะเรย์แบบในวิธีแรกที่ได้นำเสนอไป   Create Date : 28 ธันวาคม 2549     Last Update : 28 ธันวาคม 2549 18:38:34 น.     Counter : 541 Pageviews.   Share to Facebook Tweet

บทที่ 2 ธรรมชาติของวัตถุ และทฤษฎีของ OOP 3 บทที่ 2 ธรรมชาติของวัตถุ และทฤษฎีของ OOP OOP ในระบบปฏิบัติการ ดังที่ได้อธิบายไปแล้วว่า ระบบปฏิบัติการวินโดวส์ เป็นระบบปฏิบัติการที่ออกแบบภายใต้การทำงานของ OOP . จริงหรือไม่? ท่านก็ลองนำเอาแนวคิดของ OOP มาจับดู โดยพิจารณาว่าวินโดวส์ก็คือโลก ๆ นึ่ง ในระบบปฏิบัติการวินโดวส์ ทุก ๆ อย่างล้วนแล้วแต่มีคุณลักษณะ และการกระทำของมันเองด้วยกันทั้งนั้น เราลองยกตัวอย่างหน้าต่าง (Window) ดังรูป จะเห็นได้ว่า หน้าต่างนี้ เป็นหน้าต่างธรรมดา ๆ ถ้ามองให้เป็นเชิงวัตถุ ก็คือ จะมีคุณลักษณะ และการกระทำของมัน ดังนี้ คุณลักษณะของหน้าต่าง 1. มีไตเติ้ลบาร์ และมีข้อความบอกชื่อของหน้าต่าง 2. มีปุ่มยุบ (Minimize) , ปุ่มขยาย (Maximize) และปุ่มปิด (Close) 3. มีเมนูบาร์ การกระทำกับหน้าต่าง 1. สามารถยุบเป็นไอคอนได้ 2. สามารถขยายเต็มจอ (Maximize) และคืนกลับได้ (Restore) 3. สามารถกดปิดหน้าต่างได้ 4. สามารถปรับขนาด (Resize) และย้ายตำแหน่งได้ (Remove) ถ้าหน้าต่างคือคลาส ๆ หนึ่ง การสร้างหน้าต่าง 1 อัน ก็คือ สร้างอ็อบเจ็กต์ 1 อ็อบเจ็กต์ ถ้าเราเปิดหน้าต่าง 2 อัน ก็คือ สร้าง 2 อ็อบเจ็กต์ เพราะฉะนั้น ทุก ๆ หน้าต่างที่ปรากฏออกมา มันจึงมีคุณลักษณะ และการกระทำที่เหมือน ๆ กัน คือ ยุบได้ ขยายได้ ปิดได้ มีไตเติ้ลบาร์ มีเมนูบาร์เหมือนกัน เพราะฉะนั้น ถ้าในหน้าจอวินโดวส์เรามี 20 หน้าต่าง ก็หมายความว่า ทั้ง 20 หน้าต่างนี้ ก็จะมีการใช้งานหรือมีหน้าตามที่เหมือน ๆ กันหมดนั่นเอง นอกจากนี้ ในแต่ละอ็อบเจ็กต์ มันสามารถมีสถานะที่ต่างกันได้ เช่น เราเปิดหน้าต่างมา 3 หน้าต่างในวินโดวส์ เราสามารถปรับขนาดของหน้าต่างแต่ละอันไม่ให้เท่ากันได้ เพราะฉะนั้น แต่ละอ็อบเจ็กต์ ก็จะมีค่าที่เป็นของมันเอง ไม่ใช่ค่าเดียวกัน เช่นกัน ถ้าเราย้อนกลับมาพิจารณาถึงคลาสดินสอ ถ้าเรามีดินสออยู่ 3 แท่ง ก็ไม่จำเป็นว่าทุก ๆ แท่งจะต้องมีขนาดความยาวที่เท่ากัน ไม่จำเป็นที่จะต้องมีสีเดียวกันเสมอไป และดินสอแต่ละแท่ง แท่งหนึ่งอาจจะกำลังวาดรูปวงกลมอยู่ แต่อีก 2 แท่งอาจจะกำลังวาดรูปสี่เหลี่ยม และวาดรูปสามเหลี่ยมอยู่ก็ได้ ไม่จำเป็นว่าดินสอแต่ละแท่งจะต้องวาดเหมือนกัน แต่ละอ็อบเจ็กต์ล้วนแล้วแต่มีความเป็นอิสระต่อกัน ระบบปฏิบัติการวินโดวส์ และระบบปฏิบัติการรุ่นใหม่ ๆ ไม่ว่าจะเป็น แมคโอเอส , ลีนุกซ์ ฯลฯ ล้วนแล้วแต่มีรูปแบบการทำงานที่เป็นแบบวัตถุลักษณะนี้เช่นกัน เพื่อที่จะให้สามารถทำงานได้มากกว่า 1 งานในเวลาเดียวกันนั่นเอง ถ้าท่านเคยใช้ดอสมาก่อน ท่านจะทราบได้ว่า การใช้ดอสนั้น จะต้องทำงานทีละอย่าง เช่น จะฟังเพลง ก็จะต้องฟังอย่างเดียว หรือจะพิมพ์งานก็จะต้องพิมพ์ด้วยโปรแกรมเวิร์ดจุฬาอย่างเดียว ไม่สามารถพิมพ์งานไป ฟังเพลงไปได้ จะฟังได้ก็จะต้องเปิดวิทยุเทปคาสเซ็ทเอาเอง แต่ในปัจจุบัน ระบบปฏิบัติการได้หันมาพัฒนาในแบบของเชิงวัตถุ ทำให้โปรแกรมต่าง ๆ มีรากฐานที่เหมือน ๆ กันในระบบปฏิบัติการตัวนั้น ๆ ลองดูจากโปรแกรมต่าง ๆ ที่ทำงานอยู่บนวินโดวส์ เช่น NOTEPAD, เครื่องคิดเลข, เกมไพ่, โปรแกรม MS Word , โปรแกรม Flash และอื่น ๆ ฯลฯ ก็จะมีรูปแบบหน้าต่างที่คล้าย ๆ กันในเบื้องต้น คือ มีไตเติ้ลบาร์ มีเมนูต่าง ๆ มีปุ่มยุบ,ปุ่มขยาย และจะต่างกันที่หน้าตาการทำงานภายในของโปรแกรมนั่นเอง และเรายังสามารถเปิดโปรแกรมเดียวกันได้หลายครั้ง โดยที่การทำงานไม่วุ่นวาย หรือตีกัน เพราะถือว่าเป็นคนละอ็อบเจ็กต์ ซึ่งแต่ละอ็อบเจ็กต์เป็นอิสระต่อกันนั่นเอง จะเห็นว่าโปรแกรม NOTEPAD ในข้างต้นเป็นโปรแกรมเดียวกัน แต่เปิดสองหน้าต่าง ก็คือ มีอ็อบเจ็กต์ของ NOTEPAD 2 ตัว แต่ละตัวมีความเป็นอิสระต่อกัน หน้าต่างหนึ่งเราพิมพ์ข้อความว่า HELLO ลงไป ในขณะที่อีกหน้าต่างหนึ่งพิมพ์ข้อความว่า GOODBYE ลงไป ไม่จำเป็นจะต้องมีข้อความที่เหมือนกัน เห็นมั้ยครับ มันก็ตรงตามแนวคิดของ OOP ที่ได้ยกตัวอย่างเรื่องดินสอ 3 แท่งไปนั่นเอง แท่งหนึ่งวาดวงกลม แท่งหนึ่งวาดสี่เหลี่ยม และอีกแท่งหนึ่งวาดสามเหลี่ยมนั่นเอง ที่ได้อธิบายไปนี้ เป็นแนวคิดของ OOP ที่ถือว่าเป็นระบบการทำงานของระบบปฏิบัติการหลาย ๆ ตัวในปัจจุบัน ท่านผู้อ่านทดลองพิจารณาจากสิ่งรอบ ๆ ตัวที่ในแนวคิดของวัตถุเข้ามายังสภาพแวดล้อมของคอมพิวเตอร์ จากฮาร์ดแวร์ เข้ามาสู่ซอฟต์แวร์ และในหัวข้อต่อไป เราจะมาศึกษากันในมุมมองของการเขียนโปรแกรมคอมพิวเตอร์กัน   Create Date : 28 ธันวาคม 2549     Last Update : 28 ธันวาคม 2549 18:37:39 น.     Counter : 399 Pageviews.   Share to Facebook Tweet

บทที่ 2 ธรรมชาติของวัตถุ และทฤษฎีของ OOP 2 บทที่ 2 ธรรมชาติของวัตถุ และทฤษฎีของ OOP มาถึงบทที่ 2 เราจะมีทำความเข้าใจในเรื่องของแนวคิดพื้นฐานของ OOP จุดประสงค์ของบทนี้ก็คือ ทำความเข้าใจร่วมกันในเรื่องของแนวคิด ซึ่งเป็นนามธรรมบวกกับรูปธรรมที่ท่านสามารถพบเห็นได้รอบ ๆ ตัวท่าน ผู้เขียนขอให้นิยามในเรื่องของ OOP ว่าเป็น "ธรรมชาติของวัตถุ" เรามาทำความเข้าใจกับแนวคิดนี้กันดังนี้ มองทุกอย่างให้เป็นวัตถุ ก่อนอื่น ขอให้ท่านมองสิ่งของรอบ ๆ ตัวท่านก่อน.... x ทุก ๆ สิ่งที่อยู่รอบ ๆ ตัวท่านก็คือ "วัตถุ" ซึ่งแต่ละชิ้นแต่ละอย่างต่างก็จะมีชื่อเรียก เช่น - โทรศัพท์ จะยี่ห้ออะไร แบบไหน เราเรียกวัตถุนี้ว่า โทรศัพท์ - แก้วน้ำ จะเป็นแก้วกระเบื้อง หรือแก้วพลาสติก มันก็คือแก้ว - กระดาษ จะเป็นเศษกระดาษ หรือ A4 มันก็คือ กระดาษ เห็นมั้ยครับ ทุก ๆ อย่างรอบตัวล้วนมีชื่อเรียกวัตถุด้วยกันทั้งนั้น เราสามารถจับต้องได้ ถ้าเราลองมองออกไปนอกบ้าน นอกถนน ทุก ๆ ลองมองในแบบเดียวกันสิครับ จะเห็นได้ว่า สิ่งที่เรามองเห็นนั้น มันก็คือ "วัตถุ" เช่น - คน ไม่ว่าจะเป็นอาชีพใด สูงต่ำดำขาว เราก็เรียกว่าคนด้วยกันทั้งหมด - รถ ไม่ว่ายี่ห้อใด แบบใด ประเภทใด เราก็เรียกว่ารถ เช่น รถยนต์ รถบรรทุก ฯลฯ - สุนัข ไม่ว่าจะพันธุ์อะไร พันธุ์ทาง บางแก้ว เราก็เรียกมันว่าสุนัข - ป้าย ก็เป็นวัตถุที่เราจับต้องได้ มีหลายประเภทป้าย เช่น ป้ายโฆษณา ป้ายชื่อ ป้ายจราจร - ถนน ก็เป็นวัตถุที่เราจับต้องได้ ไม่ว่าจะเป็นถนนคนเดิน ถนนรถวิ่ง ฯลฯ ดังนั้น ไม่ว่าจะเป็นสิ่งมีชีวิต หรือไม่มีชีวิต ใหญ่แค่ไหน หรือเล็กแค่ไหน มันก็คือ "วัตถุ" ด้วยกันทั้งนั้น ตรงจุดนี้ เราก็สามารถสรุปได้ว่า ในโลกนี้ ทุก ๆ อย่างล้วนแล้วแต่มี "ชื่อที่บอกว่าสิ่งนั้นคืออะไร หรือเป็นอะไร" ชื่อที่เราสมมติขึ้นมาเพื่อใช้เรียกวัตถุต่าง ๆ นั้นก็คือ "คลาส" (Class) นั่นเอง ถ้าเรามองสิ่งของรอบ ๆ ตัว ก็มีหลายคลาส เช่น - คลาสของโทรศัพท์ - คลาสของดินสอ - คลาสของยางลบ - คลาสของคอมพิวเตอร์ - คลาสของเมาส์ - คลาสของพัดลม สาเหตุที่เราจะต้องมีคลาส หรือมีชื่อที่เรียกวัตถุตามลักษณะของวัตถุนั้น ก็เพราะว่า ถ้าไม่มีชื่อที่ใช้เรียกล่ะก็ ในเวลาเราจะอ้างถึงสิ่ง ๆ นั้นก็จะทำได้ยาก ยกตัวอย่างเช่น ถ้าเราบอกว่า.. "นายเอก ช่วยหยิบสิ่งที่ยาว ๆ เป็นแท่ง ๆ มีใส้เป็นถ่านมาให้หน่อยซิ ระวังอย่างไปหยิบผิด ไปหยิบสิ่งที่เป็นก้อนกลม ๆ สีขาว ๆ มาล่ะ" ถ้าพูดแบบนี้ ใครจะไปหยิบถูก หยิบถูกก็ติ๊งต๊องแล้ว เพราะฉะนั้น ทุก ๆ สิ่งจึงจะต้องมีการสมมติชื่อกันขึ้นมา ชื่อนั้น ชื่อนี้ ตามลักษณะของมัน ที่ตั้งว่า "ยางลบ" แน่นอนมันก็คือยาง เอาไว้ลบ มันไม่ควรตั้งว่า "ลบยาง" แน่นอน เพราะฉะนั้น ถ้าเราพูดใหม่ก็จะเข้าใจได้ง่ายขึ้น ดังนี้ฃ "นายเอก ช่วยหยิบดินสอมาให้หน่อยสิ ระวังอย่าไปหยิบผิด ไปหยิบยางลบมาล่ะ" เพียงเท่านี้ นายเอกก็จะเข้าใจทันที เพราะนายเอกนั้นรู้ว่า "ดินสอ" มีลักษณะเป็นแท่ง ๆ มีใส้เป็นถ่านนั่นเอง เพราะฉะนั้นคำว่า "ดินสอ" จึงเป็นชื่อของคลาส และดินสอทุก ๆ แท่งที่มีอยู่ในโลกนี้ ก็คือ "อ็อบเจ็กต์ของคลาส" (Object) หรือ "วัตถุ (สิ่ง) ที่มีคุณลักษณะของคลาสนั้นครบถ้วน" นั่นเอง เราลองมาดูตัวอย่าง เพื่อความเข้าใจมากขึ้นกัน ลองพิจารณารูปต่อไปนี้ จากรูป จะเห็นได้ว่าเป็นวัตถุที่มีรูปร่างยาว ๆ เรียว ๆ มีใส้เป็นถ่าน ปลายด้านหนึ่งจะแหลม ๆ ใช้เขียนบนวัสดุรองรับ เช่น กระดาษได้ วัตถุชิ้นนี้เรียกว่า "ดินสอ" และในคลาสของวัตถุใด ๆ จะมีอยู่ 2 องค์ประกอบที่ใช้บอกถึงความเป็นวัตถุนั้น คือ 1. คุณลักษณะ (Attribute หรือ Properties) ก็คือ ลักษณะที่บอกถึงความเป็นสิ่ง ๆ นั้น 2. การกระทำ (Method หรือ Functions) ก็คือ มันทำอะไรได้บ้าง ยกตัวอย่างเช่น ดินสอ คุณลักษณะของมันก็คือ เรียว, ยาว, มีใส้เป็นถ่าน การกระทำของดินสอก็คือ เขียน, หัก, ปา, จิ้ม, แทง พูดง่าย ๆ ก็คือ ดินสอทำอะไรได้ และเราทำอะไรกับมันได้บ้าง เราสามารถใช้มันทำอะไรได้ตั้งแต่เขียน, ทิ่มแทง ไปจนถึงใช้ทัดหู ก็ขึ้นอยู่กับการนำไปใช้งานนั่นเอง เพราะฉะนั้น ถ้าเกิดเราไปพบวัตถุใด ที่มีคุณลักษณะตรงกันคุณลักษณะของดินสอ และยังมีการกระทำที่เหมือนกัน เราจะสรุปได้เลยว่า วัตถุสิ่งนั้นก็คือ "ดินสอ" นั่นเอง เราลองมาพิจารณารถยนต์ คุณลักษณะของรถยนต์ก็คือ 1. มีล้อ 4 ล้อ 2. มีที่นั่ง อย่างน้อย 1-2 ที่นั่ง 3. มีพวงมาลัย 4. มีเกียร์ สำหรับการกระทำ (Method) ของรถยนต์ก็คือ ขับเดินหน้าถอยหลัง เลี้ยวซ้าย เลี้ยวขวาได้ หยุดได้นั่นเอง จะเห็นได้ว่าทุก ๆ อย่างล้วนแล้วแต่ก็มีคุณลักษณะและการกระทำด้วยกันทั้งนั้น เมื่อเรามามองในโลกแห่งคอมพิวเตอร์ก็เช่นกัน ไม่ว่าจะเป็นอุปกรณ์คอมพิวเตอร์ก็เช่นกัน เมาส์ (Mouse) ก็เป็นวัตถุชิ้นหนึ่ง คุณลักษณะของเมาส์ก็คือ 1. เป็นอุปกรณ์ที่มีลูกกลิ้งอยู่ข้างใต้ 2. บนเมาส์มีปุ่มให้คลิก 2-3 ปุ่ม สำหรับการกระทำ (Method) ของเมาส์ก็คือ ใช้มือจับและเลื่อนไปมา เพื่อบังคับตัวชี้บนจอภาพ จะเห็นได้ว่า ไม่ว่าจะเป็นอุปกรณ์ใด ๆ ก็ตาม ล้วนแล้วสามารถมองในเชิงของวัตถุได้ทั้งนั้น ที่ได้กล่าวมาทั้งหมดนี้ เป็นแนวคิดของ OOP ในระดับเบื้องต้น คือ เรื่องแนวคิดของวัตถุ เพราะฉะนั้น ท่านผู้อ่านจะต้องลองมองภาพวัตถุต่าง ๆ รอบ ๆ ตัวในเชิงวัตถุ (Think in Object) ให้เข้าใจ จากนั้นเมื่อเรานำเอาแนวคิดนี้ มาเปรียบเทียบกับในระบบคอมพิวเตอร์ ในการเขียนโปรแกรมแล้ว เราก็จะมองเห็นภาพ และมองเห็นประโยชน์ของแนวคิดนี้ได้ชัดเจนมากขึ้น ดังนั้น เมื่อเมาส์เป็นคลาส ๆ หนึ่ง เมาส์ทุก ๆ ตัวที่อยู่ในโลก ในแนวคิดของ OOP จะเรียกว่า "อ็อบเจ็กต์ของคลาสเมาส์" เช่นกัน ถ้ารถยนต์ เป็นคลาส ๆ หนึ่งที่มีคำนิยามตามตัวอย่างในข้างต้น รถยนต์ทุก ๆ คันก็คือ "อ็อปเจ็กต์ของคลาสรถยนต์" นั่นเอง ดังนั้น เมื่อใดที่มีการนิยามคลาสหรือมีการกำหนดคลาสเอาไว้ให้กับวัตถุต่าง ๆ แล้ว เมื่อวัตถุนั้นเกิดหรือมีตัวตนขึ้นมา เราจึงเรียกมันว่าเป็นอ๊อปเจ็กต์ของคลาสนั่นเอง ขอยกตัวอย่าง เพื่ออธิบายเรื่องของคลาสและอ็อบเจ็กต์อีกสักนิดหนึ่ง สมมติว่าท่านผู้อ่านสร้างโลกขึ้นมาหนึ่งใบ มีแต่โลกเปล่า ๆ เป็นดาวดวงหนึ่ง ยังไม่มีสิ่งใด ๆ เกิดขึ้นมาเลย แต่ได้มีการกำหนดคุณลักษณะหรือนิยามคลาสของคนเอาไว้ว่า ถ้าวัตถุใดมี 2 แขน 2 ขา มีหัว ยืนได้ เดินได้ นั่งได้ และนอนได้ ให้เรียกวัตถุอันนั้นว่า "คน" นะ เวลาผ่านไป 100 ปี มีสิ่ง ๆ หนึ่งเกิดขึ้นในโลกเปล่า ๆ ของท่าน สิ่ง ๆ นั้นมี 2 แขน 2 ขา มีหัว ยืนได้ เดินได้ นั่งได้ และนอนได้ ท่านผู้อ่านซึ่งเป็นผู้กำหนดนิยามคลาสของคนขึ้นมา ก็จะบอกได้ว่า สิ่งที่เกิดขึ้นมานี้ คือ "อ็อบเจ็กต์ของคลาสคน" นั่นเอง ดังนั้นเวลาผ่านไปอีก มีเจ้าสิ่งที่เรียกว่าอ็อบเจ็กต์ของคนมากขึ้น เป็นพัน ๆ เป็นหมื่น ๆ เต็มไปหมด ทั้งหมดนั่นล่ะ เราเรียกว่า "อ็อบเจ็กต์" ของคลาสคน และนี่ก็คือ ความหมายและธรรมชาติของ Object   Create Date : 28 ธันวาคม 2549     Last Update : 28 ธันวาคม 2549 18:36:03 น.     Counter : 644 Pageviews.   Share to Facebook Tweet