Detailed explanation of how to use Java to write graphical windows

Window is the basis of GUI programming. The visual components of small applications or graphical interface applications are placed in windows. In GUI, the window is part of the user's screen and plays the role of a small screen in the screen. . There are three types of windows:
Applet window: The Applet class manages this window, which is created and processed by the system when the application program starts;
Frame window (JFrame): This is a window in the usual sense, it supports The frame, title bar, and minimize, maximize, and close buttons around the window;
A borderless window (JWindow): no title bar, no frame, just an empty rectangle.

The object created with the JFrame class or its subclass in Swing is the JFrame window.

The main construction method of the JFrame class:

JFrame(): Create an untitled window object;

JFrame(String s): Create a title whose name is a string s window object.

Other common methods of the JFrame class:

setBounds(int x, int y, int width, int height): parameters x, y specify the position where the window appears on the screen; parameters width, height Specify the width and height of the window. The unit is pixels.

setSize(int width,int height): Set the size of the window. The parameters width and height specify the width and height of the window. The unit is pixels.

setBackground(Color c): Set the background color of the window with parameter c.

setVisible(boolean b): Parameter b sets whether the window is visible or invisible. JFrame is invisible by default.

pack(): Display the window in a compact manner. If you don't use this method, the components in the window may not be visible when the window initially appears, and may only become visible when the user resizes the window.

setTitle(String name): Set the name of the window with the parameter name.

getTitle(): Get the name of the window.

setResiable(boolean m): Set whether the current window is resizable (default is resizable).

Containers in Swing can add components. Except for JPanel and its subclasses (JApplet), other Swing containers do not allow components to be added directly. There are two ways to add components to other containers:
One is to use the getContentPane() method to obtain the content panel, and then add the component. For example, the code in the program in Example 5.1:

mw.getContentPane().add(button);

The meaning of this code is to obtain the content panel of the container and add the button button to this content panel.
The other is to create an intermediate container of JPanel objects, add components to this container, and then use setContentPane() to set this container as a content panel. For example, code:

JPanel contentPane = new JPanel();
…
mw.setContentPane(contentPane);

The above code sets the contentPane to the content panel.

[Example] A Java application that uses the JFrame class to create windows. The window has only one button.

import javax.swing.*;
public class Example5_1{
  public static void main(String args[]){
    JFrame mw = new JFrame(“我的第一个窗口”);
    mw.setSize(250,200);
    JButton button = new JButton(“我是一个按钮”);
    mw.getContentPane().add(button);
    mw.setVisible(true);
  }
}

When writing a GUI program with Swing, you usually do not directly use JFrame to create a window object, but use a subclass derived from JFrame to create a window object. Specific requirements for the window can be added to the subclass. and special content, etc.

[Example] Define the JFrame-derived subclass MyWindowDemo to create a JFrame window. The construction method of class MyWindowDemo has five parameters: the title name of the window, the component to add the window, the background color of the window, and the height and width of the window. In the main method, use the MyWindowDemo class to create two similar windows.

import javax.swing.*;
import java.awt.*;
import java.awt.event.*;
public class Example5_2{
  public static MyWindowDemo mw1;
  public static MyWindowDemo mw2;
  public static void main(String args[]){
    JButton static butt1 = new JButton(“我是一个按钮”);
    String name1 = “我的第一个窗口”;
    String name2 = “我的第二个窗口”;
    mw1 = new MyWindowDemo(name1,butt1,Color.blue,350,450);
    mw1.setVisible(true);
    JButton butt2 = new JButton(“我是另一个按钮”);
    mw2 = new MyWindowDemo(name2,butt2,Color.magenta,300,400);
    mw2.setVisible(true);
  }
}
class MyWindowDemo extends JFrame{
  public MyWindowDemo(String name,JButton button,Color c,int w,int h){
    super();
    setTitle(name);
    setSize(w,h);
    Container con = getContentPane();
    con.add(button);
    con.setBackground(c);
  }
}

The display color is managed by the Color class of the java.awt package. Some commonly used colors are reserved in the Color class, see Table 11-3. See the table below for some common methods of the JFrame class.
Common colors defined in the Color class

#Some common methods of the JFrame class

More details For articles related to writing graphical windows using Java, please pay attention to the PHP Chinese website!