Question

所以我想设计一个像这样的团队/球员关系：每个球员都属于一个球队，但是因为我想练习接口，我做了ITeam和IAthlete，然后成为了BasketballTeam和BasketballPlayer。然后我写了这段代码：

public interface IAthlete
{
     string GetName();
     string GetSport(); 
}

public interface ITeam
{
     void AddPlayer(IAthlete player);
     IAthlete[] GetAthletes();
     string GetName();
     int GetNumberOfPlayers();
}

public class BasketballPlayer:IAthlete
{
    private string name; 

    public string GetName()
    {
        return this.name; 
    }

    public string GetSport()
    {
        return "Basketball"; 
    }

    public BasketballPlayer(string name)
    {
        this.name = name; 
    }

    public void Run(int distance)
    {
        Console.WriteLine(this.name + " just ran " + distance.ToString() + " meters."); 
    }

    public bool Shoot()
    {
        Console.WriteLine("Successful shot for " + this.name);
        return true; 
    }
}

public class BasketballTeam: ITeam      
{
    BasketballPlayer[] players;
    int numberOfPlayers; 
    private string name; 

    public void AddPlayer(BasketballPlayer player)
    {
        this.players[this.numberOfPlayers] = player;
        this.numberOfPlayers++; 
    }

    public IAthlete[] GetAthletes()
    {
        return this.players; 
    }

    public string GetName()
    {
        return this.name; 
    }

    public int GetNumberOfPlayers()
    {
        return this.numberOfPlayers; 
    }

    public BasketballTeam(string name)
    {
        this.numberOfPlayers = 0; 
        this.name = name;
        this.players = new BasketballPlayer[10]; 
    }
}

class Program
{
    static void Main(string[] args)
    {
        BasketballTeam bt = new BasketballTeam("MyTeam");
        BasketballPlayer bp = new BasketballPlayer("Bob");

        bt.AddPlayer(bp);

        foreach (BasketballPlayer player in bt.GetAthletes())
        {
            Console.WriteLine(player.GetName()); 
        }

        foreach (IAthlete a in bt.GetAthletes())
        {
            Console.WriteLine(a.GetName()); 
        }
    }
}

但它不会编译，因为我正在使用它：

public void AddPlayer(BasketballPlayer player)

在BasketballPlayer中

而不是

public void AddPlayer(IAthlete player)

我认为它应该有效，因为BasketballPlayer是IAthlete。如果我将其更改为IAthlete，那么我可以创建另一个类：

public class HockeyPlayer : IAthlete
{
    private string name;

    public string GetName()
    {
        return this.name;
    }

    public string GetSport()
    {
        return "Hockey";
    }

    public HockeyPlayer(string name)
    {
        this.name = name;
    }

    public void Run(int distance)
    {
        Console.WriteLine(this.name + " just ran " + distance.ToString() + " meters.");
    }
}

然后在我的主要内容中执行此操作：

 HockeyPlayer hp = new HockeyPlayer("Henry");
 bt.AddPlayer(hp);

这在逻辑上是错误的，因为我正在将HockeyPlayer添加到BasketballTeam。它应该是这样的，我应该小心不要那样做吗？我究竟做错了什么？如何使用类图显示这个？这会导致松耦合吗？

Answer 1

您试图违反Liskov Substitution Principle。

使用超类型可以完成的任何事情 - 例如添加HockeyPlayer - 也可以使用子类型完成 - 包括BasketballTeam。

相反，你应该使用泛型：

class Team<TPlayer> where TPlayer : IAthlete {
    public ReadOnlyCollection<TPlayer> Players { get; }
    public string Name { get; }
    public void AddPlayer(TPlayer player);
}

Answer 2

以下是您的代码的一些想法。首先，在C＃中，您可以使用属性，而不是Get和Set方法。

public interface IAthlete
{
    string Name { get; }
    string Sport { get; }
}

使用自动属性，您可以要求编译器为属性生成后备存储。还要考虑创建基类Player，它将保存Name和Sport属性的实现。

public class Player : IAthlete
{
    public Player(string name, string sport)
    {
        Name = name;
        Sport = sport;
    }

    public string Name { get; private set; }
    public string Sport { get; private set; }        
}

现在，在实现某个播放器时，您只需将值传递给基类构造函数即可。并且您的自定义播放器将仅保留特定于它们的功能（无代码重复）。另外，建议使用字符串格式，而不是连接字符串：

public class BasketballPlayer : Player
{
    public BasketballPlayer(string name)
        : base(name, "Basketball")
    {
    }

    public void Run(int distance)
    {
        Console.WriteLine("{0} just ran {1} meters.", Name, distance);
    }

    public bool Shoot()
    {
        Console.WriteLine("Successful shot for " + Name);
        return true;
    }
}

现在关于团队。如果您不想在BasketballTeam中使用FootballPlayers，那么您应该创建参数化团队。还要考虑使用IEnumerable：

public interface ITeam<TPlayer>
    where TPlayer : IAthlete
{
    void AddPlayer(TPlayer player);
    IEnumerable<TPlayer> Players { get; }
    string Name { get; }
    int NumberOfPlayers { get; }
}

同样，对于常见功能，您可以创建基类。请注意，在添加新播放器之前，您应该检查您团队中当前有多少玩家。

public class Team<TPlayer> : ITeam<TPlayer>
    where TPlayer : IAthlete
{
    private readonly List<TPlayer> _players = new List<TPlayer>();

    public Team(string name, int teamSize)
    {
        Name = name;
        TeamSize = teamSize;            
    }

    public void AddPlayer(TPlayer player)
    {
        if (_players.Count == TeamSize)
            throw new Exception("Players number exceeded");

        _players.Add(player);
    }

    public string Name { get; private set; }
    public int TeamSize { get; private set; }

    public IEnumerable<TPlayer> Players
    {
        get { return _players; }
    }

    public int NumberOfPlayers 
    {
        get { return _players.Count; }
    }       
}

自定义团队实施变得非常简单。您只需告诉它将拥有哪种类型的玩家，并传递给基础团队实施团队名称和团队规模。

public class BasketballTeam : Team<BasketballPlayer>
{
    public BasketballTeam(string name)
        : base(name, 10)
    {
    }
}

现在你的程序就像一个魅力：

class Program
{
    static void Main(string[] args)
    {
        BasketballTeam bt = new BasketballTeam("MyTeam");
        BasketballPlayer bp = new BasketballPlayer("Bob");

        bt.AddPlayer(bp);

        foreach (BasketballPlayer player in bt.Players)
        {
            Console.WriteLine(player.Name);
        }

        foreach (IAthlete a in bt.Players)
        {
            Console.WriteLine(a.Name);
        }
    }
}

Answer 3

逻辑上，

这些应该是你的基类：Team，Player

这些应该是你的派生类：BasketballTeam，BasketballPalyer

这些应该是Player上的接口：IPlay（），IRun，IGetName等..适用于哪个

依旧......

指南：动词在界面上更适合，Noun适合上课。名称中的名词最适合代码中的Class。

Answer 4

如果您的界面适合各种游戏使用，您似乎错过了这里的游戏，也许需要使用泛型：

public interface IGame
{
   string Name {get;}
   ...
}

public class Bastketball : IGame
{
   ...
}

public interface ITeam<TGame> where TGame: class, IGame
{
   void AddPlayer(IPlayr<TGame> player);
   ...
}


public interface IPlayer<TGame> where TGame: class, IGame
{
   ...

}

这将阻止曲棍球运动员加入篮球队。

Answer 5

SLaks是正确的。您可以为ITeam添加一个通用约束，使其不接受所有玩家，只接受一种类型的玩家：

public interface ITeam<T> where T : IAthlete
{
     void AddPlayer(T player);
     IAthlete[] GetAthletes();
     //  or: T[] GetAthletes();
     string GetName();
     int GetNumberOfPlayers();
}

BasketballTeam实施可能如下所示：

public class BasketballTeam : ITeam<BasketballPlayer>
{
    BasketballPlayer[] players;
    // […]

    public void AddPlayer(BasketballPlayer player)
    {
        this.players[this.numberOfPlayers] = player;
        this.numberOfPlayers++;
    }

    public IAthlete[] GetAthletes()
    {
        return this.players; 
    }

    // or:
    // public BasketballPlayer[] GetAthletes()
    // {
    //     return this.players; 
    // }

    // […]
}

两个接口和两个类之间的关系。

5 个答案: