⑴ java中repaint()方法到底应该怎么用
java里repaint()是重绘component的方法；
repaint()方法用于重绘组件，该方法有下面四种形式：
1。public void repaint()
2。public void repaint(long tm)
//指定调用update方法之前等待的最大毫秒数tm
3。public void repaint(int x,int y,int width,int height)
//重绘组件的指定矩形区域
4。public void repaint(ling tm,int x,int y,int width,int height)
repaint方法不总是马上执行，Java虽然会尽可能快的执行repaint,当Applet运行在较慢的平台上或计算机较忙时，应该考虑使用第2或4种repaint方法，指定在多长时间内必须执行repaint，否则就放弃。
repaint()这个方法是一个具有刷新页面效果的方法，如果你要页面进行重画就可以调用．一般都是在AWT的图形绘制当中调用的到．那么该方法具体的工作原来是怎么样的呢？看下面的结构流程图你就可以大概的了解了：
repaint()方法
|
|
V
AWT线程－－－>paint()方法－－>图形绘制
|
|
V
update()方法－－－>paint()方法－－图形绘制
从上面的流程图可以看出，在绘制动画图形时候如果没有调用repaint()方法的时候直接就是由线程调用paint()方法进行绘制，用repaint()进行刷新显示．但是这样的动画会有个缺点(这样的效果绘制出来会有闪烁)．想想做出来的动画总是隔一段时间就闪烁，有人会看吗？那么应该怎么去除闪烁呢？我再下面的文章中会讲到．这里主要的是说明repaint()这个方法．
在调用了repaint()的时候我门可以看出，它并不是直接就去绘制动画（调用paint()）,而是通过调用AWT线程在由线程去调用另一个方法update()再由update()调用画笔paint()方法进行绘制．那么这里为什么要多做一步呢？这样是不是为我门多增加代码的书写量呢？回答是当然不会，如果你不调用repaint()那么就不能实现每一次的刷新显示，就只会绘制重叠的图形，不能一张一张的绘制出来．那么其中调用的update()到底是起到什么样的作用呢？
update()：清除当前显示并调用paint()方法．当然这个update()方法是可以被修改的，我门在另一篇文章关于"双缓冲技术"中会给大家讲到这点．
综合上面的介绍可以总结出repaint()的工作原理：repaint()通过调用线程再由线程去调用update()方法清除当前显示并再调用paint()方法进行绘制下一个需要显示的内容．这样就起到了一种图片的交替显示从而在视角上形成了动画．
⑵ 怎么用双缓冲解决java中关于Applet程序让图片动起来后如何解决屏闪
package yb_8_115;
import java.awt.Frame;
import java.awt.Graphics;
import java.awt.Image;
import java.awt.Toolkit;
import java.awt.event.KeyAdapter;
import java.awt.event.KeyEvent;
import java.awt.event.KeyListener;
import java.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;
public class JSG extends Frame {
// 定义游戏关数0代表开始1代表第一关。。。
int state = 0;
// 定义全局变量用于拿到图片系统路径
// 得到默认工具包
Toolkit tk = Toolkit.getDefaultToolkit();
// 通过工具包拿到图片
Image start = tk.getImage(
// 拿路径
JSG.class.getResource("/image/start.png"));
Image bj2 = tk.getImage(JSG.class.getResource("/image/bj_2.png"));
Image dyg = tk.getImage(JSG.class.getResource("/image/lesson_1.png"));
Image heart = tk.getImage(JSG.class.getResource("/image/heart.png"));
Image songshu = tk.getImage(JSG.class.getResource("/image/songshu.png"));
public void init() {
new MusicFor("/music/tsg.mp3").musicplay();
new myThread().start();// 启动线程
this.setSize(800, 600);
// 窗口大小
this.setVisible(true);
// 可见性
this.setLocationRelativeTo(null);
// 居中
this.setResizable(false);
// 禁用最大化
this.setTitle("松鼠快跑");
// 标题设置
this.addWindowListener(new WindowAdapter() {
@Override public void windowClosing(WindowEvent e) {
System.exit(0);
// 退出系统
}
});
this.addKeyListener(new KeyAdapter() {
@Override
public void keyPressed(KeyEvent e) {
// e.getKeyCode获得键盘的按键 KeyEvent.VK_ENTER java定义的回车标识符
if (state == 0 && e.getKeyCode() == KeyEvent.VK_ENTER) {
state = 1;
}
}
});
}
@Override public void paint(Graphics g) {
if (state == 0) {
System.out.println("开始");// 打印开始界面
g.drawImage(start, 0, 0, getWidth(), getHeight(), this);
} else if (state == 1) {
System.out.println("第一关");// 打印第一关背景
g.drawImage(bj2, 0, 0, getWidth(), getHeight(), this);
g.drawImage(dyg, 328, 20, 145,51 , this);
g.drawImage(heart, 50, 520, 40,40 , this);
g.drawImage(heart, 90, 520, 40,40 , this);
g.drawImage(heart, 130, 520, 40,40 , this);
g.drawImage(songshu, 400, 450, 98,119 , this);
this.addKeyListener(new KeyAdapter() {
public void keyPressed(KeyEvent e) {
if(e.getKeyCode()==KeyEvent.VK_S);{
g.
}
}
});
}
}
/**
* @param args
*/
public static void main(String[] args) {
// 实例化一个对象mainframe对象
JSG jsg = new JSG();
jsg.init();
}
class myThread extends Thread {
public void run() {
while (true) {
repaint();// 重绘方法 ，这个方法会自动调用paint方法
}
}
}
// 双缓冲技术
@Override
public void update(Graphics g) {
//创建和窗体一样大小的图片
Image temp=createImage(getWidth(),getHeight());
//拿到缓冲图片的画笔
Graphics gh=temp.getGraphics();
//将图片加入窗体
print(gh);
//吧缓冲区的图片画到窗体上
g.drawImage(temp, 0, 0, this);
}
}
//其实很简单就是把缓冲区的图片画到窗体的最上面
⑶ 关于java中利用BufferedImage的双缓冲技术
双缓冲就是先在内存中的另一张“画布”上进行多次绘图，然后把画好的图在一次性画到屏幕上，也就是最后一步的g.drawimage。简单的说，一个graphics对应着自己的绘图区域图形上下文
⑷ java中使用了双缓冲技术后，黑色字体变成白色，怎么样才能改回黑色！
我也遇到了相同的问题，根据你给出的代码，可以在第2、3行中间加上一句代码：
g1.setColor(Color.BLACK);
也就是先把字体主动设置为黑色。
就应该OK了，我就是这么弄的。
⑸ java 双缓冲，消除闪烁 的问题
[转]双缓冲在画板程序中的应用
1.用双缓冲解决画板程序中的刷新问题
我们用Java编制画板程序的时候,总是存在一个刷新的问题:当Canvas所在的窗口最小化或者被其他应用程序遮挡后,再次恢复,Canvas上的图形
数据将被部分或者完全擦除掉.
通常解决这个问题的方法是在Canvas的paint()函数中重绘图形,但是由于在绘图的过程中产生了大量的数据,重新在Canvas上绘制这些数据将导
致大量的系统开销,还会产生闪烁,故该方法可行但并不可取.
利用双缓冲技术可以很好的解决这个问题,其主要原理是开辟两个图形缓冲区,一个是前台的显示缓冲(也就是Canvas),一个是后台的图形缓冲(
通常是Image）.用户在绘制图形时,我们对这两个缓冲区进行同步更新,相当于为前台的数据作了一个后台备份.当前台的图形被遮盖需要恢复的
时候,我们就可以用这个后台备份来恢复,具体方法是重写paint()函数,将备份好的图像一次性的画到屏幕上去.
为什么是paint()?这里需要先了解一下有关Java处理AWT绘图的基础知识:Java的显示更新是由一个AWT线程来控制完成的.该线程主要负责两种
与显示更新相关的情况.第一种情况称为曝光,表示部分显示区域毁坏或需要清除.这种情况发生时,系统直接调用paint()方法;第二种情况是程
序决定重画显示区域,添加一些新的内容,此时需要程序调用成员的repaint()方法,repaint()方法调用成员的update(),update()再调用paint()
方法.显然我们所说的就是第一种.只要Canvas组件所在的窗口最小化或者被其他应用程序遮挡住,系统就会调用paint()对画布进行重绘.如果我
们在paint()方法中什么都不做,就只能眼睁睁的看着辛辛苦苦画的线条一旦被覆盖就再也看不见了.
作为起点,请先看一个最简单的画板程序,请注意,以下程序使用的是j2sdk1.4.1版本,在Win98的IE下(不是Tencent Explorer)全部测试通过:
//:WBApplet.java
import java.applet.*;
public class WBApplet extends Applet{
final static int DEFAULT_BOARDWIDTH=700;
final static int DEFAULT_BOARDHEIGHT=400;
public void init(){
super.init();
setLayout(null);
whiteBoard = new WhiteBoard(this);
whiteBoard.reshape(0,0,DEFAULT_BOARDWIDTH,DEFAULT_BOARDHEIGHT);
add(whiteBoard);
}
WhiteBoard whiteBoard;
}
///:~
//:WhiteBoard.java
java.awt.*;
import java.awt.event.*;
public class WhiteBoard extends Canvas implements MouseMotionListener,MouseListener{
final static int DEFAULT_BOARDWIDTH=700;
final static int DEFAULT_BOARDHEIGHT=400;
int x0,y0,x1,y1;
WhiteBoard(WBApplet WBApplet1){
parent = WBApplet1;
addMouseMotionListener(this);
addMouseListener(this);
}
synchronized public void update_buffer(Graphics g,DrawItem data) {
g.drawLine(data.x0,data.y0,data.x1,data.y1);
}
public void mouseReleased(MouseEvent e){}
public void mouseEntered(MouseEvent e){}
public void mouseExited(MouseEvent e){}
public void mouseClicked(MouseEvent e){}
public void mouseMoved(MouseEvent e){}
public void mouseDragged(MouseEvent e){
x1=e.getX();
y1=e.getY();
Graphics g = getGraphics();
update_buffer(g,new DrawItem(x0,y0,x1,y1));
g.dispose();
x0=x1;
y0=y1;
}
public void mousePressed(MouseEvent e){
x0 =e.getX();
y0 =e.getY();
}
WBApplet parent;
}
class DrawItem{
DrawItem(int x0,int y0,int x1,int y1){
this.x0=x0;
this.y0=y0;
this.x1=x1;
this.y1=y1;
}
int x0;
int y0;
int x1;
int y1;
}
///:~
我们将白板需完成的所有逻辑操作封装在了一个WhiteBoard类中,以方便主程序的Applet调用.同时,定义了一个绘图的数据类DrawItem,用来封
装图形数据.绘图的操作都写在update_buffer中.显然,这个程序无法实现刷新后的恢复,我们需要使用双缓冲技术.
为了实现双缓冲,首先定义图形缓冲区如下
private Image off_screen_buf;
private Graphics off_screen_gc;
并在WhiteBoard类的构造函数中对其进行初始化
off_screen_buf =parent.createImage(DEFAULT_BOARDWIDTH,DEFAULT_BOARDHEIGHT);
off_screen_gc = off_screen_buf.getGraphics();
在处理用户绘制图形的函数中,我们使用update_buffer对显示缓冲和图形缓冲同时进行更新
Graphics g = getGraphics();
update_buffer(g,new DrawItem(x0,y0,x1,y1));//前台更新画布
update_buffer(off_screen_gc,new DrawItem(x0,y0,x1,y1));//后台更新缓冲
g.dispose();
显然,后台的更新操作是不可视的,所以是off-screen.
最后,重写paint()方法,调用_from_offscreen_buf(g)将图形缓冲区的图像画到屏幕上去.
public void paint(Graphics g){
_from_offscreen_buf(g);
}
void _from_offscreen_buf(Graphics g){
if(g != null)
g.drawImage(off_screen_buf, 0, 0, null);
}
就是这么简单的几行代码,就可以让我们完全的避免图形不能恢复的问题.下面是WhiteBoard经改进后的完整代码.
//:WhiteBoard.java
import java.awt.*;
import java.awt.event.*;
public class WhiteBoard extends Canvas implements MouseMotionListener,MouseListener{
final static int DEFAULT_BOARDWIDTH=700;
final static int DEFAULT_BOARDHEIGHT=400;
int x0,y0,x1,y1;
WhiteBoard(WBApplet WBApplet1){
parent = WBApplet1;
off_screen_buf =parent.createImage(DEFAULT_BOARDWIDTH,DEFAULT_BOARDHEIGHT);
off_screen_gc = off_screen_buf.getGraphics();
addMouseMotionListener(this);
addMouseListener(this);
}
synchronized public void update_buffer(Graphics g,DrawItem data) {
g.drawLine(data.x0,data.y0,data.x1,data.y1);
}
public void mouseMoved(MouseEvent e){}
public void mouseReleased(MouseEvent e){}
public void mouseEntered(MouseEvent e){}
public void mouseExited(MouseEvent e){}
public void mouseClicked(MouseEvent e){}
public void mouseDragged(MouseEvent e){
x1=e.getX();
y1=e.getY();
Graphics g = getGraphics();
update_buffer(g,new DrawItem(x0,y0,x1,y1));
update_buffer(off_screen_gc,new DrawItem(x0,y0,x1,y1));
g.dispose();
x0=x1;
y0=y1;
}
public void mousePressed(MouseEvent e){
x0 =e.getX();
y0 =e.getY();
}
public void paint(Graphics g){
_from_offscreen_buf(g);//把这句话屏蔽掉,就不能恢复用户绘制的图形了
}
void _from_offscreen_buf(Graphics g){
if(g != null)
g.drawImage(off_screen_buf, 0, 0, null);
}
private Image off_screen_buf;
private Graphics off_screen_gc;
WBApplet parent;
}
class DrawItem{
DrawItem(int x0,int y0,int x1,int y1){
this.x0=x0;
this.y0=y0;
this.x1=x1;
this.y1=y1;
}
int x0;
int y0;
int x1;
int y1;
}
///:~
运行一下,看是不是不一样了.这一次你想让你画的东西消失都不可能了.为了将这个原理说清楚,以上的代码我都没有编写的太复杂,下一次我们
会创建更加复杂,更加完善的画板程序.
2.用双缓冲实现各种图形的绘制
在一个画板程序中,用户应该能够用画笔绘制各种图形,除了上一节实现的自由画法(Freehand)外,还应该可以画直线,长方体,椭圆等等.以绘制
直线为例,我们都知道,只有在松开鼠标键之后,直线才实实在在的显示在了画布上,而在拖拽鼠标的过程中,直线在画布中的显示是随着鼠标的箭
头方位的变化而不断更新的.体现在程序中,这是一个不断擦除,显示,再擦除,再显示的过程.擦除的是箭头上一个点和起点间的直线,显示的是箭
头当前点和起点间的的直线.这个显示的过程由update_buffer负责,而这个擦除的工作则和上一节出理刷新一样,由_from_offscreen_buf来
完成.实际上,所谓擦除,也就是将画板恢复到某一个原来的时刻.
这一个过程在下面一个修改后的拖拽操作的处理程序中完成:
public void mouseDragged(MouseEvent e){
Graphics g = getGraphics();
_from_offscreen_buf(g);
x1=e.getX();
y1=e.getY();
update_buffer(g,new DrawItem(x0,y0,x1,y1));
g.dispose();
}
注意,在该方法中,我们没有对后台缓冲进行更新,这是因为鼠标在拖拽的时候,虽然画板上会显示线条,但是这条直线并没有真正的画下去.那么
在什么时候应该对后台缓冲更新呢?显然,是在鼠标松开的时候.我们需要在mouseReleased方法中做这个工作.
public void mouseReleased(MouseEvent e){
Graphics g = getGraphics();
_from_offscreen_buf(g);
x1=e.getX();
y1=e.getY();
update_buffer(g,new DrawItem(x0,y0,x1,y1));
update_buffer(off_screen_gc,new DrawItem(x0,y0,x1,y1));
g.dispose();
}
可以看到,只有在鼠标松开的时候,画到画板上的直线才最后确定了,我们才能够将这一条线备份到缓冲区里面去.
下面是升级后的完整的WhiteBoard.java程序.
//:WhiteBoard.java
import java.awt.*;
import java.awt.event.*;
public class WhiteBoard extends Canvas implements MouseMotionListener,MouseListener{
final static int DEFAULT_BOARDWIDTH=700;
final static int DEFAULT_BOARDHEIGHT=400;
int x0,y0,x1,y1;
WhiteBoard(WBApplet WBApplet1){
parent = WBApplet1;
off_screen_buf =parent.createImage(DEFAULT_BOARDWIDTH,DEFAULT_BOARDHEIGHT);
off_screen_gc = off_screen_buf.getGraphics();
addMouseMotionListener(this);
addMouseListener(this);
draw_mode=2;
}
synchronized public void update_buffer(Graphics g,DrawItem data) {
g.drawLine(data.x0,data.y0,data.x1,data.y1);
}
public void mouseMoved(MouseEvent e){}
public void mouseReleased(MouseEvent e){
switch(draw_mode){
case 2:
Graphics g = getGraphics();
_from_offscreen_buf(g);
x1=e.getX();
y1=e.getY();
update_buffer(g,new DrawItem(x0,y0,x1,y1));
update_buffer(off_screen_gc,new DrawItem(x0,y0,x1,y1));
g.dispose();
}
}
public void mouseEntered(MouseEvent e){}
public void mouseExited(MouseEvent e){}
public void mouseClicked(MouseEvent e){}
public void mouseDragged(MouseEvent e){
switch(draw_mode){
case 1:
x1=e.getX();
y1=e.getY();
Graphics g = getGraphics();
update_buffer(g,new DrawItem(x0,y0,x1,y1));
update_buffer(off_screen_gc,new DrawItem(x0,y0,x1,y1));
g.dispose();
x0=x1;
y0=y1;
break;
case 2:
Graphics g1 = getGraphics();
_from_offscreen_buf(g1);
x1=e.getX();
y1=e.getY();
update_buffer(g1,new DrawItem(x0,y0,x1,y1));
g1.dispose();
}
}
public void mousePressed(MouseEvent e){
x0 =e.getX();
y0 =e.getY();
}
public void paint(Graphics g){
_from_offscreen_buf(g);
}
void _from_offscreen_buf(Graphics g){
if(g != null)
g.drawImage(off_screen_buf, 0, 0, null);
}
private int draw_mode;
private Image off_screen_buf;
private Graphics off_screen_gc;
WBApplet parent;
}
class DrawItem{
DrawItem(int x0,int y0,int x1,int y1){
this.x0=x0;
this.y0=y0;
this.x1=x1;
this.y1=y1;
}
int x0;
int y0;
int x1;
int y1;
}
///:~
注意到,在这个程序里面我们创建了一个新的私有变量draw_mode,用来存储绘图模式的代号.在这里,我们使用1来代表自由绘画,2来代表画直线.
在构造函数中为draw_mode定义初值可以使我们对不同种类图形绘制的调试很方便,在上面的程序中,我们定义的是2,如果赋值为1,则又回到自由
绘画的模式.事实上,我们应该在这样的一个框架上把程序不断的扩充和完善.
⑹ 什么是双缓冲双缓冲技术的出现是基于怎样的编程思想
双缓冲是先将显示图形放在缓冲区，再一起显示到屏幕上，以防止屏幕上的东西一个个出现或是发生闪烁。
双缓冲是基于“空间换时间”和“功能分块”的思想。
下面的文章详细介绍了双缓冲，虽然他讲的是C++，但原理和java的是完全一样的。
⑺ g如何用双缓冲解决java swing图像移动闪烁
双缓存：缓存区是绘图绘图时使用的屏外内存区。使用双缓存不是直接绘制屏幕，而是绘制到后缓存区，然后将整个缓存区复制到屏幕上，这样就可以同时更新整个屏幕，游戏者只看到要看到的东西了。后缓存区可能只是普通java图像。可以用Component类的createImage(int w,int h)方法生成后缓存区，如果是不使用活动绘制的小程序使用双缓存，则可以覆盖update（）方法，改用双缓存，并用双缓存的图形描述表调用paint（）方法，实现代码如下：
private Image doubleBuffer;
public void update(Graphics g){
Dimension size=getSize();
if(doubleBuffer.getWidth(this)!=size.width||doubleBuffer.getHeight(this)!=size.height)
{ doubleBuffer=createImage(size.width,size.height);
}
if(doubleBuffer!=null){
//绘制到双缓存区
Graphics g2=doubleBuffer.getGraphics();
paint(g2);
g2.dispose();
//将双缓存复制到屏幕
g.drawImage(doubleBuffer,0,0,null);
}
else
{//不要双缓存，只绘制屏幕
paint(g);
}
}
public void paint(Graphics g){
//在此绘图
}
⑻ java中的双缓冲
paint (offScreen)；
分好改成英文的
画面重画 offScreenImage 是保存在内存中原来的画 画中有个圆
圆的移动是通过 画面重画实现的 所以先把原来offScreenImage画出来 再在这个之上画一个圆
paint (offScreen)； 这句画就是把offScreenImage重新画上去
注释掉后 刚打开 你在一个窗口画圆 然后保存在内存 再重新出现一个窗口 但不画offScreen 窗口当然就是空白的了
能明白不
⑼ 关于java Applet 双缓冲技术显示图片的疑问
1, Graphics2D 相比Graphics功能更强大，以后用这个功能强大。所以是向后兼容；
BufferImage 就是缓冲图片，作用就是缓冲。先把图形绘制到BufferImage，然后把整张图片BufferImage直接显示出来。好比在食堂吃饭的时候，BufferImage相当于一个大托盘，这个大托盘里面装了几十碗（碟）小菜， 小二上菜的时候直接把这个大托盘一次端到客人桌子上就好了，只跑一次，效率高，速度快啊。BufferImage就起一个缓冲作用。
2、BufferGraphics 只是把图形绘制到 BufferImage 这张图片里，但这张图片只是在内存里，并没有显示出来。
g.drawImage(BufferImage,0,0,this) 这一句才把整张图片显示出来（店小二才把掌托盘菜端上桌），不调用就不显示图片（没有端出来，装满菜的托盘还在厨房呢，客人当然没菜吃！）。
BufferImage 最开始确实为空，但是applet在显示之前会先做初始化，也就是会执行init()方法。很显然init()方法里调用了createImage(***)这个方法来初始化BufferImage。后面显示出来的时候BufferImage当然就不为空了。
明白了吧！！！
⑽ java 双缓冲问题
应该把双缓冲放在update方法里面的
调用情况是repaint() -> update(Graphics g) -> paint(Graphics g)
具体方法如下
public void update(Graphics g){
Graphics bufferg;
if(bufferPage==null){
buffer=createImage(350,350);
}
bufferg=bufferPage.getGraphics();
Color c = bufferg.getColor();
bufferg.setColor(getBackground());
bufferg.fillRect(0,0, this.getSize().width, this.getSize().height);
bufferg.drawImage(img, x,y,this);
paint(bufferg);
g.drawImage(bufferPage,0,0,this);
bufferg.setColor(c);
}
public void paint(Graphics g){
g.drawImage(img,0,0,this);
}