คุณสามารถอธิบายความแตกต่างระหว่างการเขียนโปรแกรมตามขั้นตอนและ OOP ได้หรือไม่


ตอบ 1:

คำถามเดิม:

คุณสามารถอธิบายความแตกต่างระหว่างการเขียนโปรแกรมตามขั้นตอนและ OOP ได้หรือไม่

ตอบ:

ก่อนอื่นเรามากำหนดความหมายของโพรซีเดอร์และการเขียนโปรแกรมเชิงวัตถุ

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

ตอนนี้เรามากำหนด Object Oriented Programming

คำจำกัดความ - การเขียนโปรแกรมเชิงวัตถุ (OOP) หมายถึงอะไรการเขียนโปรแกรมเชิงวัตถุ (OOP) เป็นรูปแบบการเขียนโปรแกรมซอฟต์แวร์ที่สร้างขึ้นรอบ ๆ วัตถุ โมเดลนี้แบ่งข้อมูลลงในวัตถุ (เขตข้อมูล) และอธิบายเนื้อหาของวัตถุและพฤติกรรมผ่านการประกาศคลาส (วิธีการ) คุณสมบัติ OOP ประกอบด้วยสิ่งต่อไปนี้: การห่อหุ้ม: สิ่งนี้ทำให้โครงสร้างโปรแกรมง่ายต่อการจัดการเนื่องจากการใช้งานและสถานะของวัตถุแต่ละชิ้น ขอบเขตที่กำหนดอย่างชัดเจนความแตกต่าง: นี่หมายถึงเอนทิตีที่เป็นนามธรรมถูกนำมาใช้ในหลาย ๆ วิธีการสืบทอด: นี่หมายถึงการจัดเรียงลำดับชั้นของชิ้นส่วนการใช้งานการเขียนโปรแกรมเชิงวัตถุช่วยให้การเขียนโปรแกรมง่ายขึ้น ประโยชน์ของมันรวมถึงการใช้ซ้ำ, การปรับโครงสร้างใหม่, การเพิ่มความสามารถ, การบำรุงรักษาและประสิทธิภาพ TechTech อธิบายการเขียนโปรแกรมเชิงวัตถุ (OOP) OOP เป็นรูปแบบการเขียนโปรแกรมที่เลือกไว้สำหรับทศวรรษที่ผ่านมาหรือมากกว่า การออกแบบแบบแยกส่วนของ OOP ช่วยให้โปรแกรมเมอร์สามารถสร้างซอฟต์แวร์ในกลุ่มที่สามารถจัดการได้แทนที่จะเป็นรหัสลำดับจำนวนมากข้อดีอย่างหนึ่งของ OOP คือความสามารถในการปรับขยายได้โดยมีวัตถุและคำจำกัดความที่ไม่มีข้อ จำกัด แน่นอน นอกจากนี้การแยกข้อมูลออกจากวิธียังช่วยป้องกันปัญหาทั่วไปที่พบในภาษาซอฟต์แวร์เชิงเส้นแบบเก่า หากมีข้อบกพร่องปรากฏในรหัสเชิงเส้นก็สามารถแปลผ่านระบบและสร้างข้อผิดพลาดที่ยากต่อการติดตามจำนวนมาก ในทางกลับกันโปรแกรม OOP ที่แยกวิธีการและข้อมูลไม่ได้รับผลกระทบจากข้อผิดพลาดที่แพร่หลายเช่นภาษา OOP ที่นิยม ได้แก่ Java กลุ่มตระกูลภาษา C, VB.NET Shop และ Python ภาษา OOP ที่เรียกว่า "บริสุทธิ์" รวมถึง Scala, Ruby, Eiffel, JADE, Smalltalk และ Emerald

ที่มาของคำจำกัดความมาจากการเขียนโปรแกรมเชิงวัตถุ (OOP) คืออะไร? - คำจำกัดความจาก Techopedia และภาษาขั้นตอนคืออะไร - นิยามจาก Techopedia

ตอนนี้ ลองดูที่การใช้งานต่างกันอย่างชาญฉลาด

เราจะเริ่มต้นด้วยขั้นตอนและวิธีที่ง่ายที่สุดในการทำเช่นนี้คือการใช้ภาษา C โดยเฉพาะกับ Arduino เพราะนั่นคือสิ่งที่ฉันรู้

ฉันตัดสินใจใช้บทช่วยสอนการกะพริบแสงเป็นพื้นฐานเพราะเป็นหนึ่งในการติดตั้งขั้นพื้นฐาน

// ฟังก์ชั่นการตั้งค่าจะทำงานหนึ่งครั้งเมื่อคุณกดรีเซ็ตหรือเปิดใช้งานการตั้งค่าโมฆะบอร์ด () {// เริ่มต้นใช้งานขาดิจิตอล LED_BUILTIN เป็นเอาต์พุต pinMode (LED_BUILTIN, OUTPUT); } // ฟังก์ชันลูปรันซ้ำแล้วซ้ำอีกเป็นโมฆะตลอดไป () {digitalWrite (LED_BUILTIN, HIGH); // เปิดไฟ LED (HIGH คือระดับแรงดัน) ล่าช้า (1000); // รอ digitalWrite ตัวที่สอง (LED_BUILTIN, LOW); // ปิดไฟ LED โดยทำให้แรงดันไฟฟ้าต่ำล่าช้า (1,000); // รอสักครู่}

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

เวลาตัวอย่าง C # และ OOP

ใช้ระบบ ใช้ System.Collections.Generic; ใช้ System.Linq; ใช้ System.Text; เนมสเปซ oops {ลูกค้าระดับสาธารณะ {/ / ตัวแปรสมาชิก public int CustID; ชื่อสตริงสาธารณะ ที่อยู่สตริงสาธารณะ // constuctor สำหรับการเริ่มต้นเขตข้อมูลลูกค้า () {CustID = 1101; ชื่อ = "ทอม"; ที่อยู่ = "สหรัฐอเมริกา"; } // วิธีการสำหรับการแสดงบันทึกลูกค้า (ฟังก์ชั่น) โมฆะสาธารณะ displayData () {Console.WriteLine ("ลูกค้า =" + CustID); Console.WriteLine ( "ชื่อ =" + ชื่อ); Console.WriteLine ( "ที่อยู่ =" + ที่อยู่); } // รหัสสำหรับจุดเริ่มต้น}} โปรแกรมคลาส {โมฆะหลักคงที่ (สตริง [] args) {// วัตถุการสร้างอินสแตนซ์ของลูกค้า obj = ลูกค้าใหม่ (); // วิธีการเรียก obj.displayData (); // เขตข้อมูลเรียก Console.WriteLine (obj.CustID); Console.WriteLine (obj.Name); Console.WriteLine (obj.Address); }}}

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


ตอบ 2:

แนวคิด OOPS ใน Java

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


ตอบ 3:

การโปรแกรมเชิงโพรซีเดอร์คือการเขียนโปรแกรมที่มีโพรซีเดอร์เป็นกลไกการทำงานหลัก ฮะ.

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

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

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

ถ้า (เงื่อนไข) {doThisThing ()} อื่น {doThatThing ()}

และ

ในขณะที่ (เงื่อนไข) {keepOnDoingThisThing ()}

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

เลือกทางเลือก

  • ถ้าเป็นอย่างอื่น (สองตัวเลือกขึ้นอยู่กับกรณีบูลีน) หรือสลับ (ตัวเลือกมากมายขึ้นอยู่กับชุดใด ๆ )

การทำซ้ำ

ด้วยขอบเขตที่รู้จัก:

  • สำหรับลูป (มักจะเป็นจำนวนซ้ำ) foreach ลูป (วนซ้ำหลายครั้งตามขนาดของคอลเลกชันบางส่วนอาจจะมากกว่าสมาชิกเอง)

กับขอบเขตที่เฉพาะกิจ:

  • ในขณะที่ทำ (0 หรือมากกว่านั้น) ทำในขณะที่ (1 หรือมากกว่านั้น)

และคนเศร้าที่ไม่เป็นที่นิยม:

  • ออกจากวงเมื่อ

ซึ่งรันรหัสก่อนออกอย่างน้อยหนึ่งครั้งและรหัสหลังจากออกจากศูนย์หรือมากกว่าครั้ง

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

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

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

การเขียนโปรแกรมเชิงวัตถุคือการเขียนโปรแกรมด้วยวัตถุเป็นกลไกหลักที่เป็นนามธรรม ฮะ.

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

วัตถุที่ตั้งอยู่ในหน่วยความจำ เมื่อวัตถุต้องการให้วัตถุอื่นทำอะไรบางอย่างมันจะสร้างข้อความที่ขอและส่งไปยังวัตถุที่ต้องการ ข้อความเป็นวัตถุ วัตถุมีความรับผิดชอบในการรักษาสถานะนั่นคือพวกเขาถือตัวแปร พวกเขาไม่เรียกใช้รหัส เมื่อวัตถุได้รับข้อความมันจะส่งต่อไปยังคลาสของมัน คลาสเป็นวัตถุ ชั้นเรียนมีหน้าที่รับผิดชอบในการสร้างและจัดการวัตถุพวกเขาไม่เรียกใช้รหัส ชั้นส่งข้อความไปยังเมตาคลาสของมัน Metaclasses เป็นวัตถุ Metaclasses มีหน้าที่จัดการวิธีการต่างๆ metaclass พิจารณาวิธีการและค้นหาวิธีการที่สอดคล้องกับข้อความ วิธีการคือวัตถุ ระหว่างทางวัตถุข้อความได้รับการตกแต่งด้วยข้อมูลพิเศษหลายชิ้นรวมถึงการอ้างอิงถึงวัตถุที่ได้รับข้อความ วิธีการมีหน้าที่รับผิดชอบในการเรียกใช้รหัสและใช้อาร์กิวเมนต์ใด ๆ ที่ส่งผ่านในข้อความต้นฉบับเพื่อทำเช่นนั้น วิธีการเรียกใช้รหัสในบริบทของวัตถุที่ได้รับข้อความ รหัสของเมธอดเป็นเพียงสคริปต์ของข้อความเพื่อสร้างและส่งไปยังวัตถุอื่น หาก metaclass ไม่สามารถหาวิธีจับคู่ข้อความได้การค้นหาจะเริ่มต้นขึ้นใน metaclasses ของคลาสพาเรนต์ของคลาสของวัตถุ สิ่งนี้เรียกว่า“ การสืบทอด”

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

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

ในภาษาขั้นตอนคุณอาจดำเนินการบางอย่างกับสมาชิกของคอลเลกชันที่มีรหัสบิตเช่นนี้หลอกรหัส:

foreach (theThing in aCollection) doThisActionOn (theThing)

ใน Smalltalk ทั่วไปสคริปต์ที่เทียบเท่าของการส่งข้อความอาจมีลักษณะเช่นนี้:

aCollection ทำ: [aThing | aThing takeThisAction]

ที่นี่ takeThisAction เป็นข้อความที่ถูกส่งไปยังวัตถุ aThing แต่ละอันในคอลเลกชัน aCollection (โดยวิธีการรหัสภายในวงเล็บเหลี่ยมเป็นบล็อกซึ่งเป็นสิ่งที่ Smalltalk เรียกแลมบ์ดามันเป็นวัตถุ) ถ้าเราเปรียบเทียบทั้งสองเราจะเห็นลักษณะที่สำคัญของการเขียนโปรแกรมเชิงวัตถุในทางตรงกันข้ามกับขั้นตอน:

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

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