📚Swing and Top-level Windows 🖥

In the world of Java, Swing is a powerful GUI (Graphical User Interface) framework that allows developers to create feature-rich, cross-platform applications. At the heart of Swing are the concept of top-level windows, which are the foundation for building your user interface.

What are Top-level Windows? 🤔

Top-level windows are the main windows or frames that serve as the primary containers for your application's user interface. These windows are directly managed by the underlying operating system and can be resized, moved, minimized, or maximized by the user.

In Swing, the most common types of top-level windows are:

1. JFrame: This is the most widely used top-level window, and it represents the main window of your application.
2. JDialog: These are secondary windows that are used for displaying additional information, prompts, or dialogs.
3. JApplet: These are top-level windows that can be embedded in web pages, allowing for the creation of Java-based web applications.

## Creating a Simple JFrame Example 🎨

Here's a basic example of creating a JFrame in Swing:

import javax.swing.*;

public class MyWindow extends JFrame {
    public MyWindow() {
        // Set the noscript of the window
        setTitle("My Swing Application");

        // Set the size of the window
        setSize(400, 300);

        // Set the default close operation
        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

        // Create a label and add it to the content pane
        JLabel label = new JLabel("Hello, Swing!");
        getContentPane().add(label);

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

    public static void main(String[] args) {
        // Create the window on the Event Dispatch Thread
        SwingUtilities.invokeLater(() -> new MyWindow());
    }
}

In this example, we create a JFrame subclass called MyWindow. We set the noscript, size, and default close operation of the window, and then add a JLabel to the content pane. Finally, we make the window visible.

The main method demonstrates the recommended way to create and display a Swing window, which is to do it on the Event Dispatch Thread using the SwingUtilities.invokeLater() method.

When you run this code, you'll see a window with the noscript "My Swing Application" and the text "Hello, Swing!" displayed in the center. 💻

Remember, Swing is a powerful framework that allows you to create a wide range of GUI applications, from simple windows to complex, feature-rich applications. As you continue to explore Swing, you'll discover more advanced concepts and techniques to build amazing Java applications.

Greetings, everyone! 👋

In our previous lesson, we explored the concept of Swing and top-level windows. Today, we will continue our journey and delve into the GUI classes in Java. Let's dive in and explore this topic further.

🌟 GUI Classes in Java

Understanding the different categories of GUI (Graphical User Interface) classes is crucial for building interactive and visually appealing applications. Let's dive in and explore these classes, with some helpful examples to make the concepts more accessible!

1. Swing Components: 🖥
- These are the building blocks of your GUI, including buttons, labels, text fields, and more.
- Example: JButton - Create a clickable button with custom text or an icon.
- JLabel: Display text or an image on your GUI.
- JTextField: Allow users to input text.

   // Example: Creating a JButton and a JLabel
   JButton button = new JButton("Click me!");
   JLabel label = new JLabel("Hello, World!");
   

2. Layout Managers: 🧭
- These classes help you organize and position the components on your GUI.
- Examples: BorderLayout, GridLayout, FlowLayout, BoxLayout.
- BorderLayout: Arrange components in the center, north, south, east, and west positions.
- GridLayout: Organize components in a grid of rows and columns.

   // Example: Using a GridLayout
   JPanel panel = new JPanel(new GridLayout(3, 2));
   panel.add(new JButton("Button 1"));
   panel.add(new JButton("Button 2"));
   panel.add(new JButton("Button 3"));
   panel.add(new JButton("Button 4"));
   panel.add(new JButton("Button 5"));
   panel.add(new JButton("Button 6"));
   

3. Containers: 🗄
- These classes hold and manage your GUI components.
- Examples: JFrame, JPanel, JScrollPane.
- JFrame: The main window of your application.
- JPanel: A container that can hold other components and be added to a JFrame.
- JScrollPane: Adds scrolling functionality to a component, like a JTextArea.

   // Example: Creating a JFrame with a JPanel
   JFrame frame = new JFrame("My GUI");
   JPanel panel = new JPanel();
   panel.add(new JLabel("This is a panel inside a frame."));
   frame.add(panel);
   frame.setSize(300, 200);
   frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
   frame.setVisible(true);
   

Remember, these are just the tip of the iceberg when it comes to GUI classes in Java. As you continue to explore and experiment, you'll discover even more ways to create engaging and user-friendly applications. Happy coding! 🚀

here's a comprehensive code example that demonstrates the usage of Swing components, top-level windows, and various categories of GUI classes in Java.

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

public class MyGUIApplication {
    public static void main(String[] args) {
        // Create the top-level window (JFrame)
        JFrame frame = new JFrame("My GUI Application");
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        frame.setSize(400, 300);

        // Create a panel to hold the GUI components
        JPanel panel = new JPanel();
        panel.setLayout(new GridLayout(3, 2, 10, 10)); // Use a GridLayout to organize the components

        // Add Swing components to the panel
        JLabel label = new JLabel("Welcome to my GUI!");
        JButton button = new JButton("Click me!");
        JTextField textField = new JTextField("Enter some text");
        JCheckBox checkBox = new JCheckBox("Option 1");
        JComboBox<String> comboBox = new JComboBox<>(new String[]{"Option 1", "Option 2", "Option 3"});
        JTextArea textArea = new JTextArea("This is a text area");
        JScrollPane scrollPane = new JScrollPane(textArea); // Add a scroll pane to the text area

        // Add the components to the panel
        panel.add(label);
        panel.add(button);
        panel.add(textField);
        panel.add(checkBox);
        panel.add(comboBox);
        panel.add(scrollPane);

        // Add the panel to the frame
        frame.add(panel);

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

Let's break down the code:

1. Top-Level Window (JFrame): We create a JFrame instance, which represents the main window of our GUI application. We set the default close operation to JFrame.EXIT_ON_CLOSE so that the application terminates when the user closes the window. We also set the size of the frame to 400x300 pixels.

2. Swing Components: We create various Swing components, such as JLabel, JButton, JTextField, JCheckBox, JComboBox, and JTextArea. These components represent the building blocks of our GUI.

3. Layout Manager (GridLayout): We use a GridLayout to organize the components on the panel. The GridLayout arranges the components in a grid of rows and columns, with a specified gap between them.

4. Container (JPanel): We create a JPanel instance to hold the Swing components. The panel is then added to the JFrame using the frame.add(panel) method.

5. Scroll Pane (JScrollPane): We wrap the JTextArea component in a JScrollPane to add scrolling functionality to the text area.

This example showcases the use of top-level windows (JFrame), Swing components, and different categories of GUI classes (containers, layouts, and scroll panes) in a Java application.

Attempt to watch the video and practice the provided code examples. Additionally, feel free to write your own code and share it with the group.

Hello everyone! 👋

In our previous class, we covered the concept of the GUI class in Java. Today, we will explore one of the major aspects of GUI programming: color and the subclasses of JComponent.
Let's dive in and learn more about these topics.

Painting the Java GUI Canvas: Exploring Colors and JComponent Subclasses

As a Java beginner, understanding the fundamentals of color and the various JComponent subclasses is crucial for creating visually appealing and interactive Graphical User Interfaces (GUIs). Let's dive in and explore this exciting topic together! 💻

Colors in the Java GUI Palette 🌈
The java.awt.Color class is your gateway to the vibrant world of colors in Java GUI programming. This class provides a wide array of static color constants, such as Color.RED, Color.BLUE, and Color.GREEN, allowing you to easily incorporate these classic hues into your user interfaces.

But that's not all! You can also create custom colors by specifying the desired Red, Green, and Blue (RGB) values, ranging from 0 to 255. For example, to create a warm, orange-ish color, you can use:

Color myCustomColor = new Color(255, 165, 0);

Now, let's see how we can apply these colors to our GUI components.

Subclasses of JComponent: Painting the GUI Canvas
The javax.swing.JComponent class is the foundation for all Swing GUI components. It provides a rich set of subclasses, each with its own unique visual and functional capabilities. Here are a few examples:

1. JButton: This component allows you to create clickable buttons with custom text and colors. Try it out:

JButton myButton = new JButton("Click me!");
myButton.setBackground(Color.CYAN);
myButton.setForeground(Color.DARK_GRAY);

2. JLabel: Use this component to display text or icons with your desired color scheme.

JLabel myLabel = new JLabel("Hello, Java GUI!");
myLabel.setForeground(new Color(255, 165, 0));

3. JPanel: Panels are versatile containers that can hold other components and be styled with colors.

JPanel myPanel = new JPanel();
myPanel.setBackground(new Color(173, 216, 230)); // Light blue

By combining the power of colors and the wide variety of JComponent subclasses, you can create visually stunning and interactive Java GUIs that will impress your users.

Greetings everyone!

In our previous lessons, we explored writing Java code for a GUI. Today, we will demonstrate a more efficient method by utilizing a drag and drop approach. We have selected a video tutorial that provides a step-by-step guide on using this technique in IntelliJ. Please watch the video below and follow along to easily work on your GUI.

Feel free to ask any questions.
Let's get started! 💪

Hello everyone,👋

I have some important updates regarding our plans for the coming days.

As we all know, the 2nd year students will be taking their OOP final exam next week. To help prepare for this exam, we have a few key activities planned:

1. Practice Questions: Starting this Sunday, we will be conducting question and answer sessions to go through practice questions that will help prepare you for the upcoming exam.

2. Previous Year Exam Papers: We will be sharing previous year exam papers. This will give you an opportunity to review the type of questions that have been asked in the past and understand the exam pattern.

Hello everyone,

These exams are from previous years for OOP, and it's often the case that exams are repeated or have similar content. Therefore, use these exams as a guide, and we will also work on more questions.

Greetings everyone,👋

As per our schedule, we will be focusing on practicing questions for the OOP final exam today. The question and answer session is set to commence at 2:30(mata) local time.

See you all there!

NOTE:
#The difference between Abstruction and encapsulation

Abstraction hides the implementation details from users whereas, encapsulation wraps (binds) data and code into a single unit.