Most users are used to seeing an application interface with buttons an boxes. The Java programmer can provide this by using the Swing and AWT packages.

There are two quotes by Albert Einstein that every Java programmer should keep close to their hearts:

>Why should I memorize something when I know where to find it?
>Know where to find the information and how to use it - that's the secret of success.

And that, of course, is the secret to writing good Java applications. It's not done by creating completely new functionality, but by using the packages and classes that are already in existence. A good example of this is building Java GUIs (Graphical User Interfaces).

If a programmer is designing an application to be used in a Windows type environment then the user will not expect to have an application that works only on the command line. They will expect to see an application that:

- has its own window
- has elements such as text boxes and buttons
- will respond to their actions (such as clicking the mouse buttons)

It is, therefore, just a matter of learning which packages to access and how to use them.

### Java GUI Packages

Java has two packages that are used in the creation of a GUI:

1. **AWT** - the Abstract Windowing Toolkit - provides the functionality for the GUI
2. **Swing**- provides the components (the widgets) for the GUI

![image.png](https://res.cloudinary.com/hpiynhbhq/image/upload/v1515129137/aje2gj6jiqgndxd4b01t.png)


They are imported in the same way that any other Java package is imported:
```
import java.awt.* ;
import java.awt.event.* ;
import javax.swing.* ;
```
With the packages (and the classes that they contain) loaded the widgets (or components) for the GUI can be defined:

```
public class simpleForm extends JFrame {
private JPanel contentPanel;
private JLabel jLabel1;
private JLabel jLabel2;
private JTextField jTextField1;
private JButton jButton1;
```

![image.png](https://res.cloudinary.com/hpiynhbhq/image/upload/v1515129192/xxddxdeajbqwmwuidrad.png)

Here there are four key components to the GUI:

**JFrame** - the window for the GUI
**JPanel** - a container in the GUI window for the widgets
**JLabel**- a label widget
**JTextField** - a text field widget
**JButton** - a button widget

The widgets can now be added to the container in the Java frame.

### Adding Swing Widgets to a Container

Widgets are all added to the container in the same way and it is, therefore, a good ideas to have a separate method to do this:
```
private void addElement (Container c, Component w, int x, int y, int h, int w) {
w.setBounds(x, y, h, w);
c.add(e);
}
```
![image.png](https://res.cloudinary.com/hpiynhbhq/image/upload/v1515129233/yxfl3mqxncaxwsfwih1e.png)


The code uses the setBounds method to define where the widget is placed within the container (with x=0, y=0 being the top left hand corner) and it defines the height and width of the widget. Adding widgets is now a very easy task:
```
simpleForm() {
contentPanel = (JPanel)getContentPane();
contentPanel.setLayout(null); // a blank form
jLabel1 = new JLabel("Action:");
addElement(contentPanel, jLabel1,0,0,100,20);
jTextField1 = new JTextField();
addElement(contentPanel, jTextField1,0,20,100,20);
jButton1 = new JButton("Click Me");
addElement(contentPanel, jButton1,0,100,100,20);
```
![image.png](https://res.cloudinary.com/hpiynhbhq/image/upload/v1515129272/djcnadeey5ejg7g5cfwv.png)

With the widgets in place the next step is to introduce some functionality into the GUI.

### Adding Functionality to a Java Swing Widget
Functionality is added to widgets by making use of an ActionListener. In this example clicking the button will update the contents of a text box.:
```
jButton1.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
jTextField1.setText("Button clicked");
}
});
```
![image.png](https://res.cloudinary.com/hpiynhbhq/image/upload/v1515129308/xqu9vkjdclrlorjktn2z.png)

It is a very simple example, but does show just how easy it is to make a GUI fully functional.

### Displaying the GUI
The penultimate step is to define how the screen is to be displayed:
```
setTitle("A Simple Form");
setSize(200, 200); // The GUI dimensions
setLocation(new Point(150, 150)); //The GUI position
setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
setVisible(true);
}
```
![image.png](https://res.cloudinary.com/hpiynhbhq/image/upload/v1515129353/fthqbbx379ex6xlc65mi.png)

And finally the GUI is called from the main method:
```
public static void main(String args[]) {
new simpleForm();
}
}
```
![image.png](https://res.cloudinary.com/hpiynhbhq/image/upload/v1515129390/agm5vin2lwaqrvtpzpnx.png)

The code can now be saved as simpleForm.java, compiled and the run to show a very simple example of a GUI. Summary There are 5 steps to creating a Java based GUI:

Step 1. import the GUI packages
Step 2. declare the widgets to be used in the GUI
Step 3. add the widgets to a container
Step 4. implement any event handling
Step 5. show the GUI

And that's all there is to it - a simple but effective way of providing an interface for an application user.

<br /><hr/><em>Posted on <a href="https://utopian.io/utopian-io/@cheretta/how-to-create-a-simple-java-gui-with-gnu-compiler-for-java-using-swing-and-awt-in-a-graphical-user-interface">Utopian.io -  Rewarding Open Source Contributors</a></em><hr/>