Category:

Code

Java Random Maze Generator Using Swing Tutorial

written by 75ypsaw71

In this tutorial, we will build a Random Maze Generator in Java using Swing for the graphical user interface (GUI). The maze generation will use the Depth-First Search (DFS) algorithm with backtracking, which is a common and effective algorithm for generating mazes.

The maze will be displayed as a grid, where each cell represents either a wall or a path. The algorithm will carve out paths between cells to create a solvable maze.

Features:

The user can click a button to generate a new random maze.
The maze is generated using the Depth-First Search (DFS) algorithm with backtracking.
The app displays the maze in a grid layout using Swing components.
The maze includes walls and paths, where the paths can be traversed.

Algorithm Overview:

The Depth-First Search (DFS) maze generation algorithm works as follows:

Start at a random cell and mark it as visited.
Randomly choose a neighbor that has not been visited.
Remove the wall between the current cell and the chosen neighbor and mark the neighbor as visited.
Recursively repeat this process from the new cell.
If there are no unvisited neighbors, backtrack to the previous cell and continue.

Complete Code

import javax.swing.*;
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Random;

public class MazeGeneratorApp extends JFrame {

    private static final int ROWS = 20;      // Number of rows in the maze
    private static final int COLS = 20;      // Number of columns in the maze
    private static final int CELL_SIZE = 25; // Size of each cell
    private Cell[][] grid;                   // The grid representing the maze
    private JPanel mazePanel;                // Panel to display the maze
    private JButton generateButton;          // Button to generate the maze
    private Random random;                   // Random number generator

    // Cell class to represent each cell in the maze
    private static class Cell {
        int row, col;
        boolean visited = false;
        boolean topWall = true;
        boolean bottomWall = true;
        boolean leftWall = true;
        boolean rightWall = true;

        public Cell(int row, int col) {
            this.row = row;
            this.col = col;
        }
    }

    // Constructor to set up the GUI
    public MazeGeneratorApp() {
        setTitle("Maze Generator");
        setSize(COLS * CELL_SIZE + 50, ROWS * CELL_SIZE + 100);
        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        setLocationRelativeTo(null);  // Center the window on the screen

        random = new Random();

        // Create a grid to represent the maze
        grid = new Cell[ROWS][COLS];
        for (int row = 0; row < ROWS; row++) {
            for (int col = 0; col < COLS; col++) {
                grid[row][col] = new Cell(row, col);
            }
        }

        // Set up the maze panel
        mazePanel = new JPanel() {
            @Override
            protected void paintComponent(Graphics g) {
                super.paintComponent(g);
                drawMaze(g);
            }
        };
        mazePanel.setPreferredSize(new Dimension(COLS * CELL_SIZE, ROWS * CELL_SIZE));
        mazePanel.setBackground(Color.WHITE);

        // Set up the generate button
        generateButton = new JButton("Generate Maze");
        generateButton.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                generateMaze();
                mazePanel.repaint();
            }
        });

        // Set up the layout
        setLayout(new BorderLayout());
        add(mazePanel, BorderLayout.CENTER);
        add(generateButton, BorderLayout.SOUTH);

        setVisible(true);
    }

    // Method to draw the maze on the panel
    private void drawMaze(Graphics g) {
        g.setColor(Color.BLACK);

        for (int row = 0; row < ROWS; row++) {
            for (int col = 0; col < COLS; col++) {
                Cell cell = grid[row][col];
                int x = col * CELL_SIZE;
                int y = row * CELL_SIZE;

                // Draw the walls of the cell
                if (cell.topWall) {
                    g.drawLine(x, y, x + CELL_SIZE, y);  // Top wall
                }
                if (cell.bottomWall) {
                    g.drawLine(x, y + CELL_SIZE, x + CELL_SIZE, y + CELL_SIZE);  // Bottom wall
                }
                if (cell.leftWall) {
                    g.drawLine(x, y, x, y + CELL_SIZE);  // Left wall
                }
                if (cell.rightWall) {
                    g.drawLine(x + CELL_SIZE, y, x + CELL_SIZE, y + CELL_SIZE);  // Right wall
                }
            }
        }
    }

    // Method to generate the maze using DFS with backtracking
    private void generateMaze() {
        // Reset all cells
        for (int row = 0; row < ROWS; row++) {
            for (int col = 0; col < COLS; col++) {
                grid[row][col].visited = false;
                grid[row][col].topWall = true;
                grid[row][col].bottomWall = true;
                grid[row][col].leftWall = true;
                grid[row][col].rightWall = true;
            }
        }

        // Start the maze generation from a random cell
        Cell startCell = grid[random.nextInt(ROWS)][random.nextInt(COLS)];
        dfs(startCell);
    }

    // Depth-First Search (DFS) algorithm to generate the maze
    private void dfs(Cell cell) {
        cell.visited = true;
        ArrayList neighbors = getUnvisitedNeighbors(cell);

        while (!neighbors.isEmpty()) {
            Cell neighbor = neighbors.remove(0);  // Get a random neighbor
            removeWalls(cell, neighbor);          // Remove the wall between the current cell and the neighbor
            dfs(neighbor);                        // Recursively visit the neighbor
            neighbors = getUnvisitedNeighbors(cell);
        }
    }

    // Method to get the unvisited neighbors of a cell
    private ArrayList getUnvisitedNeighbors(Cell cell) {
        ArrayList neighbors = new ArrayList<>();

        // Check top neighbor
        if (cell.row > 0 && !grid[cell.row - 1][cell.col].visited) {
            neighbors.add(grid[cell.row - 1][cell.col]);
        }
        // Check bottom neighbor
        if (cell.row < ROWS - 1 && !grid[cell.row + 1][cell.col].visited) { neighbors.add(grid[cell.row + 1][cell.col]); } // Check left neighbor if (cell.col > 0 && !grid[cell.row][cell.col - 1].visited) {
            neighbors.add(grid[cell.row][cell.col - 1]);
        }
        // Check right neighbor
        if (cell.col < COLS - 1 && !grid[cell.row][cell.col + 1].visited) { neighbors.add(grid[cell.row][cell.col + 1]); } // Shuffle the neighbors to ensure randomness Collections.shuffle(neighbors, random); return neighbors; } // Method to remove the walls between two adjacent cells private void removeWalls(Cell current, Cell next) { // Determine the relative position of the next cell int dx = current.col - next.col; int dy = current.row - next.row; // Remove the walls if (dx == 1) { // Next cell is to the left current.leftWall = false; next.rightWall = false; } else if (dx == -1) { // Next cell is to the right current.rightWall = false; next.leftWall = false; } else if (dy == 1) { // Next cell is above current.topWall = false; next.bottomWall = false; } else if (dy == -1) { // Next cell is below current.bottomWall = false; next.topWall = false; } } // Main method to run the app public static void main(String[] args) { SwingUtilities.invokeLater(() -> new MazeGeneratorApp());
    }
}

Explanation of the Code

1. Import Statements

import javax.swing.*;
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Random;

javax.swing.*: Provides Swing components like JFrame, JButton, and JPanel to create the graphical interface.
java.awt.*: Provides layout management and graphical utilities (BorderLayout, Graphics).
java.util.*: Provides utilities such as ArrayList, Random, and Collections for randomization and storing neighbors.

2. Class Declaration and Instance Variables

public class MazeGeneratorApp extends JFrame {
    private static final int ROWS = 20;
    private static final int COLS = 20;
    private static final int CELL_SIZE = 25;
    private Cell[][] grid;
    private JPanel mazePanel;
    private JButton generateButton;
    private Random random;
}

ROWS and COLS: The number of rows and columns in the maze grid.
CELL_SIZE: The size of each cell in the maze.
grid: A 2D array to represent the maze as a grid of cells.
mazePanel: A panel to display the maze.
generateButton: A button to generate a new maze.
random: A Random object to generate random values.

3. Cell Class

private static class Cell {
    int row, col;
    boolean visited = false;
    boolean topWall = true;
    boolean bottomWall = true;
    boolean leftWall = true;
    boolean rightWall = true;

    public Cell(int row, int col) {
        this.row = row;
        this.col = col;
    }
}

Cell: Represents each cell in the maze. Each cell has walls (topWall, bottomWall, leftWall, rightWall) and a visited flag to indicate whether the cell has been visited during the maze generation.

4. Constructor

public MazeGeneratorApp() {
    setTitle("Maze Generator");
    setSize(COLS * CELL_SIZE + 50, ROWS * CELL_SIZE + 100);
    setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    setLocationRelativeTo(null);

    random = new Random();

    grid = new Cell[ROWS][COLS];
    for (int row = 0; row < ROWS; row++) {
        for (int col = 0; col < COLS; col++) {
            grid[row][col] = new Cell(row, col);
        }
    }

    mazePanel = new JPanel() {
        @Override
        protected void paintComponent(Graphics g) {
            super.paintComponent(g);
            drawMaze(g);
        }
    };
    mazePanel.setPreferredSize(new Dimension(COLS * CELL_SIZE, ROWS * CELL_SIZE));

    generateButton = new JButton("Generate Maze");
    generateButton.addActionListener(new ActionListener() {
        @Override
        public void actionPerformed(ActionEvent e) {
            generateMaze();
            mazePanel.repaint();
        }
    });

    setLayout(new BorderLayout());
    add(mazePanel, BorderLayout.CENTER);
    add(generateButton, BorderLayout.SOUTH);

    setVisible(true);
}

Frame Setup:

Sets the window title and size, and ensures that the app exits when the window is closed.
Initializes the grid with Cell objects and creates the mazePanel to display the maze.
Adds a button to trigger the maze generation and sets up the layout of the components.

5. drawMaze() Method

private void drawMaze(Graphics g) {
    g.setColor(Color.BLACK);

    for (int row = 0; row < ROWS; row++) {
        for (int col = 0; col < COLS; col++) {
            Cell cell = grid[row][col];
            int x = col * CELL_SIZE;
            int y = row * CELL_SIZE;

            if (cell.topWall) {
                g.drawLine(x, y, x + CELL_SIZE, y);
            }
            if (cell.bottomWall) {
                g.drawLine(x, y + CELL_SIZE, x + CELL_SIZE, y + CELL_SIZE);
            }
            if (cell.leftWall) {
                g.drawLine(x, y, x, y + CELL_SIZE);
            }
            if (cell.rightWall) {
                g.drawLine(x + CELL_SIZE, y, x + CELL_SIZE, y + CELL_SIZE);
            }
        }
    }
}

This method draws the maze by iterating through each cell and drawing its walls based on whether the topWall, bottomWall, leftWall, and rightWall flags are set.

6. generateMaze() Method

private void generateMaze() {
    for (int row = 0; row < ROWS; row++) {
        for (int col = 0; col < COLS; col++) {
            grid[row][col].visited = false;
            grid[row][col].topWall = true;
            grid[row][col].bottomWall = true;
            grid[row][col].leftWall = true;
            grid[row][col].rightWall = true;
        }
    }

    Cell startCell = grid[random.nextInt(ROWS)][random.nextInt(COLS)];
    dfs(startCell);
}

This method resets all cells and starts the maze generation from a random cell by calling the dfs() method.

7. dfs() Method (Depth-First Search)

private void dfs(Cell cell) {
    cell.visited = true;
    ArrayList neighbors = getUnvisitedNeighbors(cell);

    while (!neighbors.isEmpty()) {
        Cell neighbor = neighbors.remove(0);  // Get a random neighbor
        removeWalls(cell, neighbor);          // Remove the wall between the current cell and the neighbor
        dfs(neighbor);                        // Recursively visit the neighbor
        neighbors = getUnvisitedNeighbors(cell);
    }
}

dfs(): Implements the Depth-First Search (DFS) algorithm. It recursively visits each cell, removes walls between the current cell and a random neighbor, and marks cells as visited.

8. getUnvisitedNeighbors() Method

private ArrayList getUnvisitedNeighbors(Cell cell) {
    ArrayList neighbors = new ArrayList<>();

    if (cell.row > 0 && !grid[cell.row - 1][cell.col].visited) {
        neighbors.add(grid[cell.row - 1][cell.col]);
    }
    if (cell.row < ROWS - 1 && !grid[cell.row + 1][cell.col].visited) { neighbors.add(grid[cell.row + 1][cell.col]); } if (cell.col > 0 && !grid[cell.row][cell.col - 1].visited) {
        neighbors.add(grid[cell.row][cell.col - 1]);
    }
    if (cell.col < COLS - 1 && !grid[cell.row][cell.col + 1].visited) {
        neighbors.add(grid[cell.row][cell.col + 1]);
    }

    Collections.shuffle(neighbors, random);

    return neighbors;
}

This method returns the unvisited neighbors of a given cell. It checks the top, bottom, left, and right neighbors and shuffles the list to ensure random maze generation.

9. removeWalls() Method

private void removeWalls(Cell current, Cell next) {
    int dx = current.col - next.col;
    int dy = current.row - next.row;

    if (dx == 1) {  
        current.leftWall = false;
        next.rightWall = false;
    } else if (dx == -1) { 
        current.rightWall = false;
        next.leftWall = false;
    } else if (dy == 1) {  
        current.topWall = false;
        next.bottomWall = false;
    } else if (dy == -1) {  
        current.bottomWall = false;
        next.topWall = false;
    }
}

This method removes the walls between the current cell and the next cell based on their relative position.

Customization Ideas

1. Allow Different Maze Sizes

Add options for the user to select different maze sizes (e.g., 10×10, 20×20, or 30×30 grids).

2. Add Maze Solvers

Implement a maze-solving algorithm (e.g., BFS or A* search) to highlight the solution path from a start point to an end point.

3. Customize the Appearance

Add colors to distinguish walls and paths, or add animations for the maze generation process.

Conclusion

This Random Maze Generator in Java using Swing demonstrates how to create a maze using the Depth-First Search (DFS) algorithm with backtracking. The project covers:

Using Swing components to create a graphical interface.
Implementing maze generation algorithms with recursive DFS.
Handling user interaction with buttons to trigger maze generation.
Feel free to expand the project by adding new features or improving the appearance of the maze!

October 11, 2024 0 comment

Java Dice Roll Simulator Using Swing Tutorial

written by 75ypsaw71

In this tutorial, we will build a Dice Roll Simulator in Java using Swing for the graphical user interface (GUI). The app will simulate rolling one or more dice, and it will display random outcomes for each roll.

The app allows users to select the number of dice to roll and shows the result of each roll.

Table of Contents

Features:

The user can specify how many dice to roll.
The app simulates random dice rolls and displays the results.
The app uses Swing components like JTextField, JButton, and JLabel for input and output.
The dice results are generated using Java’s Random class to simulate rolling a six-sided die.

Complete Code

import javax.swing.*;
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.util.Random;

public class DiceRollSimulatorApp extends JFrame {

    private JTextField numberOfDiceField;  // Input for the number of dice
    private JButton rollButton;            // Button to trigger dice roll
    private JLabel resultLabel;            // Label to display the dice results
    private Random random;                 // Random number generator

    // Constructor to set up the GUI
    public DiceRollSimulatorApp() {
        setTitle("Dice Roll Simulator");
        setSize(400, 200);
        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        setLocationRelativeTo(null);  // Center the window on the screen

        random = new Random();

        // Create components
        JLabel promptLabel = new JLabel("Enter number of dice to roll:");
        numberOfDiceField = new JTextField(5);
        rollButton = new JButton("Roll Dice");
        resultLabel = new JLabel("Result: ", SwingConstants.CENTER);
        resultLabel.setFont(new Font("Serif", Font.BOLD, 16));

        // Panel for user input
        JPanel inputPanel = new JPanel();
        inputPanel.add(promptLabel);
        inputPanel.add(numberOfDiceField);
        inputPanel.add(rollButton);

        // Set layout for the frame
        setLayout(new BorderLayout());
        add(inputPanel, BorderLayout.NORTH);
        add(resultLabel, BorderLayout.CENTER);

        // Add action listener to the roll button
        rollButton.addActionListener(new RollButtonListener());

        setVisible(true);
    }

    // Method to simulate rolling multiple dice
    private String rollDice(int numberOfDice) {
        StringBuilder result = new StringBuilder("You rolled: ");
        for (int i = 0; i < numberOfDice; i++) {
            int rollResult = random.nextInt(6) + 1;  // Simulate a roll (1 to 6)
            result.append(rollResult);
            if (i < numberOfDice - 1) {
                result.append(", ");  // Add a comma between results
            }
        }
        return result.toString();
    }

    // Action listener for the roll button
    private class RollButtonListener implements ActionListener {
        @Override
        public void actionPerformed(ActionEvent e) {
            try {
                int numberOfDice = Integer.parseInt(numberOfDiceField.getText());
                if (numberOfDice <= 0) { resultLabel.setText("Please enter a positive number."); } else { String diceResults = rollDice(numberOfDice); resultLabel.setText(diceResults); } } catch (NumberFormatException ex) { resultLabel.setText("Please enter a valid number."); } } } // Main method to run the app public static void main(String[] args) { SwingUtilities.invokeLater(() -> new DiceRollSimulatorApp());
    }
}

Explanation of the Code

1. Import Statements

import javax.swing.*;
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.util.Random;
javax.swing.*: Provides Swing components like JFrame, JButton, JTextField, and JLabel for creating the GUI.
java.awt.*: Provides layout and graphical utilities like BorderLayout, Font, and Dimension.
java.awt.event.*: Provides event listener classes for handling button click events.
java.util.Random: Provides a random number generator to simulate rolling dice.

2. Class Declaration and Instance Variables

public class DiceRollSimulatorApp extends JFrame {
    private JTextField numberOfDiceField;  // Input for the number of dice
    private JButton rollButton;            // Button to trigger dice roll
    private JLabel resultLabel;            // Label to display the dice results
    private Random random;                 // Random number generator
}
JTextField numberOfDiceField: A text field for the user to input how many dice they want to roll.
JButton rollButton: A button that triggers the dice roll simulation.
JLabel resultLabel: A label that displays the results of the dice rolls.
Random random: A random number generator to simulate rolling dice.

3. Constructor

public DiceRollSimulatorApp() {
    setTitle("Dice Roll Simulator");
    setSize(400, 200);
    setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    setLocationRelativeTo(null);  // Center the window on the screen

    random = new Random();

    // Create components
    JLabel promptLabel = new JLabel("Enter number of dice to roll:");
    numberOfDiceField = new JTextField(5);
    rollButton = new JButton("Roll Dice");
    resultLabel = new JLabel("Result: ", SwingConstants.CENTER);
    resultLabel.setFont(new Font("Serif", Font.BOLD, 16));

    // Panel for user input
    JPanel inputPanel = new JPanel();
    inputPanel.add(promptLabel);
    inputPanel.add(numberOfDiceField);
    inputPanel.add(rollButton);

    // Set layout for the frame
    setLayout(new BorderLayout());
    add(inputPanel, BorderLayout.NORTH);
    add(resultLabel, BorderLayout.CENTER);

    // Add action listener to the roll button
    rollButton.addActionListener(new RollButtonListener());

    setVisible(true);
}

Frame Setup:

setTitle(“Dice Roll Simulator”): Sets the window title.
setSize(400, 200): Sets the window size to 400×200 pixels.
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE): Ensures the program exits when the window is closed.
setLocationRelativeTo(null): Centers the window on the screen.

Component Setup:

numberOfDiceField = new JTextField(5): Creates a text field for the user to input how many dice they want to roll.
rollButton = new JButton(“Roll Dice”): Creates the button that the user clicks to roll the dice.
resultLabel = new JLabel(“Result: “, SwingConstants.CENTER): Creates a label to display the results, with text centered.

Panel Setup:

inputPanel.add(promptLabel): Adds the prompt label to the input panel.
inputPanel.add(numberOfDiceField): Adds the text field to the input panel.
inputPanel.add(rollButton): Adds the roll button to the input panel.

Layout Setup:

setLayout(new BorderLayout()): Uses a BorderLayout to position components.
add(inputPanel, BorderLayout.NORTH): Adds the input panel to the top of the window.
add(resultLabel, BorderLayout.CENTER): Adds the result label to the center of the window.

4. rollDice() Method

private String rollDice(int numberOfDice) {
    StringBuilder result = new StringBuilder("You rolled: ");
    for (int i = 0; i < numberOfDice; i++) {
        int rollResult = random.nextInt(6) + 1;  // Simulate a roll (1 to 6)
        result.append(rollResult);
        if (i < numberOfDice - 1) {
            result.append(", ");  // Add a comma between results
        }
    }
    return result.toString();
}

Simulating Dice Rolls:
random.nextInt(6) + 1: Generates a random number between 1 and 6 (simulating a roll of a six-sided die).
StringBuilder result = new StringBuilder(): Used to build the result string with the outcome of each dice roll.
The method appends each dice result to the result string and returns the final outcome.

5. Action Listener for the Roll Button

private class RollButtonListener implements ActionListener {
    @Override
    public void actionPerformed(ActionEvent e) {
        try {
            int numberOfDice = Integer.parseInt(numberOfDiceField.getText());
            if (numberOfDice <= 0) {
                resultLabel.setText("Please enter a positive number.");
            } else {
                String diceResults = rollDice(numberOfDice);
                resultLabel.setText(diceResults);
            }
        } catch (NumberFormatException ex) {
            resultLabel.setText("Please enter a valid number.");
        }
    }
}

Handling Button Clicks:

numberOfDice = Integer.parseInt(numberOfDiceField.getText()): Retrieves the number of dice from the input field.

Input Validation:

If the number of dice is less than or equal to 0, an error message is displayed.
If the input is invalid (non-numeric), an error message is displayed.
rollDice(numberOfDice): Calls the method to simulate rolling the dice and displays the results in the resultLabel.

6. Main Method

public static void main(String[] args) {
    SwingUtilities.invokeLater(() -> new DiceRollSimulatorApp());
}

SwingUtilities.invokeLater(): Ensures that the GUI is created and updated on the Event Dispatch Thread (EDT), which is necessary for Swing applications.
new DiceRollSimulatorApp(): Creates and launches the dice roll simulator app.

Customization Ideas

1. Change the Number of Sides on the Dice

Add a dropdown to allow users to select the number of sides on the dice (e.g., 6-sided, 10-sided, or 20-sided dice).

2. Add Dice Images

Add images of dice to visually display the result of each roll instead of just numbers.

3. Improve the User Interface

Enhance the UI by adding colors, better fonts, and tooltips for usability.

4. Display Sum of Rolls

Add an additional label to display the sum of all dice rolled.

Conclusion

This Dice Roll Simulator in Java using Swing allows users to simulate rolling one or more dice, and it demonstrates:

Using Swing components (JFrame, JButton, JTextField, JLabel) to create a graphical user interface.
Generating random numbers to simulate rolling dice.
Handling input validation and providing real-time feedback
.
You can extend this project with more features to suit your needs and make it more interactive!

October 11, 2024 0 comment

Code GUI

Java Palindrome Checker Using Swing Tutorial

written by 75ypsaw71

In this tutorial, we will build a simple Palindrome Checker in Java using Swing for the graphical user interface (GUI).

A palindrome is a word, phrase, number, or other sequences of characters that reads the same forward and backward (ignoring spaces, punctuation, and capitalization).

Table of Contents

Features:

Allows users to input text into a text field.
Checks if the input text is a palindrome, ignoring case, spaces, and punctuation.
Displays a result indicating whether the text is a palindrome.
Provides a Check button to trigger the check.

Complete Code

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

public class PalindromeCheckerApp extends JFrame {

    private JTextField inputField;  // Text field for user input
    private JButton checkButton;    // Button to check for palindrome
    private JLabel resultLabel;     // Label to display the result

    // Constructor to set up the GUI
    public PalindromeCheckerApp() {
        setTitle("Palindrome Checker");
        setSize(600, 150);
        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        setLocationRelativeTo(null);  // Center the window on the screen

        // Create input field
        inputField = new JTextField(20);

        // Create check button
        checkButton = new JButton("Check Palindrome");

        // Create result label
        resultLabel = new JLabel("Enter text to check if it's a palindrome.", SwingConstants.CENTER);
        resultLabel.setFont(new Font("Serif", Font.BOLD, 16));

        // Panel to hold input and button
        JPanel inputPanel = new JPanel();
        inputPanel.add(new JLabel("Enter text:"));
        inputPanel.add(inputField);
        inputPanel.add(checkButton);

        // Set layout for the frame
        setLayout(new BorderLayout());
        add(inputPanel, BorderLayout.NORTH);
        add(resultLabel, BorderLayout.CENTER);

        // Add action listener to the button
        checkButton.addActionListener(new CheckButtonListener());

        setVisible(true);
    }

    // Method to check if a given string is a palindrome
    private boolean isPalindrome(String text) {
        // Remove non-alphanumeric characters and convert to lowercase
        String cleanedText = text.replaceAll("[^a-zA-Z0-9]", "").toLowerCase();

        // Check if the cleaned text is the same when reversed
        int left = 0;
        int right = cleanedText.length() - 1;
        while (left < right) { if (cleanedText.charAt(left) != cleanedText.charAt(right)) { return false; } left++; right--; } return true; } // Action listener for the Check button private class CheckButtonListener implements ActionListener { @Override public void actionPerformed(ActionEvent e) { String inputText = inputField.getText(); if (isPalindrome(inputText)) { resultLabel.setText("Yes! '" + inputText + "' is a palindrome."); } else { resultLabel.setText("No! '" + inputText + "' is not a palindrome."); } } } // Main method to run the app public static void main(String[] args) { SwingUtilities.invokeLater(() -> new PalindromeCheckerApp());
    }
}

Explanation of the Code

1. Import Statements

import javax.swing.*;
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
javax.swing.*: Provides Swing components such as JFrame, JButton, JTextField, and JLabel to create the GUI.
java.awt.*: Provides layout and graphical utilities like BorderLayout and Font.
java.awt.event.*: Provides event listener classes for handling button click events.

2. Class Declaration and Instance Variables

public class PalindromeCheckerApp extends JFrame {
    private JTextField inputField;  // Text field for user input
    private JButton checkButton;    // Button to check for palindrome
    private JLabel resultLabel;     // Label to display the result
}
JTextField inputField: A text field where the user can input the text to check.
JButton checkButton: A button that the user clicks to trigger the palindrome check.
JLabel resultLabel: A label that displays the result of the palindrome check.

3. Constructor

public PalindromeCheckerApp() {
    setTitle("Palindrome Checker");
    setSize(600, 150);
    setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    setLocationRelativeTo(null);  // Center the window on the screen

    // Create input field
    inputField = new JTextField(20);

    // Create check button
    checkButton = new JButton("Check Palindrome");

    // Create result label
    resultLabel = new JLabel("Enter text to check if it's a palindrome.", SwingConstants.CENTER);
    resultLabel.setFont(new Font("Serif", Font.BOLD, 16));

    // Panel to hold input and button
    JPanel inputPanel = new JPanel();
    inputPanel.add(new JLabel("Enter text:"));
    inputPanel.add(inputField);
    inputPanel.add(checkButton);

    // Set layout for the frame
    setLayout(new BorderLayout());
    add(inputPanel, BorderLayout.NORTH);
    add(resultLabel, BorderLayout.CENTER);

    // Add action listener to the button
    checkButton.addActionListener(new CheckButtonListener());

    setVisible(true);
}

Frame Setup:

setTitle(“Palindrome Checker”): Sets the window title.
setSize(400, 150): Sets the size of the window.
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE): Ensures the application exits when the window is closed.
setLocationRelativeTo(null): Centers the window on the screen.

Input Field and Button Setup:

inputField = new JTextField(20): Creates the input field where the user can type text.
checkButton = new JButton(“Check Palindrome”): Creates the button that the user clicks to check if the input text is a palindrome.

Result Label Setup:

resultLabel = new JLabel(…): Initializes the label that will display the result.
resultLabel.setFont(new Font(“Serif”, Font.BOLD, 16)): Sets the font style and size for the label.

Layout Setup:

setLayout(new BorderLayout()): Uses a border layout to position components.
add(inputPanel, BorderLayout.NORTH): Adds the input panel (containing the input field and button) to the top of the window.

add(resultLabel, BorderLayout.CENTER): Adds the result label to the center of the window.
Button Action Listener:

checkButton.addActionListener(new CheckButtonListener()): Registers an action listener to handle button click events.

4. isPalindrome() Method

private boolean isPalindrome(String text) {
    // Remove non-alphanumeric characters and convert to lowercase
    String cleanedText = text.replaceAll("[^a-zA-Z0-9]", "").toLowerCase();

    // Check if the cleaned text is the same when reversed
    int left = 0;
    int right = cleanedText.length() - 1;
    while (left < right) {
        if (cleanedText.charAt(left) != cleanedText.charAt(right)) {
            return false;
        }
        left++;
        right--;
    }
    return true;
}

Cleaning the Input:

text.replaceAll(“[^a-zA-Z0-9]”, “”): Removes all non-alphanumeric characters (punctuation, spaces, etc.).
toLowerCase(): Converts the cleaned text to lowercase to make the check case-insensitive.

Checking for Palindrome:

The method uses two pointers (left and right) to compare characters from the start and end of the string.
If any mismatch is found, the method returns false; otherwise, it returns true when all characters match.

5. Action Listener for the Check Button

private class CheckButtonListener implements ActionListener {
    @Override
    public void actionPerformed(ActionEvent e) {
        String inputText = inputField.getText();
        if (isPalindrome(inputText)) {
            resultLabel.setText("Yes! '" + inputText + "' is a palindrome.");
        } else {
            resultLabel.setText("No! '" + inputText + "' is not a palindrome.");
        }
    }
}

Checking for Palindrome:

inputField.getText(): Retrieves the text entered by the user.
isPalindrome(inputText): Calls the method to check if the entered text is a palindrome.

Displaying the Result:

If the input text is a palindrome, the label is updated with a success message.
If it is not a palindrome, the label is updated with a failure message.

6. Main Method

public static void main(String[] args) {
    SwingUtilities.invokeLater(() -> new PalindromeCheckerApp());
}
SwingUtilities.invokeLater(): Ensures that the GUI is created and updated on the Event Dispatch Thread (EDT), which is necessary for Swing applications.
new PalindromeCheckerApp(): Creates and launches the palindrome checker app.

Customization Ideas

1. Handle Multiple Lines of Text

Allow the user to enter multiple lines of text and check if the entire paragraph is a palindrome.

2. Display More Detailed Information

Display additional information such as the cleaned text, the reverse of the text, and how many characters were removed during cleaning.

3. Improve the User Interface

Customize the appearance of the app by changing fonts, adding colors, and using icons.

Conclusion

This Palindrome Checker in Java using Swing is a simple and effective application to demonstrate how to use a graphical interface for checking if text is a palindrome. The key concepts covered include:

Using Swing components like JFrame, JButton, JTextField, and JLabel.
Implementing event-driven programming with action listeners.
String manipulation to clean and reverse the input text for palindrome checking.

You can extend this project by adding more features and improving the user interface.

October 11, 2024 0 comment

Code GUI

Java Color Picker Tool Using Swing Tutorial

written by 75ypsaw71

In this tutorial, we will create a Color Picker Tool in Java using Swing.

The tool will allow users to select a color from a color palette, display the selected color, and show its RGB (Red, Green, Blue) values and Hexadecimal color code.

This is a fun and interactive way to explore colors and learn how they are represented in Java.

Features:

Allows users to pick a color using the JColorChooser component.
Displays the selected color in a panel.
Shows the RGB values and Hexadecimal color code of the selected color.
Provides a Copy to Clipboard feature for the hex color code.

Complete Code

import javax.swing.*;
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.datatransfer.StringSelection;

public class ColorPickerTool extends JFrame {

    private JPanel colorDisplayPanel; // Panel to show the selected color
    private JLabel rgbLabel;          // Label to display RGB values
    private JLabel hexLabel;          // Label to display Hex code
    private JButton pickColorButton, copyHexButton;

    // Constructor to set up the GUI
    public ColorPickerTool() {
        setTitle("Color Picker Tool");
        setSize(400, 200);
        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        setLocationRelativeTo(null);  // Center the window on the screen

        // Initialize components
        colorDisplayPanel = new JPanel();
        colorDisplayPanel.setBackground(Color.WHITE);  // Default color is white
        colorDisplayPanel.setPreferredSize(new Dimension(100, 100));

        rgbLabel = new JLabel("RGB: ");
        hexLabel = new JLabel("Hex: ");

        pickColorButton = new JButton("Pick a Color");
        copyHexButton = new JButton("Copy Hex Code");

        // Set up layout
        JPanel infoPanel = new JPanel(new GridLayout(2, 1));
        infoPanel.add(rgbLabel);
        infoPanel.add(hexLabel);

        JPanel buttonPanel = new JPanel();
        buttonPanel.add(pickColorButton);
        buttonPanel.add(copyHexButton);

        setLayout(new BorderLayout());
        add(colorDisplayPanel, BorderLayout.WEST);
        add(infoPanel, BorderLayout.CENTER);
        add(buttonPanel, BorderLayout.SOUTH);

        // Add action listeners
        pickColorButton.addActionListener(new PickColorButtonListener());
        copyHexButton.addActionListener(new CopyHexButtonListener());

        setVisible(true);
    }

    // Method to convert a Color object to Hex string
    private String getHexColor(Color color) {
        return String.format("#%02x%02x%02x", color.getRed(), color.getGreen(), color.getBlue());
    }

    // Action listener for the Pick Color button
    private class PickColorButtonListener implements ActionListener {
        @Override
        public void actionPerformed(ActionEvent e) {
            // Show color chooser dialog
            Color selectedColor = JColorChooser.showDialog(null, "Pick a Color", colorDisplayPanel.getBackground());

            // If a color is selected
            if (selectedColor != null) {
                // Update the color display panel
                colorDisplayPanel.setBackground(selectedColor);

                // Update RGB and Hex labels
                String rgbText = "RGB: " + selectedColor.getRed() + ", " + selectedColor.getGreen() + ", " + selectedColor.getBlue();
                rgbLabel.setText(rgbText);
                String hexText = "Hex: " + getHexColor(selectedColor);
                hexLabel.setText(hexText);
            }
        }
    }

    // Action listener for the Copy Hex button
    private class CopyHexButtonListener implements ActionListener {
        @Override
        public void actionPerformed(ActionEvent e) {
            // Copy the hex value to clipboard
            String hexText = hexLabel.getText().replace("Hex: ", "").trim();
            Toolkit.getDefaultToolkit().getSystemClipboard().setContents(new StringSelection(hexText), null);
            JOptionPane.showMessageDialog(null, "Hex code copied to clipboard!");
        }
    }

    // Main method to run the app
    public static void main(String[] args) {
        SwingUtilities.invokeLater(() -> new ColorPickerTool());
    }
}

Explanation of the Code

1. Import Statements

import javax.swing.*;
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.datatransfer.StringSelection;
javax.swing.*: Provides Swing components like JFrame, JButton, JPanel, and JLabel for creating the GUI.
java.awt.*: Provides layout and graphical utilities like Color, Dimension, BorderLayout.
java.awt.datatransfer.*: Provides clipboard functionalities for copying the hex color code to the clipboard.

2. Class Declaration and Instance Variables

public class ColorPickerTool extends JFrame {
    private JPanel colorDisplayPanel; // Panel to show the selected color
    private JLabel rgbLabel;          // Label to display RGB values
    private JLabel hexLabel;          // Label to display Hex code
    private JButton pickColorButton, copyHexButton;
}
JPanel colorDisplayPanel: A panel that will display the selected color.
JLabel rgbLabel, hexLabel: Labels to show the RGB values and Hexadecimal code of the selected color.
JButton pickColorButton, copyHexButton: Buttons for selecting a color and copying the hex code.

3. Constructor

public ColorPickerTool() {
    setTitle("Color Picker Tool");
    setSize(400, 200);
    setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    setLocationRelativeTo(null);  // Center the window on the screen

    // Initialize components
    colorDisplayPanel = new JPanel();
    colorDisplayPanel.setBackground(Color.WHITE);  // Default color is white
    colorDisplayPanel.setPreferredSize(new Dimension(100, 100));

    rgbLabel = new JLabel("RGB: ");
    hexLabel = new JLabel("Hex: ");

    pickColorButton = new JButton("Pick a Color");
    copyHexButton = new JButton("Copy Hex Code");

    // Set up layout
    JPanel infoPanel = new JPanel(new GridLayout(2, 1));
    infoPanel.add(rgbLabel);
    infoPanel.add(hexLabel);

    JPanel buttonPanel = new JPanel();
    buttonPanel.add(pickColorButton);
    buttonPanel.add(copyHexButton);

    setLayout(new BorderLayout());
    add(colorDisplayPanel, BorderLayout.WEST);
    add(infoPanel, BorderLayout.CENTER);
    add(buttonPanel, BorderLayout.SOUTH);

    // Add action listeners
    pickColorButton.addActionListener(new PickColorButtonListener());
    copyHexButton.addActionListener(new CopyHexButtonListener());

    setVisible(true);
}

Frame Setup:

setTitle(“Color Picker Tool”): Sets the title of the window.
setSize(400, 200): Sets the window size.
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE): Ensures that the app exits when the window is closed.
setLocationRelativeTo(null): Centers the window on the screen.

Component Initialization:

colorDisplayPanel: Displays the selected color with a default background color of white.
rgbLabel and hexLabel: Show the RGB values and Hexadecimal code of the selected color.
pickColorButton: A button to open the JColorChooser and allow the user to pick a color.
copyHexButton: A button to copy the hex code of the selected color to the clipboard.

Layout Setup:

infoPanel: A panel to hold the labels (rgbLabel, hexLabel) in a grid layout.
buttonPanel: A panel to hold the buttons (pickColorButton, copyHexButton).
setLayout(new BorderLayout()): Uses a border layout to position the components. The color display panel is placed on the left, the information panel in the center, and the buttons at the bottom.

4. getHexColor() Method

private String getHexColor(Color color) {
    return String.format("#%02x%02x%02x", color.getRed(), color.getGreen(), color.getBlue());
}

This method converts a Color object to a Hexadecimal string (e.g., #FF5733).
String.format(): The %02x format ensures that the red, green, and blue values are converted to two-digit hexadecimal numbers.

5. Action Listener for the Pick Color Button

private class PickColorButtonListener implements ActionListener {
    @Override
    public void actionPerformed(ActionEvent e) {
        // Show color chooser dialog
        Color selectedColor = JColorChooser.showDialog(null, "Pick a Color", colorDisplayPanel.getBackground());

        // If a color is selected
        if (selectedColor != null) {
            // Update the color display panel
            colorDisplayPanel.setBackground(selectedColor);

            // Update RGB and Hex labels
            String rgbText = "RGB: " + selectedColor.getRed() + ", " + selectedColor.getGreen() + ", " + selectedColor.getBlue();
            rgbLabel.setText(rgbText);
            String hexText = "Hex: " + getHexColor(selectedColor);
            hexLabel.setText(hexText);
        }
    }
}
JColorChooser.showDialog(): Opens a color picker dialog that allows the user to select a color.
if (selectedColor != null): Ensures that the user has selected a valid color.

Update Components:

colorDisplayPanel.setBackground(selectedColor): Updates the background color of the panel to the selected color.
rgbLabel.setText(rgbText): Displays the RGB values of the selected color.
hexLabel.setText(hexText): Displays the hexadecimal code of the selected color.

6. Action Listener for the Copy Hex Button

private class CopyHexButtonListener implements ActionListener {
    @Override
    public void actionPerformed(ActionEvent e) {
        // Copy the hex value to clipboard
        String hexText = hexLabel.getText().replace("Hex: ", "").trim();
        Toolkit.getDefaultToolkit().getSystemClipboard().setContents(new StringSelection(hexText), null);
        JOptionPane.showMessageDialog(null, "Hex code copied to clipboard!");
    }
}

Copy Hex to Clipboard:

Toolkit.getDefaultToolkit().getSystemClipboard().setContents(): Copies the hex code to the system clipboard.
JOptionPane.showMessageDialog(): Displays a confirmation dialog that the hex code has been copied.

7. Main Method

public static void main(String[] args) {
    SwingUtilities.invokeLater(() -> new ColorPickerTool());
}
SwingUtilities.invokeLater(): Ensures that the GUI is created and updated on the Event Dispatch Thread (EDT), which is necessary for Swing applications.
new ColorPickerTool(): Creates and launches the color picker tool.

Customization Ideas

1. Allow Users to Copy RGB Values
Add a feature to copy the RGB values to the clipboard along with the hex code.

2. Add Color History

Add a panel to display the last few colors picked by the user, so they can revisit recently selected colors.

3. Improve the User Interface

Change the fonts, colors, and layout to make the tool more visually appealing.
Add tooltips to the buttons for better usability.

Conclusion

This Color Picker Tool in Java using Swing allows users to select colors from a palette, view their RGB and Hexadecimal values, and copy the hex code to the clipboard. It demonstrates:

Using JColorChooser to create a color picker dialog.
Displaying RGB and Hex values dynamically as the user selects a color.
Handling clipboard operations to allow the user to copy the hex code for later use.

Feel free to expand the functionality of this tool with additional features!

October 11, 2024 0 comment

Code GUI

Java Word Counter Using Swing Tutorial with code explanation

written by 75ypsaw71

In this tutorial, we will create a Word Counter in Java using Swing for the graphical user interface (GUI). The app will allow users to input text, and it will display the total word count as well as the character count.

The app will update the count dynamically when the user types in the text area.

Table of Contents

Features of the Word Counter App:

The app provides a text area for the user to enter text.
The app calculates and displays:
Word count: The total number of words in the text.
Character count: The total number of characters in the text (including spaces).
The app updates the word and character counts in real-time as the user types.

Complete Code

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

public class WordCounterApp extends JFrame {

    private JTextArea textArea;    // Text area where the user types
    private JLabel wordCountLabel; // Label to display word count
    private JLabel charCountLabel; // Label to display character count

    // Constructor to set up the GUI
    public WordCounterApp() {
        setTitle("Word Counter");
        setSize(500, 300);
        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        setLocationRelativeTo(null);  // Center the window on the screen

        // Create a text area for input
        textArea = new JTextArea();
        textArea.setFont(new Font("Serif", Font.PLAIN, 18));
        textArea.setLineWrap(true);
        textArea.setWrapStyleWord(true);

        // Add key listener to update the word and character counts in real-time
        textArea.addKeyListener(new KeyAdapter() {
            @Override
            public void keyReleased(KeyEvent e) {
                updateCounts();
            }
        });

        // Create labels to display word and character counts
        wordCountLabel = new JLabel("Word Count: 0");
        charCountLabel = new JLabel("Character Count: 0");

        // Panel to hold the count labels
        JPanel countPanel = new JPanel(new GridLayout(1, 2));
        countPanel.add(wordCountLabel);
        countPanel.add(charCountLabel);

        // Set layout for the frame
        setLayout(new BorderLayout());
        add(new JScrollPane(textArea), BorderLayout.CENTER);
        add(countPanel, BorderLayout.SOUTH);

        setVisible(true);
    }

    // Method to update word and character counts
    private void updateCounts() {
        String text = textArea.getText();
        String[] words = text.trim().split("\\s+"); // Split based on spaces
        int wordCount = (text.trim().isEmpty()) ? 0 : words.length;
        int charCount = text.length();

        // Update labels
        wordCountLabel.setText("Word Count: " + wordCount);
        charCountLabel.setText("Character Count: " + charCount);
    }

    // Main method to run the app
    public static void main(String[] args) {
        SwingUtilities.invokeLater(() -> new WordCounterApp());
    }
}

Explanation of the Code

1. Import Statements

import javax.swing.*;
import java.awt.*;
import java.awt.event.KeyAdapter;
import java.awt.event.KeyEvent;
javax.swing.*: Provides Swing components such as JFrame, JTextArea, and JLabel for creating the GUI.
java.awt.*: Provides layout and graphical utilities (e.g., BorderLayout, GridLayout, Font).
java.awt.event.*: Provides event listener classes for handling keyboard events.

2. Class Declaration and Instance Variables

public class WordCounterApp extends JFrame {
    private JTextArea textArea;    // Text area where the user types
    private JLabel wordCountLabel; // Label to display word count
    private JLabel charCountLabel; // Label to display character count
}
JTextArea textArea: A multi-line text area where the user can type text. It supports word wrapping.
JLabel wordCountLabel: A label that displays the current word count.
JLabel charCountLabel: A label that displays the current character count.

3. Constructor

public WordCounterApp() {
    setTitle("Word Counter");
    setSize(500, 300);
    setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    setLocationRelativeTo(null);  // Center the window on the screen

    // Create a text area for input
    textArea = new JTextArea();
    textArea.setFont(new Font("Serif", Font.PLAIN, 18));
    textArea.setLineWrap(true);
    textArea.setWrapStyleWord(true);

    // Add key listener to update the word and character counts in real-time
    textArea.addKeyListener(new KeyAdapter() {
        @Override
        public void keyReleased(KeyEvent e) {
            updateCounts();
        }
    });

    // Create labels to display word and character counts
    wordCountLabel = new JLabel("Word Count: 0");
    charCountLabel = new JLabel("Character Count: 0");

    // Panel to hold the count labels
    JPanel countPanel = new JPanel(new GridLayout(1, 2));
    countPanel.add(wordCountLabel);
    countPanel.add(charCountLabel);

    // Set layout for the frame
    setLayout(new BorderLayout());
    add(new JScrollPane(textArea), BorderLayout.CENTER);
    add(countPanel, BorderLayout.SOUTH);

    setVisible(true);
}

Frame Setup:

setTitle(“Word Counter”): Sets the window title.
setSize(500, 300): Sets the window size.
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE): Ensures the app exits when the window is closed.
setLocationRelativeTo(null): Centers the window on the screen.

Text Area Setup:

textArea = new JTextArea(): Creates the text area for typing.
textArea.setFont(new Font(“Serif”, Font.PLAIN, 18)): Sets the font for the text area.
textArea.setLineWrap(true): Enables word wrapping.
textArea.setWrapStyleWord(true): Ensures that words are not cut off when wrapping.

Key Listener Setup:

textArea.addKeyListener(new KeyAdapter() { … }): Adds a key listener to the text area that updates the word and character counts whenever a key is released.

Count Labels Setup:

wordCountLabel: Displays the current word count.
charCountLabel: Displays the current character count.

Panel Setup:

JPanel countPanel = new JPanel(new GridLayout(1, 2)): Creates a panel to hold the two labels with a grid layout of 1 row and 2 columns.
Adds the word count and character count labels to the panel.

Layout Setup:

setLayout(new BorderLayout()): Uses a BorderLayout to position components.
add(new JScrollPane(textArea), BorderLayout.CENTER): Adds a scrollable text area to the center of the window.
add(countPanel, BorderLayout.SOUTH): Adds the panel with the count labels to the bottom of the window.

4. updateCounts() Method

private void updateCounts() {
    String text = textArea.getText();
    String[] words = text.trim().split("\\s+"); // Split based on spaces
    int wordCount = (text.trim().isEmpty()) ? 0 : words.length;
    int charCount = text.length();

    // Update labels
    wordCountLabel.setText("Word Count: " + wordCount);
    charCountLabel.setText("Character Count: " + charCount);
}
textArea.getText(): Retrieves the text entered in the text area.

Word Counting:

text.trim().split(“\\s+”): Splits the text into words based on one or more spaces. trim() removes any leading or trailing whitespace.
(text.trim().isEmpty()) ? 0 : words.length: If the trimmed text is empty, the word count is set to 0; otherwise, the length of the words array is used as the word count.

Character Counting:

text.length(): The length of the string is used to calculate the character count, including spaces.

Updating Labels:

wordCountLabel.setText(“Word Count: ” + wordCount): Updates the word count label.
charCountLabel.setText(“Character Count: ” + charCount): Updates the character count label.

5. Main Method

public static void main(String[] args) {
    SwingUtilities.invokeLater(() -> new WordCounterApp());
}
SwingUtilities.invokeLater(): Ensures that the GUI is created and updated on the Event Dispatch Thread (EDT), which is necessary for Swing applications.
new WordCounterApp(): Creates and launches the word counter app.

Customization Ideas

1. Add a File Input Option

Add a button to allow the user to load text from a file (JFileChooser). The word and character counts would then be calculated for the file content.

2. Display Additional Statistics

Display additional statistics such as:
Sentence count
Paragraph count
Longest word

3. Improve the User Interface

Change the fonts, colors, or layout to improve the appearance of the app.
Add icons to buttons or use tooltips for added usability.

4. Add Real-time Copying to Clipboard

Add a button to copy the entire text or just the word/character counts to the clipboard for use in other applications.

Conclusion

This Word Counter App in Java using Swing is a simple, yet useful, application that allows users to count the number of words and characters in a text.

The app includes:

Using Swing components (JFrame, JTextArea, JLabel) to create a graphical interface.
Updating the word and character counts dynamically as the user types.
Handling keyboard events with KeyListener to trigger real-time updates.

Feel free to expand this project with additional features or improvements to suit your needs!

October 10, 2024 0 comment

Code GUI

Java Stopwatch Using Swing Tutorial with code explanation

written by 75ypsaw71

In this tutorial, we will build a simple Stopwatch application in Java using Swing for the graphical user interface (GUI).

The stopwatch will have Start, Stop, and Reset functionalities, and will display the elapsed time in seconds and milliseconds.

This is the app you will create in action

Table of Contents

Features of the Stopwatch App:

Here are the features we want in the app, fairly obvious for a stopwatch.

Start: Starts the stopwatch and updates the displayed time every millisecond.
Stop: Stops the stopwatch without resetting the elapsed time.
Reset: Resets the stopwatch to 0.

The app will use Swing components like JFrame, JButton, and JLabel to create the user interface.

Complete Code

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

public class StopwatchApp extends JFrame {
    private JLabel timeLabel;
    private JButton startButton, stopButton, resetButton;
    private Timer timer;
    private long startTime;
    private long elapsedTime = 0;  // Tracks the total elapsed time

    // Constructor to set up the GUI
    public StopwatchApp() {
        setTitle("Stopwatch");
        setSize(300, 200);
        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        setLocationRelativeTo(null);  // Center the window on the screen

        // Initialize components
        timeLabel = new JLabel("00:00:000", SwingConstants.CENTER);
        timeLabel.setFont(new Font("Serif", Font.BOLD, 36));

        startButton = new JButton("Start");
        stopButton = new JButton("Stop");
        resetButton = new JButton("Reset");

        // Disable stop and reset buttons initially
        stopButton.setEnabled(false);
        resetButton.setEnabled(false);

        // Set up the layout
        JPanel buttonPanel = new JPanel();
        buttonPanel.add(startButton);
        buttonPanel.add(stopButton);
        buttonPanel.add(resetButton);

        setLayout(new BorderLayout());
        add(timeLabel, BorderLayout.CENTER);
        add(buttonPanel, BorderLayout.SOUTH);

        // Timer to update the stopwatch every millisecond
        timer = new Timer(1, new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                elapsedTime = System.currentTimeMillis() - startTime;
                updateDisplay();
            }
        });

        // Add action listeners to the buttons
        startButton.addActionListener(new StartButtonListener());
        stopButton.addActionListener(new StopButtonListener());
        resetButton.addActionListener(new ResetButtonListener());

        setVisible(true);
    }

    // Method to update the time display
    private void updateDisplay() {
        long seconds = (elapsedTime / 1000) % 60;
        long minutes = (elapsedTime / (1000 * 60)) % 60;
        long milliseconds = elapsedTime % 1000;
        timeLabel.setText(String.format("%02d:%02d:%03d", minutes, seconds, milliseconds));
    }

    // Action listener for the Start button
    private class StartButtonListener implements ActionListener {
        @Override
        public void actionPerformed(ActionEvent e) {
            startTime = System.currentTimeMillis() - elapsedTime;  // Adjust for any existing elapsed time
            timer.start();  // Start the timer
            startButton.setEnabled(false);  // Disable the start button
            stopButton.setEnabled(true);  // Enable the stop button
            resetButton.setEnabled(false);  // Disable the reset button
        }
    }

    // Action listener for the Stop button
    private class StopButtonListener implements ActionListener {
        @Override
        public void actionPerformed(ActionEvent e) {
            timer.stop();  // Stop the timer
            startButton.setEnabled(true);  // Enable the start button
            stopButton.setEnabled(false);  // Disable the stop button
            resetButton.setEnabled(true);  // Enable the reset button
        }
    }

    // Action listener for the Reset button
    private class ResetButtonListener implements ActionListener {
        @Override
        public void actionPerformed(ActionEvent e) {
            timer.stop();  // Stop the timer
            elapsedTime = 0;  // Reset elapsed time
            updateDisplay();  // Update the display to show "00:00:000"
            startButton.setEnabled(true);  // Enable the start button
            stopButton.setEnabled(false);  // Disable the stop button
            resetButton.setEnabled(false);  // Disable the reset button
        }
    }

    // Main method to run the app
    public static void main(String[] args) {
        SwingUtilities.invokeLater(() -> new StopwatchApp());
    }
}

Explanation of the Code

1. Import Statements

import javax.swing.*;
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
javax.swing.*: Provides Swing components like JFrame, JButton, and JLabel for creating the GUI.
java.awt.*: Provides layout and graphical utilities (BorderLayout, Font).
java.awt.event.*: Provides event listener classes to handle button clicks and timer events.

2. Class Declaration and Instance Variables

public class StopwatchApp extends JFrame {
    private JLabel timeLabel;
    private JButton startButton, stopButton, resetButton;
    private Timer timer;
    private long startTime;
    private long elapsedTime = 0;
}

JLabel timeLabel: Displays the current time (minutes, seconds, and milliseconds).
JButton startButton, stopButton, resetButton: Buttons for starting, stopping, and resetting the stopwatch.
Timer timer: A Swing Timer that updates the time display every millisecond.
long startTime: Tracks the time when the stopwatch starts.
long elapsedTime: Tracks the total elapsed time, even after stopping.

3. Constructor

public StopwatchApp() {
    setTitle("Stopwatch");
    setSize(300, 200);
    setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    setLocationRelativeTo(null);  // Center the window on the screen

    timeLabel = new JLabel("00:00:000", SwingConstants.CENTER);
    timeLabel.setFont(new Font("Serif", Font.BOLD, 36));

    startButton = new JButton("Start");
    stopButton = new JButton("Stop");
    resetButton = new JButton("Reset");

    stopButton.setEnabled(false);
    resetButton.setEnabled(false);

    JPanel buttonPanel = new JPanel();
    buttonPanel.add(startButton);
    buttonPanel.add(stopButton);
    buttonPanel.add(resetButton);

    setLayout(new BorderLayout());
    add(timeLabel, BorderLayout.CENTER);
    add(buttonPanel, BorderLayout.SOUTH);

    timer = new Timer(1, new ActionListener() {
        @Override
        public void actionPerformed(ActionEvent e) {
            elapsedTime = System.currentTimeMillis() - startTime;
            updateDisplay();
        }
    });

    startButton.addActionListener(new StartButtonListener());
    stopButton.addActionListener(new StopButtonListener());
    resetButton.addActionListener(new ResetButtonListener());

    setVisible(true);
}

Frame Setup:

setTitle(“Stopwatch”): Sets the window title.
setSize(300, 200): Sets the window size.
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE): Ensures the app exits when the window is closed.
setLocationRelativeTo(null): Centers the window on the screen.

Label Setup:

timeLabel = new JLabel(“00:00:000”, SwingConstants.CENTER): Initializes the label with the default “00:00:000” text.
timeLabel.setFont(new Font(“Serif”, Font.BOLD, 36)): Sets the font for the time label.

Button Setup:

stopButton.setEnabled(false) and resetButton.setEnabled(false): The stop and reset buttons are disabled initially.

Layout Setup:

setLayout(new BorderLayout()): Uses a BorderLayout to position the components.
add(timeLabel, BorderLayout.CENTER): Adds the label to the center of the window.
add(buttonPanel, BorderLayout.SOUTH): Adds the button panel at the bottom of the window.

Timer Setup:

timer = new Timer(1, …): The Timer is set to update the elapsed time every millisecond (1 ms).

Inside the timer’s ActionListener, we calculate the elapsed time and call updateDisplay() to refresh the display.

4. updateDisplay() Method

private void updateDisplay() {
    long seconds = (elapsedTime / 1000) % 60;
    long minutes = (elapsedTime / (1000 * 60)) % 60;
    long milliseconds = elapsedTime % 1000;
    timeLabel.setText(String.format("%02d:%02d:%03d", minutes, seconds, milliseconds));
}
elapsedTime / 1000: Converts milliseconds to seconds.
elapsedTime / (1000 * 60): Converts milliseconds to minutes.
elapsedTime % 1000: Extracts the remaining milliseconds.
String.format("%02d:%02d:%03d", ...): Formats the time as mm:ss:SSS, where mm is minutes, ss is seconds, and SSS is milliseconds.

5. Action Listener for the Start Button

private class StartButtonListener implements ActionListener {
    @Override
    public void actionPerformed(ActionEvent e) {
        startTime = System.currentTimeMillis() - elapsedTime;  // Adjust for any existing elapsed time
        timer.start();  // Start the timer
        startButton.setEnabled(false);  // Disable the start button
        stopButton.setEnabled(true);  // Enable the stop button
        resetButton.setEnabled(false);  // Disable the reset button
    }
}
startTime = System.currentTimeMillis() - elapsedTime: Adjusts the start time to account for any elapsed time (if the stopwatch was stopped and restarted).
timer.start(): Starts the timer.
startButton.setEnabled(false): Disables the start button while the stopwatch is running.
stopButton.setEnabled(true): Enables the stop button.
resetButton.setEnabled(false): Disables the reset button.

6. Action Listener for the Stop Button

private class StopButtonListener implements ActionListener {
    @Override
    public void actionPerformed(ActionEvent e) {
        timer.stop();  // Stop the timer
        startButton.setEnabled(true);  // Enable the start button
        stopButton.setEnabled(false);  // Disable the stop button
        resetButton.setEnabled(true);  // Enable the reset button
    }
}
timer.stop(): Stops the timer.
startButton.setEnabled(true): Re-enables the start button.
stopButton.setEnabled(false): Disables the stop button after stopping the timer.
resetButton.setEnabled(true): Enables the reset button after stopping the timer.

7. Action Listener for the Reset Button

private class ResetButtonListener implements ActionListener {
    @Override
    public void actionPerformed(ActionEvent e) {
        timer.stop();  // Stop the timer
        elapsedTime = 0;  // Reset the elapsed time
        updateDisplay();  // Update the display to show "00:00:000"
        startButton.setEnabled(true);  // Enable the start button
        stopButton.setEnabled(false);  // Disable the stop button
        resetButton.setEnabled(false);  // Disable the reset button
    }
}
timer.stop(): Stops the timer.
elapsedTime = 0: Resets the elapsed time to 0.
updateDisplay(): Updates the display to show "00:00:000".
startButton.setEnabled(true): Re-enables the start button.
stopButton.setEnabled(false): Disables the stop button.
resetButton.setEnabled(false): Disables the reset button after resetting.

8. Main Method

public static void main(String[] args) {
    SwingUtilities.invokeLater(() -> new StopwatchApp());
}
SwingUtilities.invokeLater(): Ensures that the GUI is created and updated on the Event Dispatch Thread (EDT), which is necessary for Swing applications.
new StopwatchApp(): Creates and launches the stopwatch app.

Customization Ideas

1. Add Lap Functionality

Add a Lap button to record the current time while the stopwatch is running and display the laps in a list (JList or JTextArea).

2. Change the Display Format
Allow the user to choose between different time formats (e.g., hours, minutes, seconds, milliseconds) using a dropdown or radio buttons.

3. Custom Styling
Customize the appearance of the buttons, label, and window (e.g., change colors, add icons).

4. Sound on Start/Stop
Add a small beep sound or sound when the user starts or stops the stopwatch.

Conclusion

This simple Stopwatch App in Java using Swing demonstrates how to build a GUI application with basic time-keeping functionality. The app includes start, stop, and reset functionality, and the time is displayed with precision in milliseconds.

This project introduces:

Using Swing to create a graphical interface.
Handling timers with Timer to update the time display.
Implementing event-driven programming with action listeners for buttons.

Feel free to extend this project with additional features or customize the UI to suit your needs!

October 10, 2024 0 comment

Code GUI

Java Lottery Number Generator Tutorial with code explanation

written by 75ypsaw71

In this tutorial, we will build a simple Lottery Number Generator in Java.

The program will generate a set of unique random lottery numbers, which the user can use for games like the lottery or similar random-number-based events.

Here is an image of what you will create

Features of the Lottery Number Generator:

The app will generate a set of 6 unique random numbers between 1 and 49 (commonly used in many lotteries).
The numbers will be displayed in ascending order for better readability.
The user can click a button to generate a new set of random numbers.
The app will use Swing for the GUI, allowing the user to interact with the program easily.

Complete Code

import javax.swing.*;
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.util.Arrays;
import java.util.HashSet;
import java.util.Random;
import java.util.Set;

public class LotteryNumberGenerator extends JFrame {

    private JLabel numbersLabel;
    private JButton generateButton;

    // Constructor to set up the GUI
    public LotteryNumberGenerator() {
        setTitle("Lottery Number Generator");
        setSize(500, 200);
        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        setLocationRelativeTo(null);  // Center the window on the screen

        // Label to display lottery numbers
        numbersLabel = new JLabel("Lottery Numbers: ", SwingConstants.CENTER);
        numbersLabel.setFont(new Font("Serif", Font.BOLD, 24));

        // Button to generate numbers
        generateButton = new JButton("Generate Numbers");
        generateButton.addActionListener(new GenerateButtonListener());

        // Set up the layout of the app
        setLayout(new BorderLayout());
        add(numbersLabel, BorderLayout.CENTER);
        add(generateButton, BorderLayout.SOUTH);

        setVisible(true);
    }

    // Method to generate 6 unique random numbers between 1 and 49
    private int[] generateLotteryNumbers() {
        Random random = new Random();
        Set numberSet = new HashSet<>();

        // Ensure we get exactly 6 unique numbers
        while (numberSet.size() < 6) { int number = random.nextInt(49) + 1; // Generates numbers from 1 to 49 numberSet.add(number); } // Convert the set to an array and sort it int[] lotteryNumbers = numberSet.stream().mapToInt(Integer::intValue).toArray(); Arrays.sort(lotteryNumbers); return lotteryNumbers; } // Action listener for the generate button private class GenerateButtonListener implements ActionListener { @Override public void actionPerformed(ActionEvent e) { int[] lotteryNumbers = generateLotteryNumbers(); // Generate numbers numbersLabel.setText("Lottery Numbers: " + Arrays.toString(lotteryNumbers)); // Display numbers } } // Main method to run the app public static void main(String[] args) { SwingUtilities.invokeLater(() -> new LotteryNumberGenerator());
    }
}

Explanation of the Code

1. Import Statements

import javax.swing.*;
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.util.Arrays;
import java.util.HashSet;
import java.util.Random;
import java.util.Set;
javax.swing.*: Provides the necessary classes to create a graphical user interface (e.g., JFrame, JButton, JLabel).
java.awt.*: Provides layout managers and other graphical utilities (e.g., BorderLayout, Font).
java.awt.event.*: Provides event handling, such as responding to button clicks (ActionEvent, ActionListener).
java.util.*: Provides utilities for generating random numbers (Random), working with collections (Set, HashSet), and sorting (Arrays).

2. Class Declaration and Instance Variables

public class LotteryNumberGenerator extends JFrame {
    private JLabel numbersLabel;
    private JButton generateButton;
}
JLabel numbersLabel: A label to display the generated lottery numbers.
JButton generateButton: A button that the user clicks to generate a new set of random numbers.

3. Constructor

public LotteryNumberGenerator() {
    setTitle("Lottery Number Generator");
    setSize(500, 200);
    setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    setLocationRelativeTo(null);  // Center the window on the screen

    numbersLabel = new JLabel("Lottery Numbers: ", SwingConstants.CENTER);
    numbersLabel.setFont(new Font("Serif", Font.BOLD, 24));

    generateButton = new JButton("Generate Numbers");
    generateButton.addActionListener(new GenerateButtonListener());

    setLayout(new BorderLayout());
    add(numbersLabel, BorderLayout.CENTER);
    add(generateButton, BorderLayout.SOUTH);

    setVisible(true);
}

Frame Setup:

setTitle(“Lottery Number Generator”): Sets the window title.
setSize(400, 200): Sets the size of the window.
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE): Ensures the application exits when the window is closed.
setLocationRelativeTo(null): Centers the window on the screen.

Label Setup:

numbersLabel = new JLabel(“Lottery Numbers: “, SwingConstants.CENTER): A label to display the generated lottery numbers.
setFont(new Font(“Serif”, Font.BOLD, 24)): Sets the font style and size for the label text.

Button Setup:

generateButton = new JButton(“Generate Numbers”): A button to generate lottery numbers.
generateButton.addActionListener(new GenerateButtonListener()): Adds an action listener to handle button clicks.

Layout Setup:

setLayout(new BorderLayout()): Uses a BorderLayout to position components.
add(numbersLabel, BorderLayout.CENTER): Adds the label to the center of the window.
add(generateButton, BorderLayout.SOUTH): Adds the button at the bottom of the window.

Visibility:

setVisible(true): Makes the window visible.

4. generateLotteryNumbers() Method

private int[] generateLotteryNumbers() {
    Random random = new Random();
    Set numberSet = new HashSet<>();

    while (numberSet.size() < 6) {
        int number = random.nextInt(49) + 1;  // Generates numbers from 1 to 49
        numberSet.add(number);
    }

    int[] lotteryNumbers = numberSet.stream().mapToInt(Integer::intValue).toArray();
    Arrays.sort(lotteryNumbers);
    return lotteryNumbers;
}

Random Number Generation:

Random random = new Random(): Creates a Random object to generate random numbers.
random.nextInt(49) + 1: Generates a random number between 1 and 49.
Set numberSet = new HashSet<>(): A set is used to store the numbers, ensuring that all numbers are unique.

Ensuring 6 Unique Numbers:

The while loop ensures that exactly 6 unique numbers are generated.

Convert Set to Array:

numberSet.stream().mapToInt(Integer::intValue).toArray(): Converts the set of numbers into an array.
Arrays.sort(lotteryNumbers): Sorts the numbers in ascending order for better readability.

Return the Lottery Numbers:

The method returns an array of 6 unique, sorted lottery numbers.

5. GenerateButtonListener Class

private class GenerateButtonListener implements ActionListener {
    @Override
    public void actionPerformed(ActionEvent e) {
        int[] lotteryNumbers = generateLotteryNumbers();  // Generate numbers
        numbersLabel.setText("Lottery Numbers: " + Arrays.toString(lotteryNumbers));  // Display numbers
    }
}

Button Click Handling:

generateLotteryNumbers(): Calls the method to generate random lottery numbers.
numbersLabel.setText(): Updates the label to display the generated numbers.

6. Main Method

public static void main(String[] args) {
    SwingUtilities.invokeLater(() -> new LotteryNumberGenerator());
}
SwingUtilities.invokeLater(): Ensures that the GUI is created and updated on the Event Dispatch Thread (EDT), which is necessary for Swing applications.
new LotteryNumberGenerator(): Creates and launches an instance of the lottery number generator app.

Customization Ideas

1. Change the Range of Numbers

You can change the range of numbers by modifying the value inside the random.nextInt() function. For example, to generate numbers between 1 and 100:

int number = random.nextInt(100) + 1;

2. Change the Number of Lottery Numbers

If you want to generate a different number of lottery numbers (e.g., 5 numbers instead of 6), modify the while loop condition:

while (numberSet.size() < 5) {
    // Generate numbers
}

3. Allow the User to Customize the Number Range

You can add input fields to allow the user to specify the number range and the number of lottery numbers to generate. This can be done by adding JTextField components for user input.

4. Add an Option to Save the Generated Numbers

You can add functionality to save the generated numbers to a file using FileWriter or PrintWriter. This will allow the user to keep a record of their generated numbers.

5. Style the App

You can enhance the appearance of the app by changing the background color, font size, or adding custom icons to the buttons and labels.

Conclusion

This simple Lottery Number Generator demonstrates how to create a Java GUI application using Swing. The app generates random numbers for lottery-style games, ensuring that the numbers are unique and sorted for better readability.

Key concepts covered:

Creating a GUI using Swing (JFrame, JLabel, JButton).
Random number generation using the Random class.
Handling button click events with ActionListener.
Displaying dynamically updated content in a JLabel.

You can expand this project by adding more features like allowing the user to customize the number range or save their results.

October 10, 2024 0 comment

Code GUI

Java BMI and BMR Calculator App Using Swing Tutorial with code explanation

written by 75ypsaw71

In this tutorial, we’ll build a BMI (Body Mass Index) and BMR (Basal Metabolic Rate) calculator in Java using Swing for the graphical user interface (GUI).

The app will allow users to input their weight, height, age, and gender to calculate their BMI and BMR.

Features of the BMI and BMR Calculator:

BMI Calculation: The app calculates BMI using the formula:

BMI = weight (kg) / height (m)

BMR Calculation: The app calculates BMR using the Mifflin-St Jeor equation:

For men:

BMR=10×weight (kg)+6.25×height (cm)−5×age+5

For women:

BMR=10×weight (kg)+6.25×height (cm)−5×age−161

The user inputs their weight, height, age, and gender.
The app displays the calculated BMI and BMR.
The app allows users to reset the input fields.

Complete Code of the App

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

public class BMIBMRCalculatorApp extends JFrame {

    // Components for input
    private JTextField weightField, heightField, ageField;
    private JRadioButton maleButton, femaleButton;
    private JButton calculateButton, resetButton;

    // Labels for output
    private JLabel bmiLabel, bmrLabel;

    // Constructor to set up the UI
    public BMIBMRCalculatorApp() {
        setTitle("BMI and BMR Calculator");
        setSize(400, 300);
        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        setLocationRelativeTo(null);  // Center the window on the screen

        // Panel for input fields
        JPanel inputPanel = new JPanel(new GridLayout(6, 2, 10, 10));
        inputPanel.setBorder(BorderFactory.createEmptyBorder(10, 10, 10, 10));

        // Input labels and fields
        inputPanel.add(new JLabel("Weight (kg):"));
        weightField = new JTextField();
        inputPanel.add(weightField);

        inputPanel.add(new JLabel("Height (cm):"));
        heightField = new JTextField();
        inputPanel.add(heightField);

        inputPanel.add(new JLabel("Age (years):"));
        ageField = new JTextField();
        inputPanel.add(ageField);

        // Gender selection
        inputPanel.add(new JLabel("Gender:"));
        JPanel genderPanel = new JPanel(new FlowLayout(FlowLayout.LEFT));
        ButtonGroup genderGroup = new ButtonGroup();
        maleButton = new JRadioButton("Male", true);
        femaleButton = new JRadioButton("Female");
        genderGroup.add(maleButton);
        genderGroup.add(femaleButton);
        genderPanel.add(maleButton);
        genderPanel.add(femaleButton);
        inputPanel.add(genderPanel);

        // Buttons for calculate and reset
        calculateButton = new JButton("Calculate");
        resetButton = new JButton("Reset");
        inputPanel.add(calculateButton);
        inputPanel.add(resetButton);

        // Panel for output labels
        JPanel outputPanel = new JPanel(new GridLayout(2, 1, 10, 10));
        bmiLabel = new JLabel("BMI: ");
        bmrLabel = new JLabel("BMR: ");
        outputPanel.add(bmiLabel);
        outputPanel.add(bmrLabel);

        // Add action listeners
        calculateButton.addActionListener(new CalculateButtonListener());
        resetButton.addActionListener(new ResetButtonListener());

        // Set layout for the frame
        setLayout(new BorderLayout());
        add(inputPanel, BorderLayout.CENTER);
        add(outputPanel, BorderLayout.SOUTH);

        setVisible(true);
    }

    // Method to calculate and display BMI and BMR
    private void calculateBMIandBMR() {
        try {
            double weight = Double.parseDouble(weightField.getText());
            double height = Double.parseDouble(heightField.getText()) / 100.0;  // Convert height to meters
            int age = Integer.parseInt(ageField.getText());

            // Calculate BMI
            double bmi = weight / (height * height);

            // Calculate BMR based on gender
            double bmr;
            if (maleButton.isSelected()) {
                bmr = 10 * weight + 6.25 * (height * 100) - 5 * age + 5;  // For men
            } else {
                bmr = 10 * weight + 6.25 * (height * 100) - 5 * age - 161;  // For women
            }

            // Display results
            bmiLabel.setText(String.format("BMI: %.2f", bmi));
            bmrLabel.setText(String.format("BMR: %.2f", bmr));

        } catch (NumberFormatException ex) {
            JOptionPane.showMessageDialog(this, "Please enter valid numeric values.", "Input Error", JOptionPane.ERROR_MESSAGE);
        }
    }

    // Action listener for the calculate button
    private class CalculateButtonListener implements ActionListener {
        public void actionPerformed(ActionEvent e) {
            calculateBMIandBMR();
        }
    }

    // Action listener for the reset button
    private class ResetButtonListener implements ActionListener {
        public void actionPerformed(ActionEvent e) {
            weightField.setText("");
            heightField.setText("");
            ageField.setText("");
            bmiLabel.setText("BMI: ");
            bmrLabel.setText("BMR: ");
        }
    }

    // Main method to run the app
    public static void main(String[] args) {
        SwingUtilities.invokeLater(() -> new BMIBMRCalculatorApp());
    }
}

Explanation of the Code

1. Import Statements

import javax.swing.*;
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
javax.swing.*: Imports all Swing components (JFrame, JButton, JTextField, JLabel, etc.).
java.awt.*: Imports AWT components and layout managers (GridLayout, FlowLayout, BorderLayout).
java.awt.event.*: Imports event listener classes for handling button clicks.

2. Class Declaration and Instance Variables

public class BMIBMRCalculatorApp extends JFrame {
    // Components for input
    private JTextField weightField, heightField, ageField;
    private JRadioButton maleButton, femaleButton;
    private JButton calculateButton, resetButton;

    // Labels for output
    private JLabel bmiLabel, bmrLabel;
}
JTextField weightField, heightField, ageField: Text fields for user input (weight, height, and age).
JRadioButton maleButton, femaleButton: Radio buttons to select gender.
JButton calculateButton, resetButton: Buttons to trigger the calculation and reset the input fields.
JLabel bmiLabel, bmrLabel: Labels to display the calculated BMI and BMR.

3. Constructor

public BMIBMRCalculatorApp() {
    setTitle("BMI and BMR Calculator");
    setSize(400, 300);
    setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    setLocationRelativeTo(null);

    // Panel for input fields
    JPanel inputPanel = new JPanel(new GridLayout(6, 2, 10, 10));
    inputPanel.setBorder(BorderFactory.createEmptyBorder(10, 10, 10, 10));

    // Input labels and fields
    inputPanel.add(new JLabel("Weight (kg):"));
    weightField = new JTextField();
    inputPanel.add(weightField);

    inputPanel.add(new JLabel("Height (cm):"));
    heightField = new JTextField();
    inputPanel.add(heightField);

    inputPanel.add(new JLabel("Age (years):"));
    ageField = new JTextField();
    inputPanel.add(ageField);

    // Gender selection
    inputPanel.add(new JLabel("Gender:"));
    JPanel genderPanel = new JPanel(new FlowLayout(FlowLayout.LEFT));
    ButtonGroup genderGroup = new ButtonGroup();
    maleButton = new JRadioButton("Male", true);
    femaleButton = new JRadioButton("Female");
    genderGroup.add(maleButton);
    genderGroup.add(femaleButton);
    genderPanel.add(maleButton);
    genderPanel.add(femaleButton);
    inputPanel.add(genderPanel);

    // Buttons for calculate and reset
    calculateButton = new JButton("Calculate");
    resetButton = new JButton("Reset");
    inputPanel.add(calculateButton);
    inputPanel.add(resetButton);

    // Panel for output labels
    JPanel outputPanel = new JPanel(new GridLayout(2, 1, 10, 10));
    bmiLabel = new JLabel("BMI: ");
    bmrLabel = new JLabel("BMR: ");
    outputPanel.add(bmiLabel);
    outputPanel.add(bmrLabel);

    // Add action listeners
    calculateButton.addActionListener(new CalculateButtonListener());
    resetButton.addActionListener(new ResetButtonListener());

    // Set layout for the frame
    setLayout(new BorderLayout());
    add(inputPanel, BorderLayout.CENTER);
    add(outputPanel, BorderLayout.SOUTH);

    setVisible(true);
}

Frame Setup:

setTitle(“BMI and BMR Calculator”): Sets the window title.
setSize(400, 300): Sets the window size.
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE): Ensures the program exits when the window is closed.
setLocationRelativeTo(null): Centers the window on the screen.
Input Panel Setup:

JTextField: Text fields for weight, height, and age input.
JRadioButton: Radio buttons for selecting gender (Male/Female).
JButton: Two buttons, one for calculating BMI and BMR and one for resetting the fields.
Output Panel Setup:

JLabel: Labels to display the calculated BMI and BMR.

4. calculateBMIandBMR() Method

private void calculateBMIandBMR() {
    try {
        double weight = Double.parseDouble(weightField.getText());
        double height = Double.parseDouble(heightField.getText()) / 100.0;  // Convert height to meters
        int age = Integer.parseInt(ageField.getText());

        // Calculate BMI
        double bmi = weight / (height * height);

        // Calculate BMR based on gender
        double bmr;
        if (maleButton.isSelected()) {
            bmr = 10 * weight + 6.25 * (height * 100) - 5 * age + 5;  // For men
        } else {
            bmr = 10 * weight + 6.25 * (height * 100) - 5 * age - 161;  // For women
        }

        // Display results
        bmiLabel.setText(String.format("BMI: %.2f", bmi));
        bmrLabel.setText(String.format("BMR: %.2f", bmr));

    } catch (NumberFormatException ex) {
        JOptionPane.showMessageDialog(this, "Please enter valid numeric values.", "Input Error", JOptionPane.ERROR_MESSAGE);
    }
}

BMI Calculation:

Formula: BMI = weight / (height in meters)^2.
The height is entered in centimeters by the user, so it is converted to meters (height / 100).
BMI is then calculated and displayed using bmiLabel.

BMR Calculation:

The Mifflin-St Jeor Equation is used:
For men: BMR = 10 * weight + 6.25 * height (in cm) – 5 * age + 5
For women: BMR = 10 * weight + 6.25 * height (in cm) – 5 * age – 161
The calculated BMR is displayed using bmrLabel.

Error Handling:

If the input values are invalid (non-numeric), a message dialog is displayed using JOptionPane.

5. Action Listeners

// Action listener for the calculate button
private class CalculateButtonListener implements ActionListener {
    public void actionPerformed(ActionEvent e) {
        calculateBMIandBMR();
    }
}

// Action listener for the reset button
private class ResetButtonListener implements ActionListener {
    public void actionPerformed(ActionEvent e) {
        weightField.setText("");
        heightField.setText("");
        ageField.setText("");
        bmiLabel.setText("BMI: ");
        bmrLabel.setText("BMR: ");
    }
}

CalculateButtonListener:

Calls the calculateBMIandBMR() method when the user clicks the “Calculate” button.

ResetButtonListener:

Clears all input fields and resets the output labels when the user clicks the “Reset” button.

6. Main Method

public static void main(String[] args) {
    SwingUtilities.invokeLater(() -> new BMIBMRCalculatorApp());
}

SwingUtilities.invokeLater(): Ensures that the GUI runs on the Event Dispatch Thread (EDT), which is necessary for thread-safe updates in Swing applications.
new BMIBMRCalculatorApp(): Creates and launches an instance of the BMI/BMR calculator app.

Customization Ideas

1. Allow Different Units

Add a dropdown or toggle for users to select between metric units (kg, cm) and imperial units (lbs, inches).
Convert between units in the calculation methods.

2. Include Activity Level for BMR

Add an option to input activity level (e.g., sedentary, light activity, moderate activity).
Adjust the BMR formula to calculate total daily energy expenditure (TDEE) based on the activity level.

3. Add Validation for Input Values

Add more detailed validation to ensure inputs are within a reasonable range (e.g., weight and height are positive numbers).
Display specific error messages for invalid inputs.

4. Customize the Appearance

Change the fonts, colors, and layout to improve the UI.
For example, you can change the background color of the window or make the buttons more visually appealing.

Conclusion

This tutorial demonstrates how to create a BMI and BMR Calculator App using Java Swing. The project covers:

Creating a GUI with Swing components (JFrame, JLabel, JTextField, JRadioButton, JButton).
Handling user input and performing calculations based on the inputs.
Displaying output dynamically based on the user’s actions.
Handling events with action listeners.

You can extend this basic app by adding more features, customizing the UI, or allowing the app to handle more complex calculations like total daily energy expenditure (TDEE) based on activity level.

October 10, 2024 0 comment

Code GUI

Java Quotes App Using Swing Tutorial with code explanation

written by 75ypsaw71

In this tutorial, we’ll build a simple Quotes App in Java using Swing for the graphical user interface (GUI).

The app will display a random quote from a collection of quotes every time the user clicks a button.

This is a great project to learn the basics of Java Swing, event handling, and randomization.

Features of the Quotes App:

The app has a collection of quotes stored in an array.
When the user clicks the “Show Another Quote” button, a random quote is displayed.
The quotes will be shown in a JLabel with a button below to refresh the displayed quote.
The app uses JFrame to create the window, JButton for user interaction, and JLabel to display quotes.

Complete Code

import javax.swing.*;
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.util.Random;

public class QuotesApp extends JFrame {

    private JLabel quoteLabel;  // Label to display the quote
    private JButton nextQuoteButton;  // Button to show another quote
    private String[] quotes;  // Array of quotes

    // Constructor to set up the app
    public QuotesApp() {
        setTitle("Quotes App");
        setSize(400, 200);
        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        setLocationRelativeTo(null);  // Center the window

        // Initialize the quotes array with a set of quotes
        quotes = new String[]{
            "The only limit to our realization of tomorrow is our doubts of today. – Franklin D. Roosevelt",
            "Do what you can, with what you have, where you are. – Theodore Roosevelt",
            "Success is not final, failure is not fatal: It is the courage to continue that counts. – Winston Churchill",
            "You define your own life. Don't let other people write your script. – Oprah Winfrey",
            "Life is what happens when you're busy making other plans. – John Lennon",
            "Believe you can and you're halfway there. – Theodore Roosevelt"
        };

        // Create and configure the quote label
        quoteLabel = new JLabel(getRandomQuote());
        quoteLabel.setFont(new Font("Serif", Font.ITALIC, 16));
        quoteLabel.setHorizontalAlignment(SwingConstants.CENTER);
        quoteLabel.setVerticalAlignment(SwingConstants.CENTER);

        // Create the "Show Another Quote" button
        nextQuoteButton = new JButton("Show Another Quote");
        nextQuoteButton.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                quoteLabel.setText(getRandomQuote());  // Display a new random quote
            }
        });

        // Set up the layout of the app
        setLayout(new BorderLayout());
        add(quoteLabel, BorderLayout.CENTER);  // Add the quote label in the center
        add(nextQuoteButton, BorderLayout.SOUTH);  // Add the button at the bottom

        // Make the frame visible
        setVisible(true);
    }

    // Method to get a random quote from the array
    private String getRandomQuote() {
        Random random = new Random();
        int randomIndex = random.nextInt(quotes.length);  // Get a random index from the quotes array
        return "<html><div style='text-align: center;'>" + quotes[randomIndex] + "</div></html>";  // Return the quote formatted for multi-line display
    }

    // Main method to run the app
    public static void main(String[] args) {
        SwingUtilities.invokeLater(() -> new QuotesApp());
    }
}

Explanation of the Code

1. Import Statements

import javax.swing.*;
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.util.Random;
javax.swing.*: Imports all Swing components, such as JFrame, JLabel, JButton, etc.
java.awt.*: Imports layout managers and component positioning classes.
java.awt.event.*: Imports event listener classes for handling button clicks.
java.util.Random: Allows us to generate random numbers, which we use to select a random quote.

2. Class Declaration and Instance Variables

public class QuotesApp extends JFrame {
    private JLabel quoteLabel;
    private JButton nextQuoteButton;
    private String[] quotes;
}
JLabel quoteLabel: This label displays the current quote.
JButton nextQuoteButton: A button to display another random quote.
String[] quotes: An array of strings that contains the set of quotes.

3. Constructor

public QuotesApp() {
    setTitle("Quotes App");
    setSize(400, 200);
    setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    setLocationRelativeTo(null);

    // Initialize the quotes array
    quotes = new String[]{
        // Array of quotes
    };

    // Configure the quote label
    quoteLabel = new JLabel(getRandomQuote());
    quoteLabel.setFont(new Font("Serif", Font.ITALIC, 16));
    quoteLabel.setHorizontalAlignment(SwingConstants.CENTER);
    quoteLabel.setVerticalAlignment(SwingConstants.CENTER);

    // Create and add the "Show Another Quote" button
    nextQuoteButton = new JButton("Show Another Quote");
    nextQuoteButton.addActionListener(new ActionListener() {
        @Override
        public void actionPerformed(ActionEvent e) {
            quoteLabel.setText(getRandomQuote());  // Change the quote when the button is clicked
        }
    });

    // Set the layout and add components
    setLayout(new BorderLayout());
    add(quoteLabel, BorderLayout.CENTER);
    add(nextQuoteButton, BorderLayout.SOUTH);

    // Make the window visible
    setVisible(true);
}

Frame Setup:

setTitle("Quotes App"): Sets the title of the window.
setSize(400, 200): Sets the window size to 400x200 pixels.
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE): Ensures the application exits when the window is closed.
setLocationRelativeTo(null): Centers the window on the screen.

Quotes Array:

We initialize an array of quotes (quotes[]), each of which will be randomly displayed when the button is clicked.

Quote Label Setup:

quoteLabel = new JLabel(getRandomQuote()): The label is initialized with a random quote from the array.
setFont(new Font("Serif", Font.ITALIC, 16)): Sets the font of the label text.
setHorizontalAlignment(SwingConstants.CENTER) and setVerticalAlignment(SwingConstants.CENTER): Align the text in the center of the window.

Button Setup:

nextQuoteButton = new JButton("Show Another Quote"): A button that the user clicks to get another random quote.
addActionListener(): Adds an event listener to the button. When clicked, it triggers the getRandomQuote() method and updates the label with a new random quote.

Layout Setup:

setLayout(new BorderLayout()): Uses a BorderLayout manager to position the components.
add(quoteLabel, BorderLayout.CENTER): Adds the quote label to the center of the window.
add(nextQuoteButton, BorderLayout.SOUTH): Adds the button at the bottom of the window.

Visibility:

setVisible(true): Makes the frame visible.

4. getRandomQuote() Method

private String getRandomQuote() {
    Random random = new Random();
    int randomIndex = random.nextInt(quotes.length);  // Select a random index from the quotes array
    return "<html><div style='text-align: center;'>" + quotes[randomIndex] + "</div></html>";  // Return the selected quote
}

Random Selection:

Random random = new Random(): Creates a Random object to generate random numbers.
random.nextInt(quotes.length): Generates a random index between 0 and quotes.length - 1.

Return the Quote:

The selected quote is returned. The use of <html> and <div style='text-align: center;'> allows the label to render the quote with proper line breaks and center alignment in case of long quotes.

5. Main Method

public static void main(String[] args) {
    SwingUtilities.invokeLater(() -> new QuotesApp());
}
SwingUtilities.invokeLater(): Ensures the app is run on the Event Dispatch Thread (EDT), which is necessary for Swing applications to ensure thread safety.
new QuotesApp(): Creates and launches an instance of the app.

Game Flow

The app opens with a window displaying a random quote from the collection.
The user can click the “Show Another Quote” button to display another random quote.
The quote label updates each time the button is clicked, showing a new random quote.
The app continues to function until the user closes the window.

Customization Ideas

You can extend or customize this basic app in several ways:

1. Add More Quotes

You can easily add more quotes to the quotes[] array by adding new string entries.

quotes = new String[]{
    "New Quote 1",
    "New Quote 2",
    ...
};

2. Customize the Appearance

You can modify the font, color, and background to improve the appearance:

Change Font:

quoteLabel.setFont(new Font("Arial", Font.BOLD, 18));

Change Text Color:

quoteLabel.setForeground(Color.BLUE);

Change Background Color:

getContentPane().setBackground(Color.LIGHT_GRAY);

3. Load Quotes from a File

You can load the quotes from a text file instead of hardcoding them in the program:

// Example to load quotes from a file
try (BufferedReader reader = new BufferedReader(new FileReader("quotes.txt"))) {
    String line;
    while ((line = reader.readLine()) != null) {
        // Add each line as a new quote
    }
} catch (IOException e) {
    e.printStackTrace();
}

Conclusion

In this tutorial, you've learned how to create a simple Quotes App using Java Swing. The app showcases:

Creating a GUI with Swing components (JFrame, JLabel, JButton).
Displaying random content from an array of strings.
Handling button clicks with event listeners.
Dynamic updating of components (changing the quote on each button click).

This is a beginner-friendly project, and you can further enhance it with more features like dynamic quote loading, category selection, or more sophisticated animations.
You can add animations or fade-in effects when the quote changes to make the UI more dynamic.
You could add categories for quotes (e.g., “Inspiration”, “Motivation”, “Life”) and allow the user to select a category before showing a random quote from that category.

October 10, 2024 0 comment

Code GUI

Java Guess the Number Game Using Swing with code explanation

written by 75ypsaw71

In this tutorial, we'll create a “Guess the Number” game in Java using the Swing framework for the graphical user interface (GUI).

The player will attempt to guess a random number within a specified range, and the program will provide feedback after each guess (whether the guess is too high or too low).

The game will continue until the player guesses the correct number.

Table of Contents

Features of the Game:

The game generates a random number between 1 and 100.
The player inputs their guess using a text field.
Feedback is provided if the guess is too high, too low, or correct.
The player can reset the game after guessing correctly.

Complete Code of the Game

import javax.swing.*;
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.util.Random;

public class GuessTheNumberGame extends JFrame {
    private JTextField guessField;  // Field where the player enters their guess
    private JButton guessButton, resetButton;  // Buttons for submitting guess and resetting the game
    private JLabel feedbackLabel, attemptLabel;  // Labels for feedback and showing number of attempts
    private int randomNumber;  // Random number to guess
    private int attempts;  // Number of attempts made by the player

    // Constructor to set up the game
    public GuessTheNumberGame() {
        setTitle("Guess The Number Game");
        setSize(400, 200);
        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        setLocationRelativeTo(null);  // Center the window on the screen

        // Initialize components
        guessField = new JTextField(10);
        guessButton = new JButton("Guess");
        resetButton = new JButton("Reset");
        feedbackLabel = new JLabel("Enter a number between 1 and 100.");
        attemptLabel = new JLabel("Attempts: 0");

        // Set up the layout
        setLayout(new GridLayout(4, 1));
        JPanel inputPanel = new JPanel();  // To hold input field and button
        inputPanel.add(new JLabel("Your Guess: "));
        inputPanel.add(guessField);
        inputPanel.add(guessButton);

        // Add components to the frame
        add(feedbackLabel);
        add(inputPanel);
        add(attemptLabel);
        add(resetButton);

        // Generate the random number to guess
        resetGame();

        // Add action listeners
        guessButton.addActionListener(new GuessButtonListener());
        resetButton.addActionListener(new ResetButtonListener());

        // Make the frame visible
        setVisible(true);
    }

    // Method to reset the game
    private void resetGame() {
        Random rand = new Random();
        randomNumber = rand.nextInt(100) + 1;  // Generate a number between 1 and 100
        attempts = 0;  // Reset the attempt count
        feedbackLabel.setText("Enter a number between 1 and 100.");
        attemptLabel.setText("Attempts: 0");
        guessField.setText("");
    }

    // Inner class for handling the "Guess" button click
    private class GuessButtonListener implements ActionListener {
        public void actionPerformed(ActionEvent e) {
            String guessText = guessField.getText();
            try {
                int guess = Integer.parseInt(guessText);  // Convert the guess to an integer

                attempts++;  // Increment the attempt count
                attemptLabel.setText("Attempts: " + attempts);

                // Check if the guess is too high, too low, or correct
                if (guess < randomNumber) { feedbackLabel.setText("Too low! Try again."); } else if (guess > randomNumber) {
                    feedbackLabel.setText("Too high! Try again.");
                } else {
                    feedbackLabel.setText("Correct! You guessed the number.");
                    JOptionPane.showMessageDialog(null, "Well done! You guessed the number in " + attempts + " attempts.");
                }
            } catch (NumberFormatException ex) {
                feedbackLabel.setText("Invalid input! Please enter a valid number.");
            }
        }
    }

    // Inner class for handling the "Reset" button click
    private class ResetButtonListener implements ActionListener {
        public void actionPerformed(ActionEvent e) {
            resetGame();  // Reset the game when the reset button is clicked
        }
    }

    // Main method to run the game
    public static void main(String[] args) {
        SwingUtilities.invokeLater(() -> new GuessTheNumberGame());
    }
}

Explanation of the Code

1. Import Statements

import javax.swing.*;
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.util.Random;
javax.swing.*: Imports all the Swing components used to create the GUI (e.g., JFrame, JButton, JTextField, JLabel, etc.).
java.awt.*: Imports layout managers and basic graphical classes.
java.awt.event.*: Imports event listener classes for handling button clicks.
java.util.Random: Allows us to generate random numbers.

2. Class Declaration and Instance Variables

public class GuessTheNumberGame extends JFrame {
    private JTextField guessField;
    private JButton guessButton, resetButton;
    private JLabel feedbackLabel, attemptLabel;
    private int randomNumber;
    private int attempts;
}
JTextField guessField: A text field where the user will input their guess.
JButton guessButton and resetButton: Buttons for submitting guesses and resetting the game.
JLabel feedbackLabel: Provides feedback to the player (e.g., "Too high!", "Correct!").
JLabel attemptLabel: Displays the number of attempts made by the player.
int randomNumber: The randomly generated number that the player must guess.
int attempts: Tracks the number of attempts the player has made.

3. Constructor

public GuessTheNumberGame() {
    setTitle("Guess The Number Game");
    setSize(400, 200);
    setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    setLocationRelativeTo(null);

    guessField = new JTextField(10);
    guessButton = new JButton("Guess");
    resetButton = new JButton("Reset");
    feedbackLabel = new JLabel("Enter a number between 1 and 100.");
    attemptLabel = new JLabel("Attempts: 0");

    setLayout(new GridLayout(4, 1));
    JPanel inputPanel = new JPanel();
    inputPanel.add(new JLabel("Your Guess: "));
    inputPanel.add(guessField);
    inputPanel.add(guessButton);

    add(feedbackLabel);
    add(inputPanel);
    add(attemptLabel);
    add(resetButton);

    resetGame();

    guessButton.addActionListener(new GuessButtonListener());
    resetButton.addActionListener(new ResetButtonListener());

    setVisible(true);
}

Frame Setup:

setTitle(): Sets the title of the window.
setSize(): Sets the window size to 400x200 pixels.
setDefaultCloseOperation(): Ensures the application exits when the window is closed.
setLocationRelativeTo(null): Centers the window on the screen.

Component Setup:

guessField: A text field where the user will enter their guess.
guessButton: The button to submit the guess.
resetButton: The button to reset the game.
feedbackLabel: A label that provides feedback based on the guess.
attemptLabel: A label that tracks the number of attempts.

Layout Setup:

setLayout(new GridLayout(4, 1)): Uses a grid layout with 4 rows and 1 column.
Adds components (label, input panel, attempt label, and reset button) to the frame.

Action Listeners:

guessButton.addActionListener(): Attaches an event listener to handle the "Guess" button click.
resetButton.addActionListener(): Attaches an event listener to handle the "Reset" button click.

Initial Setup:

resetGame(): Initializes the game by generating a random number and resetting the attempt count.

4. resetGame() Method

private void resetGame() {
    Random rand = new Random();
    randomNumber = rand.nextInt(100) + 1;
    attempts = 0;
    feedbackLabel.setText("Enter a number between 1 and 100.");
    attemptLabel.setText("Attempts: 0");
    guessField.setText("");
}
Random rand = new Random(): Creates a Random object.
rand.nextInt(100) + 1: Generates a random number between 1 and 100.

Resets the game state:

attempts = 0: Resets the attempt count.
feedbackLabel.setText(): Resets the feedback message.
attemptLabel.setText(): Resets the attempt count display.
guessField.setText(""): Clears the input field.

5. GuessButtonListener Class

private class GuessButtonListener implements ActionListener {
    public void actionPerformed(ActionEvent e) {
        String guessText = guessField.getText();
        try {
            int guess = Integer.parseInt(guessText);

            attempts++;
            attemptLabel.setText("Attempts: " + attempts);

            if (guess < randomNumber) { feedbackLabel.setText("Too low! Try again."); } else if (guess > randomNumber) {
                feedbackLabel.setText("Too high! Try again.");
            } else {
                feedbackLabel.setText("Correct! You guessed the number.");
                JOptionPane.showMessageDialog(null, "Well done! You guessed the number in " + attempts + " attempts.");
            }
        } catch (NumberFormatException ex) {
            feedbackLabel.setText("Invalid input! Please enter a valid number.");
        }
    }
}

Handles Guess Input:

Integer.parseInt(guessText): Converts the input text to an integer.
Increments the attempt count and updates the attempt label.
Compares the guess with the random number:
Displays "Too low!" if the guess is less than the random number.
Displays "Too high!" if the guess is greater than the random number.
Displays "Correct!" and shows a message dialog if the guess is correct.

Exception Handling:

If the input is not a valid number, it catches a NumberFormatException and displays an error message.

6. ResetButtonListener Class

private class ResetButtonListener implements ActionListener {
    public void actionPerformed(ActionEvent e) {
        resetGame();
    }
}

Handles Game Reset:

Calls the resetGame() method to restart the game when the reset button is clicked.

7. main() Method

public static void main(String[] args) {
    SwingUtilities.invokeLater(() -> new GuessTheNumberGame());
}
SwingUtilities.invokeLater(): Ensures that the game runs on the Event Dispatch Thread (EDT), which is responsible for handling all Swing GUI updates.
new GuessTheNumberGame(): Creates and launches an instance of the game.

Game Flow

The game generates a random number between 1 and 100.
The player enters a guess in the text field and clicks the “Guess” button.
The program checks if the guess is too high, too low, or correct, and displays appropriate feedback.
If the guess is correct, a congratulatory message is displayed, and the player can click “Reset” to play again.
The player can reset the game at any time using the “Reset” button.

Example Run of the Program

The window opens with the message “Enter a number between 1 and 100.”
The player inputs their guess, e.g., 50, and clicks “Guess.”
If the guess is too high, the feedback will show “Too high! Try again.”
If the guess is too low, the feedback will show “Too low! Try again.”
If the guess is correct, the feedback will show “Correct! You guessed the number.”
The player can click “Reset” to start a new game with a new random number.

Conclusion

By following this tutorial, you've created a fully functional “Guess the Number” game using Java Swing.

This program demonstrates:

Creating a GUI with Swing components (JFrame, JLabel, JButton, JTextField).
Handling user input with text fields and buttons.
Providing real-time feedback in the GUI.
Using Random to generate a random number.
Implementing action listeners to handle button clicks.
You can further enhance this game by adding more features, such as:

Difficulty levels (e.g., allowing the player to choose a range of numbers).
Limiting the number of guesses.
Displaying a history of previous guesses.

October 10, 2024 0 comment

Newer Posts

Older Posts