Question

你好，我需要帮助解决下一个家庭作业问题。

这只是问题的一部分，但我只需要帮助这一部分。

我想制作一个模拟奥运会的小型系统。我想模拟，游泳，骑自行车和跑步三项运动。我想要使用四种类型的运动员，游泳运动员，骑自行车者，短跑运动员（分别可以参加游泳，骑自行车和跑步比赛）和可以参加所有三场比赛的超级运动员（这是我遇到的问题最多）。每个运动员都应该有一个competition（）方法，它会随机产生10到20秒的跑步时间，100到200秒的游泳时间和500到800秒的骑行时间，这个时间将被用来阻止比赛的胜利者。

我的问题是如何模拟这个问题，使用什么类的课程，以及他们的关系是什么。我需要一种方法来制作不同的游戏对象，比如SwimGame，其中只有Swim和Super Athlete的列表。

这是我现在的做法。

所以我将有基本的抽象类运动员，循环器，跑步游泳运动员和superAthlete，将从这个班级延伸。

我还将有Game抽象类，SwimGame，CycleGame和RunningGame将从这里扩展。每场比赛都会有参赛者参赛。

我如何能够防止跑步者加入游泳比赛以及类似情况

当superAthleat可以参加所有3场比赛时，我将如何延长计算时间

起初我以为我制作了3个接口：

interface swimInterface() {
    public void calculateSwimTime();
}

interface runInterface() {
    public void calculateRunTime();
}
interface cycleInterface() {
    public void calculateCycleTime();
}

然后让swimmerAthleate实现swimInterface，然后runAthlete实现runInterface，cycleAthlete实现cycleInterface，最重要的是superAthlete实现runInterface，swimmerInterface和cycleInterface，所以我会这样：

public abstract class Athlete {
    ...
    // what should be here
}

public class SwimAthlete extends Athlete implements SwimInterface {

     ...
     public void calculateSwimTime() {...}
}

public class RunAthlete extends Athlete implements RunInterface {

     ...
     public void calculateRunTime() {...}
}

public class CylcleAthlete extends Athlete implements CycleInterface {

     ...
     public void calculateCycleTime() {...}
}

public class SuperAthlete extends Athlete implements SwimInterface, CycleInterface, RunInterface() {

     public void calculateSwimTime() {...}
     public void calculateRunTime() {...}   
     public void calculateCycleTime() {...}

}

但后来我还有很多其他问题：如果我有这样的事情：

public class Game {
    ArrayList<Athlete> listOfCompetitors;
    public Game(){
        listOfCompetitors = new ArrayList<Athlete>();
    }
}

public class SwimGame extends Game {
    // I could have something like this here
    // how could I add only SwimAthlete and SuperAthlete here

    // how to traverse the array of athletes and only call calculateSwimTime method.

} 

// similar for other games.

如果您需要更多解释，我非常愿意讨论这个问题。

Answer 1

interface Sport
{
    void compete();
}

abstract class Athlete implements Sport
{
    String name;

    int time = 0;

    void setName(String name)
    {
        this.name = name;
    }

    void setTime(int time)
    {
        this.time = time;
    }

    String getName() { return name; }
    int getTime() { return time; }
}

class Runner extends Athlete
{
    Runner(String name)
    {
        setName(name);
    }

    @Override
    public void compete()
    {
        int time = 10 + (int) (Math.random() * ((20d - 10d) + 1d));

        setTime(time);
    }
}

class Swimmer extends Athlete
{
    Swimmer(String name)
    {
        setName(name);
    }

    @Override
    public void compete()
    {
        int time = 100 + (int) (Math.random() * ((200d - 100d) + 1d));

        setTime(time);
    }
}

class Cyclist extends Athlete
{
    Cyclist(String name)
    {
        setName(name);
    }

    @Override
    public void compete()
    {
        int time = 500 + (int) (Math.random() * ((800d - 500d) + 1d));

        setTime(time);
    }
}

接口和继承java

1 个答案: