Java 使用GridLayout创建战舰程序时遇到问题

好的，我有一个任务，我们必须使用GUI用Java创建一个低端战舰程序。我们必须创建一个

JLabel

对象数组，并附上一个图像（用于水）。我使用

GridLayout

完成了这项工作

董事会很好，但是如果我尝试添加一艘船，（我现在只是想看看如何将一艘船添加到董事会上），我要么没有显示任何东西，要么，就像我目前的代码一样，我可以让船在董事会上显示，但它们往往会相互重叠。（有一个问题，他们越过边缘，但我解决了这一部分

所以我想知道是否有人会介意看一下我的代码，告诉我我是否做得不对。

GridLayout

是应该做的，还是应该使用其他方法？我也想知道是否有更有效的方法来操纵船只，尤其是这样它们就不会重叠，因为我不能似乎找到了真正有效的方法。这是不是在

GridLayout

中不可能实现？以下是我的代码：

package battleship;

import java.awt.Container;
import java.awt.GridLayout;
import java.awt.image.BufferedImage;
import java.io.IOException;
import java.net.MalformedURLException;
import java.net.URL;
import java.util.ArrayList;
import java.util.Random;
import javax.imageio.ImageIO;
import javax.swing.Icon;
import javax.swing.ImageIcon;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JPanel;
import javax.swing.SpringLayout;

public class Battleship extends JFrame {

private ImageIcon waterImg, shipCovered, boatImgEndH1, boatImgEndH2, boatImgMidH, boatImgFrntH2, boatImgFrntH1,
        boatImgEndV1, boatImgEndV2, boatImgMidV, boatImgFrntV2, boatImgFrntV1;
private Container content;
private JPanel boardFrame;
private JLabel[][] boardGrid;
public JLabel label, label2;
private int width, length;

public Battleship() {
}

public Battleship(int width, int length) {
    SpringLayout layout = new SpringLayout();
    this.width = width;
    this.length = length;
    this.setVisible(true);
    this.setSize(640, 540);
    this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    content = this.getContentPane();
    content.setLayout(layout);

    try {
                 BufferedImage water = ImageIO.read(new URL("http://i.stack.imgur.com/gJmeJ.png"));
                 BufferedImage ship = ImageIO.read(new URL("http://i.stack.imgur.com/T5uTa.png"));

                 waterImg = new ImageIcon(new ImageIcon(water).getImage());
                 boatImgEndH1 = new ImageIcon(new ImageIcon(ship).getImage());
                 boatImgEndH2 = new ImageIcon(new ImageIcon(ship).getImage());
                 boatImgMidH = new ImageIcon(new ImageIcon(ship).getImage());
                 boatImgFrntH2 = new ImageIcon(new ImageIcon(ship).getImage());
                 boatImgFrntH1 = new ImageIcon(new ImageIcon(ship).getImage());
                 boatImgEndV2 = new ImageIcon(new ImageIcon(ship).getImage());
                 boatImgEndV1 = new ImageIcon(new ImageIcon(ship).getImage());
                 boatImgMidV = new ImageIcon(new ImageIcon(ship).getImage());
                 boatImgFrntV2 = new ImageIcon(new ImageIcon(ship).getImage());
                 boatImgFrntV1 = new ImageIcon(new ImageIcon(ship).getImage());
                } catch (MalformedURLException ex) {
                    throw new Error("One of the cameras you are trying to connect to doesn't exist!");
                } catch (IOException ex) {
                    throw new Error("CCTV couldn't connect to the required camera feeds!");
                }

    boardFrame = new JPanel(new GridLayout(width, length, 1, 1));

    content.add(boardFrame);
    layout.putConstraint(SpringLayout.WEST, boardFrame, 5, SpringLayout.WEST, content);
    layout.putConstraint(SpringLayout.NORTH, boardFrame, 5, SpringLayout.NORTH, content);

    boardGrid = new JLabel[width][length];

    for (int x = 0; x < width; x++) {
        for (int y = 0; y < length; y++) {
            boardFrame.add(boardGrid[x][y] = new JLabel(waterImg, JLabel.CENTER));
        }
    }
    twoShip();
    threeShip();

    this.setVisible(true);
    boardFrame.setVisible(true);

}

public int random(int n) {

Random randNumGenerator = new Random();
    int random= randNumGenerator.nextInt(n) + 1;
return random;
}

private void twoShip() {
    int ran5 = random(width - 1);
    int ran4 = random(width - 2);
    int ran2 = random(2);

    int max = (ran5 - 1);
    while (boardGrid[ran5][ran5].getIcon().equals(waterImg)) {
            if (ran2 == 2) {
                if (ran5 >= (width - 1)) {
                    while (!boardGrid[max][ran4].getIcon().equals(waterImg)) {
                        return;
                    } while (boardGrid[max][ran4].getIcon().equals(waterImg)) {
                        boardGrid[max][ran4].setIcon(boatImgEndV1);
                    }
                } else {
                    while(!boardGrid[ran5][ran4].getIcon().equals(waterImg)) {
                        return;
                    } while (boardGrid[ran5][ran4].getIcon().equals(waterImg)) {
                        boardGrid[ran5][ran4].setIcon(boatImgEndV1);
                    }
                }
                if (ran5 >= (width - 1)) {
                    while (!boardGrid[max + 1][ran4].getIcon().equals(waterImg)) {
                        return;
                    } while (boardGrid[max + 1][ran4].getIcon().equals(waterImg)) {
                        boardGrid[max + 1][ran4].setIcon(boatImgFrntV1);
                    }
                } else {
                    while(!boardGrid[ran5 + 1][ran4].getIcon().equals(waterImg)) {
                        return;
                    } while (boardGrid[ran5 + 1][ran4].getIcon().equals(waterImg)) {
                        boardGrid[ran5 + 1][ran4].setIcon(boatImgFrntV1);
                    }
                }
            } else {
                if (ran5 >= (width - 1)) {
                    while(!boardGrid[ran4][max].getIcon().equals(waterImg)) {
                        return;
                    } while (boardGrid[ran4][max].getIcon().equals(waterImg)) {
                        boardGrid[ran4][max].setIcon(boatImgEndH1);
                    }
                } else if (ran5 <= (width - 1)) {
                    while(!boardGrid[ran4][ran5].getIcon().equals(waterImg)) {
                        return;
                    } while (boardGrid[ran4][ran5].getIcon().equals(waterImg)) {
                        boardGrid[ran4][ran5].setIcon(boatImgEndH1);
                    }
                }
                if (ran5 >= (width - 1)) {
                    while (!boardGrid[ran4][max + 1].getIcon().equals(waterImg)) {
                        return;
                    } while (boardGrid[ran4][max + 1].getIcon().equals(waterImg)) {
                        boardGrid[ran4][max + 1].setIcon(boatImgFrntH1);
                    }
                } else if (ran5 <= (width - 1)) {
                    while (!boardGrid[ran4][ran5 + 1].getIcon().equals(waterImg)) {
                        return;
                    } while (boardGrid[ran4][ran5 + 1].getIcon().equals(waterImg)) {
                        boardGrid[ran4][ran5 + 1].setIcon(boatImgFrntH1);
                    }
                }
            }
    }
}

private void threeShip() {
    int ran3 = random(width - 1);
    int ran2 = random(2);

    int max = (ran3 - 2);
    for (int x = 0; x < width; x++) {
        for (int y = 0; y < length; y++) {
            if (ran2 == 2) {
                if (boardGrid[x][y].getIcon().equals(waterImg)) {
                    if (ran3 >= (width - 3)) {
                        boardGrid[max][ran3].setIcon(boatImgEndV1);
                        boardGrid[max][ran3].validate();
                    } else {
                        boardGrid[ran3][ran3].setIcon(boatImgEndV1);
                    }
                }
                if (boardGrid[x][y].getIcon().equals(waterImg)) {
                    if (ran3 >= (width - 3)) {
                        boardGrid[max + 1][ran3].setIcon(boatImgMidV);
                    } else {
                        boardGrid[ran3 + 1][ran3].setIcon(boatImgMidV);
                    }
                }
                if (boardGrid[x][y].getIcon().equals(waterImg)) {
                    if (ran3 >= (width - 3)) {
                        boardGrid[max + 2][ran3].setIcon(boatImgFrntV1);
                    } else {
                        boardGrid[ran3 + 2][ran3].setIcon(boatImgFrntV1);
                    }
                }
            } else {
                if (boardGrid[x][y].getIcon().equals(waterImg)) {
                    if (ran3 >= (width - 3)) {
                        boardGrid[ran3][max].setIcon(boatImgEndH1);
                    } else {
                        boardGrid[ran3][ran3].setIcon(boatImgEndH1);
                    }
                }
                if (boardGrid[x][y].getIcon().equals(waterImg)) {
                    if (ran3 >= (width - 3)) {
                        boardGrid[ran3][max + 1].setIcon(boatImgMidH);
                    } else {
                        boardGrid[ran3][ran3 + 1].setIcon(boatImgMidH);
                    }
                }
                if (boardGrid[x][y].getIcon().equals(waterImg)) {
                    if (ran3 >= (width - 3)) {
                        boardGrid[ran3][max + 2].setIcon(boatImgFrntH1);
                    } else {
                        boardGrid[ran3][ran3 + 2].setIcon(boatImgFrntH1);
                    }
                }
            }
        }
    }
}

public static void main(String[] args) {
    new Battleship(17, 17);
}

package战舰；
导入java.awt.Container；
导入java.awt.GridLayout；
导入java.awt.image.buffereImage；
导入java.io.IOException；
导入java.net.MalformedURLException；
导入java.net.URL；
导入java.util.ArrayList；
导入java.util.Random；
导入javax.imageio.imageio；
导入javax.swing.Icon；
导入javax.swing.ImageIcon；
导入javax.swing.JFrame；
导入javax.swing.JLabel；
导入javax.swing.JPanel；
导入javax.swing.SpringLayout；
公共级战列舰扩展JFrame{
私人图像Icon waterImg、shipCovered、boatImgEndH1、boatImgEndH2、boatImgMidH、boatImgFrntH2、boatImgFrntH1、，
boatImgEndV1、boatImgEndV2、boatImgMidV、boatImgFrntV2、boatImgFrntV1；
私人容器内容；
私人JPanel boardFrame；
私人JLabel[][]boardGrid；
公共JLabel标签，标签2；
私有int宽度、长度；
公共战舰（）{
}
公共战舰（整数宽度，整数长度）{
SpringLayout布局=新的SpringLayout（）；
这个。宽度=宽度；
这个长度=长度；
此.setVisible（true）；
这个。设置大小（640540）；
此.setDefaultCloseOperation（JFrame.EXIT_ON_CLOSE）；
content=this.getContentPane（）；
content.setLayout（布局）；
试一试{
BuffereImage water=ImageIO.read（新URL（“http://i.stack.imgur.com/gJmeJ.png"));
BuffereImage ship=ImageIO.read（新URL（“http://i.stack.imgur.com/T5uTa.png"));
waterImg=newImageIcon（newImageIcon（water.getImage（））；
boatImgEndH1=newimageicon（newimageicon（ship.getImage（））；
boatImgEndH2=newimageicon（newimageicon（ship.getImage（））；
boatImgMidH=newImageIcon（newImageIcon（ship）.getImage（））；
boatImgFrntH2=新图像图标（新图像图标（ship.getImage（））；
boatImgFrntH1=newimageicon（newimageicon（ship.getImage（））；
boatImgEndV2=newImageIcon（newImageIcon（ship）.getImage（））；
boatImgEndV1=newImageIcon（newImageIcon（ship）.getImage（））；
boatImgMidV=newImageIcon（newImageIcon（ship）.getImage（））；
boatImgFrntV2=newimageicon（newimageicon（ship）.getImage（））；
boatImgFrntV1=新图像图标（新图像图标（ship.getImage（））；
}捕获（格式错误）{
抛出新错误（“您试图连接的某个摄像头不存在！”）；
}捕获（IOEX异常）{
抛出新错误（“CCTV无法连接到所需的摄像机源！”）；
}
boardFrame=新的JPanel（新的网格布局（宽度、长度、1、1））；
内容。添加（boardFrame）；
layout.putConstraint（SpringLayout.WEST，boardFrame，5，SpringLayout.WEST，content）；
layout.putConstraint（SpringLayout.NORTH，boardFrame，5，SpringLayout.NORTH，content）；
boardGrid=新的JLabel[宽度][长度]；
对于（int x=0；x=（宽度-1））{
而（！boardGrid[max][ran4].getIcon（）.equals（waterImg））{
返回；
}while（boardGrid[max][ran4].getIcon（）.equals（waterImg））{
boardGrid[max][ran4].setIcon（boatImgEndV1）；
}
}否则{
而（！boardGrid[ran5][ran4].getIcon（）.equals（waterImg））{
返回；
}while（boardGrid[ran5][ran4].getIcon（）.equals（waterImg））{
boardGrid[ran5][ran4].setIcon（boatImgEndV1）；
}
}
如果（ran5>=（宽度-1））{
而（！boardGrid[max+1][ran4].getIcon（）.equals（waterImg））{
返回；
}while（boardGrid[max+1][ran4].getIcon（）.equals（waterImg））{
boardGrid[max+1][ran4].setIcon（boatImgFrntV1）；
}
}否则{
而（！boardGrid[ran5+1][ran4].getIcon（）.equals（waterImg））{
返回；
}while（boardGrid[ran5+1][ran4].getIcon（）.equals（waterImg））{
boardGrid[ran5+1][ran4].setIcon（boatImgFrntV1）；