Wenn Sie versuchen, das Konzept der Vererbung in OOP zu erklären, ist das häufigste Beispiel das Beispiel von Säugetieren. IMHO, das ist wirklich ein schlechtes Beispiel, weil es die Neulinge dazu bringt, dieses Konzept falsch zu verwenden. Darüber hinaus ist es kein gewöhnliches Design, mit dem sie in ihrer täglichen Designarbeit konfrontiert werden.

Also, was wird ein schönes, einfaches und konkretes Problem sein, das mit Inheritance gelöst wird?

An einem rein akademischen Beispiel wie Säugetieren ist nichts auszusetzen. Ich mag auch das Rechteck / Quadrat-Beispiel, weil es darauf hinweist, warum Taxonomien aus der realen Welt nicht immer direkt in die zu erwartende Vererbungsbeziehung übersetzt werden.

Meiner Meinung nach ist das kanonischste Beispiel für jeden Tag ein GUI-Toolkit. Es ist etwas, das jeder benutzt hat, aber Anfänger haben vielleicht nicht begründet, wie sie unter der Haube arbeiten. Sie können darüber sprechen, welche Verhaltensweisen allen Containern, Widgets, Ereignissen usw. gemeinsam sind, ohne detaillierte Kenntnisse über eine bestimmte Implementierung zu benötigen.

Mein reales Beispiel ist das Domänenmodell einer einfachen HR-Anwendung. Ich sage, dass wir eine Basisklasse namens Employee erstellen können , weil Manager natürlich auch Mitarbeiter sind.

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.
    }
}

Dann erkläre ich , dass Entwickler sind Mitarbeiter , Tester sind Mitarbeiter , Projektmanager sind Mitarbeiter . Somit können sie alle von der Mitarbeiterklasse erben .

Verkapseln, was variiert ... Zeigen Sie ihnen ein Muster für eine Vorlagenmethode . Es demonstriert die Nützlichkeit der Vererbung, indem gemeinsames Verhalten in eine Basisklasse eingefügt und unterschiedliches Verhalten in Unterklassen eingekapselt wird.

UI controlsund Streamssind auch ein sehr gutes Beispiel für die Nützlichkeit der Vererbung.

Merken

Jede Instanz eines Objekts ist ein konkretes Beispiel für die Nützlichkeit der Vererbung!

Wenn Sie spezifisch Klassenvererbung meinen , befinden Sie sich jetzt in der Welt der Taxonomien, und diese variieren drastisch je nach den Zielen des Systems, das sie verwendet. Das Beispiel Tiere / Säugetiere verwendet eine verbreitete und hoffentlich vertraute Taxonomie aus der Biologie, die jedoch (wie Sie bereits erwähnt haben) für die überwiegende Mehrheit der Programmierprobleme nahezu unbrauchbar ist.

Probieren Sie etwas Universelles aus: den Begriff eines Programms. Jedes Programm startet, läuft und endet. Jedes Programm hat einen Namen und optionale Befehlszeilenparameter. Daher wäre eine Basis-Programmklasse sehr nützlich, um die Ausführung zu starten, die Befehlszeilenargumente zu erfassen und zu verarbeiten, die Hauptlogik auszuführen und ordnungsgemäß herunterzufahren.

Aus diesem Grund bieten so viele objektorientierte Programmiersprachen eine Programmklasse oder etwas, das sich genau wie eine Programmklasse verhält.

Ich arbeite mit Kameras bei der Arbeit. Wir haben Geräte, die mit verschiedenen Modellen verbunden sind, daher haben wir eine abstrakte "Kameraklasse" und jedes Modell erbt von dieser Klasse, um bestimmte Funktionen dieser Kamera zu unterstützen. Es ist ein Beispiel aus der Praxis und nicht schwer zu verstehen.

Beispiel für chemische Elemente

Dies ist ein weiteres Beispiel aus meinem Gehirn:

Klasse Element_
{
    doppeltes Atomgewicht; // Atomgewicht des Elements
    double atomicNumber; // Ordnungszahl des Elements
    String Properties; // Eigenschaften des Elements
    // Andere, falls vorhanden
}


Klasse Isotope erweitert Element_ // Es können Isotope des Elements existieren
{
    doppelte Halbwertszeit;
   // Andere, falls vorhanden

}

Beispiele aus der realen Welt verstehen es fast immer falsch, weil sie Beispiele geben, bei denen es immer die Möglichkeit gibt, dass etwas beides ist, TypeAund TypeBdie Hierarchie mit nur einer Vererbung vieler Sprachen dies nicht zulässt.

Je mehr ich programmiere, desto weiter entferne ich mich von der Vererbung.

Sogar das Wort "erben" wird hier falsch verwendet. Zum Beispiel erben Sie ungefähr 50% der Merkmale Ihres Vaters und 50% der Merkmale Ihrer Mutter. In Wirklichkeit besteht Ihre DNA aus der Hälfte der DNA Ihres Vaters und der Hälfte der DNA Ihrer Mutter. Das liegt daran, dass die Biologie die Komposition der Vererbung vorgezogen hat , und das sollten Sie auch.

Das einfache Implementieren von Schnittstellen oder noch besser das "Duck Typing" plus Abhängigkeitsinjektion ist eine viel bessere Sache, um Menschen beizubringen, die mit objektorientierter Programmierung noch nicht vertraut sind.

Ich würde ihnen nur ein reales Beispiel zeigen. Beispielsweise leiten Sie in den meisten UI-Frameworks eine Art "Dialog" - oder "Window" - oder "Control" -Klasse ab, um Ihre eigene zu erstellen.

Ein gutes Beispiel ist die Vergleichsfunktion beim Sortieren:

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);

Das einzige Problem ist, dass die Neulinge zu oft denken, Leistung sei wichtiger als guter Code ...

Mein reales Beispiel ist ein Fahrzeug:

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)
    {

    }
}

Dieses Beispiel kann so detailliert sein, wie Sie möchten, und es gibt alle Arten von Eigenschaften, die mit Fahrzeugen verknüpft sind, um die Verwendung von Modifikatoren zu erläutern, die Sie möglicherweise unterrichten möchten.

Dieses Nicht-Säugetier-Nicht-Vogel-Nicht-Fisch-Beispiel könnte helfen:

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 */
}

Dann

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());
    }       

}

HINWEIS: Verrate das Geheimnis nur nicht: Person erweitert Säugetier.

Wie wäre es mit einer Hierarchie algebraischer Ausdrücke? Ist gut, weil es sowohl Vererbung als auch Zusammensetzung umfasst:

+--------------------+------------------------+
| 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

Mit Ausnahme der Stammausdruckskonstante sind alle anderen Ausdrücke ein Ausdruck und enthalten einen oder mehrere Ausdrücke.

Ich werde Vögel als Beispiel verwenden

wie Huhn, Ente, Adler

Ich werde erklären, dass beide Klauen, Klauen und Flügel haben, aber ihre Attribute sind unterschiedlich.

Hühner können nicht fliegen, nicht schwimmen, können Würmer essen, können Getreide essen

Enten können nicht fliegen, schwimmen, Getreide essen, keine Würmer essen

Adler kann fliegen, nicht schwimmen, Würmer fressen, keine Körner fressen

Ihr typischer Rails-Clone bietet viele praktische Beispiele : Sie haben die (abstrakte) Basismodellklasse, die alle Datenmanipulationen kapselt, und Sie haben die Basiscontrollerklasse, die die gesamte HTTP-Kommunikation kapselt.