Lorsque vous essayez d'expliquer le concept de l'héritage dans la POO, l'exemple commun est souvent l'exemple des mammifères. À mon humble avis, c'est vraiment un mauvais exemple, car cela amènera les débutants à utiliser ce concept dans le mauvais sens. Et de plus, ce n'est pas une conception commune à laquelle ils seront confrontés dans leur travail de conception au jour le jour.

Alors, quel sera un problème agréable, simple et concret qui sera résolu en utilisant l'héritage?

Il n'y a rien de mal à un exemple purement académique comme les mammifères. J'aime aussi l'exemple rectangle / carré car il montre pourquoi les taxonomies du monde réel ne se traduisent pas toujours directement par la relation d'héritage que vous attendez.

À mon avis, l'exemple le plus canonique de tous les jours est une boîte à outils GUI. C'est quelque chose que tout le monde a utilisé, mais que les débutants peuvent ne pas avoir réfléchi à la façon dont ils travaillent sous le capot. Vous pouvez parler des comportements communs à tous les conteneurs, tous les widgets, événements, etc. sans nécessiter une connaissance détaillée d'une implémentation donnée.

Mon exemple réel est le modèle de domaine d'une simple application RH. Je dis que nous pouvons créer une classe de base appelée Employé , car bien sûr, les gestionnaires sont également des employés.

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

J'explique ensuite que les développeurs sont des employés , les testeurs sont des employés , les chefs de projet sont des employés . Ainsi, ils peuvent tous hériter de la classe des employés.

Encapsulez ce qui varie ... montrez-leur un modèle de méthode de modèle , cela démontre l'utilité de l'héritage en mettant un comportement commun dans une classe de base et en encapsulant un comportement variable dans des sous-classes.

UI controlset Streamssont également un très bon exemple de l'utilité de l'héritage.

Rappelles toi

Chaque instance d'un objet est un exemple concret de l'utilité de l'héritage!

Si vous voulez dire spécifiquement l' héritage de classe , vous êtes maintenant dans le monde des taxonomies, et celles-ci varieront considérablement en fonction des objectifs du système qui les utilise. L'exemple animaux / mammifères utilise une taxonomie commune et, espérons-le, familière de la biologie, mais elle est (comme vous l'avez mentionné) presque inutile pour la grande majorité des problèmes de programmation.

Essayez donc quelque chose d'universel: la notion de programme. Chaque programme démarre, s'exécute et se termine. Chaque programme a un nom et des paramètres de ligne de commande facultatifs. Ainsi, une classe Program de base serait très utile pour démarrer l'exécution, récupérer et traiter les arguments de ligne de commande, exécuter la logique principale et arrêter correctement.

C'est pourquoi tant de langages de programmation orientés objet fournissent une classe Program, ou quelque chose qui se comporte exactement comme une classe Program.

Je travaille avec des caméras au travail. Nous avons des appareils qui se connectent à différents modèles, nous avons donc une "classe de caméra" abstraite et chaque modèle hérite de cette classe pour prendre en charge des fonctionnalités spécifiques de cette caméra. C'est un exemple réel et pas difficile à comprendre.

Exemple d'éléments de chimie

Voici un autre exemple sorti de mon cerveau:

classe Element_
{
    double atomicWeight; // Poids atomique de l'élément
    double atomicNumber; // Numéro atomique de l'élément
    Propriétés de chaîne; // Propriétés de l'élément
    // Autres, le cas échéant
}


classe Isotope étend Element_ // Il peut exister des isotopes d'élément
{
    double demi-vie;
   // Autres le cas échéant

}

Les exemples du monde réel se trompent presque toujours parce qu'ils donnent des exemples où il y a toujours la possibilité que quelque chose soit à la fois TypeAet TypeBmais la hiérarchie d'héritage unique de nombreuses langues ne le permet pas.

Plus je programme, plus je m'éloigne de l'héritage.

Même le mot "hériter" n'est pas utilisé correctement ici. Par exemple, vous héritez d'environ 50% des traits de votre père et 50% des traits de votre mère. Vraiment, votre ADN est une composition de la moitié de l'ADN de votre père et de la moitié de l'ADN de votre mère. C'est parce que la biologie favorise la composition plutôt que l'héritage , et vous devriez aussi.

La simple mise en œuvre d'interfaces, ou mieux encore, le "typage du canard", plus l'injection de dépendances, est une bien meilleure chose que d'enseigner à des personnes novices en programmation orientée objet.

Je leur montrerais juste un exemple concret. Par exemple, dans la plupart des frameworks d'interface utilisateur, vous dérivez d'une sorte de classe "Dialog" ou "Window" ou "Control" pour créer la vôtre.

Un bon exemple est la fonction de comparaison dans le tri:

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

Le seul problème est que les débutants pensent trop souvent que les performances sont plus importantes qu'un bon code ...

Mon exemple réel est un véhicule:

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

    }
}

Cet exemple peut être aussi détaillé que vous le souhaitez, et il existe toutes sortes de propriétés attachées aux véhicules pour expliquer l'utilisation des modificateurs que vous voudrez peut-être enseigner.

Cet exemple sans mammifère, sans oiseau et sans poisson pourrait aider:

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

alors

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

}

REMARQUE: ne dites pas le secret: la personne étend le mammifère.

Que diriez-vous d'une hiérarchie d'expressions algébriques. Est bon car il comprend à la fois l'héritage et la composition:

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

À l'exception de l'expression racine Constant, toutes les autres expressions sont à la fois une expression et contiennent une ou plusieurs expressions.

Je vais utiliser des oiseaux comme exemple

comme le poulet, le canard, l'aigle

Je vais expliquer que les deux ont des griffes, des coups de bec et des ailes mais leurs attributs sont différents.

Les poulets ne peuvent pas voler, ne peuvent pas nager, peuvent manger des vers, peuvent manger des céréales

Les canards ne peuvent pas voler, peuvent nager, peuvent manger des céréales, ne peuvent pas manger de vers

L'aigle peut voler, ne peut pas nager, peut manger des vers, ne peut pas manger de céréales

Votre rails-clone typique fournit de nombreux exemples pratiques : vous avez la classe de modèle de base (abstraite), qui encapsule toutes les manipulations de données et vous avez la classe de contrôleur de base, qui encapsule toutes les communications HTTP.