<H4>Förbättrad variant</H4>
Det är inte så intelligent att "hårdkoda" bildernas namn och antal i programmet.
Det skulle vara mycket bättre att
kunna ange bildernas namn när programmet körs.
Nedan kommer en variant på ImageBlaster klassen som kan
få angivet vilka bilder som skall användas.
<h4>Skapa en ny klass:</h4>
När du har ImageBlaster.java öppen i editorn så väljer du File, Save As, och ger den namnet
ImageBlaster2.java. Den borde dyka upp i samma projekt som den tidigare filen.
Modifiera även Page1.htm filen. Du kan gärna sätta till en applet till på samma sida. Koden
för att få in ImageBlaster2 finns nedan. 
<h4>Page1.htm</h4>
<pre>
<applet
 code=ImageBlaster2.class
 name=ImageBlaster2
 width=200
 height=100>
 <param name="imagecount" value="5">
 <param name="basename" value="images/anim">
 <param name="filetype" value="jpg">
 <param name="background" value="images/background.gif">
 <param name="delay" value="1000">
</applet>
</pre>
<h4>ImageBlaster2.java</h4>
<PRE>
import java.applet.Applet;
import java.awt.*;

//--------------------------------------------------------------
public class ImageBlaster2 extends Applet
 implements Runnable // för att få ett flertrådigt program

{
 // ----------------------------------------------------------
 // ett antal variabler
 // för enkelhetens skull ger vi dem samma startvärden som i 
 // i föregåennde ImageBlaster
 String basename = "images/anim";
 String filetype = "jpg";
 String background = "images/background.gif";
 int delay = 1000;
 int imagecount = 5;
 // ----------------------------------------------------------

 // MediaTrackern kan hålla reda på om alla bilder är laddade 
 MediaTracker tracker;

 // bakgrundsbilden
 Image bg;

 // en array med (för tillfället ) okänt antal Images
 // OBS! Ändrad.
 // ----------------------------------------------------------
 Image anim[] ;
 // ----------------------------------------------------------

 // nuvarande bild
 int index;

 // en separat tråd
 Thread animator;

 // hämta bilden för bakgrunden (id = 0)
 // och de fem bilderna som skall animeras (id == 1) 
 // och lägg in dem i MediaTrackern så att vi vet 
 // när de är laddade
 // init är fortfarande startpunkten för Appletten
 public void init()
 {
 // skapa en MediaTracker som skall meddela oss 
 // när bilderna är laddade
 tracker = new MediaTracker(this);

 // ----------------------------------------------------------
 String param; // en sträng att läsa in parametrar i 
 // kolla om det fanns en rad med 
 // <param name="basename" value="... i applet taggen
 param = this.getParameter("basename");
 // om det fanns så sätter vi det värdet in i variabeln basename
 if ( param.length() > 0 )
 basename = param;

 // sedan kollar vi på motsvarande sätt de övriga parametrarna
 param = this.getParameter("filetype");
 if ( param.length() > 0 )
 filetype = param;

 param = this.getParameter("background");
 if ( param.length() > 0 )
 background = param;

 param = this.getParameter("imagecount");
 if ( param.length() > 0 )
 imagecount = Integer.parseInt(param); // siffra

 param = this.getParameter("delay");
 if ( param.length() > 0 )
 delay = Integer.parseInt(param); // siffra 

 // nu vet vi hur många bilder vi skall ha
 anim = new Image[imagecount];
 // ----------------------------------------------------------

 // ----------------------------------------------------------
 // delvis ändrad
 // dels använder vi background variabeln
 // dels så har jag satt dit en kompletterande kod som gör att bilden
 // alltid fyller ut hela appleten - oavsett dess storlek
 bg = getImage( getDocumentBase(),
 background ).getScaledInstance(
 this.getSize().width,
 this.getSize().height,
 Image.SCALE_SMOOTH );
 // ----------------------------------------------------------
 // eftersom bilden inte laddas ommeddelbart så
 // säger vi åt vår MediaTracker att den skall meddela oss 
 // när den finns tillgänglig
 tracker.addImage( bg, 0 );

 // hämta resten av bilderna som antas finnas i en images katalog
 // ----------------------------------------------------------
 // observera att 5:an är ändrad till imagecount i loopen
 for ( int i = 0; i < imagecount; i++ )
 // ----------------------------------------------------------
 {
 // ----------------------------------------------------------
 // delvis ändrad
 // dels använder vi basename och filetype variablerna
 // dels så har jag satt dit en kompletterande kod som gör att 
 // bilderna alltid fyller ut nästan hela appleten - oavsett 
 // dess storlek
 anim[i] = getImage( getDocumentBase(),
 basename + i + "." + filetype ).getScaledInstance(
 this.getSize().width-20,
 this.getSize().height-20,
 Image.SCALE_SMOOTH );
 // ----------------------------------------------------------
 // säg åt MediaTrackern at den skall meddela oss när 
 // bilderna är tillgängliga
 tracker.addImage( anim[i], 1 );
 }
 }

 // start behövs om man har implements Runnable
 // dvs om man har ett flertrådigt program
 public void start()
 {
 // skap en till tråd och sätt den i animator objektet
 animator = new Thread(this);
 // starta denna tråd
 animator.start();
 }

 // stop behövs om man har implements Runnable
 public void stop()
 {
 // stopp tråden
 animator.stop();
 // och döda den
 animator = null;
 }
 // Kör animeringstråden
 // men vänta först på att alla bilder är laddade
 public void run()
 {
 // felhanteringen i Java fungerar med try - catch systemet
 // som i C++
 // vi försöker således vänta på att bakgrunden är laddad
 // för att sedan vänta på att de övriga bilderna blivit
 // laddade
 try {
 tracker.waitForID(0);
 tracker.waitForID(1);
 }
 // någonting har gått fel - avbryt körningen
 catch (InterruptedException e)
 {
 return;
 }
 // Kolla vilken tråd vi kör
 // och sätt undan denna i en Thread 
 Thread me = Thread.currentThread();

 // så länge som den körda tråden är animerings tråden
 // kommer att snurra på så länge som Appleten är igång
 while (animator == me)
 {
 // försök stoppa tråden ett antal millisekunder
 try {
 // ---------------------------------------------
 // delvis ändrad
 Thread.sleep( delay );
 // ---------------------------------------------
 }
 // om det inte gick så avbryter vi loopen
 catch (InterruptedException e)
 {
 break;
 }

 // vi skall öka på index för vilken bild som skall visas
 // För att undvika att någon annan del av programmet
 // försöker göra någonting åt index variabeln så 
 // använder vi ordet synchronized, som betyder att 
 // denna kod måste bli färdig innan någon annan tråd eller
 // del av programmet får röra index variabeln
 synchronized (this)
 {
 index++;
 if (index >= anim.length)
 {
 // om vi har den sista bilden så tar vi som nästa
 // den första
 index = 0;
 }
 }
 // rita om Appletten
 repaint();
 }
 }

 // vid uppdatering så ritar vi om allt
 public void update(Graphics g)
 {
 paint(g);
 }
 // Rita en röd bakgrund om bilderna inte kunde hämtas
 // I annat fall så ritar vi dit bakgrundsbilden
 public void paint(Graphics g)
 {
 // har någonting gått fel vid bildhämtningen?
 if ((tracker.statusAll(false) & MediaTracker.ERRORED) != 0)
 {
 // röd färg över hela bakgrunden
 g.setColor(Color.red);
 g.fillRect(0, 0, getSize().width, getSize().height);
 // och bort härifrån
 return;
 }
 // kom vi hit borde vi ha en bakgrundsbild som vi 
 // då kan rita ut
 g.drawImage(bg, 0, 0, this);

 // har vi hunnit ladda alla andra bilder?
 if (tracker.statusID(1, false) == MediaTracker.COMPLETE)
 {
 // om så är fallet så kan vi rita ut den som 
 // är aktuell. Om index är 1 kommer således
 // anim1.gif att ritas
 g.drawImage(anim[index], 10, 10, this);
 }
 }
}
</PRE>