แนวคิดและตัวอย่าง OOP ที่โปรแกรมเมอร์ทุกคนควรรู้
เผยแพร่แล้ว: 2021-02-26ในบทความนี้ เราจะครอบคลุมแนวคิดพื้นฐานเกี่ยวกับการเขียนโปรแกรมเชิงวัตถุ และอภิปรายคำศัพท์ที่ใช้กันทั่วไป: นามธรรม การห่อหุ้ม การสืบทอด และความหลากหลาย
ในการเริ่มต้น OOP เป็นวิธีการเขียนโปรแกรมที่ต้องการให้โปรแกรมเมอร์สร้างวัตถุและใช้งานตลอดทั้งโปรแกรมภายในฟังก์ชันที่ต้องใช้วัตถุดังกล่าวสำหรับการทำงาน เหตุผลที่แนวคิด OOPs ถูกใช้อย่างกว้างขวางใน java ก็คือช่วยให้โค้ดสามารถนำกลับมาใช้ใหม่ได้ในขณะที่ยังคงรักษาความปลอดภัยไว้
ก่อนที่เราจะพูดถึงสี่เสาหลักของการเขียนโปรแกรมเชิงวัตถุ ให้เราทำความคุ้นเคยกับคำศัพท์ทั่วไปที่เราได้ยินบ่อยมากเมื่อใช้ภาษาเชิงวัตถุ: Java, python, c++
สารบัญ
ระดับ
คลาสคือคอลเล็กชันของอ็อบเจ็กต์ที่กำหนดชุดของคุณสมบัติที่เหมือนกันกับอ็อบเจ็กต์ทุกประเภทเฉพาะ เรียกอีกอย่างว่าพิมพ์เขียวสำหรับสร้างวัตถุ คลาสประกอบด้วยองค์ประกอบต่อไปนี้:
ชื่อชั้นเรียน: ชื่อที่กำหนดให้กับชั้นเรียนที่ขึ้นต้นด้วยอักษรตัวใหญ่
ตัวดัดแปลง: ขึ้นอยู่กับการทำงานของตัวดัดแปลงคลาสอาจเป็นแบบสาธารณะ ส่วนตัว หรือค่าเริ่มต้นก็ได้
เนื้อหา : เนื้อหาของคลาสมีรหัสทั้งหมดบนวัตถุที่มีอยู่ในชั้นเรียน ซึ่งอาจอยู่ในช่วงตั้งแต่การประกาศตัวแปรหรือการสร้างตัวสร้างหรือวิธีการที่มีการทำงานของวัตถุ
วัตถุ
ออบเจ็กต์ถูกกำหนดให้เป็นอินสแตนซ์ของคลาสและมีเอนทิตีในชีวิตจริง ตัวอย่างเช่น สำหรับคลาสที่เรียกว่า สัตว์ วัตถุจะเป็นแมว สุนัข ช้าง et al. แต่ละอ็อบเจ็กต์มีเอกลักษณ์ คุณลักษณะ และพฤติกรรมของตัวเอง โค้ดด้านล่างแสดงการใช้คลาส อ็อบเจ็กต์ และเมธอดขณะเขียนโปรแกรมในภาษาจาวา
วิธีการ
เมธอดถูกกำหนดไว้ภายในคลาสและใช้เพื่อทำหน้าที่เฉพาะ วิธีการนี้อาจมีหรือไม่มีพารามิเตอร์อินพุตก็ได้ โค้ดด้านล่างแสดงการใช้คลาส อ็อบเจ็กต์ และเมธอดขณะเขียนโปรแกรมในภาษาจาวา
ในโค้ดด้านบน Player เป็นชื่อที่กำหนดให้คลาสของเรา ในขณะที่รันเป็นพารามิเตอร์ที่ส่งผ่านในวิธี Batsman ซึ่งจะคืนค่าการวิ่งที่ทำคะแนนโดยเขาเมื่อถูกเรียกผ่านวัตถุที่เรียกว่า myobj
ตัวแก้ไขการเข้าถึง
ตัวดัดแปลงการเข้าถึงใน Java กำหนดความสามารถในการเข้าถึงหรือขอบเขตของวิธีการหรือตัวสร้างหรือคลาส ตัวแก้ไขการเข้าถึงสี่ประเภทคือ:
- สาธารณะ : รหัสที่เขียนภายในชั้นเรียนสามารถเข้าถึงได้จากชั้นเรียนอื่น
- ส่วนตัว : รหัสที่เขียนสามารถเข้าถึงได้เฉพาะในชั้นเรียนนั้นเท่านั้น
- ค่าเริ่มต้น : รหัส ที่ เขียนสามารถเข้าถึงได้ภายในแพ็คเกจเดียวกัน
- ป้องกัน : รหัสสามารถเข้าถึงได้ภายในแพ็คเกจและผ่านคลาสย่อย ในกรณีที่ไม่มีคลาสย่อย จะไม่สามารถเข้าถึงรหัสได้
ตอนนี้ เรามาพูดถึงประเด็นสำคัญของการเขียนโปรแกรมเชิงวัตถุกัน
มรดก
คำว่ามรดกหมายถึงการสืบทอดคุณสมบัติของชั้นหนึ่งไปยังอีกชั้นหนึ่ง คุณสมบัติอ้างถึงแอตทริบิวต์และวิธีการของคลาสพาเรนต์ คลาสพาเรนต์คือคลาสนั้นที่มีคุณสมบัติที่ต้องการสืบทอดโดยคลาสอื่น คลาสที่สืบทอดคุณสมบัติของคลาสพาเรนต์จะเรียกว่าคลาสย่อยหรือคลาสย่อย ในการสืบทอดคุณสมบัติของคลาสพาเรนต์ไปยังคลาสย่อย จะใช้คีย์เวิร์ดที่ ชื่อว่า extends
ในตัวอย่างข้างต้น สปอนเซอร์คือคลาสพาเรนต์โดยที่เจ้าของเป็นแอททริบิวต์ เราได้สร้างคลาสย่อยที่เรียกว่า Team ซึ่งสืบทอดคลาสหลัก - สปอนเซอร์ เราได้สร้างวัตถุของ Team ที่สามารถเข้าถึงคุณสมบัติของคลาสหลักได้ ผลลัพธ์ของรหัสข้างต้นคือ:
ความหลากหลาย
ตามชื่อที่แนะนำ- ความหลากหลายคือความสามารถของตัวแปรหรือฟังก์ชันที่มีอยู่ในหลายรูปแบบ ความหลากหลายช่วยให้โปรแกรมเมอร์ทำงานที่แตกต่างกันโดยใช้ตัวแปรหรือฟังก์ชันเดียวกัน ตัวอย่างในชีวิตจริงของ polymorphism จะพิจารณาว่าเป็นพื้นที่เปิดโล่ง ตอนนี้พื้นนี้สามารถใช้สำหรับการเล่นกีฬาได้
นอกจากนี้ยังสามารถใช้จัดงานแต่งงานและคอนเสิร์ตได้อีกด้วย สุดท้ายนี้พื้นเดียวกันสามารถใช้สำหรับจอดรถได้ จากนี้ เราสามารถอนุมานได้ว่าตัวแปรเดียวสามารถมีการใช้งานได้หลายอย่างขึ้นอยู่กับการใช้งาน
ความแตกต่างที่เรามักเจอในสองคำคือ - วิธีการโอเวอร์โหลด และ วิธี การ เอาชนะ
ใน Method Overloading วิธี เดียวสามารถใช้ได้หลายวิธีและทำหน้าที่ต่างๆ เมธอดจะมีชื่อเหมือนกัน แต่พารามิเตอร์ต่างๆ สามารถใช้เป็นอินพุตได้
ใน Method Overriding เมธอดของคลาสพาเรนต์สามารถแทนที่โดยคลาสย่อยได้ ด้วยวิธีนี้ เมธอดเดียวกันสามารถทำงานแตกต่างกันเมื่อถูกเรียกโดยคลาสพาเรนต์และคลาสย่อย
ตัวอย่างของ polymorphism แสดงไว้ด้านล่าง:
ในตัวอย่างนี้ การใช้วิธีการเดียวกันนี้ เราสามารถทำงานหลายอย่างได้ วิธีเดียวกันกับเสียงเมื่อใช้ใน Bird จะส่งออก "Turr Turr" และเมื่อใช้กับ Duck จะส่งออก "Quack Quack" สแนปชอตของเอาต์พุตแสดงอยู่ด้านล่าง -
สิ่งที่เป็นนามธรรม
สิ่งที่เป็นนามธรรมคือกระบวนการซ่อนข้อมูลบางอย่างจากผู้ใช้และแสดงเฉพาะข้อมูลที่จำเป็นต่อพวกเขา ตัวอย่างเช่น ขณะขับรถ เราไม่กังวลเกี่ยวกับการทำงานหรือกลไกภายใน สิ่งที่แสดงให้เห็นคือความเร็วในการขับขี่รถยนต์และปริมาณน้ำมันเบนซินที่มีอยู่ ข้อมูลส่วนขอบอื่น ๆ ทั้งหมดจะไม่แสดงให้ผู้ขับขี่เห็น
คีย์เวิร์ด abstract ใช้สำหรับเมธอดและคลาสขณะดำเนินการ abstraction สำหรับคลาสนามธรรม เราไม่สามารถสร้างอ็อบเจ็กต์ในขณะที่เมธอด abstract ไม่ควรมีเนื้อหา หากกฎข้อใดข้อหนึ่งถูกละเมิด ผลลัพธ์จะทำให้เกิดข้อผิดพลาด
ที่นี่ เราได้สร้างวัตถุของคลาสย่อย - Duck ซึ่งสืบทอดมาจากคลาสหลัก - Bird ผลลัพธ์ที่แสดงด้านล่าง:
การห่อหุ้ม
การห่อหุ้มเป็นกระบวนการผูกรหัสและข้อมูลเข้าด้วยกันเป็นหน่วยเดียว ที่นี่ ตัวแปรของคลาสถูกซ่อนจากคลาสอื่น (โดยใช้คีย์เวิร์ด private ) แต่สามารถเข้าถึงได้ผ่านฟังก์ชันสมาชิกเท่านั้น ฟังก์ชัน Setter และ getter ใช้เพื่อเข้าถึงตัวแปรส่วนตัวของคลาสที่เป็นนามธรรม
จนถึงขณะนี้ เราได้ครอบคลุมทุกอย่างที่เกี่ยวข้องกับการเขียนโปรแกรมเชิงวัตถุโดยใช้ Java ก่อนที่เราจะสรุป ให้เราดูข้อดีบางประการของแนวคิด OOP
- โค้ดนี้สามารถนำกลับมาใช้ใหม่ได้อย่างง่ายดาย ดังนั้นจึงช่วยประหยัดเวลาและค่าใช้จ่ายในการพัฒนาโค้ดได้มาก
- ช่วยในการออกแบบโค้ดในลักษณะที่มีโครงสร้างที่ดีเพื่อให้โปรแกรมเมอร์ใหม่ไม่ต้องใช้เวลานานหลายชั่วโมงในการทำความเข้าใจโค้ด
- นอกจากจะช่วยให้ผู้ใช้เขียนโค้ดได้อย่างมีประสิทธิภาพแล้ว ยังช่วยให้แน่ใจว่าความปลอดภัยจะไม่ถูกบุกรุก
ชำระเงิน: คำถามและคำตอบสัมภาษณ์ OOPs
เรียนรู้ หลักสูตรซอฟต์แวร์ออนไลน์ จากมหาวิทยาลัยชั้นนำของโลก รับโปรแกรม PG สำหรับผู้บริหาร โปรแกรมประกาศนียบัตรขั้นสูง หรือโปรแกรมปริญญาโท เพื่อติดตามอาชีพของคุณอย่างรวดเร็ว
บทสรุป
โดยสรุป ในบล็อกนี้ เราได้กล่าวถึงแนวคิดพื้นฐานของ OOP แนวคิดเหล่านี้ใช้กันอย่างแพร่หลายในอุตสาหกรรมและการใช้งานอื่นๆ เพื่อที่จะเป็นโปรแกรมเมอร์ที่เชี่ยวชาญ เราควรเข้าใจแนวคิดเหล่านี้อย่างถ่องแท้ ในบล็อกที่กำลังจะมาถึง เราจะเปิดเผยแนวคิดการเขียนโปรแกรมที่สำคัญอื่นๆ อีกหลายประการที่จะช่วยให้คุณพัฒนาความเชี่ยวชาญในโดเมนนี้
หากคุณสนใจที่จะเรียนรู้เพิ่มเติมเกี่ยวกับการพัฒนาซอฟต์แวร์ฟูลสแตก โปรดดูโปรแกรม Executive PG ของ upGrad & IIIT-B ในการพัฒนาซอฟต์แวร์ฟูลสแตก ซึ่งออกแบบมาสำหรับมืออาชีพที่ทำงานและมีการฝึกอบรมที่เข้มงวดมากกว่า 500 ชั่วโมง โครงการมากกว่า 9 โครงการ และ การมอบหมายงาน สถานะศิษย์เก่า IIIT-B โครงการหลักที่ปฏิบัติได้จริง และความช่วยเหลือด้านงานกับบริษัทชั้นนำ] แฟกทอเรียลคือการดำเนินการทางคณิตศาสตร์ที่นับผลคูณของตัวเลขที่ระบุและตัวเลขทั้งหมดที่อยู่ด้านล่าง แฟกทอเรียลคือผลคูณที่ระบุจำนวนครั้งที่คูณตัวเลขด้วยหนึ่ง ตัวอย่างเช่น แฟกทอเรียลของ 5 คือ 5x4x3x2x1 ซึ่งเท่ากับ 120 แฟกทอเรียลของ 1 คือ 1 และแฟคทอเรียลของ 0 ก็คือ 1 โปรแกรมหาแฟกทอเรียลของตัวเลขเป็นคำถามสัมภาษณ์ที่พบบ่อยที่สุดและเป็นอะไรบางอย่าง ที่ควรอยู่ในมือคุณ แฟกทอเรียลของจำนวน n ถูกกำหนดเป็น n! = 1 × 2 × 3 × 4 × … × น. แฟกทอเรียลของ 5 คือ 120 ฟังก์ชันแฟกทอเรียลถูกกำหนดเป็นแฟกทอเรียล(5) = 120 ฟังก์ชันแบบเรียกซ้ำคือฟังก์ชันที่เรียกตัวเอง นี่คือตัวอย่างของฟังก์ชันแฟกทอเรียลในรูปแบบเรียกซ้ำ factorial(n) = n * factorial(n - 1) การเขียนโปรแกรมเรียกซ้ำแบบแฟกทอเรียลนั้นง่ายมาก และโค้ดก็คล้ายกับเวอร์ชันวนซ้ำมาก ในการเขียนเวอร์ชันวนซ้ำ เราใช้ตัวแปรที่เรียกว่า n และเพิ่มขึ้นทีละหนึ่งแล้วคูณด้วยตัวแปรที่เรียกว่า prod ซึ่งจะคอยติดตามค่าที่ต่อเนื่องกันของ n ค่าเอาต์พุตยังถูกเก็บไว้ในตัวแปรที่เรียกว่า prod ในเวอร์ชันแบบเรียกซ้ำ คุณยังคงใช้ตัวแปรที่เรียกว่า n อย่างไรก็ตาม คุณไม่จำเป็นต้องมีตัวแปรในการจัดเก็บค่าของ prod และคุณสามารถคืนค่า prod จากฟังก์ชันได้โดยตรง การเรียกซ้ำคำมาจากคำภาษาละติน recurrere ซึ่งหมายถึงการกลับมา ในภาษาโปรแกรมส่วนใหญ่ ฟังก์ชันที่เรียกตัวเองว่าการเรียกซ้ำ กระบวนการวนซ้ำนี้ดำเนินต่อไปจนกว่าจะถึงกรณีฐาน ซึ่งไม่ได้กำหนดไว้ในฟังก์ชันแบบเรียกซ้ำใดๆ การเรียกซ้ำเป็นเทคนิคที่มีประสิทธิภาพในการแก้ปัญหาอย่างมีโครงสร้างและเป็นระเบียบ เป็นกลยุทธ์การเขียนโปรแกรมที่ดี ตัวอย่างเช่น ปัญหาอนุกรมฟีโบนักชี ปัญหาแฟกทอเรียล ฯลฯ สามารถแก้ไขได้ทั้งแบบวนซ้ำและแบบเรียกซ้ำ แฟคทอเรียลคืออะไร?
จะเขียนโปรแกรมเรียกซ้ำแบบแฟกทอเรียลได้อย่างไร?
การเรียกซ้ำในการเขียนโปรแกรมคืออะไร?