import java.util.*; 
import javax.microedition.lcdui.*; 
// 定义了一个动画，该动画其实只是一系列相同大小的图片 
// 轮流显示，然后模拟出的动画 
public class animatedimage extends timertask {; 
private canvas canvas; 
private image[] images; 
private int[][] cliplist; 
private int current; 
private int x; 
private int y; 
private int w; 
private int h; 

// construct an animation with no canvas. 

public animatedimage( image[] images ){; 
this( null, images, null ); 
}; 

// construct an animation with a null clip list. 

public animatedimage( canvas canvas, image[] 
images ){; this( canvas, images, null ); 
}; 

// construct an animation. the canvas can be null, 
// but if not null then a repaint will be triggered 
// on it each time the image changes due to a timer 
// event. if a clip list is specified, the image is 
// drawn multiple times, each time with a different 
// clip rectangle, to simulate transparent parts. 

public animatedimage( canvas canvas, image[] images, 
int[][] cliplist ){; 
this.canvas = canvas; 
this.images = images; 
this.cliplist = cliplist; 

if( images != null && cliplist != null ){; 
if( cliplist.length < images.length ){; 
throw new illegalargumentexception(); 
}; 
}; 

if( images != null && images.length > 0 ){; 
w = images[0].getwidth(); 
h = images[0].getheight(); 
}; 
}; 

// move to the next frame, wrapping if necessary. 

public void advance( boolean repaint ){; 
if( ++current >= images.length ){; 
current = 0; 
}; 

if( repaint && canvas != null && canvas.isshown() 
){; 
canvas.repaint( x, y, w, h ); 
canvas.servicerepaints(); 
}; 
}; 

// draw the current image in the animation. if 
// no clip list, just a simple copy, otherwise 
// set the clipping rectangle accordingly and 
// draw the image multiple times. 

public void draw( graphics g ){; 
if( w == 0 || h == 0 ) return; 

int which = current; 

if( cliplist == null || cliplist[which] == null 
){; 
g.drawimage( images[which], x, y, 
g.top | g.left ); 
}; else {; 
int cx = g.getclipx(); 
int cy = g.getclipy(); 
int cw = g.getclipwidth(); 
int ch = g.getclipheight(); 

int[] list = cliplist[which]; 

for( int i = 0; i + 3 <= list.length; i += 
4 ){; 
g.setclip( x + list[0], y + list[1], 
list[2], list[3] ); 
g.drawimage( images[which], x, y, 
g.top | g.left ); 
}; 

g.setclip( cx, cy, cw, ch ); 
}; 
}; 

// moves the animation's top left corner. 

public void move( int x, int y ){; 
this.x = x; 
this.y = y; 
}; 

// invoked by the timer. advances to the next frame 
// and causes a repaint if a canvas is specified. 

public void run(){; 
if( w == 0 || h == 0 ) return; 

advance( true ); 
}; 
};

private image[] loadframes( string name, int frames ) 
throws ioexception {; 
image[] images = new image[frames]; 
for( int i = 0; i < frames; ++i ){; 
images = image.createimage( name + i + 
".png" ); 
}; 

return images; 
};

timer timer = new timer(); 
animatedimage ai = ..... // get the image 
timer.schedule( ai, 200, 200 );

import java.util.*; 
import javax.microedition.lcdui.*; 

// a canvas to which you can attach one or more 
// animated images. when the canvas is painted, 
// it cycles through the animated images and asks 
// them to paint their current image. 

public class animatedcanvas extends canvas {; 
private display display; 
private image offscreen; 
private vector images = new vector(); 

public animatedcanvas( display display ){; 
this.display = display; 

// if the canvas is not double buffered by the 
// system, do it ourselves... 

if( !isdoublebuffered() ){; 
offscreen = image.createimage( getwidth(), 
getheight() ); 
}; 
}; 

// add an animated image to the list. 

public void add( animatedimage image ){; 
images.addelement( image ); 
}; 

// paint the canvas by erasing the screen and then 
// painting each animated image in turn. double 
// buffering is used to reduce flicker. 

protected void paint( graphics g ){; 
graphics saved = g; 

if( offscreen != null ){; 
g = offscreen.getgraphics(); 
}; 

g.setcolor( 255, 255, 255 ); 
g.fillrect( 0, 0, getwidth(), getheight() ); 

int n = images.size(); 
for( int i = 0; i < n; ++i ){; 
animatedimage img = (animatedimage) 
images.elementat( i ); 
img.draw( g ); 
}; 

if( g != saved ){; 
saved.drawimage( offscreen, 0, 0, 
graphics.left | graphics.top ); 
}; 
}; 
};

import java.io.*; 
import java.util.*; 
import javax.microedition.lcdui.*; 
import javax.microedition.midlet.*; 

// midlet that displays some simple animations. 
// displays a series of birds on the screen and 
// animates them at different (random) rates. 

public class animationtest extends midlet 
implements commandlistener {; 

private static final int bird_frames = 7; 
private static final int num_birds = 5; 

private display display; 
private timer timer = new timer(); 
private animatedimage[] birds; 
private random random = new random(); 

public static final command exitcommand = 
new command( "exit", 
command.exit, 1 ); 

public animationtest(){; 
}; 

public void commandaction( command c, 
displayable d ){; 
if( c == exitcommand ){; 
exitmidlet(); 
}; 
}; 

protected void destroyapp( boolean unconditional ) 
throws midletstatechangeexception {; 
exitmidlet(); 
}; 

public void exitmidlet(){; 
timer.cancel(); // turn it off... 
notifydestroyed(); 
}; 

// generate a non-negative random number... 

private int genrandom( int upper ){; 
return( math.abs( random.nextint() ) % upper ); 
}; 

public display getdisplay(){; return display; }; 

// initialize things by creating the canvas and then 
// creating a series of birds that are moved to 
// random locations on the canvas and attached to 
// a timer for scheduling. 

protected void initmidlet(){; 
try {; 
animatedcanvas c = new 
animatedcanvas( getdisplay() ); 
image[] images = 
loadframes( "/images/bird", 
bird_frames ); 

int w = c.getwidth(); 
int h = c.getheight(); 

birds = new animatedimage[ num_birds ]; 
for( int i = 0; i < num_birds; ++i ){; 
animatedimage b = new 
animatedimage( c, images ); 
birds = b; 
b.move( genrandom( w ), genrandom( h ) ); 
c.add( b ); 
timer.schedule( b, genrandom( 1000 ), 
genrandom( 400 ) ); 
}; 

c.addcommand( exitcommand ); 
c.setcommandlistener( this ); 

getdisplay().setcurrent( c ); 
}; 
catch( ioexception e ){; 
system.out.println( "could not 
load images" ); 
exitmidlet(); 
}; 
}; 

// load the bird animation, which is stored as a 
// series of png files in the midlet suite. 

private image[] loadframes( string name, int frames ) 
throws ioexception {; 
image[] images = new image[frames]; 
for( int i = 0; i < frames; ++i ){; 
images = image.createimage( name + 
i + ".png" ); 
}; 

return images; 
}; 

protected void pauseapp(){; 
}; 

protected void startapp() 
throws midletstatechangeexception {; 
if( display == null ){; 
display = display.getdisplay( this ); 
initmidlet(); 
}; 
}; 
};