Tag:

Java

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.

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

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

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.

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

Code GUI

Java Digital Clock Using Swing with explanation of code

written by 75ypsaw71

In this tutorial, we'll create a simple digital clock in Java using the Swing framework. The clock will display the current time and update every second.

This is a great way to learn about GUI programming in Java, handling time, and updating the user interface dynamically.

Here is what we will create and you can see some of the code in the background.

We can also think about other features and how we add them to our clock or modify our clocks appearance. Lets carry on.

Features of the Digital Clock:

Displays the current time in HH:mm format.
Updates every second to show the accurate current time.
Uses Swing components like JFrame, JLabel, and Timer.
Provides a clean and simple user interface.

Complete Code of the Digital Clock

import javax.swing.*;
import java.awt.*;
import java.text.SimpleDateFormat;
import java.util.Date;

public class DigitalClock extends JFrame {

    private JLabel timeLabel;
    private SimpleDateFormat timeFormat;

    public DigitalClock() {
        // Set up the frame
        this.setTitle("Digital Clock");
        this.setSize(300, 150);
        this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        this.setLocationRelativeTo(null); // Center the frame

        // Set up the time format
        timeFormat = new SimpleDateFormat("HH:mm:ss");

        // Create a label to display the time
        timeLabel = new JLabel();
        timeLabel.setFont(new Font("Verdana", Font.PLAIN, 50));
        timeLabel.setHorizontalAlignment(SwingConstants.CENTER);

        // Add the label to the frame
        this.add(timeLabel);

        // Create a timer to update the time every second
        Timer timer = new Timer(1000, e -> updateTime());
        timer.setInitialDelay(0);
        timer.start();

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

    private void updateTime() {
        // Get the current time and set it to the label
        String currentTime = timeFormat.format(new Date());
        timeLabel.setText(currentTime);
    }

    public static void main(String[] args) {
        // Run the clock in the Event Dispatch Thread
        SwingUtilities.invokeLater(() -> new DigitalClock());
    }
}

Explanation of the Code

1. Import Statements

import javax.swing.*;
import java.awt.*;
import java.text.SimpleDateFormat;
import java.util.Date;
javax.swing.*: Imports all Swing components needed for the GUI (JFrame, JLabel, Timer, etc.).
java.awt.*: Imports AWT classes for graphics (Font, Color, etc.).
java.text.SimpleDateFormat: Allows formatting of date and time.
java.util.Date: Provides date and time information.

2. Class Declaration

public class DigitalClock extends JFrame {
    // Class content
}

DigitalClock extends JFrame, making it a window that can contain GUI components.

3. Instance Variables

private JLabel timeLabel;
private SimpleDateFormat timeFormat;
timeLabel: Displays the current time.
timeFormat: Defines the format in which the time will be displayed.

4. Constructor

public DigitalClock() {
    // Frame setup
    this.setTitle("Digital Clock");
    this.setSize(300, 150);
    this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    this.setLocationRelativeTo(null);

    // Time format setup
    timeFormat = new SimpleDateFormat("HH:mm:ss");

    // Time label setup
    timeLabel = new JLabel();
    timeLabel.setFont(new Font("Verdana", Font.PLAIN, 50));
    timeLabel.setHorizontalAlignment(SwingConstants.CENTER);

    // Adding label to frame
    this.add(timeLabel);

    // Timer setup
    Timer timer = new Timer(1000, e -> updateTime());
    timer.setInitialDelay(0);
    timer.start();

    // Making the frame visible
    this.setVisible(true);
}

Frame Setup:

setTitle(“Digital Clock”): Sets the window title.
setSize(300, 150): Sets the window size.
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE): Closes the application when the window is closed.
setLocationRelativeTo(null): Centers the window on the screen.

Time Format Setup:

timeFormat = new SimpleDateFormat(“HH:mm:ss”): Defines the time format (24-hour format).

Time Label Setup:

timeLabel = new JLabel(): Initializes the label.
setFont(new Font(“Verdana”, Font.PLAIN, 50)): Sets the font type and size.
setHorizontalAlignment(SwingConstants.CENTER): Centers the text in the label.

Adding Label to Frame:

this.add(timeLabel): Adds the label to the frame.
Timer Setup:

Timer timer = new Timer(1000, e -> updateTime()): Creates a timer that triggers every 1000 milliseconds (1 second) and calls updateTime().
setInitialDelay(0): Starts the timer immediately without delay.
timer.start(): Starts the timer.

Making Frame Visible:

this.setVisible(true): Displays the window.

5. updateTime() Method

private void updateTime() {
    String currentTime = timeFormat.format(new Date());
    timeLabel.setText(currentTime);
}

Gets the current time using new Date().
Formats the time according to timeFormat.
Updates the label to display the current time.

6. main() Method

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

Ensures thread safety by running GUI updates on the Event Dispatch Thread.
Creates an instance of DigitalClock, which sets up and displays the clock.

Step-by-Step Breakdown

Initialize the Frame:

We set up the main window (JFrame) for our digital clock.
Define Time Format:

We specify how the time will be displayed using SimpleDateFormat.
Create and Configure the Time Label:

We create a JLabel to show the time.
We set its font and alignment for better visibility.
Add the Label to the Frame:

The label is added to the frame so it will be displayed.
Set Up the Timer:

A Timer is created to update the time every second.
The updateTime() method is called every time the timer ticks.
Display the Frame:

We make the frame visible so the user can see the clock.
Update Time Method:

This method gets the current time and updates the label.
It is called by the timer every second.
Run the Application:

The main() method launches the application safely on the Event Dispatch Thread.

Enhancements and Customizations

1. Displaying the Date

You can modify the code to also display the current date.

Changes:

Add another JLabel for the date.
Update the updateTime() method to set the date.
Modified Code Snippet:

private JLabel dateLabel;
private SimpleDateFormat dateFormat;

public DigitalClock() {
    // ... existing code ...

    // Set up the date format
    dateFormat = new SimpleDateFormat("EEEE, MMMM dd, yyyy");

    // Create a label to display the date
    dateLabel = new JLabel();
    dateLabel.setFont(new Font("Verdana", Font.PLAIN, 25));
    dateLabel.setHorizontalAlignment(SwingConstants.CENTER);

    // Add labels to the frame using a layout manager
    this.setLayout(new GridLayout(2, 1));
    this.add(timeLabel);
    this.add(dateLabel);

    // ... existing code ...
}

private void updateTime() {
    String currentTime = timeFormat.format(new Date());
    String currentDate = dateFormat.format(new Date());
    timeLabel.setText(currentTime);
    dateLabel.setText(currentDate);
}

2. Changing to 12-Hour Format

To display time in a 12-hour format with AM/PM:

Change the time format pattern.

Modified Code Snippet:

timeFormat = new SimpleDateFormat("hh:mm:ss a");

3. Customizing Appearance

Change Fonts: Use different fonts or styles.
Change Colors: Set background and foreground colors.

Example:

timeLabel.setForeground(Color.BLUE);
timeLabel.setBackground(Color.BLACK);
timeLabel.setOpaque(true);

Running the Application

To compile and run the application:

Save the code in a file named DigitalClock.java.

Compile the code using the command:

javac DigitalClock.java

Run the application using the command:

java DigitalClock

Note: Ensure that your Java Development Kit (JDK) is properly installed and configured.

Conclusion

By following this tutorial, you've created a functional digital clock using Java Swing.

This example demonstrates:

Creating a GUI application with Swing components.
Using Timer to perform actions at regular intervals.
Formatting dates and times with SimpleDateFormat.
Ensuring thread safety in Swing applications by using the Event Dispatch Thread.

You can further enhance this digital clock by adding new features like:

Alarm functionality.
Custom skins or themes.
Resizable fonts based on window size.
Additional time zones.

This project serves as a solid foundation for learning GUI programming in Java and can be expanded upon for more complex applications.

October 10, 2024 0 comment

Code

Java Calculator Tutorial with code explained

written by 75ypsaw71

In this tutorial, we will build a simple calculator in Java that can perform basic arithmetic operations such as addition, subtraction, multiplication, division, and modulus.

We will use the command-line interface to interact with the user, allowing them to input numbers and choose an operation.

Features of the Calculator:

The user will input two numbers.
The user will choose the operation (add, subtract, multiply, divide, modulus).
The calculator will perform the operation and display the result.
The user will be able to perform multiple operations in a loop until they decide to exit.

Code for the Calculator

import java.util.Scanner;

public class Calculator {

    // Method to display the menu
    public static void displayMenu() {
        System.out.println("---- Calculator Menu ----");
        System.out.println("1. Add");
        System.out.println("2. Subtract");
        System.out.println("3. Multiply");
        System.out.println("4. Divide");
        System.out.println("5. Modulus");
        System.out.println("6. Exit");
        System.out.print("Choose an operation: ");
    }

    // Method to perform the calculation
    public static void calculate(double num1, double num2, int operation) {
        switch (operation) {
            case 1:
                System.out.println("Result: " + (num1 + num2));
                break;
            case 2:
                System.out.println("Result: " + (num1 - num2));
                break;
            case 3:
                System.out.println("Result: " + (num1 * num2));
                break;
            case 4:
                if (num2 != 0) {
                    System.out.println("Result: " + (num1 / num2));
                } else {
                    System.out.println("Error: Division by zero is undefined.");
                }
                break;
            case 5:
                if (num2 != 0) {
                    System.out.println("Result: " + (num1 % num2));
                } else {
                    System.out.println("Error: Modulus by zero is undefined.");
                }
                break;
            default:
                System.out.println("Invalid operation.");
                break;
        }
    }

    // Main method
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);

        // Main program loop
        while (true) {
            displayMenu(); // Display menu
            int operation = scanner.nextInt(); // Read operation from user

            // If user chooses to exit, break the loop
            if (operation == 6) {
                System.out.println("Exiting calculator. Goodbye!");
                break;
            }

            // Get numbers from user
            System.out.print("Enter the first number: ");
            double num1 = scanner.nextDouble();

            System.out.print("Enter the second number: ");
            double num2 = scanner.nextDouble();

            // Perform the calculation based on the user's choice
            calculate(num1, num2, operation);
            System.out.println(); // Print a blank line for readability
        }

        scanner.close(); // Close the scanner
    }
}

Explanation of the Code:

1. Main Method

public static void main(String[] args) {
    Scanner scanner = new Scanner(System.in);

    // Main program loop
    while (true) {
        displayMenu(); // Display menu
        int operation = scanner.nextInt(); // Read operation from user

        // If user chooses to exit, break the loop
        if (operation == 6) {
            System.out.println("Exiting calculator. Goodbye!");
            break;
        }

        // Get numbers from user
        System.out.print("Enter the first number: ");
        double num1 = scanner.nextDouble();

        System.out.print("Enter the second number: ");
        double num2 = scanner.nextDouble();

        // Perform the calculation based on the user's choice
        calculate(num1, num2, operation);
        System.out.println(); // Print a blank line for readability
    }

    scanner.close(); // Close the scanner
}

Scanner Object: We create a Scanner object to take input from the user.
Main Program Loop: The program runs in an infinite loop (while(true)) to continuously prompt the user for inputs and operations. The loop continues until the user selects the “Exit” option (6).
Menu Display: The displayMenu() method is called to show the user the available options for arithmetic operations.
Operation Input: The user selects an operation by entering a number (1 to 6).
Number Input: The user inputs two numbers (num1 and num2) which will be used for the chosen operation.
Exiting the Program: If the user selects 6 (Exit), the program exits the loop and closes the scanner.

2. Menu Display

public static void displayMenu() {
    System.out.println("---- Calculator Menu ----");
    System.out.println("1. Add");
    System.out.println("2. Subtract");
    System.out.println("3. Multiply");
    System.out.println("4. Divide");
    System.out.println("5. Modulus");
    System.out.println("6. Exit");
    System.out.print("Choose an operation: ");
}

Menu Options: This method displays the available operations (Addition, Subtraction, Multiplication, Division, Modulus) and an option to exit.
Operation Input Prompt: The user is prompted to choose an operation by entering a number (1 to 6).

3. Calculate Method

public static void calculate(double num1, double num2, int operation) {
    switch (operation) {
        case 1:
            System.out.println("Result: " + (num1 + num2));
            break;
        case 2:
            System.out.println("Result: " + (num1 - num2));
            break;
        case 3:
            System.out.println("Result: " + (num1 * num2));
            break;
        case 4:
            if (num2 != 0) {
                System.out.println("Result: " + (num1 / num2));
            } else {
                System.out.println("Error: Division by zero is undefined.");
            }
            break;
        case 5:
            if (num2 != 0) {
                System.out.println("Result: " + (num1 % num2));
            } else {
                System.out.println("Error: Modulus by zero is undefined.");
            }
            break;
        default:
            System.out.println("Invalid operation.");
            break;
    }
}

Switch Statement: This method uses a switch statement to handle the various operations based on the user's input (operation):
Addition: Adds num1 and num2 and prints the result.
Subtraction: Subtracts num2 from num1 and prints the result.
Multiplication: Multiplies num1 by num2 and prints the result.
Division: Divides num1 by num2 if num2 is not zero. If num2 is zero, an error message is displayed since division by zero is undefined.
Modulus: Computes the modulus (remainder) of num1 divided by num2 if num2 is not zero. If num2 is zero, an error message is displayed.
Error Handling: For division and modulus, we check whether the second number (num2) is zero to prevent runtime errors.

Example Run of the Program

---- Calculator Menu ----
1. Add
2. Subtract
3. Multiply
4. Divide
5. Modulus
6. Exit
Choose an operation:
1

Enter the first number:
10

Enter the second number:
5

Result: 15.0

---- Calculator Menu ----
1. Add
2. Subtract
3. Multiply
4. Divide
5. Modulus
6. Exit
Choose an operation:
2

Enter the first number:
12

Enter the second number:
4

Result: 8.0

---- Calculator Menu ----
1. Add
2. Subtract
3. Multiply
4. Divide
5. Modulus
6. Exit
Choose an operation:
6

Exiting calculator. Goodbye!

Customizing the Calculator

You can extend or modify this basic calculator by adding more features, such as:

Exponentiation (power).
Square root calculation.
Scientific functions like sine, cosine, and tangent.
Support for multiple inputs and more complex expressions.

Conclusion

This basic Java calculator program demonstrates how to use fundamental Java concepts like loops, conditionals, methods, and input handling.

The program structure allows the user to continuously perform calculations until they choose to exit, making it interactive and easy to extend with additional features.

By following this tutorial, you have built a simple calculator that can perform basic arithmetic operations and handle division by zero errors.

You can further expand it to include more advanced operations or a graphical user interface (GUI) using Java Swing for a more advanced calculator experience.

October 10, 2024 0 comment

Code

Java Riddle Game with explanation

written by 75ypsaw71

In this tutorial, we will build a simple riddle game in Java. The game will ask the user a series of riddles, and the user will have a limited number of attempts to guess the answer correctly.

If the user answers correctly, they score a point. If they run out of attempts, they will lose the round and the correct answer will be displayed.

Features of the Game:

The game will have a set of riddles stored in an array or list.
The user will be prompted to answer each riddle.
The user has a limited number of attempts (e.g., 3 attempts) to answer each riddle.
If the user guesses correctly, they earn points.
After all riddles have been answered, the game will display the final score.

Complete code

import java.util.Scanner;

public class RiddleGame {

    // Array of riddles
    private static String[] riddles = {
        "I speak without a mouth and hear without ears. I have no body, but I come alive with wind. What am I?",
        "You measure my life in hours, and I serve you by expiring. I'm quick when I'm thin and slow when I'm fat. What am I?",
        "The more of this there is, the less you see. What is it?"
    };

    // Corresponding array of answers
    private static String[] answers = {
        "echo",
        "candle",
        "darkness"
    };

    // Number of attempts allowed for each riddle
    private static final int MAX_ATTEMPTS = 3;

    // Method to start the game
    public static void startGame() {
        Scanner scanner = new Scanner(System.in);
        int score = 0; // Initialize the player's score

        // Loop through all riddles
        for (int i = 0; i < riddles.length; i++) {
            System.out.println("Riddle " + (i + 1) + ": " + riddles[i]);
            boolean answeredCorrectly = false;

            // Give the user multiple attempts to answer
            for (int attempt = 1; attempt <= MAX_ATTEMPTS; attempt++) {
                System.out.print("Attempt " + attempt + " of " + MAX_ATTEMPTS + ": ");
                String userAnswer = scanner.nextLine().trim().toLowerCase();

                // Check if the user's answer is correct
                if (userAnswer.equals(answers[i])) {
                    System.out.println("Correct! You've earned 1 point.\n");
                    score++; // Increment score for a correct answer
                    answeredCorrectly = true;
                    break; // Exit the loop if the answer is correct
                } else {
                    System.out.println("Wrong answer.");
                }
            }

            // If the user fails to answer correctly after all attempts
            if (!answeredCorrectly) {
                System.out.println("You've used all attempts. The correct answer was: " + answers[i] + "\n");
            }
        }

        // Display the user's final score after all riddles
        System.out.println("Game Over! Your final score is: " + score + "/" + riddles.length);
        scanner.close();
    }

    // Main method
    public static void main(String[] args) {
        System.out.println("Welcome to the Riddle Game!");
        startGame();
    }
}

Explanation of the Code:

1. Array of Riddles and Answers

private static String[] riddles = {
    "I speak without a mouth and hear without ears. I have no body, but I come alive with wind. What am I?",
    "You measure my life in hours, and I serve you by expiring. I'm quick when I'm thin and slow when I'm fat. What am I?",
    "The more of this there is, the less you see. What is it?"
};

private static String[] answers = {
    "echo",
    "candle",
    "darkness"
};

We define two arrays: one for the riddles and one for their corresponding answers. The indexes of the riddle and its answer match, so riddles[0] has the answer answers[0].

2. MAX_ATTEMPTS Constant

private static final int MAX_ATTEMPTS = 3;
This constant defines the maximum number of attempts the user will have for each riddle. In this case, the user gets 3 attempts to guess the correct answer.

3. The startGame Method

public static void startGame() {
    Scanner scanner = new Scanner(System.in);
    int score = 0; // Initialize the player's score

    // Loop through all riddles
    for (int i = 0; i < riddles.length; i++) {
        System.out.println("Riddle " + (i + 1) + ": " + riddles[i]);
        boolean answeredCorrectly = false;

        // Give the user multiple attempts to answer
        for (int attempt = 1; attempt <= MAX_ATTEMPTS; attempt++) {
            System.out.print("Attempt " + attempt + " of " + MAX_ATTEMPTS + ": ");
            String userAnswer = scanner.nextLine().trim().toLowerCase();

            // Check if the user's answer is correct
            if (userAnswer.equals(answers[i])) {
                System.out.println("Correct! You've earned 1 point.\n");
                score++; // Increment score for a correct answer
                answeredCorrectly = true;
                break; // Exit the loop if the answer is correct
            } else {
                System.out.println("Wrong answer.");
            }
        }

        // If the user fails to answer correctly after all attempts
        if (!answeredCorrectly) {
            System.out.println("You've used all attempts. The correct answer was: " + answers[i] + "\n");
        }
    }

    // Display the user's final score after all riddles
    System.out.println("Game Over! Your final score is: " + score + "/" + riddles.length);
    scanner.close();
}

Score Initialization: A variable score is initialized to keep track of the user’s correct answers.
Looping through Riddles: The game loops through the riddles array, displaying one riddle at a time.
Multiple Attempts: For each riddle, a nested loop allows the user to attempt answering the riddle up to MAX_ATTEMPTS times.
If the user’s answer is correct (matches the corresponding answers[i]), the score is incremented, and the loop breaks.
If the user fails to answer within the given attempts, the correct answer is revealed.
Final Score: After all the riddles have been asked, the game displays the user's final score.

4. Main Method

public static void main(String[] args) {
    System.out.println("Welcome to the Riddle Game!");
    startGame();
}

The main() method is where the game begins. It prints a welcome message and calls the startGame() method to run the game logic.

Game Flow

The game starts with a welcome message.
The game presents the first riddle and gives the user three attempts to answer.
If the user answers correctly within three attempts, they earn a point.
If they fail to answer correctly, the correct answer is shown.
This process repeats for all riddles.
After all the riddles are answered, the game ends and displays the user's score.

Example Run:

Welcome to the Riddle Game!
Riddle 1: I speak without a mouth and hear without ears. I have no body, but I come alive with wind. What am I?
Attempt 1 of 3: wind
Wrong answer.
Attempt 2 of 3: sound
Wrong answer.
Attempt 3 of 3: echo
Correct! You've earned 1 point.

Riddle 2: You measure my life in hours, and I serve you by expiring. I'm quick when I'm thin and slow when I'm fat. What am I?
Attempt 1 of 3: candle
Correct! You've earned 1 point.

Riddle 3: The more of this there is, the less you see. What is it?
Attempt 1 of 3: light
Wrong answer.
Attempt 2 of 3: darkness
Correct! You've earned 1 point.

Game Over! Your final score is: 3/3

Modifying the Game

Adding more riddles: You can easily add more riddles by adding more entries to the riddles and answers arrays.
Changing the number of attempts: The number of attempts can be adjusted by changing the value of MAX_ATTEMPTS.
Enhancing the game: You could extend the game by adding features like difficulty levels, a timer, or randomizing the order of riddles.

Conclusion

This simple riddle game demonstrates how to use Java loops, conditionals, and input handling to create an interactive console-based game.

The game structure can be extended and modified to suit more advanced needs, but this version covers the basics of interactivity and scoring in a fun and engaging way.

October 10, 2024 0 comment

Misc

Java List Interface Tutorial

written by 75ypsaw71

In Java, the List interface is part of the java.util package and is a sub-interface of the Collection interface. It represents an ordered collection of elements where duplicates are allowed.

Lists can dynamically grow or shrink in size, and you can access elements based on their index (position in the list).

The List interface is commonly used when you need to maintain the order of elements and allow duplicates. There are various classes that implement the List interface, such as ArrayList, LinkedList, Vector, and Stack.

This tutorial will cover how to use the List interface with different implementations, providing multiple examples to demonstrate key features.

1. Common Implementations of the List Interface

Here are the most commonly used classes that implement the List interface:

ArrayList: A resizable array that allows fast random access.
LinkedList: A doubly linked list that allows fast insertion and deletion.
Vector: Similar to ArrayList but is synchronized (thread-safe).
Stack: A subclass of Vector that follows the LIFO (Last-In-First-Out) principle.

2. Creating a List

You can create a List using different implementations. Below are examples of creating List objects using ArrayList and LinkedList:

Example: Creating a List

import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;

public class ListCreationExample {
    public static void main(String[] args) {
        // Creating a List using ArrayList
        List arrayList = new ArrayList<>();

        // Creating a List using LinkedList
        List linkedList = new LinkedList<>();

        // Adding elements
        arrayList.add("Apple");
        arrayList.add("Banana");
        linkedList.add("Carrot");
        linkedList.add("Date");

        // Display the lists
        System.out.println("ArrayList: " + arrayList);
        System.out.println("LinkedList: " + linkedList);
    }
}

Explanation:

We created two List objects: one using ArrayList and the other using LinkedList.
We added elements to both lists and displayed them.

Output:

ArrayList: [Apple, Banana]
LinkedList: [Carrot, Date]

3. Adding Elements to a List

The List interface provides several methods to add elements:

add(E element): Adds an element to the list.
add(int index, E element): Adds an element at the specified position in the list.

Example: Adding Elements to a List

import java.util.ArrayList;
import java.util.List;

public class AddElementsExample {
    public static void main(String[] args) {
        // Creating an ArrayList
        List list = new ArrayList<>();

        // Adding elements at the end of the list
        list.add("Java");
        list.add("Python");
        list.add("C++");

        // Adding an element at a specific index
        list.add(1, "JavaScript");

        // Displaying the list
        System.out.println("List after adding elements: " + list);
    }
}

Explanation:

We added elements to the list using add() and inserted an element at a specific position using add(int index, E element).

Output:

List after adding elements: [Java, JavaScript, Python, C++]

4. Accessing Elements in a List

You can access elements in a List using the get(int index) method, which retrieves the element at the specified index.

Example: Accessing Elements

import java.util.ArrayList;
import java.util.List;

public class AccessElementsExample {
    public static void main(String[] args) {
        // Creating an ArrayList
        List list = new ArrayList<>();

        // Adding elements
        list.add("Apple");
        list.add("Banana");
        list.add("Cherry");

        // Accessing elements using get()
        String firstElement = list.get(0);
        String secondElement = list.get(1);

        // Displaying the elements
        System.out.println("First element: " + firstElement);
        System.out.println("Second element: " + secondElement);
    }
}

Explanation:

We accessed elements at specific indexes using the get() method.

Output:

First element: Apple
Second element: Banana

5. Modifying Elements in a List

You can modify elements in a List using the set(int index, E element) method, which replaces the element at the specified index.

Example: Modifying Elements

import java.util.ArrayList;
import java.util.List;

public class ModifyElementsExample {
    public static void main(String[] args) {
        // Creating an ArrayList
        List list = new ArrayList<>();

        // Adding elements
        list.add("Red");
        list.add("Green");
        list.add("Blue");

        // Modifying an element
        list.set(1, "Yellow");

        // Displaying the modified list
        System.out.println("List after modification: " + list);
    }
}

Explanation:

We replaced the element at index 1 with the new value “Yellow” using the set() method.

Output:

List after modification: [Red, Yellow, Blue]

6. Removing Elements from a List

You can remove elements from a List using:

remove(int index): Removes the element at the specified index.
remove(Object o): Removes the first occurrence of the specified element.

Example: Removing Elements

import java.util.ArrayList;
import java.util.List;

public class RemoveElementsExample {
    public static void main(String[] args) {
        // Creating an ArrayList
        List list = new ArrayList<>();

        // Adding elements
        list.add("One");
        list.add("Two");
        list.add("Three");
        list.add("Four");

        // Removing an element by index
        list.remove(1);  // Removes "Two"

        // Removing an element by object
        list.remove("Four");

        // Displaying the modified list
        System.out.println("List after removals: " + list);
    }
}

Explanation:

We removed elements by index using remove(int index) and by object using remove(Object o).

Output:

List after removals: [One, Three]

7. Iterating Over a List

There are several ways to iterate over the elements of a List:

Using a for-each loop.
Using a for loop with an index.
Using a ListIterator.
Using a Stream (Java 8+).

Example: Iterating Over a List

import java.util.ArrayList;
import java.util.List;

public class IterateListExample {
    public static void main(String[] args) {
        // Creating an ArrayList
        List list = new ArrayList<>();
        list.add("Apple");
        list.add("Banana");
        list.add("Cherry");

        // 1. Using for-each loop
        System.out.println("Using for-each loop:");
        for (String fruit : list) {
            System.out.println(fruit);
        }

        // 2. Using for loop with index
        System.out.println("\nUsing for loop with index:");
        for (int i = 0; i < list.size(); i++) {
            System.out.println(list.get(i));
        }

        // 3. Using Java 8 Stream API
        System.out.println("\nUsing Stream API:");
        list.stream().forEach(System.out::println);
    }
}

Explanation:

We demonstrated three ways to iterate over the elements of the list: for-each loop, for loop with index, and the Java 8 Stream API.

Output:

Using for-each loop:
Apple
Banana
Cherry

Using for loop with index:
Apple
Banana
Cherry

Using Stream API:
Apple
Banana
Cherry

8. Sorting a List

You can sort a List using the Collections.sort() method for natural ordering or by providing a comparator for custom sorting.

Example: Sorting a List

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

public class SortListExample {
    public static void main(String[] args) {
        // Creating an ArrayList
        List list = new ArrayList<>();
        list.add("Banana");
        list.add("Apple");
        list.add("Cherry");

        // Sorting the list in natural order
        Collections.sort(list);

        // Displaying the sorted list
        System.out.println("Sorted list: " + list);
    }
}

Explanation:

We used Collections.sort() to sort the list in natural alphabetical order.

Output:

Sorted list: [Apple, Banana, Cherry]

9. Checking if a List Contains an Element

You can check if a List contains a specific element using the contains(Object o) method.

Example: Checking for an Element

import java.util.ArrayList;
import java.util.List;

public class ContainsElementExample {
    public static void main(String[] args) {
        // Creating an ArrayList
        List list = new ArrayList<>();
        list.add("Apple");
        list.add("Banana");
        list.add("Cherry");

        // Check if the list contains "Banana"
        boolean containsBanana = list.contains("Banana");
        System.out.println("Contains Banana? " + containsBanana);

        // Check if the list contains "Date"
        boolean containsDate = list.contains("Date");
        System.out.println("Contains Date? " + containsDate);
    }
}

Explanation:

We used contains() to check if the list contains specific elements.

Output:

Contains Banana? true
Contains Date? false

10. Converting a List to an Array

You can convert a List to an array using the toArray() method.

Example: Converting List to Array

import java.util.ArrayList;
import java.util.List;

public class ListToArrayExample {
    public static void main(String[] args) {
        // Creating an ArrayList
        List list = new ArrayList<>();
        list.add("Apple");
        list.add("Banana");
        list.add("Cherry");

        // Convert list to array
        String[] array = list.toArray(new String[0]);

        // Display array elements
        System.out.println("Array elements:");
        for (String fruit : array) {
            System.out.println(fruit);
        }
    }
}

Explanation:

We converted the List to an array using toArray() and printed the elements of the array.

Output:

Array elements:
Apple
Banana
Cherry

Conclusion

The List interface in Java is a powerful collection that allows you to store and manipulate ordered elements. It is versatile and commonly used in many applications. Key points covered:

Common implementations: ArrayList, LinkedList, Vector, and Stack.
Adding, accessing, modifying, and removing elements: Simple methods like add(), get(), set(), and remove().
Iterating over a list: Various ways like for-each, for loop with index, and streams.
Sorting and checking for elements: Collections.sort() and contains().
Converting lists to arrays: Using toArray().

By mastering these methods, you can effectively work with the List interface to store and manipulate data in Java.

October 10, 2024 0 comment

Newer Posts

Older Posts