🚀 Advanced Swing Concepts 🚀

---

🎯 Introduction to Advanced Swing Concepts

Java Swing is a powerful GUI toolkit for creating desktop applications. While many tutorials cover the basics, there are advanced concepts that allow you to build more sophisticated, interactive, and professional applications. These concepts often involve customization, optimization, and advanced user interactions.

In this section, we’ll explore Advanced Swing Concepts, which will take your Java GUI skills to the next level. We’ll cover advanced topics like custom components, painting and graphics, animations, event handling, and much more.

---

🎨 Custom Components and Painting

Swing allows you to create custom components by subclassing existing components like JPanel or JButton. This is useful when you want to create a unique UI element that isn't available by default in Swing.

Step 1: Creating Custom Components

To create a custom component, you need to override the paintComponent(Graphics g) method, which allows you to draw custom graphics.

Example: Custom Button with a Gradient Background

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

public class CustomButton extends JButton {
    @Override
    protected void paintComponent(Graphics g) {
        if (getModel().isPressed()) {
            g.setColor(Color.RED);  // Red when pressed
        } else {
            g.setColor(Color.BLUE); // Blue when not pressed
        }
        g.fillRoundRect(0, 0, getWidth(), getHeight(), 15, 15); // Draw button with rounded corners
        super.paintComponent(g); // Ensure text is drawn
    }
}

Step 2: Using Your Custom Component

public class CustomComponentExample {
    public static void main(String[] args) {
        JFrame frame = new JFrame("Custom Button");
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

        CustomButton button = new CustomButton();
        button.setText("Click Me");
        frame.add(button);

        frame.setSize(300, 200);
        frame.setVisible(true);
    }
}

In this example, we’ve created a custom button with a gradient background. When the button is pressed, it turns red; otherwise, it stays blue.

---

🎮 Animations with Swing Timers

Animations are a key part of modern user interfaces, and Java Swing provides Swing Timers to help you implement animations in your applications.

Step 1: Using Swing Timer for Animation

Swing timers allow you to schedule tasks at regular intervals, which is ideal for animations.

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

public class AnimationExample extends JPanel {
    private int x = 0;

    public AnimationExample() {
        Timer timer = new Timer(10, e -> {
            x++;
            repaint();  // Repaint the component to animate
        });
        timer.start();
    }

    @Override
    protected void paintComponent(Graphics g) {
        super.paintComponent(g);
        g.setColor(Color.RED);
        g.fillRect(x, 50, 50, 50); // Draw a red rectangle that moves
    }

    public static void main(String[] args) {
        JFrame frame = new JFrame("Swing Animation");
        AnimationExample animationPanel = new AnimationExample();
        frame.add(animationPanel);
        frame.setSize(400, 200);
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        frame.setVisible(true);
    }
}

In this example, a red rectangle moves horizontally across the screen. The Timer updates the position every 10 milliseconds.

---

🧩 Event Handling with Custom Listeners

Swing provides built-in listeners for common events (e.g., mouse clicks, key presses). However, for complex interactions, you can create custom event listeners that allow your components to respond to specific events in a unique way.

Step 1: Creating a Custom Event Listener

A custom listener involves defining an interface, creating an event object, and then handling the event.

Example: Custom Event Listener

import java.util.EventObject;

// Step 1: Define the custom event class
class MyEvent extends EventObject {
    public MyEvent(Object source) {
        super(source);
    }
}

// Step 2: Define the custom event listener interface
interface MyEventListener {
    void onMyEvent(MyEvent event);
}

// Step 3: Create a component that fires the custom event
class MyComponent extends JComponent {
    private MyEventListener listener;

    public void setMyEventListener(MyEventListener listener) {
        this.listener = listener;
    }

    public void triggerEvent() {
        if (listener != null) {
            listener.onMyEvent(new MyEvent(this));
        }
    }
}

Step 2: Using Custom Event Listener

public class CustomEventListenerExample {
    public static void main(String[] args) {
        JFrame frame = new JFrame("Custom Event Listener");
        MyComponent component = new MyComponent();

        // Set custom event listener
        component.setMyEventListener(event -> {
            System.out.println("Custom event triggered!");
        });

        // Trigger the custom event
        component.triggerEvent();

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

In this example, a custom event listener is triggered, and a message is printed when the event occurs.

---

🎨 Look and Feel Customization

Swing allows you to customize the Look and Feel (L&F) of your application. By default, Swing uses the system’s native look and feel, but you can change it to make your application match your brand or style.

Step 1: Setting a Custom Look and Feel

import javax.swing.*;

public class LookAndFeelExample {
    public static void main(String[] args) {
        try {
            // Set the Look and Feel
            UIManager.setLookAndFeel(UIManager.getSystemLookAndFeelClassName());
        } catch (Exception e) {
            e.printStackTrace();
        }

        JFrame frame = new JFrame("Look and Feel Example");
        JButton button = new JButton("Click Me");
        frame.add(button);

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

You can also apply custom L&F styles by using third-party libraries such as FlatLaf or JGoodies.

---

🖥 Multithreading in Swing with SwingWorker

Swing applications are single-threaded by default, meaning that UI updates and long-running tasks (like downloading files or querying a database) must happen on the Event Dispatch Thread (EDT). This can lead to UI freezing or unresponsiveness.

To avoid freezing the UI, you can use the SwingWorker class, which allows you to perform long-running tasks in the background while keeping the UI responsive.

Step 1: Using SwingWorker for Background Tasks

import javax.swing.*;
import java.util.concurrent.ExecutionException;

public class SwingWorkerExample {
    public static void main(String[] args) {
        SwingWorker<String, Void> worker = new SwingWorker<String, Void>() {
            @Override
            protected String doInBackground() throws Exception {
                // Simulate long-running task
                Thread.sleep(2000);
                return "Task Completed!";
            }

            @Override
            protected void done() {
                try {
                    System.out.println(get()); // Display the result
                } catch (InterruptedException | ExecutionException e) {
                    e.printStackTrace();
                }
            }
        };
        worker.execute();
    }
}

In this example, doInBackground() runs the long task in a background thread, and the done() method is called when the task completes to update the UI.

---

🏆 Summary of Advanced Swing Concepts

1. Custom Components and Painting: Use paintComponent() to create your own UI components with custom graphics and animations.
2. Animations with Swing Timers: Use Timer to create smooth animations by periodically updating the UI.
3. Custom Event Handling: Define your own event listeners for unique and complex interactions.
4. Look and Feel Customization: Change the appearance of your app to match the operating system or your design preferences.
5. Multithreading with SwingWorker: Use SwingWorker to perform long-running tasks in the background, keeping the UI responsive.

By mastering these Advanced Swing Concepts, you will be able to create more polished, responsive, and professional Java applications.

---

🎯 Next Steps:

• Dive deeper into custom graphics and learn how to create complex shapes and effects.
• Experiment with animations and background tasks to build interactive applications.
• Explore more about Swing’s advanced layouts and how to design responsive, complex user interfaces.