Icon interface Java

Java is a versatile and widely-used programming language known for its rich libraries and robust features. One such feature is the Icon interface, which allows developers to create dynamic graphical representations of objects. In this section, we will delve into the Icon interface in Java, exploring its capabilities and providing full programs with outputs to help you understand how to use it effectively.

What is the Icon Interface?

The Icon interface is a part of the javax.swing package, which is commonly used for building graphical user interfaces (GUIs) in Java applications. It defines a set of methods that enable the creation and manipulation of icons, which are visual elements used to represent objects, actions, or entities within a GUI. Icons can be used for buttons, labels, and other components in graphical user interface.

To use the Icon interface effectively, you need to implement it by creating a custom class that provides concrete implementations of the required methods. Let's explore these methods in detail:

int getIconWidth(): It returns the width of the icon in pixels.
int getIconHeight(): It returns the height of the icon in pixels.
void paintIcon(Component c, Graphics g, int x, int y): It is responsible for painting the icon on the specified component at the given (x, y) coordinates using the provided Graphics object.

Creating a Custom Icon

Now, let's create a custom icon class that implements the Icon interface. We'll create a simple Icon that draws a red rectangle. Here's the code:

import javax.swing.*;
import java.awt.*;
// CustomIcon class implementing the Icon interface
class CustomIcon implements Icon {
    private int width;
    private int height;
    // Constructor to initialize the width and height of the icon
    public CustomIcon(int width, int height) {
        this.width = width;
        this.height = height;
    }
    // Method to get the width of the icon
    @Override
    public int getIconWidth() {
        return width;
    }
    // Method to get the height of the icon
    @Override
    public int getIconHeight() {
        return height;
    }
    // Method to paint the icon on a component
    @Override
    public void paintIcon(Component c, Graphics g, int x, int y) {
        // Set the color to red
        g.setColor(Color.RED);  
        // Fill a rectangle at the specified (x, y) coordinates with the specified width and height
        g.fillRect(x, y, width, height);
    }
}

Output:

In this code, we have created a CustomIcon class that implements the Icon interface. It takes width and height as parameters in the constructor and uses these values to define the icon's size. The paintIcon() method is responsible for painting the red rectangle on the component.

Using the Custom Icon

Once we have done with custom icon, let's use it in a simple Swing application. We'll create a JFrame with a JLabel that displays our custom icon.

IconDemo.java

import javax.swing.*;
// The main class for the IconDemo program
public class IconDemo {
    public static void main(String[] args) {
        // Use SwingUtilities.invokeLater() to run the GUI code on the Event Dispatch Thread (EDT)
        SwingUtilities.invokeLater(() -> {
            // Create a new JFrame with the title "Custom Icon Demo"
            JFrame frame = new JFrame("Custom Icon Demo");           
            // Set the default close operation to exit the application when the frame is closed
            frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
            // Create an instance of the CustomIcon class with dimensions 100x50 pixels
            Icon customIcon = new CustomIcon(100, 50);           
            // Create a JLabel and set its icon to the customIcon
            JLabel label = new JLabel(customIcon);            
            // Add the label to the frame
            frame.add(label);
            // Pack the frame to set its size according to the preferred size of its components
            frame.pack();       
            // Make the frame visible on the screen
            frame.setVisible(true);
        });
    }
}

Output:

In this code, we have created a JFrame and set its title. After that, we have created create an instance of our CustomIcon and use it to create a JLabel. Finally, we add the label to the frame, pack the frame to set its size according to the label's preferred size, and make the frame visible.

In Summary, The Icon interface in Java provides a versatile way to create custom graphical representations in your GUI applications. By implementing this interface, you can define your own icons and use them in various Swing components like JLabels, JButtons, and more.

In this section, we explored the Icon interface and created a custom icon class that painted a red rectangle. We also demonstrated how to use this custom icon in a Swing application. Understanding and utilizing the Icon interface can add visual appeal and customization to your Java GUI applications, making them more engaging and user-friendly.

Next TopicJava Visualizers

← prev next →