Question

我正在做一个使用面向对象编程的项目，我沿着水平路线比赛一只乌龟和一只野兔。我已经看过其他版本使用applet和swing，但我还没有介绍过那些，所以我更喜欢使用更简单的图形。

每只动物都有一组在x％的时间内发生的动作（我稍后会详细说明）。

野兔有五种方法：BigHop（） - 右移9个方格，SmallHop（） - 右方1个，BigSlip（） - 剩下12个方格，SmallSlip（） - 剩下2个方格，FallAsleep（） - 完全没有活动。现在，“最左边”的位置是1，所以如果野兔位于第6个方格，那么大的滑动仍然只会让它回到1.（不是-6）

对于乌龟来说，有三种方法：FastPlod（） - 右边3个正方形，SlowPlod（） - 右边1个正方形，滑动（） - 留下6个正方形，相同的规则适用于单据。

到目前为止，该程序包含一个Hare类，一个Tortoise类和一个Race类。

这是野兔班：

 public class Hare {
        private int position;

        public void setPosition(int s){
            position = s;
        }

        public int getPosition(){
            return position;
        }

        public void BigHop(){
            position += 9;
        }

        public void SmallHop(){
            position += 1;
        }

        public void BigSlip(){
            if (position > 12){
                position -= 12;
            }
            else{
                position = 1;
            }
        }

        public void SmallSlip(){
            if (position > 2){
                position -= 2;
            }
            else{
                position = 1;
            }
        }

        public void FallAsleep(){
            position = position;
        }
    }

乌龟类：

public class Tortoise {
    private int position;

    public void setPosition(int s){
        position = s;
    }

    public int getPosition(){
        return position;
    }

    public void FastPlod(){
        position += 3;
    }

    public void SlowPlod(){
        position += 1;
    }


    public void Slip(){
        if (position > 6){
            position -= 6;
        }
        else{
            position = 1;
        }
    }
}

Race类实际上执行了比赛。

public class Race {
    public static void main(String[] args){
        Hare myHare = new Hare();
        Tortoise myTortoise = new Tortoise();

        myHare.setPosition(1);
        myTortoise.setPosition(1);

        System.out.println("AND THEY'RE OFF!!");

        while (myHare.getPosition() > 0){
            int n = (int)(Math.random()*10);
            switch (n){
                case 1:
                    myHare.BigHop();
                    myTortoise.FastPlod();
                case 2:
                    myHare.BigHop();
                    myTortoise.FastPlod();
                case 3:
                    myHare.SmallHop();
                    myTortoise.FastPlod();
                case 4:
                    myHare.SmallHop();
                    myTortoise.FastPlod();
                case 5:
                    myHare.SmallHop();
                    myTortoise.FastPlod();
                case 6:
                    myHare.BigSlip();
                    myTortoise.SlowPlod();
                case 7:
                    myHare.SmallSlip();
                    myTortoise.SlowPlod();
                case 8:
                    myHare.SmallSlip();
                    myTortoise.SlowPlod();
                case 9:
                    myHare.FallAsleep();
                    myTortoise.Slip();
                case 10:
                    myHare.FallAsleep();
                    myTortoise.Slip();
            }
            if (myHare.getPosition() == myTortoise.getPosition()){
                System.out.println("OUCH!!");
            }
            if (myHare.getPosition() == 50 | myTortoise.getPosition() == 50){
                if (myHare.getPosition() == 50){
                    System.out.println("HARE WINS!!");
                    break;
                }
                else{
                    if (myHare.getPosition() == myTortoise.getPosition()){
                        System.out.println("IT'S A TIE!!");
                        break;
                    }
                    else{
                        System.out.println("TORTOISE WINS!!");
                        break;
                    }
                }
            }
        }

逻辑本身有效。比赛的构建方式是赛道上有五十个空间（赛道本身没有图形构造，这就是我遇到的麻烦）。每个动物的动作都是使用switch构造随机执行的。例如，30％的时候，乌龟会慢下来（）。

运行需要一段时间，因为有太多的滑倒，但最终我得到了一个胜利者（通常是乌龟）。所以，逻辑本身就有效。

但是，现在这是我展示的唯一输出：

AND THEY'RE OFF!! TORTOISE WINS!!

这当然是没有数百个“OUCH !!”当两只动物共享同一个位置时就会发生这种情况。所以我希望能够在50个空间的轨道上显示两个动物的位置。我曾想过用'_'作为每个空间，但我不确定如何编码乌龟或兔子的运动。

例如，可能的输出将是这样的：

_ _ _ _ _ _ _ _ T _ _ _ _ _ _ _ _ _ _ _ H _ _ _

OUCH!!

我只是不确定如何构建这样的轨道并编码T和H的移动。

我很感激任何帮助。

Answer 1

您似乎错过了break;中的switch。

        switch (n) {
            case 1:
                myHare.BigHop();
                myTortoise.FastPlod();
                break;
            case 2:
                myHare.BigHop();
                myTortoise.FastPlod();
                break;
            ...
            }

您需要在Race课程中编写另一种方法。

private static void printTrack(Player player, char symbol) {
    int position = player.getPosition();
    for (int i = 0; i < position; i++)
        System.out.print('_');

    System.out.print(symbol);

    for (int i = position + 1; i < 50; i++)
        System.out.print('_');

    System.out.println();
}

但在此之前，您需要创建一个（抽象）类或名为Player的接口，并修改要从Hare继承的类Tortoise和Player

public abstract class Player {
    protected int position;

    public void setPosition(int s){
        position = s;
    }

    public int getPosition(){
        return position;
    }
}

修改Hare和Tortoise，如下所示

public class Hare extends Player {
    /* 
    private int position;

    public void setPosition(int s){
        position = s;
    }

    public int getPosition(){
        return position;
    }
    */
    // The rest should be the same
    // Do the same with the class "Tortoise"
    ...
}

在switch之后，您可以调用该方法。

        switch (n) {
            ...
        }
        printTrack(myHare, 'H');
        printTrack(myTortoise, 'T');
        ...

代码中的某个地方有|运算符。您需要将其替换为||。

看看是否有效。

Answer 2

您可以在决策/重复结构中使用print语句执行此操作。你可以遍历每个可能的位置，如果动物在那个位置，打印相应的字母，否则打印下划线。

for (int i = 1; i <= maxPos; i++) {
    if (i == myTortoise.getPosition())
        System.out.print("T")
    else
        System.out.print("_")
    System.out.print(" ")
}
System.out.println()

上面的代码将打印出Tortoise的进展;在myHare和"H"替换为野兔。在while循环的顶部或底部插入此代码，以便在每次移动后打印进度。

Answer 3

如果您不想使用Swing或某种图形界面，您唯一能做的就是一遍又一遍地打印位置。但那当然会垃圾邮件你的控制台。

假设您不介意控制台收到垃圾邮件，您可以执行以下操作：

public static void main(String[] args){
    printPositions(3, 3, 10);
}

public static void printPositions(int hare, int tortoise, int totalTrackLenght){
    //print the position of hare
    for(int i = 1; i < hare; i++){//print leading empty spaces
        System.out.print("_ ");
    }
    System.out.print("H ");//print hare
    for(int i = hare; i < totalTrackLenght; i++){//print trailing empty spaces
        System.out.print("_ ");
    }
    //print the postion of tortoise in a similar way
    System.out.println();//remember to start on a new line
    for(int i = 1; i < tortoise; i++){//print leading empty spaces
        System.out.print("_ ");
    }
    System.out.print("T ");//print tortoise
    for(int i = tortoise; i < totalTrackLenght; i++){//print trailing empty spaces
        System.out.print("_ ");
    }
    System.out.println();//finish the line
    if(hare == tortoise){//Are they in the same spot?
        System.out.println("OUCH!");
    }
}

可以从每个帧的“主循环”调用此方法。

我希望这会有所帮助：）

野兔乌龟种族视觉显示

3 个答案: