作者：未知 来源：月光软件站 加入时间：2005-2-28　月光软件站

       动画实际上就是一系列连续的帧，当他们变换的足够快的时候，我们人的眼睛就会觉得他是运动的。所以如果我们能够周期性的切换画面，从第一帧到第二帧到第三帧 ......那么我们就可以制作出动画的效果了。Timer和TimerTask正好可以很好的帮我们完成这一功能，如果你还不熟悉这两个类可以参考使用Java中的Timer和TimerTask。我们首先扩展TimerTask实现AnimatedImage类，它的功能就是在特定位置画图

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

// Defines an animated image, which is just a set
// of images of equal size which are drawn in turn
// to simulate movement.

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);
    }
}

我们需要预先在jar文件里面存储几个大小一样，形态有序的图片，在MIDlet启动的时候把它装载在一个Image数组，并把它作为参数传递给AnimatedImage。
private Image[] loadFrames( String name, int frames )
                                  throws IOException {
    Image[] images = new Image[frames];
    for( int i = 0; i < frames; ++i ){
 images[i] = Image.createImage( name + i +
            ".png" );
    }

    return images;
}

Image[] frames = loadFrames( "/images/bird", 7 );
AnimatedImage ai = new AnimatedImage( frames );
ai.move( 20, 20 ); // set top-left to 20,20

下面是两个测试效果的AnimatedCanvas和AnimationTest类的源代码，在这里你可以得到全部的源文件和图片资源。仔细读读这几个类是很有好处的。有一点值得一提的是，在绘制图片的时候应该判断设备是否支持双缓冲，如果不支持要使用双缓冲技术避免画面闪烁。而且我们也不适宜把动画图片作的过大，这样会增大jar文件的大小，同时会给设备造成很大的负担。

    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[i] = 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[i] = Image.createImage(name + i + ".png");
        }

        return images;
    }

    protected void pauseApp()
    {
    }

    protected void startApp() throws MIDletStateChangeException
    {
        if (display == null)
        {
            display = Display.getDisplay(this);
            initMIDlet();
        }
    }
}


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);
        }
    }
}

相关软件：