Java: JFrame - Window

Description

The javax.swing.JFrame class is used to create a "window". This window has a few characteristics of its own (title bar, etc), but most of the controls are placed in one of two subareas: content pane or menu bar.

Constructors

You can create a frame like this:

   JFrame w = new JFrame("your title");  // OK, but it's better to use subclassing as below.

Subclass JFrame, build in constructor. Another better way is to define a class, eg MyWindow that extends JFrame, put the code which builds the GUI in the class's constructor, and create an instance of the window from the main program. See example below.

Content pane - Two styles - Get it or set it

There are two common ways to use a JFrame's content pane. Both are commonly used. In both cases, the easiest style is to assign the working version of the content pane to

Get the predefined content pane and change it. Every JFrame comes with a default content pane. It doesn't have anything on it, altho it does have a default layout, probably not the one you want to use tho! The getContentPane() method returns a Container object, which interestingly is actually a Jpanel. No problem with this approach.
Create a JPanel and make it the content pane. Most of my example code is written this way. This requires a call to setContentPane(...).

Common methods

JFrame    w;   // This is the natural Java "window".
Container c;   // This will typically be a JPanel (subclass of Container).
WindowListener listen; //
String    title;
boolean   b;
JMenuBar  mBar;

Using the content pane. See Content Panes
`c =`	`w.getContentPane();`	Returns window's content pane. Use either get or set, but not both.
	`w.setContentPane(c);`	Sets window's content pane to c (or subclass JPanel).
Handling the window's close box. See JFrame Close Box
	`w.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);`
		This adds a window listener that simply executes System.exit(). It's the short, appropriate, solution for most small programs.
	`w.addWindowListener(listen);`	Use this to call your own window closing listener.
Executing the layout.
	`w.pack();`	Finalize layout after everything is added to window and content pane. Don't use `validate()` with layout managers.
Displaying the window.
	`w.setVisible(true);`	Makes the window visible, and starts the Event Dispatch Thread (EDT) which manages the GUI. This is usually called by the main program after calling the constructor. `show()` should no longer be used.
Miscellaneous.
	`w.setTitle(title);`	xxx
	`w.setResizable(false);`	Set to false if you don't want the user to resize your window.
	`w.setJMenuBar(mbar);`	This is how to add a menubar to the window.
	`w.setLocationRelativeTo(null);`	Centers the window. If you even bother with position, this is the most common choice.
Less common positioning and sizing.
	`w.setSize(w, h);`	Sets window to pixel width (w) and height (h). The only reasons to use this are to fill the screen or restore a window size from a previous run.
	`w.setLocation(x, y);`	Sets the upper left corner of the window to this screen pixel coordinate.

Example

There is typically be a very short main method something like this.

  public static void main(String[] args {
      JFrame windo = new MyExample();
      windo.setVisible(true);
  }

And a class which defines the window.

public class MyExample extends JFrame {
    //... Declare components, something to hold the model.
    . . .
    public MyExample() { // constructor builds GUI
        //... Build the content pane.
        Container content = this.getContentPane();
        content.add(...) // Add components to the content
        . . .
        this.setTitle("My new window");
        this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        this.pack();   // does layout of components.
    }//end constructor
}