Question

I recently took all my code a manually imported it into an eclipse project from BlueJ, I then got use to the settings up “Run Configurations”, finally thinking I was home free. Then I ran the code, and I got this error

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

so I figured I had to add a main method (I never had to do this in BlueJ, why?). So I did that just called the constructor method (in BlueJ I would just create a new object and the JFrame would show). So I did that, same error. After trying different things (such as moving the code in the constructor to a different method etc.). I just put this in for the main method:

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

After that I still got the same error, so I then decided to add it to all my classes to make sure it wasn’t using another class as the main class. Still same error, so I come to you wondering if any of you have encountered this problem. Also I did search Google and all I found was problems with private classes etc and sense all my classes are public (hey I come from Python 🙂 ). I knew that wasn’t the problem. Help Please 🙂

Picture of my Run Configuration

This is my main method code

WARNING: LONG

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";

    }
}

Answer 1

You forgot static:

public static void main(String[] args)

But in order to really start your application, you should launch it from that method, not merely have it. Here is how to start it:

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);
       }
   });
}

It’s important to note the EXIT_ON_CLOSE – this will make the JVM exit when you press the X button. Otherwise your application will continue running, and you might even not notice.