JAVA 基础知识整理-20 GUI

1.GUI继承结构
2. Component
public abstract class Component
extends Object
implements ImageObserver, MenuContainer, Serializable
组件是具有可以在屏幕上显示并且可以与用户交互的图形表示的对象。

方法：
boolean action(Event evt, Object what)
已弃用
从JDK 1.1版开始，应该在组件上注册此组件作为ActionListener，该组件将触发动作事件。
void add(PopupMenu popup)
将指定的弹出菜单添加到组件。
void addComponentListener(ComponentListener l)
添加指定的组件侦听器以从该组件接收组件事件。
void addFocusListener(FocusListener l)
当该组件获得输入焦点时，添加指定的焦点侦听器以从该组件接收焦点事件。
void addHierarchyBoundsListener(HierarchyBoundsListener l)
添加指定的层次结构边界侦听器以在此容器所属的层次结构更改时从此组件接收层次结构边界事件。
void addHierarchyListener(HierarchyListener l)
添加指定的层次监听器，以便在此容器所属的层次结构更改时从此组件接收层次结构更改的事件。
void addInputMethodListener(InputMethodListener l)
添加指定的输入法侦听器以从该组件接收输入法事件。
void addKeyListener(KeyListener l)
添加指定的密钥侦听器以从该组件接收密钥事件。
void addMouseListener(MouseListener l)
添加指定的鼠标监听器以从该组件接收鼠标事件。
void addMouseMotionListener(MouseMotionListener l)
添加指定的鼠标移动侦听器以从该组件接收鼠标移动事件。
void addMouseWheelListener(MouseWheelListener l)
添加指定的鼠标滚轮侦听器以从该组件接收鼠标滚轮事件。
void addNotify()
通过将此 Component连接到本机屏幕资源来显示。
void addPropertyChangeListener(PropertyChangeListener listener)
将PropertyChangeListener添加到侦听器列表。
void addPropertyChangeListener(String propertyName, PropertyChangeListener listener)
将PropertyChangeListener添加到特定属性的侦听器列表中。
void applyComponentOrientation(ComponentOrientation orientation)
设置此组件的 ComponentOrientation属性及其中包含的所有组件。
boolean areFocusTraversalKeysSet(int id)
返回是否为此组件显式定义了给定焦点遍历操作的聚焦遍历键集。
Rectangle bounds()
已弃用
从JDK 1.1版开始，替换为getBounds() 。
int checkImage(Image image, ImageObserver observer)
返回构造指定图像的屏幕表示的状态。
int checkImage(Image image, int width, int height, ImageObserver observer)
返回构造指定图像的屏幕表示的状态。
protected AWTEvent coalesceEvents(AWTEvent existingEvent, AWTEvent newEvent)
潜在地合并现有事件发布的事件。
boolean contains(int x, int y)
检查此组件是否“包含”指定点，其中 x和 y被定义为相对于该组件的坐标系。
boolean contains(Point p)
检查此组件是否“包含”指定点，其中点的 x和 y坐标被定义为相对于该组件的坐标系。
Image createImage(ImageProducer producer)
从指定的图像制作者创建图像。
Image createImage(int width, int height)
创建一个用于双缓冲的屏幕外可绘图像。
VolatileImage createVolatileImage(int width, int height)
创建一个用于双缓冲的易失性的屏幕外可绘图像。
VolatileImage createVolatileImage(int width, int height, ImageCapabilities caps)
使用给定的功能创建一个易失的屏幕外可绘制图像。
void deliverEvent(Event e)
已弃用
从JDK 1.1版开始，由dispatchEvent(AWTEvent e) 。
void disable()
已弃用
从JDK 1.1版开始，由setEnabled(boolean) 。
protected void disableEvents(long eventsToDisable)
禁用由指定事件掩码参数定义的事件传递给此组件。
void dispatchEvent(AWTEvent e)
将事件分派到此组件或其一个子组件。
void doLayout()
提示布局管理器布局此组件。
void enable()
已弃用
从JDK 1.1版开始，由setEnabled(boolean) 。
void enable(boolean b)
已弃用
从JDK 1.1版开始，由setEnabled(boolean) 。
protected void enableEvents(long eventsToEnable)
启用由指定的事件掩码参数定义的事件传递给此组件。
void enableInputMethods(boolean enable)
启用或禁用此组件的输入法支持。
protected void firePropertyChange(String propertyName, boolean oldValue, boolean newValue)
支持报告布尔属性的绑定属性更改。
void firePropertyChange(String propertyName, byte oldValue, byte newValue)
报告绑定属性更改。
void firePropertyChange(String propertyName, char oldValue, char newValue)
报告绑定属性更改。
void firePropertyChange(String propertyName, double oldValue, double newValue)
报告绑定属性更改。
void firePropertyChange(String propertyName, float oldValue, float newValue)
报告绑定属性更改。
protected void firePropertyChange(String propertyName, int oldValue, int newValue)
支持报告整数属性的绑定属性更改。
void firePropertyChange(String propertyName, long oldValue, long newValue)
报告绑定属性更改。
protected void firePropertyChange(String propertyName, Object oldValue, Object newValue)
支持报告对象属性的绑定属性更改。
void firePropertyChange(String propertyName, short oldValue, short newValue)
报告绑定属性更改。
AccessibleContext getAccessibleContext()
获取 AccessibleContext与此相关 Component 。
float getAlignmentX()
返回沿x轴的对齐方式。
float getAlignmentY()
返回沿着y轴的对齐。
Color getBackground()
获取此组件的背景颜色。
int getBaseline(int width, int height)
返回基线。
Component.BaselineResizeBehavior getBaselineResizeBehavior()
返回一个枚举，指示组件的基线如何随着大小的变化而改变。
Rectangle getBounds()
以 Rectangle对象的形式获取此组件的边界。
Rectangle getBounds(Rectangle rv)
将此组件的边界存储到“返回值” rv并返回 rv 。
ColorModel getColorModel()
获取的实例 ColorModel用于显示在输出设备上的组件。
Component getComponentAt(int x, int y)
确定此组件或其一个直接子组件是否包含（ x ， y ）位置，如果是，则返回包含的组件。
Component getComponentAt(Point p)
返回包含指定点的组件或子组件。
ComponentListener[] getComponentListeners()
返回在此组件上注册的所有组件侦听器的数组。
ComponentOrientation getComponentOrientation()
检索用于对该组件中的元素或文本进行排序的语言敏感方向。
Cursor getCursor()
获取组件中的光标集。
DropTarget getDropTarget()
获取 DropTarget与此相关 Component 。
Container getFocusCycleRootAncestor()
返回作为该组件焦点遍历循环的焦点循环根的容器。
FocusListener[] getFocusListeners()
返回在此组件上注册的所有焦点侦听器的数组。
Set getFocusTraversalKeys(int id)
返回此组件的给定遍历操作的聚焦遍历键集。
boolean getFocusTraversalKeysEnabled()
返回是否为此组件启用焦点遍历键。
Font getFont()
获取此组件的字体。
FontMetrics getFontMetrics(Font font)
获取指定字体的字体指标。
Color getForeground()
获取此组件的前景色。
Graphics getGraphics()
为此组件创建图形上下文。
GraphicsConfiguration getGraphicsConfiguration()
获取 GraphicsConfiguration与此相关 Component 。
int getHeight()
返回此组件的当前高度。
HierarchyBoundsListener[] getHierarchyBoundsListeners()
返回在此组件上注册的所有层次结构边界侦听器的数组。
HierarchyListener[] getHierarchyListeners()
返回在此组件上注册的所有层级监听器的数组。
boolean getIgnoreRepaint()
InputContext getInputContext()
获取此组件使用的输入上下文，以便在此组件中输入文本时处理与输入法的通信。
InputMethodListener[] getInputMethodListeners()
返回在此组件上注册的所有输入法侦听器的数组。
InputMethodRequests getInputMethodRequests()
获取支持该组件输入法的请求的输入法请求处理程序。
KeyListener[] getKeyListeners()
返回在此组件上注册的所有关键侦听器的数组。

T[] getListeners(类 listenerType)
返回当前注册为 FooListener的所有对象的数组，此对象为 Component 。
Locale getLocale()
获取此组件的区域设置。
Point getLocation()
以指定组件左上角的点的形式获取此组件的位置。
Point getLocation(Point rv)
将该组件的x，y原点存储到“返回值” rv并返回 rv 。
Point getLocationOnScreen()
以指定组件左上角的点的形式获取此组件的位置。
Dimension getMaximumSize()
获取此组件的最大大小。
Dimension getMinimumSize()
获取此组件的最小大小。
MouseListener[] getMouseListeners()
返回在此组件上注册的所有鼠标监听器的数组。
MouseMotionListener[] getMouseMotionListeners()
返回在此组件上注册的所有鼠标移动侦听器的数组。
Point getMousePosition()
如果 Component直接位于鼠标指针下，则返回鼠标指针位于此 Component的坐标空间中，否则返回 null 。
MouseWheelListener[] getMouseWheelListeners()
返回在此组件上注册的所有鼠标滚轮侦听器的数组。
String getName()
获取组件的名称。
Container getParent()
获取此组件的父级。
java.awt.peer.ComponentPeer getPeer()
已弃用
从JDK 1.1版开始，程序不应该直接操纵对等体; 换成boolean isDisplayable() 。
Dimension getPreferredSize()
获取此组件的首选大小。
PropertyChangeListener[] getPropertyChangeListeners()
返回在此组件上注册的所有属性更改侦听器的数组。
PropertyChangeListener[] getPropertyChangeListeners(String propertyName)
返回与named属性相关联的所有侦听器的数组。
Dimension getSize()
以 Dimension对象的形式返回此组件的大小。
Dimension getSize(Dimension rv)
将该组件的宽度/高度存储到“返回值” rv并返回 rv 。
Toolkit getToolkit()
获取此组件的工具包。
Object getTreeLock()
获取AWT组件树和布局操作的此组件的锁定对象（拥有线程同步监视器的对象）。
int getWidth()
返回此组件的当前宽度。
int getX()
返回组件原点的当前x坐标。
int getY()
返回组件原点的当前y坐标。
boolean gotFocus(Event evt, Object what)
已弃用
从JDK 1.1版开始，由processFocusEvent（FocusEvent）替代。
boolean handleEvent(Event evt)
已弃用
从JDK版本1.1替换为processEvent（AWTEvent）。
boolean hasFocus()
如果 Component是焦点所有者，则返回 true 。
void hide()
已弃用
截至JDK 1.1版，由setVisible(boolean)替换。
boolean imageUpdate(Image img, int infoflags, int x, int y, int w, int h)
当图像发生变化时重新编辑组件。
boolean inside(int x, int y)
已弃用
从JDK 1.1版开始，由contains（int，int）替换。
void invalidate()
无效此组件及其祖先。
boolean isBackgroundSet()
返回是否为此组件显式设置了背景颜色。
boolean isCursorSet()
返回是否已经为此组件显式设置了游标。
boolean isDisplayable()
确定此组件是否可显示。
boolean isDoubleBuffered()
如果此组件绘制到稍后复制到屏幕的屏幕外图像（“缓冲区”），则返回true。
boolean isEnabled()
确定是否启用此组件。
boolean isFocusable()
返回是否可以对该Component进行聚焦。
boolean isFocusCycleRoot(Container container)
返回指定的Container是否是此组件焦点遍历周期的焦点循环根。
boolean isFocusOwner()
如果 Component是焦点所有者，则返回 true 。
boolean isFocusTraversable()
已弃用
截至1.4，由isFocusable()取代。
boolean isFontSet()
返回是否已经为此组件显式设置了字体。
boolean isForegroundSet()
返回是否为此组件显式设置了前景色。
boolean isLightweight()
轻量级组件没有本机工具包对等体。
boolean isMaximumSizeSet()
如果最大大小设置为非 null值，则返回true，否则返回false。
boolean isMinimumSizeSet()
返回是否已使用非空值调用 setMinimumSize 。
boolean isOpaque()
如果此组件完全不透明，则返回true，默认情况下返回false。
boolean isPreferredSizeSet()
如果首选大小设置为非 null值，则返回true，否则返回false。
boolean isShowing()
确定此组件是否在屏幕上显示。
boolean isValid()
确定此组件是否有效。
boolean isVisible()
确定当该组件的父级可见时是否应该可见。
boolean keyDown(Event evt, int key)
已弃用
从JDK 1.1版开始，由processKeyEvent（KeyEvent）替换。
boolean keyUp(Event evt, int key)
已弃用
从JDK 1.1版开始，由processKeyEvent（KeyEvent）替换。
void layout()
已弃用
从JDK 1.1版起，换成doLayout() 。
void list()
将此组件的列表打印到标准系统输出流 System.out 。
void list(PrintStream out)
将此组件的列表打印到指定的输出流。
void list(PrintStream out, int indent)
从指定的缩进开始列出指定的打印流的列表。
void list(PrintWriter out)
将列表打印到指定的打印作者。
void list(PrintWriter out, int indent)
从指定的缩进开始列出指定的打印作者的列表。
Component locate(int x, int y)
已弃用
从JDK 1.1版开始，由getComponentAt（int，int）替换。
Point location()
已弃用
截至JDK 1.1版，由getLocation() 。
boolean lostFocus(Event evt, Object what)
已弃用
从JDK 1.1版开始，由processFocusEvent（FocusEvent）替代。
Dimension minimumSize()
已弃用
截至JDK 1.1版，由getMinimumSize()取代。
boolean mouseDown(Event evt, int x, int y)
已弃用
从JDK 1.1版开始，由processMouseEvent（MouseEvent）替换。
boolean mouseDrag(Event evt, int x, int y)
已弃用
从JDK 1.1版开始，由processMouseMotionEvent（MouseEvent）替换。
boolean mouseEnter(Event evt, int x, int y)
已弃用
从JDK 1.1版开始，由processMouseEvent（MouseEvent）替换。
boolean mouseExit(Event evt, int x, int y)
已弃用
从JDK 1.1版开始，由processMouseEvent（MouseEvent）替换。
boolean mouseMove(Event evt, int x, int y)
已弃用
从JDK 1.1版开始，由processMouseMotionEvent（MouseEvent）替换。
boolean mouseUp(Event evt, int x, int y)
已弃用
从JDK 1.1版开始，由processMouseEvent（MouseEvent）替换。
void move(int x, int y)
已弃用
从JDK 1.1版开始，由setLocation(int, int) 。
void nextFocus()
已弃用
从JDK 1.1版开始，由transferFocus（）替换。
void paint(Graphics g)
涂抹这个组件。
void paintAll(Graphics g)
绘制此组件及其所有子组件。
protected String paramString()
返回表示此组件状态的字符串。
boolean postEvent(Event e)
已弃用
从JDK 1.1版开始，由dispatchEvent（AWTEvent）替换。
Dimension preferredSize()
已弃用
截至JDK 1.1版，由getPreferredSize()取代。
boolean prepareImage(Image image, ImageObserver observer)
准备用于在此组件上呈现的图像。
boolean prepareImage(Image image, int width, int height, ImageObserver observer)
准备一个图像，以指定的宽度和高度在此组件上渲染。
void print(Graphics g)
打印此组件。
void printAll(Graphics g)
打印此组件及其所有子组件。
protected void processComponentEvent(ComponentEvent e)
通过将组件事件发送到任何已注册的 ComponentListener对象来处理此组件上发生的组件事件。
protected void processEvent(AWTEvent e)
处理在此组件上发生的事件。
protected void processFocusEvent(FocusEvent e)
通过将其发送到任何已注册的 FocusListener对象来处理发生在此组件上的焦点事件。
protected void processHierarchyBoundsEvent(HierarchyEvent e)
进程层次结构通过将这些事件发送到任何已 HierarchyBoundsListener对象来限制发生在该组件上的事件。
protected void processHierarchyEvent(HierarchyEvent e)
通过将这些组件 HierarchyListener到任何已 HierarchyListener对象来处理此组件上发生的层次结构事件。
protected void processInputMethodEvent(InputMethodEvent e)
通过将此组件发送到任何已 InputMethodListener对象来处理在此组件上发生的输入法事件。
protected void processKeyEvent(KeyEvent e)
通过将这些事件发送到任何已 KeyListener对象来处理在此组件上发生的关键事件。
protected void processMouseEvent(MouseEvent e)
通过将鼠标事件发送到任何已 MouseListener对象来处理此组件上发生的鼠标事件。
protected void processMouseMotionEvent(MouseEvent e)
通过将其分配到任何已 MouseMotionListener对象来处理在此组件上发生的鼠标运动事件。
protected void processMouseWheelEvent(MouseWheelEvent e)
通过将鼠标滚轮事件发送到任何已注册的 MouseWheelListener对象来处理鼠标滚轮事件。
void remove(MenuComponent popup)
从组件中删除指定的弹出菜单。
void removeComponentListener(ComponentListener l)
删除指定的组件侦听器，使其不再从此组件接收组件事件。
void removeFocusListener(FocusListener l)
删除指定的焦点侦听器，使其不再从此组件接收焦点事件。
void removeHierarchyBoundsListener(HierarchyBoundsListener l)
删除指定的层次结构边界监听器，使其不再从该组件接收层次结构限制事件。
void removeHierarchyListener(HierarchyListener l)
删除指定的层次监听器，使其不再从此组件接收层次结构更改的事件。
void removeInputMethodListener(InputMethodListener l)
删除指定的输入法侦听器，使其不再从此组件接收输入法事件。
void removeKeyListener(KeyListener l)
删除指定的密钥侦听器，使其不再从此组件接收密钥事件。
void removeMouseListener(MouseListener l)
删除指定的鼠标监听器，使其不再从此组件接收鼠标事件。
void removeMouseMotionListener(MouseMotionListener l)
删除指定的鼠标移动侦听器，使其不再从此组件接收鼠标移动事件。
void removeMouseWheelListener(MouseWheelListener l)
删除指定的鼠标滚轮侦听器，使其不再从此组件接收鼠标滚轮事件。
void removeNotify()
使这个 Component通过摧毁它本机屏幕资源不可显示。
void removePropertyChangeListener(PropertyChangeListener listener)
从侦听器列表中移除PropertyChangeListener。
void removePropertyChangeListener(String propertyName, PropertyChangeListener listener)
从侦听器列表中删除特定属性的 PropertyChangeListener 。
void repaint()
重新编辑这个组件。
void repaint(int x, int y, int width, int height)
重新绘制该组件的指定矩形。
void repaint(long tm)
重写组件。
void repaint(long tm, int x, int y, int width, int height)
在tm毫秒内 tm绘制该组件的 tm矩形。
void requestFocus()
请求此组件获取输入焦点，并且该组件的顶级祖先成为关注的窗口。
protected boolean requestFocus(boolean temporary)
要求这个 Component得到输入焦点，而这个 Component的顶级祖先成为焦点 Window 。
boolean requestFocusInWindow()
要求此组件获取输入焦点，如果此组件的顶级祖先已经是关注的窗口。
protected boolean requestFocusInWindow(boolean temporary)
要求这个 Component得到输入焦点，如果这个 Component的顶级祖先已经是重点 Window 。
void reshape(int x, int y, int width, int height)
已弃用
从JDK 1.1版开始，由setBounds(int, int, int, int) 。
void resize(Dimension d)
已弃用
从JDK 1.1版开始，由setSize(Dimension) 。
void resize(int width, int height)
已弃用
从JDK 1.1版开始，由setSize(int, int) 。
void revalidate()
将组件层次结构重新验证为最接近的验证根。
void setBackground(Color c)
设置此组件的背景颜色。
void setBounds(int x, int y, int width, int height)
移动并调整此组件的大小。
void setBounds(Rectangle r)
移动并调整此组件的大小以符合新的边界矩形 r 。
void setComponentOrientation(ComponentOrientation o)
设置用于对该组件中的元素或文本进行排序的语言敏感方向。
void setCursor(Cursor cursor)
将光标图像设置为指定的光标。
void setDropTarget(DropTarget dt)
将 DropTarget与此组件关联。
void setEnabled(boolean b)
根据参数 b的值启用或禁用此 b 。
void setFocusable(boolean focusable)
将此组件的可聚焦状态设置为指定的值。
void setFocusTraversalKeys(int id, Set<? extends AWTKeyStroke> keystrokes)
设置此组件给定遍历操作的焦点遍历键。
void setFocusTraversalKeysEnabled(boolean focusTraversalKeysEnabled)
设置是否为此组件启用对焦遍历键。
void setFont(Font f)
设置此组件的字体。
void setForeground(Color c)
设置此组件的前景颜色。
void setIgnoreRepaint(boolean ignoreRepaint)
设置是否忽略从操作系统接收的画面消息。
void setLocale(Locale l)
设置此组件的区域设置。
void setLocation(int x, int y)
将此组件移动到新位置。
void setLocation(Point p)
将此组件移动到新位置。
void setMaximumSize(Dimension maximumSize)
将此组件的最大大小设置为常量值。
void setMinimumSize(Dimension minimumSize)
将此组件的最小大小设置为常量值。
void setName(String name)
将组件的名称设置为指定的字符串。
void setPreferredSize(Dimension preferredSize)
将此组件的首选大小设置为常量值。
void setSize(Dimension d)
调整此组件的大小，使其宽度为 d.width ，高度为 d.height 。
void setSize(int width, int height)
调整此组件的大小，使其宽度为 width ，高度为 height 。
void setVisible(boolean b)
根据参数b的值显示或隐藏此 b 。
void show()
已弃用
从JDK 1.1版开始，由setVisible(boolean) 。
void show(boolean b)
已弃用
从JDK 1.1版开始，由setVisible(boolean) 。
Dimension size()
已弃用
截至JDK 1.1版，由getSize() 。
String toString()
返回此组件及其值的字符串表示形式。
void transferFocus()
将焦点转移到下一个组件，就像这个组件是焦点所有者一样。
void transferFocusBackward()
将焦点转移到以前的组件，就像这个组件是焦点所有者一样。
void transferFocusUpCycle()
将焦点转移到一个焦点遍历周期。
void update(Graphics g)
更新此组件。
void validate()
验证此组件。

3.Frame

A Frame是一个标题和边框的顶级窗口。
框架的大小包括为边框指定的任何区域。 可以使用getInsets方法获得边界区域的getInsets ，但是由于这些尺寸与平台相关，因此无法通过调用pack或show显示框架，才能获得有效的插入值。 由于边框区域被包含在框架的整体尺寸中，所以边框有效地掩盖了框架的一部分，限制了可用于渲染和/或显示子组件的区域到左上角位置为(insets.left, insets.top) ，以及具有width - (insets.left + insets.right)的height - (insets.top + insets.bottom) 。

构造方法：

Frame()
构造的新实例 Frame初始时不可见。
Frame(GraphicsConfiguration gc)
构造一个新的，最初看不见的 Frame与指定的 GraphicsConfiguration 。
Frame(String title)
构造一个新的，最初不可见的 Frame对象，其中包含指定的标题。
Frame(String title, GraphicsConfiguration gc)
构造一个新的，最初不可见的 Frame对象，具有指定的标题和一个 GraphicsConfiguration 。

方法：

void addNotify()
通过将此框架连接到本机屏幕资源来使此框架可以显示。
AccessibleContext getAccessibleContext()
获取与此Frame相关联的AccessibleContext。
int getCursorType()
已弃用
从JDK 1.1版开始，由Component.getCursor() 。
int getExtendedState()
获取此框架的状态。
static Frame[] getFrames()
返回 Frame创建的所有 Frame的数组。
Image getIconImage()
返回要显示的图像作为此框架的图标。
Rectangle getMaximizedBounds()
获得此框架的最大化边界。
MenuBar getMenuBar()
获取此框架的菜单栏。
int getState()
获取此框架的状态（已过时）。
String getTitle()
获取框架的标题。
boolean isResizable()
指示该框架是否可由用户调整大小。
boolean isUndecorated()
指示此框架是否未装饰。
protected String paramString()
返回一个表示此 Frame状态的字符串。
void remove(MenuComponent m)
从此框架中删除指定的菜单栏。
void removeNotify()
通过删除其与其本机屏幕资源的连接，使此框架不可显示。
void setBackground(Color bgColor)
设置此窗口的背景颜色。
void setCursor(int cursorType)
已弃用
从JDK 1.1版开始，由Component.setCursor(Cursor) 。
void setExtendedState(int state)
设置此帧的状态。
void setIconImage(Image image)
将要显示的图像设置为此窗口的图标。
void setMaximizedBounds(Rectangle bounds)
设置此框架的最大化边界。
void setMenuBar(MenuBar mb)
将此框架的菜单栏设置为指定的菜单栏。
void setOpacity(float opacity)
设置窗口的不透明度。
void setResizable(boolean resizable)
设置该框架是否可以由用户调整大小。
void setShape(Shape shape)
设置窗口的形状。
void setState(int state)
设置此框架的状态（已过时）。
void setTitle(String title)
将此框架的标题设置为指定的字符串。
void setUndecorated(boolean undecorated)
禁用或启用此框架的装饰。

4. WindowAdapter

public abstract class WindowAdapter
extends Object
implements WindowListener, WindowStateListener, WindowFocusListener
用于接收窗口事件的抽象适配器类。

方法：
void windowActivated(WindowEvent e)
激活窗口时调用。
void windowClosed(WindowEvent e)
当窗口关闭时调用。
void windowClosing(WindowEvent e)
当窗口处于关闭状态时调用。
void windowDeactivated(WindowEvent e)
当窗口被禁用时调用。
void windowDeiconified(WindowEvent e)
当窗口被去图标化时调用。
void windowGainedFocus(WindowEvent e)
当窗口设置为聚焦窗口时调用，这意味着窗口或其子组件之一将接收键盘事件。
void windowIconified(WindowEvent e)
当窗口被图标化时调用。
void windowLostFocus(WindowEvent e)
当窗口不再是聚焦窗口时调用，这意味着键盘事件将不再传递到窗口或其任何子组件。
void windowOpened(WindowEvent e)
当窗口打开时调用。
void windowStateChanged(WindowEvent e)
当窗口状态改变时调用。

案例1：窗体关闭案例

public class WindowClose {
	public static void main(String[] args) {
		Frame f = new Frame();
		f.setBounds(500, 500,400,300);
		f.setVisible(true);
		f.addWindowListener(new WindowAdapter(){			
			public void windowClosing(WindowEvent e){
				System.exit(0);
			}			
		});
	}
}

5. TextField 文本框
TextField对象是允许编辑单行文本的文本组件。

构造方法：

TextField()
构造一个新的文本字段。
TextField(int columns)
构造具有指定列数的新的空文本字段。
TextField(String text)
构造一个使用指定文本初始化的新文本字段。
TextField(String text, int columns)
构造一个新的文本字段，并使用指定的文本进行初始化，以便显示，并且足够宽以容纳指定的列数。

方法：
void addActionListener(ActionListener l)
添加指定的动作侦听器以从此文本字段接收动作事件。
void addNotify()
创建TextField的对等体。
boolean echoCharIsSet()
指示此文本字段是否具有用于回显的字符集。
AccessibleContext getAccessibleContext()
获取与此TextField关联的AccessibleContext。
ActionListener[] getActionListeners()
返回在此文本域中注册的所有操作侦听器的数组。
int getColumns()
获取此文本字段中的列数。
char getEchoChar()
获取要用于回显的字符。

T[] getListeners(类 listenerType)
返回当前注册的所有对象的数组 FooListener在这个S TextField 。
Dimension getMinimumSize()
获取此文本字段的最小尺寸。
Dimension getMinimumSize(int columns)
获取具有指定列数的文本字段的最小尺寸。
Dimension getPreferredSize()
获取此文本字段的首选大小。
Dimension getPreferredSize(int columns)
使用指定的列数获取此文本字段的首选大小。
Dimension minimumSize()
已弃用
从JDK 1.1版开始，替换为getMinimumSize() 。
Dimension minimumSize(int columns)
已弃用
截至JDK 1.1版，由getMinimumSize(int) 。
protected String paramString()
返回表示此 TextField的状态的字符串。
Dimension preferredSize()
已弃用
从JDK 1.1版开始，由getPreferredSize() 。
Dimension preferredSize(int columns)
已弃用
截至JDK 1.1版，由getPreferredSize(int) 。
protected void processActionEvent(ActionEvent e)
通过将这些事件发送到任何已注册的 ActionListener对象来处理在此文本字段上发生的操作事件。
protected void processEvent(AWTEvent e)
处理此文本字段上的事件。
void removeActionListener(ActionListener l)
删除指定的动作监听器，使其不再从此文本字段接收到动作事件。
void setColumns(int columns)
设置此文本字段中的列数。
void setEchoChar(char c)
设置此文本字段的回音字符。
void setEchoCharacter(char c)
已弃用
从JDK 1.1版开始，替换为setEchoChar(char) 。
void setText(String t)
将此文本组件呈现的文本设置为指定的文本。

6. TextArea文本域

TextArea对象是显示文本的多行区域。 它可以设置为允许编辑或只读。

构造方法：

TextArea()
构造一个新的文本区域，空字符串作为文本。
TextArea(int rows, int columns)
构造具有指定行数和列数的新文本区域，空字符串作为文本。
TextArea(String text)
构造具有指定文本的新文本区域。
TextArea(String text, int rows, int columns)
构造具有指定文本的新文本区域，并具有指定的行数和列数。
TextArea(String text, int rows, int columns, int scrollbars)
构造具有指定文本的新文本区域，并按照指定的行，列和滚动条可见性构造。

方法：

void addNotify()
创建 TextArea的同伴。
void append(String str)
将给定的文本附加到文本区域的当前文本。
void appendText(String str)
已弃用
截至JDK 1.1版，由append(String)取代。
AccessibleContext getAccessibleContext()
返回 AccessibleContext与此相关 TextArea 。
int getColumns()
返回此文本区域中的列数。
Dimension getMinimumSize()
确定此文本区域的最小大小。
Dimension getMinimumSize(int rows, int columns)
确定具有指定行数和列数的文本区域的最小大小。
Dimension getPreferredSize()
确定此文本区域的首选大小。
Dimension getPreferredSize(int rows, int columns)
确定具有指定行数和列数的文本区域的首选大小。
int getRows()
返回文本区域中的行数。
int getScrollbarVisibility()
返回枚举值，指示文本区域使用的滚动条。
void insert(String str, int pos)
在此文本区域的指定位置插入指定的文本。
void insertText(String str, int pos)
已弃用
截至JDK 1.1版，由insert(String, int)取代。
Dimension minimumSize()
已弃用
截至JDK 1.1版，由getMinimumSize()取代。
Dimension minimumSize(int rows, int columns)
已弃用
从JDK 1.1版开始，替换为getMinimumSize(int, int) 。
protected String paramString()
返回一个表示此 TextArea状态的字符串。
Dimension preferredSize()
已弃用
从JDK 1.1版开始，由getPreferredSize() 。
Dimension preferredSize(int rows, int columns)
已弃用
从JDK 1.1版开始，由getPreferredSize(int, int)替换。
void replaceRange(String str, int start, int end)
将指定的开始和结束位置之间的文本替换为指定的替换文本。
void replaceText(String str, int start, int end)
已弃用
截至JDK 1.1版，由replaceRange(String, int, int) 。
void setColumns(int columns)
设置此文本区域的列数。
void setRows(int rows)
设置此文本区域的行数。

案例1.将文本框中输入的文字转移到文本域中并自动换行

public class AddButton {
	public static void main(String[] args) {
		Frame f = new Frame();
		f.setBounds(500,500,400,200);
		final TextField t1= new TextField(20);
		Button b = new Button("转移文字");
		final TextArea ta = new TextArea(40,30);
		f.setLayout(new FlowLayout());
		f.setVisible(true);
		f.add(t1);
		f.add(b);
		f.add(ta);
		f.addWindowListener(new WindowAdapter(){

			@Override
			public void windowClosing(WindowEvent e) {
				System.exit(0);
			}
		
		});
		b.addActionListener(new ActionListener() {
			
			@Override
			public void actionPerformed(ActionEvent e) {
				String s = t1.getText();
				ta.append(s+"\r\n");
				t1.setText("");
				t1.requestFocus();
			}
		});
		
	}
}

7. MouseAdapter
public abstract class MouseAdapter
extends Object
implements MouseListener, MouseWheelListener, MouseMotionListener

用于接收鼠标事件的抽象适配器类。 这个类中的方法是空的。 此类作为创建侦听器对象的方便而存在。

方法：

void mouseClicked(MouseEvent e)
在组件上单击（按下并释放）鼠标按钮时调用。
void mouseDragged(MouseEvent e)
在组件上按下鼠标按钮然后拖动时调用。
void mouseEntered(MouseEvent e)
当鼠标进入组件时调用。
void mouseExited(MouseEvent e)
当鼠标退出组件时调用。
void mouseMoved(MouseEvent e)
当鼠标光标移动到组件上但没有按钮被按下时调用。
void mousePressed(MouseEvent e)
在组件上按下鼠标按钮时调用。
void mouseReleased(MouseEvent e)
在组件上释放鼠标按钮时调用。
void mouseWheelMoved(MouseWheelEvent e)
当鼠标滚轮旋转时调用。

案例：通过鼠标在按钮上的移动变换窗体颜色

9. Color
Color类用于将颜色封装在默认的sRGB颜色空间中或由ColorSpace标识的任意颜色空间中的颜色 。

成员变量：
static Color black
颜色黑色。
static Color BLACK
颜色黑色。
static Color blue
颜色蓝色。
static Color BLUE
颜色蓝色。
static Color cyan
颜色青色。
static Color CYAN
颜色青色。
static Color DARK_GRAY
颜色深灰色。
static Color darkGray
颜色深灰色。
static Color gray
颜色灰色。
static Color GRAY
颜色灰色。
static Color green
颜色绿色。
static Color GREEN
颜色绿色。
static Color LIGHT_GRAY
颜色浅灰色。
static Color lightGray
颜色浅灰色。
static Color magenta
颜色洋红色。
static Color MAGENTA
颜色洋红色。
static Color orange
颜色橙色。
static Color ORANGE
颜色橙色。
static Color pink
颜色粉红色。
static Color PINK
颜色粉红色。
static Color red
颜色红色。
static Color RED
颜色红色。
static Color white
颜色白色。
static Color WHITE
颜色白色。
static Color yellow
颜色黄色。
static Color YELLOW
颜色黄色。

public class ChangeColor {
	public static void main(String[] args) {
		final Frame f = new Frame();
		f.setBounds(500,500,400,300);
		f.setVisible(true);
		f.setLayout(new FlowLayout());
		Button b1 = new Button("变粉");		
		Button b2 = new Button("变蓝");
		Button b3 = new Button("变绿");
		f.add(b1);
		f.add(b2);
		f.add(b3);
		f.addWindowListener(new WindowAdapter(){

			@Override
			public void windowClosing(WindowEvent e) {
				System.exit(0);
			}

		});
		
		b1.addMouseListener(new MouseAdapter(){

			@Override
			public void mouseEntered(MouseEvent e) {
				f.setBackground(Color.PINK);
			}

			@Override
			public void mouseExited(MouseEvent e) {
				f.setBackground(Color.WHITE);
			}
			
		});	
		
		b2.addMouseListener(new MouseAdapter(){

			@Override
			public void mouseEntered(MouseEvent e) {
				f.setBackground(Color.GREEN);
			}

			@Override
			public void mouseExited(MouseEvent e) {
				f.setBackground(Color.WHITE);
			}
			
		});	
		
		b3.addMouseListener(new MouseAdapter(){

			@Override
			public void mouseEntered(MouseEvent e) {
				f.setBackground(Color.BLUE);
			}

			@Override
			public void mouseExited(MouseEvent e) {
				f.setBackground(Color.WHITE);
			}
			
		});	
	}
}

10. KeyAdapter
public abstract class KeyAdapter
extends Object
implements KeyListener

用于接收键盘事件的抽象适配器类。 这个类中的方法是空的。 此类作为创建侦听器对象的方便而存在。

方法：
void keyPressed(KeyEvent e)
按下键时调用。
void keyReleased(KeyEvent e)
当键已被释放时调用。
void keyTyped(KeyEvent e)
键入键时调用。

11.MenuBar

MenuBar类封装了平台与框架绑定的菜单栏的概念。 为了将菜单栏与Frame对象相关联，请调用框架的setMenuBar方法。

构造方法 ：

MenuBar()
创建一个新的菜单栏。

方法：
Menu add(Menu m)
将指定的菜单添加到菜单栏。
void addNotify()
创建菜单栏的对等体。
int countMenus()
已弃用
从JDK 1.1版开始，由getMenuCount() 。
void deleteShortcut(MenuShortcut s)
删除指定的菜单快捷方式。
AccessibleContext getAccessibleContext()
获取与此MenuBar关联的AccessibleContext。
Menu getHelpMenu()
获取菜单栏上的帮助菜单。
Menu getMenu(int i)
获取指定的菜单。
int getMenuCount()
获取菜单栏上的菜单数量。
MenuItem getShortcutMenuItem(MenuShortcut s)
获取的实例 MenuItem与指定相关 MenuShortcut的对象，或 null如果被管理没有菜单项的通过该菜单栏与指定的菜单快捷方式有关。
void remove(int index)
从此菜单栏中删除位于指定索引处的菜单。
void remove(MenuComponent m)
从此菜单栏中删除指定的菜单组件。
void removeNotify()
删除菜单栏的对等体。
void setHelpMenu(Menu m)
将指定的菜单设置为此菜单栏的帮助菜单。
Enumeration shortcuts()
获取此菜单栏正在管理的所有菜单快捷方式的枚举。

12. Menu
public class Menu
extends MenuItem
implements MenuContainer, AccessibleMenu对象是从菜单栏部署的下拉菜单组件。

构造方法 :

Menu()
构造一个带有空标签的新菜单。
Menu(String label)
构造一个带有指定标签的新菜单。
Menu(String label, boolean tearOff)
构造具有指定标签的新菜单，指示菜单是否可以被拆除。

方法：
MenuItem add(MenuItem mi)
将指定的菜单项添加到此菜单。
void add(String label)
将具有指定标签的项目添加到此菜单。
void addNotify()
创建菜单的对等体。
void addSeparator()
在当前位置的菜单中添加分隔线或连字符。
int countItems()
已弃用
从JDK 1.1版开始，替换为getItemCount() 。
AccessibleContext getAccessibleContext()
获取与此菜单关联的AccessibleContext。
MenuItem getItem(int index)
获取位于此菜单的指定索引处的项目。
int getItemCount()
获取此菜单中的项目数量。
void insert(MenuItem menuitem, int index)
在指定位置的菜单中插入菜单项。
void insert(String label, int index)
在指定位置的菜单中插入带有指定标签的菜单项。
void insertSeparator(int index)
在指定位置插入分隔符。
boolean isTearOff()
指示此菜单是否为撕纸菜单。
String paramString()
返回表示此 Menu的状态的字符串。
void remove(int index)
从此菜单中删除指定索引处的菜单项。
void remove(MenuComponent item)
从此菜单中删除指定的菜单项。
void removeAll()
从此菜单中删除所有项目。
void removeNotify()
删除菜单的对等体。

13. MenuItem
public class MenuItem
extends MenuComponent
implements Accessible菜单中的所有项目必须属于类别MenuItem或其子类之一。

构造方法 ：

MenuItem()
构造一个带有空标签的新菜单项，而不需要键盘快捷方式。
MenuItem(String label)
使用指定的标签构建一个新的MenuItem，而不需要键盘快捷方式。
MenuItem(String label, MenuShortcut s)
创建一个带有相关键盘快捷方式的菜单项。

方法：
void addActionListener(ActionListener l)
添加指定的动作侦听器以从该菜单项接收动作事件。
void addNotify()
创建菜单项的对等体。
void deleteShortcut()
删除与此菜单项相关联的任何 MenuShortcut对象。
void disable()
已弃用
从JDK 1.1版开始，由setEnabled(boolean) 。
protected void disableEvents(long eventsToDisable)
禁用由指定事件掩码参数定义的事件的此菜单项的事件传递。
void enable()
已弃用
截至JDK 1.1版，由setEnabled(boolean) 。
void enable(boolean b)
已弃用
从JDK 1.1版开始，替换为setEnabled(boolean) 。
protected void enableEvents(long eventsToEnable)
启用事件传递到此菜单项，以指定事件掩码参数定义的事件
AccessibleContext getAccessibleContext()
获取与此MenuItem关联的AccessibleContext。
String getActionCommand()
获取此菜单项触发的操作事件的命令名称。
ActionListener[] getActionListeners()
返回在此菜单项上注册的所有动作侦听器的数组。
String getLabel()
获取此菜单项的标签。

T[] getListeners(类 listenerType)
返回当前注册为 FooListener的所有对象的数组，此 MenuItem 。
MenuShortcut getShortcut()
获取与 MenuShortcut对象，
boolean isEnabled()
检查此菜单项是否启用。
String paramString()
返回表示此 MenuItem的状态的字符串。
protected void processActionEvent(ActionEvent e)
通过将这些事件发送到任何已注册的 ActionListener对象来处理 ActionListener单项上发生的操作事件。
protected void processEvent(AWTEvent e)
处理此菜单项上的事件。
void removeActionListener(ActionListener l)
删除指定的动作监听器，使其不再从此菜单项接收动作事件。
void setActionCommand(String command)
设置此菜单项触发的操作事件的命令名称。
void setEnabled(boolean b)
设置是否可以选择此菜单项。
void setLabel(String label)
将此菜单项的标签设置为指定的标签。
void setShortcut(MenuShortcut s)
设置与 MenuShortcut对象。

14.Runtime
public class Runtime
extends Object

方法：

void addShutdownHook(Thread hook)
注册一个新的虚拟机关机挂钩。
int availableProcessors()
返回可用于Java虚拟机的处理器数量。
Process exec(String command)
在单独的进程中执行指定的字符串命令。
Process exec(String[] cmdarray)
在单独的进程中执行指定的命令和参数。
Process exec(String[] cmdarray, String[] envp)
在指定环境的单独进程中执行指定的命令和参数。
Process exec(String[] cmdarray, String[] envp, File dir)
在指定的环境和工作目录的单独进程中执行指定的命令和参数。
Process exec(String command, String[] envp)
在具有指定环境的单独进程中执行指定的字符串命令。
Process exec(String command, String[] envp, File dir)
在指定的环境和工作目录的单独进程中执行指定的字符串命令。
void exit(int status)
通过启动其关闭序列来终止当前正在运行的Java虚拟机。
long freeMemory()
返回Java虚拟机中的可用内存量。
void gc()
运行垃圾回收器。
InputStream getLocalizedInputStream(InputStream in)
已弃用
从JDK 1.1开始，将本地编码中的字节流转换为Unicode中的字符流的首选方法是通过InputStreamReader和BufferedReader类。
OutputStream getLocalizedOutputStream(OutputStream out)
已弃用
从JDK 1.1，将Unicode字符流转换为本地编码字节流的首选方法是通过OutputStreamWriter ， BufferedWriter和PrintWriter类。
static Runtime getRuntime()
返回与当前Java应用程序关联的运行时对象。
void halt(int status)
强制终止当前正在运行的Java虚拟机。
void load(String filename)
加载由filename参数指定的本机库。
void loadLibrary(String libname)
加载由 libname参数指定的本机库。
long maxMemory()
返回Java虚拟机将尝试使用的最大内存量。
boolean removeShutdownHook(Thread hook)
取消注册以前注册的虚拟机关闭挂接。
void runFinalization()
运行任何对象等待定稿的最终化方法。
static void runFinalizersOnExit(boolean value)
已弃用
这种方法本质上是不安全的。 它可能导致在活动对象上调用finalizer，而其他线程同时操作这些对象，导致不稳定的行为或死锁。
long totalMemory()
返回Java虚拟机中的内存总量。
void traceInstructions(boolean on)
启用/禁用指令的跟踪。
void traceMethodCalls(boolean on)
启用/禁用方法调用的跟踪。

案例：添加菜单

public class AddMenu {
	public static void main(String[] args) {
		final Frame f = new Frame();
		f.setBounds(500,500,400,200);
		final String title = "文件管理器";
		f.setTitle(title);
		f.setLayout(new FlowLayout());
		f.setVisible(true);
		MenuBar mb = new MenuBar();
		Menu m = new Menu("文件");
		Menu subm = new Menu("更改名称");
		MenuItem mi01 = new MenuItem("打开记事本");
		MenuItem mi02 = new MenuItem("退出系统");
		final MenuItem submi01 = new MenuItem("hello");
		final MenuItem submi02 = new MenuItem("world");
		final MenuItem submi03 = new MenuItem("恢复名称");
		subm.add(submi01);
		subm.add(submi02);
		subm.add(submi03);
		m.add(subm);
		m.add(mi01);
		m.add(mi02);
		mb.add(m);
		f.setMenuBar(mb);
		f.addWindowListener(new WindowAdapter(){

			@Override
			public void windowClosing(WindowEvent e) {
				System.exit(0);
			}
			
		});
		
		submi01.addActionListener(new ActionListener(){

			@Override
			public void actionPerformed(ActionEvent e) {
			 String s = submi01.getLabel().toString();
			 f.setTitle(s);
				
			}
			
		});
		
		submi02.addActionListener(new ActionListener(){

			@Override
			public void actionPerformed(ActionEvent e) {
			 String s = submi02.getLabel().toString();
			 f.setTitle(s);
				
			}
			
		});
		
		submi03.addActionListener(new ActionListener(){

			@Override
			public void actionPerformed(ActionEvent e) {
			 f.setTitle(title);
				
			}
			
		});
		
		mi01.addActionListener(new ActionListener(){

			@Override
			public void actionPerformed(ActionEvent e) {
				Runtime r= Runtime.getRuntime();
				try {
					r.exec("notepad");
				} catch (IOException e1) {
					// TODO Auto-generated catch block
					e1.printStackTrace();
				}
				
			}
			
		});
		
		mi02.addActionListener(new ActionListener(){
			@Override
			public void actionPerformed(ActionEvent e) {				
				System.exit(0);
			}
		});
	}
}

14. JOptionPane
JOptionPane可以轻松地弹出一个标准对话框，提示用户获取值或通知他们某些东西。

构造方法:

JOptionPane()
创建一个带有测试消息的 JOptionPane 。
JOptionPane(Object message)
创建一个 JOptionPane的实例，使用简单消息消息类型和UI传递的默认选项来显示消息。
JOptionPane(Object message, int messageType)
创建一个 JOptionPane的实例以显示具有指定消息类型和默认选项的消息，
JOptionPane(Object message, int messageType, int optionType)
创建一个 JOptionPane的实例以显示具有指定消息类型和选项的消息。
JOptionPane(Object message, int messageType, int optionType, Icon icon)
创建一个 JOptionPane的实例以显示具有指定消息类型，选项和图标的消息。
JOptionPane(Object message, int messageType, int optionType, Icon icon, Object[] options)
创建一个 JOptionPane的实例以显示具有指定消息类型，图标和选项的消息。
JOptionPane(Object message, int messageType, int optionType, Icon icon, Object[] options, Object initialValue)
创建一个 JOptionPane的实例以显示具有指定消息类型，图标和选项的消息，并指定最初选择的选项。

方法：

JDialog createDialog(Component parentComponent, String title)
创建并返回一个新的 JDialog封装 this集中在 parentComponent的框架上的 parentComponent 。
JDialog createDialog(String title)
创建并返回具有指定标题的新的无 JDialog JDialog。
JInternalFrame createInternalFrame(Component parentComponent, String title)
创建并返回一个 JInternalFrame的实例。
AccessibleContext getAccessibleContext()
返回 AccessibleContext与此相关的JOptionPane。
static JDesktopPane getDesktopPaneForComponent(Component parentComponent)
返回指定组件的桌面窗格。
static Frame getFrameForComponent(Component parentComponent)
返回指定的组件的 Frame 。
Icon getIcon()
返回此窗格显示的图标。
Object getInitialSelectionValue()
返回最初显示为用户的输入值。
Object getInitialValue()
返回初始值。
Object getInputValue()
返回用户输入的值，如果 wantsInput为真。
int getMaxCharactersPerLineCount()
返回在消息中放置在行上的最大字符数。
Object getMessage()
返回窗格显示的消息对象。
int getMessageType()
返回消息类型。
Object[] getOptions()
返回用户可以做出的选择。
int getOptionType()
返回显示的选项类型。
static Frame getRootFrame()
返回用于不提供框架的类方法的 Frame 。
Object[] getSelectionValues()
返回输入选择值。
OptionPaneUI getUI()
返回实现该组件的L＆F的UI对象。
String getUIClassID()
返回实现该组件的L＆F的UI类的名称。
Object getValue()
返回用户选择的值。
boolean getWantsInput()
返回 wantsInput属性的值。
protected String paramString()
返回此 JOptionPane的字符串表示 JOptionPane 。
void selectInitialValue()
请求选择初始值，将其设置为初始值。
void setIcon(Icon newIcon)
设置要显示的图标。
void setInitialSelectionValue(Object newValue)
将最初显示为选定的输入值设置为用户。
void setInitialValue(Object newInitialValue)
设置要启用的初始值 - Component显示窗格时具有焦点的Component。
void setInputValue(Object newValue)
设置用户选择或输入的输入值。
void setMessage(Object newMessage)
设置选项窗格的消息对象。
void setMessageType(int newType)
设置选项窗格的消息类型。
void setOptions(Object[] newOptions)
设置该窗格显示的选项。
void setOptionType(int newType)
设置要显示的选项。
static void setRootFrame(Frame newRootFrame)
将框架设置为不提供框架的类方法。
void setSelectionValues(Object[] newValues)
设置为用户提供可供选择的项目列表的窗格的输入选择值。
void setUI(OptionPaneUI ui)
设置实现该组件的L＆F的UI对象。
void setValue(Object newValue)
设置用户选择的值。
void setWantsInput(boolean newValue)
设置 wantsInput属性。
static int showConfirmDialog(Component parentComponent, Object message)
启动对话框，选择是 ， 否和取消 ; 标题为“选择选项” 。
static int showConfirmDialog(Component parentComponent, Object message, String title, int optionType)
提出一个对话框，其中选择的数量由 optionType参数确定。
static int showConfirmDialog(Component parentComponent, Object message, String title, int optionType, int messageType)
提出一个对话框，其中选择次数由 optionType参数确定，其中 messageType参数确定要显示的图标。
static int showConfirmDialog(Component parentComponent, Object message, String title, int optionType, int messageType, Icon icon)
启动一个带有指定图标的对话框，其中选项数由 optionType参数决定。
static String showInputDialog(Component parentComponent, Object message)
显示了一个问题消息对话框，要求从父用户输入 parentComponent 。
static String showInputDialog(Component parentComponent, Object message, Object initialSelectionValue)
显示一个问题消息对话框，请求用户输入并 parentComponent为 parentComponent 。
static String showInputDialog(Component parentComponent, Object message, String title, int messageType)
示出了从父给用户一个对话框，要求输入 parentComponent与具有标题的对话框 title和消息类型 messageType 。
static Object showInputDialog(Component parentComponent, Object message, String title, int messageType, Icon icon, Object[] selectionValues, Object initialSelectionValue)
在阻止对话框中提示用户输入，可以指定初始选择，可能的选择和所有其他选项。
static String showInputDialog(Object message)
显示一个请求用户输入的问题消息对话框。
static String showInputDialog(Object message, Object initialSelectionValue)
显示询问消息对话框，请求用户输入，输入值初始化为 initialSelectionValue 。
static int showInternalConfirmDialog(Component parentComponent, Object message)
启动一个内部对话面板，选择是 ， 否和取消 ; 标题为“选择选项” 。
static int showInternalConfirmDialog(Component parentComponent, Object message, String title, int optionType)
启动一个内部对话面板，其中选择次数由 optionType参数决定。
static int showInternalConfirmDialog(Component parentComponent, Object message, String title, int optionType, int messageType)
启动内部对话面板，其中选择次数由 optionType参数确定，其中 messageType参数确定要显示的图标。
static int showInternalConfirmDialog(Component parentComponent, Object message, String title, int optionType, int messageType, Icon icon)
启动具有指定图标的内部对话面板，其中选择数由 optionType参数决定。
static String showInternalInputDialog(Component parentComponent, Object message)
示出了一个内部问题消息对话框请求来自父于用户输入 parentComponent 。
static String showInternalInputDialog(Component parentComponent, Object message, String title, int messageType)
示出了从父给用户的内部对话框请求输入 parentComponent与具有标题的对话框 title和消息类型 messageType 。
static Object showInternalInputDialog(Component parentComponent, Object message, String title, int messageType, Icon icon, Object[] selectionValues, Object initialSelectionValue)
在阻止内部对话框中提示输入用户，可以指定初始选择，可能的选择和所有其他选项。
static void showInternalMessageDialog(Component parentComponent, Object message)
启动内部确认对话框面板。
static void showInternalMessageDialog(Component parentComponent, Object message, String title, int messageType)
启动内部对话面板，使用由 messageType参数确定的默认图标显示消息。
static void showInternalMessageDialog(Component parentComponent, Object message, String title, int messageType, Icon icon)
启动一个显示消息的内部对话框面板，指定所有参数。
static int showInternalOptionDialog(Component parentComponent, Object message, String title, int optionType, int messageType, Icon icon, Object[] options, Object initialValue)
启动具有指定图标的内部对话面板，其中初始选择由 initialValue参数确定，选择次数由 optionType参数确定。
static void showMessageDialog(Component parentComponent, Object message)
提供一个名为“消息”的信息消息对话框。
static void showMessageDialog(Component parentComponent, Object message, String title, int messageType)
使用由 messageType参数确定的默认图标显示消息的对话框。
static void showMessageDialog(Component parentComponent, Object message, String title, int messageType, Icon icon)
显示一个显示消息的对话框，指定所有参数。
static int showOptionDialog(Component parentComponent, Object message, String title, int optionType, int messageType, Icon icon, Object[] options, Object initialValue)
启动具有指定图标的对话框，其中初始选择由 initialValue参数确定，选择次数由 optionType参数确定。
void updateUI()
从通知 UIManager的L＆F已经更改。

案例：用NetBeans实现计算器案例

/*
 * To change this license header, choose License Headers in Project Properties.
 * To change this template file, choose Tools | Templates
 * and open the template in the editor.
 */

package newpackageUI;

import java.awt.Dimension;
import java.awt.Image;
import java.awt.Toolkit;
import javax.swing.JFrame;
import newpackagegui.NewJFrame;

/**
 *
 * @author Administrator
 */
public class CALUI {
    
    public static void setIcon(JFrame njf){
        Toolkit tk = Toolkit.getDefaultToolkit();
        Image i = tk.getImage("src\\newpackagesrc\\timg.jpg");
        njf.setIconImage(i);
    }
    
    public static void setWindowBackground(JFrame jf){
        Toolkit tk = Toolkit.getDefaultToolkit();
       
    }
    
    public static void setWindowCenter(JFrame jf){
        Toolkit tk = Toolkit.getDefaultToolkit();
        Dimension d = tk.getScreenSize();
        double screenWidth = d.getWidth();        
        double screenHeight = d.getHeight();
        int jfWidth = jf.getWidth();
        int jfHeight = jf.getHeight();
        int x = (int)(screenWidth- jfWidth)/2;
        int y = (int)(screenHeight- jfHeight)/2;
        jf.setLocation(x,y);
    }
    
    
}
    

package newpackagegui;

import javax.swing.JOptionPane;
import newpackageUI.CALUI;

/**
 *
 * @author Administrator
 */
public class NewJFrame extends javax.swing.JFrame {

    /**
     * Creates new form NewJFrame
     */
    public NewJFrame() {
        initComponents();
        init();
    }

    /**
     * This method is called from within the constructor to initialize the form.
     * WARNING: Do NOT modify this code. The content of this method is always
     * regenerated by the Form Editor.
     */
    @SuppressWarnings("unchecked")
    // <editor-fold defaultstate="collapsed" desc="Generated Code">                          
    private void initComponents() {

        buttonGroup1 = new javax.swing.ButtonGroup();
        jLabel1 = new javax.swing.JLabel();
        jLabel2 = new javax.swing.JLabel();
        jLabel3 = new javax.swing.JLabel();
        jTextField1 = new javax.swing.JTextField();
        jTextField2 = new javax.swing.JTextField();
        jComboBox1 = new javax.swing.JComboBox();
        jTextField3 = new javax.swing.JTextField();
        jLabel4 = new javax.swing.JLabel();
        jButton1 = new javax.swing.JButton();

        setDefaultCloseOperation(javax.swing.WindowConstants.EXIT_ON_CLOSE);

        jLabel1.setText("操作数1");

        jLabel2.setText("操作数2");

        jLabel3.setText("计算结果");

        jTextField1.addActionListener(new java.awt.event.ActionListener() {
            public void actionPerformed(java.awt.event.ActionEvent evt) {
                jTextField1ActionPerformed(evt);
            }
        });

        jComboBox1.setModel(new javax.swing.DefaultComboBoxModel(new String[] { "+", "-", "*", "/" }));
        jComboBox1.addPopupMenuListener(new javax.swing.event.PopupMenuListener() {
            public void popupMenuCanceled(javax.swing.event.PopupMenuEvent evt) {
            }
            public void popupMenuWillBecomeInvisible(javax.swing.event.PopupMenuEvent evt) {
            }
            public void popupMenuWillBecomeVisible(javax.swing.event.PopupMenuEvent evt) {
                jComboBox1PopupMenuWillBecomeVisible(evt);
            }
        });
        jComboBox1.addActionListener(new java.awt.event.ActionListener() {
            public void actionPerformed(java.awt.event.ActionEvent evt) {
                jComboBox1ActionPerformed(evt);
            }
        });

        jTextField3.setEditable(false);

        jLabel4.setText("=");

        jButton1.setText("计算");
        jButton1.addActionListener(new java.awt.event.ActionListener() {
            public void actionPerformed(java.awt.event.ActionEvent evt) {
                jButton1ActionPerformed(evt);
            }
        });

        javax.swing.GroupLayout layout = new javax.swing.GroupLayout(getContentPane());
        getContentPane().setLayout(layout);
        layout.setHorizontalGroup(
            layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
            .addGroup(javax.swing.GroupLayout.Alignment.TRAILING, layout.createSequentialGroup()
                .addGap(19, 19, 19)
                .addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignment.TRAILING)
                    .addComponent(jLabel1)
                    .addComponent(jTextField1, javax.swing.GroupLayout.PREFERRED_SIZE, 54, javax.swing.GroupLayout.PREFERRED_SIZE))
                .addGap(47, 47, 47)
                .addComponent(jComboBox1, javax.swing.GroupLayout.PREFERRED_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.PREFERRED_SIZE)
                .addGap(40, 40, 40)
                .addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
                    .addComponent(jLabel2)
                    .addComponent(jTextField2, javax.swing.GroupLayout.PREFERRED_SIZE, 62, javax.swing.GroupLayout.PREFERRED_SIZE))
                .addGap(18, 18, 18)
                .addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignment.TRAILING)
                    .addComponent(jLabel3)
                    .addGroup(layout.createSequentialGroup()
                        .addComponent(jLabel4, javax.swing.GroupLayout.DEFAULT_SIZE, 55, Short.MAX_VALUE)
                        .addGap(18, 18, 18)
                        .addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
                            .addComponent(jButton1)
                            .addComponent(jTextField3, javax.swing.GroupLayout.PREFERRED_SIZE, 62, javax.swing.GroupLayout.PREFERRED_SIZE))))
                .addGap(21, 21, 21))
        );
        layout.setVerticalGroup(
            layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
            .addGroup(layout.createSequentialGroup()
                .addGap(19, 19, 19)
                .addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignment.BASELINE)
                    .addComponent(jLabel1)
                    .addComponent(jLabel2)
                    .addComponent(jLabel3))
                .addGap(18, 18, 18)
                .addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignment.BASELINE)
                    .addComponent(jTextField1, javax.swing.GroupLayout.PREFERRED_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.PREFERRED_SIZE)
                    .addComponent(jTextField2, javax.swing.GroupLayout.PREFERRED_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.PREFERRED_SIZE)
                    .addComponent(jComboBox1, javax.swing.GroupLayout.PREFERRED_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.PREFERRED_SIZE)
                    .addComponent(jTextField3, javax.swing.GroupLayout.PREFERRED_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.PREFERRED_SIZE)
                    .addComponent(jLabel4))
                .addGap(27, 27, 27)
                .addComponent(jButton1)
                .addContainerGap(javax.swing.GroupLayout.DEFAULT_SIZE, Short.MAX_VALUE))
        );

        pack();
    }// </editor-fold>                        

    private void jTextField1ActionPerformed(java.awt.event.ActionEvent evt) {                                            
        // TODO add your handling code here:
    }                                           

    private void jComboBox1ActionPerformed(java.awt.event.ActionEvent evt) {                                           
        // TODO add your handling code here:
    }                                          

    private void jComboBox1PopupMenuWillBecomeVisible(javax.swing.event.PopupMenuEvent evt) {                                                      
        // TODO add your handling code here:
    }                                                     

    private void jButton1ActionPerformed(java.awt.event.ActionEvent evt) {                                         

        char operator  = jComboBox1.getSelectedItem().toString().trim().toCharArray()[0];
//        System.out.println(operator);
//        System.out.println(operator);
        String optNum01 = jTextField1.getText();
        String optNum02 =  jTextField2.getText();
        String pattern = "\\d+";
        
        if(!optNum01.matches(pattern)){
            JOptionPane.showMessageDialog(this,"请输入数字");
            jTextField1.setText("");
            jTextField1.requestFocus();
            return;
        }
        
         if(!optNum02.matches(pattern)){
            JOptionPane.showMessageDialog(this,"请输入数字");
            jTextField2.setText("");
            jTextField2.requestFocus();
            return;
        }
         int result=0;         
         switch(operator){
             case '*':
                 result = Integer.parseInt(optNum01)*Integer.parseInt(optNum02);
                  System.out.println(result);
                 break;
             case '-':
                 result =  Integer.parseInt(optNum01)-Integer.parseInt(optNum02);
                 System.out.println(result);
                 break;
             case '+':
                  result =  Integer.parseInt(optNum01)+Integer.parseInt(optNum02);
                 System.out.println(result);
                 break;
             case '/':
                 result =  Integer.parseInt(optNum01)/Integer.parseInt(optNum02);
                 System.out.println(result);
                 break;
         }
         jTextField3.setText(""+result);
    }                                        

    /**
     * @param args the command line arguments
     */
    public static void main(String args[]) {
        /* Set the Nimbus look and feel */
        //<editor-fold defaultstate="collapsed" desc=" Look and feel setting code (optional) ">
        /* If Nimbus (introduced in Java SE 6) is not available, stay with the default look and feel.
         * For details see http://download.oracle.com/javase/tutorial/uiswing/lookandfeel/plaf.html 
         */
        try {
            for (javax.swing.UIManager.LookAndFeelInfo info : javax.swing.UIManager.getInstalledLookAndFeels()) {
                if ("Nimbus".equals(info.getName())) {
                    javax.swing.UIManager.setLookAndFeel(info.getClassName());
                    break;
                }
            }
        } catch (ClassNotFoundException ex) {
            java.util.logging.Logger.getLogger(NewJFrame.class.getName()).log(java.util.logging.Level.SEVERE, null, ex);
        } catch (InstantiationException ex) {
            java.util.logging.Logger.getLogger(NewJFrame.class.getName()).log(java.util.logging.Level.SEVERE, null, ex);
        } catch (IllegalAccessException ex) {
            java.util.logging.Logger.getLogger(NewJFrame.class.getName()).log(java.util.logging.Level.SEVERE, null, ex);
        } catch (javax.swing.UnsupportedLookAndFeelException ex) {
            java.util.logging.Logger.getLogger(NewJFrame.class.getName()).log(java.util.logging.Level.SEVERE, null, ex);
        }
        //</editor-fold>

        /* Create and display the form */
        java.awt.EventQueue.invokeLater(new Runnable() {
            public void run() {
                new NewJFrame().setVisible(true);
            }
        });
    }

    // Variables declaration - do not modify                     
    private javax.swing.ButtonGroup buttonGroup1;
    private javax.swing.JButton jButton1;
    private javax.swing.JComboBox jComboBox1;
    private javax.swing.JLabel jLabel1;
    private javax.swing.JLabel jLabel2;
    private javax.swing.JLabel jLabel3;
    private javax.swing.JLabel jLabel4;
    private javax.swing.JTextField jTextField1;
    private javax.swing.JTextField jTextField2;
    private javax.swing.JTextField jTextField3;
    // End of variables declaration                   

    private void init() {
        //throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.
         CALUI.setIcon(this);
         CALUI.setWindowCenter(this);
         this.setTitle("计算器");
    }

   
}

15. UIManger
UIManager管理当前的外观和感觉，一组可用的外观和感觉， PropertyChangeListeners ，当外观和感觉的变化，外观默认，以及获取各种默认值的便捷方法通知。

构造方法:

UIManager()

方法:

static void addAuxiliaryLookAndFeel(LookAndFeel laf)
在辅助外观和感觉列表中添加一个 LookAndFeel 。
static void addPropertyChangeListener(PropertyChangeListener listener)
添加一个 PropertyChangeListener到监听器列表。
static Object get(Object key)
从默认值返回一个对象。
static Object get(Object key, Locale l)
从适用于给定语言环境的默认值返回一个对象。
static LookAndFeel[] getAuxiliaryLookAndFeels()
返回辅助外观和感觉的列表（可以是 null ）。
static boolean getBoolean(Object key)
从与键值相关联的默认值返回一个布尔值。
static boolean getBoolean(Object key, Locale l)
从与键值相关联的默认值和给定的 Locale返回一个布尔值。
static Border getBorder(Object key)
从默认值返回一个边框。
static Border getBorder(Object key, Locale l)
从适用于给定语言环境的默认值返回一个边框。
static Color getColor(Object key)
从默认值返回颜色。
static Color getColor(Object key, Locale l)
从适用于给定语言环境的默认值返回颜色。
static String getCrossPlatformLookAndFeelClassName()
返回实现默认跨平台外观的 LookAndFeel类的名称–Java Look and Feel（JLF）。
static UIDefaults getDefaults()
返回默认值。
static Dimension getDimension(Object key)
从默认值返回维度。
static Dimension getDimension(Object key, Locale l)
从适用于给定语言环境的默认值返回维度。
static Font getFont(Object key)
从默认值返回一个字体。
static Font getFont(Object key, Locale l)
从适用于给定语言环境的默认值返回一个字体。
static Icon getIcon(Object key)
从默认值返回一个 Icon 。
static Icon getIcon(Object key, Locale l)
从适用于给定语言环境的默认值返回 Icon 。
static Insets getInsets(Object key)
从默认值返回一个 Insets对象。
static Insets getInsets(Object key, Locale l)
从适用于给定语言环境的默认值返回一个 Insets对象。
static UIManager.LookAndFeelInfo[] getInstalledLookAndFeels()
返回一个 LookAndFeelInfo s的数组， LookAndFeelInfo LookAndFeel可用的LookAndFeel实现。
static int getInt(Object key)
从默认值返回一个整数。
static int getInt(Object key, Locale l)
从适用于给定语言环境的默认值返回一个整数。
static LookAndFeel getLookAndFeel()
返回目前的外观或 null 。
static UIDefaults getLookAndFeelDefaults()
从当前的外观和感觉返回 UIDefaults ，这是在安装外观时获得的。
static PropertyChangeListener[] getPropertyChangeListeners()
返回使用addPropertyChangeListener（）添加到此UIManager的所有 PropertyChangeListener的数组。
static String getString(Object key)
从默认值返回一个字符串。
static String getString(Object key, Locale l)
从适用于给定语言环境的默认值返回一个字符串。
static String getSystemLookAndFeelClassName()
返回实现本机系统外观的 LookAndFeel类的名称，如果有的话，否则为默认的跨平台 LookAndFeel类的名称。
static ComponentUI getUI(JComponent target)
返回相应 ComponentUI实施 target 。
static void installLookAndFeel(String name, String className)
添加指定的外观和感觉的一套可用的外观和感觉。
static void installLookAndFeel(UIManager.LookAndFeelInfo info)
添加指定的外观和感觉的一套可用的外观和感觉。
static Object put(Object key, Object value)
在开发人员的默认值中存储一个对象。
static boolean removeAuxiliaryLookAndFeel(LookAndFeel laf)
从辅助外观和感觉列表中删除 LookAndFeel 。
static void removePropertyChangeListener(PropertyChangeListener listener)
从侦听器列表中删除一个 PropertyChangeListener 。
static void setInstalledLookAndFeels(UIManager.LookAndFeelInfo[] infos)
设置一组可用的外观和感觉。
static void setLookAndFeel(LookAndFeel newLookAndFeel)
将当前的外观设置为 newLookAndFeel 。
static void setLookAndFeel(String className)
使用当前线程的上下文类加载器加载由给定类名指定的 LookAndFeel ，并将其传递给 setLookAndFeel(LookAndFeel) 。

如何使用jdk自带的皮肤：
UIManager.setLookAndFeel(LookAndFeel 的 子类类名全名)
比如：

UIManager.setLookAndFeel("javax.swing.plaf.metal.MetalLookAndFeel ");

 public static void main(String args[])throws ClassNotFoundException {
        /* Set the Nimbus look and feel */
        //<editor-fold defaultstate="collapsed" desc=" Look and feel setting code (optional) ">
        /* If Nimbus (introduced in Java SE 6) is not available, stay with the default look and feel.
         * For details see http://download.oracle.com/javase/tutorial/uiswing/lookandfeel/plaf.html 
         */
        try {
            for (javax.swing.UIManager.LookAndFeelInfo info : javax.swing.UIManager.getInstalledLookAndFeels()) {
                if ("Nimbus".equals(info.getName())) {
                    javax.swing.UIManager.setLookAndFeel(info.getClassName());
                    break;
                }
            }
        } catch (ClassNotFoundException ex) {
            java.util.logging.Logger.getLogger(NewJFrame.class.getName()).log(java.util.logging.Level.SEVERE, null, ex);
        } catch (InstantiationException ex) {
            java.util.logging.Logger.getLogger(NewJFrame.class.getName()).log(java.util.logging.Level.SEVERE, null, ex);
        } catch (IllegalAccessException ex) {
            java.util.logging.Logger.getLogger(NewJFrame.class.getName()).log(java.util.logging.Level.SEVERE, null, ex);
        } catch (javax.swing.UnsupportedLookAndFeelException ex) {
            java.util.logging.Logger.getLogger(NewJFrame.class.getName()).log(java.util.logging.Level.SEVERE, null, ex);
        }
        //</editor-fold>
        try {
            UIManager.setLookAndFeel("javax.swing.plaf.multi.MultiLookAndFeel "
            );   
        } catch (ClassNotFoundException ex) {
            Logger.getLogger(CALUI.class.getName()).log(Level.SEVERE, null, ex);
        } catch (InstantiationException ex) {
            Logger.getLogger(CALUI.class.getName()).log(Level.SEVERE, null, ex);
        } catch (IllegalAccessException ex) {
            Logger.getLogger(CALUI.class.getName()).log(Level.SEVERE, null, ex);
        } catch (UnsupportedLookAndFeelException ex) {
            Logger.getLogger(CALUI.class.getName()).log(Level.SEVERE, null, ex);
        }
        java.awt.EventQueue.invokeLater(new Runnable() {
            public void run() {
                new NewJFrame().setVisible(true);
            }
        });
    }

16.实现登录界面

注册界面：

/*
 * To change this license header, choose License Headers in Project Properties.
 * To change this template file, choose Tools | Templates
 * and open the template in the editor.
 */

package loginapp;

import java.awt.event.KeyEvent;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.util.logging.Level;
import java.util.logging.Logger;
import javax.swing.JOptionPane;
import javax.swing.UIManager;
import javax.swing.UnsupportedLookAndFeelException;
import newpackageUI.CALUI;
import studentpojo.User;

/**
 *
 * @author Administrator
 */
public class LoginWindow extends javax.swing.JFrame {
    /**
     * Creates new form LoginWindow
     */
    private String name;
    private String pwd;
    private static File f = new File("account.txt");
    public LoginWindow() {
        initComponents();
        init();
    }

    /**
     * This method is called from within the constructor to initialize the form.
     * WARNING: Do NOT modify this code. The content of this method is always
     * regenerated by the Form Editor.
     */
    @SuppressWarnings("unchecked")
    // <editor-fold defaultstate="collapsed" desc="Generated Code">                          
    private void initComponents() {

        jLabel1 = new javax.swing.JLabel();
        jTextField1 = new javax.swing.JTextField();
        jLabel2 = new javax.swing.JLabel();
        jTextField2 = new javax.swing.JTextField();
        jLabel3 = new javax.swing.JLabel();
        jTextField3 = new javax.swing.JTextField();
        jButton1 = new javax.swing.JButton();
        jButton2 = new javax.swing.JButton();
        jButton3 = new javax.swing.JButton();

        setDefaultCloseOperation(javax.swing.WindowConstants.EXIT_ON_CLOSE);

        jLabel1.setText("用户名：");

        jTextField1.addActionListener(new java.awt.event.ActionListener() {
            public void actionPerformed(java.awt.event.ActionEvent evt) {
                jTextField1ActionPerformed(evt);
            }
        });
        jTextField1.addKeyListener(new java.awt.event.KeyAdapter() {
            public void keyPressed(java.awt.event.KeyEvent evt) {
                jTextField1KeyPressed(evt);
            }
            public void keyReleased(java.awt.event.KeyEvent evt) {
                jTextField1KeyReleased(evt);
            }
        });

        jLabel2.setText("密码：");

        jTextField2.addActionListener(new java.awt.event.ActionListener() {
            public void actionPerformed(java.awt.event.ActionEvent evt) {
                jTextField2ActionPerformed(evt);
            }
        });
        jTextField2.addKeyListener(new java.awt.event.KeyAdapter() {
            public void keyReleased(java.awt.event.KeyEvent evt) {
                jTextField2KeyReleased(evt);
            }
        });

        jLabel3.setText("再次输入密码：");

        jTextField3.addActionListener(new java.awt.event.ActionListener() {
            public void actionPerformed(java.awt.event.ActionEvent evt) {
                jTextField3ActionPerformed(evt);
            }
        });
        jTextField3.addKeyListener(new java.awt.event.KeyAdapter() {
            public void keyReleased(java.awt.event.KeyEvent evt) {
                jTextField3KeyReleased(evt);
            }
        });

        jButton1.setText("注册");
        jButton1.addActionListener(new java.awt.event.ActionListener() {
            public void actionPerformed(java.awt.event.ActionEvent evt) {
                jButton1ActionPerformed(evt);
            }
        });

        jButton2.setText("登录");
        jButton2.addActionListener(new java.awt.event.ActionListener() {
            public void actionPerformed(java.awt.event.ActionEvent evt) {
                jButton2ActionPerformed(evt);
            }
        });

        jButton3.setText("退出");
        jButton3.addActionListener(new java.awt.event.ActionListener() {
            public void actionPerformed(java.awt.event.ActionEvent evt) {
                jButton3ActionPerformed(evt);
            }
        });

        javax.swing.GroupLayout layout = new javax.swing.GroupLayout(getContentPane());
        getContentPane().setLayout(layout);
        layout.setHorizontalGroup(
            layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
            .addGroup(javax.swing.GroupLayout.Alignment.TRAILING, layout.createSequentialGroup()
                .addContainerGap(23, Short.MAX_VALUE)
                .addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
                    .addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignment.TRAILING)
                        .addComponent(jLabel3)
                        .addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING, false)
                            .addComponent(jLabel1, javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE, Short.MAX_VALUE)
                            .addComponent(jLabel2, javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE, Short.MAX_VALUE)))
                    .addComponent(jButton1))
                .addGap(50, 50, 50)
                .addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING, false)
                    .addGroup(layout.createSequentialGroup()
                        .addComponent(jButton2)
                        .addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED, 100, Short.MAX_VALUE)
                        .addComponent(jButton3))
                    .addComponent(jTextField1)
                    .addComponent(jTextField2)
                    .addComponent(jTextField3, javax.swing.GroupLayout.DEFAULT_SIZE, 214, Short.MAX_VALUE))
                .addGap(29, 29, 29))
        );
        layout.setVerticalGroup(
            layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
            .addGroup(layout.createSequentialGroup()
                .addGap(37, 37, 37)
                .addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignment.BASELINE)
                    .addComponent(jTextField1, javax.swing.GroupLayout.PREFERRED_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.PREFERRED_SIZE)
                    .addComponent(jLabel1))
                .addGap(25, 25, 25)
                .addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignment.BASELINE)
                    .addComponent(jLabel2)
                    .addComponent(jTextField2, javax.swing.GroupLayout.PREFERRED_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.PREFERRED_SIZE))
                .addGap(35, 35, 35)
                .addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignment.BASELINE)
                    .addComponent(jLabel3)
                    .addComponent(jTextField3, javax.swing.GroupLayout.PREFERRED_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.PREFERRED_SIZE))
                .addGap(27, 27, 27)
                .addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignment.BASELINE)
                    .addComponent(jButton1)
                    .addComponent(jButton2)
                    .addComponent(jButton3))
                .addContainerGap(29, Short.MAX_VALUE))
        );

        pack();
    }// </editor-fold>                        

    private void jButton1ActionPerformed(java.awt.event.ActionEvent evt) {                                         
        String text1 = jTextField1.getText();
        String text2 = jTextField2.getText();
        String text3 = jTextField3.getText();
        String nameregex = "[0-9a-zA-Z]{6,10}";
        String pwdregex = "[0-9a-zA-Z]{8,12}";
        if(!text2.equals(text3)){
            JOptionPane.showMessageDialog(this,"两次密码输入不一致");
            return;
        }
        if(!text1.matches(nameregex)){
            JOptionPane.showMessageDialog(this,"用户名必须由6到10位数字或字母组成");
            return;
        }
        if(!text2.matches(pwdregex)){
            JOptionPane.showMessageDialog(this,"密码必须由6到12位数字或字母组成");
            return;
        }
        //将用户名和密码通过IO写到记事本中，并弹出弹框“注册成功”
        boolean b;
        User u = new User(text1,text2);
        //File f = new File("acount.txt");
        System.out.println(f.exists());
        System.out.println(f.getAbsolutePath());
        if(!f.exists()){
            try {
                f.createNewFile();
            } catch (IOException ex) {
                Logger.getLogger(LoginWindow.class.getName()).log(Level.SEVERE, null, ex);
            }
        }
        try {
            b = checkAcount(text1,f);
            System.out.println(b);
            if(b!= true){
                 JOptionPane.showMessageDialog(this,"用户名已存在请重新设置");
                return;
            }
        } catch (IOException ex) {
            Logger.getLogger(LoginWindow.class.getName()).log(Level.SEVERE, null, ex);
        }
        
        BufferedWriter fw = null;
        String newuser = u.getName()+","+u.getPwd();
        System.out.println(newuser);
        
        try {
            fw = new BufferedWriter(new FileWriter(f,true));
            System.out.println(fw);
        } catch (IOException ex) {
            Logger.getLogger(LoginWindow.class.getName()).log(Level.SEVERE, null, ex);
        }
        
        try {
            if(fw != null){
               fw.write(newuser); //123456789
               fw.newLine();
               //fw.flush();
               fw.close();
               JOptionPane.showMessageDialog(this,"恭喜"+text1+"注册成功！");
            }           
        } catch (IOException ex) {
            Logger.getLogger(LoginWindow.class.getName()).log(Level.SEVERE, null, ex);
        }        
    }                                        
    private boolean checkAcount(String name,File f) throws FileNotFoundException, IOException{
        BufferedReader fd = new BufferedReader(new FileReader(f));
        String info = null;
        boolean b = true;
        while((info = fd.readLine())!=null){
            String[] account = info.split(",");
            String n = account[0];
            System.out.println(n);
            if(n.equals(name)){
                fd.close();
                System.out.println(n);
                return b = false;
            }
        }
        fd.close();
        return b;
    }
    
    private void jButton2ActionPerformed(java.awt.event.ActionEvent evt) {                                         
        this.setVisible(false);
        new DengLuWindow().setVisible(true);
    }                                        

    private void jButton3ActionPerformed(java.awt.event.ActionEvent evt) {                                         
       System.exit(0);
    }                                        

    private void jTextField1ActionPerformed(java.awt.event.ActionEvent evt) {                                            
        // TODO add your handling code here:
    }                                           

    private void jTextField2ActionPerformed(java.awt.event.ActionEvent evt) {                                            
        // TODO add your handling code here:
    }                                           

    private void jTextField3ActionPerformed(java.awt.event.ActionEvent evt) {                                            
        // TODO add your handling code here:
    }                                           

    private void jTextField1KeyPressed(java.awt.event.KeyEvent evt) {                                       
     
       
    }                                      

    private void jTextField1KeyReleased(java.awt.event.KeyEvent evt) {                                        
        String regex = "[0-9a-zA-Z]*";
       //char input = evt.getKeyChar();
       //String s = KeyEvent.getKeyText(input);
       //设置用户名只能是字母和数字
       String info =jTextField1.getText();
       int length = info.length();
       if(!info.matches(regex)){
            JOptionPane.showMessageDialog(this,"用户名必须是数字或英文");
            String newinfo = info.substring(0,length-1);
            jTextField1.setText(newinfo);
            return;
        }
    }                                       

    private void jTextField2KeyReleased(java.awt.event.KeyEvent evt) {                                        
        String regex = "[0-9a-zA-Z]*";
       //char input = evt.getKeyChar();
       //String s = KeyEvent.getKeyText(input);
       //设置用户名只能是字母和数字
       String info =jTextField1.getText();
       int length = info.length();
       if(!info.matches(regex)){
            JOptionPane.showMessageDialog(this,"密码必须是数字或英文");
            String newinfo = info.substring(0,length-1);
            jTextField1.setText(newinfo);
            return;
        }
    }                                       

    private void jTextField3KeyReleased(java.awt.event.KeyEvent evt) {                                        
        // TODO add your handling code here:
    }                                       

    /**
     * @param args the command line arguments
     */
    public static void main(String args[]) {
        /* Set the Nimbus look and feel */
        //<editor-fold defaultstate="collapsed" desc=" Look and feel setting code (optional) ">
        /* If Nimbus (introduced in Java SE 6) is not available, stay with the default look and feel.
         * For details see http://download.oracle.com/javase/tutorial/uiswing/lookandfeel/plaf.html 
         */
        try {
            for (javax.swing.UIManager.LookAndFeelInfo info : javax.swing.UIManager.getInstalledLookAndFeels()) {
                if ("Nimbus".equals(info.getName())) {
                    javax.swing.UIManager.setLookAndFeel(info.getClassName());
                    break;
                }
            }
        } catch (ClassNotFoundException ex) {
            java.util.logging.Logger.getLogger(LoginWindow.class.getName()).log(java.util.logging.Level.SEVERE, null, ex);
        } catch (InstantiationException ex) {
            java.util.logging.Logger.getLogger(LoginWindow.class.getName()).log(java.util.logging.Level.SEVERE, null, ex);
        } catch (IllegalAccessException ex) {
            java.util.logging.Logger.getLogger(LoginWindow.class.getName()).log(java.util.logging.Level.SEVERE, null, ex);
        } catch (javax.swing.UnsupportedLookAndFeelException ex) {
            java.util.logging.Logger.getLogger(LoginWindow.class.getName()).log(java.util.logging.Level.SEVERE, null, ex);
        }
        //</editor-fold>
        try {
            /* Create and display the form */
            UIManager.setLookAndFeel("javax.swing.plaf.nimbus.NimbusLookAndFeel ");
        } catch (ClassNotFoundException ex) {
            Logger.getLogger(LoginWindow.class.getName()).log(Level.SEVERE, null, ex);
        } catch (InstantiationException ex) {
            Logger.getLogger(LoginWindow.class.getName()).log(Level.SEVERE, null, ex);
        } catch (IllegalAccessException ex) {
            Logger.getLogger(LoginWindow.class.getName()).log(Level.SEVERE, null, ex);
        } catch (UnsupportedLookAndFeelException ex) {
            Logger.getLogger(LoginWindow.class.getName()).log(Level.SEVERE, null, ex);
        }
        java.awt.EventQueue.invokeLater(new Runnable() {
            public void run() {
                new LoginWindow().setVisible(true);
            }
        });
    }

    // Variables declaration - do not modify                     
    private javax.swing.JButton jButton1;
    private javax.swing.JButton jButton2;
    private javax.swing.JButton jButton3;
    private javax.swing.JLabel jLabel1;
    private javax.swing.JLabel jLabel2;
    private javax.swing.JLabel jLabel3;
    private javax.swing.JTextField jTextField1;
    private javax.swing.JTextField jTextField2;
    private javax.swing.JTextField jTextField3;
    // End of variables declaration                   

    private void init() {
       CALUI.setWindowCenter(this);
    }
}

登录界面：

/*
 * To change this license header, choose License Headers in Project Properties.
 * To change this template file, choose Tools | Templates
 * and open the template in the editor.
 */

package loginapp;

import java.awt.event.KeyEvent;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.util.logging.Level;
import java.util.logging.Logger;
import javax.swing.JOptionPane;
import javax.swing.UIManager;
import javax.swing.UnsupportedLookAndFeelException;
import newpackageUI.CALUI;
import studentpojo.User;

/**
 *
 * @author Administrator
 */
public class LoginWindow extends javax.swing.JFrame {
    /**
     * Creates new form LoginWindow
     */
    private String name;
    private String pwd;
    private static File f = new File("account.txt");
    public LoginWindow() {
        initComponents();
        init();
    }

    /**
     * This method is called from within the constructor to initialize the form.
     * WARNING: Do NOT modify this code. The content of this method is always
     * regenerated by the Form Editor.
     */
    @SuppressWarnings("unchecked")
    // <editor-fold defaultstate="collapsed" desc="Generated Code">                          
    private void initComponents() {

        jLabel1 = new javax.swing.JLabel();
        jTextField1 = new javax.swing.JTextField();
        jLabel2 = new javax.swing.JLabel();
        jTextField2 = new javax.swing.JTextField();
        jLabel3 = new javax.swing.JLabel();
        jTextField3 = new javax.swing.JTextField();
        jButton1 = new javax.swing.JButton();
        jButton2 = new javax.swing.JButton();
        jButton3 = new javax.swing.JButton();

        setDefaultCloseOperation(javax.swing.WindowConstants.EXIT_ON_CLOSE);

        jLabel1.setText("用户名：");

        jTextField1.addActionListener(new java.awt.event.ActionListener() {
            public void actionPerformed(java.awt.event.ActionEvent evt) {
                jTextField1ActionPerformed(evt);
            }
        });
        jTextField1.addKeyListener(new java.awt.event.KeyAdapter() {
            public void keyPressed(java.awt.event.KeyEvent evt) {
                jTextField1KeyPressed(evt);
            }
            public void keyReleased(java.awt.event.KeyEvent evt) {
                jTextField1KeyReleased(evt);
            }
        });

        jLabel2.setText("密码：");

        jTextField2.addActionListener(new java.awt.event.ActionListener() {
            public void actionPerformed(java.awt.event.ActionEvent evt) {
                jTextField2ActionPerformed(evt);
            }
        });
        jTextField2.addKeyListener(new java.awt.event.KeyAdapter() {
            public void keyReleased(java.awt.event.KeyEvent evt) {
                jTextField2KeyReleased(evt);
            }
        });

        jLabel3.setText("再次输入密码：");

        jTextField3.addActionListener(new java.awt.event.ActionListener() {
            public void actionPerformed(java.awt.event.ActionEvent evt) {
                jTextField3ActionPerformed(evt);
            }
        });
        jTextField3.addKeyListener(new java.awt.event.KeyAdapter() {
            public void keyReleased(java.awt.event.KeyEvent evt) {
                jTextField3KeyReleased(evt);
            }
        });

        jButton1.setText("注册");
        jButton1.addActionListener(new java.awt.event.ActionListener() {
            public void actionPerformed(java.awt.event.ActionEvent evt) {
                jButton1ActionPerformed(evt);
            }
        });

        jButton2.setText("登录");
        jButton2.addActionListener(new java.awt.event.ActionListener() {
            public void actionPerformed(java.awt.event.ActionEvent evt) {
                jButton2ActionPerformed(evt);
            }
        });

        jButton3.setText("退出");
        jButton3.addActionListener(new java.awt.event.ActionListener() {
            public void actionPerformed(java.awt.event.ActionEvent evt) {
                jButton3ActionPerformed(evt);
            }
        });

        javax.swing.GroupLayout layout = new javax.swing.GroupLayout(getContentPane());
        getContentPane().setLayout(layout);
        layout.setHorizontalGroup(
            layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
            .addGroup(javax.swing.GroupLayout.Alignment.TRAILING, layout.createSequentialGroup()
                .addContainerGap(23, Short.MAX_VALUE)
                .addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
                    .addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignment.TRAILING)
                        .addComponent(jLabel3)
                        .addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING, false)
                            .addComponent(jLabel1, javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE, Short.MAX_VALUE)
                            .addComponent(jLabel2, javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE, Short.MAX_VALUE)))
                    .addComponent(jButton1))
                .addGap(50, 50, 50)
                .addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING, false)
                    .addGroup(layout.createSequentialGroup()
                        .addComponent(jButton2)
                        .addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED, 100, Short.MAX_VALUE)
                        .addComponent(jButton3))
                    .addComponent(jTextField1)
                    .addComponent(jTextField2)
                    .addComponent(jTextField3, javax.swing.GroupLayout.DEFAULT_SIZE, 214, Short.MAX_VALUE))
                .addGap(29, 29, 29))
        );
        layout.setVerticalGroup(
            layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
            .addGroup(layout.createSequentialGroup()
                .addGap(37, 37, 37)
                .addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignment.BASELINE)
                    .addComponent(jTextField1, javax.swing.GroupLayout.PREFERRED_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.PREFERRED_SIZE)
                    .addComponent(jLabel1))
                .addGap(25, 25, 25)
                .addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignment.BASELINE)
                    .addComponent(jLabel2)
                    .addComponent(jTextField2, javax.swing.GroupLayout.PREFERRED_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.PREFERRED_SIZE))
                .addGap(35, 35, 35)
                .addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignment.BASELINE)
                    .addComponent(jLabel3)
                    .addComponent(jTextField3, javax.swing.GroupLayout.PREFERRED_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.PREFERRED_SIZE))
                .addGap(27, 27, 27)
                .addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignment.BASELINE)
                    .addComponent(jButton1)
                    .addComponent(jButton2)
                    .addComponent(jButton3))
                .addContainerGap(29, Short.MAX_VALUE))
        );

        pack();
    }// </editor-fold>                        

    private void jButton1ActionPerformed(java.awt.event.ActionEvent evt) {                                         
        String text1 = jTextField1.getText();
        String text2 = jTextField2.getText();
        String text3 = jTextField3.getText();
        String nameregex = "[0-9a-zA-Z]{6,10}";
        String pwdregex = "[0-9a-zA-Z]{8,12}";
        if(!text2.equals(text3)){
            JOptionPane.showMessageDialog(this,"两次密码输入不一致");
            return;
        }
        if(!text1.matches(nameregex)){
            JOptionPane.showMessageDialog(this,"用户名必须由6到10位数字或字母组成");
            return;
        }
        if(!text2.matches(pwdregex)){
            JOptionPane.showMessageDialog(this,"密码必须由6到12位数字或字母组成");
            return;
        }
        //将用户名和密码通过IO写到记事本中，并弹出弹框“注册成功”
        boolean b;
        User u = new User(text1,text2);
        //File f = new File("acount.txt");
        System.out.println(f.exists());
        System.out.println(f.getAbsolutePath());
        if(!f.exists()){
            try {
                f.createNewFile();
            } catch (IOException ex) {
                Logger.getLogger(LoginWindow.class.getName()).log(Level.SEVERE, null, ex);
            }
        }
        try {
            b = checkAcount(text1,f);
            System.out.println(b);
            if(b!= true){
                 JOptionPane.showMessageDialog(this,"用户名已存在请重新设置");
                return;
            }
        } catch (IOException ex) {
            Logger.getLogger(LoginWindow.class.getName()).log(Level.SEVERE, null, ex);
        }
        
        BufferedWriter fw = null;
        String newuser = u.getName()+","+u.getPwd();
        System.out.println(newuser);
        
        try {
            fw = new BufferedWriter(new FileWriter(f,true));
            System.out.println(fw);
        } catch (IOException ex) {
            Logger.getLogger(LoginWindow.class.getName()).log(Level.SEVERE, null, ex);
        }
        
        try {
            if(fw != null){
               fw.write(newuser); //123456789
               fw.newLine();
               //fw.flush();
               fw.close();
               JOptionPane.showMessageDialog(this,"恭喜"+text1+"注册成功！");
            }           
        } catch (IOException ex) {
            Logger.getLogger(LoginWindow.class.getName()).log(Level.SEVERE, null, ex);
        }        
    }                                        
    private boolean checkAcount(String name,File f) throws FileNotFoundException, IOException{
        BufferedReader fd = new BufferedReader(new FileReader(f));
        String info = null;
        boolean b = true;
        while((info = fd.readLine())!=null){
            String[] account = info.split(",");
            String n = account[0];
            System.out.println(n);
            if(n.equals(name)){
                fd.close();
                System.out.println(n);
                return b = false;
            }
        }
        fd.close();
        return b;
    }
    
    private void jButton2ActionPerformed(java.awt.event.ActionEvent evt) {                                         
        this.setVisible(false);
        new DengLuWindow().setVisible(true);
    }                                        

    private void jButton3ActionPerformed(java.awt.event.ActionEvent evt) {                                         
       System.exit(0);
    }                                        

    private void jTextField1ActionPerformed(java.awt.event.ActionEvent evt) {                                            
        // TODO add your handling code here:
    }                                           

    private void jTextField2ActionPerformed(java.awt.event.ActionEvent evt) {                                            
        // TODO add your handling code here:
    }                                           

    private void jTextField3ActionPerformed(java.awt.event.ActionEvent evt) {                                            
        // TODO add your handling code here:
    }                                           

    private void jTextField1KeyPressed(java.awt.event.KeyEvent evt) {                                       
     
       
    }                                      

    private void jTextField1KeyReleased(java.awt.event.KeyEvent evt) {                                        
        String regex = "[0-9a-zA-Z]*";
       //char input = evt.getKeyChar();
       //String s = KeyEvent.getKeyText(input);
       //设置用户名只能是字母和数字
       String info =jTextField1.getText();
       int length = info.length();
       if(!info.matches(regex)){
            JOptionPane.showMessageDialog(this,"用户名必须是数字或英文");
            String newinfo = info.substring(0,length-1);
            jTextField1.setText(newinfo);
            return;
        }
    }                                       

    private void jTextField2KeyReleased(java.awt.event.KeyEvent evt) {                                        
        String regex = "[0-9a-zA-Z]*";
       //char input = evt.getKeyChar();
       //String s = KeyEvent.getKeyText(input);
       //设置用户名只能是字母和数字
       String info =jTextField1.getText();
       int length = info.length();
       if(!info.matches(regex)){
            JOptionPane.showMessageDialog(this,"密码必须是数字或英文");
            String newinfo = info.substring(0,length-1);
            jTextField1.setText(newinfo);
            return;
        }
    }                                       

    private void jTextField3KeyReleased(java.awt.event.KeyEvent evt) {                                        
        // TODO add your handling code here:
    }                                       

    /**
     * @param args the command line arguments
     */
    public static void main(String args[]) {
        /* Set the Nimbus look and feel */
        //<editor-fold defaultstate="collapsed" desc=" Look and feel setting code (optional) ">
        /* If Nimbus (introduced in Java SE 6) is not available, stay with the default look and feel.
         * For details see http://download.oracle.com/javase/tutorial/uiswing/lookandfeel/plaf.html 
         */
        try {
            for (javax.swing.UIManager.LookAndFeelInfo info : javax.swing.UIManager.getInstalledLookAndFeels()) {
                if ("Nimbus".equals(info.getName())) {
                    javax.swing.UIManager.setLookAndFeel(info.getClassName());
                    break;
                }
            }
        } catch (ClassNotFoundException ex) {
            java.util.logging.Logger.getLogger(LoginWindow.class.getName()).log(java.util.logging.Level.SEVERE, null, ex);
        } catch (InstantiationException ex) {
            java.util.logging.Logger.getLogger(LoginWindow.class.getName()).log(java.util.logging.Level.SEVERE, null, ex);
        } catch (IllegalAccessException ex) {
            java.util.logging.Logger.getLogger(LoginWindow.class.getName()).log(java.util.logging.Level.SEVERE, null, ex);
        } catch (javax.swing.UnsupportedLookAndFeelException ex) {
            java.util.logging.Logger.getLogger(LoginWindow.class.getName()).log(java.util.logging.Level.SEVERE, null, ex);
        }
        //</editor-fold>
        try {
            /* Create and display the form */
            UIManager.setLookAndFeel("javax.swing.plaf.nimbus.NimbusLookAndFeel ");
        } catch (ClassNotFoundException ex) {
            Logger.getLogger(LoginWindow.class.getName()).log(Level.SEVERE, null, ex);
        } catch (InstantiationException ex) {
            Logger.getLogger(LoginWindow.class.getName()).log(Level.SEVERE, null, ex);
        } catch (IllegalAccessException ex) {
            Logger.getLogger(LoginWindow.class.getName()).log(Level.SEVERE, null, ex);
        } catch (UnsupportedLookAndFeelException ex) {
            Logger.getLogger(LoginWindow.class.getName()).log(Level.SEVERE, null, ex);
        }
        java.awt.EventQueue.invokeLater(new Runnable() {
            public void run() {
                new LoginWindow().setVisible(true);
            }
        });
    }

    // Variables declaration - do not modify                     
    private javax.swing.JButton jButton1;
    private javax.swing.JButton jButton2;
    private javax.swing.JButton jButton3;
    private javax.swing.JLabel jLabel1;
    private javax.swing.JLabel jLabel2;
    private javax.swing.JLabel jLabel3;
    private javax.swing.JTextField jTextField1;
    private javax.swing.JTextField jTextField2;
    private javax.swing.JTextField jTextField3;
    // End of variables declaration                   

    private void init() {
       CALUI.setWindowCenter(this);
    }
}

计算器

/*
 * To change this license header, choose License Headers in Project Properties.
 * To change this template file, choose Tools | Templates
 * and open the template in the editor.
 */

package mathcal;

import java.util.logging.Level;
import java.util.logging.Logger;
import javax.swing.JOptionPane;
import javax.swing.UIManager;
import javax.swing.UnsupportedLookAndFeelException;
import newpackageUI.CALUI;
//import javax.swing.plaf.multi.MultiLookAndFeel 
/**
 *
 * @author Administrator
 */
public class NewJFrame extends javax.swing.JFrame {

    /**
     * Creates new form NewJFrame
     */
    public NewJFrame() {
        initComponents();
        init();
    }

    /**
     * This method is called from within the constructor to initialize the form.
     * WARNING: Do NOT modify this code. The content of this method is always
     * regenerated by the Form Editor.
     */
    @SuppressWarnings("unchecked")
    // <editor-fold defaultstate="collapsed" desc="Generated Code">                          
    private void initComponents() {

        buttonGroup1 = new javax.swing.ButtonGroup();
        jLabel1 = new javax.swing.JLabel();
        jLabel2 = new javax.swing.JLabel();
        jLabel3 = new javax.swing.JLabel();
        jTextField1 = new javax.swing.JTextField();
        jTextField2 = new javax.swing.JTextField();
        jComboBox1 = new javax.swing.JComboBox();
        jTextField3 = new javax.swing.JTextField();
        jLabel4 = new javax.swing.JLabel();
        jButton1 = new javax.swing.JButton();

        setDefaultCloseOperation(javax.swing.WindowConstants.EXIT_ON_CLOSE);

        jLabel1.setText("操作数1");

        jLabel2.setText("操作数2");

        jLabel3.setText("计算结果");

        jTextField1.addActionListener(new java.awt.event.ActionListener() {
            public void actionPerformed(java.awt.event.ActionEvent evt) {
                jTextField1ActionPerformed(evt);
            }
        });

        jComboBox1.setModel(new javax.swing.DefaultComboBoxModel(new String[] { "+", "-", "*", "/" }));
        jComboBox1.addPopupMenuListener(new javax.swing.event.PopupMenuListener() {
            public void popupMenuCanceled(javax.swing.event.PopupMenuEvent evt) {
            }
            public void popupMenuWillBecomeInvisible(javax.swing.event.PopupMenuEvent evt) {
            }
            public void popupMenuWillBecomeVisible(javax.swing.event.PopupMenuEvent evt) {
                jComboBox1PopupMenuWillBecomeVisible(evt);
            }
        });
        jComboBox1.addActionListener(new java.awt.event.ActionListener() {
            public void actionPerformed(java.awt.event.ActionEvent evt) {
                jComboBox1ActionPerformed(evt);
            }
        });

        jTextField3.setEditable(false);

        jLabel4.setText("=");

        jButton1.setText("计算");
        jButton1.addActionListener(new java.awt.event.ActionListener() {
            public void actionPerformed(java.awt.event.ActionEvent evt) {
                jButton1ActionPerformed(evt);
            }
        });

        javax.swing.GroupLayout layout = new javax.swing.GroupLayout(getContentPane());
        getContentPane().setLayout(layout);
        layout.setHorizontalGroup(
            layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
            .addGroup(javax.swing.GroupLayout.Alignment.TRAILING, layout.createSequentialGroup()
                .addGap(19, 19, 19)
                .addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignment.TRAILING)
                    .addComponent(jLabel1)
                    .addComponent(jTextField1, javax.swing.GroupLayout.PREFERRED_SIZE, 54, javax.swing.GroupLayout.PREFERRED_SIZE))
                .addGap(47, 47, 47)
                .addComponent(jComboBox1, javax.swing.GroupLayout.PREFERRED_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.PREFERRED_SIZE)
                .addGap(40, 40, 40)
                .addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
                    .addComponent(jLabel2)
                    .addComponent(jTextField2, javax.swing.GroupLayout.PREFERRED_SIZE, 62, javax.swing.GroupLayout.PREFERRED_SIZE))
                .addGap(18, 18, 18)
                .addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignment.TRAILING)
                    .addComponent(jLabel3)
                    .addGroup(layout.createSequentialGroup()
                        .addComponent(jLabel4, javax.swing.GroupLayout.DEFAULT_SIZE, 55, Short.MAX_VALUE)
                        .addGap(18, 18, 18)
                        .addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
                            .addComponent(jButton1)
                            .addComponent(jTextField3, javax.swing.GroupLayout.PREFERRED_SIZE, 62, javax.swing.GroupLayout.PREFERRED_SIZE))))
                .addGap(21, 21, 21))
        );
        layout.setVerticalGroup(
            layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
            .addGroup(layout.createSequentialGroup()
                .addGap(19, 19, 19)
                .addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignment.BASELINE)
                    .addComponent(jLabel1)
                    .addComponent(jLabel2)
                    .addComponent(jLabel3))
                .addGap(18, 18, 18)
                .addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignment.BASELINE)
                    .addComponent(jTextField1, javax.swing.GroupLayout.PREFERRED_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.PREFERRED_SIZE)
                    .addComponent(jTextField2, javax.swing.GroupLayout.PREFERRED_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.PREFERRED_SIZE)
                    .addComponent(jComboBox1, javax.swing.GroupLayout.PREFERRED_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.PREFERRED_SIZE)
                    .addComponent(jTextField3, javax.swing.GroupLayout.PREFERRED_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.PREFERRED_SIZE)
                    .addComponent(jLabel4))
                .addGap(27, 27, 27)
                .addComponent(jButton1)
                .addContainerGap(javax.swing.GroupLayout.DEFAULT_SIZE, Short.MAX_VALUE))
        );

        pack();
    }// </editor-fold>                        

    private void jTextField1ActionPerformed(java.awt.event.ActionEvent evt) {                                            
        // TODO add your handling code here:
    }                                           

    private void jComboBox1ActionPerformed(java.awt.event.ActionEvent evt) {                                           
        // TODO add your handling code here:
    }                                          

    private void jComboBox1PopupMenuWillBecomeVisible(javax.swing.event.PopupMenuEvent evt) {                                                      
        // TODO add your handling code here:
    }                                                     

    private void jButton1ActionPerformed(java.awt.event.ActionEvent evt) {                                         

        char operator  = jComboBox1.getSelectedItem().toString().trim().toCharArray()[0];
        String optNum01 = jTextField1.getText();
        String optNum02 =  jTextField2.getText();
        String pattern = "\\d+";
        
        if(!optNum01.matches(pattern)){
            JOptionPane.showMessageDialog(this,"请输入数字");
            jTextField1.setText("");
            jTextField1.requestFocus();
            return;
        }
        
         if(!optNum02.matches(pattern)){
            JOptionPane.showMessageDialog(this,"请输入数字");
            jTextField2.setText("");
            jTextField2.requestFocus();
            return;
        }
         int result=0;         
         switch(operator){
             case '*':
                 result = Integer.parseInt(optNum01)*Integer.parseInt(optNum02);
                  System.out.println(result);
                 break;
             case '-':
                 result =  Integer.parseInt(optNum01)-Integer.parseInt(optNum02);
                 System.out.println(result);
                 break;
             case '+':
                  result =  Integer.parseInt(optNum01)+Integer.parseInt(optNum02);
                 System.out.println(result);
                 break;
             case '/':
                 result =  Integer.parseInt(optNum01)/Integer.parseInt(optNum02);
                 System.out.println(result);
                 break;
         }
         jTextField3.setText(""+result);
    }                                        

    /**
     * @param args the command line arguments
     */
//    public static void main(String args[])throws ClassNotFoundException {
//        /* Set the Nimbus look and feel */
//        //<editor-fold defaultstate="collapsed" desc=" Look and feel setting code (optional) ">
//        /* If Nimbus (introduced in Java SE 6) is not available, stay with the default look and feel.
//         * For details see http://download.oracle.com/javase/tutorial/uiswing/lookandfeel/plaf.html 
//         */
//        try {
//            for (javax.swing.UIManager.LookAndFeelInfo info : javax.swing.UIManager.getInstalledLookAndFeels()) {
//                if ("Nimbus".equals(info.getName())) {
//                    javax.swing.UIManager.setLookAndFeel(info.getClassName());
//                    break;
//                }
//            }
//        } catch (ClassNotFoundException ex) {
//            java.util.logging.Logger.getLogger(NewJFrame.class.getName()).log(java.util.logging.Level.SEVERE, null, ex);
//        } catch (InstantiationException ex) {
//            java.util.logging.Logger.getLogger(NewJFrame.class.getName()).log(java.util.logging.Level.SEVERE, null, ex);
//        } catch (IllegalAccessException ex) {
//            java.util.logging.Logger.getLogger(NewJFrame.class.getName()).log(java.util.logging.Level.SEVERE, null, ex);
//        } catch (javax.swing.UnsupportedLookAndFeelException ex) {
//            java.util.logging.Logger.getLogger(NewJFrame.class.getName()).log(java.util.logging.Level.SEVERE, null, ex);
//        }
//        //</editor-fold>
//        try {
//            UIManager.setLookAndFeel("javax.swing.plaf.multi.MultiLookAndFeel "
//            );   
//        } catch (ClassNotFoundException ex) {
//            Logger.getLogger(CALUI.class.getName()).log(Level.SEVERE, null, ex);
//        } catch (InstantiationException ex) {
//            Logger.getLogger(CALUI.class.getName()).log(Level.SEVERE, null, ex);
//        } catch (IllegalAccessException ex) {
//            Logger.getLogger(CALUI.class.getName()).log(Level.SEVERE, null, ex);
//        } catch (UnsupportedLookAndFeelException ex) {
//            Logger.getLogger(CALUI.class.getName()).log(Level.SEVERE, null, ex);
//        }
//        java.awt.EventQueue.invokeLater(new Runnable() {
//            public void run() {
//                new NewJFrame().setVisible(true);
//            }
//        });
//    }

    // Variables declaration - do not modify                     
    private javax.swing.ButtonGroup buttonGroup1;
    private javax.swing.JButton jButton1;
    private javax.swing.JComboBox jComboBox1;
    private javax.swing.JLabel jLabel1;
    private javax.swing.JLabel jLabel2;
    private javax.swing.JLabel jLabel3;
    private javax.swing.JLabel jLabel4;
    private javax.swing.JTextField jTextField1;
    private javax.swing.JTextField jTextField2;
    private javax.swing.JTextField jTextField3;
    // End of variables declaration                   

    private void init() {
        //throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.
         CALUI.setIcon(this);
//        try {
//            CALUI.setLookAndFeel();
//        } catch (ClassNotFoundException ex) {
//            Logger.getLogger(NewJFrame.class.getName()).log(Level.SEVERE, null, ex);
//        }
         CALUI.setWindowCenter(this);
         this.setTitle("计算器");
    }

   
}

设置外观

/*
 * To change this license header, choose License Headers in Project Properties.
 * To change this template file, choose Tools | Templates
 * and open the template in the editor.
 */

package newpackageUI;

import java.awt.Dimension;
import java.awt.Image;
import java.awt.Toolkit;
import java.util.logging.Level;
import java.util.logging.Logger;
import javax.swing.JFrame;
import javax.swing.UIManager;
import javax.swing.UnsupportedLookAndFeelException;
import mathcal.NewJFrame;

/**
 *
 * @author Administrator
 */
public class CALUI {
    
    public static void setIcon(JFrame njf){
        Toolkit tk = Toolkit.getDefaultToolkit();
        Image i = tk.getImage("src\\newpackagesrc\\timg.jpg");
        njf.setIconImage(i);
    }
    
    public static void setWindowBackground(JFrame jf){
        Toolkit tk = Toolkit.getDefaultToolkit();
       
    }
    
    public static void setWindowCenter(JFrame jf){
        Toolkit tk = Toolkit.getDefaultToolkit();
        Dimension d = tk.getScreenSize();
        double screenWidth = d.getWidth();        
        double screenHeight = d.getHeight();
        int jfWidth = jf.getWidth();
        int jfHeight = jf.getHeight();
        int x = (int)(screenWidth- jfWidth)/2;
        int y = (int)(screenHeight- jfHeight)/2;
        jf.setLocation(x,y);
    }
    
    public static void setLookAndFeel(){
        try {
            UIManager.setLookAndFeel("javax.swing.plaf.multi.MultiLookAndFeel "
            );   
        } catch (ClassNotFoundException ex) {
            Logger.getLogger(CALUI.class.getName()).log(Level.SEVERE, null, ex);
        } catch (InstantiationException ex) {
            Logger.getLogger(CALUI.class.getName()).log(Level.SEVERE, null, ex);
        } catch (IllegalAccessException ex) {
            Logger.getLogger(CALUI.class.getName()).log(Level.SEVERE, null, ex);
        } catch (UnsupportedLookAndFeelException ex) {
            Logger.getLogger(CALUI.class.getName()).log(Level.SEVERE, null, ex);
        }
       
    }
}