当试图解释OOP中的继承概念时，常见的例子通常是哺乳动物。恕我直言，这确实是一个不好的例子，因为它将导致新手以错误的方式使用此概念。而且，他们在日常设计工作中将面临的不是常见的设计。

那么，使用继承解决的一个好，简单而具体的问题是什么？

像哺乳动物这样的纯学术实例没有错。我也喜欢矩形/正方形示例，因为它指出了为什么现实世界中的分类法并不总是直接转换为您期望的继承关系。

我认为，最典型的日常示例是GUI工具包。这是每个人都在使用的东西，但是初学者可能没有对他们如何在后台工作进行推理。您可以谈论所有容器，所有小部件，事件等共有的行为，而无需了解任何给定实现的详细知识。

我的真实示例是一个简单的HR应用程序的域模型。我告诉我们可以创建一个名为Employee的基类，因为经理当然也是雇员。

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

然后我解释说开发人员是员工，测试人员是员工，项目经理是员工。因此，他们都可以从员工类继承。

封装变化的内容……向他们展示一个模板方法模式，它通过将常见行为放在基类中并将变化的行为封装在子类中，展示了继承的有用性。

UI controls并且Streams也是继承的用处一个很好的例子。

记得

对象的每个实例都是继承有用的具体示例！

如果您专门指的是类继承，那么您现在处于分类法领域，并且这些分类将因使用它们的系统目标而大不相同。动物/哺乳动物示例使用了生物学上常见且希望熟悉的分类法，但是（如您所提到的）对于绝大多数程序设计问题几乎没有用。

因此，尝试一些通用的东西：程序的概念。每个程序都将开始，运行和结束。每个程序都有一个名称和可选的命令行参数。因此，基本的Program类对于启动执行，获取和处理命令行参数，运行主逻辑以及正常关闭非常有用。

这就是为什么这么多面向对象的编程语言提供Program类或行为完全类似于Program类的原因。

我在工作时使用相机。我们有连接到不同模型的设备，因此我们有一个抽象的“相机类”，每个模型都继承自此类，以支持该相机的特定功能。这是一个真实的例子，不难理解。

化学元素实例

这是另一个突然出现的例子：

类Element_
{
    双atomicWeight；//元素的原子量
    double atomicNumber; //元素的原子数
    字符串属性；//元素的属性
    //其他（如果有）
}


同位素扩展Element_ //元素可能存在同位素
{
    半衰期加倍；
   //其他（如果有）

}

真实世界的例子几乎总是弄错了，因为他们给的例子，其中总会有一些既是可能性TypeA和TypeB，但许多语言的单一继承层次结构不允许。

我编写的程序越多，我越能摆脱继承。

甚至“继承”一词在这里也被不正确地使用。例如，您继承了父亲约50％的特质和母亲约50％的特质。实际上，您的DNA是父亲的一半，母亲的一半。这是因为生物学实际上更喜欢组成而不是继承，您也应该这样做。

对那些刚接触面向对象编程的人来说，简单地实现接口，甚至更好地实现“鸭子类型”，再加上依赖注入，是一件好得多的事情。

我只是给他们看一个真实的例子。例如，在大多数UI框架中，您都从某种“对话框”或“窗口”或“控件”类派生出自己的类。

一个很好的例子是排序中的比较功能：

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

唯一的问题是新手常常认为性能比好的代码更重要...

我的真实示例是车辆：

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

    }
}

该示例可以根据您的需要进行详细介绍，并且在车辆上附加了各种属性，以说明您可能要教的修饰符的用法。

这个非哺乳动物，非鸟类，非鱼类的示例可能会有所帮助：

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

然后

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

}

注意：只是不要告诉这个秘密：人会延伸哺乳动物。

代数表达式的层次结构怎么样。很好，因为它既包含继承又包含组成：

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

除了根表达式Constant以外，所有其他表达式都是一个Expression，并且包含一个或多个表达式。

我将以鸟为例

像鸡，鸭，鹰

我将解释它们都有爪，啄和翅膀，但是它们的属性不同。

鸡不能飞，不能游泳，可以吃蠕虫，可以吃谷物

鸭子不能飞，不能游泳，可以吃谷物，不能吃蠕虫

鹰会飞，不会游泳，可以吃蠕虫，不能吃谷物

典型的rails-clone提供了许多实际示例：您拥有（抽象的）基本模型类，该类封装了所有数据操作，而您拥有了基本的控制器类，封装了所有HTTP通信。