Próbując wyjaśnić pojęcie dziedziczenia w OOP, częstym przykładem jest często przykład ssaków. IMHO, to naprawdę zły przykład, ponieważ doprowadzi początkujących do niewłaściwego korzystania z tej koncepcji. Co więcej, nie jest to powszechny projekt, z którym będą mieli do czynienia w codziennej pracy projektowej.

Więc jaki będzie ładny, prosty i konkretny problem, który zostanie rozwiązany za pomocą Dziedziczenia?

Nie ma nic złego w czysto akademickim przykładzie, takim jak ssaki. Podoba mi się również przykład w kształcie prostokąta / kwadratu, ponieważ pokazuje, dlaczego taksonomie w świecie rzeczywistym nie zawsze bezpośrednio przekładają się na oczekiwane relacje dziedziczenia.

Moim zdaniem najbardziej kanonicznym przykładem każdego dnia jest zestaw narzędzi GUI. Jest to coś, z czego wszyscy korzystali, ale początkujący może nie rozumieli, jak działają pod maską. Możesz porozmawiać o tym, jakie zachowania są wspólne dla wszystkich kontenerów, wszystkich widżetów, zdarzeń itp. Bez konieczności szczegółowej wiedzy na temat dowolnej implementacji.

Moim prawdziwym przykładem jest model domeny prostej aplikacji HR. Mówię, że możemy stworzyć klasę podstawową o nazwie Pracownik , ponieważ oczywiście menedżerowie też są pracownikami.

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

Następnie wyjaśniam, że programiści to pracownicy , testerzy to pracownicy , kierownicy projektów to pracownicy . W ten sposób wszyscy mogą dziedziczyć po klasie pracowników.

Hermetyzuj to, co się różni ... pokaż im wzorzec metody szablonu , demonstruje on przydatność dziedziczenia poprzez umieszczenie wspólnego zachowania w klasie bazowej i hermetyzowanie różnych zachowań w podklasach.

UI controlsi Streamssą również bardzo dobrym przykładem przydatności dziedziczenia.

Zapamiętaj

Każde wystąpienie obiektu jest konkretnym przykładem przydatności dziedziczenia!

Jeśli masz na myśli konkretnie klasę dziedziczenie , teraz znajdujesz się w świecie taksonomii, które różnią się drastycznie od celów systemu, który ich używa. Przykład zwierząt / ssaków wykorzystuje wspólną i miejmy nadzieję znaną taksonomię z biologii, ale jest (jak wspomniałeś) prawie bezużyteczny w przypadku większości problemów programistycznych.

Spróbuj więc czegoś uniwersalnego: pojęcia programu. Każdy program uruchamia się, uruchamia i kończy. Każdy program ma nazwę i opcjonalne parametry wiersza polecenia. Podstawowa klasa programu byłaby więc bardzo przydatna, aby rozpocząć wykonywanie, przechwytywać i przetwarzać argumenty wiersza poleceń, uruchamiać główną logikę i wdzięcznie zamykać.

Dlatego tak wiele obiektowych języków programowania zapewnia klasę Program lub coś, co zachowuje się dokładnie jak klasa Program.

Pracuję z aparatami w pracy. Mamy urządzenia, które łączą się z różnymi modelami, więc mamy abstrakcyjną „klasę kamery”, a każdy model dziedziczy z tej klasy, aby obsługiwać określone funkcje tej kamery. To przykład z prawdziwego świata i nietrudny do zrozumienia.

Przykład pierwiastków chemicznych

Oto kolejny przykład, który wyskoczył mi z mózgu:

klasa Element_
{
    podwójna masa atomowa; // Masa atomowa pierwiastka
    double atomicNumber; // Liczba atomowa elementu
    Właściwości łańcucha; // Właściwości elementu
    // Inne, jeśli istnieją
}


klasa Izotop rozszerza Element_ // Mogą istnieć izotopy elementu
{
    podwójny okres półtrwania;
   // Inne, jeśli istnieją

}

Przykłady ze świata rzeczywistego prawie zawsze źle to rozumieją, ponieważ podają przykłady, w których zawsze istnieje możliwość, że coś jest jednocześnie, TypeAa TypeBjedna hierarchia dziedziczenia wielu języków nie pozwala na to.

Im więcej programuję, tym bardziej uciekam od dziedziczenia.

Nawet słowo „dziedziczenie” jest tu używane niewłaściwie. Na przykład dziedziczysz około 50% cech ojca i 50% cech matki. Naprawdę twoje DNA składa się z połowy DNA twojego ojca i połowy DNA twojej matki. To dlatego, że biologia w rzeczywistości preferuje kompozycję nad dziedziczeniem , a ty też powinieneś.

Po prostu implementacja interfejsów, a nawet lepiej, „pisanie kaczych znaków” oraz wstrzykiwanie zależności, jest o wiele lepszą rzeczą, aby uczyć ludzi, którzy są nowicjuszami w programowaniu obiektowym.

Po prostu pokażę im przykład z życia. Na przykład, w większości frameworków interfejsu użytkownika wywodzisz się z pewnego rodzaju klasy „Dialog”, „Window” lub „Control”, aby stworzyć własną.

Dobrym przykładem jest funkcja porównania w sortowaniu:

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

Jedynym problemem jest to, że początkujący zbyt często uważają, że wydajność jest ważniejsza niż dobry kod ...

Moim prawdziwym przykładem jest pojazd:

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

    }
}

Ten przykład może być tak szczegółowy, jak tylko chcesz, a do pojazdów dołączone są różnego rodzaju właściwości wyjaśniające użycie dowolnych modyfikatorów, których możesz chcieć nauczyć.

Ten przykład, który nie jest ssakiem, ptakiem i ptakiem, może nie pomóc:

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

Następnie

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

}

UWAGA: Po prostu nie zdradzaj tajemnicy: Osoba rozszerza Ssak.

A może hierarchia wyrażeń algebraicznych. Jest dobry, ponieważ obejmuje zarówno dziedziczenie, jak i kompozycję:

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

Z wyjątkiem wyrażenia głównego Constant wszystkie pozostałe wyrażenia są zarówno Wyrażeniami, jak i zawierają jedno lub więcej wyrażeń.

Wykorzystam ptaki jako przykład

jak kurczak, kaczka, orzeł

Wyjaśnię, że oba mają pazury, dziobaki i skrzydła, ale ich atrybuty są różne.

Kurczaki nie potrafią latać, nie potrafią pływać, mogą jeść robaków, mogą jeść ziarna

Kaczki nie mogą latać, mogą pływać, mogą jeść ziarna, nie mogą jeść robaków

Orzeł potrafi latać, nie umie pływać, może jeść robaki, nie może jeść zbóż

Typowy klon-szyna zawiera wiele praktycznych przykładów : masz (abstrakcyjną) klasę modelu bazowego, która zawiera wszystkie operacje na danych i masz klasę bazowego kontrolera, która obejmuje całą komunikację HTTP.