คุณสมบัติที่จำเป็นสำหรับการวางแนววัตถุคืออะไร?

ฉันแค่สงสัยว่าคุณสมบัติหรือภาษาใดที่ห้องสมุดต้องมีเพื่อให้มันถูกกำหนดให้เป็น 'Object Oriented' คือการจัดวางวัตถุบางสิ่งบางอย่างที่สามารถมากขึ้นหรือน้อยกว่าจะประสบความสำเร็จในการใด ๆวัตถุประสงค์ทั่วไปการเขียนโปรแกรมภาษาที่มีคุณสมบัติที่ดี? หรือเป็นสิ่งที่สามารถทำได้ในภาษาที่โฆษณาเฉพาะที่สนับสนุนการเขียนโปรแกรมเชิงวัตถุ?

ตัวอย่างเช่นดูที่รหัส C ต่อไปนี้:

SDL_Surface* screen = SDL_SetVideoMode( 640, 480, 16, SDL_HWSURFACE);
SDL_FreeSurface( screen );

หรือรหัสที่กล่าวถึงที่นี่

ตอนนี้โค้ดด้านบนไม่ได้ใช้การสืบทอด, ความแปรปรวนแบบรันไทม์ (?), ฟังก์ชั่นเสมือนจริง ฯลฯ แต่ดูเหมือนว่า OOP จะค่อนข้างดีสำหรับฉัน

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

อ้างอิงจากอลันเคย์ผู้คิดค้นคำว่า "เชิงวัตถุ"

OOP สำหรับฉันหมายถึงเพียงการส่งข้อความการเก็บรักษาในท้องถิ่นและการป้องกันและการซ่อนกระบวนการของรัฐและการผูกมัดปลายสุดของทุกสิ่ง สามารถทำได้ใน Smalltalk และ LISP อาจมีระบบอื่น ๆ ที่เป็นไปได้ แต่ฉันไม่ทราบ

การส่งข้อความ (ตามที่นำมาใช้ใน Smalltalk) เป็นแนวคิดที่เปรียบเทียบได้กับ polymorphism แต่มีประสิทธิภาพมากกว่า (อย่างน้อยก็มากกว่า polymorphism ที่สนับสนุนโดย C ++ หรือ Java) สามารถทำได้ในทุกภาษา แต่ค่อนข้างเจ็บปวดหากไม่รองรับภาษาโดยตรง โดยทั่วไปหมายความว่าวัตถุสามารถส่งข้อความอื่น ๆ ที่มีสิ่งใด ๆ และสามารถตอบสนองได้อย่างไรก็ตามพวกเขาต้องการข้อความที่ได้รับ ในการรองรับการรับส่งข้อความอย่างสมบูรณ์นั้นจะต้องมีวิธีที่วัตถุจะตอบสนองต่อข้อความได้อย่างยืดหยุ่นโดยไม่ต้องระบุในซอร์สโค้ด

การเก็บรักษาและการป้องกันในท้องถิ่นและการซ่อนกระบวนการของรัฐ - การห่อหุ้ม AKA - สามารถทำได้โดยการประชุมในทุกภาษา แต่นั่นเป็นการโกง การเก็บรักษาข้อมูลในระดับภาษาจริง ๆ แล้วดูเหมือนว่าจะเป็นฟีเจอร์เดียวที่ทุกภาษาอ้างว่าเป็น OO (และอีกหลายภาษาที่ไม่แชร์) - โดยทั่วไปจะมีวิธีในการสร้างประเภทข้อมูลผสมที่มีหลายอินสแตนซ์ ในทางกลับกันการป้องกันและการซ่อนตัวมักกระทำโดยการประชุมเท่านั้น

ปลายที่มีผลผูกพันทุกสิ่ง - เลื่อนระดับที่ C คือจริงๆห่างไกลจากวิสัยทัศน์ของเคย์ ( ณ คือ C ++, Java เป็นในขณะที่ใกล้ชิดมาก) สามารถแกล้ง (ดู COM) แต่นั่นจะเป็นความเจ็บปวดที่จะใช้

หมายเหตุว่าเคย์ไม่ได้พูดถึงการถ่ายทอดทางพันธุกรรม ในอีเมลเดียวกันเขาเขียน

ฉันไม่ชอบวิธีที่ Simula ฉันหรือ Simula 67 ได้รับมรดก (แม้ว่าฉันคิดว่า Nygaard และ Dahl เป็นเพียงนักคิดและนักออกแบบที่ยิ่งใหญ่) ดังนั้นฉันจึงตัดสินใจที่จะละทิ้งมรดกเป็นคุณลักษณะในตัวจนกว่าฉันจะเข้าใจได้ดีขึ้น

การเขียนโปรแกรมเชิงวัตถุไม่ได้เกี่ยวกับคุณสมบัติทางไวยากรณ์ แต่เป็นความรู้ด้านการเขียนโปรแกรมและการออกแบบ ที่แกนกลางของมันหมายถึงแนวคิดของวัตถุซึ่งเป็นโครงสร้างที่ระบุกลุ่มที่มีรูทีนเพื่อดำเนินการกับมัน (หรือขึ้นอยู่กับมุมมองของคุณการตอบสนองต่อข้อความ) สิ่งสำคัญอื่น ๆ ของ OOP คือการห่อหุ้ม : การห่อรายละเอียดการใช้งานลงในโครงสร้างทึบและเชื่อมต่อผ่านอินเตอร์เฟสที่กำหนดไว้อย่างดี ค่อนข้างทุกอย่างอื่นในทฤษฎี OOP กลับไปที่พื้นฐานทั้งสองนี้

ดังนั้นภาษาใดก็ตามที่สามารถทำโมเดลวัตถุ (เอนทิตีที่มีทั้งข้อมูลและรหัส) และการห่อหุ้มสามารถใช้ในการทำ OOP ตัวอย่างเช่นใน C คุณสามารถใช้ตัวชี้ฟังก์ชั่นเพื่อจัดเก็บฟังก์ชั่นใน structs และคุณสามารถใช้ระบบไฟล์ส่วนหัว / ซอร์สเพื่อตระหนักถึงการห่อหุ้ม มันไม่สะดวก แต่ก็เพียงพอที่จะทำ OOP คุณอาจจะงอบางอย่างเช่น Haskell หรือ ML เพื่อทำ OOP และฉันจะไม่แปลกใจถ้ามีคนคิดวิธีการทำ OOP ในที่ประชุม

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

ดังนั้นฉันจะเรียกชิ้นส่วนของรหัสวัตถุเชิงถ้ามันเป็นไปตามหลักการ OOP และใช้ไวยากรณ์ OOP ที่มีอยู่

BTW. ตัวอย่างเช่นรหัสของคุณอาจจะไม่ใช้งานหลายรูปแบบและฟังก์ชั่นเสมือนแม้ว่าไวยากรณ์ซีไม่ได้ทำให้มันเห็นได้ชัด ฉันไม่ใช่ผู้เชี่ยวชาญเกี่ยวกับ SDL แต่ฉันคาดหวังว่าSDL_surfaceจะสามารถนำเสนอพื้นผิวหลากหลายประเภทแต่ละแบบมีชุดการนำไปใช้งานเฉพาะของตนเอง - การทำบางสิ่งบางอย่างลงในบิตแมปหน่วยความจำและการตัดกับพื้นผิวหน้าจอ รหัส แต่ส่วนต่อประสาน (ฟังก์ชั่นที่รับSDL_surface*เป็นอาร์กิวเมนต์) ยังคงเหมือนเดิม เช่นเดียวกับที่ใช้ในการห่อหุ้ม: คุณไม่สามารถเข้าถึงการแสดงพื้นผิวโดยตรงได้คุณต้องผ่านฟังก์ชั่นที่รู้วิธีจัดการSDL_surfaceเพราะนั่นคือทั้งหมดที่คุณมี มันเป็นตัวอย่างที่ดีของวิธีที่คุณทำ OOP ใน C

ความเข้าใจของฉันเกี่ยวกับ OO คือ OO เป็นวิธีคิดและการดำเนินการตามความคิดที่ว่างานคำนวณสามารถทำได้โดยคนงานคนหนึ่ง (วัตถุ) หรือโดยการทำงานร่วมกันของพนักงานแต่ละคน (วัตถุ) ผ่านข้อความผ่านระหว่างคนงานเหล่านั้น ( วัตถุ) ในเวลาทำงาน ลักษณะการทำงานในขณะใช้งานนี้ต้องการสแตติกแบบคงที่และการสร้างแบบไดนามิกเพื่อเปิดใช้งาน

ไวยากรณ์เฉพาะที่จะใช้ OO ไม่ใช่กุญแจที่กำหนดว่าภาษาเป็น OO หรือไม่ ตัวอย่างเช่น Smalltalk และ C # มีไวยากรณ์ที่แตกต่างกัน แต่ทั้งคู่เป็นภาษา OO (ไปยังองศาที่ต่างกัน) กุญแจสำคัญคือว่าภาษาที่กำหนดรักษาปรัชญา (ด้านบน) และให้วิธีการปลูกฝังที่จำเป็น

เมื่อฉันเป็นนักเรียนฉันถูกสอนว่าการเขียนโปรแกรมเชิงวัตถุตั้งอยู่บนเสาหลักสามประการ:

• encapsulation ,
• ความหลากหลายและ
• มรดก

ภาษาจะต้องสนับสนุนคุณสมบัติเหล่านั้นเพื่อให้ได้รับการพิจารณาเป็นภาษาเชิงวัตถุ

หมายเหตุที่ว่านี้จะอธิบายถึงชุดของคุณลักษณะมากกว่าไวยากรณ์ ดังนั้นไม่ว่าคุณจะต้องเขียน

type obj; // or type obj = new type;
obj.func(arg);

หรือ

type* ptr = create_type();
func(ptr, arg); 

ไม่สำคัญ

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

คุณสามารถทำ OO ในภาษาทั่วไปที่เหมาะสม

มันง่ายกว่าที่จะทำในภาษา "OO" เพราะคุณมีโครงสร้างที่ใช้ง่ายและไม่ต้องหันไปใช้OO ใน C - ซึ่งเป็นไปได้ แต่น่ากลัว

ไม่ว่า OO สร้างจะให้บริการโดยภาษาของตัวเองโดยห้องสมุดมาตรฐานหรือโดยห้องสมุดอื่น ๆ ไม่สำคัญเท่าที่บางภาษา (เช่น Scala) อนุญาตให้ห้องสมุดเพื่อเพิ่มภาษาสร้างเพื่อให้จากมุมมองของโปรแกรมเมอร์เกือบจะเป็นไปไม่ได้ เพื่อแยกความแตกต่างสิ่งที่มีให้โดยภาษาหลักและที่โดยห้องสมุด

หากคุณมองไปที่ช่วงของภาษาที่ได้รับการยอมรับอย่างกว้างขวางว่าเป็น OO และผู้ที่ไม่ได้ทดสอบดูเหมือนว่าจะสนับสนุนการรวม polymorphism (aka sub-type polymorphism แต่การรวม polymorphism เป็นคำที่ใช้โดย Cardelli ในกระดาษที่นำมาใช้กับฉันและฉันคิดว่าคนอื่นค่อนข้างมากสำหรับการจำแนกประเภทของความแตกต่าง) IE ความเป็นไปได้สำหรับตัวแปรบางตัวที่มีค่าของชนิดที่แตกต่างกันและความเป็นไปได้สำหรับบางสายที่จะส่งไปยังรูทีนที่แตกต่างกันขึ้นอยู่กับประเภทของค่าหนึ่งหรือหลายค่า ทุกสิ่งทุกอย่างมีอยู่ในภาษาที่ไม่ยอมรับในฐานะ OO หรือขาดหายไปจากภาษาที่ยอมรับกันในฐานะ OO

คุณสมบัติอื่นที่สำคัญสองประการที่เกี่ยวข้องกับภาษา OO นั้นจัดทำโดยภาษาที่ไม่ใช่ OO:

• การห่อหุ้มนั้นค่อนข้างดีโดย Ada83;
• การสืบทอดมาจาก Oberon (Oberon น่าสนใจ Wirth ต้องการให้ภาษา OO มี cruft น้อยที่สุดเท่าที่จะเป็นไปได้ แต่ต้องทบทวนความคิดของเขาเพื่อรับหนึ่ง - Oberon-2 คือ OO)

การวางแนววัตถุถูกกำหนดเป็น

• ความแตกต่าง
• มรดก
• encapsulation

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

พิจารณารหัสวัตถุของคุณถ้ามันเป็นภาษาโปรแกรมเชิงวัตถุ แม้ว่าคุณจะเขียนอะไรบางอย่างที่ดูเหมือนว่าจะเป็นขั้นตอนมันก็จะทำตามวิธีการในวัตถุจากชั้นเรียนที่ใช้ความหลากหลายผ่านการห่อหุ้ม [อาจ] :)

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