继承中的构造函数

基本概念

在面向对象编程中，构造函数是用于初始化对象的特殊方法。当一个类继承自另一个类时，子类会继承父类的构造函数，但不能直接调用父类的构造函数。因此，子类需要在自己的构造函数中显式调用父类的构造函数，以确保父类的属性和方法得到正确的初始化。

用途

1. 初始化对象：确保对象在创建时具有有效的初始状态。

2. 传递参数：在创建子类对象时，将参数传递给父类，以便父类的构造函数可以正确地初始化它的成员。

3. 代码复用：通过调用父类的构造函数，避免在子类中重复初始化父类的成员。

在游戏开发中，继承中的构造函数可以用于初始化各种游戏对象。例如，玩家角色和敌人角色都可以继承自同一个基类，并通过构造函数初始化不同的属性，如生命值、攻击力等。

语法规则

1. 子类的构造函数需要显式调用父类的构造函数，可以使用 base 关键字。

2. 父类的构造函数在子类的构造函数之前被调用。

public class ParentClass
{
    public ParentClass()
    {
        // 父类的无参数构造函数
    }

    public ParentClass(int param)
    {
        // 父类的有参数构造函数
    }
}

public class ChildClass : ParentClass
{
    public ChildClass() : base() // 显式调用父类的无参数构造函数
    {
        // 子类的构造函数
    }

    public ChildClass(int param) : base(param) // 显式调用父类的有参数构造函数
    {
        // 子类的构造函数
    }
}

示例代码

1. 基本示例

public class Animal
{
    public string Name { get; set; }

    public Animal(string name)
    {
        Name = name;
    }
}

public class Dog : Animal
{
    public string Breed { get; set; }

    public Dog(string name, string breed) : base(name)
    {
        Breed = breed;
    }

    public void DisplayInfo()
    {
        Console.WriteLine($"Name: {Name}, Breed: {Breed}");
    }
}

public class Program
{
    public static void Main()
    {
        Dog myDog = new Dog("Buddy", "Golden Retriever");
        myDog.DisplayInfo(); // 输出: Name: Buddy, Breed: Golden Retriever
    }
}

2. 复杂示例

public class Character
{
    public string Name { get; set; }
    public int Health { get; set; }

    public Character(string name, int health)
    {
        Name = name;
        Health = health;
    }

    public void DisplayInfo()
    {
        Console.WriteLine($"Name: {Name}, Health: {Health}");
    }
}

public class Player : Character
{
    public int Level { get; set; }

    public Player(string name, int health, int level) : base(name, health)
    {
        Level = level;
    }

    public new void DisplayInfo()
    {
        base.DisplayInfo();
        Console.WriteLine($"Level: {Level}");
    }
}

public class Program
{
    public static void Main()
    {
        Player player = new Player("Hero", 100, 5);
        player.DisplayInfo(); // 输出: Name: Hero, Health: 100, Level: 5
    }
}

优点和缺点

优点

1. 初始化：确保父类的属性和方法得到正确的初始化。

2. 代码复用：避免在子类中重复初始化父类的成员。

3. 参数传递：通过构造函数，可以在创建子类对象时传递参数给父类。

缺点

1. 复杂性：继承中的构造函数可能增加代码的复杂性，特别是在多层继承的情况下。

2. 耦合性：子类与父类之间的耦合性较高，修改父类的构造函数可能需要修改所有子类的构造函数。

基础练习题

1. 创建一个 Vehicle 类，包含 Speed 属性和带参数的构造函数。然后创建 Car 和 Bike 子类，分别调用 Vehicle 类的构造函数，初始化 Speed 属性。创建 Program 类，在 Main 方法中实例化 Car 和 Bike 对象，并输出它们的 Speed。

2. 创建一个 Person 类，包含 FirstName 和 LastName 属性，以及带参数的构造函数。然后创建 Student 子类，调用 Person 类的构造函数，并添加 Grade 属性。创建 Program 类，在 Main 方法中实例化 Student 对象，并输出完整的名字和年级。

进阶练习题

1. 创建一个 Shape 抽象类，包含 Area 和 Perimeter 抽象方法，以及带参数的构造函数。然后创建 Circle 和 Rectangle 子类，分别实现 Area 和 Perimeter 方法，并调用 Shape 类的构造函数。创建 Program 类，在 Main 方法中实例化 Circle 和 Rectangle 对象，并计算它们的面积和周长。

2. 创建一个 Appliance 基类，包含 Brand 和 Power 属性，以及带参数的构造函数。然后创建 WashingMachine 和 Refrigerator 子类，分别调用 Appliance 类的构造函数，并添加 Capacity 和 Volume 属性。创建 Program 类，在 Main 方法中实例化 WashingMachine 和 Refrigerator 对象，并输出它们的所有属性。