2

我正在尝试了解如何在 C# 中使用或访问多个类，有人可以向我解释这段代码的作用吗？

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 Eat(Food food)什么？我的意思是它有什么作用？？

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");
        }
    }
}
4

5 回答 5

6

行，

您已经定义了一个名为哺乳动物的基本类，然后您创建了不同类型的哺乳动物，例如 Animal，然后是特定的动物（Horse）。

所以每个哺乳动物都需要吃东西，所以你为什么要创建一个叫做吃的函数。

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

但是每一个哺乳动物都需要吃东西。

所以在那个地方，覆盖属性很方便，它允许你覆盖“吃”的基本功能，这样你就可以指定吃每一种特定动物的东西。

因此，当您创建一个狗类时，您将覆盖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());
            }
于 2012-09-26T20:34:13.820 回答
5

override是 C# 中的一个关键字，它表示“嘿，我想以不同于我的基（父）类的方式来做这件事。” 它与多态性有关。

对于发布的代码，您有一个类层次结构。AMammal是 的特定类型Animal。所以我们可以说Mammal 继承自 Animal 基类( Mammal : Animal)。

在Animal基类中，有virtual成员（如public virtual void Eat）。这些虚拟成员中的任何一个都可以在更派生的类中被覆盖。

当您override在更派生的类中使用虚拟属性或方法时，您是在说“当有人使用此属性或方法时，如果该对象是 Mammal 的实例，则与该实例是基本 Animal 或其他一些实例时的做法不同一种动物（例如鸟、鱼或爬行动物）”。

Animal beaver = new Mammal("beaver"); // "Mammal beaver"
Animal finch = new Bird("finch"); // "Bird finch"
Animal japaneseHuman = new Mammal("Japanese human"); // "Mammal Japanese human"
Animal godzilla = new Reptile("godzilla"); // "Reptile godzilla"

beaver.Eat(new Food("wood")); // "eats wood"
finch.Eat(new Food("nuts")); // "eats nuts"
japaneseHuman.Eat(new Food("whale")); // "eats whale"
godzilla.Eat(new Food("Japanese people")); // "eats Japanese people"

您还可以在抽象基类override中声明类型。abstract覆盖abstract几乎就像覆盖一样工作virtual，除了没有定义基本实现（只定义了基本签名）。

于 2012-09-26T20:37:49.217 回答
1

覆盖为类提供了更改特定方法实现方式的能力。

通过阅读示例代码，所有Animal的 s 都可以出生，可以死亡，可以吃东西。Mammal和类中的覆盖Horse允许不同的功能。吃的方式可能与Horse吃的方式不同Dog。

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

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

上面的每个调用都会向下流动，并将调用Horse.Born()orDog.Eat(Food)实现。

于 2012-09-26T20:44:18.583 回答
1

Blockquote public override void Eat(Food food) 的目的是什么，我的意思是它有什么作用？

哺乳动物是动物类型的一类。如果 Animal 是一个抽象类，那么 Mammal 将继承 Animal 拥有的所有属性和方法，并且必须具有 Animal 中所有抽象的实现。所有抽象意味着它只是一个框架，它强制子类实现抽象类知道它们必须具备的东西才能正常运行。

哺乳动物有一种方法，食物，它是特定于其类别的，并且与所有其他动物所做的不同。尽管所有动物都可能在为食物定义的基类动物中拥有一个方法，但哺乳动物总是会使用它自己的方法——这就是覆盖的意思。

所以回顾一下：

Mammal someMammal = new Mammal();
someMammal.Eat(new Food());

在这种情况下，将调用的 eat 版本是 Mammal's Eat。

现在，如果我们这样做：

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!?

好吧，因为 Mammal 的 eat 是一个覆盖，所以哺乳动物的 eat 方法将被再次调用。如果它没有被覆盖，我们会得到动物的。

供参考，以了解有关覆盖、基类/派生类和虚拟类的更多信息。 http://msdn.microsoft.com/en-us/library/ms173152%28v=vs.80%29.aspx

于 2012-09-26T20:46:33.373 回答
0

public override void Eat(Food food)的目的是什么，我的意思是它有什么作用？？

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

public override void Eat(Food food)

它为继承类定义了 Eat 方法。

于 2012-09-26T20:39:31.093 回答