第14篇-JAVA GUI编程

第14篇-JAVA GUI编程

  • 每篇一句 ：道路一开始开辟的时候总是存在障碍的
  • 初学心得： 原本下定决心才能开始的事情也变得理所当然
  • (笔者：JEEP/711)[JAVA笔记 | 时间:2017-04-25| JAVA GUI编程 ]

1.什么是界面

图形用户界面（Graphical User Interface,简称 GUI,又称图形用户接口）是指采用图形方式显示的计算机操作用户界面 
与早期计算机使用的命令行界面相比，图形界面对于用户来说在视觉上更易于接受

2.Java 基础类 JFC 的基本概念

主要包含5 个 API： AWT， JavaD， Accessibility，Drag & Drop，Swing 
它提供了帮助开发人员设计复杂应用程序的一整套应用程序开发包

3.什么是组件（Component）

组件构成图形界面零部件面板按钮下拉选等等,具有图形界面，并能完成一定功能的封装体

4.什么是容器（Container）

用于包含其它组件的组件

5.什么是Swing

  • Swing 是 Java 平台的 UI —— 它充当处理用户和计算机之间全部交互的软件 
    它实际上充当用户和计算机内部之间的中间人
  • Swing组件是Java语言提供的第二代GUI设计工具包 
    它以AWT为基础在AWT内容的基础上新增或改进了一些GUI组件使得GUI程序功能更强大设计更容易、更方便

Swing 组件主要为文本处理、按钮、标签、列表、pane、组合框、滚动条、滚动 pane、菜单、表格和树提供了组件

  • JButton 能显示文本和图形的按钮，它是AWT按钮组件的替代组件
  • JCheckBox 能显示文本和图形的复选框，它是AWT选择组件的替代组件
  • JCheckBoxMenuItem 一个复选框菜单项，它是AWT的复选框菜单项组件的替代组件
  • JComboBox 带下拉列表的文本框，它是AWT选择组件的替代组件
  • JComponent 所有轻量J组件的基类
  • JDesktopPane 内部窗体的容器
  • JDialog　Swing对话框的基类，它扩展了AWT Dialot类
  • JEditorPane 用于编辑文本的文本窗格
  • JFrame 扩展java.awt.Frame的外部窗体
  • JInternalFrame 在JDesktopPane中出现的内部窗体
  • JLabel 可显示文本和图标的标签，它是AWT标签组件的替代组件
  • JLayeredPane 能够在不同层上显示组件的容器
  • JList 显示选项列表的组件，它是AWT列表组件的替代组件
  • JMenu 菜单条中显示的一个菜单，它是AWT菜单组件的替代组件
  • JMenuBar 用于显示菜单的菜单条，它是AWT菜单条组件的替代组件
  • JMenuItem 菜单项，它是AWT菜单项组件的替代组件
  • JOptionPane 显示标准的对话框，如：消息和问题对话框
  • JPanel 通用容器，它是AWT面板和画布组件的替代组件
  • JPasswordfield JTextField的扩展，使输入的字符不可见
  • JPopupMenu 弹出式菜单，它是AWT弹出式菜单组件的替代组件
  • JProgressBar 进度指示器
  • JRadioButton 单选按钮，它是AWT复选框组件的替代组件
  • JRootPane 顶层容器，它包含一个玻璃窗格，一个层窗格，一个内容窗格和一个可选的菜单条
  • JScrollBar 滚动条，它是AWT滚动条组件的替代组件
  • JScrollPane 滚动窗格，它是AWT滚动窗格组件的替代组件
  • JSeparator 水平或垂直分隔条
  • JSlider 滑杆
  • JSplitPane 有两个分隔区的容器，这两个分隔区可以水平排列或者垂直排列且分隔区的大小能自动调整
  • JTabbedPane 带选项卡的窗格
  • JTable 表格
  • JTableHeader 表格头
  • JTextArea 用于输入多行文本的文本域，它是AWT文本域组件的替代组件
  • JTestComponent 文本组件的基类，它替代AWT的TextComponent类
  • JTextField 单行文本域，它替代AWT的单行文本域组件
  • JTextPane 简单的文本编辑器
  • JToggleButton 两种状态的按钮，它是JCheckBox和JRadioButton组件的基类
  • JToolBar 工具条
  • JToolTip 当光标停留在一个组件上时，该组件上显示的一行文字
  • JTree 用于按钮层次组织数据的结构控件
  • JViesport 用于浏览可滚动组件的视口
  • JWindow 外部窗口，它是java.awt.Window的扩展

6.什么是AWT

AWT: AWT 是抽象窗口工具集（Abstract Window Toolkit）的英文缩写，为用户界面程序提供所需要的组件

  • 例如按钮、标签、复选框、下拉菜单、画布、文本输入区、列表等
  • 此外，AWT还提供事件类、监听器类、图形处理工具、2D 图形等的支持
  • AWT 存在缺少剪贴板、打印支持等缺陷，甚至没有弹出式菜单和滚动窗口

java.awt包,在这个包中，提供了基本的java程序GUI设计工具：

  • Component/MenuComponent
  • Container
  • LayoutMa

Swing: 不是真正使用原生平台提供设备，而是仅仅在模仿，因此可以在任何平台上使用Swing 图形用户界面组件

  • Swing 绝大部分组件都是轻量级组件，它不像重量级组件那样必须在它们自己本地窗口中绘制，而是在它们所在的重量级窗口中绘制,它比AWT适应性更强

Container（容器）

  • 容器(Container)实际上是Component的子类，因此容器类对象本身也是一个组件，具有组件的所有性质，另外还具有容纳其它组件和容器的功能。
  • 容器类对象可使用方法add()添加组件 
    两种主要的容器类型
  • Window：可独立存在的顶级窗口
  • Panel：可作为容器容纳其它组件，但不能独立存在，必须被添加到其它容器中(如Window 或 Applet)

Container常用方法：

  • add()
  • setLocation()：设置位置
  • setSize()：设置大小
  • setBoundes()：同时设置大小、位置
  • setVisible()
  • pack()

Frame类：

  • 代表一个窗口，是Window类的子类
  • 有标题，可通过拖拉改变大小
  • 初始化时为不可见，可用setVisible(true)使其显示出来
  • 使用BorderLayout作为其缺省布局管理器
  • 使用setLayout方法改变布局管理器

Container的布局管理器

  • AWT中的布局管理器有：
  • FlowLayout
  • BorderLayout
  • GridLayout
  • CardLayout
  • GridBagLayout

基本组件

  • Button：按钮，可接收单击操作
  • Canvas：用于绘图的画布
  • Checkbox：复选框组件（也可变成单选框组件）
  • CheckboxGroup:用于将多个Checkbox组件组合成一组,一组Checkbox组件将只有一个可以被选中,即全部变成单选框组件
  • Choice：下拉式选择框组件
  • Frame：窗口，在GUI程序里通过该类创建窗口
  • Label：标签类，用于放置提示性文本
  • List。列表框组件，可以添加多项条目
  • Panel：不能单独存在基本容器类，必须放到其他容器中
  • Scrollbar：滑动条组件。如果需要用户输入位于某个范围的值，就可以使用滑动条组件。如调色板中设置RGB的三个值所用的滑动条。当创建一个滑动条时，必须指定它的方向、初始值、滑块的大小、最小值和最大值
  • ScrollPane：带水平及垂直滚动条的容器组件
  • TextArea：多行文本域
  • TextField：单行文本框

AWT的事件处理方式

  • 委派式事件处理（delegation）—-个别的组件将整个事件处理委托给特定的对象，当该组件发生指定的事件时，就通知所委托的对象，有这个对象来处理这个事件，这个受委托处理事件的对象称为事件倾听对象（event listener）
  • 每个组件均可以针对特定的事件指定一个或多个事件倾听对象，由这些事件倾听对象负责处理事件

创建菜单 ：创建一个菜单步骤：

  • 创建一个MenuBar对象，将其放置到菜单容器中（如Frame）
  • 创建若干个Menu对象，将其放置到MenuBar对象中
  • 创建若干个MenuItem对象，将其放置到Menu对象中

MenuItem包括

  • MenuItem：普通的菜单项
  • CheckboxMenuItem：可以选择的菜单项

右键菜单 ：右键菜单使用PopupMenu对象表示，创建右键菜单的步骤如下：

  • （1）创建PopupMenu的实例
  • （2）创建多个MenuItem实例，依次将这些实例加入PopupMenu中
  • （3）将PopupMenu加入到目标组件之中
  • （4）为需要出现上下文菜单的组件编写鼠标监听器，当用户释放鼠标右键时弹出右键菜单

AWT中画图：创建Canvas类或Panel的子类，并覆盖paint方法

  • 每当组件出现时调用paint方法
  • 每个组件都有一个Graphics对象
  • Graphics类实现了很多绘图方法

Graphics类：Graphics是一个抽象的画笔对象，Graphics可以在组件上绘制丰富多彩的几何图形和位图，Graphics类提供了如下几个方法用于绘制几何图形和位图

  • drawLine：绘制直线
  • drawString：绘制字符串
  • drawRect：绘制矩形
  • drawRoundRect：绘制圆角矩形
  • drawOval：绘制椭圆形状
  • drawPolygon：绘制多边形边框
  • drawArc：绘制一段圆弧（可能是椭圆的圆弧）
  • drawPolyline：绘制折线
  • fillRect：填充一个矩形区域
  • fillRoundRect：填充一个圆角矩形区域
  • fillOval：填充椭圆区域
  • fillPolygon：填充一个多边形区域
  • fillArc：填充圆弧和圆弧两个端点到中心连线所包围的区域。
  • drawImage：绘制位图

7.菜单和列表

JMenu/JMenuItem/JMenuBar(菜单、菜单项、菜单条) 
1.菜单条：类JMenuBar的实例就是菜单条。例如，以下代码创建菜单条对象menubar： 
JMenuBar menubar = new JMenuBar(); 
在窗口中增设菜单条，必须使用JFrame类中的setJMenuBar()方法 
例如，代码：setJMenuBar(menubar);

类JMenuBar的常用方法有：

  • add(JMenu m)：将菜单m加入到菜单条中
  • countJMenus()：获得菜单条中菜单条数
  • getJMenu(int p)：取得菜单条中的菜单
  • remove(JMenu m)：删除菜单条中的菜单m

2. 菜单：由类JMenu创建的对象就是菜单，类JMenu的常用方法如下：

  • JMenu()：建立一个空标题的菜单
  • JMenu(String s)：建立一个标题为s的菜单
  • add(JMenuItem item)：向菜单增加由参数item指定的菜单选项
  • add(JMenu menu)：向菜单增加由参数menu指定的菜单。实现在菜单嵌入子菜单
  • addSeparator()：在菜单选项之间画一条分隔线
  • getItem(int n)：得到指定索引处的菜单项
  • getItemCount()：得到菜单项数目
  • insert(JMenuItem item,int n)：在菜单的位置n插入菜单项item
  • remove(int n)：删除菜单位置n的菜单项
  • removeAll()：删除菜单的所有菜单项

3.菜单项：类JMenuItem 的实例就是菜单项。类JMenuItem的常用方法如下：

  • JMenuItem()：构造无标题的菜单项
  • JMenuItem(String s)：构造有标题的菜单项
  • setEnabled(boolean b)：设置当前单项是否可被选择
  • isEnabled()：返回当前菜单项是否可被用户选择
  • getLabel()：得到菜单项的名称
  • setLabel()：设置菜单选项的名称
  • addActionListener(ActionListener e)：为菜单项设置监视器。监视器接受点击某个菜单的动作事件

8.事件监听

什么是事件

  • 用户用于交互而产生的键盘或鼠标动作
  • 响应用户的动作称为处理事件

JAVA事件的委托机制

  • 1.事件源先注册好监听器（监听器负责监听事件的产生），（监听器是实现监听器接口的类，监听器接口定义了一个要成为监听器的类应该实现的方法，同时监听器接口都继承与监听器接口基类java.util.EventListener 虽然这个接口没有定义任何需要实现的方法，但是它有它的用途，它作为一种标志，标志着继承自它的接口是监听器接口）
  • 2.事件源产生事件（前提： 声明好相应的事件类，事件类都必须继承自JAVA的事件基类java.util.EventObject,EventObject(Object source)是EventObject唯一的构造方法，这意味着所有事件必须在实例化时就指定事件源，这一点很好，要求在产生事件的时候明确 是谁产生的 为后面的寻根提供保障)
  • 3.事件源广播事件给任意一个在它上面注册的监听器
  • 4.监听器接受事件并执行相应的事件处理方法

9.事件的处理机制

Java的事件处理机制

  • 1.事件源（event source） 
    事件源是一个能够注册监听器对象并发送事件对象的对象。例如按钮或者滚动条就是事件源
  • 2.事件，事件类型和事件对象 
    事件一般是用户在界面上的一个操作，当一个事件发生时，该事件用一个事件对象来表示，事件对象有对应的事件类 
    不同的事件类描述不同类型的用户动作，不同的事件源可以产生不同类别的事件。例如，按钮可以发送ActionEvent对象，而窗口可以发送WindowEvent对象，在Java中，所有的事件对象都最终派生于java.util.EventObject类
  • 3.事件监听器（event listener） 
    监听器对象是一个实现了特定监听器接口（listener interface）的类的实例 
    事件监听器类（监听器对象所属的类）必须实现事件监听器接口或继承事件监听器适配器类 
    事件监听器接口定义了处理事件必须实现的方法 
    事件监听器适配器类是对事件监听器接口的简单实现。目的是为了减少编程的工作量 
    处理事件的方法被称为事件处理器，即事件监听器接口定义，并在事件监听器类中实现的方法
  • 4.注册事件监听器 
    为了能够让事件监听器检查某个组件（事件源）是否发生了某些事件，并且在发生时激活事件处理器进行相应的处理，必须在事件源上注册事件监听器 
    这是通过使用事件源组件的以下方法来完成的： 
    addXxxListener（事件监听器对象） 
    Xxx对应相应的事件类

10.GUI编程实例

实例一：GUI记事本

1.package cn.guis;
2.import java.awt.Image;
3.import java.awt.Toolkit;
4.import java.awt.event.ActionEvent;
5.import java.awt.event.ActionListener;
6.import java.io.FileNotFoundException;
7.import java.io.FileWriter;
8.import java.io.IOException;
9.import javax.swing.JEditorPane;
10.import javax.swing.JFrame;
11.import javax.swing.JLabel;
12.import javax.swing.JMenu;
13.import javax.swing.JMenuBar;
14.import javax.swing.JMenuItem;
15./**
16. * 记事本
17. * @author JEEP-711
18. *
19. */
[email protected]("serial")
21.public class GuiNotepad extends JFrame{
22.  JEditorPane je = null;//定义成员
23.  //构造器
24.  public GuiNotepad(){
25.      /**
26.       * 绘制界面
27.       */
28.      this.setLayout(null);
29.      JLabel jb = new JLabel();
30.      setTitle("记事本");//窗口标题
31.      this.setBounds(615, 98,836,908);//设置窗口宽为536像素，高为408像素
32.      je = new JEditorPane();//创建文本框对象
33.      je.setText("\r\n");//提示
34.      je.setFont(new java.awt.Font("Dialog",1, 20));//设置字体样式
35.      je.setSize(836,908);//设置宽高
36.      add(je);//添加当前对象
37.      setResizable(false);// 设置窗体是否可以调整大小，参数为布尔值 
38.      this.add(jb);//将其加入到窗口当中
39.      /**
40.       * 设置窗口图标
41.       */
42.       Toolkit kit = Toolkit.getDefaultToolkit(); 
43.       Image image = kit.getImage("src//image//0x1f4dd.png"); //设置窗口图标路径
44.       setIconImage(image); //换掉窗体样式
45.      /**
46.       * 绘制菜单
47.       * 文件菜单
48.       * 
49.       */
50.       JEditorPane jee = new JEditorPane();
51.      JMenuBar jr = new JMenuBar();//创建菜单条对象
52.      JMenu jm = new JMenu("文件");
53.      //新建项
54.      JMenuItem ji = new JMenuItem();//创建菜单项对象
55.      ji.setText("新建");
56.      //动作事件接口
57.      ji.addActionListener(new ActionListener(){
58.      @Override
59.      public void actionPerformed(ActionEvent e) {    
60.      //jee.JEditorPane();//创建文本框对象
61.      jee.setText("请输入内容: ");//提示
62.      jee.setSize(836,908);//设置宽高
63.      add(jee);//添加当前对象
64.      }
65.      });
66.      this.add(ji);
67.      /**
68.       * 保存项
69.       */
70.      JMenuItem bc = new JMenuItem("保存");//创建保存项
71.      //动作事件接口
72.      bc.addActionListener(new ActionListener(){
73.      @Override
74.      public void actionPerformed(ActionEvent e) {
75.          try {
76.              FileWriter fw = new FileWriter("src//记事本.txt",true);//实例化文件写入
77.              fw.write(je.getText());//写入当前内容
78.              fw.flush();//刷新
79.              fw.close();//关闭流
80.              System.out.println("成功保存");//提示
81.          } catch (FileNotFoundException e1) {
82.              e1.printStackTrace();
83.          } catch (IOException e1) {
84.              e1.printStackTrace();
85.          } catch(NullPointerException e1){
86.              System.out.println("您操作有误!");   
87.          }
88.      }
89.      });
90.      this.add(bc);   
91.      /**
92.       * 编辑菜单     
93.       */
94.      JMenu j1 = new JMenu(); //创建菜单对象
95.      j1.setText("编辑");
96.      JMenuItem jit = new JMenuItem();//创建菜单项对象
97.      jit.setText("查找");
98.      /**
99.       * 格式菜单
100.       */
101.      JMenu j2 = new JMenu(); //创建菜单格式对象
102.      j2.setText("格式");
103.      JMenuItem zt = new JMenuItem();//创建菜单项对象
104.      zt.setText("字体");
105.      /**
106.       * 查看菜单
107.       */
108.      JMenu j3 = new JMenu(); //创建菜单查看对象
109.      j3.setText("查看");
110.      JMenuItem ztl = new JMenuItem();//创建菜单项对象
111.      ztl.setText("状态栏");
112.      /**
113.       * 帮助菜单
114.       */
115.      JMenu j4 = new JMenu(); //创建菜单帮助对象
116.      j4.setText("帮助");
117.      JMenuItem jt = new JMenuItem();//创建菜单项对象
118.      jt.setText("关于记事本");
119.      /**
120.       * 添加功能
121.       */
122.      jm.add(ji);//把新建添加到菜单
123.      jr.add(jm);//把菜单加载到菜单条
124.      jr.add(j1);//把编辑添加到菜单条
125.      j1.add(jit);//将查找添加到编辑
126.      jr.add(j2);//把格式添加到菜单条
127.      jr.add(j3);//把查看添加到菜单条
128.      jr.add(j4);//把帮助添加到菜单条
129.      j4.add(jt);//把关于记事本添加j4
130.      j2.add(zt);//将字体加入到j2
131.      j3.add(ztl);//将菜单项加入到菜单
132.      jm.add(bc);//将保存加入到菜单
133.      setDefaultCloseOperation(EXIT_ON_CLOSE);// 用户点击窗口关闭
134.      this.setJMenuBar(jr);
135.      this.setVisible(true);//设置是否窗口显示
136.  }
137.  //定义主方法
138.  public static void main(String[] args){
139.      new  GuiNotepad();//调用方法
140.  }
141.}

实例二：GUI用户猜数程序

1.package cn.gui;
2.import java.awt.Color;
3.import java.awt.Image;
4.import java.awt.Toolkit;
5.import java.awt.event.ActionEvent;
6.import java.awt.event.ActionListener;
7.import java.util.Scanner;
8.import javax.swing.ImageIcon;
9.import javax.swing.JButton;
10.import javax.swing.JFrame;
11.import javax.swing.JLabel;
12.import javax.swing.JPanel;
13.import javax.swing.JTextArea;
14./**
15. * 猜数小程序
16. * @author JEEP-711
17. *
18. */
[email protected]("serial")
20.public class Plays extends JFrame{
21.  boolean flag = true;
22.  Scanner info = new Scanner(System.in);
23.  //构造方法
24.  public Plays(){
25.      /**
26.       * 绘制界面
27.       */
28.      this.setLayout(null);
29.      JLabel jl = new JLabel();//实例化界面对象
30.      setTitle("猜数游戏");//设置窗口标题
31.      setResizable(false);//设置窗口不可调整大小
32.      this.setBounds(560, 290,836, 510);//设置窗口大小
33.      this.add(jl);//添加到窗口
34.      /**
35.       * 返回随机数文本输入框
36.       */
37.      JTextArea jt = new JTextArea("游戏随机数:");//实例化文本框对象
38.      jt.setBounds(215,105,140,50);//设置文本大小
39.      jt.setFont(new java.awt.Font("宋体",0, 16));//设置字体样式
40.      this.add(jt);//添加当前文本对象
41.      jt.setBackground(new Color(231,210,181));
42.      /**
43.       * 用户输入数字文本框
44.       */
45.      JTextArea ues = new JTextArea("请输入一个数字:");//实例化用户文本框对象
46.      ues.setBounds(460,105,140,50);//设置文本大小
47.      ues.setFont(new java.awt.Font("宋体",0, 15));//设置字体样式
48.      this.add(ues);//添加当前文本对象
49.      ues.setBackground(new Color(230,207,176));
50.      /**
51.       * 设置游戏开始按钮
52.       */
53.      JButton jbn = new JButton("点击游戏开始");//实例化开始按钮对象
54.      jbn.setBounds(218,205,140,50);//设置按钮位置
55.      jbn.setFont(new java.awt.Font("Dialog",1, 15));//设置字体样式
56.      jbn.setForeground(Color.white);//设置字体颜色
57.      jbn.setBackground(new Color(8,163,219));//设置按钮颜色
58.      //监听事件
59.      jbn.addActionListener(new ActionListener(){
60.          @Override
61.          public void actionPerformed(ActionEvent e) {
62.              //实例化线程
63.              new Thread(new Runnable(){
64.                  @Override//覆写线程方法
65.                  public void run() {
66.                      //循环flag
67.                      while(flag){
68.                          int sj = (int)(Math.random()*95+5);//random*括号里的最大数减去最小数加最小数千位我认识的看风景阿斯蒂芬> > 聚少离多激发了考虑考虑我怎么知道扫你在哪啦圣诞节付款金额按乐山大佛萨顶顶 的
69.                          jt.setText(""+sj);//设置显示随机数框
70.                          try {
71.                              Thread.sleep(100);//睡眠100毫秒
72.                          } catch (InterruptedException e) {
73.                              e.printStackTrace();
74.                          }
75.                      }
76.                  }   
77.              }).start();//开始线程
78.          }});
79.      this.add(jbn);//添加当前开始按钮
80.      /**
81.       * 停止以后输出结果
82.       */
83.      JLabel jg = new JLabel("--公布游戏结果--");
84.      jg.setBounds(330, 270, 200, 30);
85.      jg.setFont(new java.awt.Font("宋体",0, 12));//设置字体样式
86.      this.add(jg);
87.      /**
88.       * 设置游戏结束按钮
89.       */
90.      JButton jtn = new JButton("点击结束游戏");//实例化结束按钮对象
91.      jtn.setFont(new java.awt.Font("Dialog",1, 15));//设置字体样式
92.      jtn.setBounds(420,205,140,50);//设置按钮位置
93.      jtn.setForeground(Color.white);//设置字体颜色
94.      jtn.setBackground(new Color(8,163,219));//设置按钮颜色
95.      //监听事件
96.      jtn.addActionListener(new ActionListener(){
97.          @Override
98.          public void actionPerformed(ActionEvent e) {
99.              flag = false;//等于假就结束
100.              //比较结果
101.              if(ues.getText().equals(jt.getText())){
102.                  jg.setText("恭喜你猜对了,结果为:"+ues.getText());
103.              }else{
104.                  jg.setText("你的输入不正确,"+"正确答案是:"+jt.getText());
105.              }
106.          }
107.      });
108.      this.add(jtn);//添加当前结束按钮
109.      /**
110.       * 设置窗口图标
111.       */
112.       Toolkit kit = Toolkit.getDefaultToolkit(); 
113.       Image image = kit.getImage("src//image//0x1f3ae.png"); //设置窗口图标路径
114.       setIconImage(image); //换掉窗体样式
115.       setDefaultCloseOperation(EXIT_ON_CLOSE);// 用户点击窗口关闭
116.      /**
117.       * 设置背景图片
118.       *  
119.       */
120.        setSize(836, 510);//设置大小    
121.        String path = "src//image//timg.jpg";//设置背景图片的路径  
122.        ImageIcon background = new ImageIcon(path); // 背景图片   
123.        JLabel label = new JLabel(background);// 把背景图片显示在一个标签里面    
124.        label.setBounds(0, 0, this.getWidth(), this.getHeight()); // 把标签的大小位置设置为图片刚好填充整个面板   
125.        JPanel imagePanel = (JPanel) this.getContentPane(); // 把内容窗格转化为JPanel，否则不能用方法setOpaque()来使内容窗> 格透明   
126.        imagePanel.setOpaque(false);  
127.        this.getLayeredPane().add(label, new Integer(Integer.MIN_VALUE));// 把背景图片添加到分层窗格的最底层作为背景    
128.      this.setVisible(true);//设置是否窗口显示
129.  } 
130.  //主方法
131.  public static void main(String[] args) {
132.      new Plays();//调用方法
133.  }
134.}

实例三：GUI红绿灯程序

1.package cn.gui;
2.import java.awt.Color;
3.import java.awt.Image;
4.import java.awt.Toolkit;
5.import java.awt.event.ActionEvent;
6.import java.awt.event.ActionListener;
7.import javax.swing.AbstractButton;
8.import javax.swing.Icon;
9.import javax.swing.ImageIcon;
10.import javax.swing.JButton;
11.import javax.swing.JFrame;
12.import javax.swing.JLabel;
13.import javax.swing.JPanel;
14.import javax.swing.JTextArea;
15./**
16. * 交通警示灯-红 黄 绿 灯
17. * @author JEEP-711
18. *
19. */
[email protected]({ "serial", "unused" })
21.public class WarningLight extends JFrame{
22.  boolean flag = true;//定义成员属性,作为标记
23.  //构造方法
24.  public WarningLight(){
25.      /**
26.       * 绘制界面
27.       */
28.      this.setLayout(null);
29.      JLabel jl = new JLabel();//实例化界面对象
30.      setTitle("交通信号灯程序");//设置标题
31.      this.setBounds(515, 98,836,908);//设置窗口宽为836像素，高为908像素
32.      this.add(jl);//将其加入到窗口当中
33.      setResizable(false);// 设置窗体是否可以调整大小，参数为布尔值 
34.      setDefaultCloseOperation(EXIT_ON_CLOSE);// 用户点击窗口关闭
35.      /**
36.       * 设置开始按钮
37.       */
38.      JButton begin = new JButton("点击开始");//实例化开始按钮
39.      begin.setBounds(610,370,140,50);
40.      begin.setFont(new java.awt.Font("Dialog",1, 15));//设置字体样式
41.      begin.setForeground(Color.white);//设置字体颜色
42.      begin.setBackground(new Color(8,163,219));//设置按钮颜色
43.      /**
44.       * 设置颜色
45.       */
46.//        JTextArea area = new JTextArea();
47.//        area.setBounds(200, 200, 400, 400);
48.//        this.add(area);
49.      /**
50.       * 警示灯切换
51.       */
52.      JLabel lb = new JLabel();//实例化对象
53.      lb.setBounds(200,50,568,798);//设置宽高
54.      jl.add(lb);//添加到jn里
55.      this.add(lb);//添加当前的lb
56.      /**
57.       * 文字提示
58.       */
59.      JLabel ts = new JLabel("交通信号提示");
60.      ts.setBounds(586, 280, 200, 30);
61.      ts.setFont(new java.awt.Font("黑体",1, 30));//设置字体样式
62.      //jg.setForeground(Color.white);//设置字体颜色
63.      add(ts);
64.      //监听器，事件处理
65.      begin.addActionListener(new ActionListener(){
66.          @Override//覆写方法
67.          public void actionPerformed(ActionEvent e) {
68.              //匿名实例化线程
69.              new Thread(new Runnable(){
70.                  @Override//覆写run方法
71.                  public void run() {
72.                      //循环标记
73.                      while(flag){
74.                          lb.setIcon(new ImageIcon("src//image//红灯.png"));//设置显示红灯png
75.                          lb.setSize(368,698);//设置宽高
76.                           //area.setBackground(Color.RED);
77.                           try {
78.                               ts.setText("红灯/停一停");
79.                              Thread.sleep(5200);//设置睡眠
80.                          } catch (InterruptedException e) {
81.                              e.printStackTrace();
82.                          }
83.                           lb.setIcon(new ImageIcon("src//image//黄灯.png"));//设置显示黄灯png
84.                              lb.setSize(368,698);//设置宽高
85.                              ts.setText("黄灯/等一等");
86.                           //area.setBackground(Color.YELLOW);
87.                           try {
88.                              Thread.sleep(2000);//设置睡眠
89.                          } catch (InterruptedException e) {
90.                              e.printStackTrace();
91.                          }
92.                           lb.setIcon(new ImageIcon("src//image//绿灯.png"));//设置显示绿灯png
93.                              lb.setSize(368,698);//设置宽高
94.                              ts.setText("绿灯/可通行");
95.                          // area.setBackground(Color.GREEN);
96.                           try {
97.                              Thread.sleep(5000);//设置睡眠
98.                          } catch (InterruptedException e) {
99.                              e.printStackTrace();
100.                          }
101.                      }
102.                  }
103.              }).start();//开启线程
104.          }
105.      });
106.      this.add(begin);//添加当前按钮
107.      /**
108.       * 设置结束按钮
109.       */
110.      JButton end = new JButton("点击结束");//实例化结束按钮
111.      end.setBounds(610,432,140,50);
112.      end.setFont(new java.awt.Font("Dialog",1, 15));//设置字体样式
113.      end.setForeground(Color.white);//设置字体颜色
114.      end.setBackground(new Color(8,163,219));//设置按钮颜色
115.      //事件处理
116.      end.addActionListener(new ActionListener(){
117.          @Override//覆写方法
118.          public void actionPerformed(ActionEvent e) {
119.              flag=false;//结束进程
120.          }
121.      });
122.      this.add(end);//添加当前结束按钮
123.      /**
124.       * 设置窗口图标
125.       */
126.       Toolkit kit = Toolkit.getDefaultToolkit(); //创建窗口图标对象
127.       Image image = kit.getImage("src//image//0x1f6a6.png"); //设置窗口图标路径
128.       setIconImage(image); //换掉窗体样式
129.       /**
130.           * 设置背景图片
131.           *  
132.           */
133.          setSize(839, 908);//设置大小    
134.          String path = "src//image//交通安全灯.jpg";//设置背景图片的路径  
135.          ImageIcon background = new ImageIcon(path); // 背景图片   
136.          JLabel label = new JLabel(background);// 把背景图片显示在一个标签里面    
137.          label.setBounds(0, 0, this.getWidth(), this.getHeight()); // 把标签的大小位置设置为图片刚好填充整个面板   
138.          JPanel imagePanel = (JPanel) this.getContentPane(); // 把内容窗格转化为JPanel，否则不能用方法setOpaque()来使内容窗> 格透明   
139.          imagePanel.setOpaque(false);  
140.          this.getLayeredPane().add(label, new Integer(Integer.MIN_VALUE));// 把背景图片添加到分层窗格的最底层作为背景    
141.          this.setVisible(true);//设置是否窗口显示
142.  }
143.  //定义主方法
144.  public static void main(String[] args) {
145.      new WarningLight();//调用方法
146.  }
147.}

实例四：GUI单机五子棋程序

1.package cn.gobang;
2.import java.awt.Color;
3.import java.awt.Graphics;
4.import java.awt.Image;
5.import java.awt.Toolkit;
6.import java.awt.event.ActionEvent;
7.import java.awt.event.ActionListener;
8.import java.awt.event.MouseEvent;
9.import java.awt.event.MouseListener;
10.import java.util.ArrayList;
11.import javax.swing.ImageIcon;
12.import javax.swing.JButton;
13.import javax.swing.JComponent;
14.import javax.swing.JFrame;
15.import javax.swing.JLabel;
16.import javax.swing.JPanel;
17./**
18. * 五子棋
19. * @author JEEP-711
20. *
21. */
[email protected]("serial")
23.public class Gobangs extends JFrame{  
24.  /**
25.   * 构造方法
26.   */
27.  public Gobangs(){
28.      /**
29.       * 自定义组件
30.       */
31.      this.setLayout(null);
32.      this.setBounds(610, 140,630,630);//设置宽高
33.      setTitle("国际五子棋");
34.      setResizable(false);// 设置窗体是否可以调整大小，参数为布尔值 
35.      /**
36.       * 开始按钮
37.       */
38.      JButton dy = new JButton("开始对弈");//创建开始按钮
39.      dy.setBounds(138,670,100,50);//设置位置
40.      dy.setFont(new java.awt.Font("Dialog",1, 15));//设置字体样式
41.      dy.setForeground(Color.white);//设置字体颜色
42.      dy.setBackground(new Color(8,163,219));//设置按钮颜色
43.      //监听器
44.      dy.addActionListener(new ActionListener(){
45.          @Override
46.          public void actionPerformed(ActionEvent e) {
47.              Gobangss();//调用五子棋开始方法
48.          }
49.      });
50.      this.add(dy);//添加当前对弈按钮
51.      /**
52.       * 悔棋按钮
53.       */
54.      JButton hq = new JButton("悔棋");//创建悔棋按钮
55.      hq.setBounds(270,670,100,50);//设置位置
56.      hq.setFont(new java.awt.Font("Dialog",1, 15));//设置字体样式
57.      hq.setForeground(Color.white);//设置字体颜色
58.      hq.setBackground(new Color(8,163,219));//设置按钮颜色
59.      //监听器
60.      hq.addActionListener(new ActionListener(){
61.          @Override
62.          public void actionPerformed(ActionEvent e) {
63.          }
64.      });
65.      this.add(hq);//添加当前悔棋按钮
66.      /**
67.       * 重新开始
68.       */
69.      JButton cx = new JButton("重新开始");//创建重新开始对象
70.      cx.setBounds(410,670,100,50);//设置位置
71.      cx.setFont(new java.awt.Font("Dialog",1, 15));//设置字体样式
72.      cx.setForeground(Color.white);//设置字体颜色
73.      cx.setBackground(new Color(8,163,219));//设置按钮颜色
74.      //监听器
75.      cx.addActionListener(new ActionListener(){
76.          @Override
77.          public void actionPerformed(ActionEvent e) {
78.              //if(cx!= null){
79.                  Gobangss();//调用方法
80.              //}
81.          }
82.      });
83.      this.add(cx);//添加当前对象
84.      /**
85.       * 退出游戏
86.       */
87.      JButton tc = new JButton("退出游戏");//创建退出按钮
88.      tc.setBounds(545,670,100,50);//设置位置
89.      tc.setFont(new java.awt.Font("Dialog",1, 15));//设置字体样式
90.      tc.setForeground(Color.white);//设置字体颜色
91.      tc.setBackground(new Color(8,163,219));//设置按钮颜色
92.      //监听事件
93.      tc.addActionListener(new ActionListener(){
94.          @Override
95.          public void actionPerformed(ActionEvent e) {
96.              System.exit(1);//退出游戏界面
97.          }
98.      });
99.      this.add(tc);//添加当前对象
100.      /**
101.       * 设置窗口图标
102.       */
103.       Toolkit kit = Toolkit.getDefaultToolkit(); 
104.       Image image = kit.getImage("src//image//0x1f3a8.png"); //设置窗口图标路径
105.       setIconImage(image); //换掉窗体样式
106.      /**
107.       * 设置背景图片
108.       *  
109.       */
110.        setSize(800,800);//设置大小    board 535, 536
111.        String path = "src//image//qp.jpg";//设置背景图片的路径  
112.        ImageIcon background = new ImageIcon(path); // 背景图片   
113.        JLabel label = new JLabel(background);// 把背景图片显示在一个标签里面    
114.        label.setBounds(0, 0, this.getWidth(), this.getHeight()); // 把标签的大小位置设置为图片刚好填充整个面板   
115.        JPanel imagePanel = (JPanel) this.getContentPane(); // 把内容窗格转化为JPanel，否则不能用方法setOpaque()来使内容窗> 格透明   
116.        imagePanel.setOpaque(false);  
117.        this.getLayeredPane().add(label, new Integer(Integer.MIN_VALUE));// 把背景图片添加到分层窗格的最底层作为背景
118.        setDefaultCloseOperation(EXIT_ON_CLOSE);// 用户点击窗口关闭
119.        this.setVisible(true);//设置是否窗口显示
120.  }
121.  /**
122.   * 创建五子棋开始方法
123.   */
124.  public void Gobangss(){
125.      Draw dr = new Draw();
126.      //dr.setBounds(140,100,535,510);
127.      dr.setBounds(140,100,535,510);
128.      dr.addMouseListener(dr);
129.      this.setBounds(610, 140,799,799);//设置宽高
130.      this.add(dr); 
131.  }
132.  public static void main(String[] args) {
133.      new Gobangs();//调用方法    
134.      new Draw();//调用绘制五子棋类   
135.  }   
136.}
137./**
138. * 绘制五子棋盘，继承JComponet类
139. * @author JEEP-711
140. *    实现接口 MouseListener
141. */ 
[email protected]("serial")
143.class Draw extends JComponent implements MouseListener{
144.  private boolean isblack = true;//标记黑棋子先走
145.  java.util.List<Pieces> psList = new ArrayList<Pieces>();//创建List对象,存放Pieces内容
146.  private int pcesX = 0;//当前X棋子的位置
147.  private int pcesY = 0;//当前Y棋子的位置
148.  private boolean isNow = false;
149.  //覆写方法，自定义控件
150.  public void paint(Graphics g){
151.      super.paint(g);
152.      this.addMouseListener(this);//添加当前,注册自己
153.      /**
154.       * 绘制棋盘线,绘制棋子
155.       * 十行十列,Y轴变换,X轴不变
156.       */
157.      for(int i=-1;i<10;i++){
158.          g.drawLine(0, (i*50+50), 500, (i*50+50));//x轴
159.          g.drawLine((i*50+50),0,(i*50+50),500);//y轴
160.      }
161.      /**
162.       * 绘制棋子
163.       * 遍历集合棋子
164.       */
165.      for(Pieces p : psList){
166.          g.setColor(p.getColor());//取得棋子颜色，黑色
167.          g.fillOval(p.getX(), p.getY(), Pieces.PIECES_SIZE,Pieces.PIECES_SIZE);//设置黑棋子的x，y轴，棋子大小
168.      }
169.      iswin();//调用方
170.      if(isNow == true){
171.          //g.setFont(new Font("微软雅黑",Font.ITALIC,24));
172.          g.setColor(Color.WHITE);
173.          g.setFont(new java.awt.Font("Dialog",1, 60));//设置字体样式
174.          g.drawString("旗开得胜!", 110, 270);    
175.      }       
176.  }
177.  /**
178.   * 判断输赢
179.   * 东,西,南,北
180.   * 东北,东南,西南,西北
181.   */
182.  public void iswin(){
183.      /**
184.       * --北方向
185.       */
186.          int nanbei = 0; 
187.          for(int nowY = pcesY-50,i=0;i<5 && nowY>=0;nowY-=50,i++){
188.              Pieces pieces = findPieces(pcesX,nowY);
189.              //System.out.println(pieces);
190.              //不等于空,就有棋子
191.              if(pieces!= null){
192.                  //当前棋子等于黑,判断颜色是否相相等
193.                  if(isblack != true){
194.                      if(pieces.getColor() == Color.BLACK){
195.                          nanbei++;
196.                      }else{
197.                          break;
198.                      }
199.                  }
200.                  //当前等于白棋,判断颜色是否相等
201.                  if(isblack != false){
202.                      if(pieces.getColor() == Color.WHITE){
203.                          nanbei++;
204.                      }else{
205.                          break;
206.                      }
207.                  }
208.              }else{
209.                  break;
210.              }
211.          }if(isblack != true){
212.              System.out.println("北方向黑棋子个数"+nanbei);
213.          }else{
214.              System.out.println("北方向白棋子个数"+nanbei);
215.          }
216.          if(nanbei>=5){
217.              isNow = true;
218.              if(isblack != true){
219.                  System.out.println("黑棋赢了");
220.              }else{
221.                  System.out.println("白棋赢了");
222.              }
223.          }
224.          /**
225.           * --南方向
226.           */
227.              for(int nowY = pcesY,i=0;i<5 && nowY<=500;nowY+=50,i++){
228.                  Pieces pieces = findPieces(pcesX,nowY);
229.                  //System.out.println(pieces);
230.                  //不等于空,就有棋子
231.                  if(pieces!= null){
232.                      //当前棋子等于黑,判断颜色是否相相等
233.                      if(isblack != true){
234.                          if(pieces.getColor() == Color.BLACK){
235.                              nanbei++;
236.                          }else{
237.                              break;
238.                          }
239.                      }
240.                      //当前等于白棋,判断颜色是否相等
241.                      if(isblack != false){
242.                          if(pieces.getColor() == Color.WHITE){
243.                              nanbei++;
244.                          }else{
245.                              break;
246.                          }
247.                      }
248.                  }else{
249.                      break;
250.                  }
251.              }if(isblack != true){
252.                  System.out.println("南方向黑棋子个数"+nanbei);
253.              }else{
254.                  System.out.println("南方向白棋子个数"+nanbei);
255.              }
256.              if(nanbei>=5){
257.                  isNow = true;
258.                  if(isblack != true){
259.                      System.out.println("黑棋赢了");
260.                  }else{
261.                      System.out.println("白棋赢了");
262.                  }
263.              }
264.      /*
265.       *--东方向 
266.       *
267.       */
268.      int dongxi = 0; 
269.      for(int nowX = pcesX,i=0;i<5 && nowX<=500;nowX+=50,i++){
270.          Pieces pieces = findPieces(nowX,pcesY);
271.          //System.out.println(pieces);
272.          //不等于空,就有棋子
273.          if(pieces!= null){
274.              //当前棋子等于黑,判断颜色是否相相等
275.              if(isblack != true){
276.                  if(pieces.getColor() == Color.BLACK){
277.                      dongxi++;
278.                  }else{
279.                      break;
280.                  }
281.              }
282.              //当前等于白棋,判断颜色是否相等
283.              if(isblack != false){
284.                  if(pieces.getColor() == Color.WHITE){
285.                      dongxi++;
286.                  }else{
287.                      break;
288.                  }
289.              }
290.          }else{
291.              break;
292.          }
293.      }
294.      if(isblack != true){
295.          System.out.println("东方向黑棋子个数"+dongxi);
296.      }else{
297.          System.out.println("东方向白棋子个数"+dongxi);
298.      }
299.      /**
300.       * --西方向
301.       */
302.      for(int nowX = pcesX-50,i=0;i<5 && nowX>=0;nowX-=50,i++){
303.          Pieces pieces = findPieces(nowX,pcesY);
304.          //不等于空,就有棋子
305.          if(pieces!=null){
306.              //当前棋子等于黑,判断颜色是否相相等
307.              if(isblack != true){
308.                  if(pieces.getColor() == Color.BLACK){
309.                      dongxi++;
310.                  }else{
311.                      break;
312.                  }
313.              }
314.              //当前等于白棋,判断颜色是否相等
315.              if(isblack != false){
316.                  if(pieces.getColor() == Color.WHITE){
317.                      dongxi++;
318.                  }else{
319.                      break;
320.                  }
321.              }
322.          }else{
323.              break;
324.          }
325.      }
326.      if(isblack != true){
327.          System.out.println("西方向黑棋子个数"+dongxi);
328.      }else{
329.          System.out.println("西方向白棋子个数"+dongxi);
330.      }
331.      if(dongxi>=5){
332.          isNow = true;
333.          if(isblack != true){
334.              System.out.println("黑棋赢了");
335.          }else{
336.              System.out.println("白棋赢了");
337.          }
338.      }
339.      /**
340.       * -*-东北方向
341.       */
342.      int dongbeixinan= 0;
343.      for(int nowX = pcesX,nowY = pcesY,i=0;nowY >=0 && nowX<=500 && i< 5;nowX+=50,nowY-=50,i++){
344.          Pieces pieces = findPieces(nowX,nowY);
345.          //不等于空,就有棋子
346.          if(pieces!=null){
347.              //当前棋子等于黑,判断颜色是否相相等
348.              if(isblack != true){
349.                  if(pieces.getColor() == Color.BLACK){
350.                      dongbeixinan++;
351.                  }else{
352.                      break;
353.                  }
354.              }
355.              //当前等于白棋,判断颜色是否相等
356.              if(isblack != false){
357.                  if(pieces.getColor() == Color.WHITE){
358.                      dongbeixinan++;
359.                  }else{
360.                      break;
361.                  }
362.              }
363.          }else{
364.              break;
365.          }
366.      }
367.      if(isblack != true){
368.          System.out.println("东北方向黑棋子个数"+dongbeixinan);
369.      }else{
370.          System.out.println("东北方向白棋子个数"+dongbeixinan);
371.      }
372.      if(dongbeixinan>=5){
373.          isNow = true;
374.          if(isblack != true){
375.              System.out.println("黑棋赢了");
376.          }else{
377.              System.out.println("白棋赢了");
378.          }
379.      }
380.      /**
381.       * --西南方向
382.       */
383.      for(int nowX = pcesX-50,nowY = pcesY+50,i=0;nowY <=500 && nowX>=0 && i< 5;nowX-=50,nowY+=50,i++){
384.          Pieces pieces = findPieces(nowX,nowY);
385.          //不等于空,就有棋子
386.          if(pieces!=null){
387.              //当前棋子等于黑,判断颜色是否相相等
388.              if(isblack != true){
389.                  if(pieces.getColor() == Color.BLACK){
390.                      dongbeixinan++;
391.                  }else{
392.                      break;
393.                  }
394.              }
395.              //当前等于白棋,判断颜色是否相等
396.              if(isblack != false){
397.                  if(pieces.getColor() == Color.WHITE){
398.                      dongbeixinan++;
399.                  }else{
400.                      break;
401.                  }
402.              }
403.          }else{
404.              break;
405.          }
406.      }if(isblack != true){
407.          System.out.println("西南方向黑棋子个数"+dongbeixinan);
408.      }else{
409.          System.out.println("西南方向白棋子个数"+dongbeixinan);
410.      }
411.      if(dongbeixinan>=5){
412.          isNow = true;
413.          if(isblack != true){
414.              System.out.println("黑棋赢了");
415.          }else{
416.              System.out.println("白棋赢了");
417.          }
418.      }   
419.      /**
420.       * --东南方向
421.       */
422.      int dongnan = 0;
423.      for(int nowX = pcesX,nowY = pcesY,i=0;nowY <=500 && nowX<=500 && i< 5;nowX+=50,nowY+=50,i++){
424.          Pieces pieces = findPieces(nowX,nowY);
425.          //不等于空,就有棋子
426.          if(pieces!=null){
427.              //当前棋子等于黑,判断颜色是否相相等
428.              if(isblack != true){
429.                  if(pieces.getColor() == Color.BLACK){
430.                      dongnan++;
431.                  }else{
432.                      break;
433.                  }
434.              }
435.              //当前等于白棋,判断颜色是否相等
436.              if(isblack != false){
437.                  if(pieces.getColor() == Color.WHITE){
438.                      dongnan++;
439.                  }else{
440.                      break;
441.                  }
442.              }
443.          }else{
444.              break;
445.          }
446.      }if(isblack != true){
447.          System.out.println("东南方向黑棋子个数"+dongnan);
448.      }else{
449.          System.out.println("东南方向白棋子个数"+dongnan);
450.      }
451.      /**
452.       * --西北方向
453.       */
454.      for(int nowX = pcesX-50,nowY = pcesY-50,i=0;nowY >=0 && nowX>=0 && i< 5;nowX-=50,nowY-=50,i++){
455.          Pieces pieces = findPieces(nowX,nowY);
456.          //不等于空,就有棋子
457.          if(pieces!=null){
458.              //当前棋子等于黑,判断颜色是否相相等
459.              if(isblack != true){
460.                  if(pieces.getColor() == Color.BLACK){
461.                      dongnan++;
462.                  }else{
463.                      break;
464.                  }
465.              }
466.              //当前等于白棋,判断颜色是否相等
467.              if(isblack != false){
468.                  if(pieces.getColor() == Color.WHITE){
469.                      dongnan++;
470.                  }else{
471.                      break;
472.                  }
473.              }
474.          }else{
475.              break;
476.          }
477.      }
478.      if(isblack != true){
479.          System.out.println("西北方向黑棋子个数"+dongnan);
480.      }else{
481.          System.out.println("西北方向白棋子个数"+dongnan);
482.      }
483.      if(dongnan>=5){
484.          isNow = true;
485.          if(isblack != true){
486.              System.out.println("黑棋赢了");
487.          }else{
488.              System.out.println("白棋赢了");
489.          }
490.      }
491.  }
492.  /**
493.   * 找点
494.   */
495.  public Pieces findPieces(int x,int y){
496.      for(Pieces p:psList){
497.          if(p.getX() == x && p.getY() == y){
498.                  return p;//判断坐标是否相同
499.              }
500.          }
501.      return null;
502.  }
503.  @Override
504.  public void mouseClicked(MouseEvent e) {
505.      int x = e.getX()-Pieces.PIECES_SIZE/2;//取得x轴坐标
506.      int y = e.getY()-Pieces.PIECES_SIZE/2;//取得y轴坐标
507.      //算出在哪一条线
508.      double xianX = Math.round(x/50.0);
509.      double xianY = Math.round(y/50.0);
510.      //System.out.println("第几根线"+xianY+"---"+Math.round(xianY));
511.      x = ((int)xianX)*50-20;
512.      y = ((int)xianY)*50-20;
513.      pcesX = x;//记录棋子X当前位置
514.      pcesY = y;//记录棋子Y当前位置
515.      boolean isHa = false;
516.      //去重复棋子
517.      for(Pieces p:psList){
518.          if(p.getX() == x && p.getY() == y){
519.              isHa = true;
520.              }
521.          }
522.      //避免重复棋子
523.      if(!isHa){
524.          Pieces ps = new Pieces(x,y); //创建棋子对象,并传x，y值
525.          /**
526.           * 找点
527.           */
528.              if(isblack == true){
529.                  //黑棋子
530.                  ps.setColor(Color.BLACK);//设置棋子颜色为黑色
531.                  isblack = false;
532.              }else{
533.                  //白棋子
534.                  ps.setColor(Color.WHITE);//设置棋子颜色为白色
535.                  isblack = true;
536.              }
537.              if(isNow==false){
538.                  psList.add(ps);//把棋子保存到数组里
539.              }
540.              this.repaint();//让其重新调用,用户触发,重新绘制
541.      }
542.      //System.out.println("目前棋子数为:"+psList.size());
543.      //System.out.println("你点击了,X轴为:"+e.getX()+",Y轴为:"+e.getY());
544.  }
545.  @Override
546.  public void mousePressed(MouseEvent e) {
547.  }
548.  @Override
549.  public void mouseReleased(MouseEvent e) {   
550.  }
551.  @Override
552.  public void mouseEntered(MouseEvent e) {    
553.  }
554.  @Override
555.  public void mouseExited(MouseEvent e) { 
556.  }
557.}
558./**
559. * 绘制棋子类 
560. * @author JEEP-711
561. *
562. */
563.class Pieces{
564.  private int x;//x轴点坐标属性
565.  private int y;//y轴点坐标属性
566.  private Color color;//棋子颜色属性
567.  public static final int PIECES_SIZE = 40;//棋子尺寸
568.  //取得X轴get方法
569.  public int getX() {
570.      return x;
571.  }//设置x轴set方法
572.  public void setX(int x) {
573.      this.x = x;
574.  }//取得y轴方法
575.  public int getY() {
576.      return y;
577.  }//设置y轴方法
578.  public void setY(int y) {
579.      this.y = y;
580.  }//取得棋子颜色方法
581.  public Color getColor() {
582.      return color;
583.  }//设置棋子颜色方法
584.  public void setColor(Color color) {
585.      this.color = color;
586.  }
587.  //构造器
588.  public Pieces(int x, int y, Color color) {
589.      super();
590.      this.x = x;
591.      this.y = y;
592.      this.color = color;
593.  }
594.  public Pieces(int x, int y) {
595.      this.x = x;
596.      this.y = y;
597.  }
598.  @Override
599.  public String toString() {
600.      return "Pieces [x=" + x + ", y=" + y + ", color=" + color + "]";
601.  }
602.}

初学(JAVA GUI编程 高级阶段) 难点: ★★★★★

希望每一篇文章都能够对读者们提供帮助与提升，这乃是每一位笔者的初衷

感谢您的阅读 欢迎您的留言与建议

时间： 2024-10-13 23:20:09

第14篇-JAVA GUI编程的相关文章

第15篇-JAVA JDBC编程

第15篇-JAVA JDBC编程 每篇一句 :对于勇敢者,尝试是一条崭新的生活之路 初学心得: 但对于坎坷与泥泞,能以平常之心视之,就非常不容易 (笔者:JEEP/711)[JAVA笔记 | 时间:2017-05-08| JAVA JDBC编程 ] 1.JDBC概述 通过使用JDBC API,Java程序可以非常方便地操作各种主流数据库,这是是Java语言的巨大魅力所在 由于Java语言的跨平台特性,所以使用JDBC API所编写的程序不仅可以实现跨数据库,还可以跨平台,具有非常优秀的可移植性

第13篇-JAVA 网络编程

第13篇-JAVA 网络编程 每篇一句 比我强大的人都在努力我还有什么理由不拼命 初学心得 不去追逐你所渴求你将永远不会拥有 (笔者JEEP/711)[JAVA笔记 | 时间:2017-04-22| JAVA 网络编程 ] 1.网络编程基本概念 1.什么是计算机网络 计算机网络是指将地理位置不同的具有独立功能的多台计算机及其外部设备通过通信线路连接起来在网络操作系统网络管理软件及网络通讯协议的管理和协调下实现资源共享和信息传递的计算机系统 把分布在不同地理区域的计算机与专门的外部设备用通讯线路互

JAVA GUI编程学习笔记目录

1.JAVA之GUI编程概述 2.JAVA之GUI编程布局 3.JAVA之GUI编程Frame窗口 4.JAVA之GUI编程事件监听机制 5.JAVA之GUI编程窗体事件 6.JAVA之GUI编程Action事件 7.JAVA之GUI编程鼠标事件 8.JAVA之GUI编程键盘码查询器 9.JAVA之GUI编程列出指定目录内容 10.JAVA之GUI编程弹出对话框Dialog 11.JAVA之GUI编程菜单 12.JAVA之GUI编程打开与保存文件 13.JAVA之GUI编程将程序打包jar JA

Java GUI编程中AWT/swing/SWT的优缺点

http://www.cnblogs.com/dugang/archive/2010/10/22/1858478.html AWT AWT是Abstract Window Toolkit(抽象窗口工具包)的缩写,是SUN专门针对Java GUI编程提供的最早的也是最初的开发工具包,用来建立和设置Java图形用户界面,这个工具包提供了一套与本地图形界面交互的接口.AWT 中的图形函数与操作系统所提供的图形函数之间有着一一对应的关系(peers).也就是说,当我们利用 AWT 来构件图形用户界面的时

Java GUI编程（一）

********************第16章 GUI编程 ************************** 一.什么是GUI GUI= Graphical User Interface 图形用户接口 图形用户界面 GUI是用java来编写带界面的应用程序 两套技术 1. AWT(Abstract Window Toolkit) 抽象窗口工具集 图形界面不是java本身实现的,其实是依赖于操作系统的底层函数 为了让同一个java程序运行在不同的操作系统上效果一致,所以 awt技术是抽取所有

java GUI编程(swing)之二swing按钮组件

swing的按钮组件.在widgets 类中. 要使用按钮,必须要导入JButton import javax.swing.JButton; 按钮需要加入到Frame里面 package gui; import java.awt.Frame; import javax.swing.JFrame; import javax.swing.JButton; /** * Created by admin on 2017/6/30. * java gui 学习 */ public class Gui ex

Java GUI编程

----基础 // 创建一个窗体对象        JFrame frame = new JFrame();        // 设置窗口大小        frame.setSize(300, 200);        // 指定窗口的显示位置        frame.setLocation(300, 200);        // 指定窗口的标题栏        frame.setTitle("MY FRIST WINDOWS!"); // 获取窗口的内容面板        Co

java GUI编程(swing)之四swing下拉框，列表框，滚动窗口

下拉框(JComboBox) 列表框(JList) 滚动窗口(JScrollPane) package gui; import java.awt.GridLayout; import javax.swing.*; /** * 下拉框,列表框,窗口滚动 * Created by admin on 2017/7/9. */ public class Scroll extends JFrame{ // 定义需要用到的组件 private JList jList; private JComboBox j

java GUI编程(swing)之八swing绘图

Graphics 类可以理解为画笔.它是java为我们提供的一个绘图类. 使用它可以画: 直线 drawLine(int x1, int y1, int x2, int y2) 矩形 drawRect(int x, int y, int width, int height) 圆形 drawOval(int x, int y, int width,int height) 填充矩形 fillRect(int x,int y, int width, int height) 填充圆形 fillOval(