



Window Closing Examples


We will now deal only with Java 1.1 events, but within this model you can
accomplish the same task in many different ways. In this lesson we will look
at different ways to get a window frame to close. The behavior of all these
examples will be identical, BUT the structure of the program will be 
different. So, if nothing more you will learn that
there's more than one way to close a window!

NOTE: Command line applications... see info at bottom of page.

External Class Extending Adapter Class:


import java.awt.event.*;
import java.awt.*;

public class way1{
  public static void main(String[] args){
    final Frame f = new Frame("Method 1");
    f.addWindowListener(new WA(f));
    f.setSize(200,200);
    f.show();
  }
}

class WA extends WindowAdapter{
  Frame w;

  WA(Frame x){
    w=x;
  }

  public void windowClosing(WindowEvent e) {
    w.dispose();
    System.exit(0);
  }
}


All the sample programs presented on this page will close a window. This
one uses a class which external from the class which creates the frame
to accomplish this task. You will notice the line:
   f.addWindowListener(new WA(f));

This line attaches a windowListener to the frame. The windowListener
is implemented by extending the WindowAdapter class. The windowClosing()
method is defined in such a way as to cause the frame window to close
when the X in the upper right hand corner is clicked.

Inner Class Extending Adapter Class:

import java.awt.*;
import java.awt.event.*;


public class way2{
  public static void main(String [] s){
    Wink w = new Wink("Method 2");
    w.setSize(200,200);
    w.show();
  }
}

class Wink extends Frame{
  Wink(String s){
    super(s);
    addWindowListener(new WW());
  }

  class WW extends WindowAdapter{
    public void windowClosing(WindowEvent e){
      dispose();
      System.exit(0);
    }
  }
}



Here the class which sets up the Window Event handling facilities is a class
inside the class that extends Frame. Again there is an addWindowListener()
method and the WW class looks a lot like the WA class in the first example.

Class Extending Adapter Class:

import java.awt.event.*;
import java.awt.*;

public class way3 extends WindowAdapter{

  static Frame f;

  public static void main(String[] args){
    f = new Frame("Method 3");
    f.addWindowListener(new way3());
    f.setSize(200,200);
    f.show();
  }

  public void windowClosing(WindowEvent e) {
    f.dispose();
    System.exit(0);
  }
}


This class extends WindowAdapter and contains a Frame. You can see the
usual addWindowListener() and windowClosing() method. 

Class Implementing Listener Class:

import java.awt.event.*;
import java.awt.*;

public class way4 implements WindowListener{

  static Frame f;

  public static void main(String[] args){
    f = new Frame("Method 4");
    f.addWindowListener(new way4());
    f.setSize(200,200);
    f.show();
  }

  public void windowClosing(WindowEvent e) {
    f.dispose();
    System.exit(0);
  }

  public void windowActivated(WindowEvent e) {}
  public void windowClosed(WindowEvent e) {}
  public void windowDeactivated(WindowEvent e) {}
  public void windowDeiconified(WindowEvent e) {}
  public void windowIconified(WindowEvent e) {}
  public void windowOpened(WindowEvent e) {}
}



Here the WindowListener interface is implemented. When you implement
an interface all its methods must be defined. You will notice that there
are six methods which are defined with empty curly braces. They aren't used
and so there is no need to define behavior for them.

Using an Anonymous Inner Class: 

import java.awt.event.*;
import java.awt.*;

public class way5{
  public static void main(String[] args){
    final Frame f = new Frame("Method 5");
    f.addWindowListener( new WindowAdapter() {
      public void windowClosing(WindowEvent e) {
        f.dispose();
        System.exit(0);
      }
    });
    f.setSize(200,200);
    f.show();
  }
}



The most concise way to handle events is with anonymous inner classes. You
can see all the usual methods used here, but everything done with a 
minimum of coding.

Low-Level Event Handling:

import java.awt.event.*;
import java.awt.*;

public class way6{
  public static void main(String[] args){
    win f = new win("Method 6");
    f.setSize(200,200);
    f.show();
  }
}  

class win extends Frame{

  win(String s){
    super(s);
    enableEvents(AWTEvent.WINDOW_EVENT_MASK);
  }

  public void processWindowEvent(WindowEvent e){
    if(e.getID()==WindowEvent.WINDOW_CLOSING){
      dispose();
      System.exit(0);
    }
  }
}



This last method is quite different from the other five, but it still
gets the job done. Here the enableEvents(), processWindowEvent(), and
getID() methods are used to deal with events.