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

ดังนั้นสิ่งที่จะเป็นปัญหาที่ดีเรียบง่ายและเป็นรูปธรรมที่แก้ไขได้โดยใช้มรดก?

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

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

ตัวอย่างโลกแห่งความจริงของฉันคือโมเดลโดเมนของแอปพลิเคชั่น HR อย่างง่าย ฉันบอกว่าเราสามารถสร้างคลาสพื้นฐานชื่อพนักงานได้แน่นอนผู้จัดการก็เป็นพนักงานเช่นกัน

public class Employee
{
    public string FirstName { get; set; }

    public string LastName { get; set; }

    public int Code { get; set; }

    public string GetInsuranceHistory()
    {
        // Retrieving insurance history based on employee code.
    }
}

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

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

UI controlsและStreamsยังเป็นตัวอย่างที่ดีสำหรับประโยชน์ของการสืบทอด

จำ

ตัวอย่างของวัตถุทุกชิ้นเป็นตัวอย่างที่ชัดเจนของประโยชน์ของการสืบทอด!

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

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

นี่คือเหตุผลว่าทำไมภาษาโปรแกรมเชิงวัตถุจำนวนมากจึงมีคลาสโปรแกรมหรือสิ่งที่มีลักษณะเหมือนกับคลาสโปรแกรม

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

ตัวอย่างองค์ประกอบทางเคมี

นี่เป็นอีกตัวอย่างที่โผล่ออกมาจากสมองของฉัน:

องค์ประกอบคลาส _
{
    น้ำหนักอะตอมคู่ // น้ำหนักอะตอมขององค์ประกอบ
    เลขอะตอมคู่ // จำนวนอะตอมขององค์ประกอบ
    คุณสมบัติของสตริง; // คุณสมบัติขององค์ประกอบ
    // อื่น ๆ ถ้ามี
}


ชั้นไอโซโทปขยาย Element_ // มีไอโซโทปขององค์ประกอบอยู่ได้
{
    halflife สองเท่า
   // อื่น ๆ ถ้ามี

}

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

ยิ่งฉันเขียนโปรแกรมมากเท่าไหร่ก็ยิ่งได้รับมรดกมากขึ้นเท่านั้น

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

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

ฉันแค่แสดงให้พวกเขาเห็นตัวอย่างในชีวิตจริง ตัวอย่างเช่นในเฟรมเวิร์ก UI ส่วนใหญ่คุณได้รับคลาส "โต้ตอบ" หรือ "หน้าต่าง" หรือ "ควบคุม" บางอย่างเพื่อสร้างของคุณเอง

ตัวอย่างที่ดีคือฟังก์ชันการเปรียบเทียบในการเรียงลำดับ:

template<class T>
class CompareInterface {
public:
   virtual bool Compare(T t1, T t2) const=0;
};
class FloatCompare : public CompareInterface<float> { };
class CompareImplementation : public FloatCompare {
public:
   bool Compare(float t1, float t2) const { return t1<t2; }
};
template<class T>
void Sort(T*array, int size, CompareInterface<T> &compare);

ปัญหาเดียวคือมือใหม่บ่อยเกินไปคิดว่าประสิทธิภาพสำคัญกว่ารหัสที่ดี ...

ตัวอย่างโลกแห่งความจริงของฉันคือยานพาหนะ:

public class Vehicle
{
    public Vehicle(int doors, int wheels)
    {
        // I describe things that should be
        // established and "unchangeable" 
        // when the class is first "made"
        NumberOfDoors = doors;
        NumberOfWheels = wheels;
    }

    public void RollWindowsUp()
    {
        WindowsUp = true;
    }

    // I cover modifiers on properties to show
    // how to protect certain things from being
    // overridden
    public int NumberOfDoors { get; private set; }
    public int NumberOfWheels { get; private set; }

    public string Color { get; set; }
    public bool WindowsUp { get; set; }
    public int Speed { get; set; }
}

public class Car : Vehicle
{
    public Car : base(4, 4)
    {

    }
}

public class SemiTruck : Vehicle
{
    public SemiTruck : base(2, 18)
    {

    }
}

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

ตัวอย่างที่ไม่ใช่สัตว์เลี้ยงลูกด้วยนมที่ไม่ใช่นกและไม่ใช่ปลานี้อาจช่วย:

public abstract class Person {

    /* this contains thing all persons have, like name, gender, home addr, etc. */

    public Object getHomeAddr() { ... }

    public Person getName() { ... }

}

public class Employee extends Person{

    /* It adds things like date of contract, salary, position, etc */

    public Object getAccount() { ... }

}

public abstract class Patient extends Person {
    /* It adds things like medical history, etc */
}

แล้วก็

public static void main(String[] args) {

    /* you can send Xmas cards to patients and employees home addresses */

    List<Person> employeesAndPatients = Factory.getListOfEmployeesAndPatients();

    for (Person p: employeesAndPatients){
        sendXmasCard(p.getName(),p.getHomeAddr());
    }

    /* or you can proccess payment to employees */

    List<Employee> employees = Factory.getListOfEmployees();

    for (Employee e: employees){
        proccessPayment(e.getName(),e.getAccount());
    }       

}

หมายเหตุ: อย่าบอกความลับ: บุคคลขยาย Mammal

วิธีการเกี่ยวกับลำดับชั้นของการแสดงออกเกี่ยวกับพีชคณิต เป็นสิ่งที่ดีเพราะมันมีทั้งการถ่ายทอดและองค์ประกอบ:

+--------------------+------------------------+
| Expression         |<------------------+    |
+--------------------+----------+        |    |
| + evaluate(): int  |<---+     |        |    |
+--------------------+    |     |        |    |
          ^               |     |        |    |
          |               |     |        |    |
   +--------------+  +---------------+  +-------------+  ...
   | Constant     |  | Negation      |  | Addition    |
   +--------------+  +---------------+  +-------------+
   | -value: int  |  |               |  |             |
   +--------------+  +---------------+  +-------------+
   | +evaluate()  |  | +evaluate()   |  | +evaluate() |
   | +toString()  |  | +toString()   |  | +toString() |
   +--------------+  +---------------+  +-------------+

   Addition(Constant(5), Negation(Addition(Constant(3),Constant(2))))
   (5 + -(3 + 2)) = 0

ด้วยข้อยกเว้นของนิพจน์รูตค่าคงที่นิพจน์อื่นทั้งหมดเป็นทั้งนิพจน์และมีหนึ่งนิพจน์หรือมากกว่า

ฉันจะใช้นกเป็นตัวอย่าง

เหมือนไก่เป็ดนกอินทรี

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

ไก่ไม่สามารถบินได้ว่ายน้ำไม่สามารถกินเวิร์มกินธัญพืชได้

เป็ดบินไม่ได้สามารถว่ายน้ำกินธัญพืชกินหนอนไม่ได้

นกอินทรีสามารถบินได้ว่ายน้ำไม่ได้กินหนอนไม่สามารถกินธัญพืชได้

Rails-clone ทั่วไปของคุณมีตัวอย่างการใช้งานจริงมากมาย : คุณมีคลาสโมเดลพื้นฐาน (นามธรรม) ที่สรุปการจัดการข้อมูลทั้งหมดและคุณมีคลาสคอนโทรลเลอร์ฐานที่ห่อหุ้มการสื่อสาร HTTP ทั้งหมด