Quando si cerca di spiegare il concetto di ereditarietà in OOP, l'esempio comune è spesso l'esempio dei mammiferi. IMHO, questo è davvero un cattivo esempio, perché porterà i neofiti a usare questo concetto nel modo sbagliato. Inoltre, non è un progetto comune che dovranno affrontare nel loro lavoro di progettazione quotidiano.

Quindi, quale sarà un problema bello, semplice e concreto che viene risolto usando Ereditarietà?

Non c'è niente di sbagliato in un esempio puramente accademico come i mammiferi. Mi piace anche l'esempio rettangolo / quadrato perché indica perché le tassonomie del mondo reale non si traducono sempre direttamente nella relazione di eredità che ti aspetteresti.

Secondo me, l'esempio più canonico di tutti i giorni è un toolkit GUI. È qualcosa che tutti hanno usato, ma che i principianti potrebbero non aver ragionato su come lavorano sotto il cofano. Puoi parlare di quali comportamenti sono comuni a tutti i contenitori, tutti i widget, eventi, ecc. Senza richiedere una conoscenza dettagliata di una determinata implementazione.

Il mio esempio nel mondo reale è il modello di dominio di una semplice applicazione per le risorse umane. Dico che possiamo creare una classe base chiamata Employee , perché ovviamente anche i manager sono impiegati.

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

Quindi spiego che gli sviluppatori sono impiegati , i tester sono impiegati , i project manager sono impiegati . Pertanto, tutti possono ereditare dalla classe dei dipendenti.

Incapsula ciò che varia ... mostra loro un modello di modello , dimostra l'utilità dell'eredità inserendo comportamenti comuni in una classe base e incapsulando comportamenti variabili in sottoclassi.

UI controlse Streamssono anche un ottimo esempio per l'utilità dell'eredità.

Ricorda

Ogni istanza di un oggetto è un esempio concreto dell'utilità dell'eredità!

Se intendi specificamente l' eredità di classe , ora ti trovi nel mondo delle tassonomie, e queste varieranno drasticamente in base agli obiettivi del sistema che le utilizzano. L'esempio di animali / mammiferi usa una tassonomia comune e speriamo familiare dalla biologia, ma è (come hai detto tu) quasi inutile per la stragrande maggioranza dei problemi di programmazione.

Quindi prova qualcosa di universale: la nozione di programma. Ogni programma inizia, viene eseguito e termina. Ogni programma ha un nome e parametri opzionali da riga di comando. Quindi una classe Program di base sarebbe molto utile, per avviare l'esecuzione, afferrare ed elaborare gli argomenti della riga di comando, eseguire la logica principale e chiudere con grazia.

Ecco perché così tanti linguaggi di programmazione orientati agli oggetti forniscono una classe Program o qualcosa che si comporta esattamente come una classe Program.

Sto lavorando con le telecamere al lavoro. Abbiamo dispositivi che si collegano a diversi modelli, quindi abbiamo una "classe di telecamere" astratta e ogni modello eredita da questa classe per supportare funzionalità specifiche di quella telecamera. È un esempio del mondo reale e non è difficile da capire.

Esempio di elementi di chimica

Questo è un altro esempio emerso dal mio cervello:

classe Element_
{
    doppio peso atomico; // Peso atomico dell'elemento
    doppio atomicNumber; // Numero atomico di elemento
    Proprietà stringa; // Proprietà dell'elemento
    // Altri, se presenti
}


la classe Isotope estende Element_ // Possono esistere isotopi dell'elemento
{
    doppia emivita;
   // Altri se presenti

}

Gli esempi del mondo reale quasi sempre sbagliano perché forniscono esempi in cui esiste sempre la possibilità che qualcosa sia entrambi TypeAe TypeBma la singola gerarchia ereditaria di molte lingue non lo consente.

Più programma, più mi allontano dall'eredità.

Anche qui la parola "ereditare" è usata impropriamente. Ad esempio, erediti circa il 50% dei tratti di tuo padre e il 50% dei tratti di tua madre. Davvero il tuo DNA è una composizione di metà del DNA di tuo padre e metà del DNA di tua madre. Questo perché la biologia in realtà favorisce la composizione rispetto all'eredità , e dovresti farlo anche tu.

La semplice implementazione di interfacce o, meglio ancora, la "tipizzazione anatra", oltre all'iniezione di dipendenza, è una cosa molto migliore per insegnare alle persone che non conoscono la programmazione orientata agli oggetti.

Vorrei solo mostrare loro un esempio di vita reale. Ad esempio, nella maggior parte dei framework dell'interfaccia utente si ottiene una sorta di classe "Finestra di dialogo" o "Finestra" o "Controllo".

Un buon esempio è la funzione di confronto nell'ordinamento:

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

L'unico problema è che i neofiti troppo spesso pensano che le prestazioni siano più importanti del buon codice ...

Il mio esempio del mondo reale è un veicolo:

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

    }
}

Questo esempio può essere dettagliato come desideri e ci sono tutti i tipi di proprietà associate ai veicoli per spiegare l'uso di eventuali modificatori che potresti voler insegnare.

Questo esempio non-mammifero, non-uccello, non-pesce potrebbe aiutare:

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

Poi

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: non dire il segreto: la persona estende Mammal.

Che ne dici di una gerarchia di espressioni algebriche. È buono perché include sia l'eredità che la composizione:

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

Ad eccezione dell'espressione radice Costante, tutte le altre espressioni sono sia Espressione che contengono una o più espressioni.

Userò gli uccelli come esempio

come pollo, anatra, aquila

Spiegherò entrambi che hanno artigli, becchi e ali ma i loro attributi sono diversi.

I polli non possono volare, non sanno nuotare, possono mangiare vermi, possono mangiare cereali

Le anatre non possono volare, possono nuotare, possono mangiare cereali, non possono mangiare vermi

L'aquila può volare, non sa nuotare, può mangiare vermi, non può mangiare cereali

Il tuo tipico clone rails fornisce molti esempi pratici : hai la classe (astratta) del modello di base, che incapsula tutta la manipolazione dei dati e hai la classe del controller di base, che incapsula tutte le comunicazioni HTTP.