ภาพจาก http://www.voidspace.org.uk/
Object Oriented Programming เป็นการเขียนโปรแกรมโดยการมองสิ่งต่างๆ เป็นวัตถุ ซึ่งใน Realworld สิ่งต่างๆ รอบๆ ตัวเราก็เป็นวัตถุ โดยมีแนวคิดที่ว่า สิ่งที่ประกอบกันเป็นวัตถุนั้นจะประกอบไปด้วย
- Attribute(ลักษณะที่สามารถอธิบายได้ว่าวัตถุนี้คืออะไร อย่างเช่น คนสิ่งที่อธิบายได้ว่าเป็นคน อาจจะเป็น มีหู ตา จมูก ปาก แขน ขา อะไรพวกนี้)
- Method(พฤติกรรมของวัตถุนั้นว่าสามารถทำอะไรได้ พูดง่ายๆ การกระทำนั่นแหละ)
เราสามารถทำการ Implement ได้โดยการทำให้อยู่ในรูปของ Class ซึ่งเปรียบเหมือนกับต้นแบบที่ไว้ สร้าง Object (Class ไม่ใช่ object นะ) คุณสมบัติที่สำคัญของ OOP ก็คือ
- Encapsulation
เป็นการห่อหุ้ม Attribute ไว้ด้วย Method หมายความว่าการที่เราต้องการเข้าไป เปลี่ยนแปลงหรือใช้ค่า Attribute นั้นต้องกระทำผ่าน Method ยกตัวอย่างเช่นเด็กหญิงนิดกับเด็กหญิงหน่อยเป็นเพื่อนกัน มีอยู่วันหนึ่งนิดเดินเหยียบเท้าหน่อย หน่อยรู้สึกไม่พอใจ (ตอนนี้ค่า Attribute อารมณ์ของหน่อยเพิ่มขึ้น) แต่นิดยังไม่รู้ เมื่อหน่อยแสดงสีหน้าไม่พอใจ เมื่อนิดเห็นแบบนั้นนิดรู้สึกผิด(หน่อยก็ยังไม่รู้เพราะ นิดคิดอยู่ในใจ) จึงกล่าวขอโทษ หน่อยได้ยินแบบนั้นจึงหายโกรธ
ตัวหนา คือ Method
ตัวหนาเอียง คือ Attributeจะเห็นได้ว่าค่า Attribute นั้นก็คือค่าที่อยู่ภายในการที่จะให้ Object อื่นรับรู้ได้ก็จำเป็นที่จะ ต้องแสดงค่านั้นออกมาผ่านทาง Method สิ่งที่ส่งออกมาให้ Object อื่นรับรู้นั้นเราเรียกว่า Message จากตัวอย่างจะเห็นว่ามีการเปลี่ยนแปลงค่า Atrribute ตอนที่นิดเหยียบเท้าหน่อยนั้น การเหยียบเท้าคือ Method ที่แสดงออกมาทำให้อารมณ์ ซึ่งเป็น Attribute อยู่ภายในเปลี่ยนแปลง และ การกล่าวขอโทษก็เป็น Method ที่ทำการเปลี่ยนแปลงค่า Attribute ดังนั้นภาพของ Object ในหัวก็จะเป็นลักษณะที่ Method ห่อหุ้ม Attribute ไว้ วัตถุทุกตัวจะแสดงออกให้รับรู้ถึงสิ่งที่อยู่ภายในหรือสิ่งที่ต้องการผ่านทางการกระทำ
- Inheritance
เป็นการทำให้ Class สามารถสืบทอดต่อกันได้ โดยลักษณะของการสืบทอดนั้นก็เพื่อเพิ่มเติมความสามารถให้สามารถทำงานได้มากกว่าคลาสแม่ที่สืบทอดมา เช่น คลาสของคนสืบทอดมาจากคลาสของสัตว์เลี้ยงลูกด้วยนม โดยที่ Method พื้นฐานของสัตว์เลี้ยงลูกด้วยนมนั้น สมมุติให้มีเพียง กินอาหาร สืบพันธุ์ ขับถ่าย Class ของคนที่สืบทอดมาจากสัตว์เลี้ยงลูกด้วยนม สิ่งที่คนทำได้แตกต่าง เช่น การพูด ก็จะถูกเพิ่มเข้าไปในคลาสของคน สรุปว่าคนสามารถ กิน,สืบพันธุ์,ขับถ่าย และ พูด ได้ - Abstraction
เป็นการสร้าง Method แบบลอยๆ ขึ้นมายังไม่ได้ระบุรายละเอียดว่า Method นั้น ทำงานอย่างไรจะมีการระบุการทำงานในส่วนของ Subclass ที่รับสืบทอดมา สาเหตุที่มีการทำแบบนี้ก็เพื่อให้สามารถใช้ Polymorphism ได้นั่นเอง - Polymorphism
คือสภาวะที่ Method มีหลายรูปแบบ เป็นวิธีการกำหนดรูปแบบการกระทำที่เหมือนกันแต่ได้ผลที่แตกต่างกัน สมมุติว่ามี คลาสแม่(Superclass) ที่เป็นคลาสของสัตว์เลี้ยงลูกด้วยนม โดยมีคลาสลูก(Subclass) คือ คลาสของคนกับสุนัข ซึ่งทั้งคนกับสุนัขมี Method ที่ใช้ในการเปล่่งเสียงซึ่งการเปล่งเสียงระหว่างคนกับสุนัขนั้นไม่เหมือนกันแต่มันก็คือการเปล่งเสียง ดังนั้นเมื่อได้รับ Message ที่บอกให้ทำการเปล่งเสียงทั้งคนและสุนัขก็สามารถเปล่งเสียงได้เพียงแต่มีเสียงที่แตกต่างกันเท่านั้นเอง เพื่อให้สามารถเข้าใจได้ง่ายเราก็จะสร้าง Method ที่ชื่อว่า เปล่งเสียง( ) มาเพียงชื่อเดียวแล้วใช้หลักการ polymorphism นี้เพื่อให้สามารถเปล่งเสียงได้หลายๆ รูปแบบ
การสร้างโครงสร้างการ Design แบบ OO ที่ดีนั้นควรพยายามสร้างตามหลักข้างบนให้ได้นะครับ จะช่วยได้มากเลยทีเดียว แต่ที่แน่ๆ พยายามทำให้คลาสของเรามีลักษณะที่เป็น Encapsulation ตามข้อแรกให้ได้ครับ
นี่ก็เป็นหลักการในการเขียนโปรแกรมแบบ OO ที่ผมสรุปมาจากความเข้าใจของตัวเองนะครับไม่ได้อ้างอิงมาจากที่ไหน ถ้ามีส่วนใดที่ผิดก็แสดงความคิดเห็นมาได้ครับ คราวต่อไปจะมาเล่าเรื่องปัญหาที่เกิดจากการ Design ให้ฟังครับ
เป็นบทความที่ดีครับ
เพราะหาใครที่จะมาอธิบายเรื่องพวกนี้ยากเหมือนกัน
แต่ผมอ่านไม่ค่อยเข้าใจรายะเอียดเท่าไรครับ
คงเพราะความรู้น้อยเกินไปจริงๆ
อ่านจนจบแล้ว
Attribute Method Object Class
ขนาดมี sub ไทยประกอบแล้ว ยังไม่รู้จักมันเลย
-_-”
ถ้าอธิบายอีกรอบก็คงไม่ต่างจากเดิมเท่าไหร่นะ เดี๋ยวจะพยายามหาวิธีการเล่าแบบอื่นดูใหม่แล้วกัน
แล้วสมบัติ Polymorphism เนี่ยะ ถ้า Message ต่างกันแสดง พฤติกรรม ต่างกันไม่ได้หรอครับ
มันจะแสดงพฤติกรรมต่างกันครับ แต่สิ่งที่ทำมันคืออย่างเดียวกัน สมมุติผมมี method การเปล่งเสียง ซึ่งมีในคลาสมนุษย์ และ คลาสแมว ซึ่งสืบทอดมาจากคลาสสัตว์เลี้ยงลูกด้วยนม ทั้งมนุษย์และแมวสามารถ เปล่งเสียงได้เหมือนกันแต่วิธีการเปล่งเสียงเป็นคนละอย่างกัน ซึ่งนี่ก็เป็นตัวอย่างง่ายๆของ Polymorphism
ทำการแก้ไขให้แล้วครับเผอิญข้อมูลผมผิดไปจริงๆ ตรงที่ว่า polymorphism นั้นคือการรับ message ที่ต่างกันแล้วให้ผลเหมือนกัน ที่จริงแล้วต้องรับ message มาเหมือนกันแล้วแสดงผลที่ต่างกันนะครับ ขอบคุณ kojiro540 มากครับที่ช่วยชี้แนะ
วินนิ่งก็ได้ มาดิ -_-!!
Polymorphism
ผมเข้าใจว่า ชื่อ method Parameter เหมือนกัน แต่ Implement ต่างกัน
Overload
ผมเข้าใจว่าชื่อmethod เหมือนกัน Parameter ไม่เหมือนกัน implement ตาม Parameter ว่าจะ
เข้าmethodไหน นี่ผมเข้าใจถูกป่ะครับ
ถ้าไปโฟกัสที่ตรงนั้นอาจจะทำให้สับสนได้นะครับ เพราะว่า polymorphism มันคือการพ้องรูปของ method โดยคลาสแม่จะทำ abstract class เอาไว้แล้วคลาสที่สืบทอดไปก็เอาไป implement เอาเองว่า method นั้นทำงานอย่างไร พารามิเตอร์ก็กำหนดเอาเองว่าจะใช้อะไรบ้าง เราไม่ต้องกังวลในเรื่องของพารามิเตอร์เลยว่าจะต้องเหมือนกัน
ส่วน Overloading มันเป็นวิธีการเขียนแบบหนึ่งครับไม่ใช่คุณสมบัติของ OOP เป็นการเขียนเพื่อบอกว่าจะทำงานที่ฟังก์ชั่นไหนโดยดูจากพารามิเตอร์ที่ป้อนเข้ามา
เราจะทำ overloading ในคลาสด้วยก็ได้ครับ ดูตามตัวอย่างที่ผมเขียนแล้วกันครับอาจจะเข้าใจได้ง่ายขึ้น
class Animal():
abstract speak()
class Human(Animal):
def speak(self):
print “hi”
def speak(self,message):
print message
class Dog(Animal):
def speak(self):
print “Bow”
human = Human()
dog = Dog()
man.speak()
man.speak(“hello world”)
dog.speak()
จะเห็นว่า method speak ประกาศไว้ในคลาส Animal ก่อนยังไม่ได้ใส่อะไรลงไป พารามิเตอร์ก็ยังไม่ได้กำหนด
ในคลาส Human เลยมา implement ให้ method speak ที่สืบทอดมาจากคลาส Animal ซึ่งใช้คุณสมบัติของ polymorphism และก็ยังมี method ที่ overload มาด้วย
ส่วนคลาส Dog นั้นมีเพียงแค่ method ที่สืบทอดมาจาก Animal แล้ว Implement วิธีเข้าไปซึ่งก็ใช้คุณสมบัติของ polymorphism เช่นกัน
สรุปตามที่ผมเข้าใจก็คือ polymorphism นั้นช่วยให้มีความรู้สึกว่ามัน make sense ในการใช้งาน object ถึงแม้ object จะต่างชนิดกัน แต่ก็มีประเภทเดียวกัน เช่น Human.eat() กับ Dog.eat() ถ้าต้องตั้งชื่อแตกต่างกันทั้งหมดคงจะใช้ลำบากน่าดู ส่วนพารามิเตอร์จะเป็นยังไงก็ได้ไม่ต้องเหมือนกันทั้งหมดก็ได้
ส่วน overload นั้นเป็นการระบุว่ามีฟังก์ชั่นการทำงานได้หลายแบบขึ้นอยู่กับพารามิเตอร์ ที่ป้อนเข้ามา ซึ่งก็สามารถนำมาใช้ในคลาสที่ method นั้นถูก polymorphism มาก็ได้
ปล. โค้ดนี้เป็น pseudo code นะครับ ไว้ให้เห็นความแตกต่างระหว่าง polymorphism กับ overload
อยากทราบว่า เวลาเราจะมองโปรแกรมว่าจะต้องมีกี่คลาส อะไรบ้าง เราต้องทำยังไง เพราะบางทีเริ่มรู้สึกว่าไม่รู้ว่าถ้าโจทย์มาแบบนี้จะต้องใช้classอะไรบ้าง ทำไมไม่จำป็นต้องมีบางclass แล้วทำไมต้องมี class นี้ มีassociationแบบใด แล้วเวลาจะดึงใช้ถึงกันระห่วางclass ที่มีassociation ร่วมกันทำยังไงคะสับสนมากค่ะ
ช่วยอธิบายเรื่อง constructor หน่อยไดไหมคะ
ตอบทีละคำถามนะครับ
#1 หลักการเขียนแบบ OO นั้น การจะจำแนกว่าควรมีคลาสอะไรบ้างนี่ต้องพิจารณา ควรจะครอบคลุมในลักษณะของ MVC (Model, View, Controller) ครับ
- Model ก็คือลักษณะโครงสร้างของข้อมูลของเรานั้นประกอบด้วยอะไรบ้าง เช่น ในรายชื่อสมุดโทรศัพท์ข้อมูลจะประกอบไปด้วย ชื่อ นามสกุล ที่อยู่ เบอร์ติดต่อ ฯลฯ
- View เป็นส่วนแสดงผลมีหน้าที่ดึงข้อมูลที่ต้องการออกมาแสดงผลให้ผู้ใช้ดู
- Controller เป็นส่วนที่ไว้ควบคุมการทำงานต่างๆ เช่น วิธีค้นหาชื่อในสมุดโทรศัพท์ วิธีบันทึกข้อมูล ฯลฯ
ที่ต้องทำแบบนั้นเพราะว่าเมื่อเราแก้ไขในส่วนใดก็จะได้ไม่กระทบกับส่วนอื่นๆ ก็จะได้ตรงตามจุดประสงค์ของการเขียนแบบ OO ครับ แต่ส่วนหนึ่งก็ต้องอาศัยประสบการณ์พอสมควรในการเขียนแบบ OO เพราะ ในมหาลัยมักจะเริ่มสอนแบบ structure ก่อนทำให้ปรับสไตล์กันลำบากนิดนึง เพื่อความรวดเร็วลองไปหาโปรแกรม Opensource เล็กๆ ซักตัวมาดูซอร์สโค้ดก็ได้ครับ อาจจะช่วยให้เข้าใจได้เร็วขึ้นว่าต้องเขียนแบบไหนถึงจะดี
#2 Constructor ไม่มีอะไรมากกว่าการเป็น Method ที่ต้องทำงานทันทีถ้า Object นี้ถูกสร้างขึ้นมา เราอยากให้มันทำงานอะไรบ้างในตอนแรกก็สามารถกำหนดได้ที่ constructor ครับ อย่างเช่น กำหนดค่าเริ่มต้นให้ตัวแปร, การเรียก Method อื่นๆ ให้ทำงาน ฯลฯ
ขอบคุณมากค่ะที่ช่วยอธิบายเรื่องที่ถามไปแล้ว
ตอนนี้กำลังสงสัยเรื่องassociation อ่ะค่ะ รู้สึกว่ายังใช้ไม่ค่อยเป็น แบบว่าระหว่างclass ยังดึงความสัมพันธ์ออกมาไม่ค่อยถูกจะเขียนcode ก็เลยยังทำไม่ค่อยถูก พอดีตอนนี้กำลังเรียนวิชาoopอยู่อ่ค่ะ
ผมเข้าใจว่าเรื่อง association คือเรื่องการติดต่อกันระหว่าง object แต่ละตัวใช่รึเปล่าครับ ช่วยอธิบายเพิ่มเติมอีกนิดนึงได้มั้ยครับ
Thanx for the helpful explaination
Encapsulation เป็นการห่อหุ้มทั้ง ข้อมูล(data member) และกิกรรม (method member) นั่นก็หมายความว่า หากภาษาใดที่ต้องการสนับการเขียนภาษาคอมพิวเตอร์แบบวัตถุ ก็ต้องสร้างภาษาที่สามารถห่อหุ้มทั้ง ข้อมูล(data member) และกิกรรม (method member) รวมถึงการกำหนดขอขเขตในการเข้าถึง ตัวอย่างเช่น java script จะใช้ function ในการห่อหุ้ม , java c# php จะใช้ class ในการห่อหุ้ม และมีการกำหนดขอบการเข้าถึงข้อมูลและกิจกรรมด้วย public , private ผมเข้าใจว่าน่าจะประมาณนี้นะครับ
จากคนสนใจ OOP เหมือนกัน
อีกข้อของ oop คือ Aggregation และ Composition ก็ประมาณว่า ภาษาใดที่ต้องการสนับการเขียนภาษาคอมพิวเตอร์แบบวัตถุได้ ต้องสามารถเก็บข้อมูลประเภท object ได้ด้วย เพื่อให้สามารถรองรับการสร้าง object ที่เกิดจากการรวม object ภายนอกอื่นๆมาเป็นองค์ประกอบ หรือการนำเข้ามาร่วมในการดำเนินกิจกรรม
จากคนสนใจ OOP และอาศัยการเขียนโปรแกรมในการตีความหมาย
สมมุติว่าเรามีคลาสอยู่ 3 คลาส คือคลาส A, B และ C โดยคลาส B และ C ทำการ implement ตัว Interface ตัวเดียวกันชื่อ Interface D เราจะทำอย่างไรให้ตอนแรก คลาส A คุยกับคลาส B ได้ผลแบบหนึ่ง ต่อมาให้คลาส A คุยกับคลาส C ได้ผลอีกแบบหนึ่ง โดยที่เราไม่จำเป็นต้องทำการคอมไพล์โปรแกรมอีก ในกรณีที่เราเปลี่ยนการเชื่อมต่อระหว่างคลาส A กับคลาส B ไปเป็นคลาส A กับคลาส C ช่วยตอบหน่อยน่ะ
สร้าง method สำหรับติดต่อระหว่างคลาสขึ้นมา ให้ B รับ message จาก A แล้วทำการเช็คว่าถ้า A ติดต่อกับ B แล้วให้ส่งค่าอะไรกลับมา ส่วน C ก็ทำวิธีการเดียวกันครับ
ไม่รู้ว่าผมเข้าใจคำถามถูกรึเปล่านะครับ
ไม่ใช่ไม่อยากทำนะ OOP การเขียนโปรแกรมโดยการมองสิ่งต่างๆเป็นวัตถุ ได้แต่จำไว้เขียนตอบตอนสอบ เอาเข้าจริงๆ ไม่รู้จะเขียนยังไง ถ้ามีหนังสือพัฒนาโปรแกรมด้วย OOP ก็ดี แบบมีตัวอย่างมากๆ ก็ดี เห็นมีแต่ทฤษฎีอ่านแล้วก็ยังงง ทุกวันนี้ก็เขียนโปรแกรมแบบ เดิมๆ อยู่ เขียนแล้ว run ได้ก็ดีใจจะแย่แล้ว
ลองดูตัวอย่างโค้ดที่เปิดให้ดาวน์โหลดน่าจะช่วยเสริมความเข้าใจได้เยอะทีเดียวครับ
สู้ต่อไปไอ้มดแดง ^^
ไม่ค่อยเข้าใจ oo เท่าไหร่ครับช่วยแนะนำหน่อยนะครับสมมุติมีโจทย์ว่า
ร้านขายขนมแห่งหนึ่งจะมีขนมขายอยู่ 2 ประเภท คือขนมอายุสั้น ขนมประเภทนี้ต้องขายให้หมดในวันเดียว และจะถูกแขวนป้ายลดราคาในช่วงเย็น อีกประเภทหนึ่งขนมที่มีอายุนานซึ่งเป็นขนมที่วางขายได้หลายวัน ขนมทุกชนิดจะถูกบรรจุในถุง และติดป้ายหมดอายุไว้
พนักงานขายจะทำหน้าที่จัดวางขนมบนชั้นที่วางขาย และเรียงขนมที่หมดอายุก่อนไว้ด้านหน้า นำขนมจากหลังร้านมาเติมที่ชั้นวางเมื่อใกล้หมด และขายขนมให้ลูกค้า ลูกค้าสามารถหยิบขนมจากชั้นมาชำระเงินที่พนักงานขาย ซึ่งพนักงานขายจะบันทึกว่าได้ขายขนมชนิดใด ขนาดใด (ถุงเดี่ยว,ถุงเล็ก,ถุงใหญ่) ไปกี่ชิ้น ลูกค้าสามารถสั่งขนมล่วงหน้าอย่างน้อย 1 วัน ซึ่งพนักงานขายจะทำการจดชื่อ และเบอร์ติดต่อลูกค้าไว้ รวมทั้งวันและเวลาที่ลูกค้าจะมารับขนม ลูกค้าต้องมารับขนมภายใน 3 ชั่วโมง จากวันเวลาที่นัดไว้ ถ้าเลยเวลาลูกค้ายังไม่มารับ พนักงานขายจะนำขนมนั้นไปวางขายที่ชั้น ในวันหนึ่งจะมีการกำหนดเวลาเป็นช่วงในการนับเงินที่เป็นรายได้จากการขายขนมแล้วนำเงินไปเก็บเข้าตู้เซพ
ถามนะครับ
1. จะเขียน Class Instance และ Encapsulation อย่างไรครับ
2. จะเขียน Inheritance และ Polymorphism อย่างไรครับ
ช่วยเขียนให้ดูเป็นตัวอย่างหน่อยได้ไหมครับ เผื่อจะได้เข้าใจและนำไปใช้ได้กับเขาบ้าง
ก็มีคลาส ขนม(inherit เป็น อายุสั้น กับ อายุยาว), คน (inherit เป็น พนง.ขาย กับ ลูกค้าอีกที)
พวก encapsulation ของคนที่เป็น พนง.ขายก็จะมี คิดเงิน บันทึกข้อมูลการขาย ฯลฯ (อะไรก็ตามที่ พนง.ขายทำได้) ส่วนลูกค้าก็อาจจะเป็น ถามราคาจากคนขาย, รับสินค้า อะไรพวกนี้ ส่วนไหนที่ พนง.ขาย ทำได้เหมือนกับลูกค้า เช่น การเดิน ฯลฯ ก็ถูก inherit มาจากคลาส คน อยู่แล้ว
polymorphism ที่เห็นได้ชัดเจนเลยก็น่าจะเป็น พนง.ขาย กับ ลูกค้า เช่น ทั้งคู่สามารถถามได้เหมือนกัน แต่ก็ถามกันคนละแบบ เช่น พนง.ขาย จะถามว่า รับอะไรดีคะ? ส่วนลูกค้าก็อาจถามว่า ราคาเท่าไหร่? ตรงนี้ก็สามารถใช้ polymorphism ได้ครับ โดยการทำเป็นฟังก์ชั่น ask() สมมุติว่ามี
sale.ask() ฟังก์ชั่นของ พนง.ขาย จะ return ว่า “รับอะไรดีคะ?”
customer.ask() ฟังก์ชั่นของ ลูกค้า จะ return ว่า “ราคาเท่าไหร่?”
ขอบคุณมากครับที่ช่วยตอบ พอเข้าใจมานิดหน่อยแล้วครับ เริ่มเห็นภาพบ้างแล้วครับ
แล้ว polymorphism ของ class ขนมนี่พอจะมีอะไรได้บ้างครับ
polymorphism ของขนมอายุสั้นกับยาว น่าจะเป็นฟังก์ชั่นพวก setter กับ getter มากกว่า เช่น getPackageStatus()
ขนมอายุสั้นจะ return “in package”
ขนมอายุยาวจะ return “not in package”
ขอโทษทีครับไม่ค่อยเข้าใจครับ setter,getter คืออะไร และ method getPackageStatus()
นี่ใช้ทำอะไรครับภายใน method นี่ทำอะไรครับ งงงง
setter และ getter เป็นชื่อเรียก method ที่ใช้สำหรับตั้งค่าหรือต้องการให้วัตถุส่งค่าอะไรบางอย่างให้กับเรา
อย่างเช่นคลาสของเรามีตัวแปร A อยู่ ถ้าเราอยากรูค่าของ A เราจะไม่บอกว่า x=myclass.A เพราะแบบนี้จะเป็นการเข้าถึง attribute โดยตรง ซึ่งไม่เป็นไปตามรูปแบบของการ encapsulation
วิธีที่ใช้กันถ้าอยากได้ค่าตัว A จะให้เรียก method ที่รีเทิร์นค่า A ออกมา (method แบบนี้เราเรียกว่า getter เพราะเป็นการ get ค่าออกมา แต่ถ้าเป็น method เกี่ยวกับการตั้งค่าให้ attribute ในคลาส จะเรียกว่า setter)
ภายใน method พวกนี้ก็จะเป็นการนำค่าไปให้ attribute (setter) หรือ การส่งค่าออกมาให้ (getter)
อย่าง getPackageStatus() ก็เป็น method สำหรับการตรวจสอบสถานะ ว่าขนมนั้นบรรจุถุงหรือไม่ (ขนมอายุสั้นไม่ใส่ถุง ส่วนขนมอายุยาวใส่ถุง) แค่นั้นครับ ไม่มีอะไรมาก ส่งค่าออกมาแบบ boolean ก็ได้
ขอบคุณครับเดี๋ยวลองไปนั่งศึกษารายละเอียดดูอีกทีครับ
พี่รู้เยอะดีจัง
ทำโปรแกรมขายปลากระป๋องอัตโนมัตได้มั๊ยคะ
ทำได้ครับแต่ลำพังงานที่ออฟฟิศก็ท่วมหัวแล้วครับ T-T
ยอดไปเลยคับ