中国Java开发网 - [请教]用覆盖JFrame的paint方法画图的问题
Topic: [请教]用覆盖JFrame的paint方法画图的问题
1.[请教]用覆盖JFrame的paint方法画图的问题
Posted by: macroxmu
Posted on:
用覆盖paint（Graphics g）的方法画图，把窗口最大化和最小化时是正常的，但是在改变窗口大小后绘制的图形就消失了，请问是什么原因？是不是改变窗口大小这个事件无法repaint？应该如何解决？测试代码如下：/*
*/import javax.swing.*;import java.awt.*;public class pai extends JFrame{
public pai(){
this.setSize(800,500);
this.setVisible(true);
this.setDefaultCloseOperation(EXIT_ON_CLOSE);
public static void main(String args[]){
pai p=new pai();
public void paint(Graphics g){
g.drawLine(0,0,800,500);
2.Re:[请教]用覆盖JFrame的paint方法画图的问题
[Re: macroxmu]
Posted by: Infinite
Posted on:
“但是在改变窗口大小后绘制的图形就消失了，“？？？不明白什么意思，好像没有消失就是了。
3.Re:[请教]用覆盖JFrame的paint方法画图的问题
[Re: Infinite]
Posted by: macroxmu
Posted on:
现在是可以啊，但是只要你双击标题栏把这个窗口最大化的话里面画的线就消失了。
4.Re:[请教]用覆盖JFrame的paint方法画图的问题
[Re: macroxmu]
Posted by: Infinite
Posted on:
呵呵，我照做了，还是没问题，看看你提供的代码和你运行的版本有没有出入？macroxmu wrote:现在是可以啊，但是只要你双击标题栏把这个窗口最大化的话里面画的线就消失了。
5.Re:[请教]用覆盖JFrame的paint方法画图的问题
[Re: macroxmu]
Posted by: macroxmu
Posted on:
不可能吧-_||我用的是jdk1.5的附件中左边是把窗口拉大之前的，右边是把窗口拉大之后的。把窗口拉大之后里面画的线就消失了。当时把它最小化后在还原又出现了。
6.Re:[请教]用覆盖JFrame的paint方法画图的问题
[Re: macroxmu]
Posted by: losfound
Posted on:
窗口大小改变时重画窗口：import javax.swing.*;import java.awt.*;import java.ponentAimport java.ponentEpublic class pai extends JFrame {
public pai() {
this.setSize(800, 500);
this.setVisible(true);
this.setDefaultCloseOperation(EXIT_ON_CLOSE);
public static void main(String args[]) {
pai p = new pai();
p.addComponentListener(new ComponentAdapter() {
public void componentResized(ComponentEvent e) {
e.getComponent().repaint();
public void paint(Graphics g) {
g.drawLine(0, 0, 800, 500);
7.Re:[请教]用覆盖JFrame的paint方法画图的问题
[Re: macroxmu]
Posted by: fairy_ap
Posted on:
俺也一样试过了，那个确实可以正常显示啊，即使与最大化来回切换也是显示正常的啊：）
Powered by & Version Jute 1.5.6 Ent
Copyright &
Cjsdn Team. All Righits Reserved.
客服电话&&&&&客服信箱&&&&&客服QQ&714923下次自动登录
现在的位置:
& 综合 & 正文
关于Java中的paint，repaint，update三个方法的关系
关于Java中的paint，repaint，update三个方法的关系
1401人阅读
这些天一直在用repaint()和paint(),到网上一查，还揪出了update(), 其中查到一篇介绍Java中的paint，repaint，update三个方法的关系的：
先还是看看 Java API 中的介绍吧：update public void update(Graphics g)
更新组件。
如果此组件不是轻量级组件，则为了响应对 repaint 的调用，AWT 调用 update 方法。可以假定未清除背景。
Component 的 update 方法调用此组件的 paint 方法来重绘此组件。为响应对 repaint 的调用而需要其他工作的子类通常重写此方法。重写此方法的 Component 子类应该调用 super.update(g)，或者直接从其 update 方法中调用 paint(g)。
图形上下文的原点，即它的（0，0）坐标点是此组件的左上角。图形上下文的剪贴区域是此组件的边界矩形。repaint
public void repaint()
重绘此组件。
如果此组件是轻量级组件，则此方法会尽快调用此组件的 paint 方法。否则此方法会尽快调用此组件的 update 方法。 paint
public void paint(Graphics
绘制此组件。出于性能的考虑，首次显示宽度或高度为 0 的 Component 时认为它不需要进行绘制，并且也不需要修复。应该绘制组件的内容时调用此方法；例如首次显示组件或者组件已损坏并需要修复时。Graphics 参数中的剪贴区矩形设置为需要绘制的区域。重写此方法的 Component 子类不需要调用 super.paint(g)。
2. 引文地址：
应用不应直接调用 paint，而是应该使用 repaint 方法来安排重绘组件
repaint -& update -& paint
重量级组件：
重写update方法
轻量级组件：
尽快调用paint方法，此方法将绘制工作委托给三个受保护的方法：paintComponent、paintBorder 和 paintChildren。按列出的顺序调用这些方法，以确保子组件出现在组件本身的顶部。
重写paintComponet方法paint(g) ,一个回调方法，绝大多数时候组件的绘图逻辑都存储于这个方法中。awt系统会在适当的时候调用这个方法对组件进行绘图。容器在绘制的时候,容器的paint(g)方法默认会显示通知在容器中存在的所有visible为true的子组件进行绘制. awt调用这个方法有2种形式。程序驱动方式和系统驱动方式。 在系统驱动的情况下（比如界面第一次显示组件），系统会判断组件的显示区域，然后向事件分发线程发出调用paint(g)的命令. 程序驱动则由外部的程序调用repaint()方法提出一个异步请求.repaint方法会调用update(g)方法,update方法在默认情况下简单调用paint(g)方法.从而绘制组件. 一般不提倡将组件的具体绘制逻辑放到paint(g)之外,也不提倡程序直接调用paint(g)方法.需要注意的是,由于程序驱动方式是由程序来负责组件的绘制,所以repaint方法拥有几个重载方法.传入绘制区域,由程序决定组件的绘制区域. update(g)方法.在awt的重量级组件上,update是一个很重要的方法.在外部程序调用repaint的时候,都会调用到 update.程序员通过继承重量级组件,覆盖这个update方法.可以实现自己的绘图逻辑,典型的用法是重新绘制组件需要改变的的一部份而不是全部 (增量绘图).这样对于复杂的 组件绘制可以提高效率,不然在默认情况下,重量级组件的update将擦除组件的整个区域,并重新调用paint()方法从头绘制.不过轻量级组件不能采用这个方法.这是由于轻量级组件的本质造成的:
重量级组件和轻量级组件的区别,在于前者拥有一个本地同位体,绘制和现实逻辑都是依靠本地系统来完成.而轻量级组件不依赖于任何本地系统.只需要 一个重量级容器组件作为载体.在重量级组件的基础上,完全采用java的绘制(个人理解为graphics)来生成.所以轻量级组件在不显示的时候是透明的.甚至可以认为本组件不存在.由于轻量级组件没有采用任何本地系统代码来进行绘制,所以在需要绘制的情况下需要awt显式的通知,当这个通知来自于 轻量级组件(就是指组件尺寸改变)而非本地系统时(指组件第一次进行绘制),这个通知采用调用repaint方法的形式进行.换句话说,对于轻量级组件, 即使是系统级驱动绘图,也可能会调用repaint方法.而repaint方法将会调用update方法,update方法默认调用paint方法.所以 轻量级组件在系统驱动和程序驱动方式上的绘图并没有什么区别. 即使如此,也有办法对复杂的轻量级组件进行有效的增量绘图.复杂的轻量级组件都可以做成容器.可以根据一些内部信息,只绘制轻量级组件中某几个组件.典型做法是覆盖paint方法.
3.引文地址：百度空间
repaint,update和paint这三个方法在Component中定义,由于awt,swing组件都直接或间接继承自Component,所以几乎所有的awt,swing组件都有这三个方法.这三个方法主要是用于组件的界面绘制.这三个方法执行顺序repaint() - update() - paint()一般在程序中我们都会重装paint()方法以执行重绘画面的动作,但实际上除了paint()以后,update()也执行了一部分的工作,这部分工作包括用默认的背景颜色填充,设置前景色等,由于这部分一般都无须用户参考,所以一般都update()自动完成,然后update()再调用paint()执行用户自定义的绘制操作.一般情况不用重写update()方法。但是如果你填充背景的颜色跟paint（）中的颜色不一样的时候就会有闪烁感。可以重写update方法，事实上,在用双缓冲画图时,一般都会选择重装update()而不是paint()方法,由于在执行paint()方法之前,update()还执行填充背景的动作,所以当重绘的速度很大时,填充背景的动作将很明显,也即闪烁很大,也将,如果在paint()中用双缓冲的话实际上起不了效果.而如果用update()的话就可以双缓冲达到预期的效果.
当在程序中需要重绘操作时,我们一般会用repaint()而不是直接调用update()或者paint(),repaint()将调用update().而在各种awt,swing组件需要自动重新绘制时,程序也一般也会自动调用repaint()方法.
下列就是本人今天做了欢迎介面时遇到的种种困难和错误，希望放在这里能让大家引以为鉴，不要再犯这样的错误！ 1、不理解paint()方法、repaint()方法、update()方法的区别； 解决思路：paint()方法是由系统自动随机调用，而update()方法是我们自己人为调用，paint()方法必须要人为指定是什么时候让系统开始调用，但是首先在最开始的时候自己调用一次，所以不安全，我们一般使用update()方法，此方法必须用repaint()方法调用。我们调用paint()方法其实也是由repaint()方法调用update()方法（注：paint()方法在加图之前必须判断内存里面是否有图片）； 2、程序执行顺序问题：this.memoryImage()!= 解决思路：虚拟机是先加载属性文件； 3、路径错误； 解决思路：src是源文件，不要和它混在一起，我们要用到其它如图片和音乐的文件要放在一个文件夹下面，且此文件夹是和src同一级别； 4、找不到图片； 解决思路：图片都必须是在媒体跟踪器跟踪完之后才能加载，才能找到其的宽和高，不能在媒体跟踪器加载完之前调用图片的宽和高； 5、图片覆盖； 解决思路：图片在画进屏幕的时候要有一定的顺序问题，背景放在最下面，一层一层往上放，要不然会发生覆盖问题； 6、图片不能显示； 解决思路：我们的图片画在屏幕上但前题是我们要有一个窗体才能画，所以在将内存的图画进屏幕的时候必须将窗体可见性设出：setVisible(true); 7、未找到图片的问题判断： 解决思路：如果没有找到图片，那么那个图片点whith及点height打印出来都是-1;
关于上面提到的双缓冲问题，一个最好的解决办法就是重写 update 方法。
总结：三个方法的调用顺序是没有错的，然后，对于轻量级组件，一般是重写 paint 方法以快速的绘制组件，但是对于重量及组件，由于重新绘制时间长，容易产生闪烁的现象，所以一般是采用重写 update 方法，利用双缓冲图片来解决闪烁的问题。
这些天一直在用repaint()和paint(),到网上一查，还揪出了update(), 其中查到一篇介绍Java中的paint，repaint，update三个方法的关系的文章：
先还是看看 Java API 中的介绍吧：update public void update(Graphics g)
更新组件。
如果此组件不是轻量级组件，则为了响应对 repaint 的调用，AWT 调用 update 方法。可以假定未清除背景。
Component 的 update 方法调用此组件的 paint 方法来重绘此组件。为响应对 repaint 的调用而需要其他工作的子类通常重写此方法。重写此方法的 Component 子类应该调用 super.update(g)，或者直接从其 update 方法中调用 paint(g)。
图形上下文的原点，即它的（0，0）坐标点是此组件的左上角。图形上下文的剪贴区域是此组件的边界矩形。repaint
public void repaint()
重绘此组件。
如果此组件是轻量级组件，则此方法会尽快调用此组件的 paint 方法。否则此方法会尽快调用此组件的 update 方法。 paint
public void paint(Graphics
绘制此组件。出于性能的考虑，首次显示宽度或高度为 0 的 Component 时认为它不需要进行绘制，并且也不需要修复。应该绘制组件的内容时调用此方法；例如首次显示组件或者组件已损坏并需要修复时。Graphics 参数中的剪贴区矩形设置为需要绘制的区域。重写此方法的 Component 子类不需要调用 super.paint(g)。
2. 引文地址：
应用程序不应直接调用 paint，而是应该使用 repaint 方法来安排重绘组件
repaint -& update -& paint
重量级组件：
重写update方法
轻量级组件：
尽快调用paint方法，此方法将绘制工作委托给三个受保护的方法：paintComponent、paintBorder 和 paintChildren。按列出的顺序调用这些方法，以确保子组件出现在组件本身的顶部。
重写paintComponet方法paint(g) ,一个回调方法，绝大多数时候组件的绘图逻辑都存储于这个方法中。awt系统会在适当的时候调用这个方法对组件进行绘图。容器在绘制的时候,容器的paint(g)方法默认会显示通知在容器中存在的所有visible为true的子组件进行绘制. awt调用这个方法有2种形式。程序驱动方式和系统驱动方式。 在系统驱动的情况下（比如界面第一次显示组件），系统会判断组件的显示区域，然后向事件分发线程发出调用paint(g)的命令. 程序驱动则由外部的程序调用repaint()方法提出一个异步请求.repaint方法会调用update(g)方法,update方法在默认情况下简单调用paint(g)方法.从而绘制组件. 一般不提倡将组件的具体绘制逻辑放到paint(g)之外,也不提倡程序直接调用paint(g)方法.需要注意的是,由于程序驱动方式是由程序来负责组件的绘制,所以repaint方法拥有几个重载方法.传入绘制区域,由程序决定组件的绘制区域. update(g)方法.在awt的重量级组件上,update是一个很重要的方法.在外部程序调用repaint的时候,都会调用到 update.程序员通过继承重量级组件,覆盖这个update方法.可以实现自己的绘图逻辑,典型的用法是重新绘制组件需要改变的的一部份而不是全部 (增量绘图).这样对于复杂的 组件绘制可以提高效率,不然在默认情况下,重量级组件的update将擦除组件的整个区域,并重新调用paint()方法从头绘制.不过轻量级组件不能采用这个方法.这是由于轻量级组件的本质造成的:
重量级组件和轻量级组件的区别,在于前者拥有一个本地同位体,绘制和现实逻辑都是依靠本地系统来完成.而轻量级组件不依赖于任何本地系统.只需要 一个重量级容器组件作为载体.在重量级组件的基础上,完全采用java的绘制代码(个人理解为graphics)来生成.所以轻量级组件在不显示的时候是透明的.甚至可以认为本组件不存在.由于轻量级组件没有采用任何本地系统代码来进行绘制,所以在需要绘制的情况下需要awt显式的通知,当这个通知来自于 轻量级组件(就是指组件尺寸改变)而非本地系统时(指组件第一次进行绘制),这个通知采用调用repaint方法的形式进行.换句话说,对于轻量级组件, 即使是系统级驱动绘图,也可能会调用repaint方法.而repaint方法将会调用update方法,update方法默认调用paint方法.所以 轻量级组件在系统驱动和程序驱动方式上的绘图并没有什么区别. 即使如此,也有办法对复杂的轻量级组件进行有效的增量绘图.复杂的轻量级组件都可以做成容器.可以根据一些内部信息,只绘制轻量级组件中某几个组件.典型做法是覆盖paint方法.
3.引文地址：百度空间
repaint,update和paint这三个方法在Component中定义,由于awt,swing组件都直接或间接继承自Component,所以几乎所有的awt,swing组件都有这三个方法.这三个方法主要是用于组件的界面绘制.这三个方法执行顺序repaint() - update() - paint()一般在程序中我们都会重装paint()方法以执行重绘画面的动作,但实际上除了paint()以后,update()也执行了一部分的工作,这部分工作包括用默认的背景颜色填充,设置前景色等,由于这部分一般都无须用户参考,所以一般都update()自动完成,然后update()再调用paint()执行用户自定义的绘制操作.一般情况不用重写update()方法。但是如果你填充背景的颜色跟paint（）中的颜色不一样的时候就会有闪烁感。可以重写update方法，事实上,在用双缓冲画图时,一般都会选择重装update()而不是paint()方法,由于在执行paint()方法之前,update()还执行填充背景的动作,所以当重绘的速度很大时,填充背景的动作将很明显,也即闪烁很大,也将,如果在paint()中用双缓冲的话实际上起不了效果.而如果用update()的话就可以双缓冲达到预期的效果.
当在程序中需要重绘操作时,我们一般会用repaint()而不是直接调用update()或者paint(),repaint()将调用update().而在各种awt,swing组件需要自动重新绘制时,程序也一般也会自动调用repaint()方法.
下列就是本人今天做了欢迎介面时遇到的种种困难和错误，希望放在这里能让大家引以为鉴，不要再犯这样的错误！ 1、不理解paint()方法、repaint()方法、update()方法的区别； 解决思路：paint()方法是由系统自动随机调用，而update()方法是我们自己人为调用，paint()方法必须要人为指定是什么时候让系统开始调用，但是首先在最开始的时候自己调用一次，所以不安全，我们一般使用update()方法，此方法必须用repaint()方法调用。我们调用paint()方法其实也是由repaint()方法调用update()方法（注：paint()方法在加图之前必须判断内存里面是否有图片）； 2、程序执行顺序问题：this.memoryImage()!= 解决思路：虚拟机是先加载属性文件； 3、路径错误； 解决思路：src是源文件，不要和它混在一起，我们要用到其它如图片和音乐的文件要放在一个文件夹下面，且此文件夹是和src同一级别； 4、找不到图片； 解决思路：图片都必须是在媒体跟踪器跟踪完之后才能加载，才能找到其的宽和高，不能在媒体跟踪器加载完之前调用图片的宽和高； 5、图片覆盖； 解决思路：图片在画进屏幕的时候要有一定的顺序问题，背景放在最下面，一层一层往上放，要不然会发生覆盖问题； 6、图片不能显示； 解决思路：我们的图片画在屏幕上但前题是我们要有一个窗体才能画，所以在将内存的图画进屏幕的时候必须将窗体可见性设出：setVisible(true); 7、未找到图片的问题判断： 解决思路：如果没有找到图片，那么那个图片点whith及点height打印出来都是-1;
关于上面提到的双缓冲问题，一个最好的解决办法就是重写 update 方法。
总结：三个方法的调用顺序是没有错的，然后，对于轻量级组件，一般是重写 paint 方法以快速的绘制组件，但是对于重量及组件，由于重新绘制时间长，容易产生闪烁的现象，所以一般是采用重写 update 方法，利用双缓冲图片来解决闪烁的问题。
&&&&推荐文章:
【上篇】【下篇】> 问题详情
下列方法与Applet显示无关的是（)A．paintB．updateC．repaint（)D．draw
悬赏：0&答案豆
提问人：匿名网友
发布时间：
下列方法与Applet显示无关的是 ()A．paintB．updateC．repaint()D．draw请帮忙给出正确答案和分析，谢谢！
为您推荐的考试题库
您可能感兴趣的试题
1关于Applet，下面的哪一条是错误的?&&(&&)A．Applet就是一个ApplicationB．Applet可以在浏览器中执行C．Application可以直接用Java解释器执行D．Applet也可以是一个Application2Java中，JDBC是指&&(&&)A．Java程序与数据库连接的一种机制B．Java程序与浏览器交互的一种机制C．Java类库名称D．Java类编译程序3Java虚拟机中的______模块既负责管理针对各种类型数据库软件的JDBC驱动程序，也负责和用户的应用程序交互，为Java应用程序建立起基于JDBC机制的数据库连接。&&&&(&&)A．JDBCConnection ManagerB．JDBCCommand ManagerC．JDBCDriver ManagerD．JDBCDatabase Manager
我有更好的答案
请先输入下方的验证码查看最佳答案
图形验证：
验证码提交中……
享三项特权
享三项特权
享三项特权
选择支付方式：
支付宝付款
郑重提醒：支付后，系统自动为您完成注册
请使用微信扫码支付(元)
支付后，系统自动为您完成注册
遇到问题请联系在线客服QQ：
请您不要关闭此页面,支付完成后点击支付完成按钮
遇到问题请联系在线客服QQ：
恭喜您！升级VIP会员成功
常用邮箱：
用于找回密码
确认密码：14268人阅读
JavaSE（25）
Java图形开发--GUI
1、图形用户界面(gui)介绍
图形用户界面(Graphics&User&Interface,GUI)是用户与程序交互的窗口，比命令行的界面更加直观并且更好操作。
awt,swing,swt,Jface是什么？
Sun已经提供了一个跨平台GUI开发工具包AWT抽象窗口工具箱(Abstract&Window&Toolkit).
Sun又创建了一个新的GUI框架swing.解决了AWT存在的Icd问题.
IBM认为swing比较消耗内存，创建了一个新的GUI库，这就是SWT
IBM为了方便开发SWT程序，在SWT基础上又创建了一个更易用，功能强大的图开包&JFace&
2、eclipse开发工具介绍
eclipse是什么东西，我们用三句话来说明：
1、eclipse最早是IBM附属公司oti开发的，一共投入了4000万美金，后来捐献给开源社区
2、eclipse是一个开源的、可扩展的集成开发环境，已经成为目前最流行的java开发工具
3、eclipse安装后就可以开发java&se的项目了，但不能开发java&ee项目，需要安装web开发插件(lomboz或是myeclipse..)
ide(集成开发环境，比如jcreator、vs、myeclipse这些开发工具都是ide)
3、swing组件介绍
1、JFrame是Frame的子类
2、属于容器类组件，顶层容器
3、JFrame有一些常用的方法，通过示例与java的帮助文档即可了解。
在图形用户界面编程中，我们在窗体中会经常使用到按钮，我们在进行选择的时候，常常需要确认，所以按钮很重要。
只需要在窗体中添加按钮组件(JButton)即可完成。
按钮组件--深入讨论
1、JButton是AbstractButton的子类
2、属于窗口类组件，可以加入别的组件
3、Swing包的按钮组件不只有JButton，还有单选按钮(JRadioButton)、箭头按钮(BasicArrowButton)、触发器按钮(JToggleButton)。
* 功能：GUI开发
package com.
import javax.swing.*;
import java.awt.*;
//JFrame是一个顶层容器类（可以添加其他swing组件的类）
public class Gui1 extends JFrame {
//需要的swing组件，定义到这里
JButton jb1 =
// 构造函数
public Gui1() {
// 创建了一个Button按钮
jb1 = new JButton(&按钮&);
// 添加组件
// 给窗体设置标题
setTitle(&hello,world!&);
// 设置大小，按像素计算
setSize(200, 200);
// 设置初始位置
setLocation(100, 200);
// 设置当窗口关闭时，保证JVM也退出
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
setVisible(true);
public static void main(String[] args) {
Gui1 gui1 = new Gui1();
4、三大常用布局管理器
布局管理器--介绍
&&&&组件在容器(比如JFrame)中的位置和大小是由布局管理器来决定的。所有的容器都会
使用一个布局管理器，通过它来自动进行组件的布局管理。
&&&&java共提供了五种布局管理器：流式布局管理器(FlowLayout)、边界布局管理器(BorderLayout)、网格布局管理器(GridLayout)、卡片布局管理器(CardLayout)、网格包布局管理器(GridBagLayout)。其中前三种是最常见的布局管理器。
边界布局BorderLayout--介绍
&&&&边界布局(BorderLayout)将容器简单的划分为东南西北5个区域，中间区域最大。
&&&&JFrame窗体，JDialog对话框组件默认布局方法
* 边界布局
package com.
import java.awt.*;
import javax.swing.*;
//1.继承JFrame
public class Gui2 extends JFrame{
//2.定义组件
JButton jb1, jb2, jb3, jb4, jb5;
public Gui2(){
//3.创建组件
jb1 = new JButton(&中部&);
jb2 = new JButton(&北部&);
jb3 = new JButton(&东部&);
jb4 = new JButton(&南部&);
jb5 = new JButton(&西部&);
//4.添加各个组件
add(jb1, BorderLayout.CENTER);
add(jb2, BorderLayout.NORTH);
add(jb3, BorderLayout.EAST);
add(jb4, BorderLayout.SOUTH);
add(jb5, BorderLayout.WEST);
//5.设置窗体属性
setTitle(&边界布局&);
setSize(300, 200);
setLocation(200, 200);
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
//6.显示窗体
setVisible(true);
public static void main(String[] args) {
Gui2 gui1 = new Gui2();
边界布局BorderLayout--注意事项
1、不是五个部分都必需添加；
2、中部组件会自动调节大小；
3、JFrame，JDialog默认布局管理器就是BorderLayout
流式布局FlowLayout--介绍
FlowLayout布局，按照组件的添加次序将按钮组件(当然也可以是别的组件)从左到右放置在容器中。当到达容器的边界时，组件将放置到下一行中。FlowLayout可以以左对齐、居中对齐、以右对齐的方式排列组件。
* 流式布局
package com.
import java.awt.*;
import javax.swing.*;
public class Gui3 extends JFrame{
//定义组件
JButton jb1, jb2, jb3, jb4, jb5, jb6;
//构造函数
public Gui3(){
//创建组件
jb1 = new JButton(&Button1&);
jb2 = new JButton(&Button2&);
jb3 = new JButton(&Button3&);
jb4 = new JButton(&Button4&);
jb5 = new JButton(&Button5&);
jb6 = new JButton(&Button6&);
//添加组件
//设置流式布局
setLayout(new FlowLayout(FlowLayout.RIGHT));
//设置窗体属性
setTitle(&流式布局&);
setSize(300, 200);
setLocation(200, 200);
//禁止用户改变窗体大小
setResizable(false);
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
setVisible(true);
public static void main(String[] args) {
Gui3 gui1 = new Gui3();
流式布局FlowLayout--注意事项
1、不限制他所管理的组件大小，允许他们有最佳大小
2、当容器被缩放、扩大时，组件的位置可能变化，但组件的大小不变。
3、默认组件是居中对齐，可以通过FlowLayout(int&align)函数来指定对齐方式。
网格布局GridLayout--介绍
GridLayout布局，听其名而知其意，它将容器分割成多行多列，组件被填充到每个网格中，添加到容器中的组件首先放置在左上角的网格中，然后从左到右放置其它的组件，当占满该行的所有网格后，接着继续在下一行从左到右放置组件。
* 网格布局
package com.
import java.awt.*;
import javax.swing.*;
public class Gui4 extends JFrame{
int size = 9;
//定义组件;
JButton[] jbs = new JButton[9];
public Gui4(){
//创建组件
for(int i = 0; i & i++){
jbs[i] = new JButton(&& + i);
//设置网格布局
setLayout(new GridLayout(3, 3, 5, 5));
//添加组件
for(int i = 0; i & i++){
add(jbs[i]);
//设置窗体属性
setTitle(&网格布局&);
setSize(300, 300);
setLocation(200,200);
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
setVisible(true);
public static void main(String[] args) {
Gui4 gui1 = new Gui4();
网格布局GridLayout--注意事项
1、组件的相对位置不随容器的缩放而变化，但大小会变化；
2、所有组件的大小相同；
3、可以通过GridLayout(int&rows,int&cols,int&hgap,int&vgap)来指定网格的行/列，水平间隙/垂直间隙。
参数说明：rows:行数/cols:列数/hgap:垂直间隙/vgap:水平间隙
3、开发GUI程序步骤
1、继承JFrame(类继承)
2、定义需要的组件(成员变量)
3、创建组件(构造函数中)
4、添加组件(构造方法中)
5、设置布局管理器(构造方法中)
6、显示窗体(构造函数中)
5、Swing组件--面板组件
面板组件(JPanel)--介绍
在图形用户界面编程中，如果只是普通的组件布局，我们用前面讲的三种布局管理器就可以解决，但在比较复杂的布局要求时，就需要使用布局管理器的组合使用。
JPanel：面板组件，非顶层容器，一个界面只可以有一个JFrame窗体组件，但可以有多个JPanel面板组件，而JPanel上也可以使用FlowLayout、BorderLayout、GirdLayout等各种布局管理器，这样可以组合使用达到较为复杂的布局效果。
* 多种布局管理器的使用
package com.
import java.awt.*;
import javax.swing.*;
public class Gui5 extends JFrame{
//定义组件
JPanel jp1, jp2;
JButton jb1, jb2, jb3, jb4, jb5, jb6;
//构造方法
public Gui5(){
//创建组件
//JPanel布局默认是FlowLayout
jp1 = new JPanel();
jp2 = new JPanel();
jb1 = new JButton(&Button1&);
jb2 = new JButton(&Button2&);
jb3 = new JButton(&Button3&);
jb4 = new JButton(&Button4&);
jb5 = new JButton(&Button5&);
jb6 = new JButton(&Button6&);
//添加JPanel
jp1.add(jb1);
jp1.add(jb2);
jp2.add(jb3);
jp2.add(jb4);
jp2.add(jb5);
//把JPanel加入JFrame
add(jp1, BorderLayout.NORTH);
add(jb6, BorderLayout.CENTER);
add(jp2, BorderLayout.SOUTH);
//设置窗体
setTitle(&多种布局管理器的使用&);
setSize(300, 300);
setLocation(200, 200);
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
setVisible(true);
public static void main(String args[]){
Gui5 gui1 = new Gui5();
面板(JPanel)组件--注意事项
1、JPanel是JComponent的子类；
2、属于容器类组件，可以加入别的组件；
3、默认布局管理器是流式布局(FlowLayout)
Swing组件--文本框/密码框/标签组件
在图形用户界面编程中，我们常常会提供用户登录界面，比如登录到会员管理系统，登录到工资管理系统、仓库管理系统等。这时候我们就会用到：
1、文本框(JTextField)
2、密码框(JPasswordField)
3、标签(JLable)
package com.
import java.awt.*;
import javax.swing.*;
public class Gui6 extends JFrame{
//定义组件
JPanel jp1, jp2, jp3;
JLabel jlb1, jlb2;
JButton jb1, jb2;
JPasswordF
//构造方法
public Gui6(){
//创建组件
jp1 = new JPanel();
jp2 = new JPanel();
jp3 = new JPanel();
jlb1 = new JLabel(&用户名：&);
jlb2 = new JLabel(&密
jb1 = new JButton(&登录&);
jb2 = new JButton(&取消&);
jtf = new JTextField(10);
jpf = new JPasswordField(10);
//设置布局管理器
setLayout(new GridLayout(3, 1));
//加入组件
jp1.add(jlb1);
jp1.add(jtf);
jp2.add(jlb2);
jp2.add(jpf);
jp3.add(jb1);
jp3.add(jb2);
//加入到JFrame
//设置窗体
setTitle(&登录界面&);
setSize(300, 150);
setLocation(500,500);
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
setVisible(true);
public static void main(String[] args) {
Gui6 gui1 = new Gui6();
Swing组件--复选框/单选框组件
在图形用户界面编程中，我们常常会提供用户注册界面，这时候我们就会用到：
1、复选框组件(JCheckBox)
2、单选框组件(JRadioBuutton)
特别说明：
&&&&同一组单选按钮必需先创建ButtonGroup，然后把单选框组件放入到ButtonGroup中
package com.
import java.awt.*;
import javax.swing.*;
public class Gui7 extends JFrame{
//定义组件
JPanel jp1, jp2, jp3;
JLabel jl1, jl2;
JButton jb1, jb2;
JCheckBox jcb1, jcb2, jcb3;
JRadioButton jrb1, jrb2;
//构造函数
public Gui7(){
//创建组件
jp1 = new JPanel();
jp2 = new JPanel();
jp3 = new JPanel();
jl1 = new JLabel(&你喜欢的运动：&);
jl2 = new JLabel(&你喜欢的运动：&);
jb1 = new JButton(&注册用户&);
jb2 = new JButton(&取消注册&);
jcb1 = new JCheckBox(&足球&);
jcb2 = new JCheckBox(&篮球&);
jcb3 = new JCheckBox(&网球&);
jrb1 = new JRadioButton(&男&);
jrb2 = new JRadioButton(&女&);
//单选组件一定要放入到一个ButtonGroup
//不放入的话，可以多选
bg = new ButtonGroup();
bg.add(jrb1);
bg.add(jrb2);
//设置布局管理器
setLayout(new GridLayout(3, 1));
//添加组件
jp1.add(jl1);
jp1.add(jcb1);
jp1.add(jcb2);
jp1.add(jcb3);
jp2.add(jl2);
jp2.add(jrb1);
jp2.add(jrb2);
jp3.add(jb1);
jp3.add(jb2);
//设置窗体
setTitle(&调查报告&);
setSize(300, 300);
setLocation(500, 500);
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
setVisible(true);
public static void main(String[] args) {
Gui7 gui1 = new Gui7();
Swing组件--下拉框/列表框/流动空格组件
在图形用户界面编程中，常常会提供用户调查界面，这个时候会用到：
1、下拉框组件(JComboBox)
2、列表框组件(JList)
3、滚动窗格组件(JScrollPane)
特别说明：
&&&&一般来说，列表框组件+滚动窗格组件是结合使用的。目的是让列表框中的选项可以有滚动条支持。
package com.
import java.awt.*;
import javax.swing.*;
public class Gui8 extends JFrame{
//定义组件
JPanel jp1, jp2;
JLabel jl1, jl2;
//构造方法
public Gui8(){
//创建组件
jp1 = new JPanel();
jp2 = new JPanel();
jl1 = new JLabel(&你的籍贯：&);
jl2 = new JLabel(&旅游地点：&);
String[] jg = {&北京&, &上海&, &天津&, &火星&};
jcb = new JComboBox(jg);
String[] dd = {&九寨沟&, &故宫&, &长城&, &天安门&};
jlist = new JList(dd);
//设置显示选项个数
jlist.setVisibleRowCount(2);
jsp = new JScrollPane(jlist);
//设置布局
setLayout(new GridLayout(3, 1));
//添加组件
jp1.add(jl1);
jp1.add(jcb);
jp2.add(jl2);
jp2.add(jsp);
//设置窗体
setTitle(&旅游&);
setSize(300, 300);
setLocation(500, 500);
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
setVisible(true);
public static void main(String[] args) {
Gui8 gui1 = new Gui8();
Swing组件--总结
1、Swing的常用组件(JFrame(框架)、Jpanel(面板)、JButton(按钮)、JLable(标签)、JTextField(文本框)、JPasswordField(密码框)、JCheckBox(复选框)、JRadioButton(单选框)、JComboBox(下拉框)、JScrollPane(滚动窗格)、JList(列表框))。
2、三大布局管理器(BorderLayout(边界布局)、FlowLayout(流布局)、GridLayout(网格布局))，要灵活使用，从而满足设计需求。
6、GUI编程实践
1、拆分窗格(JSplitPane)属于容器类组件
package com.
import java.awt.*;
import javax.swing.*;
public class Gui9 extends JFrame{
//定义组件
//构造方法
public Gui9(){
//创建组件
String[] words = {&boy&, &girl&, &bird&};
jlist = new JList(words);
jl = new JLabel(new ImageIcon(&images/image01.jpg&));
//拆分窗格
jsp = new JSplitPane(JSplitPane.HORIZONTAL_SPLIT, jlist, jl);
//可以变化
jsp.setOneTouchExpandable(true);
//添加组件
//设置窗体
setTitle(&分割&);
setSize(400, 300);
setLocation(500, 500);
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
setVisible(true);
public static void main(String[] args) {
Gui9 gui1 = new Gui9();
2、多行文本框(JTextArea)组件
package com.
import java.awt.*;
import javax.swing.*;
public class Gui10 extends JFrame{
//定义组件
JTextArea jta =
JPanel jp1 =
JComboBox jcb =
JTextField jtf =
JButton jb =
JScrollPane jsp =
//构造方法
public Gui10(){
jta = new JTextArea();
jsp = new JScrollPane(jta);
jp1 = new JPanel();
String[] chatter = {&张三&,&李四&};
jcb = new JComboBox(chatter);
jtf = new JTextField(10);
jb = new JButton(&发送&);
//添加组件
jp1.add(jcb);
jp1.add(jtf);
jp1.add(jb);
//加入JFrame
add(jp1, BorderLayout.SOUTH);
//设置窗体
setIconImage((new ImageIcon(&images/image01.jpg&)).getImage());
setTitle(&聊天&);
setSize(400, 300);
setLocation(500, 500);
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
setVisible(true);
public static void main(String[] args) {
Gui10 gui1 = new Gui10();
3、页签组件(JTabbedPane)选项卡窗格
package com.
import java.awt.*;
import javax.swing.*;
public class Gui11 extends JFrame{
//定义组件
JPanel jp1, jp2, jp3, jp4;
JLabel jl1, jl2, jl3, jl4, jl5;
JTextField jtf1;
JPasswordField jpf1;
JCheckBox jcb1, jcb2;
JButton jb1, jb2, jb3, jb4;
//构造函数
public Gui11(){
//创建组件
jp1 = new JPanel();
jp2 = new JPanel();
jp3 = new JPanel();
jp4 = new JPanel();
jl1 = new JLabel(new ImageIcon(&images/image01.jpg&));
jl2 = new JLabel(&账号&);
jl3 = new JLabel(&密码&);
jl4 = new JLabel(&忘记密码&);
jl4.setForeground(Color.BLUE);
jl5 = new JLabel(&&html&&a href='http://blog.csdn.net/q'&访问&/a&&);
jl5.setCursor(Cursor.getPredefinedCursor(Cursor.HAND_CURSOR));
jtf1 = new JTextField(10);
jpf1 = new JPasswordField(10);
jcb1 = new JCheckBox(&隐身登录&);
jcb2 = new JCheckBox(&记住密码&);
jb1 = new JButton(&清除号码&);
jb2 = new JButton(&登录&);
jb3 = new JButton(&注销&);
jb4 = new JButton(&注册&);
jtp = new JTabbedPane();
//设置布局
jp1.setLayout(new GridLayout(3, 3));
jp1.add(jl2);
jp1.add(jtf1);
jp1.add(jb1);
jp1.add(jl3);
jp1.add(jpf1);
jp1.add(jl4);
jp1.add(jcb1);
jp1.add(jcb2);
jp1.add(jl5);
jp2.setBackground(Color.RED);
jp3.setBackground(Color.BLUE);
jtp.add(&账号&, jp1);
jtp.add(&手机号码&, jp2);
jtp.add(&电子邮件&, jp3);
jp4.add(jb2);
jp4.add(jb3);
jp4.add(jb4);
//加入到JFrame
add(jl1, BorderLayout.NORTH);
add(jp4, BorderLayout.SOUTH);
//设置窗体
setTitle(&登录界面&);
setIconImage((new ImageIcon(&images/image02.jpg&)).getImage());
setSize(400, 300);
setLocation(500, 500);
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
setVisible(true);
public static void main(String[] args) {
Gui11 gui1 = new Gui11();
4、菜单组件（JMenuBar、JMenu、JMenuItem）工具条组件（JToolBar）
package com.
* 1、菜单组件
JMenuBar 菜单条组件 树干
菜单组件 树枝
JMenuItem 菜单项组件 树叶
2、二级菜单制作
JMenu里面可以嵌套JMenu
3、工具条组件
JToolBar 容器类组件
import java.awt.*;
import java.awt.event.InputE
import java.awt.event.InputMethodE
import java.awt.event.KeyE
import javax.swing.*;
public class Gui12 extends JFrame{
//文件组定义组件
JMenuB//菜单条组件
JMenu menu1,menu2,menu3,menu4,menu5;//主菜单：文件、编辑、格式、查看、帮助
JMenuItem item2,item3,item4,item5,item6,item7;//子菜单：新建、打开、保存、另存为、页面设置、打印、退出
JM//二级菜单
JMenuItem file,
//编辑组定义组件
//编辑：撤消、剪切、复制、粘贴、删除、查找、查找下一个、替换、转到、全选、时间/日期
JMenuItem eitem1,eitem2,eitem3,eitem4,eitem5,eitem6,eitem7,eitem8,eitem9,eitem10,eitem11;
//格式组定义组件
JMenuItem oitem1,oitem2;//格式：自动换行、字体
//查看组定义组件
JMenuItem vitem1;//查看：状态栏
//帮助组定义组件
JMenuItem hitem1,hitem2;//帮助：查看帮助、关于记事本
JButton jb1,jb2,jb3,jb4,jb5,jb6,jb7,jb8;
public static void main(String[] args) {
Gui12 win=new Gui12();
//构造函数
public Gui12(){
//构建组件
jtb=new JToolBar();
jb1=new JButton(new ImageIcon(&images/new.jpg&));
jb1.setToolTipText(&新建&);//设置提示信息
jb2=new JButton(new ImageIcon(&images/open.jpg&));
jb2.setToolTipText(&打开&);
jb3=new JButton(new ImageIcon(&images/save.jpg&));
jb3.setToolTipText(&保存&);
jb4=new JButton(new ImageIcon(&images/copy.jpg&));
jb4.setToolTipText(&复制&);
jb5=new JButton(new ImageIcon(&images/delete.jpg&));
jb5.setToolTipText(&删除&);
jb6=new JButton(new ImageIcon(&images/modify.jpg&));
jb6.setToolTipText(&编辑&);
jb7=new JButton(new ImageIcon(&images/print.jpg&));
jb7.setToolTipText(&打印&);
jb8=new JButton(new ImageIcon(&images/close.jpg&));
jb8.setToolTipText(&关闭&);
jmb=new JMenuBar();
menu1=new JMenu(&文件(F)&);
menu1.setMnemonic('F');//设置助记符
menu2=new JMenu(&编辑(E)&);
menu2.setMnemonic('E');
menu3=new JMenu(&格式(O)&);
menu3.setMnemonic('O');
menu4=new JMenu(&查看(V)&);
menu4.setMnemonic('V');
menu5=new JMenu(&帮助(H)&);
menu5.setMnemonic('H');
//文件--新建--子目录
xinjian=new JMenu(&新建&);
file=new JMenuItem(&文件&);
project=new JMenuItem(&工程&);
item2=new JMenuItem(&打开(O)&);
item2.setMnemonic('O');
item2.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_O,InputEvent.CTRL_MASK));//设置ctrl快捷组合键
item3=new JMenuItem(&保存(S)&);
item3.setMnemonic('S');
item3.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_S,InputEvent.CTRL_MASK));
item4=new JMenuItem(&另存为(A)&);
item4.setMnemonic('A');
item5=new JMenuItem(&页面设置(U)&);
item5.setMnemonic('U');
item6=new JMenuItem(&打印(P)&);
item6.setMnemonic('P');
item6.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_P,InputEvent.CTRL_MASK));
item7=new JMenuItem(&退出(X)&);
item7.setMnemonic('X');
eitem1=new JMenuItem(&撤消(U)&);
eitem1.setMnemonic('U');
eitem1.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_U,InputEvent.CTRL_MASK));
eitem2=new JMenuItem(&剪切(T)&);
eitem2.setMnemonic('T');
eitem2.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_T,InputEvent.CTRL_MASK));
eitem3=new JMenuItem(&复制(C)&);
eitem3.setMnemonic('C');
eitem3.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_C,InputEvent.CTRL_MASK));
eitem4=new JMenuItem(&粘贴(P)&);
eitem4.setMnemonic('P');
eitem4.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_P,InputEvent.CTRL_MASK));
eitem5=new JMenuItem(&删除(L)&);
eitem5.setMnemonic('L');
eitem5.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_DELETE,0));
eitem6=new JMenuItem(&查找(F)&);
eitem6.setMnemonic('F');
eitem6.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_F,InputEvent.CTRL_MASK));
eitem7=new JMenuItem(&查找下一个(N)&);
eitem7.setMnemonic('N');
eitem7.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_F3,0));
eitem8=new JMenuItem(&替换(R)&);
eitem8.setMnemonic('R');
eitem8.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_R,InputEvent.CTRL_MASK));
eitem9=new JMenuItem(&转到(G)&);
eitem9.setMnemonic('G');
eitem9.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_G,InputEvent.CTRL_MASK));
eitem10=new JMenuItem(&全选(A)&);
eitem10.setMnemonic('A');
eitem10.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_A,InputEvent.CTRL_MASK));
eitem11=new JMenuItem(&时间/日期(D)&);
eitem11.setMnemonic('D');
eitem11.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_F5,0));
oitem1=new JMenuItem(&自动换行(W)&);
oitem1.setMnemonic('W');
oitem2=new JMenuItem(&字体(F)&);
oitem2.setMnemonic('F');
vitem1=new JMenuItem(&状态栏(S)&);
vitem1.setMnemonic('S');
hitem1=new JMenuItem(&查看帮助(H)&);
hitem1.setMnemonic('H');
hitem2=new JMenuItem(&关于记事本(A)&);
hitem2.setMnemonic('A');
jta=new JTextArea();
//设定布局管理器
//加入组件
//将按钮添加到工具条上
jtb.add(jb1);
jtb.add(jb2);
jtb.add(jb3);
jtb.add(jb4);
jtb.add(jb5);
jtb.add(jb6);
jtb.add(jb7);
jtb.add(jb8);
//将菜单项添加到菜单上
xinjian.add(file);
xinjian.add(project);
menu1.add(xinjian);
menu1.add(item2);
menu1.add(item3);
menu1.add(item4);
menu1.addSeparator();//添加分割线
menu1.add(item5);
menu1.add(item6);
menu1.addSeparator();
menu1.add(item7);
menu2.add(eitem1);
menu2.addSeparator();
menu2.add(eitem2);
menu2.add(eitem3);
menu2.add(eitem4);
menu2.add(eitem5);
menu2.addSeparator();
menu2.add(eitem6);
menu2.add(eitem7);
menu2.add(eitem8);
menu2.add(eitem9);
menu2.addSeparator();
menu2.add(eitem10);
menu2.add(eitem11);
menu3.add(oitem1);
menu3.add(oitem2);
menu4.add(vitem1);
menu5.add(hitem1);
menu5.addSeparator();
menu5.add(hitem2);
//将菜单添加到菜单条上
jmb.add(menu1);
jmb.add(menu2);
jmb.add(menu3);
jmb.add(menu4);
jmb.add(menu5);
//将菜单条添加到窗体上
this.setJMenuBar(jmb);
//将工具条添加到窗体上
this.add(jtb,BorderLayout.NORTH);
JScrollPane jsp=new JScrollPane(jta);
jsp.setVerticalScrollBarPolicy(JScrollPane.VERTICAL_SCROLLBAR_ALWAYS);
this.add(jsp);
//窗体设置
this.setTitle(&Java记事本&);
this.setSize(500, 400);
this.setLocationRelativeTo(null);
this.setVisible(true);
this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
7、java绘图坐标体系
绘图坐标本系--介绍
坐标原点位于左上角，以像素为单位。像素是计算机屏幕上最小的显示单位。在java的坐标系中，第一个是X坐标，表示当前位置为水平方向，距离坐标原点X个像素；第二个是Y坐标，表示当前位置为垂直方向，距离坐标原点Y个像素。
坐标体系--像素
&&&& 计算机在屏幕上显示的内容都是由屏幕上的每一个像素组成的。例如，计算机显示器的分辨率是800×600，表示计算机屏幕上的每一行由800个点组成，共有600行，整个计算机屏幕共有480000个像素。现在的计算机可以支持更高的分辨率，也就是说，屏幕上可以显示更多的像素。因此，像素是一个密度单位，而厘米是长度单位，两者无法比较。
绘图原理(1)
Component类提供了两个和绘图相关最重要的方法：
1、paint(Graphics&g)绘制组件的外观
2、repaint()刷新组件的外观
当组件第一次在屏幕显示的时候，程序会自动的调用paint()方法来绘制组件
绘图原理(2)
在以下情况paint()将会被调用：
1、窗口最小化，再最大化
2、窗口的大小发生变化
3、repaint函数被调用
java绘图技术--Graphics
Graphics类
Graphics类你可以理解就是画笔，为我们提供了各种绘制图形的方法：
1、画直线&drawLine(int&x1,int&y1,int&x2,int&y2);
2、画矩形边框&drawRect(int&x,int&y,int&width,int&height);
3、画椭圆边框&drawOval(int&x,int&y,int&width,int&height);
4、填充矩形&fillRect(int&x,int&y,int&width,int&height);
5、填充椭圆&fillOval(int&x,int&y,int&width,int&height);
6、画图片&drawImage(Image&img.int&x,int&y,..);
7、画字符串&drawString(String&str,int&x,int&y);
8、设置画笔的字体&setFont(Font&font);
9、设置画笔的颜色&setColor(Color&c);
package com.
import java.awt.*;
import javax.swing.*;
public class Gui13 extends JFrame{
MyPanel mp =
public Gui13(){
mp = new MyPanel();
setSize(400, 300);
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
setVisible(true);
public static void main(String[] args) {
Gui13 gui1 = new Gui13();
//定义一个MyPanel,用于绘图和显示绘图的区域
class MyPanel extends JPanel{
//覆盖JPanel的paint方法
//Graphics是绘图的重要类，等价于画笔
public void paint(Graphics g){
//1.调用父类方法，完成初始化
super.paint(g);
//g.drawOval(10, 10, 30, 30);
//g.drawLine(10, 10, 40, 40);
//空心矩形
//g.drawRect(10, 10, 40, 60);
//填充矩形
g.setColor(Color.BLUE);
g.fillRect(10, 10, 40, 60);
g.setColor(Color.RED);
g.fillRect(70, 70, 40, 60);
//在面板上画出图片
Image im = Toolkit.getDefaultToolkit().getImage(Panel.class.getResource(&/images/image01.jpg&));
g.drawImage(im, 10, 10, 200, 150, this);
g.setColor(Color.red);
g.setFont(new Font((&隶书&), Font.BOLD, 30));
g.drawString(&String 字符串&, 100, 100);
//圆的轮廓
g.drawArc(100, 100, 100, 100, 20, 300);
8、java事件处理机制
java事件处理机制--初步介绍
java事件处理是采取“委派事件模型”。所谓“委派事件模型”是指当事件发生时，产生事件的对象(即事件源)，会把此“信息”传递给“事件的监听者”处理的一种方式，而这里所说的“信息”实际上就是java.awt.event事件类库里某个类所创建的对象，我们暂时把它称为“事件的对象”。
& & 比如：当按下按钮时，就会在按钮触发一个“事件”，程序就会产生一个“事件对象”来表示这个事件，并把这个“事件对象”传递给“事件的监听者”，“事件的监听者”再根据“事件对象”的类型进行相应处理。
为了让“产生事件的对象”[比如按钮]知道要把事件传递给哪一个“事件监听者”，我们必需先把“事件监听者”在“产生事件的对象”注册，这个操作也就是要告知“产生事件的对象”要把事件传递给它。
* 功能：事件处理机制
package com.
import java.awt.*;
import javax.swing.*;
import java.awt.event.*;
public class Gui14 extends JFrame implements ActionListener{
//定义组件
Panel mp =
JButton jb1, jb2;
public Gui14(){
mp = new Panel();
//设置背景颜色
mp.setBackground(Color.black);
jb1 = new JButton(&黑色&);
jb2 = new JButton(&红色&);
add(jb1, BorderLayout.NORTH);
add(jb2, BorderLayout.SOUTH);
//注册监听
jb1.addActionListener(this);
jb2.addActionListener(this);
//事件源是jb1,jb2,事件监听者是gui14的对象
//指定action命令
jb1.setActionCommand(&黑色&);
jb2.setActionCommand(&红色&);
//设置窗体
setSize(300, 200);
setLocation(500, 500);
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
setVisible(true);
public static void main(String[] args) {
Gui14 gui1 = new Gui14();
//对事件处理的方法
public void actionPerformed(ActionEvent e) {
//判断是哪个按钮被点击
if(e.getActionCommand().equals(&黑色&)){
//System.out.println(&黑色&);
mp.setBackground(Color.black);
} else if(e.getActionCommand().equals(&红色&)){
//System.out.println(&红色&);
mp.setBackground(Color.red);
class MyPanel2 extends JPanel{
public void paint(Graphics g){
* 1.通过上下左右键来控制一个小球的移动
package com.
import java.awt.*;
import javax.swing.*;
import java.awt.event.*;
public class Gui15 extends JFrame{
//定义组件
MyPanel3 mp =
public Gui15(){
mp = new MyPanel3();
//mp加入JFrame
//添加监听
addKeyListener(mp);
//设置窗体
setTitle(&小球&);
setSize(400, 300);
setLocationRelativeTo(null);
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
setVisible(true);
public static void main(String[] args) {
Gui15 gui1 = new Gui15();
//定义自己的面板
class MyPanel3 extends JPanel implements KeyListener{
private int x = 10;
private int y = 10;
public void paint(Graphics g){
super.paint(g);
g.fillOval(x, y, 20, 20);
//输入的一个具体信息
public void keyTyped(KeyEvent e) {
// TODO Auto-generated method stub
//System.out.println(&typed&);
public void keyPressed(KeyEvent e) {
// TODO Auto-generated method stub
//System.out.println(&press&);
//向下 向上 向左 向右
if(e.getKeyCode() == KeyEvent.VK_DOWN){
} else if(e.getKeyCode() == KeyEvent.VK_UP){
} else if(e.getKeyCode() == KeyEvent.VK_LEFT){
} else if(e.getKeyCode() == KeyEvent.VK_RIGHT){
//调用repaint()方法，重绘面板
repaint();
public void keyReleased(KeyEvent e) {
// TODO Auto-generated method stub
//System.out.println(&released& + (char)e.getKeyCode());
java事件处理机制--深入理解
&&&& 事件源是一个产生(或触发)事件的对象，比如前面的JButton的一个对象jb1。当这个事件源对象的某些状态以某种方式发生变化时，就会产生某种类型的事件(一个事件源可能会生成多个不同类型的事件)。如果某个组件(对象)希望得到事件源产生的事件，就需要在这个事件源上注册。
事件就是承载事件源状态改变时的信息对象。或者说，事件是事件源事件监听器传输事件源状态信息的载体。在用户与GUI组件进行交互时就会生成事件，比如当鼠标在面板中移动时，就会生成一个鼠标移动事件的对象，而这个对象保存着当前鼠标在面板中位置信息。java.awt.event包和javax.swing.event包中定义了各种事件类型，常见的事件类有：
ActionEvent
通常在按下按钮，或双击一个列表项或选中某个菜单时发生
AdjustmentEvnet
当操作一个滚动条时发生
ComponentEvent
当一个组件隐藏、移动、改变大小时发送
ContainerEvent
当一个组件从容器中加入或者删除时发生
FocusEvent
当一个组件获得或是失去焦点时发生
当一个复选框或是列表项被选中时，当一个选择框或选择菜单被选中
当从键盘的按键被按下，松开时发生
MouseEvent
当鼠标被拖动、移动、点击、按下..
当文本区和文本域的文本发生改变时发生
WindowEvent
当一个窗口激活、关闭、失效、恢复、最小化...
3、事件监听器接口
&&&& 事件源产生一个事件，可以传送给事件监听者处理，那么怎样才能编写一个事件监听者呢？
&&&& 事件监听者实际上就是一个类，该类实现了某个事件监听器接口、比如前面我们案例中的MyPanel就是一个类，它实现了ActionListener接口，它就可以作为一个事件监听者，对接受到的事件进行处理。
&&&& 事件监听器接口有多种，不同的事件监听器接口可以监听不同的事件，一个类可以实现一个事件监听接口，也可以实现多个监听接口，这些接口在java.awt.event和javax.swing.event包中定义。
package com.
import java.awt.*;
import javax.swing.*;
import java.awt.event.*;
public class Gui16 extends JFrame{
//定义组件
MyPanel4 mp =
//构造方法
public Gui16(){
mp = new MyPanel4();
//mp加入JFrame
//注册监听
addMouseListener(mp);
addKeyListener(mp);
addMouseMotionListener(mp);
//设置窗体
setSize(400, 300);
setLocationRelativeTo(null);
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
setVisible(true);
public static void main(String[] args) {
Gui16 gui1 = new Gui16();
//1 鼠标按下输出坐标，移出，移入，按下，释放
//2.按键按下对应字符
//3.鼠标移动、拖拽
//4.窗口变化(关闭，最小化，最大化)
//定义自己的面板
class MyPanel4 extends JPanel implements MouseListener, KeyListener, MouseMotionListener, WindowListener{
public void paint(Graphics g){
super.paint(g);
//鼠标点击
public void mouseClicked(MouseEvent e) {
// TODO Auto-generated method stub
System.out.println(&鼠标点击了 x = & + e.getX() + & y = & + e.getY());
//鼠标按下
public void mousePressed(MouseEvent e) {
// TODO Auto-generated method stub
System.out.println(&鼠标按下&);
//鼠标松开
public void mouseReleased(MouseEvent e) {
// TODO Auto-generated method stub
System.out.println(&鼠标松开&);
//鼠标移动到MyPanel4
public void mouseEntered(MouseEvent e) {
// TODO Auto-generated method stub
System.out.println(&鼠标移出&);
//鼠标移出MyPanel4
public void mouseExited(MouseEvent e) {
// TODO Auto-generated method stub
System.out.println(&鼠标进入&);
//鼠标拖拽
public void mouseDragged(MouseEvent e) {
// TODO Auto-generated method stub
//鼠标移动
public void mouseMoved(MouseEvent e) {
// TODO Auto-generated method stub
System.out.println(&鼠标当前坐标x = & + e.getX() + & Y = & + e.getY());
//输入具体信息
public void keyTyped(KeyEvent e) {
// TODO Auto-generated method stub
public void keyPressed(KeyEvent e) {
// TODO Auto-generated method stub
System.out.println(e.getKeyChar() + &键被按下&);
public void keyReleased(KeyEvent e) {
// TODO Auto-generated method stub
//窗口打开
public void windowOpened(WindowEvent e) {
// TODO Auto-generated method stub
//窗口正在关闭
public void windowClosing(WindowEvent e) {
// TODO Auto-generated method stub
//窗口关闭
public void windowClosed(WindowEvent e) {
// TODO Auto-generated method stub
//窗口最小化
public void windowIconified(WindowEvent e) {
// TODO Auto-generated method stub
//窗口最小化到显示
public void windowDeiconified(WindowEvent e) {
// TODO Auto-generated method stub
//窗口被激活了
public void windowActivated(WindowEvent e) {
// TODO Auto-generated method stub
//窗口变成非激活窗口
public void windowDeactivated(WindowEvent e) {
// TODO Auto-generated method stub
java事件处理机制--总结
总结--事件编程步骤：
1、编写事件处理类(事件监听者)
2、根据需求给事件处理类实现监听器接口
3、在事件处理中重写(实现)其事件处理的函数
4、在事件源类中指定该事件的监听器(响应者)是谁
注意事项：
1、java采用委托机制处理事件
2、java中的事件是分类的，比如对窗体事件、鼠标事件、按键事件、操作事件[按按钮]
3、java中一个类要监听某个事件，则必需实现相应的事件监听接口
4、事件监听接口有多种，程序员应当针对不同的情况，实现不同的监听接口，比如监听鼠标事件就应当实现MouseL要监听键盘事件，就应当实现KeyListener..
5、在实现监听接口的类(事件监听类/者)中，需要重写处理函数，比如实现了ActionListener接口，就应当重写actionPerformed(ActionEvent&e),可以参考前面的事件监听器接口表格
6、在事件源中需要注册事件监听类。否则事件监听类接收不到事件源发生的事件。
一个类要实现监听的步骤：
a、实现相应的接口[KeyListener/MouseListener/ActionListener/WindowListener]
b、把接口的处理方法根据需要重新编写(Override)
c、在事件源上注册监听
d、事件传递是靠事件(类)对象
----------参考《韩顺平.循序渐进学.java.从入门到精通》
----------参考《JDK_API_1_6_zh_CN》
Java学习笔记--导航
&&相关文章推荐
参考知识库
* 以上用户言论只代表其个人观点，不代表CSDN网站的观点或立场
访问：690888次
积分：10370
积分：10370
排名：第1466名
原创：408篇
评论：131条
PS:请注明理由
文章：17篇
阅读：97650
阅读：8932
阅读：5580
文章：14篇
阅读：19368
文章：14篇
阅读：184052
文章：12篇
阅读：24519
(4)(24)(4)(12)(8)(7)(12)(16)(7)(43)(34)(17)(57)(16)(12)(12)(46)(16)(31)(14)(4)(12)(10)