Design a GUI Based Application using Java Swing Controls

Explanation

This Java code creates a simple Graphical User Interface (GUI) application using the Swing toolkit. The application is designed to display a window where a user can select known languages using checkboxes.

Here's a step-by-step breakdown:

1. Import Swing Library: import javax.swing.*; brings in all the necessary classes from the Swing library, which provides components for building GUIs (like windows, buttons, labels, etc.).
2. Define the GUI Class: The gui3 class serves as the container for our GUI logic.
3. Constructor gui3(): This special method runs automatically when an object of gui3 is created. All the GUI setup happens inside this constructor.
   • Create Main Window (JFrame): JFrame f = new JFrame("Language Selector"); creates the main window of our application. It's titled "Language Selector" and will be the top-level container for all other GUI elements.
   • Create Instruction Label (JLabel): JLabel l1 = new JLabel("Select known Languages:"); creates a static text label that displays the instruction "Select known Languages:".
   • Position Label: l1.setBounds(100, 50, 200, 30); manually sets the position and size of the label. (100, 50) are the x and y coordinates (from the top-left corner of the frame), and (200, 30) are the width and height in pixels.
   • Add Label to Frame: f.add(l1); places the label inside our main window (f).
   • Create Checkboxes (JCheckBox):
     • JCheckBox c1 = new JCheckBox("English"); creates a checkbox labeled "English".
     • JCheckBox c2 = new JCheckBox("Hindi"); creates a checkbox labeled "Hindi".
     • JCheckBox c3 = new JCheckBox("Konkani"); creates a checkbox labeled "Konkani".
   • Position Checkboxes: Similar to the label, setBounds() is used for each checkbox (c1, c2, c3) to place them manually below the label, stacking them vertically. For example, c1.setBounds(100, 100, 100, 30); places the "English" checkbox at (100, 100) with a size of 100x30 pixels.
   • Add Checkboxes to Frame: f.add(c1);, f.add(c2);, f.add(c3); add each checkbox to the main window.
   • Set Frame Size: f.setSize(400, 400); sets the initial dimensions of the main window to 400 pixels wide and 400 pixels high.
   • Disable Layout Manager: f.setLayout(null); is a crucial line. It tells the JFrame not to use any automatic layout manager. This means we are entirely responsible for positioning and sizing every component using setBounds().
   • Set Default Close Operation: f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); configures the frame so that when the user clicks the close button (usually 'X' in the window's title bar), the Java application will terminate completely.
   • Make Frame Visible: f.setVisible(true); makes the JFrame and all its contained components appear on the screen. Until this line is executed, the window is created but remains hidden.
4. main Method: This is the entry point of any Java application. public static void main(String args[]) calls new gui3();, which creates an instance of our gui3 class. This action, in turn, executes the gui3() constructor, setting up and displaying the GUI.

In essence, this program constructs a simple window with a title, an instructional message, and three checkboxes for language selection, all positioned manually.

Algorithm

The algorithm used to create and display the GUI can be summarized as follows:

1. Initialize the Main Window: Create a JFrame instance to serve as the application's primary window, setting its title.
2. Create and Configure Label: Instantiate a JLabel with the desired instructional text, then define its exact position and size using setBounds().
3. Create and Configure Checkboxes: Instantiate three JCheckBox instances, each with a different language label, and individually define their positions and sizes using setBounds() to stack them vertically.
4. Add Components to Window: Attach the created JLabel and all JCheckBox components to the JFrame.
5. Set Window Properties:
   • Define the initial width and height of the JFrame.
   • Disable the default layout manager for the JFrame by setting it to null, indicating manual component placement.
   • Specify the behavior when the window is closed (e.g., exit the application).
6. Display the Window: Make the JFrame and all its contained components visible on the screen.
7. Program Entry Point: From the main method, instantiate the class containing the GUI setup logic to initiate the process.