AWT的基础知识

本章任务

1.创建窗口，指定大小，位置，在窗口上可以自由添加组件，

2.自己可以合理布局

3.处理常见的按钮点击事件

本章目标

1.熟练使用JFrame的相关组件

2.能够将数据库表中的数据按照自己的意愿，展示在窗口容器中

3.对常见的布局管理器了解

4.能够理解事件处理机制，熟练使用常见的事件监听器（ActionListener,MouseListener），事件适配器(MouseAdapter)

AWT的基础知识

GUI（Graphical user interface,即图形用户界面），应用程序提供给用户操作的图形用户界面，包括菜单、窗口、按钮、工具栏、和其他各种屏幕元素。

在JDK中提供了AWT和Swing两个包，用于GUI程序的设计和开发。AWT是早期版本，swing是对awt的改进，提供了更加丰富的组件和功能，掌握了awt基本上就掌握了swing

 

GUI结构图

Component & Container

java的图形用户界面的最基本组成部分是Component,Component类及其子类的对象用来描述以图形化的方式显示在屏幕上并能与用户进行交互的GUI元素，例如，一个按钮，一个标签等。

一般的Component对象不能独立地显示出来，必须将“放在”某一的Container对象中才可以显示出来。

Container是Component子类，Container子类对象可以“容纳”别的Component对象。

Container对象可使用方法add(...)向其中添加其他Component对象。

Container是Component的子类，因此Container对象也可以被当作Component对象添加到其他Container对象中。

有两种常用的Container:

Window：其对象表示自由停泊的顶级窗口

  Panel:其对象可作为容纳其他Component对象，但不能独立存在，必须被添加到其他Container中（如Window或Applet）

 

示例1：创建JFrame窗口，设置大小为（400,500），位置（200,100），设置窗口关闭操作，窗口可见。

package com.njwb.components.use;

import javax.swing.JFrame;

/**

 * 新建一个窗口，在屏幕的指定位置显示

 * JFrame 是Frame的子类

 * @author Administrator

 *

 */

public class Test01 {

public static void main(String[] args) {

//创建一个窗口

JFrame jf = new JFrame("My first JFrame");

//设置大小

jf.setSize(400, 500);

//设置位置（坐标）

jf.setLocation(200, 100);

//设置关闭操作,退出即关闭

jf.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

//设置窗口可见

jf.setVisible(true);

}

}

示例2 窗口居中显示(获取本机工具包—>获取屏幕尺寸—>(屏幕宽，高)),窗口大小仍为（400,500），窗口位置(（w1-400）/2,(h1-500)/2)

package com.njwb.components.use;

import java.awt.Dimension;

import java.awt.Toolkit;

import javax.swing.JFrame;

/**

 * 屏幕居中显示

 * setLocation(x,y) x,y指的的是你设置的窗口的左上角的坐标

 * @author Administrator

 *

 */

public class Test02 {

public static void main(String[] args) {

//创建一个窗口

JFrame jf = new JFrame("My second JFrame");

//设置大小

jf.setSize(400, 500);

//获取本机的工具包

Toolkit tk = Toolkit.getDefaultToolkit();

//获取屏幕的尺寸

Dimension d = tk.getScreenSize();

//获取屏幕的宽

int width = d.width;

//获取屏幕的高

int height = d.height;

//设置位置（坐标）

//jf.setLocation(width/2-200, height/2-250);

jf.setLocation((width-400)/2, (height-500)/2);

//设置关闭操作,退出即关闭

jf.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

//设置窗口可见

jf.setVisible(true);

}

}

示例3： 添加组件(添加1个按钮位置（100,400,80,40）)，布局管理器设置为空，其余设置保持不变,

package com.njwb.components.use;

import java.awt.Dimension;

import java.awt.Toolkit;

import javax.swing.JButton;

import javax.swing.JFrame;

/**

 * 添加按钮

 * @author Administrator

 *

 */

public class Test03 {

public static void main(String[] args) {

//创建一个窗口

JFrame jf = new JFrame("My second JFrame");

//设置布局管理器为null  默认是BorderLayout

jf.setLayout(null);

//创建一个按钮

//JButton but = new JButton("按钮");

JButton but = new JButton();

//setText()设置按钮的显示文本

but.setText("按钮");

//该位置是相对于父容器左上角而言

//but.setLocation(100, 400);

//but.setSize(80, 40);

but.setBounds(100, 400, 80, 40);

//将按钮添加到窗口中

jf.add(but);

//设置大小

jf.setSize(400, 500);

//获取本机的工具包

Toolkit tk = Toolkit.getDefaultToolkit();

//获取屏幕的尺寸

Dimension d = tk.getScreenSize();

//获取屏幕的宽

int width = d.width;

//获取屏幕的高

int height = d.height;

//设置位置（坐标）

jf.setLocation((width-400)/2, (height-500)/2);

//设置关闭操作,退出即关闭

jf.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

//设置窗口可见

jf.setVisible(true);

}

}

布局管理器

BorderLayout

这是一个布置容器的边框布局，它可以对容器组件进行安排，并调整其大小，使其符合下列五个区域：北、南、东、西、中。每个区域最多只能包含一个组件，并通过相应的常量进行标识：NORTH、SOUTH、EAST、WEST、CENTER。当使用边框布局将一个组件添加到容器中时，要使用这五个常量之一。

根据其首选大小和容器大小的约束 (constraints) 对组件进行布局。NORTH 和 SOUTH 组件可以在水平方向上拉伸；而 EAST 和 WEST 组件可以在垂直方向上拉伸；CENTER 组件可同时在水平和垂直方向上拉伸，从而填充所有剩余空间

package com.njwb.layoutmanager.use;

import java.awt.BorderLayout;

import java.awt.Dimension;

import java.awt.Toolkit;

import javax.swing.JButton;

import javax.swing.JFrame;

/**

 * 布局1是JFrame的默认布局管理器  边框布局

 * BorderLayout()

 * BorderLayout(int hgap,int vgap)

 * @author Administrator

 *

 */

public class TestBorderLayout {

public static void main(String[] args) {

//创建一个窗口

JFrame jf = new JFrame("My second JFrame");

//按钮之间没有间隔

//jf.setLayout(new BorderLayout());

// 水平间距， 垂直间距

jf.setLayout(new BorderLayout(5,12));

//创建一个按钮

JButton but1 = new JButton("按钮1");

but1.setBounds(100, 400, 80, 40);

JButton but2 = new JButton("按钮2");

but2.setBounds(100, 400, 80, 40);

JButton but3 = new JButton("按钮3");

but3.setBounds(100, 400, 80, 40);

JButton but4 = new JButton("按钮4");

but4.setBounds(100, 400, 80, 40);

JButton but5 = new JButton("按钮5");

but5.setBounds(100, 400, 80, 40);

//将按钮添加到窗口中

//两种都可以， 指定区域的BorderLayout.North可以放在第一个参数或者第2个参数都可以

//jf.add(BorderLayout.NORTH,but1);

jf.add(but1,BorderLayout.NORTH);

jf.add(BorderLayout.SOUTH,but2);

jf.add(BorderLayout.WEST,but3);

jf.add(BorderLayout.EAST,but4);

jf.add(BorderLayout.CENTER,but5);

//设置大小

jf.setSize(400, 500);

//获取本机的工具包

Toolkit tk = Toolkit.getDefaultToolkit();

//获取屏幕的尺寸

Dimension d = tk.getScreenSize();

//获取屏幕的宽

int width = d.width;

//获取屏幕的高

int height = d.height;

//设置位置（坐标）

jf.setLocation((width-400)/2, (height-500)/2);

//设置关闭操作,退出即关闭

jf.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

//设置窗口可见

jf.setVisible(true);

}

}

FlowLayout

流布局一般用来安排面板中的按钮。它使得按钮呈水平放置，直到同一条线上再也没有适合的按钮。线的对齐方式由 align 属性确定。可能的值为：

· LEFT 

· RIGHT 

· CENTER 

· LEADING 

· TRAILING 

package com.njwb.layoutmanager.use;

import java.awt.Dimension;

import java.awt.Toolkit;

import javax.swing.JButton;

import javax.swing.JFrame;

/**

 * 布局2是Panel面板的默认布局管理器 流式布局

 * FlowLayout(int align)

 * FlowLayout(int align,int hgap,int vgap)

 * @author Administrator

 *

 */

public class TestFlowLayout {

public static void main(String[] args) {

//创建一个窗口

JFrame jf = new JFrame("My second JFrame");

//按钮之间没有间隔  默认居中对齐，水平，垂直，都是5个单位

//jf.setLayout(new FlowLayout());左对齐 ，水平，垂直都是5个单位

//jf.setLayout(new FlowLayout(FlowLayout.LEFT));

//水平间距是10个单位，垂直间距是20个单位

//jf.setLayout(new FlowLayout(FlowLayout.RIGHT,10,20));

//创建一个按钮

JButton but1 = new JButton("按钮1");

but1.setBounds(100, 400, 80, 40);

JButton but2 = new JButton("按钮2");

but2.setBounds(100, 400, 80, 40);

JButton but3 = new JButton("按钮3");

but3.setBounds(100, 400, 80, 40);

JButton but4 = new JButton("按钮4");

but4.setBounds(100, 400, 80, 40);

JButton but5 = new JButton("按钮5");

but5.setBounds(100, 400, 80, 40);

//将按钮添加到窗口中

jf.add(but1);

jf.add(but2);

jf.add(but3);

jf.add(but4);

jf.add(but5);

//设置大小

jf.setSize(400, 500);

//获取本机的工具包

Toolkit tk = Toolkit.getDefaultToolkit();

//获取屏幕的尺寸

Dimension d = tk.getScreenSize();

//获取屏幕的宽

int width = d.width;

//获取屏幕的高

int height = d.height;

//设置位置（坐标）

jf.setLocation((width-400)/2, (height-500)/2);

//设置关闭操作,退出即关闭

jf.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

//设置窗口可见

jf.setVisible(true);

}

}

GridLayout

GridLayout 类是一个布局处理器，它以矩形网格形式对容器的组件进行布置。容器被分成大小相等的矩形，一个矩形中放置一个组件。

package com.njwb.layoutmanager.use;

import java.awt.Dimension;

import java.awt.GridLayout;

import java.awt.Toolkit;

import javax.swing.JButton;

import javax.swing.JFrame;

/**

 * 布局3  几行几列 网格布局

 * GridLayout(int rows,int cols)

 *  行数，列数  水平间距  垂直间距

 * GridLayout(int rows,int cols,int hgap,int vgap)

 * @author Administrator

 *

 */

public class TestGridLayout {

public static void main(String[] args) {

//创建一个窗口

JFrame jf = new JFrame("My second JFrame");

//2 行，3列

//jf.setLayout(new GridLayout(2,4));

jf.setLayout(new GridLayout(2,4,5,20));

//创建一个按钮

JButton but1 = new JButton("按钮1");

but1.setBounds(100, 400, 80, 40);

JButton but2 = new JButton("按钮2");

but2.setBounds(100, 400, 80, 40);

JButton but3 = new JButton("按钮3");

but3.setBounds(100, 400, 80, 40);

JButton but4 = new JButton("按钮4");

but4.setBounds(100, 400, 80, 40);

JButton but5 = new JButton("按钮5");

but5.setBounds(100, 400, 80, 40);

JButton but6 = new JButton("按钮6");

but6.setBounds(100, 400, 80, 40);

JButton but7 = new JButton("按钮7");

but7.setBounds(100, 400, 80, 40);

//将按钮添加到窗口中

jf.add(but1);

jf.add(but2);

jf.add(but3);

jf.add(but4);

jf.add(but5);

jf.add(but6);

jf.add(but7);

//设置大小

jf.setSize(400, 500);

//获取本机的工具包

Toolkit tk = Toolkit.getDefaultToolkit();

//获取屏幕的尺寸

Dimension d = tk.getScreenSize();

//获取屏幕的宽

int width = d.width;

//获取屏幕的高

int height = d.height;

//设置位置（坐标）

jf.setLocation((width-400)/2, (height-500)/2);

//设置关闭操作,退出即关闭

jf.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

//设置窗口可见

jf.setVisible(true);

}

}

事件处理机制

通过GUI组件用户可以对应用程序进行各种操作，反之，应用程序可以通过各种组件来收集用户的操作信息，比如移动鼠标，按下键盘等，GUI只是提供给用户操作的图形界面，但GUI本身并不对用户的操作结果负责，比如单击按钮，程序并不知道在单击按钮时应该做出什么样的反应，如果想要单击按钮时程序响应某种功能，我们就必须编写相应的程序代码。

上一节的程序中在我们点击关闭按钮时并不能关闭窗口和结束程序，只能通过结束进程的方式结束。

Java设计了一种专门的方式称为事件处理机制，来处理程序和用户之间的交互。

在事件处理机制中需要了解3个重要的概念

1、 事件：用户对组件的操作称为事件

2、 事件源：发生事件的组件就是事件源

3、 事件处理器：某个java类中负责处理事件的成员方法。（我们要对事件进行处理肯定是编写程序代码，当发生了某种事件，只要调用写好的程序代码即可）

事件源、事件、事件处理器之间的工作关系：

对某个事件的处理的方法必须是java中的某个类的成员方法，这个类就称为事件监听器类，一个事件监听器对象必须先跟某个事件源进行关联，关联的过程称为监听器向事件源注册监听，这样当组件发生事件时，就知道该找哪个事件监听对象中的哪个方法了。

注册完后，当组件接收到外部的作用，组件就会产生事件对象，并将事件对象传递给事件处理器来处理，在事件处理器中，只要打开事件对象看事件对象中的信息就知道发生了什么样的事情和事情的一些细节，比如发生事件时鼠标的位置。

举例：按钮点击事件

package com.njwb.components.use;

import java.awt.Dimension;

import java.awt.Toolkit;

import java.awt.event.ActionEvent;

import java.awt.event.ActionListener;

import javax.swing.JButton;

import javax.swing.JFrame;

 

/**

 * 点击按钮，在控制台输出一句话“按钮被点击”

 * 事件的源头 ： 按钮

 * 事件处理器： 点击按钮，引发一个响应，这个响应需要1个类来处理掉，这个类 就叫做 事件处理器

 * 事件源  和事件处理器之间如何建立联系？   给事件源注册监听  addActionListener(事件处理器对象);

 * @author Administrator

 *

 */

public class Test04 {

public static void main(String[] args) {

//创建一个窗口

JFrame jf = new JFrame("My second JFrame");

//设置布局管理器为null  默认是BorderLayout

jf.setLayout(null);

//创建一个按钮

JButton but = new JButton("按钮");

but.setBounds(100, 400, 80, 40);

//创建1个事件处理器对象

//给自身注册监听

but.addActionListener(new ActionListener(){

//动作发生时，会有一个事件传入，在该方法中将该事件处理掉（对该事件作出响应）

@Override

public void actionPerformed(ActionEvent e) {

System.out.println("按钮被点击");

}

});

//将按钮添加到窗口中

jf.add(but);

//设置大小

jf.setSize(400, 500);

//获取本机的工具包

Toolkit tk = Toolkit.getDefaultToolkit();

//获取屏幕的尺寸

Dimension d = tk.getScreenSize();

//获取屏幕的宽

int width = d.width;

//获取屏幕的高

int height = d.height;

//设置位置（坐标）

jf.setLocation((width-400)/2, (height-500)/2);

//设置关闭操作,退出即关闭

jf.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

//设置窗口可见

jf.setVisible(true);

}

}

package com.njwb.components.use;

import java.awt.Dimension;

import java.awt.Toolkit;

import java.awt.event.ActionEvent;

import java.awt.event.ActionListener;

import javax.swing.JButton;

import javax.swing.JFrame;

/**

 * 点击按钮，在控制台输出一句话“按钮被点击”

 * 事件的源头 ： 按钮

 * 事件处理器： 点击按钮，引发一个响应，这个响应需要1个类来处理掉，这个类 就叫做 事件处理器

 * 事件源  和事件处理器之间如何建立联系？   给事件源注册监听  addActionListener(事件处理器对象);

 * @author Administrator

 *

 */

class MyAction  implements ActionListener{

//动作发生时，会有一个事件传入，在该方法中将该事件处理掉（对该事件作出响应）

@Override

public void actionPerformed(ActionEvent e) {

System.out.println("按钮被点击");

}

}

public class Test042 {

public static void main(String[] args) {

//创建一个窗口

JFrame jf = new JFrame("My second JFrame");

//设置布局管理器为null  默认是BorderLayout

jf.setLayout(null);

//创建一个按钮

JButton but = new JButton("按钮");

but.setBounds(100, 400, 80, 40);

//创建1个事件处理器对象

//MyAction m = new MyAction();

//给自身注册监听

//but.addActionListener(m);

but.addActionListener(new MyAction());

//将按钮添加到窗口中

jf.add(but);

//设置大小

jf.setSize(400, 500);

//获取本机的工具包

Toolkit tk = Toolkit.getDefaultToolkit();

//获取屏幕的尺寸

Dimension d = tk.getScreenSize();

//获取屏幕的宽

int width = d.width;

//获取屏幕的高

int height = d.height;

//设置位置（坐标）

jf.setLocation((width-400)/2, (height-500)/2);

//设置关闭操作,退出即关闭

jf.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

//设置窗口可见

jf.setVisible(true);

}

}

事件分类

事件用于描述发生了什么事情。我们根据这些事情给事件进行分类，事件对象就是事件类的实例对象。

按产生事件的物理操作和GUI组件的表现效果进行分类：举例：

MouseEvent

WindowEvent

ActionEvent事件的基本操作，例如按钮操作，不考虑是鼠标的单击还是快捷键时就可以使用ActionEvent

…

如果事件对应的监听器中的成员方法仅有一个，就可以称为是语义事件，是高级事件，

如果事件对应的监听器中的成员方法有多种方法即事件发生的每一种情况都有对应的方法处理，就是低级事件

事件监听器

java.awt.event.* 下    MouseListener (5个方法) 鼠标监听器, ActionListener（1个方法）动作监听器，通常监听按钮的点击动作KeyListener(按键监听器)

一个事件监听器对象负责处理一类事件，这一类事件的每一种情况的发生分别由事件监听器对象中的一个方法来具体处理

在事件源和事件监听器对象中进行约定的接口类就称为事件监听器接口

事件监听器接口类的名称与事件类的名称是相对应的，例如，MouseEvent事件类的监听器接口名为MouseListener。

举例：

package com.njwb.components.use;

import java.awt.Dimension;

import java.awt.Toolkit;

import java.awt.event.MouseEvent;

import java.awt.event.MouseListener;

import javax.swing.JFrame;

/**

 * MouseListener 鼠标监听接口，提供5个方法，实现类都需要实现

 * @author Administrator

 *

 */

class MyMouse implements MouseListener{

@Override

public void mouseClicked(MouseEvent e) {

System.out.println("鼠标被点击");

}

@Override

public void mouseEntered(MouseEvent e) {

System.out.println("鼠标进入窗口");

}

@Override

public void mouseExited(MouseEvent e) {

System.out.println("鼠标退出窗口");

}

@Override

public void mousePressed(MouseEvent e) {

System.out.println("鼠标按下");

}

@Override

public void mouseReleased(MouseEvent e) {

System.out.println("鼠标释放");

}

}

public class Test06 {

public static void main(String[] args) {

//创建一个窗口

JFrame jf = new JFrame("My second JFrame");

//设置布局管理器为null  默认是BorderLayout

jf.setLayout(null);

//创建事件处理器对象

//MyMouse m = new MyMouse();

//给窗口添加监听器对象

//jf.addMouseListener(m);

jf.addMouseListener(new MyMouse());

//设置大小

jf.setSize(400, 500);

//获取本机的工具包

Toolkit tk = Toolkit.getDefaultToolkit();

//获取屏幕的尺寸

Dimension d = tk.getScreenSize();

//获取屏幕的宽

int width = d.width;

//获取屏幕的高

int height = d.height;

//设置位置（坐标）

jf.setLocation((width-400)/2, (height-500)/2);

//设置关闭操作,退出即关闭

jf.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

//设置窗口可见

jf.setVisible(true);

}

}

package com.njwb.components.use;

import java.awt.Dimension;

import java.awt.Toolkit;

import java.awt.event.MouseEvent;

import java.awt.event.MouseListener;

import javax.swing.JFrame;

/**

 * MouseListener 鼠标监听接口，提供5个方法，实现类都需要实现

 * @author Administrator

 *

 */

public class Test062 {

public static void main(String[] args) {

//创建一个窗口

JFrame jf = new JFrame("My second JFrame");

//设置布局管理器为null  默认是BorderLayout

jf.setLayout(null);

//创建事件处理器对象

//给窗口添加监听器对象

jf.addMouseListener(new MouseListener(){

@Override

public void mouseClicked(MouseEvent e) {

System.out.println("鼠标被点击");

}

@Override

public void mouseEntered(MouseEvent e) {

System.out.println("鼠标进入窗口");

}

@Override

public void mouseExited(MouseEvent e) {

System.out.println("鼠标退出窗口");

}

@Override

public void mousePressed(MouseEvent e) {

System.out.println("鼠标按下");

}

@Override

public void mouseReleased(MouseEvent e) {

System.out.println("鼠标释放");

}

});

//设置大小

jf.setSize(400, 500);

//获取本机的工具包

Toolkit tk = Toolkit.getDefaultToolkit();

//获取屏幕的尺寸

Dimension d = tk.getScreenSize();

//获取屏幕的宽

int width = d.width;

//获取屏幕的高

int height = d.height;

//设置位置（坐标）

jf.setLocation((width-400)/2, (height-500)/2);

//设置关闭操作,退出即关闭

jf.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

//设置窗口可见

jf.setVisible(true);

}

}

事件适配器

为了简化事件监听器接口实现类的编程，java提供了大多数事件监听器接口的简单的实现类，称为事件适配器（Adapter）类。适配器类简单的实现了监听器接口中的所有的方法。

用事件适配器来处理事件，可以简化事件监听器的编写，因为一个类只要实现了适配器的方法，就等于实现了监听器接口。如果要对某类监听器的某类情况进行处理只要在适配器的处理类中覆盖处理这种事件的方法就可以了。

KeyAdapter 按键适配器类  keyPressed(KeyEvent e)  keyReleased(KeyEvent e)   keyTyped(KeyEvent e)

MouseAdapter  鼠标适配器类 ，是MouseListener接口的实现类，已经实现了MoseListener接口中的5个抽象方法，

mouseClicked(MouseEvent e)  mouseEntered(MouseEvent e) mouseExited(MouseEvent e) mousePressed(MouseEvent e) mouseReleased(MouseEvent e)

同时也是MouseWheelListener接口的实现类，实现了该接口的抽象方法mouseWheelMoved(MouseWheelEvent e) ,同时也是MouseMotionListener接口的实现类，实现了该接口的2个抽象方法

mouseDragged(MouseEvent e)，mouseMoved(MouseEvent e) ，

适配器类的8个方法，都是普通方法，子类可以有选择的根据自己的需求去重写父类的方法，不需要全部实现。

举例：

package com.njwb.components.use;

import java.awt.Dimension;

import java.awt.Toolkit;

import java.awt.event.MouseAdapter;

import java.awt.event.MouseEvent;

import javax.swing.JFrame;

/**

 * 适配器类虽然是抽象类，但是提供的方法都是普通方法，  子类继承适配器类 ，子类可以有选择的去重写父类的方法

 * @author Administrator

 *

 */

class MyMouseAda extends MouseAdapter{

@Override

public void mouseClicked(MouseEvent e) {

System.out.println("鼠标被点击");

}

@Override

public void mouseEntered(MouseEvent e) {

System.out.println("鼠标进入窗口");

}

@Override

public void mouseExited(MouseEvent e) {

System.out.println("鼠标退出窗口");

}

}

public class Test07 {

public static void main(String[] args) {

//创建一个窗口

JFrame jf = new JFrame("My second JFrame");

//设置布局管理器为null  默认是BorderLayout

jf.setLayout(null);

//给当前窗口注册监听

jf.addMouseListener(new MyMouseAda());

//设置大小

jf.setSize(400, 500);

//获取本机的工具包

Toolkit tk = Toolkit.getDefaultToolkit();

//获取屏幕的尺寸

Dimension d = tk.getScreenSize();

//获取屏幕的宽

int width = d.width;

//获取屏幕的高

int height = d.height;

//设置位置（坐标）

jf.setLocation((width-400)/2, (height-500)/2);

//设置关闭操作,退出即关闭

jf.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

//设置窗口可见

jf.setVisible(true);

}

}

package com.njwb.components.use;

import java.awt.Dimension;

import java.awt.Toolkit;

import java.awt.event.MouseAdapter;

import java.awt.event.MouseEvent;

import javax.swing.JFrame;

/**

 *

 * @author Administrator

 *

 */

 

public class Test072 {

public static void main(String[] args) {

//创建一个窗口

JFrame jf = new JFrame("My second JFrame");

//设置布局管理器为null  默认是BorderLayout

jf.setLayout(null);

//设置大小

jf.setSize(400, 500);

//获取本机的工具包

Toolkit tk = Toolkit.getDefaultToolkit();

//获取屏幕的尺寸

Dimension d = tk.getScreenSize();

//获取屏幕的宽

int width = d.width;

//获取屏幕的高

int height = d.height;

//设置位置（坐标）

jf.setLocation((width-400)/2, (height-500)/2);

//创建事件处理器对象

//给窗口添加监听器对象

jf.addMouseListener(new MouseAdapter() {

@Override

public void mouseClicked(MouseEvent e) {

System.out.println("鼠标被点击");

}

@Override

public void mouseEntered(MouseEvent e) {

System.out.println("鼠标进入窗口");

}

@Override

public void mouseExited(MouseEvent e) {

System.out.println("鼠标退出窗口");

}

});

//设置关闭操作,退出即关闭

jf.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

//设置窗口可见

jf.setVisible(true);

}

}

Graphics类

每个Component都有一个paint(Graphics g) 用于实现绘图目的，每次重画该Component时都自动调用paint方法。

Graphics类中提供了许多绘图方法，如：

drawRect(int x,int y,int width,int height)

fillRoundRect(int x,int y,int width,int height,int arcWidth,int arcHeight)

paint(Graphics g)

以下圆位置大小（50,50,30,30），红色，矩形（80,80,50,50），绿色,窗口位置大小（200,200,640,480）

 

package com.njwb.components.use;

import java.awt.Color;

import java.awt.Graphics;

import javax.swing.JFrame;

/**

 * 绘制指定图形

 * @author Administrator

 *

 */

class GraphicFrame extends JFrame{

public GraphicFrame(String title) {

//调用父类JFrame的带参构造

super(title);

setLayout(null);

setBounds(200, 200, 640, 480);

//设置关闭操作,退出即关闭

setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

//设置窗口可见

setVisible(true);

}

/**

 * JFrame的子类，paint()方法,窗口显示自动调用

 */

@Override

public void paint(Graphics g) {

super.paint(g);

//获取画笔的原有颜色

Color c = g.getColor();

//设置画笔颜色为红色

g.setColor(Color.red);

//画的的线条(x,y,width,height), width=height圆

//g.drawOval(50, 50, 30, 30);

//填充的实心

g.fillOval(50, 50, 30, 30);

//设置画笔颜色为绿色

g.setColor(Color.green);

//填充的矩形

//g.drawRect(80, 80, 50, 50);

//g.drawLine(100, 100,300, 300);

g.fillRect(80, 80, 50, 50);

//还原画笔颜色

g.setColor(c);

System.out.println("*****");

}

}

public class Test05 {

public static void main(String[] args) {

//创建一个窗口

GraphicFrame gf = new GraphicFrame("图形");

}

}

示例4： 给按钮添加监听事件（如果按钮被点击，那么在控制台打印“按钮被点击”,添加ActionListener监听器，分为2类实现，一种自定义的监听器类，一种匿名内部类）。 给窗口添加（MouseListener监听器，一种是自定义的监听器类，一种是匿名内部类），另外使用匿名内部类时，可比较MouseListener接口实现，MouseAdapter适配器实现的区别。(拆分成3个方法 ，第1个初始化大小 initFrame() 设置关闭, 第2个添加组件 addComponents()，布局设置为空,第3个添加监听addListener())

package com.njwb.components.use;

import java.awt.Dimension;

import java.awt.Toolkit;

import java.awt.event.MouseAdapter;

import java.awt.event.MouseEvent;

import javax.swing.JFrame;

 

/**

 *

 * @author Administrator

 *

 */

 

public class Test073 extends JFrame {

public Test073(String title) {

super(title); //调用JFrame的带参构造

initFrame();

addComponents();

addListener();

this.setVisible(true);

}

/**

 * 初始化大小

 */

protected void initFrame(){

//设置布局管理器为null  默认是BorderLayout

this.setLayout(null);

//设置大小

this.setSize(400, 500);

//获取本机的工具包

Toolkit tk = Toolkit.getDefaultToolkit();

//获取屏幕的尺寸

Dimension d = tk.getScreenSize();

//获取屏幕的宽

int width = d.width;

//获取屏幕的高

int height = d.height;

//设置位置（坐标）

this.setLocation((width-400)/2, (height-500)/2);

this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

}

/**

 * 添加组件

 */

protected void addComponents(){

}

/**

 * 添加监听

 */

protected void addListener(){

this.addMouseListener(new MouseAdapter() {

@Override

public void mouseClicked(MouseEvent e) {

System.out.println("鼠标被点击");

}

@Override

public void mouseEntered(MouseEvent e) {

System.out.println("鼠标进入窗口");

}

@Override

public void mouseExited(MouseEvent e) {

System.out.println("鼠标退出窗口");

}

 

});

}

public static void main(String[] args) {

//创建一个窗口

Test073 t = new Test073("窗口");

}

}

 

示例5 在窗口指定位置(100,200)绘制红色字符串”hello GUI”,要求字符串大小比系统默认字体大小大10个点，字体名，风格保持不变

 

package com.njwb.graphic.use;

import java.awt.Color;

import java.awt.Dimension;

import java.awt.Font;

import java.awt.Graphics;

import java.awt.GraphicsEnvironment;

import java.awt.Toolkit;

import javax.swing.JFrame;

/**

 * java.awt.GraphicsEnvironment

 * abstract  Font[] getAllFonts()

          返回一个数组，它包含此 GraphicsEnvironment中所有可用字体的像素级实例。

 * Font(String name, int style,int size)

 * 第1个参数 字体的名称  Arial  ,Dialog,Serif,默认是Default

 * 第2个参数Plain ,Italic(倾斜) Bold（加粗）

 * @author Administrator

 *

 */

public class Test01 extends JFrame{

public Test01(String title) {

super(title);

initFrame();

addComponents();

addListener();

this.setVisible(true);

}

/**

 * 初始化大小

 */

protected void initFrame(){

//布局管理器

this.setLayout(null);

Toolkit tk = Toolkit.getDefaultToolkit();

Dimension d = tk.getScreenSize();

int width = d.width;

int height = d.height;

this.setBounds((width-400)/2, (height-500)/2, 400, 500);

this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

}

/**

 * 添加组件

 */

protected void addComponents(){

}

/**

 * 添加监听

 */

protected void addListener(){

}

@Override

public void paint(Graphics g) {

super.paint(g);

//获取画笔原有的颜色

Color c = g.getColor();

//获取原有的字体

Font f = g.getFont();

//创建新字体 (字体的名称，字体的风格，字体的大小)

//Font nFont = new Font(f.getName(),f.getStyle(),f.getSize()+30);

//Font nFont = new Font("Arial",Font.PLAIN,f.getSize()+30);

//Font nFont = new Font("Serif",Font.PLAIN,f.getSize()+30);

//Font nFont = new Font("楷体",Font.PLAIN,f.getSize()+30);

//Font nFont = new Font("微软雅黑",Font.PLAIN,f.getSize()+30);

Font nFont = new Font("Dialog",Font.PLAIN,f.getSize()+30);

//Font nFont = new Font("Arial",Font.ITALIC,f.getSize()+30);

//设置红色

g.setColor(Color.red);

//设置新字体

g.setFont(nFont);

//绘制字符串

g.drawString("hello GUI", 100, 200);

//还原成原有的颜色

g.setColor(c);

//还原成原有的字体

g.setFont(f);

System.out.println("******");

}

public static void main(String[] args) {

Font[] arr =GraphicsEnvironment.getLocalGraphicsEnvironment().getAllFonts();

for(Font f:arr){

System.out.println(f.getName());

}

Test01 t = new Test01("绘制字符串");

}

}

示例6 将指定的物理文件（E:/others/name.txt，一行一个）中的人名读取出来显示在窗口中，500ms显示1个,开始按钮（100,300,80,40），停止按钮（200,300,80,40），字符串（100,200），开始时，开启线程，停止时，终止线程

 

 

分析： 人名一行一个，人名读取出来保存到 集合List中，每500ms取出一个  list.get(i) ,在线程体里 ,需要循环，因为点击开始后，人名始终跳动，没有停止,控制线程的开启或者停止，需要1个标志位，如果终止线程的话，提供1个公有的方法，更改此标志位的值

 

class Test02 extends JFrame{

 

Test02(String title){

…….

}

 

paint(){

 

}

 

initFrame(){

 

}

 

addComponents(){

//添加2个按钮

 

}

addListener(){

 

开始按钮.addActionListener( 开启线程);

 

停止按钮.addActionListener(结束线程);

 

}

 

//多线程类是Test02的内部类 ，为什么设计成内部类，方便调用外部的paint()方法，绘制字符串

 

class ReadNameThread extends Thread{

void run(){

while(isRunning){

//获取到1个人名，调用1次绘制的方法paint()

}

}

 

 

}

}

package com.njwb.graphic.use;

import java.awt.*;

import java.awt.event.ActionEvent;

import java.awt.event.ActionListener;

import java.io.*;

import java.util.ArrayList;

import java.util.List;

import javax.swing.JButton;

import javax.swing.JFrame;

/**

 * @author Administrator

 *

 */

public class Test02 extends JFrame{

public Test02(String title) {

super(title);

initFrame();

addComponents();

addListener();

this.setVisible(true);

}

private JButton startBut = new JButton("开始");

private JButton stopBut = new JButton("停止");

private String name = ""; //用于存储从list集合中取出的人名

/**

 * 初始化大小

 */

protected void initFrame(){

Toolkit tk = Toolkit.getDefaultToolkit();

Dimension d = tk.getScreenSize();

int width = d.width;

int height = d.height;

this.setBounds((width-400)/2, (height-500)/2, 400, 500);

this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

}

/**

 * 添加组件

 */

protected void addComponents(){

//布局管理器

this.setLayout(null);

startBut.setBounds(100, 300, 80, 40);

stopBut.setBounds(200, 300, 80, 40);

this.add(startBut);

this.add(stopBut);

}

/**

 * 添加监听

 */

//声明线程对象

ReadNameThread rt = null;

protected void addListener(){

startBut.addActionListener(new ActionListener() {

@Override

public void actionPerformed(ActionEvent e) {

//开启线程

rt = new ReadNameThread();

rt.start();

}

});

stopBut.addActionListener(new ActionListener() {

@Override

public void actionPerformed(ActionEvent e) {

//结束线程

if(null!=rt){

rt.stopThead();

}

}

});

}

@Override

public void paint(Graphics g) {

super.paint(g);

//获取画笔原有的颜色

Color c = g.getColor();

//获取原有的字体

Font f = g.getFont();

//创建新字体 (字体的名称，字体的风格，字体的大小)

Font nFont = new Font(f.getName(),f.getStyle(),f.getSize()+10);

//设置红色

g.setColor(Color.red);

//设置新字体

g.setFont(nFont);

//绘制字符串

g.drawString(name, 100, 200);

//还原成原有的颜色

g.setColor(c);

//还原成原有的字体

g.setFont(f);

}

public static void main(String[] args) {

Test02 t = new Test02("抽奖");

}

class ReadNameThreadextends Thread{

private boolean isRunning =true; //用于控制循环是否继续，控制线程体是否结束

private BufferedReaderbr = null;

private List<String>list = new ArrayList<String>();

public ReadNameThread() {

try {

//建立输入流和源文件之间的联系

br = new BufferedReader(new FileReader("E:/others/name.txt"));

String data = null;

while((data = br.readLine())!=null){

list.add(data);

}

} catch (FileNotFoundException e) {

e.printStackTrace();

} catch (IOException e) {

e.printStackTrace();

}finally{

if(null!=br){

try {

br.close();

} catch (IOException e) {

e.printStackTrace();

}

}

}

}

@Override

public void run() {

int i=0;

while(isRunning && i<list.size()){

name = list.get(i);

//调用外部类的paint()方法绘制name ,调用的是repaint()

repaint();

try {

Thread.sleep(500);

} catch (InterruptedException e) {

e.printStackTrace();

}

i++;

//如果到头了，需要再次从0开始i最大值= list.size()-1

if(i>=list.size()){

i=0;

}

}

}

public void stopThead(){

isRunning = false;

}

}

}

常见组件

示例7 为下拉列表(,组件：JComboBox位置(100,200,100,70))添加内容：北京，上海，武汉，长沙，南京。为组件添加点击事件，每选择一个，就将相应项输出在控制台，同时将窗口标题更改为所选项。

 

 

package com.njwb.graphic.use;

import java.awt.*;

import java.awt.event.*;

import javax.swing.*;

/**

 * JcomboBox的使用 下拉列表

 * @author Administrator

 *

 */

public class Test03 extends JFrame{

public Test03(String title) {

super(title);

initFrame();

addComponents();

addListener();

this.setVisible(true);

}

private JComboBox jcb = null;

/**

 * 初始化大小

 */

protected void initFrame(){

Toolkit tk = Toolkit.getDefaultToolkit();

Dimension d = tk.getScreenSize();

int width = d.width;

int height = d.height;

this.setBounds((width-400)/2, (height-500)/2, 400, 500);

this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

}

/**

 * 添加组件

 */

protected void addComponents(){

//布局管理器

this.setLayout(null);

String[] data = {"南京","武汉","上海","北京","长沙"};

jcb = new JComboBox();

//遍历数组

for(int i=0;i<data.length;i++){

//给jcb添加单个列表项

jcb.addItem(data[i]);

}

jcb.setBounds(100, 200, 100, 70);

this.add(jcb);

}

/**

 * 添加监听

 */

protected void addListener(){

jcb.addActionListener(new ActionListener() {

@Override

public void actionPerformed(ActionEvent e) {

//获取选择的下拉列表项

String itemName = (String)jcb.getSelectedItem();

System.out.println(itemName);

//设置当前窗口的标题

setTitle(itemName);

}

});

}

public static void main(String[] args) {

Test03 t = new Test03("下拉列表");

}

}

示例8 文本框（JTextField 50, 50, 300, 40）中的内容，按回车键追加到文本域(JTextArea 50, 120, 300, 200),封装一个抽象父类MyFrame(initFrame()将大小，位置规定好，而添加组件，添加监听设计成抽象方法) ，新建子类继承自所创建的抽象类MyFrame. 标签（50, 350, 200, 50）。为文本框添加keyListener监听。

 

package com.njwb.graphic.use;

import java.awt.Dimension;

import java.awt.Toolkit;

import java.awt.event.KeyAdapter;

import java.awt.event.KeyEvent;

import javax.swing.JFrame;

import javax.swing.JLabel;

import javax.swing.JScrollPane;

import javax.swing.JTextArea;

import javax.swing.JTextField;

/**

 * 将单行文本域中的内容 ，点击回车后，追加到多行文本域中，同时将内容显示在label标签中

 * @author Administrator

 *

 */

public class Test04 extends JFrame{

public Test04(String title) {

super(title);

initFrame();

addComponents();

addListener();

this.setVisible(true);

}

private JTextField jtf = new JTextField("单行文本框");

private JTextArea jta = new JTextArea("多行文本域");

private JLabel jl = new JLabel("标签");

//滚动视图组件

private JScrollPane jsp = null;

/**

 * 初始化大小

 */

protected void initFrame(){

Toolkit tk = Toolkit.getDefaultToolkit();

Dimension d = tk.getScreenSize();

int width = d.width;

int height = d.height;

this.setBounds((width-400)/2, (height-500)/2, 400, 500);

this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

}

/**

 * 添加组件

 */

protected void addComponents(){

//布局管理器

this.setLayout(null);

jtf.setBounds(50, 50, 300, 40);

//带参构造，里面传入其他的要显示的组件对象，通常JTabel,JTextArea

jsp = new JScrollPane(jta);

jsp.setBounds(50, 120, 300, 200);

jl.setBounds(50, 350, 200, 50);

this.add(jtf);

this.add(jsp);

this.add(jl);

}

/**

 * 添加监听

 */

protected void addListener(){

//给单行文本注册监听

jtf.addKeyListener(new KeyAdapter() {

 public void keyTyped(KeyEvent e) {

 if(e.getKeyChar()=='\n'){

 //将单行文本的内容追加到多行文本域中

 jta.append(jtf.getText()+"\n");

 //将单行文本的内容显示在label中

 jl.setText(jtf.getText());

 //清空单行文本框中的内容

 jtf.setText(null);

 }

 }

});

}

public static void main(String[] args) {

Test04 t = new Test04("单行文本");

}

}

JTable组件

示例1  将数据存入表格（JTable），为了防止表格中内容过多，需显示，需将表格放入滚动条(JScrollPane 100,100,200,200)

javax.swing.JTable

JTable(Object[][] rowData,Object[] columnNames) 构造一个 JTable 来显示二维数组 rowData 中的值，其列名称为 columnNames

javax.swing.JScrollPane

JScrollPane(Component view) 创建一个显示指定组件内容的 JScrollPane，只要组件的内容超过视图大小就会显示水平和垂直滚动条。

  

 

package com.njwb.table.use;

import javax.swing.JScrollPane;

import javax.swing.JTable;

public class TestTable01 extends MyFrame {

public TestTable01(String title) {

super(title);

addComponents();

addListener();

}

//声明table组件

private JTable jta = null;

private JScrollPane jsp = null;

@Override

protected void addComponents() {

this.setLayout(null);

//（2维数组数据，1维数组 列名）

String[][] rowData = {{"1001","jack","98"},{"1002","tom","87"},{"1003","张三","96"}};

//列名

String[] columnNames = {"学号","姓名","分数"};

jta = new JTable(rowData,columnNames);

//将表格对象传入JScrollPane

jsp = new JScrollPane(jta);

//jta.setBounds(50, 50, 300, 400);

jsp.setBounds(50, 50, 200, 200);

//this.add(jta);

this.add(jsp);

}

@Override

protected void addListener() {

}

public static void main(String[] args) {

TestTable01 t = new TestTable01("表格1");

t.setVisible(true);

}

}

示例2 点击按钮 往表格里添加数据 ，表格JTable 添加到JScrollPane（50,50,300,300）中 ，按钮（100,400,80,40），为按钮添加点击事件时，记得刷新表格数据。

 

JTable(Vector rowData,Vector columnNames) 
          构造一个 JTable 来显示 Vector 所组成的 Vector rowData 中的值，其列名称为 columnNames。

updateUI() 
          UIManager 发出的表明 L&F 已经更改的通知。

JScrollPane(Component view) 
          创建一个显示指定组件内容的 JScrollPane，只要组件的内容超过视图大小就会显示水平和垂直滚动条。

package com.njwb.table.use;

import java.awt.event.ActionEvent;

import java.awt.event.ActionListener;

import java.util.Vector;

import javax.swing.JButton;

import javax.swing.JScrollPane;

import javax.swing.JTable;

 

public class TestTable02 extends MyFrame {

public TestTable02(String title) {

super(title);

addComponents();

addListener();

}

//声明table组件

private JTable jta = null;

private JScrollPane jsp = null;

//声明按钮

private JButton addBtn = new JButton("添加");

//行数据 Vector<String>类型，用于存储一行数据 ,rowData表示的整张表的数据 ,rowData中的每一个元素表示一行数据

private Vector<Vector<String>>rowData = new Vector<Vector<String>>();

//列名

private Vector<String>columnNames = new Vector<String>();

@Override

protected void addComponents() {

this.setLayout(null);

//添加列名

columnNames.add("学号");

columnNames.add("姓名");

columnNames.add("分数");

jta = new JTable(rowData,columnNames);

jsp = new JScrollPane(jta);

jsp.setBounds(50, 50, 300, 300);

this.add(jsp);

//设置大小

addBtn.setBounds(100, 400, 80, 40);

this.add(addBtn);

}

@Override

protected void addListener() {

addBtn.addActionListener(new ActionListener() {

@Override

public void actionPerformed(ActionEvent e) {

//准备一行数据

Vector<String> item = new Vector<String>();

item.add("1001");

item.add("jack");

item.add("97");

//将一行数据添加到行数据集合rowData中

rowData.add(item);

//刷新表格数据

jta.updateUI();

}

});

}

public static void main(String[] args) {

TestTable02 t = new TestTable02("表格2");

t.setVisible(true);

}

}

示例3： 为表格中（JTable）添加鼠标点击事件（addMouseListener），点击某行，将某行的各列值输出到控制台，如下图所示。为防止数据角度，无法正常显示，表格仍旧需要添加到JScrollPane(50,50,300,200滚动面板)中)

int

getSelectedRow() 
          返回第一个选定行的索引；如果没有选定的行，则返回 -1。

int

getSelectedColumn()
          返回第一个选定列的索引；如果没有选定的列，则返回 -1。

 

Object

getValueAt(int row, int column) 
          返回 row 和 column 位置的单元格值。

int

getColumnCount()
          返回列模型中的列数

 

 

package com.njwb.table.use;

import java.awt.event.MouseAdapter;

import java.awt.event.MouseEvent;

import javax.swing.JScrollPane;

import javax.swing.JTable;

/**

 * 打印的整行数据

 * @author Administrator

 *

 */

@SuppressWarnings("serial")

public class TestTable04extends MyFrame {

public TestTable04(String title) {

super(title);

addComponents();

addListener();

}

//声明table组件

private JTable jta = null;

private JScrollPane jsp = null;

@Override

protected void addComponents() {

this.setLayout(null);

//（2维数组数据，1维数组 列名）

String[][] rowData = {{"1001","jack","98"},{"1002","tom","87"},{"1003","张三","96"}};

//列名

String[] columnNames = {"学号","姓名","分数"};

jta = new JTable(rowData,columnNames);

//将表格对象传入JScrollPane

jsp = new JScrollPane(jta);

jsp.setBounds(50, 50, 200, 200);

this.add(jsp);

}

@Override

protected void addListener() {

jta.addMouseListener(new MouseAdapter() {

@Override

public void mouseClicked(MouseEvent e) {

//获取选中的行

int row = jta.getSelectedRow();

//获取列数

int columnCount = jta.getColumnCount();

//遍历某行

for(int i=0;i<columnCount;i++){

//打印的是每一个单元格上的值

System.out.print(jta.getValueAt(row, i)+" ");

}

//打印一行后换行

System.out.println();

}

});

}

public static void main(String[] args) {

TestTable04 t = new TestTable04("表格4");

t.setVisible(true);

}

}

//打印单元格的值

jta.addMouseListener(new MouseAdapter() {

@Override

public void mouseClicked(MouseEvent e) {

//获取选中的行

int row = jta.getSelectedRow();

//获取选中的列

int column = jta.getSelectedColumn();

System.out.println(jta.getValueAt(row, column));

}

});

示例4 加入表格模型，一个按钮添加数据，一个按钮删除数据，要删除某行数据，某行必须选中

滚动面板（50, 50, 300, 200），按钮1（100, 300, 80, 60），按钮2（200, 300, 80, 60）

修改或删除，需要重新创建表格模型，然后将表格重新设置模型，刷新表格数据

添加后，也要刷新表格数据

javax.swing.table.DefaultTableModel

DefaultTableModel(Vector data,Vector columnNames) 

 构造一个 DefaultTableModel，并通过将 data 和 columnNames 传递到 setDataVector 方法来初始化该表。

JTable(TableModel dm)  //TableModel接口  ，已知的实现类： AbstractTableModel,DefaultTableModel 

 构造一个 JTable，使用数据模型 dm、默认的列模型和默认的选择模型对其进行初始化。

 

 

方式1：

package com.njwb.table.use;

import java.awt.event.ActionEvent;

import java.awt.event.ActionListener;

import java.util.Vector;

import javax.swing.JButton;

import javax.swing.JScrollPane;

import javax.swing.JTable;

/**

 * java.lang.ArrayIndexOutOfBoundsException

 * 注意：如果要删除某行数据，必须选中该行才行，如果没有选中，直接删除，出现索引越界

 * @author Administrator

 *

 */

public class TestTable03 extends MyFrame {

public TestTable03(String title) {

super(title);

addComponents();

addListener();

}

//声明table组件

private JTable jta = null;

private JScrollPane jsp = null;

//声明按钮

private JButton addBtn = new JButton("添加");

private JButton delBtn = new JButton("删除");

//行数据 Vector<String>类型，用于存储一行数据 ,rowData表示的整张表的数据 ,rowData中的每一个元素表示一行数据

private Vector<Vector<String>>rowData = new Vector<Vector<String>>();

//列名

private Vector<String>columnNames = new Vector<String>();

@Override

protected void addComponents() {

this.setLayout(null);

//添加列名

columnNames.add("学号");

columnNames.add("姓名");

columnNames.add("分数");

jta =new JTable(rowData,columnNames);

jsp = new JScrollPane(jta);

jsp.setBounds(50, 50, 300, 200);

this.add(jsp);

//设置添加按钮大小位置

addBtn.setBounds(100, 300, 80, 60);

this.add(addBtn);

//设置删除按钮大小位置

delBtn.setBounds(200, 300, 80, 60);

this.add(delBtn);

}

 

@Override

protected void addListener() {

addBtn.addActionListener(new ActionListener() {

@Override

public void actionPerformed(ActionEvent e) {

//准备一行数据

Vector<String> item = new Vector<String>();

item.add("1001");

item.add("jack");

item.add("97");

//将一行数据添加到行数据集合rowData中

rowData.add(item);

//刷新表格数据

jta.updateUI();

}

});

delBtn.addActionListener(new ActionListener() {

@Override

public void actionPerformed(ActionEvent e) {

//获取选中行的索引  =该行数据在集合rowData中的索引位置 ，从0开始,选中的第几行就是集合中的第几个元素

int index = jta.getSelectedRow();

System.out.println("index="+index);

if(index!=rowData.size() && index!=-1){

rowData.remove(index);

//刷新表格数据

jta.updateUI();

}else{

System.out.println("请选择数据");

}

}

});

}

public static void main(String[] args) {

TestTable03 t = new TestTable03("表格3");

t.setVisible(true);

}

}

方式2：

package com.njwb.table.use;

import java.awt.event.ActionEvent;

import java.awt.event.ActionListener;

import java.util.Vector;

import javax.swing.JButton;

import javax.swing.JScrollPane;

import javax.swing.JTable;

import javax.swing.table.DefaultTableModel;

/**

 * 添加，删除

 * @author Administrator

 *

 */

public class TestTable032 extends MyFrame {

public TestTable032(String title) {

super(title);

addComponents();

addListener();

}

//声明table组件

private JTable jta = null;

private JScrollPane jsp = null;

//声明按钮

private JButton addBtn = new JButton("添加");

private JButton delBtn = new JButton("删除");

//行数据 Vector<String>类型，用于存储一行数据 ,rowData表示的整张表的数据 ,rowData中的每一个元素表示一行数据

private Vector<Vector<String>>rowData = new Vector<Vector<String>>();

//列名

private Vector<String>columnNames = new Vector<String>();

//表格模型，用于构造table

private DefaultTableModeldtm =new DefaultTableModel(rowData,columnNames);

@Override

protected void addComponents() {

this.setLayout(null);

//添加列名

columnNames.add("学号");

columnNames.add("姓名");

columnNames.add("分数");

//利用表格模型，构造table

jta =new JTable(dtm);

jsp = new JScrollPane(jta);

jsp.setBounds(50, 50, 300, 200);

this.add(jsp);

//设置添加按钮大小位置

addBtn.setBounds(100, 300, 80, 60);

this.add(addBtn);

//设置删除按钮大小位置

delBtn.setBounds(200, 300, 80, 60);

this.add(delBtn);

}

@Override

protected void addListener() {

addBtn.addActionListener(new ActionListener() {

@Override

public void actionPerformed(ActionEvent e) {

//准备一行数据

Vector<String> item = new Vector<String>();

item.add("1001");

item.add("jack");

item.add("97");

//将一行数据添加到行数据集合rowData中

rowData.add(item);

//刷新表格数据

dtm =new DefaultTableModel(rowData,columnNames);

//table重新绑定表格模型

jta.setModel(dtm);

//table刷新数据

jta.updateUI();

}

});

delBtn.addActionListener(new ActionListener() {

@Override

public void actionPerformed(ActionEvent e) {

//获取选中行的索引  =该行数据在集合rowData中的索引位置 ，从0开始,选中的第几行就是集合中的第几个元素

int index = jta.getSelectedRow();

System.out.println("index="+index);

if(index!=rowData.size() && index!=-1){

rowData.remove(index);

//刷新表格数据

dtm = new DefaultTableModel(rowData,columnNames);

//table重新绑定表格模型

jta.setModel(dtm);

//table刷新数据

jta.updateUI();

}else{

System.out.println("请选择数据");

}

}

});

}

public static void main(String[] args) {

TestTable032 t = new TestTable032("表格3");

t.setVisible(true);

}

}

选项卡

示例5 选项卡（JTabbedPane）

JTabbedPane()  创建一个具有默认的 JTabbedPane.TOP 选项卡布局的空 TabbedPane。

addTab(String title,Component component)  添加一个由 title 表示，且没有图标的 component。

 

 

package com.njwb.tabbedpane;

import javax.swing.JTabbedPane;

import com.njwb.table.use.MyFrame;

public class TestTab01 extends MyFrame {

 

public TestTab01(String title) {

super(title);

addComponents();

addListener();

}

private JTabbedPane jtp = new JTabbedPane();

//声明2个面板对象

private MyPanel1 m1 =new MyPanel1();

private MyPanel2 m2 = new MyPanel2();

@Override

protected void addComponents() {

this.setLayout(null);

jtp.addTab("1",m1);

jtp.addTab("2",m2);

jtp.setBounds(10, 10, 300, 300); //相对于TestTab01的对象t而言（相对于添加的父容器而言）

this.add(jtp);

}

@Override

protected void addListener() {

}

public static void main(String[] args) {

TestTab01 t = new TestTab01("选项卡");

t.setVisible(true);

}

}

 

package com.njwb.tabbedpane;

import java.awt.event.ActionEvent;

import java.awt.event.ActionListener;

import javax.swing.JButton;

import javax.swing.JPanel;

/**

 * JPanel 也是一种Container容器，各种组件都可以添加到面板上

 * Jpanel又可以添加到JFrame中 （容器可以添加到父容器中（顶级容器中））

 * @author Administrator

 *

 */

public class MyPanel1 extends JPanel {

public MyPanel1() {

addComponents();

addListener();

}

private JButton but = new JButton("这是第一个标签页");

protected void addComponents(){

this.setLayout(null);

but.setBounds(50, 50, 120, 40);//相对于父容器MyPanel1对象 而言的，在50,50的位置

this.add(but);

}

protected void addListener(){

but.addActionListener(new ActionListener() {

@Override

public void actionPerformed(ActionEvent e) {

//打印按钮的文本

System.out.println(but.getText());

}

});

}

}

package com.njwb.tabbedpane;

import java.awt.Color;

import javax.swing.JLabel;

import javax.swing.JPanel;

import javax.swing.border.LineBorder;

public class MyPanel2 extends JPanel {

public MyPanel2() {

addComponents();

addListener();

}

private JLabel jl = new JLabel("这是第2个面板");

protected void addComponents(){

this.setLayout(null);

jl.setBounds(30, 50, 150, 40);

jl.setBorder(new LineBorder(Color.orange));

this.add(jl);

}

protected void addListener(){

}

}

提示框

例题1

package com.njwb.optionpane;

import javax.swing.JOptionPane;

/**

 * 询问输入框

 * messageType

 * ERROR_MESSAGE

INFORMATION_MESSAGE

WARNING_MESSAGE

QUESTION_MESSAGE

PLAIN_MESSAGE

 *

 * optionType

 * DEFAULT_OPTION

YES_NO_OPTION

YES_NO_CANCEL_OPTION

OK_CANCEL_OPTION

 * @author Administrator

 *

 */

public class Test01 {

public static void main(String[] args) {

//询问提示框

//int option =JOptionPane.showConfirmDialog(null, "今天天气如何？");

//

//int option = JOptionPane.showConfirmDialog(null, "今天天气如何", "请选择", JOptionPane.CANCEL_OPTION);

int option = JOptionPane.showConfirmDialog(null,"今天天气如何？","标题", JOptionPane.DEFAULT_OPTION,JOptionPane.WARNING_MESSAGE);

if(option==JOptionPane.YES_OPTION){

System.out.println("是");

}else if(option==JOptionPane.NO_OPTION){

System.out.println("否");

}else if(option==JOptionPane.CANCEL_OPTION){

System.out.println("取消");

}

}

}

例题2：

package com.njwb.optionpane;

import javax.swing.JOptionPane;

/**

 * 输入提示框

 * @author Administrator

 *

 */

public class Test02 {

public static void main(String[] args) {

//String data = JOptionPane.showInputDialog("1+1等于几？");

//String data = JOptionPane.showInputDialog(null, "1+1等于几？");

//带初始值

//String data = JOptionPane.showInputDialog("1+1等于几？", 100);

//String data = JOptionPane.showInputDialog(null, "1+1等于几？", 100);

String data = JOptionPane.showInputDialog(null,"1+1等于几？","标题", JOptionPane.ERROR_MESSAGE);

System.out.println("你输入的是："+data);

}

}

例题3：

package com.njwb.optionpane;

import javax.swing.JOptionPane;

/**

 * showMessageDialog 告知用户某事已发生。

 * @author Administrator

 *

 */

public class Test03 {

public static void main(String[] args) {

//JOptionPane.showMessageDialog(null, "该用户不存在，无法登陆");

//JOptionPane.showMessageDialog(null, "密码错误","标题", JOptionPane.INFORMATION_MESSAGE);

//JOptionPane.showMessageDialog(null, "该用户不存在", "标题", JOptionPane.ERROR_MESSAGE, null);

JOptionPane.showOptionDialog(null,"密码错误","标题", JOptionPane.YES_NO_OPTION , JOptionPane.INFORMATION_MESSAGE,null, new Object[]{}, 100);

}

}