c# - 具有许多通用和一些独特方法的类对象的设计方法

Question

在下面的示例中，我们有两个 Terrier 的实例类，派生自 Dog .
一个实例被类型为 Terrier 的变量引用.
使用此变量，您可以访问 Terrier 类的所有成员。
另一方面，类型为 Dog 的变量只能引用 Dog 的成员类，即使引用指向 Terrier 的实例.

Terrier bubba = new Terrier("Bubba", 2, "Happy");
bubba.Growl();    // Can call Terrier.Growl

Dog jack = new Terrier("Jack", 17, "Surly");
jack.Growl();     // ERROR: Can't call Growl method

我需要实现一个类 MyPets它有一个 List<Pets>可以容纳 Cat 中的任何一个对象或 Dog对象。
这两个对象都有一些常用方法，如 MakeNoise()但也有一些不在基类中的独特方法，如 Cat 有方法 ClimbTree() .
这MyPets类还将有一个方法将遍历 List<animals>并调用 MakeNoise()方法和ClimbTree()方法。

实现此目标的最佳方法是什么，使用抽象基类或其他方法？

Answer 1

关于我的评论，按照这些思路应该可以解决您的问题:

public class Visitor
{
    public void doItterate(Cat c)
    {
        Console.WriteLine(c.ToString());
        c.makeNoise();
        c.climbTree();
    }

    public void doItterate(Dog d)
    {
        Console.WriteLine(d.ToString());
        d.makeNoise();
    }
}

public abstract class Pet
{
    public Pet(string name, int age, Mood mood)
    {
        this.MoodOfPet = mood;
        this.Name = name;
        this.Age = age;
    }

    public string Name
    {
        get;
        private set;
    }

    public int Age
    {
        get;
        private set;
    }

    public Mood MoodOfPet
    {
        get;
        private set;
    }

    public abstract void makeNoise();
    public override string ToString()
    {
        return this.Name + " is " + this.Age +
            " years old  and feels " + this.MoodOfPet;
    }

    public abstract void accept(Visitor v);
}

public enum Mood
{
    Surly,
    Happy
}

public abstract class Dog : Pet
{
    public Dog(string name, int age, Mood mood): base (name, age, mood)
    {
    }

    public override void makeNoise()
    {
        Console.WriteLine(this.Name + " is woofing");
    }

    public override void accept(Visitor v)
    {
        v.doItterate(this);
    }
}

public class SheepDog : Dog
{
    public SheepDog(string name, int age, Mood mood): base (name, age, mood)
    {
    }
}

public class Cat : Pet
{
    public Cat(string name, int age, Mood mood): base (name, age, mood)
    {
    }

    public void climbTree()
    {
        Console.WriteLine(this.Name + " is climbing");
    }

    public override void makeNoise()
    {
        Console.WriteLine(this.Name + " is meowing");
    }

    public override void accept(Visitor v)
    {
        v.doItterate(this);
    }
}

public class Terrier : Dog
{
    public Terrier(string name, int age, Mood mood): base (name, age, mood)
    {
    }

    public void growl()
    {
        Console.WriteLine(this.Name + " is growling");
    }

    public override void makeNoise()
    {
        growl();
    }
}

public class MyPets
{
    private Visitor visitor = new Visitor();
    public MyPets()
    {
        Pets = new List<Pet>();
    }

    public List<Pet> Pets
    {
        get;
        private set;
    }

    public void addPet(Pet p)
    {
        Pets.Add(p);
    }

    public void itterate()
    {
        foreach (Pet p in Pets)
        {
            p.accept(visitor);
        }
    }
}

Fiddle

这是标准的 OOP 设计，使用抽象方法，稍后在更具体的类中重载。

编辑现在它正在使用访问者模式

运行以下代码:

MyPets pets = new MyPets();
pets.addPet(new Cat("Bob", 2, Mood.Surly));
pets.addPet(new Terrier("Jack", 17, Mood.Surly));
pets.addPet(new SheepDog("Bubba", 2, Mood.Happy));
pets.itterate();

产生这些结果:

Bob is 2 years old and feels Surly

Bob is meowing

Bob is climbing

Jack is 17 years old and feels Surly

Jack is growling

Bubba is 2 years old and feels Happy

Bubba is woofing