Java - Creating a Simple GUI Application Using Swing

Creating a Simple GUI Application Using Swing in Java

Java Swing is one of the most widely used GUI toolkits for building desktop-based applications in Java. It provides a rich set of lightweight components such as JFrame, JButton, JLabel, JTextField, JPanel, and many more. Swing is part of the Java Foundation Classes (JFC) and is built on top of AWT but offers platform-independent, flexible, and extensible UI components. With the power of Swing, developers can create professional, interactive, and user-friendly graphical applications. This document gives detailed, step-by-step notes on how to create a simple GUI application using Java Swing while covering essential components, event handling, layout management, and best practices. Every topic is explained in 10–15 lines, along with formatted code blocks and outputs. This makes it helpful for beginners, students, and Java learners preparing for interviews, project work, or practical assignments. The explanations also incorporate important keywords like Java Swing, JFrame, ActionListener, GUI development, event-driven programming, layout managers, and desktop application development, which help increase reach and SEO impressions for user search queries.

Introduction to Java Swing

Java Swing is a part of the Java Standard Edition and is widely used for creating Graphical User Interface (GUI) applications. Swing is built on top of the Abstract Window Toolkit (AWT) but overcomes many of its limitations. It provides a wide range of components such as buttons, labels, text fields, tables, lists, panels, and menus, all written purely in Java. Because Swing components are lightweight, they do not rely heavily on the underlying native OS components, making them portable across all platforms that support Java. Swing uses a powerful event-driven programming model that makes handling user interactions easy and modular. Another major advantage of Swing is its pluggable look-and-feel, which means users can switch between different UI themes without changing the source code. Swing also supports advanced features such as double buffering, custom painting, rich text support, and drag-and-drop. In GUI development, Swing remains one of the most durable and flexible toolkits, especially for educational projects and enterprise desktop software. Overall, its simplicity, reliability, and rich component set make it ideal for beginners learning GUI programming in Java.

JFrame – The Main Window

A JFrame is the top-level container in Swing applications. It represents the main application window that holds all the components such as buttons, text fields, panels, and labels. The JFrame offers methods to set the window title, size, visibility, layout, close operation, and background color. To create a Swing application, one of the first steps is to declare and initialize a JFrame. Inside the JFrame, we can place other components using layout managers such as BorderLayout, FlowLayout, or GridLayout. A JFrame also supports menus, toolbars, and dialogs, making it the foundation of desktop UI development. It is also commonly extended through inheritance, allowing the developer to customize its behavior and structure. JFrame objects must be created and displayed inside the Event Dispatch Thread (EDT) for thread safety. Using the setDefaultCloseOperation method, developers can specify how the window should behave when the user clicks the close button. Thus, understanding JFrame is essential because it is the building block for almost every Swing GUI application.

Example: Creating a Basic JFrame

import javax.swing.*;

public class SimpleFrame {
    public static void main(String[] args) {
        JFrame frame = new JFrame("My First Swing Frame");
        frame.setSize(400, 300);
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        frame.setVisible(true);
    }
}

Output:

A window titled "My First Swing Frame" opens with dimensions 400×300 pixels. It is blank inside because no components are added yet. Closing the window exits the program.

Using JLabel and JButton in Swing

JLabel and JButton are two essential components in Java Swing used frequently in GUI applications. JLabel is used to display text, messages, or images that the user cannot modify. It is useful for headings, instructions, labels for forms, or help text. JButton represents a clickable button that can trigger an action when the user interacts with it. Both these components can be added directly to a JFrame or placed inside a JPanel for better layout control. Buttons support event listeners, especially ActionListener, which makes the program respond to user clicks. Labels do not support user input, but they can display dynamic text changes at runtime. These two components together help build interactive interfaces such as login screens, calculators, forms, or menu systems. Beginner-level GUI applications often start with a simple JLabel and JButton setup to learn event handling in Swing.

Example: Adding JLabel and JButton

import javax.swing.*;

public class LabelButtonDemo {
    public static void main(String[] args) {
        JFrame frame = new JFrame("Label and Button Example");
        JLabel label = new JLabel("Welcome to Swing GUI!");
        JButton button = new JButton("Click Me");

        frame.add(label);
        frame.add(button);

        frame.setLayout(new java.awt.FlowLayout());
        frame.setSize(300, 200);
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        frame.setVisible(true);
    }
}

Output:

A window opens with a JLabel displaying "Welcome to Swing GUI!" and a button labeled "Click Me" arranged horizontally in FlowLayout.

Working with JTextField and User Input

The JTextField component allows users to enter text values in a GUI application. It is commonly used in forms, login screens, search bars, and any application requiring input. JTextField supports methods such as getText and setText to retrieve and update its content. It also fires action events when the user presses Enter inside it. Developers can set its size, font, and initial text. When combined with JLabel and JButton, it creates interactive applications where the program can process user-entered data. JTextField works with ActionListener, DocumentListener, and KeyListener depending on the type of interaction you want to handle. This makes it highly flexible and useful for many real-world programs. Understanding JTextField is essential for creating dynamic applications in Swing.

Example: Taking Input Using JTextField

import javax.swing.*;

public class TextFieldDemo {
    public static void main(String[] args) {
        JFrame frame = new JFrame("Input Example");
        JLabel label = new JLabel("Enter your name:");
        JTextField textField = new JTextField(15);

        frame.setLayout(new java.awt.FlowLayout());
        frame.add(label);
        frame.add(textField);

        frame.setSize(350, 150);
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        frame.setVisible(true);
    }
}

Output:

A window appears with a label asking for a name and a text field where the user can type text.

Handling Events Using ActionListener

Java Swing uses an event-driven programming model, meaning actions such as button clicks or typing generate events. To respond to these events, Java provides interfaces such as ActionListener, MouseListener, KeyListener, and others. ActionListener is the most commonly used interface for handling button click events or Enter key actions. When a button is clicked, the actionPerformed method is automatically triggered, allowing the program to run custom logic. This helps build interactive programs where user actions affect the application’s behavior. Using ActionListener involves registering the listener with addActionListener on the component. It encourages clean coding because logic is separated from component declaration. Understanding event handling is crucial for building calculators, forms, games, and large-scale desktop applications. Event handling is what makes a GUI dynamic instead of static.

Example: Button Click Event

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

public class ButtonEventDemo {
    public static void main(String[] args) {
        JFrame frame = new JFrame("Event Handling");
        JButton button = new JButton("Click Me");
        JLabel label = new JLabel("Button not clicked yet");

        button.addActionListener(new ActionListener() {
            public void actionPerformed(ActionEvent e) {
                label.setText("Button was clicked!");
            }
        });

        frame.setLayout(new java.awt.FlowLayout());
        frame.add(button);
        frame.add(label);

        frame.setSize(300, 150);
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        frame.setVisible(true);
    }
}

Output:

Initially, the label shows "Button not clicked yet". After clicking the button, the label changes to "Button was clicked!".

Complete Simple GUI Application Using Swing

In this section, we combine all previously discussed components into a complete functional GUI program. The application will have a text field, a label, and a button. When the user enters text and clicks the button, the label will update with the user’s input. This example demonstrates JFrame, JLabel, JTextField, JButton, ActionListener, and FlowLayout in a single program. Such programs form the foundation for advanced GUIs such as login systems, registration forms, and search applications. It also helps learners understand the structure and flow of event-driven Java applications. This final example serves as a practical demonstration of everything learned so far.

Example: Simple User Input Application

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

public class SimpleGUIApp {
    public static void main(String[] args) {
        JFrame frame = new JFrame("Simple GUI Application");

        JLabel label = new JLabel("Enter something:");
        JTextField textField = new JTextField(15);
        JButton button = new JButton("Submit");
        JLabel outputLabel = new JLabel("Output will appear here");

        button.addActionListener(new ActionListener() {
            public void actionPerformed(ActionEvent e) {
                String input = textField.getText();
                outputLabel.setText("You entered: " + input);
            }
        });

        frame.setLayout(new java.awt.FlowLayout());
        frame.add(label);
        frame.add(textField);
        frame.add(button);
        frame.add(outputLabel);

        frame.setSize(400, 200);
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        frame.setVisible(true);
    }
}

Output:

A full GUI window appears with a label, input field, button, and output label. Typing text and clicking Submit updates the output label with "You entered: <your text>".

Java Swing provides a powerful, user-friendly, and flexible toolkit for building desktop GUI applications. By understanding components like JFrame, JButton, JLabel, JTextField, and the event-driven model using ActionListener, you can easily build interactive applications. The examples in this document offer a strong foundation for learners to create more advanced projects such as calculators, login systems, menu-driven applications, and data-entry forms. With proper practice, Swing becomes an essential skill in the Java developer’s toolkit and continues to be relevant in educational and professional settings.