C# 了解如何使用类

我正在试图理解如何使用或访问C#中的多个类，有人能给我解释一下这段代码的作用吗

public class Mammal : Animal
{   
    public Mammal(String name) : base(name) { }

    public override void Eat(Food food)
    {
        Console.WriteLine("Mammal \"" + Name + "\" eats " + food.Name);
    }
}

公共饮食（食品）

的目的是什么？我是说它有什么用

namespace ConsoleApplication1
{
    public class Food
    {
        private String name;

        Food(String name)
        {
            this.name = name;
        }

        public String Name
        {
            get 
            {
                return name;
            }
            set
            {
                name = value;
            }
        }   
    }

    public class Animal
    {
        private String name = "no name";

        public String Name {
            get 
            { 
                return name; 
            }
            set 
            { 
                name = value; 
            }
        }

        private Animal() { }

        public Animal(String name)
        {
            this.name = name;
        }

        public virtual void Eat(Food food)
        {
            Console.WriteLine("Animal \"" + Name + "\" eats " + food.Name);
        }

        public virtual void Born() 
        {
            Console.WriteLine("Animal \"" + Name + "\" is born");
        }

        public virtual void Die() 
        {
            Console.WriteLine("Animal \"" + Name + "\" is died");
        }
    }

    public class Mammal : Animal
    {   
        public Mammal(String name) : base(name) { }

        public override void Eat(Food food)
        {
            Console.WriteLine("Mammal \"" + Name + "\" eats " + food.Name);
        }

        public override void Born()
        {
            Console.WriteLine("Mammal \"" + Name + "\" is born");
        }

        public override void Die()
        {
            Console.WriteLine("Mammal \"" + Name + "\" is died");
        }

        public virtual void FedMilk(Mammal[] children)
        {
            for (Int32 i = 0; i < children.Length; i++)
            {
                Console.WriteLine("Mammal \"" + Name + "\" feds milk child \"" + children[i].Name + "\"");
            }
        }
    }

    public class Horse : Mammal
    {
        public Horse(String name) : base(name) { }

        public override void Eat(Food food)
        {
            Console.WriteLine("Horse \"" + Name + "\" eats " + food.Name);
        }

        public override void Born()
        {
            Console.WriteLine("Horse \"" + Name + "\" is born");
        }
    }
}

命名空间控制台应用程序1
{
公共食品
{
私有字符串名称；
食物（字符串名称）
{
this.name=名称；
}
公共字符串名
{
得到
{
返回名称；
}
设置
{
名称=值；
}
}   
}
公营动物
{
私有字符串name=“无名称”；
公共字符串名{
得到
{ 
返回名称；
}
设置
{ 
名称=值；
}
}
私人动物（{}
公共动物（字符串名称）
{
this.name=名称；
}
公共虚拟空吃（食物）
{
Console.WriteLine（“Animal\”“+Name+”eats“+food.Name”）；
}
公共虚拟空间
{
Console.WriteLine（“动物”+“名字”+“出生”）；
}
公共虚拟空间
{
Console.WriteLine（“动物”+“名称”+“死亡”）；
}
}
公共类哺乳动物：动物
{   
公共哺乳动物（字符串名称）：base（名称）{}
公众饮食（食物）
{
Console.WriteLine（“哺乳动物\”+Name+“吃”+food.Name）；
}
公共覆盖无效出生（）
{
Console.WriteLine（“哺乳动物\”“名称+”\“出生”）；
}
公共覆盖无效死（）
{
Console.WriteLine（“哺乳动物\”“名称+”\“死亡”）；
}
公共虚拟空FedMilk（哺乳动物[]子类）
{
for（Int32 i=0；i

好的

您定义了一个名为“哺乳动物”的基本类，然后创建了不同类型的哺乳动物，比如动物，然后是特定的动物（马）

所以每一种哺乳动物都需要吃东西，这就是为什么你创造了一种叫做吃的功能

但是每一种哺乳动物都吃同样的东西？不

但是每种哺乳动物都需要吃东西

因此，在这个地方，override属性很方便，它允许您重写“eat”的基本功能，这样您就可以指定吃每种特定动物的食物

因此，当您创建一个dog类时，您将覆盖eat函数并指定吃狗粮的人

但是，因为你所有的特定动物也是动物，你可以把它们称为动物，并打印eat函数

假设你想看看是什么吃掉了每只动物。您将创建一个动物列表循环，并打印eat函数

因为您已经覆盖了eat函数并指定了每种食物。你将为每只动物获得正确的食物

我说得清楚了吗

例如，请参见此代码

List<Animal> animals = new List<Animal>();

            Horse hr = new Horse();
            Dog dg = new Dog();
            Bird br = new Bird();

            animals.Add(hr);
            animals.Add(dg);
            animals.Add(br);

            foreach(var animal in Animals)
            {
                Console.WriteLine(animal.eat());
            }

列出动物=新建列表（）；
马hr=新马（）；
狗dg=新狗（）；
鸟br=新鸟（）；
动物。添加（hr）；
动物。添加（dg）；
添加（br）；
foreach（动物中的动物变量）
{
Console.WriteLine（animal.eat（））；
}

override

是C#中的一个关键字，上面写着“嘿，我想用不同于我的基本（父）类的方式来做这件事。”它与

对于发布的代码，您有一个类层次结构。哺乳动物是一种特殊类型的动物。所以我们可以说哺乳动物继承自动物基类（

哺乳动物：动物

）

在

Animal

基类中，有

virtual

成员（比如

publicvirtualvoideat

）。这些虚拟成员中的任何一个都可以在更派生的类中重写

当您在更派生的类中重写虚拟属性或方法时，您的意思是“当有人使用此属性或方法时，如果对象是哺乳类的实例，请以与如果该实例是基本动物或其他种类的动物（如鸟、鱼或爬行动物）不同的方式执行”

---

您还可以

重写在抽象基类中声明为
abstract
的类型。重写
abstract
的工作原理几乎与重写
virtual
一样，只是没有定义基本实现（只定义了基本签名）
 公共饮食（食品）的目的是什么

namespace ConsoleApplication1
{
    public class Food
    {
        private String name;

        Food(String name)
        {
            this.name = name;
        }

        public String Name
        {
            get 
            {
                return name;
            }
            set
            {
                name = value;
            }
        }   
    }

    public class Animal
    {
        private String name = "no name";

        public String Name {
            get 
            { 
                return name; 
            }
            set 
            { 
                name = value; 
            }
        }

        private Animal() { }

        public Animal(String name)
        {
            this.name = name;
        }

        public virtual void Eat(Food food)
        {
            Console.WriteLine("Animal \"" + Name + "\" eats " + food.Name);
        }

        public virtual void Born() 
        {
            Console.WriteLine("Animal \"" + Name + "\" is born");
        }

        public virtual void Die() 
        {
            Console.WriteLine("Animal \"" + Name + "\" is died");
        }
    }

    public class Mammal : Animal
    {   
        public Mammal(String name) : base(name) { }

        public override void Eat(Food food)
        {
            Console.WriteLine("Mammal \"" + Name + "\" eats " + food.Name);
        }

        public override void Born()
        {
            Console.WriteLine("Mammal \"" + Name + "\" is born");
        }

        public override void Die()
        {
            Console.WriteLine("Mammal \"" + Name + "\" is died");
        }

        public virtual void FedMilk(Mammal[] children)
        {
            for (Int32 i = 0; i < children.Length; i++)
            {
                Console.WriteLine("Mammal \"" + Name + "\" feds milk child \"" + children[i].Name + "\"");
            }
        }
    }

    public class Horse : Mammal
    {
        public Horse(String name) : base(name) { }

        public override void Eat(Food food)
        {
            Console.WriteLine("Horse \"" + Name + "\" eats " + food.Name);
        }

        public override void Born()
        {
            Console.WriteLine("Horse \"" + Name + "\" is born");
        }
    }
}

在基类中，Eat方法被标记为virtual。这意味着它可以由继承它的任何类重新实现。这就是这段代码的作用：

public override void Eat(Food food)

它为继承类定义Eat方法。
重写使类能够更改特定方法的实现方式

通过阅读示例代码，所有
动物都可以出生、死亡和进食。
哺乳动物
和
马
类中的覆盖允许不同的功能。
马
的进食方式可能与
狗
的进食方式不同

这些方法是虚拟的这一事实允许ode，例如：

Animal[] animals = new Animal[] { new Horse(), new Dog(), new Mammal() };
foreach (Animal animal in animals)
{
    animal.Born();
    animal.Eat(new Food());
    animal.Die();
}

以上每一个电话
Mammal someMammal = new Mammal();
someMammal.Eat(new Food());

Animal someAnimal = new Animal();--must be non-abstract
someaAnimal.Eat(new Food());

Mammal someMammal = new Mammal();
someMammal.Eat(new Food());--no surprise we get mammal's eat
Animal someAnimal = (Animal)someMammal;
someAnimal.Eat(new Food());--but what happens here!?