Class 15: Lab: Java's Abstract Windowing Toolkit

Held Tuesday, September 19, 2000

Summary

Today we move away from the basics of the Java language and start to consider how to build simple GUI (graphical user interface) applications with Java. We examine some basic issues in GUI construction, including windows, buttons, text fields, and events.

Notes

• Are there any questions on exam 1?
• No readings for tomorrow, but please bring more exam questions.
• This coming weekend is the planned parenthood booksale in Des Moines. Go see a huge agricultural hall filled with books.
• Coffee and donuts this morning to keep you working.
• CS Picnic Friday

Overview

• GUI basics, including Java GUI concepts.
• A sample GUI, step by step
• Detour: Anonymous classes

GUI Basics

• Although many of the programs we've been writing are text-based, most modern programs use a graphical user interface (GUI).
• Graphical user interfaces include windows, buttons, menus, and the Ilk.
• GUI programming environments typically use an event-driven programming model. We might also call this a reactive model.
  • Rather than using an imperative model in which your program says step-by-step what do do, reactive programs have event handlers which basically say ``when this happens, do this''.
  • The ``this'' may be imperative.
  • You may need some imperative code for setting up the GUI.
• There are many different ways to create the same GUI in Java; you can divide different responsibilities between classes in different ways.
  • We'll see one in class and another in lab.

Java GUI Basics

• Java's included toolkits for building GUIs since the early versions.
  • Unfortunately, these toolkits have changed substantially as Java evolved from 1.0 to 1.1 and from 1.1 to 1.2.
  • We'll focus on the Abstract Windowing Toolkit (AWT) because it is supported in Java 1.1 and Java 1.2.
  • Java 1.2 adds Swing, but Swing is not yet fully supported on all platforms.
• In Java's AWT, almost everything you'd add to a GUI is a Component
  • A good example of inheritance and polymorphism.
• Events are handled by Listeners. When things can happen related to that object, the listeners are informed.
• Although AWT programs are event-driven, you still need a main method to create the objects which supply these event handlers.
• The top-level window is typically a Frame.

A Sample Program

• Let's look at the steps involved in creating a simple GUI program.
• We'll start with the Main class.

  public class OurGUI
  {
    public static void main(String[] args) {
    }
  } // class OurGUI
  

• We need to build a Frame for our GUI.

  import java.awt.Frame;
    ...
    public static void main(String[] args) {
      // Set up the primary window.
      Frame window = new Frame("Our First GUI");
    }
  

• We also need to give it a layout. The layout determines how things are arranged in the Frame. The simplest is a FlowLayout.

  import java.awt.FlowLayout;
    ...
      window.setLayout(new FlowLayout();
  

• We're now ready to display the frame.

      window.pack();
      window.show();
  

• See if youc an get the program to compile and run. You'll need to hit control-C to stop it.
• We'll need to create a new listener for the Frame. This listener will initially do nothing. You use WindowListeners to listen to frames. You can extend WindowAdapter for your initial listeners.

  import java.awt.event.WindowAdapter;
  import java.awt.event.WindowEvent;
  import java.awt.event.WindowListener;
  
  public class QuitWhenClosed
    extends WindowAdapter
  {
    public void windowClosing(WindowWEvent we) {
    } // windowClosing(WindowEvent)
  } // class QuitWhenClosed
  

• We then add it to our Frame.

  import QuitWhenClosed;
  ...
  public class OurGUI {
    ...
      Frame window = new Frame(...);
      QuitWhenClosed quitter = new QuitWhenClosed();
      window.addWindowListener(quitter);
    ...
  } // class OurGUI
  

• Here's another good time to try compiling and running. You'll still need to hit control-C to stop.
• Now we're ready to stop the program when the window closes.

    public void windowClosing(WindowWEvent we) {
      System.exit(0);
    } // windowClosing(WindowEvent)
  

• Once again, let's try it and see.
• Now we can add buttons.
• More to come?

Detour: Anonymous Classes

• You may recall from Scheme that we occasionally needed to create functions that we would use only once.
  • Rather than naming those functions, we typically used lambda to build an anonymous function.
• In Java, you can do the same thing with objects. That is, you can build an extension of a class without naming that extension.
• You write

      new ClassName(parameters) {
        OverriddenMethods
      }
  

• For example

      WindowListener quitter = 
        new WindowAdapter() {
          /**
           * Quit the program when the user closes this window.
           */
          public void windowClosing(WindowEvent we) {
            System.exit(0);
          } // windowClosing(WindowEvent)
        } // the extended WindowAdapter
  

• Or even

      window.add(new WindowAdapter() { ... });
  

Laboratory

Are there questions on the readings?

Do lab G3, parts G3.1 and G3.2. I'd like you to finish this on your own if you can't finish it in class today.