แนวคิดและหลักการพื้นฐานของ OOP การเขียนโปรแกรมเชิงวัตถุ (OOP) ย่อมาจาก OOP

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

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

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

คำศัพท์เฉพาะทางการเขียนโปรแกรมเชิงวัตถุ

ก่อนที่จะอธิบายประโยชน์ที่ OOP มอบให้กับนักพัฒนาซอฟต์แวร์ในกระบวนการและผลิตภัณฑ์ซอฟต์แวร์ จำเป็นต้องทำความคุ้นเคยกับคำศัพท์ที่ใช้บ่อยที่สุดในด้านนี้

ระดับ – ชนิดข้อมูลที่อธิบายโครงสร้างและพฤติกรรมของวัตถุ

วัตถุ – ตัวอย่างของคลาส

สนาม องค์ประกอบข้อมูลคลาส: ตัวแปรประเภทพื้นฐาน โครงสร้าง หรือคลาสอื่นที่เป็นส่วนหนึ่งของคลาส

สถานะของวัตถุ – ชุดของค่าฟิลด์วัตถุปัจจุบัน

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

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

สมาชิกชั้นเรียน – ฟิลด์ วิธีการ และคุณสมบัติของคลาส

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

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

ผู้ทำลายล้าง – วิธีการพิเศษที่เรียกโดยสภาพแวดล้อมการทำงานของโปรแกรมในขณะที่วัตถุถูกลบออกจาก RAM ตัวทำลายจะใช้ในกรณีที่คลาสรวมทรัพยากรที่ต้องการการเผยแพร่อย่างชัดเจน (ไฟล์ การเชื่อมต่อฐานข้อมูล การเชื่อมต่อเครือข่าย ฯลฯ)

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

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

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

ประโยชน์ของการเขียนโปรแกรมเชิงวัตถุ

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

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

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

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

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


แผนภาพคลาสหรือลำดับชั้นการสืบทอด "ยานพาหนะ" สี่เหลี่ยมสีขาวแสดงถึงคลาสนามธรรม

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

อินเทอร์เฟซ- ในภาษาการเขียนโปรแกรมบางภาษา (C#, Java) แนวคิดของอินเทอร์เฟซถูกกำหนดไว้อย่างชัดเจน - ไม่ใช่เฉพาะวิธีการสาธารณะและคุณสมบัติของคลาสเท่านั้น ตามกฎแล้วภาษาดังกล่าวไม่รองรับการสืบทอดหลายรายการและชดเชยสิ่งนี้โดยอนุญาตให้วัตถุใด ๆ มีวัตถุฐานเดียวและใช้อินเทอร์เฟซจำนวนเท่าใดก็ได้ ในการตีความ อินเทอร์เฟซเป็นเหมือนคลาสนามธรรมที่มีเพียงคำอธิบาย (ลายเซ็น) ของวิธีการและคุณสมบัติสาธารณะ การใช้อินเทอร์เฟซตกอยู่ภายใต้ภาระของแต่ละคลาสที่ต้องการรองรับ อินเทอร์เฟซเดียวกันสามารถนำไปใช้โดยคลาสที่มีลำดับชั้นที่แตกต่างกันโดยสิ้นเชิง ซึ่งจะขยายความเป็นไปได้ของความหลากหลาย ตัวอย่างเช่น อินเทอร์เฟซ "การบันทึก/กู้คืนข้อมูลในฐานข้อมูล" สามารถนำไปใช้โดยทั้งสองคลาสของลำดับชั้น "เฟอร์นิเจอร์" และคลาสที่เกี่ยวข้องกับการสั่งซื้อการผลิตเฟอร์นิเจอร์ และเมื่อคุณคลิกที่ปุ่ม "บันทึก" โปรแกรมจะผ่านออบเจ็กต์ทั้งหมด ถามอินเทอร์เฟซนี้และเรียกใช้เมธอดที่เกี่ยวข้อง

การเขียนโปรแกรมเชิงวัตถุมีการพัฒนาอย่างต่อเนื่อง ก่อให้เกิดกระบวนทัศน์ใหม่ๆ เช่น การเขียนโปรแกรมเชิงมุมมอง เชิงหัวเรื่อง และแม้กระทั่งการเขียนโปรแกรมเชิงเอเจนต์ ควรสังเกตว่ารางวัล OOP หลอกหลอนนักทฤษฎีคนอื่น ๆ และพวกเขารีบเสนอทางเลือกของตนเองในการปรับปรุงและขยาย ฉันเขียนบันทึกแยกต่างหากเกี่ยวกับเรื่องนี้ แต่ตอนนี้ฉันอยากจะพูดสองสามคำเกี่ยวกับการเขียนโปรแกรมต้นแบบซึ่งใช้ภาษาฝั่งไคลเอ็นต์ JavaScript การเขียนโปรแกรมต้นแบบกำจัดแนวคิดของคลาส โดยแทนที่ด้วยต้นแบบ - ตัวอย่างของออบเจ็กต์ ดังนั้นในภาษาที่เน้นต้นแบบจึงไม่มีแนวคิดเกี่ยวกับประเภทวัตถุ แต่มีแนวคิดเกี่ยวกับรูปแบบหรือต้นแบบ ต้นแบบเป็นอินสแตนซ์ของออบเจ็กต์ที่สร้างอินสแตนซ์อื่นโดยการคัดลอก (โคลน) สมาชิก ใน JavaScript คุณไม่ได้อธิบายฟิลด์และวิธีการของคลาส แต่ก่อนอื่นให้สร้างอ็อบเจ็กต์ว่าง จากนั้นจึงเพิ่มฟิลด์และวิธีการที่จำเป็นลงไป (ใน JavaScript สามารถกำหนดและเพิ่มเมธอดลงในอ็อบเจ็กต์แบบไดนามิกได้) ในทำนองเดียวกัน มีการสร้างต้นแบบขึ้น ซึ่งวัตถุอื่นจะอ้างอิงว่าเป็นต้นแบบ หากออบเจ็กต์ไม่มีเมธอดหรือฟิลด์ที่ระบุในตำแหน่งการโทร วัตถุนั้นจะถูกค้นหาในกลุ่มสมาชิกของต้นแบบ ฉันก็อธิบายแยกกันด้วย

องค์ประกอบบางประการของการเขียนโปรแกรมเชิงวัตถุสมัยใหม่

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

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

ประเภทสากล- แนวคิดของประเภททั่วไปไม่เกี่ยวข้องโดยตรงกับแนวคิดของ OOP แต่เป็นสาเหตุของการปรากฏตัวขององค์ประกอบต่างๆ เช่น คลาสทั่วไป วิธีการทั่วไป เหตุการณ์ทั่วไป ฯลฯ ประเภททั่วไปคือประเภทที่กำหนดพารามิเตอร์ตามประเภทอื่น (ชุดประเภท) ไม่ทราบประเภทพารามิเตอร์นี้ในบริบทของการออกแบบประเภททั่วไป แม้ว่าจะเป็นไปได้ที่จะจำกัดค่าของประเภทพารามิเตอร์โดยบังคับให้มาจากคลาสเฉพาะหรือใช้อินเทอร์เฟซบางอย่าง ตัวอย่างคือคลาสสากลสำหรับการเรียงลำดับองค์ประกอบ โดยไม่ทราบประเภทขององค์ประกอบในลำดับล่วงหน้า เมื่อออกแบบคลาสดังกล่าว สิ่งสำคัญคือต้องระบุว่าประเภทพารามิเตอร์ต้องสนับสนุนการดำเนินการเปรียบเทียบ เมื่อสร้างอ็อบเจ็กต์ประเภททั่วไป คุณจะต้องระบุพารามิเตอร์อย่างชัดเจน เช่น ประเภทจำนวนเต็มหรือสตริง และอ็อบเจ็กต์เองก็เริ่มทำงานราวกับว่าเป็นอินสแตนซ์ของคลาสที่สร้างขึ้นโดยเฉพาะสำหรับการเรียงลำดับจำนวนเต็มหรือสตริง

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

ข้อเสียของการเขียนโปรแกรมเชิงวัตถุ

ฉันได้กล่าวไปแล้วว่าความนิยมของแนวทางเชิงวัตถุนั้นมีมหาศาล ฉันยังได้ตั้งข้อสังเกตไว้แล้วว่ามีคนจำนวนมากที่ต้องการขยายกระบวนทัศน์นี้ แต่มีอีกวิธีหนึ่งที่จะโดดเด่นท่ามกลางชุมชนผู้เชี่ยวชาญด้านเทคโนโลยีสารสนเทศขนาดใหญ่ - นี่คือการประกาศว่า OOP ไม่ได้พิสูจน์ตัวเองว่ามันไม่ใช่ยาครอบจักรวาล แต่เป็นยาหลอก ในบรรดาคนเหล่านี้มีผู้เชี่ยวชาญระดับสูงเช่น Alexander Stepanov, Edsger Dijkstra และคนอื่น ๆ และความคิดเห็นของพวกเขาสมควรได้รับความสนใจ แต่ก็มีคนที่พวกเขาพูดว่า "มีบางอย่างขัดขวางนักเต้นที่ไม่ดีเสมอ ” นี่คือข้อเสียที่ชัดเจนที่สุดของ OOP ซึ่งผู้เชี่ยวชาญชี้ให้เห็น:

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

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

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

(ตามที่ OOP ย่อมาจาก) ประการแรกคือกระบวนทัศน์การเขียนโปรแกรม
กระบวนทัศน์การเขียนโปรแกรมกำหนดวิธีที่โปรแกรมเมอร์เห็นการทำงานของโปรแกรม
ดังนั้น กระบวนทัศน์ OOP จึงมีลักษณะเฉพาะคือโปรแกรมเมอร์มองว่าโปรแกรมเป็นชุดของวัตถุที่มีการโต้ตอบ ในขณะที่ ตัวอย่างเช่น ในการเขียนโปรแกรมเชิงฟังก์ชัน โปรแกรมจะแสดงเป็นลำดับของการคำนวณฟังก์ชัน การเขียนโปรแกรมเชิงขั้นตอน หรือที่เรียกอย่างถูกต้องว่า การเขียนโปรแกรมเชิงปฏิบัติการแบบคลาสสิก เกี่ยวข้องกับการเขียนอัลกอริทึมเพื่อแก้ปัญหา ในกรณีนี้จะไม่มีการอธิบายหรือระบุคุณสมบัติที่คาดหวังของผลลัพธ์สุดท้าย การเขียนโปรแกรมแบบมีโครงสร้างโดยพื้นฐานแล้วเป็นไปตามหลักการเดียวกันกับการเขียนโปรแกรมตามขั้นตอน โดยมีเทคนิคที่เป็นประโยชน์บางประการเพิ่มเข้ามา
กระบวนทัศน์การเขียนโปรแกรมที่ไม่ใช่ขั้นตอน ซึ่งรวมถึงกระบวนทัศน์เชิงวัตถุ มีแนวคิดที่แตกต่างไปจากเดิมอย่างสิ้นเชิง
คำจำกัดความของ Gradi Bucha อ่านว่า: “ การเขียนโปรแกรมเชิงวัตถุเป็นวิธีการเขียนโปรแกรมที่มีพื้นฐานอยู่บนการแสดงโปรแกรมเป็นคอลเลกชันของอ็อบเจ็กต์ ซึ่งแต่ละคลาสเป็นการดำเนินการของคลาสเฉพาะ (ชนิดพิเศษ) และคลาสสร้างลำดับชั้นตามหลักการของการถ่ายทอดทางพันธุกรรม”
การเขียนโปรแกรมเชิงโครงสร้างและเชิงวัตถุขึ้นอยู่กับวิธีการทางวิทยาศาสตร์ที่เรียกว่า การสลายตัว- วิธีการที่ใช้โครงสร้างของปัญหาและช่วยให้คุณสามารถแยกวิธีแก้ปัญหาของปัญหาใหญ่ทั่วไปออกเป็นการแก้ปัญหาลำดับของปัญหาเล็ก ๆ การสลายตัวของ OOPเกิดขึ้นไม่ได้ขึ้นอยู่กับอัลกอริธึม แต่ขึ้นอยู่กับวัตถุที่ใช้ในการแก้ปัญหา การสลายตัวนี้จะลดขนาดของระบบซอฟต์แวร์โดยการนำกลไกทั่วไปกลับมาใช้ใหม่ เป็นที่ทราบกันดีว่าระบบการเขียนโปรแกรมด้วยภาพหรือระบบที่สร้างขึ้นบนหลักการของการเขียนโปรแกรมเชิงวัตถุมีความยืดหยุ่นมากกว่าและพัฒนาได้ง่ายขึ้นเมื่อเวลาผ่านไป

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

วันนี้มีจำนวนเพียงพอ ภาษาโปรแกรมเชิงวัตถุซึ่งความนิยมสูงสุดในปัจจุบัน ได้แก่ C++, Delphi, Java, Visual Basic, Flash แต่นอกจากนี้ หลายภาษาที่มักจัดว่าเป็นกระบวนทัศน์ก็มีคุณสมบัติ OOP เช่นกัน คือสามารถทำงานกับวัตถุได้ ดังนั้นการเขียนโปรแกรมเชิงวัตถุในภาษา C จึงเป็นส่วนใหญ่ของการเขียนโปรแกรมในภาษานี้ เช่นเดียวกับ OOP ใน Python และภาษาที่มีโครงสร้างอื่นๆ อีกมากมาย

เมื่อพูดถึง OOP มักมีคำจำกัดความอื่นเกิดขึ้น - การเขียนโปรแกรมภาพ- นอกจากนี้ยังจัดให้มีการใช้งานต้นแบบอ็อบเจ็กต์อย่างกว้างขวาง ซึ่งถูกกำหนดให้เป็นคลาสอ็อบเจ็กต์
กิจกรรมสภาพแวดล้อมการเขียนโปรแกรมด้วยภาพจำนวนมากใช้คุณลักษณะ (นอกเหนือจากการห่อหุ้ม ความหลากหลาย และการสืบทอด) ของอ็อบเจ็กต์ - เหตุการณ์ เหตุการณ์ในการเขียนโปรแกรมเชิงวัตถุคือความสามารถในการประมวลผลข้อความ (หรือเหตุการณ์) ที่ได้รับจากระบบปฏิบัติการ Windows หรือตัวโปรแกรมเอง หลักการนี้เป็นเรื่องปกติสำหรับส่วนประกอบทั้งหมดของสภาพแวดล้อมที่ประมวลผลเหตุการณ์ต่างๆ ที่เกิดขึ้นระหว่างการทำงานของโปรแกรม โดยพื้นฐานแล้ว เหตุการณ์คือการกระทำบางอย่างที่กระตุ้นปฏิกิริยามาตรฐานของวัตถุ สามารถพิจารณาเหตุการณ์ได้ เช่น การคลิกปุ่มเมาส์ การเลื่อนเคอร์เซอร์เมาส์ไปเหนือรายการเมนู การเปิดแท็บ เป็นต้น ลำดับการดำเนินการบางอย่างจะถูกกำหนดอย่างแม่นยำโดยเหตุการณ์ที่เกิดขึ้นในระบบและปฏิกิริยาของวัตถุต่อสิ่งเหล่านั้น
คลาสและอ็อบเจ็กต์ใน OOP- แนวคิดต่างๆ แนวคิดของคลาสใน OOP คือประเภทข้อมูล (เหมือนกับเช่น Real หรือ String) และวัตถุเป็นอินสแตนซ์เฉพาะของคลาส (สำเนา) ซึ่งจัดเก็บไว้ในหน่วยความจำคอมพิวเตอร์เป็นตัวแปรประเภทที่เกี่ยวข้อง .
ระดับเป็นชนิดข้อมูลเชิงโครงสร้าง คลาสนี้ประกอบด้วยคำอธิบายของฟิลด์ข้อมูล ตลอดจนขั้นตอนและฟังก์ชันที่ทำงานบนฟิลด์ข้อมูลเหล่านี้ วิธีอ๊อป- สิ่งเหล่านี้เป็นขั้นตอนและหน้าที่ที่เกี่ยวข้องกับคลาส
คลาสมีฟิลด์ (เช่นประเภทข้อมูลบันทึก) คุณสมบัติที่คล้ายกับฟิลด์ แต่มีคำอธิบายเพิ่มเติมที่กำหนดกลไกในการเขียนและการอ่านข้อมูล และวิธีการ - รูทีนย่อยที่มุ่งเปลี่ยนฟิลด์และคุณสมบัติของคลาส

หลักการพื้นฐานของ OOP

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

หลักการสืบทอด OOP และคลาสย่อย

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

ความหลากหลายของ OOP

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

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

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

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

ภาษาขั้นตอน

C, Pascal, FORTRAN และภาษาที่คล้ายกันเป็นขั้นตอน นั่นคือผู้ดำเนินการแต่ละคนสั่งให้คอมพิวเตอร์ทำบางอย่าง: รับข้อมูล เพิ่มตัวเลข หารด้วยหก แสดงผลลัพธ์ แอปพลิเคชันในภาษาขั้นตอนคือรายการคำแนะนำ หากมีขนาดเล็กก็ไม่จำเป็นต้องมีหลักการจัดระเบียบอื่น (มักเรียกว่ากระบวนทัศน์) โปรแกรมเมอร์สร้างรายการคำสั่งและคอมพิวเตอร์ดำเนินการคำสั่งเหล่านั้น

แบ่งออกเป็นฟังก์ชั่น

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

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

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

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

ปัญหาการเขียนโปรแกรมแบบมีโครงสร้าง

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

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

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

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

เข้าถึงได้ไม่จำกัด

ในโปรแกรมที่เขียนด้วยภาษา C จะมีข้อมูลอยู่ 2 ประเภท วัตถุในเครื่องจะถูกซ่อนอยู่ภายในฟังก์ชันและไม่ได้ใช้โดยขั้นตอนอื่น

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

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

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

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

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

การจำลองโลกแห่งความเป็นจริง

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

คุณสมบัติ

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

พฤติกรรม

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

การแก้ปัญหา

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

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

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

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

ควรสังเกตว่าสิ่งที่เรียกว่าฟังก์ชันสมาชิกในภาษา C++ เรียกว่าวิธีการในภาษาเชิงวัตถุอื่นๆ เช่น Smalltalk องค์ประกอบข้อมูลเรียกว่าแอตทริบิวต์ การเรียกเมธอดบนวัตถุกำลังส่งข้อความถึงมัน

การเปรียบเทียบ

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

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

วัตถุใน OOP: คำจำกัดความ

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

สิ่งใดกลายเป็นวัตถุใน OOP ด้านล่างเป็นหมวดหมู่ทั่วไป

วัตถุทางกายภาพใน OOP คือ:

• การขนส่งในรูปแบบการไหล
• องค์ประกอบทางไฟฟ้าในโปรแกรมการออกแบบวงจร
• ประเทศในรูปแบบเศรษฐกิจ
• อากาศยานในระบบควบคุมจราจรทางอากาศ

องค์ประกอบของสภาพแวดล้อมคอมพิวเตอร์ของผู้ใช้:

• เมนู;
• หน้าต่าง;
• กราฟิก (เส้น, สี่เหลี่ยม, วงกลม);
• คีย์บอร์ด เมาส์ เครื่องพิมพ์ ดิสก์ไดรฟ์

• คนงาน;
• นักเรียน;
• ลูกค้า;
• ผู้ขาย

• สมุดบัญชี
• เรื่องส่วนตัว;
• พจนานุกรม;
• ตารางละติจูดและลองจิจูดของพื้นที่ที่มีประชากร

การเชื่อมต่อระหว่างวัตถุในโลกแห่งความเป็นจริงและ OOP เป็นผลมาจากการผสมผสานระหว่างฟังก์ชันและข้อมูล ซึ่งถือเป็นการปฏิวัติการเขียนโปรแกรม ไม่มีการติดต่อกันอย่างใกล้ชิดในภาษาขั้นตอน

ระดับ

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

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

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

มรดก

ในชีวิต ชั้นเรียนแบ่งออกเป็นคลาสย่อย เช่น สัตว์ต่างๆ แบ่งออกเป็น สัตว์ครึ่งบกครึ่งน้ำ สัตว์เลี้ยงลูกด้วยนม นก แมลง เป็นต้น

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

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

ใช้ซ้ำ

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

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

การสร้างชนิดข้อมูลใหม่

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

ตำแหน่ง 1 = ตำแหน่ง + ต้นกำเนิด

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

ความหลากหลาย, โอเวอร์โหลด

ตัวดำเนินการ = (เท่ากับ) และ + (บวก) ที่ใช้ในเลขคณิตตำแหน่งด้านบนจะไม่ทำงานในลักษณะเดียวกับประเภทที่มีอยู่แล้วภายใน เช่น int วัตถุตำแหน่ง ฯลฯ ไม่ได้ถูกกำหนดไว้ล่วงหน้า แต่ถูกกำหนดไว้โดยทางโปรแกรม ผู้ปฏิบัติงานเหล่านี้ทราบวิธีจัดการกับพวกเขาได้อย่างไร? คำตอบก็คือสามารถกำหนดรูปแบบพฤติกรรมใหม่ให้กับพวกเขาได้ การดำเนินการเหล่านี้จะเป็นฟังก์ชันสมาชิกของคลาส Position

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

หนังสือเกี่ยวกับ OOP “Object-Oriented Programming for Dummies” จะช่วยให้ทุกคนคุ้นเคยกับหัวข้อนี้โดยละเอียดยิ่งขึ้น

ข้อมูลทั่วไป

OOP เป็นรูปแบบการเขียนโปรแกรมที่ปรากฏในยุค 80 ของศตวรรษที่ 20 ต่างจากภาษาขั้นตอนที่ข้อมูลและคำแนะนำสำหรับการประมวลผลแยกกัน ในการเขียนโปรแกรมเชิงวัตถุข้อมูลนี้จะรวมกันเป็นเอนทิตีเดียว

หลักการพื้นฐานของ OOP

มรดก

หลักการที่สองของ OOP คือการสืบทอดคือความสามารถของคลาสหนึ่งในการใช้วิธีการของคลาสอื่นโดยไม่ต้องทำซ้ำการใช้งานจริง การสืบทอดช่วยให้คุณกำจัดความซ้ำซ้อนในซอร์สโค้ด

ความแตกต่าง

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

ภาษาอ๊ะ

หลักการ OOP ใช้ในภาษาโปรแกรมยอดนิยมเช่น C++ และ Java ซึ่งมีการพัฒนาส่วนสำคัญของโปรแกรมและแอปพลิเคชัน นอกจากนี้ยังมีภาษา OOP ที่ใช้น้อยเช่น Delphi, Object Pascal, Ruby และอื่น ๆ อีกมากมาย

คำติชมของ OOP

แม้จะมีข้อความเชิงบวกเป็นส่วนใหญ่ต่อวิธีการนี้ แต่หลักการของ OOP ก็มักถูกวิพากษ์วิจารณ์ เช่นเดียวกับ OOP ก็มีข้อเสีย

ประการแรก ความยากของการเปลี่ยนแปลง จะต้องใช้เวลาค่อนข้างมากในการทำความเข้าใจหลักการของ OOP โดยเฉพาะสำหรับผู้ที่ทำงานอย่างใกล้ชิดกับภาษาโปรแกรมขั้นตอนเท่านั้น

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

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

ในการทำเช่นนี้ ฉันพยายามอธิบายแนวคิดพื้นฐานของ OOP (คลาส วัตถุ อินเทอร์เฟซ สิ่งที่เป็นนามธรรม การห่อหุ้ม การสืบทอด และความหลากหลาย) โดยใช้ตัวอย่างสดไม่มากก็น้อย

ส่วนแรกด้านล่างเป็นเรื่องเกี่ยวกับคลาส วัตถุ และอินเทอร์เฟซ
ส่วนที่สองแสดงให้เห็นถึงการห่อหุ้ม ความหลากหลาย และการสืบทอด

แนวคิดพื้นฐานของ OOP

ระดับ

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

ระดับเป็นวิธีการอธิบายเอนทิตีที่กำหนดสถานะและพฤติกรรมที่ขึ้นอยู่กับสถานะนี้ รวมถึงกฎสำหรับการโต้ตอบกับเอนทิตีนี้ (สัญญา)

จากมุมมองของการเขียนโปรแกรม คลาสสามารถถือเป็นชุดของข้อมูล (ฟิลด์ คุณลักษณะ สมาชิกของคลาส) และฟังก์ชันสำหรับการทำงานกับข้อมูลเหล่านั้น (วิธีการ)

จากมุมมองของโครงสร้างของโปรแกรม คลาสเป็นประเภทข้อมูลที่ซับซ้อน

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

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

วัตถุ

วัตถุ (อินสแตนซ์)เป็นตัวแทนรายบุคคลของชั้นเรียนที่มีสถานะและพฤติกรรมเฉพาะที่กำหนดโดยชั้นเรียนทั้งหมด

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

อินเทอร์เฟซ

อินเทอร์เฟซคือชุดของวิธีการเรียนที่คลาสอื่นสามารถใช้ได้

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

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

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