สารบัญ
การสืบทอดใน C # คืออะไร
ใน C# โดยใช้การสืบทอด คลาสหนึ่งสามารถรับหรือสืบทอดคุณสมบัติและเมธอดของคลาสอื่นได้ กล่าวอีกนัยหนึ่ง มันอนุญาตให้สร้างคลาสใหม่ตามคลาสที่มีอยู่ ซึ่งเรียกว่าคลาสพื้นฐานหรือซูเปอร์คลาส คลาสที่สร้างขึ้นหลังจากการรับคุณสมบัติของคลาสพื้นฐานเรียกว่า คลาสที่ได้รับ หรือคลาสย่อย
คลาสที่ได้รับมานี้ใน C# ไม่เพียงแต่ใช้คุณสมบัติของคลาสพื้นฐานเท่านั้น แต่ยังสามารถเพิ่มคุณลักษณะเฉพาะของตัวเองได้อีกด้วย
การสืบทอดทำงานอย่างไรใน C #
ใน C# การสืบทอดทำได้โดยการใช้เครื่องหมายทวิภาค (:) เครื่องหมาย. ชื่อคลาสพื้นฐานถูกกำหนดตามหลังโคลอน และระบุโดยคลาสที่ได้รับ
ต่อไปนี้คือไวยากรณ์สำหรับการสร้างคลาสที่ได้รับซึ่งรับคุณสมบัติจากคลาสพื้นฐาน:
คลาส DerivedClass : เบสคลาส{
// สมาชิกคลาสที่ได้รับ
}
ที่นี่ในรหัสนี้ คลาสที่ได้รับมา เป็นชื่อของคลาสที่ได้รับและ เบสคลาส เป็นชื่อของคลาสพื้นฐาน เดอะ : สัญลักษณ์บ่งชี้ว่า DerivedClass กำลังสืบทอดมาจาก BaseClass สมาชิกของ DerivedClass สามารถเข้าถึงสมาชิก BaseClass ได้ หากไม่เป็นส่วนตัว
ประเภทของการสืบทอดใน C #
C# รองรับการสืบทอดสี่ประเภท: การสืบทอดแบบเดี่ยว หลายระดับ ลำดับชั้น และการสืบทอดหลายรายการ มาดูแต่ละประเภทกัน
มรดกเดียว
การสืบทอดแบบเดี่ยวเป็นประเภทการสืบทอดที่พบได้บ่อยที่สุด โดยคลาสที่ได้รับมาจะรับหรือสืบทอดคุณสมบัติของคลาสพื้นฐานเพียงคลาสเดียว
ตัวอย่างเช่น, รหัสที่กำหนดจะอธิบายลำดับชั้นของคลาสและแสดงแนวคิดการสืบทอด
ใช้ระบบ ;ใช้ระบบ ;
รถคลาส
{
สาธารณะ เป็นโมฆะ เริ่ม ( )
{
คอนโซล เขียนไลน์ ( 'สตาร์ทรถ' ) ;
}
}
คลาสเทสลา : รถ
{
สาธารณะ เป็นโมฆะ เร่งความเร็ว ( )
{
คอนโซล เขียนไลน์ ( 'เทสลาเร่งความเร็ว' ) ;
}
}
โปรแกรมคลาส
{
คงที่ เป็นโมฆะ หลัก ( สตริง [ ] หาเรื่อง )
{
เทสลา มายเทสลา = เทสลาใหม่ ( ) ;
เทสลาของฉัน เริ่ม ( ) ; // เอาท์พุต: รถสตาร์ท
เทสลาของฉัน เร่งความเร็ว ( ) ; // เอาต์พุต: เทสลากำลังเร่งความเร็ว
}
}
ในโค้ดข้างต้น คลาสรถ เป็นคลาสพื้นฐานและมีเมธอดที่เรียกว่า เริ่ม() ซึ่งเพียงแค่พิมพ์ข้อความ รถสตาร์ท ไปที่คอนโซล
เดอะ คลาสเทสลา มาจากคลาสรถยนต์และใช้คุณสมบัติทั้งหมดของคลาสรถยนต์ คลาสเทสลาเพิ่มเมธอดที่เรียกว่า เร่งความเร็ว() ซึ่งพิมพ์ข้อความ เทสลากำลังเร่งความเร็ว ไปที่คอนโซล
เดอะ หลัก() ฟังก์ชันกำหนดอินสแตนซ์ของคลาสเทสลาที่เรียก เทสลาของฉัน และเรียกใช้เมธอด Start() และ Accelerate()
มรดกหลายระดับ
การสืบทอดหลายระดับคือการที่คลาสที่ได้รับสืบทอดมาจากคลาสที่ได้รับมาอื่น ซึ่งจะสืบทอดมาจากคลาสพื้นฐาน
ตัวอย่างเช่น, รหัส C# ต่อไปนี้แสดงให้เห็นถึงการสืบทอดและวิธีการแทนที่ในลำดับชั้นของคลาส
ใช้ระบบ ;สัตว์ชั้น
{
สาธารณะ เป็นโมฆะ กิน ( )
{
คอนโซล เขียนไลน์ ( 'การกินสัตว์' ) ;
}
}
สัตว์เลี้ยงลูกด้วยนมในชั้นเรียน : สัตว์
{
สาธารณะ เป็นโมฆะ วิ่ง ( )
{
คอนโซล เขียนไลน์ ( 'สัตว์เลี้ยงลูกด้วยนมวิ่ง' ) ;
}
}
สุนัขชั้น : สัตว์เลี้ยงลูกด้วยนม
{
สาธารณะ เป็นโมฆะ เห่า ( )
{
คอนโซล เขียนไลน์ ( 'สุนัขเห่า' ) ;
}
}
โปรแกรมคลาส
{
คงที่ เป็นโมฆะ หลัก ( สตริง [ ] หาเรื่อง )
{
หมามายด็อก = สุนัขตัวใหม่ ( ) ;
สุนัขของฉัน. กิน ( ) ; // ผลลัพธ์: การกินสัตว์
สุนัขของฉัน. วิ่ง ( ) ; // เอาต์พุต: สัตว์เลี้ยงลูกด้วยนมกำลังวิ่ง
สุนัขของฉัน. เห่า ( ) ; // เอาต์พุต: สุนัขเห่า
}
}
ที่นี่ สุนัข เป็นคลาสที่ได้รับสืบทอดมาจาก สัตว์เลี้ยงลูกด้วยนม ซึ่งจะสืบทอดมาจาก สัตว์ . คลาส Dog สามารถเข้าถึงคุณสมบัติ วิธีการ และพฤติกรรมทั้งหมดของสัตว์เลี้ยงลูกด้วยนมและสัตว์ และยังสามารถกำหนดวิธีการเฉพาะของมันเอง เห่า() .
เดอะ ชั้นเรียนสัตว์ เป็นคลาสพื้นฐานและมีเมธอดที่เรียกว่า กิน() ซึ่งเพียงแค่พิมพ์ข้อความ Animal eating ไปยังคอนโซล
เดอะ ชั้นสัตว์เลี้ยงลูกด้วยนม มาจากคลาส Animal และเพิ่มเมธอดที่เรียกว่า วิ่ง() ซึ่งพิมพ์ข้อความ Mammal ที่วิ่งไปที่คอนโซล
เดอะ ชั้นเรียนสุนัข มาจากคลาส Mammal และเพิ่มเมธอดที่เรียกว่า เห่า() ซึ่งพิมพ์ข้อความ สุนัขเห่าไปที่คอนโซล
เมธอด Main() สร้างอินสแตนซ์ของคลาส Dog ที่เรียกว่า สุนัขของฉัน และเรียกใช้เมธอด Eat(), Run() และ Bark()
โปรดทราบว่าเมธอด Eat() และ Run() ไม่ได้กำหนดไว้ในคลาส Dog แต่สืบทอดมาจากคลาสพาเรนต์ สัตว์ และ สัตว์เลี้ยงลูกด้วยนม ตามลำดับ เดอะ เห่า() เมธอดกำหนดไว้ในคลาส Dog เท่านั้น
การสืบทอดลำดับชั้น
ในการสืบทอดแบบลำดับชั้น จำนวนคลาสที่ได้รับมาแตกต่างกันจะสืบทอดมาจากคลาสพื้นฐานเพียงคลาสเดียว ตัวอย่างเช่น:
ใช้ระบบ ;รูปร่างคลาส
{
สาธารณะ เป็นโมฆะ วาด ( )
{
คอนโซล เขียนไลน์ ( 'การวาดรูปร่าง' ) ;
}
}
วงกลมชั้น : รูปร่าง
{
สาธารณะ เป็นโมฆะ เติม ( )
{
คอนโซล เขียนไลน์ ( 'เติมวงกลม' ) ;
}
}
คลาสสแควร์ : รูปร่าง
{
สาธารณะ เป็นโมฆะ สี ( )
{
คอนโซล เขียนไลน์ ( 'ตารางระบายสี' ) ;
}
}
โปรแกรมคลาส
{
คงที่ เป็นโมฆะ หลัก ( สตริง [ ] หาเรื่อง )
{
วงกลม myCircle = วงกลมใหม่ ( ) ;
วงกลมของฉัน วาด ( ) ; // เอาต์พุต: รูปร่างการวาด
วงกลมของฉัน เติม ( ) ; // เอาต์พุต: เติมวงกลม
สแควร์ mySquare = สแควร์ใหม่ ( ) ;
มายสแควร์. วาด ( ) ; // เอาต์พุต: รูปร่างการวาด
มายสแควร์. สี ( ) ; // เอาต์พุต: สี่เหลี่ยมระบายสี
}
}
ในรหัสข้างต้นทั้งสอง วงกลม และ สี่เหลี่ยม เป็นคลาสที่ได้รับสืบทอดมาจาก รูปร่าง . พวกเขามีสิทธิ์เข้าถึงเมธอด Draw() ที่กำหนดใน Shape และยังสามารถกำหนดเมธอดเฉพาะของตนเอง Fill() และ Color()
ที่นี่เราสร้างวัตถุของคลาส Circle ชื่อ วงกลมของฉัน และวัตถุของ สี่เหลี่ยม ชั้นชื่อ มายสแควร์ . เราก็โทรไปที่ วาด() วิธีการซึ่งสืบทอดมาจากคลาส Shape บนวัตถุทั้งสอง
ต่อไปเราเรียกว่า เติม() เมธอดบน myCircle ซึ่งเฉพาะสำหรับคลาส Circle และ สี() วิธีการบน mySquare ซึ่งเฉพาะสำหรับคลาสสแควร์
ผลลัพธ์จะถูกพิมพ์ไปยังคอนโซลดังต่อไปนี้:
มรดกหลายรายการ
การสืบทอดหลายรายการคือการที่คลาสที่ได้รับสืบทอดมาจากคลาสพื้นฐานหลายคลาส อย่างไรก็ตาม C# ไม่รองรับการสืบทอดหลายรายการ เพื่อให้ได้ฟังก์ชันที่คล้ายกัน C# จะใช้ อินเทอร์เฟซ .
บทสรุป
การสืบทอดใน C# ทำให้คลาสสามารถสืบทอดพฤติกรรมและการทำงานจากคลาสพื้นฐานได้ การใช้การสืบทอด เราสามารถใช้รหัสซ้ำและสร้างโฟลว์ลำดับชั้นภายในโปรแกรม เมื่อเข้าใจประเภทต่างๆ ของการสืบทอด เราสามารถเขียนโค้ดที่มีประสิทธิภาพและเป็นระเบียบมากขึ้น ซึ่งง่ายต่อการบำรุงรักษาและขยาย