Eclipse:Java，未找到主方法

我最近把我所有的代码都从BlueJ手动导入到eclipse项目中，然后我习惯了“运行配置”的设置，最后我认为我是自由的。然后我运行代码，得到了这个错误

java.lang.NoSuchMethodError: main
Exception in thread "main" 

所以我想我必须添加一个主方法（我从来没有在BlueJ中这样做过，为什么？）。所以我只是调用了构造函数方法（在BlueJ中，我只是创建了一个新对象，JFrame就会显示出来）。所以我犯了同样的错误。在尝试不同的事情后（例如将构造函数中的代码移动到不同的方法等）。我只是把它作为主要方法：

public void main(String[] args)
{
    System.out.println("Hello, this is main why won't Java find this.");
}

在那之后，我仍然得到相同的错误，所以我决定将它添加到我的所有类中，以确保它没有使用另一个类作为主类。还是同样的错误，所以我来问你们是否有人遇到过这个问题。我也在谷歌上搜索过，我发现的只是

私有类等的问题，感觉我所有的类都是
公共类（嘿，我来自Python:））。我知道这不是问题所在。请帮忙：）

我的跑步配置图片


这是我的主要方法代码
警告：长

import java.awt.event.*;
import java.awt.*;
import javax.swing.*;

public class AppFrame extends JFrame
{

    public String status = "Status:";// Status of Applet
    public int paint_count = 1;// Number of times applet has been painted
    public int[] mousePos = {-1, -1};// Stores Mouse's Last Clicked X and Y Cordinates
    public int[] boardPos = {-1, -1};//Stores The Board's X and Y Cordinates
    public int[] selectedSquarePos = {-1, -1};

    public int[] boardSquare = {-1, -1};//Stores Last Clicked Square

    public Color P1_Color = Color.GRAY;
    public Color P2_Color = Color.WHITE;
    public Color SquareEven = Color.BLACK;
    public Color SquareOdd = Color.RED;// pieces move on this one

    public int boardHeight = 400;
    public int boardWidth = 400;

    public boolean pieceSelected = false;
    public boolean CheckersPiece = false;

    public Board CheckersBoard = new Board();

    public Image buffer = null;
    public Graphics bg = null;

    public void main(String[] args)
    {
        System.out.println("Hello, this is main why won't Java find this.");
    }
    public AppFrame()
    {
        super("JCheckers");
        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        setSize(900,900);
        setVisible(true);

        buffer = createImage(getWidth(), getHeight());
        boardHeight = getHeight() - 40; // 20 pixel border at top and bottom and 20 pixels for blue bar
        boardWidth = getWidth() - 40; // 20 pixel border at left and right
        bg = buffer.getGraphics();

        addMouseListener(new MouseAdapter()
        {
            public void mouseClicked (MouseEvent e)
            {
                handleClick(e);
            }
        }
        );
    }

    public void handleClick(MouseEvent e)
    {
        /* Handles tracking of mouse clicks; DOES NOT HANDLE DISPLAY, it just updates the data and calls redraw */
        mousePos[0] = e.getX();
        mousePos[1] = e.getY();
        repaint();
    }

    public void paint(Graphics g)
    {
        super.paint(g);
        render(g);
    }

    public void render(Graphics g)
    {   
        bg.clearRect(0,0, getWidth(), getHeight());

        //Draw Chess Board and Pieces
        renderChessBoard(bg, 20, 20);

        // Display Info
        System.out.println(status);
        System.out.println(String.format("Last Mouse Click @ (X:%d Y:%d)", mousePos[0], mousePos[1]) );
        System.out.println("Paint #" + paint_count );
        System.out.println(String.format("Board Square (x:%s, y:%s) %b", boardSquare[0], boardSquare[1], CheckersPiece) );
        System.out.println(CheckersBoard.status );
        paint_count += 1;
        // Draw Image to Screen
        g.drawImage(buffer, 0, 25, null);// so it does not get hidden by the blue close/min/max room

    }

    public boolean isValidSquare(int col, int row)
    {
        if (col > -1 & col < 8) {return true;}
        return false;
    }

    public void renderChessBoard(Graphics g, int x, int y)
    {
        /* Renders board and pieces*/
        // sense the row squares are well squares then the
        // board will be a square also; so we draw it with whatever
        // side is smallest, width or height
        boardPos[0] = x;
        boardPos[1] = y;

        drawBoard(g, x, y, boardWidth, boardHeight);
        boardSquare = getBoardSquare(mousePos[0], mousePos[1]);
        CheckersPiece = isCheckersPiece(boardSquare[0], boardSquare[1]);
        boolean validSquare = isValidSquare(boardSquare[0], boardSquare[1]);
        if (validSquare)
        {
            if (CheckersPiece)
            {
                selectSquare(g, boardSquare[0], boardSquare[1]);
            }
            else
            {
                if (pieceSelected)
                {
                    int selectedCol = selectedSquarePos[0];
                    int selectedRow = selectedSquarePos[1];
                    int toCol = boardSquare[0];
                    int toRow = boardSquare[1];

                    System.out.println(selectedCol + " " + selectedRow + " " + toCol + " " + toRow);
                    if (!CheckersBoard.move(selectedSquarePos, boardSquare)) // not a valid move;
                    {
                        pieceSelected = false;   
                    }
                }
            }
        }
        parseBoard(CheckersBoard.board, g);
    }

    public void drawBoard(Graphics g, int Bx, int By, int Bw, int Bh)
    {
        int numberRowsDrawed = 0;

        int rH = Bh / 8;
        int rW = Bw; // Row width is the same as the Board's width because the board and the row share the same sides

        while (numberRowsDrawed < 8)
        {

            int rY = (numberRowsDrawed * rH) + By;
            // Row X is the same as the Board X because the board and the row share the same sides
            int rX = Bx;

            Color EVEN = SquareEven;
            Color ODD = SquareOdd;
            // Yes Yes The EVEN Color is now odd and vica versa its because rows only now there row counts and so they start at 0 and don't
            // include the rows above
            if ((numberRowsDrawed % 2) != 0) {EVEN = SquareOdd; ODD = SquareEven;}

            drawRow(g, rX, rY, rW, rH, EVEN, ODD);
            numberRowsDrawed +=1;

        }

    }

    public void drawRow(Graphics g, int x, int y, int width, int height, Color EVEN, Color ODD)
    {   
        System.out.println("Board Y: " + y);
        int squareW = width / 8;
        int squareH = height;
        int numberSquaresCreated = 0;
        while (numberSquaresCreated < 8)
        {
            // needs a special case because Java's modulo uses division (so it would give a divide by 0 error) STUPID JAVA!!!!!!
            if (numberSquaresCreated == 0)
            {
                g.setColor(EVEN);
                g.fillRect(x, y, squareW, squareH);
            }
            else
            {
                if (numberSquaresCreated % 2 == 0){g.setColor(EVEN);}
                else {g.setColor(ODD);}
                int sX = x + (squareW * numberSquaresCreated);
                g.fillRect(sX, y, squareW, squareH);
            }
            numberSquaresCreated +=1;
        }
    }

    public void drawMan(Graphics g, int boardRow, int boardCol, Color pieceColor)
    {
        int x = boardPos[0];
        int y = boardPos[1];
        int pixelPosX = x + ((boardWidth / 8) * boardRow);
        int pixelPosY = y + ((boardHeight / 8) * boardCol);
        g.setColor(pieceColor);
        g.fillOval(pixelPosX + 13, pixelPosY + 13, (boardWidth / 8) - 26, (boardHeight / 8) - 26);
    }

   public void drawKing(Graphics g, int boardRow, int boardCol, Color pieceColor, Color crownColor)
   {
       drawMan(g, boardRow, boardCol, pieceColor);
       g.setColor(crownColor);
       int x = boardPos[0];
       int y = boardPos[1];
       double DsizeFactor = ( (float) boardHeight / 8.0) / 3.75;
       int sizeFactor = (int) DsizeFactor;
       int pixelPosX = x + ((boardWidth / 8) - sizeFactor) / 2 + ((boardWidth / 8) * boardRow);
       int pixelPosY = y + ((boardHeight / 8) - sizeFactor) / 2 + ((boardHeight / 8) * boardCol);
       int[] xPoints = {pixelPosX, pixelPosX,  pixelPosX + sizeFactor, pixelPosX + sizeFactor, pixelPosX + ((sizeFactor * 3) / 4), pixelPosX + (sizeFactor / 2),  pixelPosX + (sizeFactor / 4) };
       int[] yPoints = {pixelPosY, pixelPosY + sizeFactor, pixelPosY + sizeFactor, pixelPosY,  pixelPosY + (sizeFactor / 2), pixelPosY, pixelPosY + (sizeFactor / 2)};
       g.fillPolygon(xPoints, yPoints, 7);
   }

   public void selectSquare(Graphics g, int bSX, int bSY)
   {
       g.setColor(Color.YELLOW);
       /*+10 is to offset text (the xy cordinates are the bottom left side of the text NOT top left.*/
       pieceSelected = true;
       int squareX = boardPos[0] + (boardWidth / 8) * bSX;
       int squareY = 10 + boardPos[1] + (boardHeight / 8) * bSY;
       selectedSquarePos[0] = bSX;
       selectedSquarePos[1] = bSY;
       g.drawString("Selected", squareX, squareY);

   }

// Data Handling and Retreiving methods
    public void parseBoard(String[][] Board, Graphics g)
    {
        int row = 0;
        int col = 0;
        for (String[] rowOfPieces : Board)
        {
            for (String piece : rowOfPieces)
            {
                if (piece != "X")
                {   
                    Color PIECE_COLOR = P1_Color;
                    if (piece.contains("P2")) {PIECE_COLOR = P2_Color;}

                    if (piece.contains("C"))
                    {
                        drawMan(g, col, row, PIECE_COLOR);
                    }
                    if (piece.contains("K"))
                    {
                        Color Crown_Color = P2_Color;
                        if (PIECE_COLOR != P1_Color) {Crown_Color = P1_Color;}
                        drawKing(g, col, row, PIECE_COLOR, Crown_Color);
                    }
                }
                col+=1;
            }
            row +=1;
            col = 0;
        }
    }


    public int[] getBoardSquare(int x, int y)
    {   
        //row or col  =  boardpos - offset / row height or width
        if ((x < boardPos[0]) | (y < boardPos[1]) | (x > (boardPos[0] + boardWidth)) | (y > (boardPos[1] + boardHeight)) )
        {
            int[] BS = {-1, -1};
            return BS;
        }
        int col = (x - boardPos[0]) / (boardWidth / 8);
        int row = (y - boardPos[1]) / (boardHeight / 8);

        int[] BS = {col, row};
        return BS;
    }

    public boolean isCheckersPiece(int BoardSquareX, int BoardSquareY)
    {
        int Px = BoardSquareX;
        int Py = BoardSquareY;
        if (Px == -1 & Py == -1)
        {
            return false;
        }
        String Square = CheckersBoard.board[Py][Px];
        return Square != "X";

    }
}

导入java.awt.event.*；
导入java.awt.*；
导入javax.swing.*；
公共类AppFrame扩展了JFrame
{
public String status=“status:；//小程序的状态
public int paint_count=1；//小程序被绘制的次数
public int[]mousePos={-1，-1}；//存储鼠标最后单击的X和Y坐标
public int[]boardPos={-1，-1}；//存储板的X和Y坐标
public int[]selectedSquarePos={-1，-1}；
public int[]boardSquare={-1，-1}；//存储上次单击的正方形
公共颜色P1_Color=Color.GRAY；
公共颜色P2_Color=Color.WHITE；
公共颜色square偶数=Color.BLACK；
public Color SquareOdd=Color.RED；//在这一块上移动
公共内板高度=400；
公共int boardWidth=400；
public boolean piecelected=false；
公共布尔CheckersPiece=false；
公共棋盘checkerboard=新棋盘（）；
公共图像缓冲区=空；
公共图形bg=null；
公共void main（字符串[]参数）
{
println（“你好，这是Java找不到这个的主要原因。”）；
}
公共应用程序框架（）
{
超级（“JCheckers”）；
setDefaultCloseOperation（JFrame.EXIT_ON_CLOSE）；
设置大小（900900）；
setVisible（真）；
buffer=createImage（getWidth（），getHeight（））；
boardHeight=getHeight（）-40；//顶部和底部的边框为20像素，蓝色条为20像素
boardWidth=getWidth（）-40；//20像素左右边框
bg=buffer.getGraphics（）；
addMouseListener（新的MouseAdapter（）
{
公共无效mouseClicked（MouseEvent e）
{
handleClick（e）；
}
}
);
}
公共无效handleClick（MouseeEvent e）
{
/*处理鼠标单击的跟踪；不处理显示，它只是更新数据并调用重画*/
mousePos[0]=e.getX（）；
mousePos[1]=e.getY（）；
重新油漆（）；
}
公共空间涂料（图g）
{
超级油漆（g）；
渲染（g）；
}
公共空间渲染（图形g）
{   
clearRect（0,0，getWidth（），getHeight（））；
//画棋盘
渲染测试板（bg，20，20）；
//显示信息
系统输出打印项次（状态）；
System.out.println（String.format（“最后一次鼠标点击@（X:%d Y:%d）”，鼠标点[0]，鼠标点[1]）；
System.out.println（“绘制”+“绘制计数”）；
System.out.println（String.format（“Board Square（x:%s，y:%s）%b”、boardSquare[0]、boardSquare[1]、CheckersPiece））；
System.out.println（checkerboard.status）；
油漆计数+=1；
//将图像绘制到屏幕
g、 drawImage（buffer，0，25，null）；//因此它不会被蓝色close/min/max room隐藏
}
公共布尔值isValidSquare（整数列，整数行）
{
如果（col>-1&col<8）{return true；}
返回false；
}
公共void renderChessBoard（图形g、整数x、整数y）
{
/*渲染木板和碎片*/
//感觉行方格是好方格，然后
//木板也是正方形的，所以我们用任何东西画它
//边是最小的，宽度或高度
boardPos[0]=x；
boardPos[1]=y；
绘图板（g、x、y、板宽、板高）；
boardSquare=getBoardSquare（鼠标点[0]，鼠标点[1]）；
CheckersPiece=isCheckersPiece（boardSquare[0]，boardSquare[1]）；
布尔值validSquare=isValidSquare（boardSquare[0]，boardSquare[1]）；
如果（有效方）
{
if（棋盘格）
{
选择Square（g，boardSquare[0]，boardSquare[1]）；
}
其他的
{
如果（已选定）
{
int selectedCol=selectedSquarePos[0]；
int selectedRow=selectedSquarePos[1]；
int toCol=boardSquare[0]；
int toRow=boardSquare[1]；
System.out.println（selectedCol+“”+selectedRow+“”+toCol+“”+toRow）；
如果（！checkerboard.move（selectedSquarePos，boardSquare））//不是有效的移动；
{
pieceSelected=false；
}
}
}
}
parseBoard（checkerboard.board，g）；
}
公共真空抽油板（图形g、int Bx、int By、int Bw、int Bh）
{
int numberrowDrawed=0；
int-rH=Bh/8；
int rW=Bw；//行宽度与线路板的宽度相同，因为线路板和行共用同一侧
while（编号小于8）
{
int rY=（numberrowsdrauded*rH）+By；
//行X与板X相同，因为板和行共享sa
public static void main(String[] args)

public static void main(String[] args) {
    javax.swing.SwingUtilities.invokeLater(new Runnable() {
       @Override
       public void run() {
           AppFrame frame = new AppFrame();
           frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
       }
   });
}