Cuando se trata de explicar el concepto de herencia en OOP, el ejemplo común es a menudo el ejemplo de los mamíferos. En mi humilde opinión, este es realmente un mal ejemplo, porque llevará a los novatos a utilizar este concepto de la manera incorrecta. Y, además, no es un diseño común al que se enfrentarán en su trabajo de diseño diario.

Entonces, ¿cuál será un problema agradable, simple y concreto que se resuelva con Herencia?

No hay nada malo con un ejemplo puramente académico como los mamíferos. También me gusta el ejemplo de rectángulo / cuadrado porque señala por qué las taxonomías del mundo real no siempre se traducen directamente a la relación de herencia que esperarías.

En mi opinión, el ejemplo más canónico de todos los días es un kit de herramientas GUI. Es algo que todos han usado, pero que los principiantes pueden no haber razonado sobre cómo trabajan bajo el capó. Puede hablar sobre qué comportamientos son comunes a todos los contenedores, todos los widgets, eventos, etc. sin requerir un conocimiento detallado de ninguna implementación dada.

Mi ejemplo del mundo real es el modelo de dominio de una aplicación de recursos humanos simple. Le digo que podemos crear una clase base llamada Empleado , porque, por supuesto, los gerentes también son empleados.

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

Luego explico que los desarrolladores son empleados , los probadores son empleados , los gerentes de proyecto son empleados . Por lo tanto, todos pueden heredar de la clase de empleado.

Encapsula lo que varía ... muéstrales un patrón de método de plantilla , demuestra la utilidad de la herencia colocando el comportamiento común en una clase base y encapsulando el comportamiento variable en las subclases.

UI controlsy Streamstambién son un muy buen ejemplo de la utilidad de la herencia.

Recuerda

¡Cada instancia de un objeto es un ejemplo concreto de la utilidad de la herencia!

Si te refieres específicamente a la herencia de clase , ahora estás en el mundo de las taxonomías, y éstas variarán drásticamente según los objetivos del sistema que las usa. El ejemplo de animales / mamíferos utiliza una taxonomía común y con suerte familiar de la biología, pero es (como usted mencionó) casi inútil para la gran mayoría de los problemas de programación.

Intente algo universal: la noción de un programa. Cada programa comienza, se ejecuta y termina. Cada programa tiene un nombre y parámetros opcionales de línea de comandos. Por lo tanto, una clase de programa base sería muy útil para iniciar la ejecución, tomar y procesar los argumentos de la línea de comandos, ejecutar la lógica principal y cerrar con gracia.

Es por eso que tantos lenguajes de programación orientados a objetos proporcionan una clase de Programa, o algo que se comporta exactamente como una clase de Programa.

Estoy trabajando con cámaras en el trabajo. Tenemos dispositivos que se conectan a diferentes modelos, por lo que tenemos una "clase de cámara" abstracta y cada modelo hereda de esta clase para admitir la funcionalidad específica de esa cámara. Es un ejemplo del mundo real y no es difícil de entender.

Ejemplo de elementos químicos

Este es otro ejemplo que salió de mi cerebro:

clase Element_
{
    doble peso atómico; // peso atómico del elemento
    doble número atómico; // número atómico del elemento
    Propiedades de cadena; // Propiedades del elemento
    // Otros, si los hay
}


clase Isótopo extiende Elemento_ // Pueden existir isótopos de elemento
{
    doble vida media;
   // Otros si alguno

}

Los ejemplos del mundo real casi siempre se equivocan porque dan ejemplos donde siempre existe la posibilidad de que algo sea ambos TypeAy TypeBla jerarquía de herencia única de muchos idiomas no lo permita.

Cuanto más programo, más me alejo de la herencia.

Incluso la palabra "heredar" se usa incorrectamente aquí. Por ejemplo, usted hereda aproximadamente el 50% de los rasgos de su padre y el 50% de los rasgos de su madre. Realmente tu ADN es una composición de la mitad del ADN de tu padre y la mitad del ADN de tu madre. Esto se debe a que la biología en realidad favorece la composición sobre la herencia , y usted también debería hacerlo.

Simplemente implementar interfaces, o incluso mejor, "escribir pato", además de la inyección de dependencia, es mucho mejor para enseñar a las personas que son nuevas en la programación orientada a objetos.

Solo les mostraría un ejemplo de la vida real. Por ejemplo, en la mayoría de los marcos de UI, usted deriva de algún tipo de clase "Diálogo" o "Ventana" o "Control" para crear la suya propia.

Un buen ejemplo es la función de comparación en la clasificación:

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

El único problema es que los novatos a menudo piensan que el rendimiento es más importante que un buen código ...

Mi ejemplo del mundo real es un vehículo:

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

    }
}

Este ejemplo puede ser tan detallado como desee, y hay todo tipo de propiedades asociadas a los vehículos para explicar el uso de cualquier modificador que desee enseñar.

Este ejemplo de no mamífero, no pájaro ni pez podría ayudar:

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

Luego

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

}

NOTA: Simplemente no digas el secreto: la persona extiende Mamífero.

¿Qué tal una jerarquía de expresiones algebraicas? Es bueno porque incluye herencia y composición:

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

Con la excepción de la expresión raíz Constant, todas las demás expresiones son una Expresión y contienen una o más expresiones.

Usaré pájaros como ejemplo

como pollo, pato, águila

Explicaré que ambos tienen garras, picoteos y alas, pero sus atributos son diferentes.

Las gallinas no pueden volar, no pueden nadar, pueden comer gusanos, pueden comer granos

Los patos no pueden volar, pueden nadar, pueden comer granos, no pueden comer gusanos

El águila puede volar, no puede nadar, puede comer gusanos, no puede comer granos

Su típico clon de rails proporciona muchos ejemplos prácticos : tiene la clase de modelo base (abstracta), que encapsula toda la manipulación de datos y tiene la clase de controlador base, que encapsula toda la comunicación HTTP.