Ao tentar explicar o conceito de herança na OOP, o exemplo comum é frequentemente o exemplo dos mamíferos. IMHO, este é realmente um mau exemplo, porque levará os novatos a usar esse conceito da maneira errada. Além disso, não é um design comum que eles enfrentarão no trabalho de design do dia-a-dia.

Então, qual será um problema agradável, simples e concreto que será resolvido usando a Herança?

Não há nada errado com um exemplo puramente acadêmico como mamíferos. Também gosto do exemplo de retângulo / quadrado, porque aponta por que as taxonomias do mundo real nem sempre se traduzem diretamente no relacionamento de herança que você esperaria.

Na minha opinião, o exemplo mais canônico de todos os dias é um kit de ferramentas da GUI. É algo que todo mundo já usou, mas os iniciantes podem não ter raciocinado sobre como trabalham sob o capô. Você pode falar sobre quais comportamentos são comuns a todos os contêineres, todos os widgets, eventos etc. sem exigir conhecimento detalhado de qualquer implementação.

Meu exemplo do mundo real é o modelo de domínio de um aplicativo de RH simples. Digo que podemos criar uma classe base chamada Employee , porque é claro que os gerentes também são empregados.

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

Então eu explico que desenvolvedores são funcionários , testadores são funcionários , gerentes de projeto são funcionários . Assim, todos eles podem herdar da classe de funcionários.

Encapsule o que varia ... mostre a eles um padrão de método de modelo , ele demonstra a utilidade da herança colocando comportamento comum em uma classe base e encapsulando comportamentos variáveis ​​nas subclasses.

UI controlse Streamstambém são um bom exemplo para a utilidade da herança.

Lembrar

Toda instância de um objeto é um exemplo concreto da utilidade da herança!

Se você quer dizer especificamente herança de classe , agora está no mundo das taxonomias, e essas variarão drasticamente de acordo com os objetivos do sistema que as utiliza. O exemplo de animais / mamíferos usa uma taxonomia comum e esperançosamente familiar da biologia, mas é (como você mencionou) quase inútil para a grande maioria dos problemas de programação.

Então tente algo universal: a noção de um programa. Todo programa inicia, executa e termina. Todo programa tem um nome e parâmetros opcionais de linha de comando. Portanto, uma classe de programa base seria muito útil, para iniciar a execução, pegar e processar os argumentos da linha de comando, executar a lógica principal e desligar normalmente.

É por isso que tantas linguagens de programação orientadas a objetos fornecem uma classe Program ou algo que se comporta exatamente como uma classe Program.

Eu estou trabalhando com câmeras no trabalho. Como temos dispositivos que se conectam a modelos diferentes, temos uma "classe de câmera" abstrata e cada modelo é herdado dessa classe para suportar funcionalidades específicas dessa câmera. É um exemplo do mundo real e não é difícil de entender.

Exemplo de elementos de química

Este é outro exemplo que saiu do meu cérebro:

classe Element_
{
    double atomicWeight; // Peso atômico do elemento
    double atomicNumber; // Número atômico do elemento
    Propriedades da string; // Propriedades do elemento
    // Outros, se houver
}


classe Isótopo estende Element_ // Pode existir isótopos de elemento
{
    halflife dupla;
   // Outros, se houver

}

Exemplos do mundo real quase sempre errar, porque eles dão exemplos em que há sempre a possibilidade de algo ser tanto TypeAe TypeBmas a hierarquia de herança única de muitas línguas não permitem isso.

Quanto mais eu programo, mais me afasto da herança.

Até a palavra "herdar" é usada incorretamente aqui. Por exemplo, você herda cerca de 50% dos traços de seu pai e 50% dos traços de sua mãe. Realmente seu DNA é uma composição de metade do DNA de seu pai e metade do DNA de sua mãe. Isso porque a biologia realmente favorece a composição sobre a herança , e você também deveria.

Simplesmente implementar interfaces, ou melhor ainda, "digitação de pato", além de injeção de dependência, é uma coisa muito melhor para ensinar as pessoas que são novas na programação orientada a objetos.

Eu apenas mostraria a eles um exemplo da vida real. Por exemplo, na maioria das estruturas de interface do usuário, você deriva de algum tipo de classe "Caixa de diálogo" ou "Janela" ou "Controle" para criar sua própria.

Um bom exemplo é a função de comparação na classificação:

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

O único problema é que os novatos costumam pensar que o desempenho é mais importante do que um bom código ...

Meu exemplo do mundo real é um veí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 exemplo pode ser tão detalhado quanto você quiser e existem todos os tipos de propriedades associadas aos veículos para explicar o uso de qualquer modificador que você queira ensinar.

Este exemplo não mamífero, não pássaro e não peixe pode ajudar:

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

Então

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: Apenas não conte o segredo: a pessoa estende o mamífero.

Que tal uma hierarquia de expressões algébricas. É bom porque inclui herança e composição:

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

Com exceção da expressão raiz Constant, todas as outras expressões são Expressões e contêm uma ou mais expressões.

Vou usar pássaros como exemplo

como frango, pato, águia

Explicarei que ambos têm garras, beijinhos e asas, mas seus atributos são diferentes.

Galinhas não podem voar, não sabem nadar, podem comer vermes, podem comer grãos

Os patos não podem voar, podem nadar, podem comer grãos, não podem comer vermes

Águia pode voar, não sabe nadar, pode comer vermes, não pode comer grãos

Seu típico rails-clone fornece muitos exemplos práticos : você tem a classe de modelo base (abstrata), que encapsula toda a manipulação de dados e a classe de controlador base, que encapsula toda a comunicação HTTP.