Object oriented programming
(โดยใช้ syntax แบบ C++)
OOP คือการมองทุกอย่างให้เป็น object ซึ่งแบ่งได้เป็น
1. Object ที่เป็น รูปธรรม เช่น คน,ใบรายการสินค้า
2. Object ที่เป็น นามธรรม เช่น ความเป็นเจ้าของ,เที่ยวบิน เป็นต้น
ทุก object จะประกอบด้วย 2 ส่วนคือ
1. Attribute (object data) – เป็นส่วนที่ใช้ในการเก็บข้อมูลต่างๆของ object เช่น รถ มี attribute คือ ยี่ห้อรถ,ชื่อรุ่น,สี เป็นต้น
2. Method (object behavior) – เป็นสิ่งที่ object นั้นสามารถทำได้ เช่น รถ สามารถ เพิ่มความเร็ว,ชะลอความเร็ว,หยุด,เปลี่ยนเกียร์ เป็นต้น
หลักการสำคัญของ OOP
1. Data hiding คือ ปกปิด source code ส่วนหนึ่งไว้ไม่ให้ผู้ที่ไม่เกี่ยวข้องสามารถเข้าถึง หรือแก้ไขข้อมูลได้โดยตรง ซึ่งจะต้องบอกคำสงวนในการควมคุมการเข้าถึงข้อมูล
– Public สามารถเข้าถึงได้จากทุกๆที่ของโปรแกรม
– Private ไม่สามารถเข้าถึงได้จากภายนอก class ส่วนมากจะใช้กับ attribute ของ class
2. encapsulation นั่นคือ attribute ต่างๆภายใน class นั้นจะไม่สามารถถูกเปลี่ยนแปลงค่าได้จากภายนอก class การเปลี่ยนแปลงค่าของ attribute จะสามารถทำได้จากการเรียก method ภายใน class เท่านั้น ซึงคือการกำหนดด้วยคำสงวน private นั่นเอง
3. inheritance & reusable คือการ นำ source code ส่วนที่มีการใช้ซ้ำๆนำกลับมาใช้ใหม่
การนำกลับมาใช้ใหม่ แบ่งได้เป็น 2 กรณี
3.1 inheritance (การสืบทอดจากคลาสหลัก/ is-a relationship)
– superclass (base class/classหลัก)/subclass (derived class/classสืบทอด)
– superclass อาจเรียกได้ว่าเป็น classพ่อ
– subclass อาจเรียกได้ว่าเป็น class ลูก class ลูกจะมี attribute/method เพิ่มเติมจากclass พ่อ
สามารถเป็นได้ทั้ง single inheritance คลาสลูกมีคลาสพ่อเพียงคลาสเดียว และ multiple inheritance คลาสลูกมีคลาสพ่อหลายคลาส เช่น ในระบบของโรงพยาบาล
– คลาสพนักงาน จะประกอบด้วย attribute ชื่อ/รหัสประจำตัวพนักงาน
– คลาสหมอ จะประกอบด้วย ชื่อ/รหัสประจำตัวพนักงาน/สาขาที่เชียวชาญ
จะเห็นได้ว่ามีกานซ้ำซ้อนของการใช้ attribute ของ class ทั้ง 2 เนื่องจากคลาสพนักงานมีแต่ attribute ที่เหมือนกันกับ attribute ของ คลาสหมอ ดังนั้นเราสามารถทำให้ คลาสพนักงาน เป้น superclass ของ คลาสหมอได้
3.2 composition (has-a relationship) เป็นการนำ class ที่มีอยู่เดิมมาเป็น attribute ของ class ใหม่ เช่น คลาสรถยนต์ ประกอบด้วย คลาสเครื่องยนต์ คลาสตัวถัง คลาสล้อรถ
4. polymorphism ใช้ได้กับการสืบทอดแบบ is-a เท่านั้น คือการที่คลาสพ่อมี method ที่ภายในไม่มีการ implement ใดๆ เมื่อคลาสลูกสืบทอดคุณสมบัติไป คลาสลูกได้มีการเพิ่มส่วนของการ implement ใน method นั้น
*object ของคลาสที่มีคลาสพ่อคลาสเดียวกันทั้งๆที่เรียก method ชื่อเดียวกันกลับได้ผลลัพ์ที่แตกต่างกัน โดย obj ของคลาสก็จะดู method นี้ภายในคลาสของตนเท่านั้น
เช่น คลาสรูปภาพ มี method drawPicture ซึ่งเป็น functionที่ว่างเปล่าไว้ (เรียกว่าเป็น abstract function) เมื่อคลาสวงกลมมาสืบทอดต่อจากคลาสรูปภาพ method ที่ชื่อ drawPicture ได้เพิ่มส่วนของการ implement เป็นการวาดวงกลม และมีคลาสสี่เหลี่ยม สืบทอดต่อจากคลาสรูปภาพ แต่ method drawPicture ของคลาสสี่เหลี่ยม ได้เพิ่มส่วนของการ implement เป็นการวาดรูปสี่เหลี่ยมให้ เมื่อobj ของคลาสวงกลมมาเรียกใช้ method drawPicture จะได้รูปวงกลม ถ้าobj คลาสสี่เหลี่ยมมาเรียกใช้ method drawPicture จะได้รูปสี่เหลี่ยม
ความสัมพันธ์ระหว่างคลาส
1. association เป็นความสัมพันธ์แบบรู้จักกันเฉยๆ สามารถทำงานแยกกันได้อย่างอิสระ แต่ประกอบกันเพื่อให้ได้การทำงานที่สมบูรณ์ อาจรู้จักเพื่อให้เรียกใช้งาน method ที่มีในอีกคลาสได้ เช่น คลาสของพนักงานต้องรู้จักคลาสคำนวณยอดเงิน เพื่อที่จะสามารถใช้ method ที่เป็นการคำนวณเงินเดือนในคลาสคำนวณยอดเงินได้ เนื่องจากภายในคลาสพนักงานไม่มีส่วนของการคำนวณเงินเดือน และ คลาสคำนวณยอดเงินเป็นคลาสที่จะเก็บ method ที่ใช้ในการคำนวณเกี่ยวกับยอดเงินต่างๆภายในบริษัท
2. aggregation สัมพันธ์กันเชิงเป็นส่วนประกอบ
2.1 composition เป็นความสัมพันธ์ที่คลาส 1 หรือมากกว่า 1 เป็นส่วนประกอบย่อยของคลาสที่มีขนาดใหญ่กว่า และส่วนประกอบนี้ คลาสใหญ่ไม่สามารถขาดได้ เช่น คลาสรถ ต้องมี คลาสล้อ/คลาสเครื่องยนต์ เป็นต้นถ้าขาดสิ่งพวกนี้รถก็จะไม่สามารถเรียกได้ว่าเป็นรถ
2.2 contain เป็นความสัมพันธ์ที่คลาส 1 หรือมากกว่า 1 เป็นส่วนประกอบย่อยของคลาสที่มีขนาดใหญ่กว่า และส่วนประกอบนี้ คลาสใหญ่สามารถขาดได้ ขาดไปก็ไม่ส่งผลต่อคลาสนั้น เช่น คลาสรถ มีคลาสคนขับรถ อยู่เป็นส่วนประกอบด้วยแต่ถ้ารถขาดคนขับไป รถก็ยังสามารถเรียกได้ว่าเป็นรถอยู่
Interface และ implement
Interface คือส่วนที่ประกาศเป็น public สามารถเข้าถึงได้จากภายนอกคลาส เป็นส่วนที่เปิดให้รับรู้ว่าคลาสนี้ทำอะไรได้บ้าง ซึ่งไม่จำเป็นต้องรับรู้ว่าคลาสนี้ทำงานอย่าง 1 โดยใช้กระบวนการอะไร
Implement คือส่วนที่ประกาศเป็น private หรือ โค้ดต่างๆภายใน method ของคลาส เป็นส่วนที่ถูกซ่อนไว้ไม่สามารถเห็นได้จากภายนอกคลาส ถ้าเกิดมีการเปลี่ยนแปลง implement จะไม่มีผลกระทบต่อ user เพราะ user ติดต่อคลาสผ่าน interface เท่านั้น
เช่น เตาปิ้งขนมปัง เปิดให้ผู้คนรับรูว่าถ้าใส่ขนมปังลงในเตาปิ้งแล้วขนมปังจะถูกทำให้กรอบ ถือว่านี่เป็นส่วนของ interface คือทุกคนรับรู้ว่ามันทำอะไรได้ แต่การที่เตาปิ้งใช้วิธีการให้ความร้อนผ่านขดลวดแล้วส่งความร้อนไปยังขนามปังจนทำให้ขนมปังกรอบนั่นผู้ใช้เตาปิ้งขนมปังไม่จำเป็นต้องรับรู้ในส่วนนี้ ถือว่าวิธีกานที่ทำให้ขนมปังกรอบนี้เป็นส่วนของ implement
Class
เป็นแม่แบบของ object ก่อนที่จะสร้าง object ได้ก็ต้องมี class เสียก่อน object เป็น object ของ classใดก็จะมีคุณสมบัติ(attribute) และสามารถทำพฤติกรรม (method) ได้เหมือนที่ class มี
เช่น
Class number
{
Private value; Public number(){ };
Public void setValue(int v) { value = v};
Public void getValue() {return value};
}
Main program
{
number a;
ประกาศ object ชื่อ a เป็น type number a.setValue(10);
obj ‘a’ สามารถเรียกใช้ method ต่างๆที่มีใน class number ได้ a.getValue();
}
Constructor
เป็น method พิเศษในคลาสทีจะกำหนดค่าเริ่มต้นให้แก่ attribute ต่างๆภายในคลาส ข้อกำหนดของ constructor
1. เป็น method ที่ชื่อเดียวกับชื่อคลาส
2. ไม่มีการ return ค่าใดๆ
3. ประกาศการเข้าถึงเป็นแบบ public
แบ่งประเภทของ constructor เป็น
1. default constructor เป็น constructor ที่ไม่มีส่วนของ implement ภายใน
เช่น
Class number
{
Private value;
Public number(){ };
Public void setValue(int v) { value = v};
Public void getValue() {return value};
}
Main program
{
number a = new number(); สร้าง object แบบ dynamic โดยเรียกใช้ default constructor
}
*object แบบ dynamic เป็นการจองพื้นที่ในหน่วยความจำตอน runtime
2. multiple constructor เป็น constructor ที่มีส่วน implement ภายในซึ่งอาจมีการรับค่า parameter หรือไม่มีก็ได้
เช่น
Class number
{
Private value; Public number(){ value = 0};
Public number(int v){value = v;};
Public void setValue(int v) { value = v;};
Public void getValue() {return value};
}
Main program
{
number a = new number();
สร้าง object แบบ dynamic โดยเรียกใช้ constructor ที่ไม่มีการรับ parameter attribute ชื่อvalueมีค่าเป็น 0
number a = new number(9);
สร้าง object แบบ dynamic โดยเรียกใช้ constructor ที่มีการรับ parameter attribute ชื่อvalueมีค่าเป็น 9
}
Overloading method
คือ method ที่ใช้ชื่อซ้ำกันแต่ค่า parameter ที่รับมีความแตกต่างกัน ซึ่งโปรแกรมจะเลือกว่าเป็นการเรียก method ใดโดยดูจาก parameter ที่รับเข้ามา เช่น
Public getStudentName(string StudentLastName);
Public getStudentName(int StudentNO);
ดังนั้นเพื่อที่จะให้ผู้ใช้สามารถเข้าถึง method ได้ผู้ใช้จะต้องรู้
1. ชื่อของ method
2. Parameter ของ method
การเรียก method ของ object นั้นคล้ายกับการ call function แต่ oop จะเป็นการให้ object นั้นทำ method ของตนเอง เช่น
Line 1 :Employee em01;
Line 2 :em01.setName(“David”);
Line 2 เป็นการส่ง message ให้ object ของ Employee ที่ชื่อว่า em01 เรียกใช้ method setName ของตัวมันเองซึ่งมี argument เป็น “David”
รูปแบบการเรียกใช้ method : ชื่อobject . ชื่อmethod
Accessor
คือ method ที่ให้ read หรือ write attribute ใน คลาสนั้นๆ ซึ่งมักจะตั้งชื่อเป็น
Set….() เป็นการ write ค่าให้ attribute
Get….(return….;) เป็นการ read ค่าใน attribute
การสื่อสารระหว่าง object
การที่ object 2 ประเภทจะติดต่อสื่อสารกันได้ จะต้องมี object ตัวหนึ่งเป็น sender ซึ่งเป็นผู้ส่ง message ไปยัง object อีกตัวหนึ่งซึ่งเป็น receiver โดยที่ sender จะต้องรู้จักกับ object ที่เป็น receiver เสียก่อน แล้ว object ที่เป็น receiver เมื่อได้รับ message จะ return value กลับมาให้ sender หรือไม่ก็ได้
เช่น
กรณีที่มีการ return value : object School ส่ง messageสอบถามรายชื่อนักเรียน ไปยัง object Student object Student ก็จะส่งข้อมูลรายชื่อนักเรียนทั้งหมดกลับไป
กรณีที่ไม่มีการ return value : object School ส่ง messageต้องการเปลี่ยนชื่อนักเรียน ที่มีรหัสประจำตัว คือ XX เป็นชื่อ YYY ไปยัง object Student object Student จะทำการเปลี่ยน attribute ชื่อของนักเรียนที่มีรหัส 1 เป็นชื่อที่กำหนด โดยที่ object School ไม่สนใจว่า object Student จะ return ค่าใดๆกลับมา
BIG 