Question

我试图为10名运动员的“运动”抽象课程实例化对象，其中列出了每个运动员的名字和年龄，然后有两个派生类别用于“网球”运动员和一个用于“高尔夫”的运动员。

  class Program
    {
        static void Main(string[] args)
        {
            Sport[] athlete = new Sport[10];
            athlete[0] = new Tennis("John Smith", 18, "Tennis", 5.0, 92);
            athlete[1] = new Tennis("Lisa Townsend", 15, "Tennis");
            athlete[2] = new Tennis("Brian Mills", 17, "Tennis", 4.0, 83);
            athlete[3] = new Golf("Stacey Bell", 16, "Golf", 10, 20);
            athlete[4] = new Golf("Tom Spehr", 18, "Golf", 9, 12);
            athlete[5] = new Golf("Sam Calen", 14, "Golf");
            athlete[6] = new Tennis("Karen Strong", 17, "Tennis", 3.0, 78);
            athlete[7] = new Golf("Ken Able", 15, "Golf", 15, 16);
            athlete[8] = new Tennis("Troy Soni", 18, "Tennis", 4.5, 93);
            athlete[9] = new Golf("Toni Palmer", 17, "Golf", 8, 22);

            for (int i = 0; i < 10; i++)
            {
                Console.WriteLine("{0}", athlete[i]);
            }    
        }
    }

我正在尝试像这样打印数组，但它输出不正确。当我尝试单独打印数据字段时

Console.WriteLine（“{0} {1}”，运动员[i] .name，运动员[i] .age）

我可以输出每个运动员的姓名和年龄，但如果我尝试添加其他字段，他们将无法输出。我应该将每个数组对象声明为“Sport”而不是Tennis或Golf吗？

编辑：

这是体育课

abstract class Sport
{

    protected string name;
    protected int age;

    public Sport(string name, int age)
    {
        Name = name;
        Age = age;
    }
    public string Name
    {
        get
        {
            return name;
        }
        set
        {
            name = value;
        }
    }
    public int Age
    {
        get
        {
            return age;
        }
        set
        {
            age = value;
        }
    }
    public abstract void Performance();
 }

这里是派生的网球类（高尔夫球的结构方式与变量名称略有不同）

   class Tennis : Sport
    {
        private string type;
        private double rating;
        private int serveSpeed;

        public Tennis(string name, int age, string type, double rating, int serveSpeed) : base(name, age)
        {
            Rating = rating;
            Type = type;
            ServeSpeed = serveSpeed;
        }
        public Tennis(string name, int age, string type) : base(name, age)
        {
        }
        public double Rating
        {
            get
            {
                return rating;
            }
            set
            {
                rating = value;
            }
        }
        public string Type
        {
            get
            {
                return type;
            }
            set
            {
                type = "Tennis";
            }
        }
        public int ServeSpeed
        {
            get
            {
                return serveSpeed;
            }
            set
            {
                serveSpeed = value;
            }
        }

Answer 1

让我们解决这个问题。现在是你的C＃职业生涯中学习良好习惯和习惯的时候了。

abstract class Sport

运动？不。此课程不代表体育。此类代表玩家。体育是他们的运动。你在Main中命名当地“运动员”的事实告诉你，你在这里犯了一个错误。请拨打此Athlete或Player或其他内容。我们说Player，因为派生类可以是TennisPlayer和GolfPlayer或Golfer。

protected string name;
protected int age;

为何受到保护？你有公共的吸气者和制定者包装这些！

完全消除支持字段。

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

这些都是不必要的罗嗦;使用自动属性。

public int Age

年龄不断变化;生日不。存储生日，然后看

How to calculate an age based on a birthday?

public abstract void Performance();

我不知道这意味着什么，但可能是错的。抽象方法通常是动词，但这是一个名词。这不应该是Perform吗？还是Play？你从派生类中省略了这一点，所以让我们忽略它。

我们也想说一下我们的运动。所以让我们为此做一个类型。把它们放在一起：

enum Sport { Tennis, Golf }      
public abstract class Player 
{
  // Consider making Name and Birthday get-only as well.
  // Is there any situation in which they change after construction?
  // If not, then *don't allow them to change*!
  public string Name { get; set; }
  public DateTime Birthday { get; set; }
  public abstract Sport Sport { get; }
  public Player(string name, DateTime birthday) 
  {
    this.Name = name;
    this.Birthday = birthday;
  }
}

更短更容易理解。现在让我们推导出一些类型。我们将再次缩短属性，并添加ToString。

另外，Rating真的是 double 吗？使用双打作为身高，如身高或体重。我怀疑这是 decimal ，而不是 double 。如果将3.4的等级实际存储为3.39999999999999999绝对非常错误，那么double是要使用的错误类型，而decimal是要使用的正确类型。

public sealed class TennisPlayer : Player
{
  public override Sport Sport => Sport.Tennis;
  // Again, do these change after construction? If not
  // then remove the setters.
  public decimal Rating { get; set; }
  public int ServeSpeed { get; set; }
  public TennisPlayer(string name, DateTime birthday, decimal rating, int speed) : base(name, birthday) 
  {
    this.Rating = rating;
    this.ServeSpeed = speed;
  }
  public override string ToString() 
  {
    return @"Tennis player: {Name} {Birthday} {Rating} {ServeSpeed}";
  }
}

同样，更短，更容易阅读。现在，您对GolfPlayer或Golfer或其他任何名称都做同样的事情。

Answer 2

如果我理解你的问题，你希望能够为你的班级输出一个友好的字符串，他们总是输出Name和Age，然后为每项运动输出他们的特定属性这项运动。

这可以通过覆盖ToString属性来完成。您可以在Name和Age的基类中执行此操作，然后在每个单独的类中输出base.ToString以及任何特定的类属性。

例如，基类将输出Name和Age：

abstract class Sport
{
    public override string ToString()
    {
        return string.Format("{0} {1}", Name, Age);
    }

    // Rest of class code omitted...

网球课也将输出其他一些领域：

class Tennis : Sport
{
    public override string ToString()
    {
        return string.Format("{0} [Sport: {1}] [Rating: {2}] [Serve Speed: {3}]",
            base.ToString(), Type, Rating, ServeSpeed);
    }

    // Rest of class code omitted...

然后您的输出将如下所示：

另请注意Sport字符串对Lisa Townsend为空，因为用于实例化该实例的构造函数未设置Type属性。

使用C＃中的基类和派生类在数组中实例化对象

2 个答案: