Java中的移动机器人子类编程挑战

我被分配了以下任务：

创建一个10x10矩阵作为二维阵列。假设机器人被放置在位置[0,0]。现在随机生成一个移动。这个动作可能会将机器人带到八个可能相邻的插槽中的一个{上、下、左、右、左上角、左下角、右上角和右下角}，这些插槽由{1、2、3、4、5、6、7、8}表示。然而，在[0,0]处，机器人只有三个可能的插槽可以移动-右下角、右下角和右下角。 创建另一个名为R2的机器人，并将其放置在[9,9]上。 现在随机生成一个[1到8]范围内的整数。第一个随机整数对应于机器人R1的可能移动。如果移动有效，则将R1移动到其新插槽。如果移动机器人超出[10x10]矩阵的边界，则移动无效。如果移动无效，则继续生成随机整数，直到找到有效的移动。 对第二个机器人R2重复此步骤。 如果R1和R2都在同一个插槽中，则停止，打印最后一个插槽，打印导致R1进入此插槽的随机数序列，然后打印导致R2进入同一插槽的随机数序列。 使用Robot类和MovingRobot子类实现该程序

方法、变量、返回类型和参数均由讲师指定，不能更改

```public class Robot {

int x;
int y;
public static final int DOWN = 1;
public static final int LEFT = 2;
public static final int LEFT_DOWN_CORNER = 3;
public static final int LEFT_UP_CORNER = 4;
public static final int RIGHT = 5;
public static final int RIGHT_DOWN_CORNER = 6;
public static final int RIGHT_UP_CORNER = 7;
public static final int UP = 8;

//getters
public int getX() {
    return x;
}

public int getY() {
    return y;
}

//setters
public void setX(int x) {
    this.x = x;
}

public void setY(int y) {
    this.y = y;
}

//constructor
public Robot(int x, int y) {
    this.x = x;
    this.y = y;
}
}//end Robot class

import java.util.ArrayList;

public class MovingRobot extends Robot{
    ArrayList<Integer> moves;
    int nextMove;


//constructor
public MovingRobot(int x, int y){
    super(x, y);
}

public boolean validateNextMove() {
    if ((nextMove == LEFT || nextMove == LEFT_UP_CORNER || nextMove == LEFT_DOWN_CORNER) && (this.getY() == 0))
        return false;
    if ((nextMove == RIGHT || nextMove == RIGHT_UP_CORNER || nextMove == RIGHT_DOWN_CORNER) && (this.getY() == 9))
        return false;
    if ((nextMove == UP || nextMove == LEFT_UP_CORNER || nextMove == RIGHT_UP_CORNER) && (this.getX() == 0))
        return false;
    if ((nextMove == DOWN || nextMove == LEFT_DOWN_CORNER || nextMove == RIGHT_DOWN_CORNER) && (this.getX() == 9))
        return false;
    else
        return true;
}

public int generateNextMove(){
       return (int)(Math.random()*8) + 1;
}

public static boolean sameSlot(Robot r1, Robot r2){
    if ((r1.getX() == r2.getX()) && (r1.getY() == r2.getY()))
        return true;
    else
        return false;
}

public String printMoves(){
    String movesReport = "";
    for (var nextMove: moves) {
        if (nextMove == DOWN) movesReport += "Down, ";
        if (nextMove == LEFT) movesReport += "Left, ";
        if (nextMove == LEFT_DOWN_CORNER) movesReport += "Left Down Corner, ";
        if (nextMove == LEFT_UP_CORNER) movesReport += "Left Up Corner, ";
        if (nextMove == RIGHT) movesReport += "Right, ";
        if (nextMove == RIGHT_DOWN_CORNER) movesReport += "Right Down Corner, ";
        if (nextMove == RIGHT_UP_CORNER) movesReport += "Right Up Corner, ";
        if (nextMove == UP) movesReport += "Up, ";
    }
    return movesReport;
}

public void move(){
    do nextMove = generateNextMove();
    while (validateNextMove() == false);
    switch (nextMove) {
        case 1: //LEFT
            this.x -= 1;
            moves.add(nextMove);
            break;
        case 2: //LEFT DOWN
            this.x -= 1;
            this.y += 1;
            moves.add(nextMove);
            break;
        case 3: //LEFT UP
            this.x -= 1;
            this.y -= 1;
            moves.add(nextMove);
            break;
        case 4: //RIGHT
            this.x += 1;
            moves.add(nextMove);
            break;
        case 5: // RIGHT DOWN
            this.x += 1;
            this.y += 1;
            moves.add(nextMove);
            break;
        case 6: // RIGHT UP
            this.x += 1;
            this.y -= 1;
            moves.add(nextMove);
            break;
        case 7: // UP
            this.y -= 1;
            moves.add(nextMove);
            break;
        case 8: //DOWN
            this.y += 1;
            moves.add(nextMove);
            break;
        default: System.out.print("invalid move");
    }
}

public static void main(String[] args) {
    var r1 = new MovingRobot(0,0);
    var r2 = new MovingRobot(9, 9);
    r1.moves = new ArrayList<>();
    r2.moves = new ArrayList<>();
    while (!sameSlot(r1, r2)) {
        r1.move();
        if (!sameSlot(r1, r2)) {
            r2.move();
        }
    }
    System.out.println("Robot 1's moves were: " + r1.printMoves());
    System.out.println("Robot 2's moves were: " + r2.printMoves());
   }
}```

``公共类机器人{
int x；
int-y；
公共静态最终整数下降=1；
公共静态最终整数左=2；
公共静态最终整数左下角=3；
公共静态最终整数左上角=4；
公共静态最终整数右=5；
公共静态最终整数右下角=6；
公共静态最终整数右上角=7；
公共静态最终整数=8；
//吸气剂
公共int getX（）{
返回x；
}
公共int getY（）{
返回y；
}
//二传手
公共无效集合x（整数x）{
这个.x=x；
}
公共空间设置（整数y）{
这个。y=y；
}
//建造师
公共机器人（整数x，整数y）{
这个.x=x；
这个。y=y；
}
}//末端机器人类
导入java.util.ArrayList；
公共类移动机器人扩展机器人{
ArrayList移动；
int nextMove；
//建造师
公共移动机器人（int x，int y）{
super（x，y）；
}
公共布尔值validateNextMove（）{
如果（（nextMove==LEFT | | nextMove==LEFT | | | nextMove==LEFT | | | nextMove==LEFT | | DOWN | |）和&（this.getY（）=0））
返回false；
如果（（nextMove==RIGHT | | nextMove==RIGHT | | | nextMove==RIGHT | |下|下|下|==RIGHT |下| |下|下|下| 124
返回false；
如果（（nextMove==UP | | nextMove==LEFT | | | nextMove==RIGHT | UP | CORNER）&&（this.getX（）=0））
返回false；
如果（（nextMove==DOWN | | nextMove==LEFT | | | nextMove==RIGHT | DOWN | CORNER | | nextMove==RIGHT | DOWN |）和&（this.getX（）=9））
返回false；
其他的
返回true；
}
public int generateNextMove（）{
return（int）（Math.random（）*8）+1；
}
公共静态布尔sameSlot（机器人r1、机器人r2）{
如果（（r1.getX（）==r2.getX（））&&（r1.getY（）==r2.getY（））
返回true；
其他的
返回false；
}
公共字符串printMoves（）{
字符串movesReport=“”；
对于（var nextMove:移动）{
如果（nextMove==向下）movesReport+=“向下”；
如果（nextMove==左）movesReport+=“左”；
如果（nextMove==左下角）移动报告+=“左下角”；
如果（nextMove==左上角）移动报告+=“左上角”；
如果（nextMove==RIGHT）movesReport+=RIGHT；
如果（nextMove==右下角）移动报告+=“右下角”；
如果（nextMove==右上角）移动报告+=“右上角”；
如果（nextMove==向上）移动报告+=“向上”；
}
退货报告；
}
公开作废动议（）{
do nextMove=generateNextMove（）；
while（validateNext（）==false）；
开关（下一个移动）{
案例1://左
这个.x-=1；
移动。添加（下一步移动）；
打破
案例2://左下
这个.x-=1；
这个。y+=1；
移动。添加（下一步移动）；
打破
案例3://左起
这个.x-=1；
这个.y-=1；
移动。添加（下一步移动）；
打破
案例4://对
这个.x+=1；
移动。添加（下一步移动）；
打破
案例5://右下
这个.x+=1；
这个。y+=1；
移动。添加（下一步移动）；
打破
案例6://马上开始
这个.x+=1；
这个.y-=1；
移动。添加（下一步移动）；
打破
案例7://上升
这个.y-=1；
移动。添加（下一步移动）；
打破
案例8://关闭
这个。y+=1；
移动。添加（下一步移动）；
打破
默认值：System.out.print（“无效移动”）；
}
}
公共静态void main（字符串[]args）{
var r1=新移动机器人（0,0）；
var r2=新的移动机器人（9,9）；
r1.moves=新的ArrayList（）；
r2.moves=新的ArrayList（）；
而（！sameSlot（r1，r2））{
r1.move（）；
如果（！sameSlot（r1，r2））{
r2.move（）；
}
}
System.out.println（“机器人1的移动为：+r1.printMoves（））；
System.out.println（“机器人2的动作是：+r2.printMoves（））；
}
}```

我得到：

线程“main”java.lang.OutOfMemoryError中出现异常：java堆空间 位于java.base/java.util.Arrays.copyOf（Arrays.java:3721） java.base/java.util.Arrays.copyOf（Arrays.java:3690）位于 java.base/java.util.ArrayList.grow（ArrayList.java:237）位于 java.base/java.util.ArrayList.grow（ArrayList.java:242）位于 java.base/java.util.ArrayList.add（ArrayList.java:485）位于 java.base/java.util.ArrayList.add（ArrayList.java:498）位于 MovingRobot.move（MovingRobot.java:60）位于 main（MovingRobot.java:97）

---

x和y有值，但

移动

为

空

。确定的可能重复我已在子数组的开头初始化了数组