Remarks#

Quitting the application on window close

It’s easy to forget to quit the application when the window is closed. Remember to add the following line.

frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE); //Quit the application when the JFrame is closed

Creating an Empty Window (JFrame)

Creating the JFrame

Creating a window is easy. You just have to create a JFrame.

JFrame frame = new JFrame();

Titling the Window

You may wish to give your window a title. You can so do by passing a string when creating the JFrame, or by calling frame.setTitle(String title).

JFrame frame = new JFrame("Super Awesome Window Title!");
//OR
frame.setTitle("Super Awesome Window Title!");

Setting the Window Size

The window will be as small as possible when it has been created. To make it bigger, you can set its size explicitly:

frame.setSize(512, 256);

Or you can have the frame size itself based on the size of its contents with the pack() method.

frame.pack();

The setSize() and pack() methods are mutually exclusive, so use one or the other.

What to do on Window Close

Note that the application will not quit when the window has been closed. You can quit the application after the window has been closed by telling the JFrame to do that.

frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);

Alternatively, you can tell the window to do something else when it is closed.

WindowConstants.DISPOSE_ON_CLOSE //Get rid of the window
WindowConstants.EXIT_ON_CLOSE //Quit the application
WindowConstants.DO_NOTHING_ON_CLOSE //Don't even close the window
WindowConstants.HIDE_ON_CLOSE //Hides the window - This is the default action

Creating a Content Pane

An optional step is to create a content pane for your window. This is not needed, but if you want to do so, create a JPanel and call frame.setContentPane(Component component).

JPanel pane = new JPanel();
frame.setContentPane(pane);

Showing the Window

After creating it, you will want to create your components, then show the window. Showing the window is done as such.

frame.setVisible(true);

Example

For those of you who like to copy and paste, here’s some example code.

JFrame frame = new JFrame("Super Awesome Window Title!"); //Create the JFrame and give it a title
frame.setSize(512, 256); //512 x 256px size
frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE); //Quit the application when the JFrame is closed

JPanel pane = new JPanel(); //Create the content pane
frame.setContentPane(pane); //Set the content pane

frame.setVisible(true); //Show the window

Adding Components

A component is some sort of user interface element, such as a button or a text field.

Creating a Component

Creating components is near identical to creating a window. Instead of creating a JFrame however, you create that component. For example, to create a JButton, you do the following.

JButton button = new JButton();

Many components can have parameters passed to them when created. For example, a button can be given some text to display.

JButton button = new JButton("Super Amazing Button!");

If you don’t want to create a button, a list of common components can be found in another example on this page.

The parameters that can be passed to them vary from component to component. A good way of checking what they can accept is by looking at the paramters within your IDE (If you use one). The default shortcuts are listed below.

• IntelliJ IDEA - Windows / Linux: CTRL + P
• IntelliJ IDEA - OS X / macOS: CMD + P
• Eclipse: CTRL + SHIFT + Space
• NetBeans: CTRL + P

Showing the Component

After a component has been created, you would typically set its parameters. After than, you need to put it somewhere, such as on your JFrame, or on your content pane if you created one.

frame.add(button); //Add to your JFrame
//OR
pane.add(button); //Add to your content pane
//OR
myComponent.add(button); //Add to whatever

Example

Here’s an example of creating a window, setting a content pane, and adding a button to it.

JFrame frame = new JFrame("Super Awesome Window Title!"); //Create the JFrame and give it a title
frame.setSize(512, 256); //512 x 256px size
frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE); //Quit the application when the JFrame is closed

JPanel pane = new JPanel(); //Create the content pane
frame.setContentPane(pane); //Set the content pane

JButton button = new JButton("Super Amazing Button!"); //Create the button
pane.add(button); //Add the button to the content pane

frame.setVisible(true); //Show the window

Setting Parameters for Components

Components have various parameters that can be set for them. They vary from component to component, so a good way to see what parameters can be set for components is to start typing componentName.set, and let your IDE’s autocomplete (If you use an IDE) suggest methods. The default shortcut in many IDEs, if it doesn’t show up automatically, is CTRL + Space.

Common parameters that are shared between all components

Common parameters in other components

Common Components

Making Interactive User Interfaces

Having a button there is all well and good, but what’s the point if clicking it does nothing? ActionListeners are used to tell your button, or other component to do something when it is activated.

Adding ActionListeners is done as such.

buttonA.addActionListener(new ActionListener() {
    @Override
    public void actionPerformed(ActionEvent e) {
        //Code goes here...
        System.out.println("You clicked the button!");
    }
});

Or, if you’re using Java 8 or above…

buttonA.addActionListener(e -> {
    //Code
    System.out.println("You clicked the button!");
});

Example (Java 8 and above)

JFrame frame = new JFrame("Super Awesome Window Title!"); //Create the JFrame and give it a title
frame.setSize(512, 256); //512 x 256px size
frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE); //Quit the application when the JFrame is closed

JPanel pane = new JPanel(); //Create a pane to house all content
frame.setContentPane(pane);

JButton button = new JButton("Click me - I know you want to.");
button.addActionListener(e -> {
    //Code goes here
    System.out.println("You clicked me! Ouch.");
});
pane.add(buttonA);

frame.setVisible(true); //Show the window

Organizing Component Layout

Adding components one after another results in a UI that’s hard to use, because the components all are somewhere. The components are ordered from top to bottom, each component in a separate “row”.

To remedy this and provide you as developer with a possibility to layout components easily Swing has LayoutManagers.

These LayoutManagers are covered more extensively in Introduction to Layout Managers as well as the separate Layout Manager topics:

• Grid Layout

• GridBag Layout