แนวคิด OOPs สำหรับผู้เริ่มต้น: อธิบายความแตกต่าง

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

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

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

นิยามความหลากหลาย

คำนิยามพหุสัณฐานที่ง่ายที่สุดคือพหุสัณฐานหมายถึงการมีอยู่ในรูปแบบต่างๆ มีรากศัพท์มาจากภาษากรีกสองคำคือ 'poly' หมายถึง 'มากมาย' และ 'morph' ซึ่งแปลว่า 'รูปแบบ'

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

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

สมมติว่าคุณมีชั้นเรียนที่แสดงวันที่และเวลา ตอนนี้ คุณสร้างวิธีการที่สืบทอดคลาสและแสดงข้อความ “สวัสดี!” พร้อมกับวันที่และเวลา

ตัวอย่าง Polymorphism ใน Java

พิจารณา superclass "Shapes" ที่มีเมธอด "area()" คลาสย่อยภายใต้ "รูปร่าง" สามารถเป็น "สี่เหลี่ยมผืนผ้า" "วงกลม" "สามเหลี่ยม" ฯลฯ และแต่ละคลาสย่อยมีวิธีการคำนวณพื้นที่ การใช้แนวคิดของการสืบทอดและความหลากหลาย คลาสย่อยใช้เมธอด "area()" เพื่อค้นหาสูตรสำหรับการคำนวณพื้นที่ของรูปร่างนั้น ๆ

รูปร่างคลาส {

พื้นที่ว่างเปล่าสาธารณะ () {

System.out.println(“สูตรพื้นที่ของ“);

}

}

คลาสสามเหลี่ยมขยายรูปร่าง {

พื้นที่ว่างเปล่าสาธารณะ () {

System.out.println("สามเหลี่ยมเท่ากับ 1/2 * ฐาน * สูง");

}

}

คลาส Circle ขยายรูปร่าง {

พื้นที่ว่างเปล่าสาธารณะ () {

System.out.println("วงกลมคือ 3.14 * รัศมี * รัศมี ");

}

}

คลาสหลัก {

โมฆะคงที่สาธารณะหลัก (สตริง [] args) {

รูปร่าง myShape = รูปร่างใหม่ (); // สร้างวัตถุรูปร่าง

รูปร่าง myTriangle = สามเหลี่ยมใหม่ (); // สร้างวัตถุสามเหลี่ยม

รูปร่าง myCircle = วงกลมใหม่ (); // สร้างวัตถุวงกลม

myShape.area();

myTriangle.area();

myShape.area();

myCircle.area();

}

}

ผลลัพธ์ของรหัสโปรแกรมข้างต้นจะเป็นดังนี้:

สูตรหาพื้นที่สามเหลี่ยม 1/2 * ฐาน * สูง

สูตรสำหรับพื้นที่ของวงกลมคือ 3.14 * รัศมี * รัศมี

ประเภทของความหลากหลายใน OOPs

ความหลากหลายใน OOPs มีสองประเภท - สแตติก (ความหลากหลายในเวลาคอมไพล์) และไดนามิก (ความหลากหลายรันไทม์)

1. พหุสัณฐานคงที่

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

• เมธอดต้องมีจำนวนพารามิเตอร์ต่างกัน
• ประเภทพารามิเตอร์ต้องแตกต่างกัน ตัวอย่างเช่น ถ้าวิธีหนึ่งยอมรับแบบยาว อีกวิธีหนึ่งยอมรับสตริง
• วิธีการควรยอมรับพารามิเตอร์ในลำดับที่ต่างกัน ตัวอย่างเช่น หากวิธีที่ 1 ยอมรับ Long และ String วิธีที่สองต้องยอมรับ String และ Long

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

ต่อไปนี้เป็นตัวอย่างโค้ด Java เพื่อแสดงความแตกต่างของเวลาคอมไพล์ ในตัวอย่างนี้ วิธีการเพิ่ม () มีพารามิเตอร์สองประเภทที่แตกต่างกันมากเกินไป

แพคเกจ staticPolymorphism;

การเพิ่มชั้นเรียนสาธารณะ

{

โมฆะซัม (int x, int y)

{

int c = x+y;

System.out.println("การบวกเลขสองตัว :" +c); }

โมฆะซัม (int x, int y, int z)

{

int c = x+y+z;

System.out.println("การบวกเลขสามตัว :" +c); }

โมฆะคงที่สาธารณะ main(String[] args)

{

นอกจากนี้ obj = การเพิ่มใหม่ ();

obj.sum ( 45,34);

obj.sum(60, 32, 11);

}

}

ผลลัพธ์ของโปรแกรมข้างต้นจะเป็น:

การบวกเลขสองตัว:79

การบวกเลขสามตัว:103

2. ความหลากหลายแบบไดนามิก

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

ต่อไปนี้เป็นตัวอย่างโค้ด Java เพื่อแสดงความแตกต่างรันไทม์ ในตัวอย่าง มีซูเปอร์คลาส "สัตว์" และสามคลาสย่อย "จิงโจ้" "เสือ" และ "ปลา" คลาสย่อยขยายซูเปอร์คลาสและแทนที่เมธอด “move()” วิธีการ “ย้าย ()” ถูกเรียกโดยตัวแปรอ้างอิงของคลาสหลัก “สัตว์”

สัตว์ประจำชั้น{

โมฆะย้าย(){

System.out.println("สัตว์เคลื่อนไหว");

}

}

คลาสจิงโจ้ขยายสัตว์{

โมฆะย้าย(){

System.out.println("จิงโจ้กระโดด");

}

}

เสือโคร่งขยายสัตว์{

โมฆะย้าย(){

System.out.println("เสือเดิน");

}

}

ปลาชั้นขยายสัตว์{

โมฆะย้าย(){

System.out.println("ปลาว่าย");

}

}

คลาสหลัก{

โมฆะคงที่สาธารณะหลัก (สตริง args[]){

สัตว์ A = สัตว์ใหม่ ();

สัตว์ k = จิงโจ้ใหม่ (); //กำลังอัพ

สัตว์ t = เสือใหม่ (); //กำลังอัพ

สัตว์ f = ปลาใหม่ (); //กำลังอัพ

A.move();

k.move();

t.move();

f.move();

}

}

ผลลัพธ์ของโปรแกรมข้างต้นจะเป็น:

สัตว์เคลื่อนไหว

จิงโจ้กระโดด

เสือเดิน

ปลาว่ายน้ำ

ความหลากหลายใน Python

Polymorphism ใน Python แบ่งเป็น 3 ประเภท ได้แก่ Operator Polymorphism, Function Polymorphism และ Class Polymorphism Python ยังอนุญาตให้มีการแทนที่เมธอดแต่ไม่รองรับเมธอดโอเวอร์โหลด

1. ความหลากหลายของตัวดำเนินการ

ใน Python ตัวดำเนินการ '+' มีการใช้งานแบบคู่ มันถูกใช้สำหรับการดำเนินการบวกเลขคณิตในกรณีของชนิดข้อมูลจำนวนเต็ม และสำหรับสตริง ตัวดำเนินการ '+' จะดำเนินการต่อกัน

ต่อไปนี้เป็นตัวอย่างโค้ด Python ที่ตัวดำเนินการ '+' ทำการบวกกับประเภทข้อมูลจำนวนเต็ม:

num1 = 4

num2 = 5

พิมพ์(หมายเลข1+หมายเลข2)

ผลลัพธ์ของรหัสโปรแกรมด้านบนคือ '9'

ต่อไปนี้เป็นตัวอย่างโค้ด Python ที่ตัวดำเนินการ '+' ทำการต่อข้อมูลประเภทสตริง:

str1 = “ดี”

str2 = “ตอนเย็น”

พิมพ์ (str1+” “+str2)

ผลลัพธ์ของโปรแกรมด้านบนจะเป็น 'Good Evening'

2. ฟังก์ชันพหุสัณฐาน

ฟังก์ชัน 'len()' ใน Python เข้ากันได้กับข้อมูลประเภทต่างๆ เช่น list, string, tuple, dictionary และ set แต่จะคืนค่าข้อมูลเฉพาะสำหรับข้อมูลแต่ละประเภท นี่คือตัวอย่าง:

พิมพ์(len("โปรแกรมเมอร์"))

พิมพ์ (เลน (["Python", "Java", "C"]))

พิมพ์ (เลน ({"ชื่อ": "เคธี", "ที่อยู่": "เท็กซัส"}))

โปรแกรมข้างต้นจะมีผลลัพธ์ดังต่อไปนี้:

9

3

2

3. ความหลากหลายทางชนชั้น

การขยายแนวคิดของความหลากหลาย Python อนุญาตให้หลายคลาสมีเมธอดที่มีชื่อเดียวกัน รับด้านล่างเป็นตัวอย่างเพื่อแสดงความหลากหลายในวิธีการเรียนใน Python ในตัวอย่าง มีสองคลาสคือ 'Cat' และ 'Dog' พวกเขามีโครงสร้างที่คล้ายกันและมีชื่อเมธอดเดียวกัน 'make_sound()' และ 'info()'

คลาสแมว:

def __init__(ตัวเอง ชื่อ อายุ):

self.name = ชื่อ

self.age = อายุ

ข้อมูล def (ตัวเอง):

print(f”I am a cat. My name is {self.name}. I am {self.age} years old”)

def make_sound (ตัวเอง):

พิมพ์ (“เหมียว”)

คลาสสุนัข:

def __init__(ตัวเอง ชื่อ อายุ):

self.name = ชื่อ

self.age = อายุ

ข้อมูล def (ตัวเอง):

พิมพ์(f”ฉันเป็นหมา ฉันชื่อ {self.name} ฉันอายุ {self.age} ปี”)

def make_sound (ตัวเอง):

พิมพ์ (“เปลือก”)

cat1 = แมว("มินนี่", 3)

dog1 = สุนัข (“ทอม”, 6)

สำหรับสัตว์ใน (cat1, dog1):

สัตว์.make_sound()

สัตว์.ข้อมูล()

สัตว์.make_sound()

ผลลัพธ์จะเป็นดังนี้:

เหมียว

ฉันคือแมว. ฉันชื่อมินนี่ ฉันอายุ 3 ขวบ

เหมียว

เห่า

ฉันเป็นหมา. ฉันชื่อทอม ฉันอายุ 6 ขวบ

เห่า

4. วิธีการเอาชนะ

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

ต่อไปนี้เป็นตัวอย่างโค้ด Python เพื่อแสดงวิธีการแทนที่:

จาก pi . นำเข้าคณิตศาสตร์

รูปร่างชั้น:

def __init__ (ตัวเอง, ชื่อ):

self.name = ชื่อ

def พื้นที่ (ตัวเอง):

ผ่าน

def ข้อเท็จจริง (ตัวเอง):

กลับ "ฉันเป็นคนปิด"

def __str__(ตัวเอง):

กลับชื่อตัวเอง

คลาสสแควร์(รูปร่าง):

def __init__ (ตัวเอง, ความยาว):

super().__init__("สี่เหลี่ยม")

self.length = ความยาว

def พื้นที่ (ตัวเอง):

กลับความยาว**2

def ข้อเท็จจริง (ตัวเอง):

ย้อนกลับ “แต่ละมุมในสี่เหลี่ยมจัตุรัสมีค่าเท่ากับ 90 องศา”

คลาส Circle (รูปร่าง):

def __init__ (ตัวเอง, รัศมี):

super().__init__("วงกลม")

self.radius = รัศมี

def พื้นที่ (ตัวเอง):

คืนค่า pi*self.radius**2

a = สแควร์(4)

ข = วงกลม(7)

พิมพ์ (ข)

พิมพ์(b.fact())

พิมพ์(a.fact())

พิมพ์(b.พื้นที่())

โปรแกรมข้างต้นจะมีผลลัพธ์ดังต่อไปนี้:

วงกลม

ฉันเป็นคนปิด

แต่ละมุมในสี่เหลี่ยมจัตุรัสมีค่าเท่ากับ 90 องศา

153.93804002589985

เรียนรู้เพิ่มเติมเกี่ยวกับการแทนที่เมธอด

ข้อดีของ Polymorphism ใน OOPs

ความหลากหลายใน OOPs มีข้อดีที่สำคัญสามประการ พวกเขามีดังนี้:

• Polymorphism ช่วยให้โค้ดสามารถนำกลับมาใช้ใหม่ได้ ดังนั้น เมื่อเขียน ทดสอบ และใช้งานคลาสแล้ว คุณสามารถใช้ซ้ำได้ครั้งแล้วครั้งเล่า นอกจากนี้ โค้ดยังสามารถเปลี่ยนแปลงได้โดยไม่กระทบต่อโค้ดเดิม ทั้งหมดนี้ช่วยประหยัดเวลาอย่างมากสำหรับ coder

• ในรูปแบบ polymorphism สามารถเก็บค่าข้อมูลหลายค่าไว้ในตัวแปรเดียวได้ นอกจากนี้ ค่าของตัวแปรที่สืบทอดจากซูเปอร์คลาสไปยังคลาสย่อยสามารถแก้ไขได้โดยไม่ต้องเปลี่ยนค่าของตัวแปรในซูเปอร์คลาสหรือคลาสย่อยใดๆ

• สุดท้าย ความหลากหลายทำงานกับโค้ดน้อยลง ซึ่งทำให้โปรแกรมเมอร์แก้ไขจุดบกพร่องได้ง่ายขึ้น

ทางข้างหน้า

upGrad ร่วมกับมหาวิทยาลัย Liverpool John Moores อันทรงเกียรติ เสนอ หลักสูตรวิทยาศาสตรมหาบัณฑิตออนไลน์อย่างเข้มงวดในโปรแกรม Data Science สำหรับมืออาชีพด้านการทำงานที่ต้องการประกอบอาชีพด้านวิทยาศาสตร์ข้อมูล หลักสูตรนี้จบลงด้วยปริญญาโทจาก LJMU และประกาศนียบัตร Executive PG Program จาก IIIT Bangalore

ไฮไลท์ของโปรแกรม:

• เนื้อหามากกว่า 500 ชั่วโมง กรณีศึกษาและโครงการมากกว่า 60 รายการ เซสชันสดมากกว่า 20 รายการ
• ครอบคลุมเครื่องมือและซอฟต์แวร์มากกว่า 14 รายการ เช่น Python, AWS, MySQL และอื่นๆ
• การฝึกสอนกับผู้เชี่ยวชาญในอุตสาหกรรม
• การเรียนรู้แบบเพียร์และเครือข่ายอุตสาหกรรม
• ความช่วยเหลือด้านอาชีพ 360 องศา

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

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