Question

所以我目前有一个地址簿程序（故意基本，因为没有花哨写任何更花哨的东西）所以评估的模块正在完成（这不是学校工作）。

我必须在这个模块中演示多态，封装和继承。

我想知道实现IEnumerable是否算作多态，如下所示？

public class AddressBookEnumerator : IEnumerator
{
    #region IEnumerable Implementation
    public Person[] Contacts;
    int Position = -1;

    public AddressBookEnumerator(Person[] ContactList)
    {
        Contacts = ContactList;
    }

    public bool MoveNext()
    {
        Position++;
        return (Position < Contacts.Length);
    }

    public void Reset()
    {
        Position = -1;
    }

    object IEnumerator.Current
    {
        get
        {
            return Current;
        }
    }

    public Person Current
    {
        get
        {
            try
            {
                return Contacts[Position];
            }
            catch (IndexOutOfRangeException)
            {
                throw new InvalidOperationException();
            }
        }
    }
    #endregion
}

我只是想知道是否因为继承了IEnumerator类，然后为我的特定类创建了具有不同行为的新方法？或者我只是误解了IEnumerator的工作原理。

Answer 1

Polymorphism是

一种编程语言功能，允许不同数据的值使用统一接口处理的类型。

在提供的当前代码中，我只看到您操作的一个数据类型。

实施IEnumerable是关于订阅给定界面的合同，因此您的类型可以像该界面一样受到威胁。就个人而言，我不会像polymorphism示例那样代替这个代码。

Answer 2

我会尽快将其分解，

interface IOrganism
{
    string GetSpecies();
}

abstract class Animal : IOrganism
{
    abstract string GetSpecies();
}

class Rat : Animal
{
   public virtual string GetSpecies()
   {
      return "Ratus";
   }
}

sealed class BlackRat : Rat
{
    public override string GetSpecies()
    {
       return string.Format("{0} Ratus", base.GetSpecies()));
    }
}

Animal，Rat和BlackRat都是IOrganism的多态。 Rat和BlackRat与Animal具有多态性。最后，BlackRat与Rat具有多态性。

这意味着，我可以写一个函数，

void OutputSpecies(IOrganism organism)
{
    Console.WriteLine(organism.GetSpecies());
}

它可以接受IOrganism的任何实现者，无论是Rat，BlackRat还是未来的实现者，因为它们都是IOrganism的多态性。

因此，回答原始问题，实现一个接口，如IEnumerable并将其用作函数的参数是使用多态。但是，您的代码只是实现了IEnumerator，所以有一半的方法。它显示了多态性的潜力，但在实践中没有多态性。

此外，使用IEnumerator作为示例可能会分散所需任务的注意力，您可能最好让您的示例更抽象。

Answer 3

虽然您可以考虑将接口级别的类型视为多态，但对于更具学术性的方法，他们可能会更多地考虑这些行吗？

我们在这里看到：

从抽象基类Employee
当我们引用GetBonusMultiplier方法时封装/多态。我们能够从抽象基类中引用该方法，并且我们也不知道每种类型如何确定基本乘数的内部。我们所知道/关心的是，当我们调用方法时，我们会得到一个int值。

如果您想将Employee更改为接口IEmployee，那么这很简单。我可能仍然会有一些抽象基础来捕获常见字段，因此您不必在实现IEmployee的每个类中重新实现。

class Program
{
    static void Main(string[] args)
    {
        var employees = new List<Employee>
        {
            new Manager(1, "Dave Smith"),
            new Director(2, "Peter Thompson")
        };

        foreach (Employee employee in employees)
        {
            Console.WriteLine(string.Format("Employee ID: {0}. Employee Name: {1}. Bonus Multiplier: {2}.", employee.Id, employee.Name, employee.GetBonusMultiplier()));
        }
        Console.ReadKey();
    }
}

abstract class Employee
{
    public int Id { get; protected set; }
    public string Name { get; protected set; }

    public abstract int GetBonusMultiplier();
}

class Director : Employee
{
    public Director(int employeeId, string name)
    {
        Id = employeeId;
        Name = name;
    }

    public override int GetBonusMultiplier()
    {
        return 3;
    }
}

class Manager : Employee
{
    public Manager(int employeeId, string name)
    {
        Id = employeeId;
        Name = name;
    }

    public override int GetBonusMultiplier()
    {
        return 2;
    }
}

实践中的多态性c＃

3 个答案: